Wj dZddlmZddlZ ddlmZddlm Z ddl m Z ddl Z ddlmZddlmZdd l mZmZmZmZmZmZmZmZmZmZmZdd l mZmZ m!Z"m#Z# dd l$m%Z%d Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 e6Z7e9dZ:e9dZ;ddddddddddd Z<ejzdZ>ejzdZ?ejzdZ@ejzdZAdZBdZCdZDd ZEdZFdZGdZHd ZId ZJeKd!ZLd"ZMd#ZNd$ZOd%ZPd&ZQd'ZRd(ZSd)ZTd*ZUd+ZVdFd,ZWdGd-ZXd.ZYdHd/ZZd0Z[dId1Z\d2Z]d3Z^dFd4Z_dFd5Z`d6Zad7Zbd8ZceDeCdfd9ZdeHeIeGeFfd:Zed;ZfGd<d=egZhGd>d?egZiGd@dAegZjGdBdCegZkGdDdEeZly#e$r ddlmZYwxYw#d Z&YTxYw#e8$rY8wxYw)JzThis submodule contains the class definitions of the the main five classes svgpathtools is built around: Path, Line, QuadraticBezier, CubicBezier, and Arc.) annotationsN)MutableSequence)warn) itemgetter)tee)reduce) sqrtcossintanarccosarcsindegreesradianslogpiceil)expr angleisnan)quadTF)bezier_intersectionsbezier_bounding_box split_bezierbezier_by_line_intersectionspolynomial2bezierbezier2polynomial) BugException)rational_limit polyroots polyroots01imagrealMmZzLlHhVvCcSsQqTtAa MZLHVCSQTA) MLHVCSQTAZz([MmZzLlHhVvCcSsQqTtAa])z([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?z[01]z[\s,]*c#JKd}d}t|} tj||}|r|j}||k\ryd}|dzdvrtj||}|t j||}|y|j |j}|dz }w)zBYield the tokens of one or more seven-field elliptical-arc groups.rNr*)r)r)len WSP_COMMA_REmatchend ARC_FLAG_REFLOAT_REgroup) arg_chunkposfieldnsepr9s b/workspace/moltex-experiments/.pixi/envs/default/lib/python3.12/site-packages/svgpathtools/path.py_tokenize_arc_argsrD=s C E IA   C0 '')C !8  19 %%i5E =NN9c2E = kkmiik   sB!B#-q=i'z9This method has not yet been implemented for Arc objects.aThe name of this method is somewhat misleading (yet kept for compatibility with scripts created using svg.path 2.0). This method is meant only for d-string creation and should NOT be used to check for kinks. To check a segment for differentiability, use the joins_smoothly_with() method instead or the kinks() function (in smoothing.py). To turn off this warning, set warning_on=False.ct|dk(r|\}}t||St|dk(r|\}}}}t||||St|dk(r|\}}}t|||St|dvsJy)Nr'r)r6)r'r6r))r7Line CubicBezierQuadraticBezier)bpointsstartr:control1control2controls rCbezier_segmentrPss 7|q sE3 W )0&x35(Hc:: W %wugs337|y(((cjt|txs"t|txst|tSN) isinstancerHrJrIsegs rCis_bezier_segmentrWs/ sD ! ) sO , ) sK (*rQc<t|xst|tSrS)rWrTArcrUs rCis_path_segmentrZs S ! 9ZS%99rQcXt|txrttt|S)zXChecks that all segments in path are a Line, QuadraticBezier, or CubicBezier object.)rTPathallmaprW)paths rCis_bezier_pathr`s# dD ! Gc#.?*F&GGrQcLt|Dcgc] }|D]}| c}}Scc}}w)zTakes in a sequence of paths and returns their concatenations into a single path (following the order of the input sequence).)r\) list_of_pathsr_rVs rC concatpathsrcs) -@-$4C#4#-@ AA@s ct|d|zz|d|zz}t|d|zz|d|zz}t|d|zz|d|zz}t|d|zz|d|zz}t|||j|jS)z1Converts a bounding box 4-tuple to a Path object.?)rHr\reversed)xminxmaxyminymaxbtrls rC bbox2pathros TBtG^TBtG^,A TBtG^TBtG^,A TBtG^TBtG^,A TBtG^TBtG^,A 1ajjlAJJL 11rQc ttt|dz Dcgc]}t||||dzc}Scc}w)zConverts a list of points to a Path composed of lines connecting those points (i.e. a linear spline or polyline). See also `polygon()`.rr\ranger7rHpointsis rCpolylinervsQ  Vq131avay&1+.13 443s?c ttt|Dcgc]#}t||||dzt|z%c}Scc}w)zConverts a list of points to a Path composed of lines connecting those points, then closes the path by connecting the last point to the first. See also `polyline()`.rrqrss rCpolygonrxsW  V-/-avay&!a%3v;)>"?@-/ 00/s(Act|dz }|dk(rt|S|dk(rt|S|dk(rt|St|dvsJy)zConverts a list of length 2, 3, or 4 to a CubicBezier, QuadraticBezier, or Line object, respectively. See also: poly2bez.rr6r'>r'r6r)N)r7rIrJrH)rKorders rCbpoints2bezierr{sY L1 E zG$$ !(( !W~7|y(((rQc6t|}|r|St|S)aConverts a cubic or lower order Polynomial object (or a sequence of coefficients) to a CubicBezier, QuadraticBezier, or Line object as appropriate. If return_bpoints=True then this will instead only return the control points of the corresponding Bezier curve. Note: The inverse operation is available as a method of CubicBezier, QuadraticBezier and Line objects.)rr{)polyreturn_bpointsrKs rCpoly2bezrs! %Gg&&rQcTt|r|j}t|||S)aConverts a Bezier object or tuple of Bezier control points to a tuple of coefficients of the expanded polynomial. return_poly1d : returns a numpy.poly1d object. This makes computations of derivatives/anti-derivatives and many other operations quite quick. numpy_ordering : By default (to accommodate numpy) the coefficients will be output in reverse standard order. Note: This function is redundant thanks to the .poly() method included with all bezier segment classes.)numpy_ordering return_poly1d)rWrKr)bezrrs rCbez2polyrs,kkm S,:+8 ::rQc|Dcgc] }|| }}t|jD]H\}\}}|j|jk(s#||dzt |zj||_Jt |Scc}w)zBMakes sure that, if joints were continuous, they're kept that way.r) enumeratejointsr:rLr7r\)r_transformationrVtransformed_segsrusasbs rCtransform_segments_togetherrs7;.rotate_points%2gdm#$a&j1F::rQ?c t|S)Nrrotate)rVrrs rCzrotate..sVCf%ErQradiusrotation large_arcsweepr:RInput `curve` should be a Path, Line, QuadraticBezier, CubicBezier, or Arc object.)rTrYcenterpointr\rrWr{rKrLr:rrrr TypeError) curverrrrbpt new_startnew_end new_rotations `` rCrrs ;~ eS !\\F[[%F%E*5.AA 5 !EMMOLOS|C0OLMM E3  - uyy)~~, 9U\\L"__EKKWN NGH HMs=Dct|trfd}t||St|r*t |j Dcgc]}|z c}St|t rW|jz}|jz}t ||j|j|j|j|Stdcc}w)zlShifts the curve by the complex quantity z such that translate(curve, z0).point(t) = curve.point(t) + z0ct|SrS translate)rVz0s rCrztranslate..  YsB%7rQrr)rTr\rrWr{rKrYrLr:rrrrr)rrrrrrs ` rCrrs%7*5.AA 5 !5==?C?CsRx?CDD E3 KK"$ ))b.9U\\ENN"__EKKWN NGH HDs C c dzndzfdfd}t|trfd}t||St|r||St|trtk(rbt |j z zz|j z|j|j|j|jz zzStdtd)a]Scales `curve`, about `origin`, by diagonal matrix `[[sx,0],[0,sy]]`. Notes: ------ * If `sy` is not specified, it is assumed to be equal to `sx` and a scalar transformation of `curve` about `origin` will be returned. I.e. scale(curve, sx, origin).point(t) == ((curve.point(t) - origin) * sx) + origin recP|zS|jz|jzzSrS)r$r#)risysxsys rC_scalezscale.._scale*s, :a4K!&&y3qvv:%%rQct|Dcgc] }| }}|dxxz z cc<t|Scc}w)N)rr)rcprrs rC scale_bezierzscale..scale_bezier/sE ( . 1VAY  . "&.(({ /sAc t|SrSscale)rVrrrs rCrzscale..5sU3B%?rQrLrrrrr:zG For `Arc` objects, only scale transforms with sx==sy are implemented. r) rTr\rrWrYrLrrrrr: Exceptionr)rrrrrrrrs ``` @@rCrrs zee&  %?*5.AA 5 !E"" E3  :rRv!56? o %!&"[[uyy612V; = ==> >GH HrQc ttjdk(jr|Sd}d}d}t |t rfd}t ||St|rBt|jDcgc]}|j||!c}St |tr|j||j}|j||j}|jjdz} |jj dz} tj"d| z dgdd| z gg} tj$j'd dd df} t)tj*| j,| | g} tj$j/d | | j,zz\}}dtj0|dz }dtj0|dz }t3||}|d d df}tj4tj6|d|d}|jdk(s|j dk(r t9||Sddddzd k\r |j:}n |j: }t|||j<|z|j>||d StAdcc}w)z@Transforms the curve by the homogeneous transformation matrix tfr6c`tj|jg|jgdggS)N?nparrayr$r#)rs rCto_pointztransform..to_pointO&xx!&&AFF8cU344rQc`tj|jg|jgdggS)Nr)rs rC to_vectorztransform..to_vectorRrrQcN|jdd|jdzzS)Nrrer)item)vs rC to_complexztransform..to_complexUs!vvay2q >))rQct|SrS) transform)rVtfs rCrztransform..YrrQr'rrNrrTrrrrr:autoscale_radiusr)!r]reyeravelrTr\rrWr{rKdotrYrLr:rr$r#rlinalginvrmatmulr2eighr complexrarctan2rHrrrr)rrrrrrrrrrx2ry2r1invTDeigvalseigvecsrxry new_radiusxeigvecrot new_sweeps ` rCrrIs B"&&)O " " $% 55*%7*5.AA 5 !(- 9(71 *"&&!*=>(79: : E3 rvvhu{{&;<= RVVHUYY$789ll1$ll1$ HHquaj1ae*- .yy}}R2A2Y' 299tvvq$/ 099>>#qu+6 $ $ $ $R_ !Q$-jjGAJ ;< ??a :??a#7 7+ +!uQx"Q%("c)!KK % O yenns>R!& w(,. . GH HI9s?$K#cR|j|} |t|z }|S#ttf$r|j j }t |dzt|dzz} tt|dz||}Y|S#t$r|j j |dz }|j j |dz}dj|dj|zdj|z}t|wxYwwxYw)a#Returns the unit tangent of the segment at t. Notes ----- If you receive a RuntimeWarning, try the following: >>> import numpy >>> old_numpy_error_settings = numpy.seterr(invalid='raise') This can be undone with: >>> numpy.seterr(**old_numpy_error_settings) r'-C6?z8Unit tangent appears to not be well-defined at t = {}, z"seg.poly().deriv()(t - 1e-4) = {} z!seg.poly().deriv()(t + 1e-4) = {}) derivativeabsZeroDivisionErrorFloatingPointErrorr}derivr$r#csqrtr ValueErrorformat) rVrldseg unit_tangent dseg_polydseg_abs_squared_polybefaftmess rCbezier_unit_tangentrs9 >>! D"CI~ & % 1 2"HHJ$$& !%iA!5!%iA!5"6 "  1 ,A1"FGL  "$#((*""$QX.C$#((*""$QX.C &q 8??DE7==cBCCS/ ! ""s#A D&.B  BD""D&c|j|}|j|d}|j|j}}|j|j}}tjd} t ||z||zz t ||z||zzdzz } tjdi| | S#ttf$r|j} | j} | j} t| t| }}t| t| }}||z||zz dz}||z||zzdz}t|||}|dkrYtjdi| yt |} YwxYw#tjdi| wxYw)zreturns the curvature of the segment at t. Notes ----- If you receive a RuntimeWarning, run command >>> old = np.seterr(invalid='raise') This can be undone with >>> np.seterr(**old) r'rAraise)invalidr6r) rr$r#rseterrrr rrr}rr )selfrluse_infdzddzdxdyddxddy old_np_seterrkappardpddpf2g2lim2s rCsegment_curvaturer sl  B //!q/ !C WWbggBxxCIIg.M#BsFRVO$T"R%"R%-%8!%;; "M" L 1 2  IIK WWYhhjb48B9d3iSfr#vo !ebema b"a( !8 "M"T   "M"s1,,B//BE-E0 E-*E0,E--E00FcVfd}jz }t|dzt|dzz}ddgt|j z}|Dcgc] }|||f}}|rt t |td} t|td} | | fScc}w)aPreturns the tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance d = |self.point(t)-origin|. return_all_global_extrema: Multiple such t_min or t_max values can exist. By default, this will only return one. Set return_all_global_extrema=True to return all such global extrema.c>tj|z SrSrr)taurrVs rC_radiusz#bezier_radialrange.._radiuss399S>F*++rQr'rrkey) r}r$r#r"rNotImplementedErrorminrmax) rVrreturn_all_global_extremarshifted_seg_poly r_squared extremizersrlextremaseg_global_minseg_global_maxs `` rCbezier_radialrangers,xxzF*%&!+%&!+,Ia&;y'899K(34 1 A G4 !!W*Q-8W*Q-8~--5sB&c*|j|dS)zreturns (|path.seg.point(t)-pt|, t, seg_idx) where t and seg_idx minimize the distance between pt and curve path[idx].point(t) for 0<=t<=1 and any seg_idx. Warning: Multiple such global minima can exist. This will only return one.r radialrangeptr_s rCclosest_point_in_pathr%s   B  ""rQc*|j|dS)a,returns (|path.seg.point(t)-pt|, t, seg_idx) where t and seg_idx maximize the distance between pt and curve path[idx].point(t) for 0<=t<=1 and any seg_idx. :rtype : object :param pt: :param path: Warning: Multiple such global maxima can exist. This will only return one.rr!r#s rCfarthest_point_in_pathr's   B  ""rQc|jsJtt||j|}t |dzryy)zreturns true if pt is a point enclosed by path (which must be a Path object satisfying path.isclosed==True). opt is a point you know is NOT enclosed by path.r'TF)isclosedr\rH intersectr7)r$optr_ intersectionss rCpath_encloses_ptr-s@ ==??b#'11$7M =ArQc ||zdz }|j|} t||z } t| |z } t|| z } | | z} | | z |kDs||kr*|dz }t||||| |||t|||| ||||zS| S)z5Recursively approximates the length by straight linesr'r)rrsegment_length)rrLr: start_point end_pointerror min_depthdepthmid mid_pointlength first_half second_halflength2s rCr/r/s 3;/C C I [( )FY,-Ji)+,K;&G&5 ei&7  ueS+y$i8uc3 9$i88 9 NrQc |j||}|dkDsJd|cxkr|kstdtd|dk(ry||k(ryt|trw|Dcgc]}|j||}}d} t |D]F\} } | |cxkr| | zkr.nn+t || || z ||||} |j | | cS| | z } Hyt|tr||j||z St|ts t|tst|trd} d}d}||krq|dz }|| zdz } |j| ||}t||z |kr| S||kr| }n| } | |k(r(tdjt||z | S||krqtd j|z td cc}w) awINPUT: curve should be a CubicBezier, Line, of Path of CubicBezier and/or Line objects. OUTPUT: Returns a float, t, such that the arc length of curve from 0 to t is approximately s. s_tol - exit when |s(t) - s| < s_tol where s(t) = seg.length(0, t, error, min_depth) and seg is either curve or, if curve is a Path object, then seg is a segment in curve. error - used to compute lengths of cubics and arcs min_depth - used to compute lengths of cubics and arcs Note: This function is not designed to be efficient, but if it's slower than you need, make sure you have scipy installed.r2r3rz)s is not in interval [0, curve.length()].rs_tolmaxitsr2r3r')t1r2r3zQt is as close as a float can be to the correct value, but |s(t) - s| = {} > s_tolz.Maximum iterations reached with s(t) - s = {}.zQFirst argument must be a Line, QuadraticBezier, CubicBezier, Arc, or Path object.)r7rrTr\r inv_arclengtht2TrHrJrIrYrrrrr)rsr>r?r2r3 curve_lengthrV seg_lengthslsumklen_krlt_uppert_lower iterations_ts rCrArAs<3@ @rQcX|j|jz }|j||zzS);returns the coordinates of the Bezier curve evaluated at t.r:rL)rrldistances rCrz Line.points'88djj(zzHQJ&&rQc.|j|Sz*Faster than running Path.point many times.r}rtss rCrtz Line.pointstyy{2rQNcRt|j|jz ||z zS)z9returns the length of the line segment between t0 and t1.)rr:rL)rrPr@r2r3s rCr7z Line.lengths#488djj()2b511rQc$t||||||SzReturns a float, t, such that self.length(0, t) is approximately s. See the inv_arclength() docstring for more details.r=rArrCr>r?r2r3s rCilengthz Line.ilengthT1E&'02 2rQc2|j|jfSz1returns the Bezier control points of the segment.rWr[s rCrKz Line.bpointsszz488##rQct|j}|d|dz |dg}|r|Stj|S)z(returns the line as a Polynomial object.rrrKrpoly1dr return_coeffsrcoeffss rCr}z Line.polys> LLNQ4!A$;!% M99V$ $rQc|j|jk7sJ|dk(r|j|jz S|dkDrytd)/returns the nth derivative of the segment at t.rrn should be a positive integer.)r:rLr)rrlrAs rCrzLine.derivativesHxx4::%%% 688djj( ( U>? ?rQc|j|jk7sJ|j|jz }|t|z S)z-returns the unit tangent of the segment at t.)r:rLrrrlrs rCrzLine.unit_tangents8xx4::%%%xx$**$CI~rQc*d|j|zSz>returns the (right hand rule) unit normal vector to self at t.yrrrls rCnormalz Line.normal4$$Q'''rQcy)z8returns the curvature of the line, which is always zero.rrrs rC curvaturezLine.curvaturesrQcBt|j|jS)z@returns a copy of the Line object with its orientation reversed.)rHr:rLr[s rCrfz Line.reversedsDHHdjj))rQct|tttfr|j Dcgc]}|j }}|j Dcgc]}|j }}t |t|kDrgSt|t |krgS|j Dcgc]}|j}}|j Dcgc]}|j}}t |t|kDrgSt|t |krgSt|tr|j|jk7r|j|jk7sJ||k7sJ|jj |jj f}|jj|jjf}|jj |jj f}|jj|jjf} |d|dz | d| dz z|d|dz |d|dz zz } tj| drgS|d|d| dz z|d|d| dz zz |d| d| dz zz | z } |d|d| dz z|d|d| dz zz |d|d|dz zz | z } d| cxkrdkrngSd| cxkrdkr ngS| | fgSgSt|tr#t||} | D cgc] \} } | | f c} } St|tr#t||} | D cgc] \} } | | f c} } St|tr(|j|} | D cgc] \} } | | f c} } St|t r t#dt#dcc}wcc}wcc}wcc}wcc} } wcc} } wcc} } w)aFinds the intersections of two segments. returns a list of tuples (t1, t2) such that self.point(t1) == other_seg.point(t2). Note: This will fail if the two segments coincide for more than a finite collection of points. tol is not used.rrJother_seg must be a path segment, not a Path object, use Path.intersect().!other_seg must be a path segment.)rTrHrJrIrKr$rrr#r:rLrrurrYr*r\r)r other_segtoleobrarkrddenomr@t2t2t1ss rCr*zLine.intersects i$!E F"+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  "+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  i &==IOO3DJJ8N NN9$ $$$((--0A$((--0A%%y}}'9'9:A%%y}}'9'9:AdQqTkAaD1Q4K0dQqTkAaD1Q4K01Ezz%# A$!qt $A$!qt $%A$!qt $%&+,BQ41!%Q41!%&Q41!%&'',-BB|!|I!"R 1 IRz!I  ? 30DAE+015RRH51 1  ; /0DAE+015RRH51 1  3 '''-E+015RRH51 1  4 ($% %?@ @a71 71:222s)N:N?/OO O OOct|jj|jj}t |jj|jj}t|jj |jj }t |jj |jj }||||fSzVreturns the bounding box for the segment in the form (xmin, xmax, ymin, ymax).)rrLr$r:rr#)rrgrhrirjs rCbboxz Line.bbox#s4::??DHHMM24::??DHHMM24::??DHHMM24::??DHHMM2T4%%rQcdtj||jddrytj||jddry|j }||dz |dz }tj|j dr*|j dk\r|j dkr |j Sy)zvIf the point lies on the Line, returns its `t` parameter. If the point does not lie on the Line, returns None.rư>rtolatolrrrN)rrurLr:r}r#r$)rrrrls rC point_to_tzLine.point_to_t,s ::eTZZad ; ZZtxxad ; IIKQqT\QqT ! ::affa affm!&&C-66MrQcVt|j||j|Sireturns a cropped copy of this segment which starts at self.point(t0) and ends at self.point(t1).)rHrrrPr@s rCcroppedz Line.croppedCs!DJJrNDJJrN33rQc||j|}t|j|t||jfSzZreturns two segments, whose union is this segment and which join at self.point(t).)rrHrLr:)rrlr$s rCrNz Line.splitHs2ZZ]DJJ#T"dhh%777rQc 8|j|j}}|j|j}}|j|j|j|jf\}}} } | |z | |z } } | ||z z| ||z zz| | z| | zz}} | |z }d|cxkrdkrQnnNt ||z t ||z t |j ||z }}}||kr||f|dffS||f|dffSt ||z t ||z }}||kr|df|dffS|df|dffS)a<compute points in self that are min and max distance to origin. Args: origin (complex): the point extremize distance to Returns: tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance d = |self.point(t)-origin|. rr)r$r#rLr:rr)rrkwargsxyp0p1x0y0x1y1rr numerator denominatorrld0d1dts rCr"zLine.radialrangeNsN{{FKK1TXXB"''277BGG;BBb"r'B!#q2vq2v!>R"r'@Q;  # q919BK BK DJJqMF*+B BwAwQ''7RG# #f%s2;'7BBwAwQ''7RG# #rQct|||SzReturns a copy of self rotated by `degs` degrees (CCW) around the point `origin` (a complex number). By default `origin` is either `self.point(0.5)`, or in the case that self is an Arc object, `origin` defaults to `self.center`.rrrrrs rCrotatedz Line.rotatedr dD00rQct||SzReturns a copy of self shifted by the complex quantity `z0` such that self.translated(z0).point(t) = self.point(t) + z0 for any t.rrrs rC translatedzLine.translatedyr""rQc t||||Sz?Scale transform. See `scale` function for further explanation.)rrrrrrrrs rCscaledz Line.scaled~TbR77rQreturnintFrrNN)NrrSN)#__name__ __module__ __qualname__rXr\r`rerhrmrpryrrtr7 ILENGTH_S_TOLILENGTH_MAXITS ILENGTH_ERRORILENGTH_MIN_DEPTHrrKr}rrrrrfr*rrrrNr"rrrrrQrCrHrHzs,AC ! $ @' 2 -^#/@2$%@ (*8At&.4 8 "$H1# 8rQrHceZdZdddZdZddZdZdZdZdZ d Z d d Z d!d Z d Z d Zd"dZeeeefdZdZd#dZd$dZdZdZdZdZd%dZdZdZdZd#dZ d&dZ!dZ"d'dZ#y)(rJNr7rKcB||_||_||_ddd|_y)Nr)rLr:rO _length_info)rrLrOr:s rCrXzQuadraticBezier.__init__s&  (,=rQcZt|j|j|jfSrS)rZrLrOr:r[s rCr\zQuadraticBezier.__hash__s TZZtxx899rQcVd|jd|jd|jdS)NzQuadraticBezier(start=z , control=r^r_rLrOr:r[s rCr`zQuadraticBezier.__repr__s JJ dhh0 0rQct|tsy|j|jk(xr4|j|jk(xr|j|jk(Srb)rTrJrLr:rOrcs rCrezQuadraticBezier.__eq__sM%1zzU[[(.TXX-B.  - .rQc:t|tstS||k( SrS)rTrJrgrcs rCrhzQuadraticBezier.__ne__s%1! !5=  rQc(|j|SrSrkrls rCrmzQuadraticBezier.__getitem__rnrQcy)Nr6rr[s rCrpzQuadraticBezier.__len__rqrQc|rttt|trN|j|j k(xr3|j |jz |j |j z k(S|j |jk(SaT[Warning: The name of this method is somewhat misleading (yet kept for compatibility with scripts created using svg.path 2.0). This method is meant only for d string creation and should not be used to check for kinks. To check a segment for differentiability, use the joins_smoothly_with() method instead.])r_is_smooth_from_warningrTrJrLr:rOrrw warning_ons rCis_smooth_fromzQuadraticBezier.is_smooth_fromsp  ( ) h 0JJ(,,.9\\DJJ. x'7'779 :<<4::- -rQc.|rJ|j|jk(xr/t|jd|jdz |kS|j|jk(xr/t|j d|j dz |kSrsrLr:rrrrrwrxr2s rCryz#QuadraticBezier.joins_smoothly_with ::-F#"X%8%8%;;3=@E3F F::-J#!!!$x'<'AR AaffkAFFaK/0BWB1qvv{*BR=DGdai'E2a<"r'1B67G2a<"r'1B67GBx29-7HBx29-7H3;q=s8h./aHdg%dg(==R 8+,A FAQxA!c!f*-:q6R1WrQw%67#a&BG:LLLRZq6R1WrQw%67#a&BG:LLLq6R1WrQw%67#a&BG:LLq6Q;!c!f*566 7rQw*+D  h '+/<<>D  i ($$X. .HrQc$t||||||Srrrs rCrzQuadraticBezier.ilengthrrQcH|j|j|jfSrrr[s rCrKzQuadraticBezier.bpointsszz4<<11rQc|j}|dd|dzz |dzd|d|dz z|df}|r|Stj|S)z-returns the quadratic as a Polynomial object.rr'rrrs rCr}zQuadraticBezier.polys] LLNA$1Q4-!A$&1Q4!A$;1> M99V$ $rQc|j}|dk(r#d|d|dz d|z z|d|dz |zzzS|dk(rd|dd|dzz |dzzS|dkDrytd)returns the nth derivative of the segment at t. Note: Bezier curves can have points where their derivative vanishes. If you are interested in the tangent direction, use the unit_tangent() method instead.rr'rrrKrrrlrArs rCrzQuadraticBezier.derivative s LLN 6qtad{QU+qtad{Ao=> > !VadQqtVmad*+ + U>? ?rQct||Sareturns the unit tangent vector of the segment at t (centered at the origin and expressed as a complex number). If the tangent vector's magnitude is zero, this method will find the limit of self.derivative(tau)/abs(self.derivative(tau)) as tau approaches t.rrs rCrzQuadraticBezier.unit_tangent #4++rQc*d|j|zSrrrs rCrzQuadraticBezier.normal"rrQct||Sz*returns the curvature of the segment at t.r rs rCrzQuadraticBezier.curvature& q))rQct|j|j|j}|jdrA|j|_|j|j|jf|jd<|S)zSreturns a copy of the QuadraticBezier object with its orientation reversed.r7rK)rJr:rOrLr)rnew_quads rCrfzQuadraticBezier.reversed5sd#488T\\4::F   X &$($5$5H !$,, 04H ! !) ,rQct|tttfr|j Dcgc]}|j }}|j Dcgc]}|j }}t |t|kDrgSt|t |krgS|j Dcgc]}|j}}|j Dcgc]}|j}}t |t|kDrgSt|t |krgSt|tr t||St|tr?||k7sJt|j|j}t|||||St|tr8t|j|j}t|||||St|tr(|j|}|D cgc] \}} | |f c} }St|tr tdtdcc}wcc}wcc}wcc}wcc} }w)zFinds the intersections of two segments. returns a list of tuples (t1, t2) such that self.point(t1) == other_seg.point(t2). Note: This will fail if the two segments coincide for more than a finite collection of points. longer_lengthrtol_deCrrrTrHrJrIrKr$rrr#rr7rrYr*r\r) rrrrrrr#rrr@s rCr*zQuadraticBezier.intersect?s i$!E F"+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  "+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  i &/i@ @  ? 39$ $$ y/?/?/ABM'i6C,/> > ; / y/?/?/ABM'i6C,/> > 3 '''-E+015RRH51 1  4 ($% %?@ @C71 71(2sH.H3/H8H=6Ict|Srrr[s rCrzQuadraticBezier.bboxis#4((rQc\t|j|\}}t|t|fSr)rrKrJrrlbpoints1bpoints2s rCrNzQuadraticBezier.splitns0*$,,.!<()?H+EEErQc(tt|||Sr)rJrOrs rCrzQuadraticBezier.croppedts D"b 9::rQct|||Szreturns the tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance d = |self.point(t)-origin|.)rrrrrs rCr"zQuadraticBezier.radialrangeys"$*CE ErQct|||Srrrs rCrzQuadraticBezier.rotatedrrQct||Srrrs rCrzQuadraticBezier.translatedrrQc t||||Srrrs rCrzQuadraticBezier.scaledrrQrTFrrrrrFrSr)$rrrrrXr\r`rerhrmrprryrrtr7rrrrrrKr}rrrrrfr*rrNrr"rrrrrQrCrJrJs"t4L>:0. ! $ .BG"# JE )V -^#/@22% @,(*(AT) F ; E 1# 8rQrJceZdZdddddZdZd!dZdZdZdZdZ d Z d"d Z d#d Z d Z d ZddeefdZeeeefdZdZd#dZd$dZdZdZdZdZd%dZdZdZ dZ!d#dZ"d&dZ#dZ$d'd Z%y)(rINr7rKr2r3cT||_||_||_||_ddddd|_y)Nr9)rLrMrNr:r)rrLrMrNr:s rCrXzCubicBezier.__init__s4     (,t*.0rQcpt|j|j|j|jfSrS)rZrLrMrNr:r[s rCr\zCubicBezier.__hash__s&TZZ txxHIIrQc pd|jd|jd|jd|jd S)NzCubicBezier(start=z , control1=z , control2=r^r_rLrMrNr:r[s rCr`zCubicBezier.__repr__s' JJ t}}dhh@ @rQct|tsy|j|jk(xrO|j|jk(xr4|j|jk(xr|j |j k(Srb)rTrIrLr:rMrNrcs rCrezCubicBezier.__eq__sb%-zzU[[(0TXX-B0 /0 / 0rQc:t|tstS||k( SrS)rTrIrgrcs rCrhzCubicBezier.__ne__s%-! !5=  rQc(|j|SrSrkrls rCrmzCubicBezier.__getitem__rnrQcy)Nr)rr[s rCrpzCubicBezier.__len__rqrQc|rttt|trN|j|j k(xr3|j |jz |j |jz k(S|j |jk(Sr)rrrTrIrLr:rMrNrs rCrzCubicBezier.is_smooth_fromsp  ( ) h ,JJ(,,.:]]TZZ/ x'8'88: ;==DJJ. .rQcB|rO|j|jk(xr4tj|j d|j dS|j|jk(xr4tj|j d|j dSrsrtrvs rCryzCubicBezier.joins_smoothly_withrzrQc 0|j|d|j|jz z|d|j|jzzd|jzz ||j d|j|jz zz|jzzzzzzzS)z9Evaluate the cubic Bezier curve at t using Horner's rule.r6r(r=rs rCrzCubicBezier.points zzA t}}tzz) *Q4:: -.4==@1ZZK!T]]T]]%B"CCdhhND.  rQc.|j|Srrrs rCrtzCubicBezier.pointsrrQrrc "|dk(rX|dk(rSjdjk(r3jd|k\r!jd|k\rjdStrtfd|||d d}n0t ||j |j |||d}|dk(r^|dk(rY|jd<jjd<|jd<|jd<jdS|S) z9Calculate the length of the path up to a certain positionrrrKr2r3r7c8tj|SrSrrrrs rCrz$CubicBezier.length..sT__S%9!:rQepsabslimit)rrK_quad_availablerr/r)rrPr@r2r3rCs` rCr7zCubicBezier.lengths 7rQw  +t||~=))'2e;))+6)C((22 :B#(6679AtRTZZ^TZZ^$i4A 7rQw*+D  h '+/<<>D  i ().D  g &-6D  k *$$X. .HrQc$t||||||Srrrs rCrzCubicBezier.ilengthrrQc^|j|j|j|jfSrr=r[s rCrKzCubicBezier.bpointss!zz4==$--AArQc|j}|d d|d|dz zz|dzd|dd|dzz |dzzd|d |dzz|df}|r|Stj|S)z+Returns a the cubic as a Polynomial object.rr6rr'rrs rCr}zCubicBezier.polys LLNQ4%!QqTAaD[/)AaD0QqTAadF]QqT)*adUQqT\"A$ M99V$ $rQc|j}|dk(rDd|d|dz zd|z dzzd|d|dz zd|z z|zzd|d|dz z|dzzzS|dk(r5dd|z |dd|dzz |dzz||dd|dzz |dzzzzS|dk(rd|dd|d|dz zz |dz zS|dkDrytd)rrr6rr'r(rrrs rCrzCubicBezier.derivatives/ LLN 6adQqTk?AEA:-1Q4!A$;Q0G0IIA!qt MTM"" " !VQ1!A$1-.AaD1QqT6MAaD4H1IIK K !VadQ!qt _,qt34 4 U>? ?rQct||Srrrs rCrzCubicBezier.unit_tangent&rrQc*d|j|zSrrrs rCrzCubicBezier.normal-sT&&q)))rQct||Srrrs rCrzCubicBezier.curvature1rrQc(t|j|j|j|j}|j drL|j |_|j|j|j|jf|j d<|S)zOreturns a copy of the CubicBezier object with its orientation reversed.r7rK)rIr:rNrMrLr)rnew_cubs rCrfzCubicBezier.reversed@stdhh t}}"jj*   X &#'#4#4G $-- /DG  +rQct|tttfr|j Dcgc]}|j }}|j Dcgc]}|j }}t |t|kDrgSt|t |krgS|j Dcgc]}|j}}|j Dcgc]}|j}}t |t|kDrgSt|t |krgSt|tr t||St|tst|tr?||k7sJt|j|j}t|||||St|tr&|j|Dcgc] \}}||f c}}St|tr tdtdcc}wcc}wcc}wcc}wcc}}w)a<Finds the intersections of two segments. Returns: (list[tuple[float]]) a list of tuples (t1, t2) such that self.point(t1) == other_seg.point(t2). Scope: This will fail if the two segments coincide for more than a finite collection of points. r"zP`other_seg` must be a path segment, not a `Path` object, use `Path.intersect()`.z#`other_seg` must be a path segment.r%) rrrrrrr#rr@s rCr*zCubicBezier.intersectKs i$!E F"+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  "+"3"3"56"5Q!&&"5B6"&,,.1.Q!&&.B12wR  2wR  i &/i@ @O4K09$ $$ y/?/?/ABM'i}#s  3 '+4+>+>t+DE+DRRH+DE E  4 (EF FAB B771 71FsG4G9/G>H<Hct|S)z8returns bounding box in format (xmin, xmax, ymin, ymax).r'r[s rCrzCubicBezier.bboxts "4((rQc\t|j|\}}t|t|fS)z=Splits a copy of `self` at t and returns the two subsegments.)rrKrIr)s rCrNzCubicBezier.splitxs.)$,,.!<(H%{H'===rQc(tt|||Sr)rIrOrs rCrzCubicBezier.cropped}sKb"566rQct|||Sr.r/r0s rCr"zCubicBezier.radialranges" &4MO OrQct|||Srrrs rCrzCubicBezier.rotatedrrQct||Srrrs rCrzCubicBezier.translatedrrQc t||||Srrrs rCrzCubicBezier.scaledrrQrr4rr6r7rSr)&rrrrrXr\r`rerhrmrprryrrt LENGTH_ERRORLENGTH_MIN_DEPTHr7rrrrrrKr}rrrrrfr*rrNrr"rrrrrQrCrIrIs"td!%'L0J@0! $ / @ a|?O2 -^#/@2B %@&,** 'CR)> 7 O 1# 8rQrIceZdZ d$dZd%dZd&dZdZdZdZdZ dZ d Z d Z d Z d Zd ZddeefdZeeeefdZ d'dZd(dZdZdZdZdZdZd)dZdZ dZ!dZ"d*dZ#d+dZ$d Z%d,d!Z&d(d"Z'd(d#Z(y)-rYc||k7sJ|jdk7r|jdk7sJ||_t|jdt|jzz|_||_t ||_t ||_||_ ||_ d|_ d|_ t|j |_td|jz|_|j#y)a This should be thought of as a part of an ellipse connecting two points on that ellipse, start and end. Parameters ---------- start : complex The start point of the curve. Note: `start` and `end` cannot be the same. To make a full ellipse or circle, use two `Arc` objects. radius : complex rx + 1j*ry, where rx and ry are the radii of the ellipse (also known as its semi-major and semi-minor axes, or vice-versa or if rx < ry). Note: If rx = 0 or ry = 0 then this arc is treated as a straight line segment joining the endpoints. Note: If rx or ry has a negative sign, the sign is dropped; the absolute value is used instead. Note: If no such ellipse exists, the radius will be scaled so that one does (unless autoscale_radius is set to False). rotation : float This is the CCW angle (in degrees) from the positive x-axis of the current coordinate system to the x-axis of the ellipse. large_arc : bool Given two points on an ellipse, there are two elliptical arcs connecting those points, the first going the short way around the ellipse, and the second going the long way around the ellipse. If `large_arc == False`, the shorter elliptical arc will be used. If `large_arc == True`, then longer elliptical will be used. In other words, `large_arc` should be 0 for arcs spanning less than or equal to 180 degrees and 1 for arcs spanning greater than 180 degrees. sweep : bool For any acceptable parameters `start`, `end`, `rotation`, and `radius`, there are two ellipses with the given major and minor axes (radii) which connect `start` and `end`. One which connects them in a CCW fashion and one which connected them in a CW fashion. If `sweep == True`, the CCW ellipse will be used. If `sweep == False`, the CW ellipse will be used. See note on curve orientation below. end : complex The end point of the curve. Note: `start` and `end` cannot be the same. To make a full ellipse or circle, use two `Arc` objects. autoscale_radius : bool If `autoscale_radius == True`, then will also scale `self.radius` in the case that no ellipse exists with the input parameters (see inline comments for further explanation). Derived Parameters/Attributes ----------------------------- self.theta : float This is the phase (in degrees) of self.u1transform(self.start). It is $\theta_1$ in the official documentation and ranges from -180 to 180. self.delta : float This is the angular distance (in degrees) between the start and end of the arc after the arc has been sent to the unit circle through self.u1transform(). It is $\Delta\theta$ in the official documentation and ranges from -360 to 360; being positive when the arc travels CCW and negative otherwise (i.e. is positive/negative when sweep == True/False). self.center : complex This is the center of the arc's ellipse. self.phi : float The arc's rotation in radians, i.e. `radians(self.rotation)`. self.rot_matrix : complex Equal to `exp(1j * self.phi)` which is also equal to `cos(self.phi) + 1j*sin(self.phi)`. Note on curve orientation (CW vs CCW) ------------------------------------- The notions of clockwise (CW) and counter-clockwise (CCW) are reversed in some sense when viewing SVGs (as the y coordinate starts at the top of the image and increases towards the bottom). rreN)r$r#rLrrrboolrrr:rsegment_length_hashr/rphir rot_matrix _parameterize)rrLrrrrr:rs rCrXz Arc.__init__sX||{{aFKK1$444 &++&C ,<)<<   i%[  0#' "4==)bk* rQc|j|j|j|j|j|j fS)z>Analog of the Bezier path method, .bpoints(), for Arc objects.rr[s rCapointsz Arc.apointss0zz4;; t~~tzzSWS[S[[[rQc4t|jSrS)rZrjr[s rCr\z Arc.__hash__sDLLN##rQc|j|j|j|j|j|j f}dj |S)NzEArc(start={}, radius={}, rotation={}, large_arc={}, sweep={}, end={}))rLrrrrr:r)rparamss rCr`z Arc.__repr__sL**dkk4==..$**dhh89228&&B CrQcdt|tsy|j|jk(xr|j|jk(xrj|j|jk(xrO|j |j k(xr4|j |j k(xr|j|jk(Srb)rTrYrLr:rrrrrcs rCrez Arc.__eq__s%%zzU[[(PTXX-BP u||+P /P%//1P7;jjEKK6O PrQc:t|tstS||k( SrS)rTrYrgrcs rCrhz Arc.__ne__s%%! !5=  rQc& |jj}|jj}||z}||z}d|jz |j|j z zdz }|j|j}}||z}||z} ||z | |z z} | dkDrK|j r4|t| z}|t| z}|d|zz|_||z}||z}n td|| z||zz} ||z| z | z } tj| drdn t| } |j|jk(r| ||z|z d|z|z|z z z}n| ||z|z d|z|z|z z z}td|jz|z|j|j zdz z|_||jz |z d||jz z|z z}| |jz |z d| |jz z|z z}tj |jdddtj |jddzz}tj |jdddtj |jddzz}|jdkDr$t#t%|j|_nR|jdkr%t#t%|j |_n|jdkDrd|_nd|_|j|jz|j|jzz }|j|jz|j|jzz}tj |jddtj |jddz}|dkDrt#t%||_ne|dkrt#t%| |_nE|j|jz|j|jzzdkDrd|_nd|_|js%|j(dk\r|xj(dzc_y|jr&|j(dkr|xj(dz c_yyy) Nrr'rezNo such elliptic arc exists.rrh)rr$r#rgrLr:rr rrrurrrrfrclipracosthetadelta)rrrrx_sqdry_sqdzp1x1py1px1p_sqdy1p_sqd radius_checktmpradicandradicalcpu1u2det_uvacosands rCrhzArc._parameterizes[[   [[  BB 4::#89!;88SXXSc'c'  76>: ! $$d<((d<(( 2b5j BB !?@@Wnvg~-6MC'3.zz(A.!DN >>TZZ '2c6"9r"uSy|34B"S&)beCil23B"TXX+&r)TZZ$((-BA,EE BGGmR "cBGGm"4R"7 7dRWWnb 2tbgg~#6r#9 9WWRWWb! $r"''"''2q*A'A A WWRWWb! $rBGGBGGR,C'C C 77Q; bgg/DJ WWq[!$rww-00DJww{ ! 277277?2''"''/BGGBGGO3''',,A.r11MM A: g/DJ aZ!$w-00DJwwrww014 ! zzdjjAo JJ# J ^^ a JJ# J!0^rQc|j||jzztzdz }|jj}|jj }|j j}|j j }||zt|z||zt|zz |jjz}||zt|z||zt|zz|jj z}||dzzS)Nrqre) rurvrrgr$r#rr r r) rrlrcosphisinphirrrrs rCrz Arc.point}sa l*B.s2%%%% [[   [[   vIc%j 2f9SZ#7 7$++:J:J J vIc%j 2f9SZ#7 7$++:J:J J1R4xrQcd}tj||jddrytj||jddry|jdk7r t d||j z }t|j|jz|j|jzz}t|jj|jj}t|jj|jj}||krtj||sy||kDrtj||sy|j}|j}|j|jz} t|j| } t|j| } ||j jz |jjz } | dkDrd} n| dkrd} tt!| } | | kr | d z } | | kr | | kDr | d z} | | kDr d| z}|| kr |d z }|| kr || kDr |d z}|| kDr | |jz |jz }||jz |jz }||j jz |jjz }|dkDrd}n|dkrd}tt#|}|| kr |d z }|| kr || kDr |d z}|| kDr d |z }|| kr |d z }|| kr || kDr |d z}|| kDr ||jz |jz }||jz |jz }d}tj||r ||zd z }n^tj||r ||zd z }n?tj||r ||zd z }n tj||r ||zd z }ny|dk\r|dkr|Sy) zIf the point lies on the Arc, returns its `t` parameter. If the point does not lie on the Arc, returns None. This function only works on Arcs with rotation == 0.0c||kxr||k\SrSr)rrvals rCin_rangez Arc.point_to_t..in_ranges3J0SCZ 0rQrrrrz0Arc.point_to_t() only works on non-rotated Arcs.Nggv@rq@)rrurLr:rrrr r$r#rrrrurvrrtasin)rrrrdistance_from_center min_radius max_radiusrr end_angle min_angle max_angleacos_arg x_angle_0 x_angle_1t_x_0t_x_1asin_arg y_angle_0 y_angle_1t_y_0t_y_1rls rCrzArc.point_to_ts  1 ::eTZZc = ZZtxxc = ==C OP P DKK #QVVaff_!&&$IJ))4;;+;+;< ))4;;+;+;< : -rzzBVXb7c : -rzzBVXb7c JJ JJJJ+  I.  I.  (((DKK,<,<< c>H _HDN+ )#  I)#)#  I)#9$ )#  I)#)#  I)#TZZ'4::5TZZ'4::5 (((DKK,<,<< c>H _HDN+ )#  I)#)#  I)#)O )#  I)#)#  I)#TZZ'4::5TZZ'4::5  ::eU ##%A ZZu %#%A ZZu %#%A ZZu %#%A  H18HrQc@d|jz ||jz zS)a[Isometry to a centered aligned ellipse. This is an isometry that shifts and rotates `self`'s underlying ellipse so that it's centered on the origin and has its axes aligned with the xy-axes. Args: z (:obj:`complex` or :obj:`numpy.ndarray[complex]`): a point to send through the above-described isometry. Returns: (:obj:`complex` or :obj:`numpy.ndarray[complex]`) The point(s) f(z), where f is the above described isometry of the xy-plane (i.e. the one-dimensional complex plane). rrgr)rrs rC centerisoz Arc.centerisos $//!A O44rQc:|j|z|jzS)z(The inverse of the `centeriso()` method.r)rzetas rC icenterisozArc.icenterisost#dkk11rQc|j|}t|t|}}||jjz d|z|jjz zS)zASimilar to the `centeriso()` method, but maps to the unit circle.re)rr$r#r)rrrrrs rC u1transformzArc.u1transformsN~~a Dz4:1!!!BqD)9)9$999rQct|}t|}||jjz||jjzz}|j|z|jzS)z*The inverse of the `u1transform()` method.)r$r#rrgr)rrrrrs rC iu1transformzArc.iu1transformsT J J dkk 4;;#3#3!3 3q 4;;..rQrrc $d|cxkrdkrnJd|cxkrdksJJ|dk(r|dk(rt}jj|k7ri|_tr'tfd|||dd_jSt ||j |j |||d_jStrtfd|||ddSt ||j |j |||dS)aComputes the length of the Arc segment, `self`, from t0 to t1. Notes: * The length of an elliptical large_arc segment requires numerical integration, and in that case it's simpler to just do a geometric approximation, as for cubic bezier curves. rrc8tj|SrSrHrIs rCrzArc.length..5s3ts?S;TrQrJrKc8tj|SrSrHrIs rCrzArc.length..=sC(<$=rQ)rZrerNrr/r)rrPr@r2r3hs` rCr7z Arc.length&s-B|!|,,R 1 ,, ,, 7rQwT A''/43K3Kq3P+,("*./T/12e4+QQR+TD' && &+9r2tzzRT~9=BPY[\+^D'&& & =r2$D2235 5"$B 2 2"'A7 7rQc$t||||||S)a8Approximates the unique `t` such that self.length(0, t) = s. Args: s (float): A length between 0 and `self.length()`. Returns: (float) The t, such that self.length(0, t) is approximately s. For more info: See the inv_arclength() docstring. r=rrs rCrz Arc.ilengthCsT1E&'02 2rQc.|rJ|j|jk(xr/t|jd|jdz |kS|j|jk(xr/t|j d|j dz |kSrsrrs rCryzArc.joins_smoothly_withSrrQct|j||jzz}t|j}|jj }|jj }|jtzdz |z}|dzdk(rs|dkDrn|t|zt|z|t|zt|zz d|t|zt|z|t|zt|zzzzS|dzdk(rs|| t|zt|z|t|zt|zz d| t|zt|z|t|zt|zzzzzS|dzdk(rs|| t|zt|z|t|zt|zzd| t|zt|z|t|zt|zz zzzS|dzdk(rq||t|zt|z|t|zt|zzd|t|zt|z|t|zt|zz zzzStd) rrqr)rrerr'r6r) rrurvrrr$r#rr r r)rrlrArrfrrrGs rCrzArc.derivativeasd Qtzz\12dmm$ [[   [[   ZZ]3  " q5A:!a%c#h;s5z)Bs3xKE ,BBR3s8 CJ&CHSZ)??FAA A UaZrc#c(l3u:-3s8 CJ0FFCH SZ'"SX+c%j*@@JBBC C UaZrc#c(l3u:-3s8 CJ0FFCH SZ'"SX+c%j*@@JBBC C UaZbSk#e*,r#c({3u:/EE3s8 CJ&CHSZ)??IAAB B>? ?rQc@|j|}|t|z S)zwreturns the unit tangent vector of the segment at t (centered at the origin and expressed as a complex number).)rrrs rCrzArc.unit_tangentxs q!CI~rQc*d|j|zSrrrs rCrz Arc.normal~rrQct||Srrrs rCrz Arc.curvaturerrQct|j|j|j|j|j |j S)z?returns a copy of the Arc object with its orientation reversed.)rYr:rrrrrLr[s rCrfz Arc.reverseds6488T[[$--zz>4::/ /rQcd}|jdkDr|||j}n|||j}||jz |jz S)aZConverts phase to t-value. I.e. given phase, psi, such that -np.pi < psi <= np.pi, approximates the unique t-value such that `self.u1transform(self.point(t))` equals `np.exp(1j*psi)`. Args: psi (float): The phase in radians. Returns: (float): the corresponding t-value. c^t|dtzz}|dz}||dzz }||kr|dz }|S)Nr'rr)rr)radsdomain_lower_limitrrGs rC_degzArc.phase2t.._degsD41R4=)D#c)A AGOD(( KrQr)r)rvru)rpsirrs rCphase2tz Arc.phase2tsL  ::> ;D ;Dtzz!4::--rQc ^jdk(r4ttr#jj}jj }tj jz jjz }|j}|djdk(rD|dj}|g}d||z||zz z } | dkrgS| dk(rdg} n|t| z} | | g} n|dj |djz } | |djz|dj z}||z| z| z||zz} | ||zz } | dkrgS||zt| z}||z| z|z |z| z }||z| z|z |z | z }|g}||k7r|j||| z}||z|z|z| z }||z|z|z | z }|g} ||k7r| j|g}|D]c}| D]\}t||jz}j|}|dk(r3j|}|dk(rJ|j||g^e|Strtj j#j}t |dzt |dzz}t%|dz Dcgc]}d|cxkrdksnn|}}|Dcgc]"}j't)||$}}t+||Dcgc]\}}d|cxkrdksnn||fc}}Stt,r[k7sJddl} jdk(rujjjj k(rGjdk(r7jjjj k(r jj}!jj}"j}#j}$t1|#|$z }%g}&|%|!|"zkDrn.|%t1|!|"z krntj2|%dddr{tj2|!|"ddrad }'|'j s9|'js&|'j s|'jrgSj j k(r*j4j4k7r|&jd j jk(r*j4j4k(r|&jd jj k(r*j4j4k(r|&jd jjk(rj4j4k7r|&jd ntj2|%|!|"zddrTt|#|$}|j7|!|%z }|&jj|j|fntj2|%t1|!|"z ddrkt|#|$}|!}(|!|"kDrt|$|#}|"}(|j7|( |%z }|&jj|j|fnt9|!dt9|"dz t9|%dzd|%zz }tt9|!dt9|dz })|#||$|#z z|%z z}*|*j|)|$j |#j z z|%z z}+|*j|)|$j |#j z z|%z z },|*j |)|$j|#jz z|%z z }-|*j |)|$j|#jz z|%z z}.t|+|-}/t|,|.}0|&jj|/j|/f|&jj|0j|0fg}1|&D]t}|d}2|2 |2dks|2dkDr|d}| |dks|dkDr'tj2j7|2j7|ddsJ|2|f}3|1j|3v|1St;j=j=}4t?|4||}1tA|1dkDrfd}5|1jC|5tEdtA|1dz D]F}6t1|1|6d|1|6dzdz t1|1|6d|1ddz ks<|1d|1|6gcS|1d|1dgS|1StGdcc}wcc}wcc}}w)aBNOT FULLY IMPLEMENTED. Finds the intersections of two segments. returns a list of tuples (t1, t2) such that self.point(t1) == other_seg.point(t2). Note: This will fail if the two segments coincide for more than a finite collection of points. Note: Arc related intersections are only partially supported, i.e. are only half-heartedly implemented and not well tested. Please feel free to let me know if you're interested in such a feature -- or even better please submit an implementation if you want to code one.rrWrrNr'rrc|j|}|r2tj|dddstj|dddryy)NrrrrFT)rrru)rrVrls rCpoint_in_seg_interiorz,Arc.intersect..point_in_seg_interiors=NN51 ! " 1c$ G " 1c$ G#(#rQ)rr)rr)rr)rrrrr"cf|\}}tj|j|z SrSr)tpairr@rrrs rCkeyfcnzArc.intersect..keyfcns-"FBtzz"~ 0CCDDrQrrzHother_seg should be a Arc, Line, QuadraticBezier, or CubicBezier object.)$rrTrHrr$r#rLrr:r}r appendrrrWrrrr"rphaseziprYsysrrurrpowrr7rr7sortrrr)7rrrrrkrnrrx_values discriminanty_valuesrmrx_sqrtrx2y_sqrtry2r,rrmy_tother_tu1poly u1poly_mag2rlt2srt1sr@rr0r1rrrpossible_intersrlittle_rrp2x30x31y30y31p30p31intersself_trur#ridxs7`` rCr*z Arc.intersects;  MMQ Jy$$?   A   AIOODKK7y}}T[[?XZAAtyyCaDII3 !AEAE?2 !#I!Q& !sHd<00C #cT{H&aDII! )R!A$))^qtyy0: !1uqy1}Q7 *a!e4 !#IQl!33A A &/;>A A &/;>48OOB'!1uqyF*k91uqyF*k948OOB'M!A1  3A??1-Dt| '2215G$ !(($9"! y )YYt// 0@ABFv,/DL!O;K)+/:J:a1kk1:CJ=@ASr4<<fRj 12SCA+.sC=I=RALqLRH=I I  3 '$ $$  ")9)9T[[=M=M)MT]TfTfjkTkr{sCsCsHsHLUL\L\LaLasa[[%%%%**[[%%RL"$R=R"W%jjACd;"**RQSZ]dhBi$2$**iH1$((IF1)//4H1)--F!  ioo5DJJ)// @T@TUV@W+XYZZ3rBw @T@TUV@W+XYRB 4s1c{BsQwOASS\C3K78AqBG}q01B''Q"''BGG*;%F1IaL#@AB &q 6#;773 #1Ivbz22MFG GgKAIs1ff'f$f) f)cddlm}m}tjdk(r t dz }d}nt jdk(r d}t dz }nijjjj}}|||z |jz}|||z |jz }fd}jjjjg}jjjjg} tddD]} ||| } ||| } d| cxkrdkr-nn*|jj| jd| cxkrdksYn\| jj| jt|} t!|t|t!| t| fS)zTreturns a bounding box for the segment in the form (xmin, xmax, ymin, ymax).r)atanr r'cj|t|zzddtzz zjz jz S)Nrrr')rrurv)angrGrs rC angle_invzArc.bbox..angle_inv s02a4Z#qt*- :DJJF FrQrEr)mathrr r rfrr rr$r#rLr:rrrrrr)rrr atan_xatan_yrrrxtremaytremarGtxtyrgs` rCrzArc.bboxsq& # txx=A TFF ]a FTF[[%%t{{'7'7BBrE(3txx=01F2b5#dhh-/0F G**//488==1**//488==1r1A61%B61%BB|!| djjn112B|!| djjn112 6{6{CKVc&kAArQcJ|jd||j|dfS)zZreturns two segments, whose union is this segment and which join at self.point(t).rr)rrs rCrNz Arc.split s%||Aq!4<<1#555rQc t|j||z zdkrd}nd}t|j||j|j ||j |j||jS)rrqrrr)rrvrYrrrrr)rrPr@ new_large_arcs rCrz Arc.cropped$ si tzz27# $ +MM4::b>$++ *$**zz"~8M8MO OrQct)zreturns the tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance, d = |self.point(t)-origin|.)_NotImplemented4ArcExceptionr0s rCr"zArc.radialrange/ s \+*rQNct|||Srrrs rCrz Arc.rotated_ rrQct||Srrrs rCrzArc.translatedf rrQc t||||Srrrs rCrz Arc.scaledk rrQc #nKt|jt|z }t|j}|jj }|jj }|j}t|j}|jj }|jj } t|} t|} t|D]]} ||z} t|tddtt|dz dzzdz zdz }t|}t|}| | z|z|| z|zz }| | z|z|| z|zz}t| }t| }|||z| zz||z| zz }| ||z| zz||z| zz}||dzz}| |dz k(r |j }| | z|z|| z|zz }| | z|z|| z|zz}|j ||zz|j ||zzdzz}|j ||zz |j ||zz dzz}t#|||||}| }`yw) z.Generates cubic curves to approximate this arcr)r6rr'r@reN)rrvfloatrurr$r#rLrrr r rrr rr r:rI)rcurvesslice_t current_trrp_startrurr cos_theta sin_thetarunext_talpha cos_start_t sin_start_t ePrimen1x ePrimen1y cos_end_t sin_end_tp2En2xp2En2yp_end ePrimen2x ePrimen2yp_c1p_c2s rCas_cubic_curveszArc.as_cubic_curveso sU$**%f 5DJJ' [[   [[  ** & [[   [[  J J vA(FLDQS'S5I11M-M)M$NQR$RSVYYEi.Ki.Ki+5Y8TTIi+5Y8TTIF IF I"y.944rI~ 7QQF"y.944rI~ 7QQFVb[(EFQJi)3b9ny6PPIi)3b9ny6PPILL59#44PYHY9Y]_8__DJJ!22uzzEIDU7UY[6[[DgtT59 9GI9sH3H5c#`Kt|jt|z }t|j}|jj }|jj }|j}t|j}|jj }|jj } t|} t|} t|D]} ||z} | |zdz }t| }t| }|||z| zz||z| zz }| ||z| zz||z| zz}||dzz}| |dz k(r |j}t|}t|}dt|z dz }||||z| z||z| zz zz}| |||z| z||z| zzzz}t|||dzz||}| }yw)z2Generates quadratic curves to approximate this arcr'rerg@rN)rrvrrurr$r#rLrrr r rrr:rJ)rrrrrrkrrucxcyrrrurmid_trr r r r  cos_mid_t sin_mid_trpxpys rCas_quad_curveszArc.as_quad_curves s$**%f 5DJJ' KK   KK  ** & [[   [[  J J vA(Fi'1,EF IF I!i-)33a)mi6OOF!i-)33a)mi6OOFVb[(EFQJE IE I3w<'3.Eeq9}y81y=9;TTUUBeq9}y81y=9;TTUUB!'2R<? ?GI#sF,F.r4)rz3tuple[complex, complex, float, bool, bool, complex]rr5r6r7rrSr))rrrrXrjr\r`rerhrhrrrrrrr`rar7rrrrrryrrrrrfrr*rrNrr"rrrrrrrQrCrYrYs"&_B\$C P! fP xt5$2: /a|?O7: -^#/@2 BG"# J@. (*R/ .>^G@ .B`6 O.+`1# 8+Z!rQrYceZdZdZdZdZdZdZdZdZ dZ d8dZ dZ dZ dZd Zd Zd Zd Zd ZdZdZdZeefdZdZddeefdZeeeefdZ dZ!dZ"dZ#dZ$dZ%e&e'fdZ(e(jRdZ(e&dZ*e*jRdZ*e&d Z+e+jRd!Z+d9d"Z,d:d#Z-d$Z.d%Z/d;d&Z0d'Z1d(Z2d)Z3dd/Z9d0Z:d?d1Z;d2Zd5Z?d6Z@dAd7ZAy)Br\z%A Path is a sequence of path segmentsFNcd|_d|_d|vr |d|_t|dk\rit |dt rEt|dk\r|d}n d|vr|d}nd}t |_|j|d|n t ||_nt |_|jr=|jdj|_ |jdj|_ nd|_ d|_ d|vr |d|_ yy) Nclosedrrr' current_posrr tree_element)_length_lengthsrr7rTstrlist _segments _parse_pathrL_startr:_end _tree_element)rsegmentskwrs rCrXz Path.__init__ s  r>X,DK x=A (1+s+x=A%"*1+K"b("$]"3K"$K!%  !k:!%h!VDN >>..+11DKr*..DIDKDI R !#N!3D  rQcxdtfd|jD}t||jfzS)Ncbt|tr|jS|jSrS)rTrYrjrK)segments rC _pointifyz Path.__hash__.._pointify s$(27C(@7??$ WgooFW WrQc3<K|]}|D]}|ywrSr).0r-rr.s rC z Path.__hash__.. s P^'Yw=OA=OA^s)tupler$rZ_closed)rptsr.s @rCr\z Path.__hash__ s5 XPT^^PPC4<T2W~3s6c,t|jSrS)r7r$r[s rCrpz Path.__len__ s4>>""rQcddjdjd|jDS)NzPath({})z, c32K|]}t|ywrS)repr)r0rs rCr1z Path.__repr__.. s<^DG^s)rjoinr$r[s rCr`z Path.__repr__ s+  OO >rQct|tsyt|t|k7ryt|j|jD] \}}||k(r yy)NFT)rTr\r7rr$)rrdrCos rCrez Path.__eq__ sN%& t9E "8DAq69rQc:t|tstS||k( SrS)rTr\rgrcs rCrhz Path.__ne__& rirQc|jy|jDcgc]}|j||}}t||_|jdk(r||_y|Dcgc]}||jz c}|_ycc}wcc}w)Nr<r)r r$r7sumr!)rr2r3eachlengthss rC _calc_lengthszPath._calc_lengths+ s << # >>#!FJ4;;Ui;@! #7| <<1 #DM=DEWTTDLL0WEDM # Fs B#Bct|jdk(r td|dk(r|jdj|S|dk(r|jdj|S|j d}t |jD]<\}}||j |z}||k\r||z ||z z }|j|cS|}>tdj||)NrzThis path contains no segments!rrrzGSomething has gone wrong. Could not compute Path.point({}) for path {}) r7r$rrrTrr! RuntimeErrorr)rr? segment_startr7r- segment_end segment_poss rCrz Path.point7 s t~~ ! #>? ? #:>>!$**3/ / #:>>"%++C0 0  '7NE7'$--*>>Kc!"]2-/1 }}[11'M8dkkloquvwwrQrrcj|||dk(r|dk(r jStdk(rdj||Sj |\}}j |\}}||k(r|j||S|j|t fdt |dz|Dz|j|zS)Nr<rr)rPr@)rPc3DK|]}|jywrS)r7)r0rrs rCr1zPath.length..Z s!L6KsS ((*6Ks )r@)rTr r7r7T2trQrr) rT0T1r2r3idx0rPidx1r@s ` rCr7z Path.lengthN s )< 7rQw<< 4yA~Aw~~~33xx|HD"xx|HD"t|Dz((B2(66J%%%,LeD1Hd6KLLMJ%%%,- .rQc$t||||||Srrrs rCrz Path.ilength] rrQcVtfdttdz DS)zLChecks if a path is continuous with respect to its parameterization.c3bK|]&}|j|dzjk((yw)rNr})r0rurs rCr1z$Path.iscontinuous..g s-P;Oa47;;$qs)//1;Os,/r)r]rrr7r[s`rC iscontinuouszPath.iscontinuousd s#P5TQ;OPPPrQc .g}d}tt|dz D]S}||j||dzt|zjk7s2|j t |||dz|dz}U|j t ||t||S)a Breaks self into its continuous components, returning a list of continuous subpaths. I.e. (all(subpath.iscontinuous() for subpath in self.continuous_subpaths()) and self == concatpaths(self.continuous_subpaths())) ) rr)rrr7r:rLrr\)rsubpaths subpath_startrus rCcontinuous_subpathszPath.continuous_subpathsi s s4y1}%AAw{{dAaC3t9#45;;;d=!A#&> ?@ !! & d=#d)<=>rQcxt|dk7sJ|jsJ|j|jk(S)z7This function determines if a connected path is closed.r)r7rdrLr:r[s rCr)z Path.isclosedz s74yA~~  """zzTXX%%rQcTt|dk7sJ|j|jk(SNr)r7rLr:r[s rC isclosedaczPath.isclosedac s%4yA~~zzTXX%%rQcr |dj}|D]}|j|k(syy#t$rYywxYw)NrTF)r: IndexErrorrL)rr:r-s rC _is_closablezPath._is_closable sH r(,,CG}}#   s * 66c\d}|r t||jxr|jS)zThe closed attribute is deprecated, please use the isclosed() method instead. See _closed_warning for more information.zThis attribute is deprecated, consider using isclosed() method instead. This attribute is kept for compatibility with scripts created using svg.path (v2.0). You can prevent this warning in the future by setting CLOSED_WARNING_ON=False.)rr3ro)rrrs rCrz Path.closed s-*  I||3 1 1 33rQcbt|}|r|js td||_y)Nz+End does not coincide with a segment start.)rdrorr3)rr;s rCrz Path.closed s,U  **,JK K rQc|js6t|jdkDr|jdj|_|jSrkr&r7r$rLr[s rCrLz Path.start s9{{s4>>214..+11DK{{rQcl||_t|jdkDr||jd_yyrkrsrr$s rCrLz Path.start s0 t~~ q &(DNN1  # !rQc|js6t|jdkDr|jdj|_|jSr9r'r7r$r:r[s rCr:zPath.end s9yyS02r*..DIyyrQcl||_t|jdkDr||jd_yyr9rwrus rCr:zPath.end s0 t~~ q %'DNN2  " !rQc, t|dk(ry|r0|jxr|j}|r|dd}n |dd}nd}|dd}d}g}d}|dj} |D]} | j} || k7s |rJ| | k(rE|rC|r || |z n| } n| } |j dj | j| jt| trU|r| j| z } n | j} |j dj | j| jn't| trT|r| j|dr|r| j| z }| j| z } n| j}| j} |j|j| j| jf}|j d j |nz|r.| j| z }| j| z }| j| z } n$| j}| j}| j} |j|j|j|j| j| jf}|j d j |nt| tr|ri| j|drV|r| j| z } n | j} | j| jf}|j d j |nG|r| j | z }| j| z } n| j }| j} |j|j| j| jf}|j d j |nt| t"r|r| j| z } n | j} | j$j| j$j| j&t)| j*t)| j,| j| jf}|j d j || j}| }|r|j ddj/|}|s|S|j1S)zReturns a path d-string for the path object. For an explanation of useSandT and use_closed_attrib, see the compatibility notes in the README.rNrFzM {},{}zL {},{})rz S {},{} {},{}zC {},{} {},{} {},{}zT {},{}z Q {},{} {},{}zA {},{} {} {:d},{:d} {},{}r4 )r7rdr)r:rLrrr$r#rTrHrIrrNrMrJrOrYrrrrrrLlower)ruseSandTuse_closed_attribrel self_closedr)rpartsprevious_segmentr:r- seg_start _seg_start_seg_end _seg_control2args _seg_control1 _seg_controlrCs rCrzPath.d s t9> ++-A$--/K97KAwH 2hllG Ii' Y#%5:K?(/(8(89(D (/(8(89(D #*;;#:(/(8(8 (/(8(8 #*;;).. 0B0B).. 0B0B$MM8==:DLL!=!6!=!=t!DEG_5 6 67GBG!7!I#*;;#:#*;;#==(--7DLL!1!1!14!89'.'B #*;;#:'. #*;;(--|/@/@$MM8==:DLL!7!7!7!>?GS)&{{Y6H&{{H++W^^-@-@((W->->)?GMM*8==(--I @9@@$GH!++K& U X  LL  HHUOq**rQc |rA|dj|jk(xr#|jd|jdk(S|dj|jk(xr#|jd|jdk(S)aPChecks if this Path object joins smoothly with previous path/segment. By default, this only checks that this Path starts moving (at t=0) in the same direction (and from the same positive) as previous stopped moving (at t=1). To check if the tangent magnitudes also match, set wrt_parameterization=True.rr)rLr:rrrvs rCryzPath.joins_smoothly_with! s 7==HLL0-T__6))!,6- -7==HLL0/T5F5F6++A.6/ /rQc|dk(rt|dz dfS|dk(ry|jd}t|jD]\}}||z}||k\r||z |z }||fcS|}!d|cxkrdksJJt)zreturns the segment index, `seg_idx`, and segment parameter, `t`, corresponding to the path parameter `T`. In other words, this is the inverse of the `Path.t2T()` method.rr)rr)r7rTrr!r)rr2r]seg_idx seg_lengthr^rls rCr\zPath.T2t. s 6t9Q;> ! 6  #,T]]#; GZjBQwVZ'z!B $<A{{{{rQc0|jt|tr|}n |j|}t |jd|}||j|z}||z |z|z}|S#t$rt |st|tsJwxYw)areturns the path parameter T which corresponds to the segment parameter t. In other words, for any Path object, path, and any segment in path, seg, T(t) = path.t2T(seg, t) is the unique reparameterization such that path.point(T(t)) == seg.point(t) for all 0 <= t <= 1. Input Note: seg can be a segment in the Path object or its corresponding index.N)rTrTrr7rrZrQr!)rrVrlrrWrXr2s rCrBzPath.t2TD s  c3 G **S/ DMM(734 #dmmG&<< = (! +m ; &s+z#s/CCC s A--(Bc|j|\}}|j|}|j|||j|zz S)areturns the tangent vector of the Path at T (centered at the origin and expressed as a complex number). Note: Bezier curves can have points where their derivative vanishes. If you are interested in the tangent direction, use unit_tangent() method instead.r)r\r$rr7)rr2rArrlrVs rCrzPath.derivative\ sE XXa[ nnW%~~a1~%cjjlAo55rQcf|j|\}}|j|j|S)areturns the unit tangent vector of the Path at T (centered at the origin and expressed as a complex number). If the tangent vector's magnitude is zero, this method will find the limit of self.derivative(tau)/abs(self.derivative(tau)) as tau approaches T.)r\r$r)rr2rrls rCrzPath.unit_tangentf s/ XXa[ ~~g&33A66rQc*d|j|zSrrrs rCrz Path.normaln rrQc|j|\}}||}tj|drb|dk7s|j|jk(rD|j |dz t |j z}|j|stdStj|drn|t |dz k7s|j|jk(rD|j |dzt |j z}|j|s tdS|j|}|j|d}|j|j} } |j|j} } t| | z| | zz | | z| | zzdzz S)zkreturns the curvature of this Path object at T and outputs float('inf') if not differentiable at T.rrinfr'rg?) r\rrur:rLr$r7ryrrr$r#r) rr2rrlrVprevious_seg_in_pathnext_seg_in_pathrrrrrrs rCrzPath.curvaturer sVXXa[ 7m ::a A4::1E#'>>1DNN 33$5 **+?@U|# ZZ1 7c$i!m#;#'88tzz#9#~~1DNN 33 5 #77<U|# __Q ooa1o%"''B88SXXS2c6BsF?#RURU]S$888rQcd}fd}|jsJg}|D]/}t|tr |||z }|j|1|t |S)atFind area enclosed by path. Approximates any Arc segments in the Path with lines approximately `chord_length` long, and returns the area enclosed by the approximated Path. Default chord length is 0.01. If Arc segments are included in path, to ensure accurate results, make sure this `chord_length` is set to a reasonable value (e.g. by checking curvature). Notes ----- * Negative area results from clockwise (as opposed to counter-clockwise) parameterization of the input Path. To Contributors --------------- This is one of many parts of `svgpathtools` that could be improved by a noble soul implementing a piecewise-linear approximation scheme for paths (one with controls to guarantee a desired accuracy). cd}|D]k}t|j}t|jj}||z}|j }||d|dz z }m|S)Nrr)r$r}r#rinteg)r_ area_enclosedrVrr integrandintegrals rCarea_without_arcsz$Path.area..area_without_arcs snM$#((*%++-bD $??,!x{!::  ! rQc &tt|jz }tjdd|dzDcgc]}|j |}}t |Dcgc]}t||||dzc}Scc}wcc}w)z-Find piecewise-linear approximation of `seg`.rr)rrr7rlinspacerrrrH)seg_ num_linesrlr4ru chord_lengths rC seg2lineszPath.area..seg2lines sD!=>?I*,++aIaK*HI*HQ4::a=*HCI49)4DE4DqDQQqS*4DE EJEs B *B)r)rTrYrr\)rrrrbezier_path_approximationrVs ` rCareaz Path.area sh. ! F }}$&!C#s#)Ys^;))005  !'@!ABBrQc |}t|tr|n t|}||k7sJg}|D]n}|D]g}|r |r |dccS|j||D]B\} } |j|| } |j|| } |j | || f| || ffDip|r|r|dS|rt t |dD cgc]\} }}|j|}}} }g}tt|D]H}t|dzt|D]+}t||||z |ks|j |-Jt|Dcgc] \}}||vr| }}}|Scc}}} wcc}}w)aTFinds intersections of `self` with `other_curve` Args: other_curve: the path or path segment to check for intersections with `self` justonemode (bool): if true, returns only the first intersection found. tol (float): A tolerance used to check for redundant intersections (see comment above the code block where tol is used). Returns: (list[tuple[float, Curve, float]]): list of intersections, each in the format ((T1, seg1, t1), (T2, seg2, t2)), where self.point(T1) == seg1.point(t1) == seg2.point(t2) == other_curve.point(T2) Scope: If the two path objects coincide for more than a finite set of points, this code will iterate to max depth and/or raise an error. r)rr) rTr\r*rBrr#rrrrr7rr)r other_curve justonemoderpath1path2intersection_listseg1seg2r@rr^T2_T1_seg1_t1r4indices2removeind1ind2indinters rCr*zPath.intersect s()+t< ${BS~~D#4,Q//"nnTsn;FB4,B4,B%,,r4nr4n-MN< ,$Q' ' ;?EV@W;XYZ;[\;[UC5;;s#;[C\Nc#h!$(CH5D3t9s4y01C7&--d36( "++Dzz&!$jj&*c$i7BxZZ% 77DFB#xx| Hf>Dzz&!$jj&*c$i7BxZZ% 7rRxDLL89H,)DLL34HBw}}$&899#263t95 Q06"1b\ Q0* rAvr*AOODG,+{ Q 78rQc|rttjddf}d}t|D]<\}}|j |\}}|d|dkr||fz}|d|dkDs7||fz}>||fS)zreturns the tuples (d_min, t_min, idx_min), (d_max, t_max, idx_max) which minimize and maximize, respectively, the distance d = |self[idx].point(t)-origin|.N)rNNr)rrrrr") rrr global_min global_maxrrVrrs rCr"zPath.radialrange@ s %% %&&$-J(J )$ 141H.!!$z!}4!/7*!>%T> 2 ZZ]!&dD$bgg--LDBGG4Kt4K d1fd1f%C//rQc.tdz}t||z}tt|dz ddD]b}||}t |t st tt|j|z }t|j||||dzdy)z\ Iterates through this path and replaces any Arcs with cubic bezier curves. r'rrN) rrrrr7rTrYrrrrvr#rrr2r sweep_limitrCr- arc_requireds rCapproximate_arcs_with_cubicsz!Path.approximate_arcs_with_cubicst s1fcEk* s4y{B+A1gGgs+tC $6$DEFLw66|DED1Q3K ,rQc.tdz}t||z}tt|dz ddD]b}||}t |t st tt|j|z }t|j||||dzdy)z` Iterates through this path and replaces any Arcs with quadratic bezier curves. r'rrN) rrrrr7rTrYrrrrvr#rrs rCapproximate_arcs_with_quadsz Path.approximate_arcs_with_quads s1fcEk* s4y{B+A1gGgs+tC $6$DEFLw55lCDD1Q3K ,rQcNt|\}}t|dt||S)zreturns generator of segment joints I.e. Path(s0, s1, s2, ..., sn).joints() returns generator (s0, s1), (s1, s2), ..., (sn, s0) credit: https://docs.python.org/3/library/itertools.html#recipes N)rnextr)rrrks rCrz Path.joints s&4y1 Q 1ayrQc#Kd}tj|D]H}|tvr|}||dvrt|D]}|+tj |D]}|Jyw)N)r3r) COMMAND_RErNCOMMANDSrDr<findall)rpathdefcommandrtokens rC_tokenize_pathzPath._tokenize_path sn!!'*AH}*$02EK3&--a0EK1+sA$A&c " t|j|}|j|j}d}d}|rQ|dtvr+|}|j }|t v} |j}n8|4td|dt|jt|z |}t|t|kr"td|t|t||fz|dk(rJ|j } |j } t| t| dzz}  r| }n|| z }|}d}nY|dk(r-||k(s|jt||d |_|}d}n'|dk(r`|j } |j } t| t| dzz}  s| |z } |jt|| | }n|d k(r[|j } t| |j dzz}  s| |j"z } |jt|| | }nb|d k(r^|j } |j"t| dzz}  s| |j dzz } |jt|| | }n|d k(rt|j t|j dzz} t|j t|j dzz}t|j t|j dzz} s| |z } ||z }||z }|jt%|| |||}n&|d k(r|dvr|} n||z|dj&z } t|j t|j dzz}t|j t|j dzz} s ||z }||z }|jt%|| |||}nl|dk(rt|j t|j dzz}t|j t|j dzz} s ||z }||z }|jt)||||}n|dk(ry|dvr|}n||z|dj*z }t|j t|j dzz} s||z }|jt)||||}nQ|dk(rKt|j t|j dzz}t|j }t|j }t|j }t|j t|j dzz} s||z }|j"dk(s|j dk(rNt-dj/||||||dj/||z|jt||n|jt1|||||||}|rQ|S)NrzUnallowed implicit command in z , position zLInvalid path string: command '%s' expects %d values but only %d remain in %rr+rer,r4Tr-r.r/r0)r/r0r1r2)r1r2r3rzyReplacing degenerate (zero radius) Arc with a Line: Arc(start={}, radius={}, rotation={}, large_arc={}, sweep={}, end={})z --> Line(start={}, end={}))r#rrFr$rpop UPPERCASEupperrr7rNCOMMAND_NUM_ARGSrrrHr3r#r$rIrNrJrOrrrY)rrrrelementsr) start_posr last_commandabsoluterrr?rMrNr:rOrrarcrs rCr%zPath._parse_path s  ++G45>> |x'& ",,."i/!--/?$W]]_!5H !E&GHH& 8}/88 "C%,.>w.G%(]GF="=>> #~LLNLLNAhqB."%K3&K ( C#y0OODi$@A# ' CLLNLLNAhqB.;&C[# 67! CLLNAh!1!1B!66;+++C[# 67! CLLN!&&qB6;++b00C[# 67! C 053H23MM 053H23MMHLLN+eHLLN.Cb.HH +H +H;&C K8S QR! C z1 +H +[88B<;P;PPH 053H23MMHLLN+eHLLN.Cb.HH +H;&C K8S QR! C /% 2G"2LLHLLN+eHLLN.Cb.HH{*G;&C Wc JK! C z1*G *K7(2,:N:NNGHLLN+eHLLN.Cb.HH;&C Wc JK! Cx||~.x||~1F1KK 0HLLN+hlln-HLLN+eHLLN.Cb.HH;&C;;!#v{{a'7--3V#VXsE3.H"F;4 56 OODc$:;OOK3sKM! _brQr)FFFrr6)r)FrFrSr)g?)rN)Brrr__doc__r3r&r'elementrmetarXr\rmr<r>r@rBrDrfrpr`rerhr`rarTrr7rrrrrrdrhr)rlropropertyCLOSED_WARNING_ONrsetterrLr:rryr\rBrrrrrr*rrr"rrrrrrrrr%rrQrCr\r\ s/G F DGI D4:+%+ ).+  #>! #/:J Fx.a|?O . -^#/@2Q "& & 1 4 4 ]]   \\))   ZZ(( e+N /,067(9@/Cb4!l&;z*"1# 80& F E  rQr\r)TFrSr)mr __future__rrecollections.abcr ImportError collectionswarningsroperatorrnumpyr itertoolsr functoolsrr r r r r rtrrrrrrrrrrrrscipy.integraterrNbezierrrrrrr misctoolsr polytoolsr r!r"r#r$ basestringr" NameErrorsetrrrcompilerr<r;r8rDrar`USE_SCIPY_QUADrrrrrrrrrPrWrZr`rcrorvrxr{rrrrrrrrr rr%r'r-r/rArOobjectrHrJrIrYr\rrQrCrs] # ,/$$$$;;$O (($II C % &   <RZZ3 4 2::A B bjj! rzz)$ 2    IJ  )* :H B 240 ) ' :"#H<H$-H`9Hx#L!H.0# # &1A*#0%1BA=L.F86F8RJ8fJ8ZF8&F8Rd&dN!i?imM,++,"O  s/FF,F6 F)(F),F36F?>F?