U md@sdZddlmZmZmZddlmZddlZddlm Z zddl Z e j Z Wn(e efk rrddlm Z dZ YnXe dd d d gZd d ddddddddddddddddddd d!d"d#d$d%d&d'gZdd)dZd*d+Ze e je je je je je jd,e je je je jd-d.d/Ze e je je je je je jd0e je je jd1dd2dZd3Zd4Ze je je e je je je jd5d6d7Ze je je e je je jd8d9d:Zd;dZ e e je je je je je je je je jd<e je je je je je je je jd=d>dZ!d?dZ"e e je je je je jd@e je je je jdAdBdZ#dCdZ$dDd Z%e e je je je je je jd0e je je je je je jdEdFd Z&dGdZ'dHdZ(dIdZ)dJdZ*dKdZ+dLdZ,e je je je je je je je je jdMdNdZ-e e je je je je je je je je je jdOe je je je je jdPdQdZ.dRdSZ/dTdUZ0e je je je je je je je je je je je je je jdV dWdXZ1ddYlm2Z2m3Z3m4Z4m5Z5e2fdZdZ6d[dZ7d\d]Z8d^d_Z9e je je je je je je je je je jd`dadbZ:dcddZ;dedfZdkdZ?dld Z@e e je je je je je je jdme je je je jdndod!ZAdpd#ZBdqdrZCdsdtZDdud$ZEdvdwZFdxdyZGdzd%ZHd{d|ZId}d~ZJdddZKdd&ZLdd'ZMddZNddZOePdkrddlQZQddlRZReQSeRTjUdS)zNfontTools.misc.bezierTools.py -- tools for working with Bezier path segments. ) calcBoundssectRectrectArea)IdentityN) namedtuple)cythonF Intersectionptt1t2approximateCubicArcLengthapproximateCubicArcLengthCapproximateQuadraticArcLengthapproximateQuadraticArcLengthCcalcCubicArcLengthcalcCubicArcLengthCcalcQuadraticArcLengthcalcQuadraticArcLengthCcalcCubicBoundscalcQuadraticBounds splitLinesplitQuadratic splitCubicsplitQuadraticAtT splitCubicAtTsplitCubicAtTCsplitCubicIntoTwoAtTCsolveQuadratic solveCubicquadraticPointAtT cubicPointAtTcubicPointAtTC linePointAtTsegmentPointAtTlineLineIntersectionscurveLineIntersectionscurveCurveIntersectionssegmentSegmentIntersections{Gzt?cCs tt|t|t|t||S)aCalculates the arc length for a cubic Bezier segment. Whereas :func:`approximateCubicArcLength` approximates the length, this function calculates it by "measuring", recursively dividing the curve until the divided segments are shorter than ``tolerance``. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. tolerance: Controls the precision of the calcuation. Returns: Arc length value. )rcomplex)pt1pt2pt3pt4 tolerancer/S/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/fontTools/misc/bezierTools.pyr8scCs\|d|||d}||||d}|||d|||f|||||d|ffS)Ng??r/)p0p1p2p3midZderiv3r/r/r0_split_cubic_into_twoKs r8)r3r4r5r6)multarchboxc Cszt||}t||t||t||}|||krH||dSt||||\}}t|f|t|f|SdSNr2)absr8_calcCubicArcLengthCRecurse) r9r3r4r5r6r:r;onetwor/r/r0r>Ts $  r>r*r+r,r-)r.r9cCsdd|}t|||||S)zCalculates the arc length for a cubic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. tolerance: Controls the precision of the calcuation. Returns: Arc length value. ?g?)r>)r*r+r,r-r.r9r/r/r0rhs g|=v1v2cCs||jSN) conjugaterealrDr/r/r0_dotsrJxcCs(|t|dddt|dS)N)mathsqrtasinhrKr/r/r0 _intSecAtansrRcCstt|t|t|S)aCalculates the arc length for a quadratic Bezier segment. Args: pt1: Start point of the Bezier as 2D tuple. pt2: Handle point of the Bezier as 2D tuple. pt3: End point of the Bezier as 2D tuple. Returns: Arc length value. Example:: >>> calcQuadraticArcLength((0, 0), (0, 0), (0, 0)) # empty segment 0.0 >>> calcQuadraticArcLength((0, 0), (50, 0), (80, 0)) # collinear points 80.0 >>> calcQuadraticArcLength((0, 0), (0, 50), (0, 80)) # collinear points vertical 80.0 >>> calcQuadraticArcLength((0, 0), (50, 20), (100, 40)) # collinear points 107.70329614269008 >>> calcQuadraticArcLength((0, 0), (0, 100), (100, 0)) 154.02976155645263 >>> calcQuadraticArcLength((0, 0), (0, 50), (100, 0)) 120.21581243984076 >>> calcQuadraticArcLength((0, 0), (50, -10), (80, 50)) 102.53273816445825 >>> calcQuadraticArcLength((0, 0), (40, 0), (-40, 0)) # collinear points, control point outside 66.66666666666667 >>> calcQuadraticArcLength((0, 0), (40, 0), (0, 0)) # collinear points, looping back 40.0 )rr)r*r+r,r/r/r0rs )r*r+r,d0d1dn)scaleorigDistabx0x1LencCs||}||}||}|d}t|}|dkr>> calcQuadraticBounds((0, 0), (50, 100), (100, 0)) (0, 0, 100, 50.0) >>> calcQuadraticBounds((0, 0), (100, 0), (100, 100)) (0.0, 0.0, 100, 100) @rcsTg|]L}d|krdkrnq||||||fqSrrNr/.0taxaybxbycxcyr/r0 Ds  z'calcQuadraticBounds..)calcQuadraticParametersappendr)r*r+r,Zax2Zay2rootspointsr/rhr0r*scCstt|t|t|t|S)aApproximates the arc length for a cubic Bezier segment. Uses Gauss-Lobatto quadrature with n=5 points to approximate arc length. See :func:`calcCubicArcLength` for a slower but more accurate result. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. Returns: Arc length value. Example:: >>> approximateCubicArcLength((0, 0), (25, 100), (75, 100), (100, 0)) 190.04332968932817 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 50), (100, 100)) 154.8852074945903 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (150, 0)) # line; exact result should be 150. 149.99999999999991 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (-50, 0)) # cusp; exact result should be 150. 136.9267662156362 >>> approximateCubicArcLength((0, 0), (50, 0), (100, -50), (-50, 0)) # cusp 154.80848416537057 )r r)rAr/r/r0r Ls )rarErFv3v4c Cst||d}td|d|d|d|}t||||d}td|d|d|d|}t||d}|||||S) zApproximates the arc length for a cubic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. Returns: Arc length value. g333333?gc1g85$t?gu|Y?g#$?g?g#$gc1?rb) r*r+r,r-rarErFrtrur/r/r0r js,c st||||\\\\\d}d}d}d}ddt||D}ddt||D} || } fdd| D||g} t| S)aXCalculates the bounding rectangle for a quadratic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. Returns: A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``. Example:: >>> calcCubicBounds((0, 0), (25, 100), (75, 100), (100, 0)) (0, 0, 100, 75.0) >>> calcCubicBounds((0, 0), (50, 0), (100, 50), (100, 100)) (0.0, 0.0, 100, 100) >>> print("%f %f %f %f" % calcCubicBounds((50, 0), (0, 100), (100, 100), (50, 0))) 35.566243 0.000000 64.433757 75.000000 @rccSs(g|] }d|krdkrnq|qSrdr/rer/r/r0ros  z#calcCubicBounds..cSs(g|] }d|krdkrnq|qSrdr/rer/r/r0ros  cs\g|]T}||||||||||||fqSr/r/rerirjrkrlrmrndxdyr/r0ros&&)calcCubicParametersrr) r*r+r,r-Zax3Zay3Zbx2Zby2ZxRootsZyRootsrrrsr/rwr0rs&cCs|\}}|\}}||}||} |} |} || f|} | dkrF||fgS|| | f|| } d| krndkrnn(|| | | | | f}||f||fgS||fgSdS)a Split a line at a given coordinate. Args: pt1: Start point of line as 2D tuple. pt2: End point of line as 2D tuple. where: Position at which to split the line. isHorizontal: Direction of the ray splitting the line. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two line segments (each line segment being two 2D tuples) if the line was successfully split, or a list containing the original line. Example:: >>> printSegments(splitLine((0, 0), (100, 100), 50, True)) ((0, 0), (50, 50)) ((50, 50), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 100, True)) ((0, 0), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 0, True)) ((0, 0), (0, 0)) ((0, 0), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 0, False)) ((0, 0), (0, 0)) ((0, 0), (100, 100)) >>> printSegments(splitLine((100, 0), (0, 0), 50, False)) ((100, 0), (50, 0)) ((50, 0), (0, 0)) >>> printSegments(splitLine((0, 100), (0, 0), 50, True)) ((0, 100), (0, 50)) ((0, 50), (0, 0)) rrNNr/)r*r+where isHorizontalZpt1xZpt1yZpt2xZpt2yrirjrkrlrZrgZmidPtr/r/r0rs$  c Csbt|||\}}}t|||||||}tdd|D}|sP|||fgSt|||f|S)aSplit a quadratic Bezier curve at a given coordinate. Args: pt1,pt2,pt3: Control points of the Bezier as 2D tuples. where: Position at which to split the curve. isHorizontal: Direction of the ray splitting the curve. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two curve segments (each curve segment being three 2D tuples) if the curve was successfully split, or a list containing the original curve. Example:: >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 150, False)) ((0, 0), (50, 100), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, False)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, False)) ((0, 0), (12.5, 25), (25, 37.5)) ((25, 37.5), (62.5, 75), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, True)) ((0, 0), (7.32233, 14.6447), (14.6447, 25)) ((14.6447, 25), (50, 75), (85.3553, 25)) ((85.3553, 25), (92.6777, 14.6447), (100, -7.10543e-15)) >>> # XXX I'm not at all sure if the following behavior is desirable: >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, True)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (50, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) css*|]"}d|krdkrnq|VqdSrrNNr/rer/r/r0 "s  z!splitQuadratic..)rprsorted_splitQuadraticAtT) r*r+r,r{r|rZr[c solutionsr/r/r0rs#  c Cspt||||\}}}} t||||||| ||} tdd| D} | s\||||fgSt|||| f| S)aSplit a cubic Bezier curve at a given coordinate. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. where: Position at which to split the curve. isHorizontal: Direction of the ray splitting the curve. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two curve segments (each curve segment being four 2D tuples) if the curve was successfully split, or a list containing the original curve. Example:: >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 150, False)) ((0, 0), (25, 100), (75, 100), (100, 0)) >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 50, False)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (68.75, 75), (87.5, 50), (100, 0)) >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 25, True)) ((0, 0), (2.29379, 9.17517), (4.79804, 17.5085), (7.47414, 25)) ((7.47414, 25), (31.2886, 91.6667), (68.7114, 91.6667), (92.5259, 25)) ((92.5259, 25), (95.202, 17.5085), (97.7062, 9.17517), (100, 1.77636e-15)) css*|]"}d|krdkrnq|VqdSr}r/rer/r/r0r~Gs  zsplitCubic..)rzrr_splitCubicAtT) r*r+r,r-r{r|rZr[rrVrr/r/r0r(s cGs$t|||\}}}t|||f|S)aSplit a quadratic Bezier curve at one or more values of t. Args: pt1,pt2,pt3: Control points of the Bezier as 2D tuples. *ts: Positions at which to split the curve. Returns: A list of curve segments (each curve segment being three 2D tuples). Examples:: >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5, 0.75)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (62.5, 50), (75, 37.5)) ((75, 37.5), (87.5, 25), (100, 0)) )rpr)r*r+r,tsrZr[rr/r/r0rMsc Gs*t||||\}}}}t||||f|S)aSplit a cubic Bezier curve at one or more values of t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. *ts: Positions at which to split the curve. Returns: A list of curve segments (each curve segment being four 2D tuples). Examples:: >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (68.75, 75), (87.5, 50), (100, 0)) >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5, 0.75)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (59.375, 75), (68.75, 68.75), (77.3438, 56.25)) ((77.3438, 56.25), (85.9375, 43.75), (93.75, 25), (100, 0)) )rzr r*r+r,r-rrZr[rrVr/r/r0res)r*r+r,r-rZr[rrVc gs4t||||\}}}}t||||f|EdHdS)aSplit a cubic Bezier curve at one or more values of t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.. *ts: Positions at which to split the curve. Yields: Curve segments (each curve segment being four complex numbers). N)calcCubicParametersC_splitCubicAtTCrr/r/r0r}s)rgr*r+r,r-pointAtToff1off2)r _1_t_1_t_2_2_t_1_tc Cs||}d|}||}d||}|||d|||||||||} ||||||} ||||||} ||||}||||}||| | f| | ||ffS)aSplit a cubic Bezier curve at t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. t: Position at which to split the curve. Returns: A tuple of two curve segments (each curve segment being four complex numbers). rNrMr1r/) r*r+r,r-rgr rrrrrrr/r/r0rs 2cGst|}g}|dd|d|\}}|\}}|\} } tt|dD]} || } || d} | | }||}||}||}d|| ||}d|| ||}| | }|||| | }|||| | }t||f||f||f\}}}||||fqJ|S)Nrr_rBrNrM)listinsertrqrangelencalcQuadraticPoints)rZr[rrsegmentsrirjrkrlrmrnir r deltadelta_2a1xa1yb1xb1yt1_2c1xc1yr*r+r,r/r/r0rs,   rc"Gst|}|dd|dg}|\}}|\}} |\} } |\} } tt|dD](}||}||d}||}||}||}||}||}||}||}d||||}d||| |}d||| d|||}d| || d|||}||||| || }||| || || }t||f||f||f||f\}}} }!|||| |!fqR|SNrr_rBrNr1rM)rrrqrrcalcCubicPoints)"rZr[rrVrrrirjrkrlrmrnrxryrr r rrdelta_3rt1_3rrrrrrZd1xZd1yr*r+r,r-r/r/r0rs@      r) rZr[rrVr r rrra1b1c1rUcgst|}|dd|dtt|dD]}||}||d}||}||} || } ||} || } || } d|||| }d|||d|| |}|| || |||}t| |||\}}}}||||fVq.dSr)rrrqrrcalcCubicPointsC)rZr[rrVrrr r rrrrrrrrrUr*r+r,r-r/r/r0rs"    r)rPacoscospicCs~t|tkr,t|tkrg}qz| |g}nN||d||}|dkrv||}| |d|| |d|g}ng}|S)uKSolve a quadratic equation. Solves *a*x*x + b*x + c = 0* where a, b and c are real. Args: a: coefficient of *x²* b: coefficient of *x* c: constant term Returns: A list of roots. Note that the returned list is neither guaranteed to be sorted nor to contain unique values! @r_rcr=r`)rZr[rrPrrZDDZrDDr/r/r0r(s  &cCst|tkrt|||St|}||}||}||}||d|d}d|||d||d|d}||} |||} | tkrdn| } t| tkrdn| } | | } | dkr| dkrt| dt} | | | gS| tdkr@ttt|t | d d } d t |}|d}|t | d|}|t | dt d|}|t | d t d|}t |||g\}}}||tkr||tkrt|||dt}}}n~||tkrt||dt}}t|t}nN||tkrt|t}t||dt}}nt|t}t|t}t|t}|||gSt t | t|d } | || } |dkrr| } t| |dt} | gSdS)utSolve a cubic equation. Solves *a*x*x*x + b*x*x + c*x + d = 0* where a, b, c and d are real. Args: a: coefficient of *x³* b: coefficient of *x²* c: coefficient of *x* d: constant term Returns: A list of roots. Note that the returned list is neither guaranteed to be sorted nor to contain unique values! Examples:: >>> solveCubic(1, 1, -6, 0) [-3.0, -0.0, 2.0] >>> solveCubic(-10.0, -9.0, 48.0, -29.0) [-2.9, 1.0, 1.0] >>> solveCubic(-9.875, -9.0, 47.625, -28.75) [-2.911392, 1.0, 1.0] >>> solveCubic(1.0, -4.5, 6.75, -3.375) [1.5, 1.5, 1.5] >>> solveCubic(-12.0, 18.0, -9.0, 1.50023651123) [0.5, 0.5, 0.5] >>> solveCubic( ... 9.0, 0.0, 0.0, -7.62939453125e-05 ... ) == [-0.0, -0.0, -0.0] True rvg"@rcg;@gK@rr_r2rBggrUUUUUU?N)r=r`rfloatround epsilonDigitsrmaxminrPrrrpow)rZr[rrVrZa2a3QRZR2ZQ3ZR2_Q3rLthetaZrQ2Za1_3r\r]x2r/r/r0rIsT&  (            c Cs^|\}}|\}}|\}}||d} ||d} ||| } ||| } | | f| | f||ffS)Nrcr/) r*r+r,ry2x3y3rmrnrkrlrirjr/r/r0rps    rpcCs|\}}|\}}|\}} |\} } || d} || d} ||d| }||d| }|| | |}| | | |}||f||f| | f| | ffSNrvr/)r*r+r,r-rrrrx4y4rxryrmrnrkrlrirjr/r/r0rzs  rz)r*r+r,r-rZr[rcCs8||d}||d|}||||}||||fSrr/)r*r+r,r-rr[rZr/r/r0rs rcCsf|\}}|\}}|\}}|} |} |d|} |d|} |||} |||}| | f| | f| |ffSr<r/)rZr[rrirjrkrlrmrnr]y1rrrrr/r/r0rs    rcCs|\}}|\}}|\}} |\} } | } | } |d| }| d| }||d|}|| d|}|| ||}|| | |}| | f||f||f||ffSrr/)rZr[rrVrirjrkrlrmrnrxryr]rrrrrrrr/r/r0rs  rrZr[rrVr5r6Zp4cCs8|d|}||d|}||||}||||fS)Nrr/rr/r/r0rs rcCs8|dd||d||dd||d|fS)zFinds the point at time `t` on a line. Args: pt1, pt2: Coordinates of the line as 2D tuples. t: The time along the line. Returns: A 2D tuple with the coordinates of the point. rrNr/)r*r+rgr/r/r0r" s cCsd|d||ddd|||d|||d}d|d||ddd|||d|||d}||fS)zFinds the point at time `t` on a quadratic curve. Args: pt1, pt2, pt3: Coordinates of the curve as 2D tuples. t: The time along the curve. Returns: A 2D tuple with the coordinates of the point. rNrrMr/)r*r+r,rgrLyr/r/r0rs @@c Cs||}d|}||}|||dd|||d|||d|||d}|||dd|||d|||d|||d} || fS)zFinds the point at time `t` on a cubic curve. Args: pt1, pt2, pt3, pt4: Coordinates of the curve as 2D tuples. t: The time along the curve. Returns: A 2D tuple with the coordinates of the point. rNrr1r/) r*r+r,r-rgr rrrLrr/r/r0r %s "")rgr*r+r,r-)r rrcCsL||}d|}||}|||d|||||||||S)zFinds the point at time `t` on a cubic curve. Args: pt1, pt2, pt3, pt4: Coordinates of the curve as complex numbers. t: The time along the curve. Returns: A complex number with the coordinates of the point. rNr1r/)r*r+r,r-rgr rrr/r/r0r!?scCsZt|dkrt||fSt|dkr4t||fSt|dkrNt||fStddSNrMr1Unknown curve degree)rr"rr ValueError)segrgr/r/r0r#Xs   c Csx|\}}|\}}|\}}t||tkr>> a = lineLineIntersections( (310,389), (453, 222), (289, 251), (447, 367)) >>> len(a) 1 >>> intersection = a[0] >>> intersection.pt (374.44882952482897, 313.73458370177315) >>> (intersection.t1, intersection.t2) (0.45069111555824465, 0.5408153767394238) r r r )rOiscloserrr)s1e1s2e2Zs1xZs1yZe1xZe1yZs2xZs2yZe2xZe2yrLZslope34rr Zslope12r/r/r0r${s           cCsT|d}|d}t|d|d|d|d}t| |d |d S)NrrrN)rOatan2rrotate translate)segmentstartendZangler/r/r0_alignment_transformations$rcCst||}t|dkrBt|\}}}t|d|d|d}nDt|dkr~t|\}}}}t|d|d|d|d}ntdtdd|DS)Nr1rNrrcss*|]"}d|krdkrnq|VqdS)r_rNNr/rfrr/r/r0r~s  z._curve_line_intersections_t..) rZtransformPointsrrprrzrrr)curvelineZ aligned_curverZr[r intersectionsrVr/r/r0_curve_line_intersections_ts   rcCst|dkrt}nt|dkr$t}ntdg}t||D]B}|||f}t||f}t||f}|t|||dq:|S)aFinds intersections between a curve and a line. Args: curve: List of coordinates of the curve segment as 2D tuples. line: List of coordinates of the line segment as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> curve = [ (100, 240), (30, 60), (210, 230), (160, 30) ] >>> line = [ (25, 260), (230, 20) ] >>> intersections = curveLineIntersections(curve, line) >>> len(intersections) 3 >>> intersections[0].pt (84.9000930760723, 189.87306176459828) r1rrr) rrr rrrr"rqr)rrZ pointFinderrrgr Zline_tr/r/r0r%s  cCs4t|dkrt|St|dkr(t|StddS)Nr1rr)rrrr)rr/r/r0 _curve_boundss   rcCspt|dkr0|\}}t|||}||f||fgSt|dkrJt||fSt|dkrdt||fStddSr)rr"rrr)rrgrrmidpointr/r/r0_split_segment_at_ts    rMbP?c sxt|}t|}|sd}|s d}t||\}}|s6gSdd} t|krht|krh| || |fgSt|d\} } |d| |f} | ||df} t|d\}}|d| |f}| ||df}g}|t| || |d|t| || |d|t| || |d|t| || |dfdd }t}g}|D]0}||}||kr\qB||||qB|S) N)r_rBcSsd|d|dS)Nr2rrNr/)rr/r/r0r*sz._curve_curve_intersections_t..midpointr2rrN)range1range2cs t|dt|dfS)NrrN)int)r precisionr/r0Oz._curve_curve_intersections_t..) rrrrextend_curve_curve_intersections_tsetaddrq)curve1curve2rrrZbounds1Zbounds2Z intersects_rZc11Zc12Z c11_rangeZ c12_rangeZc21Zc22Z c21_rangeZ c22_rangefoundZ unique_keyseenZ unique_valuesrkeyr/rr0rs   rcst|}fdd|DS)a Finds intersections between a curve and a curve. Args: curve1: List of coordinates of the first curve segment as 2D tuples. curve2: List of coordinates of the second curve segment as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ] >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ] >>> intersections = curveCurveIntersections(curve1, curve2) >>> len(intersections) 3 >>> intersections[0].pt (81.7831487395506, 109.88904552375288) cs,g|]$}tt|d|d|ddqS)rrNr)rr#)rfrrr/r0rossz+curveCurveIntersections..)r)rrZintersection_tsr/rr0r&]s  cCsd}t|t|kr"||}}d}t|dkrRt|dkrFt||}qt||}n.t|dkrxt|dkrxt||}ntd|s|Sdd|DS)a)Finds intersections between two segments. Args: seg1: List of coordinates of the first segment as 2D tuples. seg2: List of coordinates of the second segment as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ] >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ] >>> intersections = segmentSegmentIntersections(curve1, curve2) >>> len(intersections) 3 >>> intersections[0].pt (81.7831487395506, 109.88904552375288) >>> curve3 = [ (100, 240), (30, 60), (210, 230), (160, 30) ] >>> line = [ (25, 260), (230, 20) ] >>> intersections = segmentSegmentIntersections(curve3, line) >>> len(intersections) 3 >>> intersections[0].pt (84.9000930760723, 189.87306176459828) FTrMz4Couldn't work out which intersection function to usecSs g|]}t|j|j|jdqS)r)rr r r rr/r/r0rosz/segmentSegmentIntersections..)rr&r%r$r)Zseg1Zseg2Zswappedrr/r/r0r'ys     cCsFz t|}Wntk r(d|YSXdddd|DSdS)zw >>> _segmentrepr([1, [2, 3], [], [[2, [3, 4], [0.1, 2.2]]]]) '(1, (2, 3), (), ((2, (3, 4), (0.1, 2.2))))' z%gz(%s)z, css|]}t|VqdSrG) _segmentrepr)rfrLr/r/r0r~sz_segmentrepr..N)iter TypeErrorjoin)objitr/r/r0rs  rcCs|D]}tt|qdS)zlHelper for the doctests, displaying each segment in a list of segments on a single line as a tuple. N)printr)rrr/r/r0 printSegmentssr__main__)r()r()rNN)V__doc__ZfontTools.misc.arrayToolsrrrZfontTools.misc.transformrrO collectionsrrcompiledZCOMPILEDAttributeError ImportErrorZfontTools.miscr__all__rr8Zreturnsdoublelocalsr)r>rrr`ZcfuncinlinerJrRrrrrrr r rrrrrrrrrrrrPrrrrrrprzrrrrr"rr r!r#rrr$rrr%rrrr&r'rr__name__sysdoctestexittestmodfailedr/r/r/r0s           #     !" $&9-%   #  !a       N  & C0