hFdZddlmZddlZ 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;ejxdZ=ejxdZ>dZ?dZ@d ZAdZBdZCdZDdZEd ZFeGdZHdZIdZJdZKdZLdZMdZNd ZOd!ZPd"ZQd#ZRd>d$ZSd?d%ZTd&ZUd@d'ZVd(ZWdAd)ZXd*ZYd+ZZd>d,Z[d>d-Z\d.Z]d/Z^d0Z_e@e?dfd1Z`eDeEeCeBfd2Zad3ZbGd4d5ecZdGd6d7ecZeGd8d9ecZfGd:d;ecZgGd<d=eZhy#e$r ddlmZY`wxYw#d Z&Y xYw#e8$rYwxYw)BzThis 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 MZLHVCSQTAz([MmZzLlHhVvCcSsQqTtAa])z([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?-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)N)r*r,r+)lenLine CubicBezierQuadraticBezier)bpointsstartendcontrol1control2controls m/home/developers/rajanand/mypropertyqr-fmb-refixing-v2/venv/lib/python3.12/site-packages/svgpathtools/path.pybezier_segmentr8Rs 7|q sE3 W )0&x35(Hc:: W %wugs337|y(((cjt|txs"t|txst|tSN) isinstancer.r0r/segs r7is_bezier_segmentr?`s/ sD ! ) sO , ) sK (*r9c<t|xst|tSr;)r?r<Arcr=s r7is_path_segmentrBfs S ! 9ZS%99r9cXt|txrttt|S)zXChecks that all segments in path are a Line, QuadraticBezier, or CubicBezier object.)r<Pathallmapr?)paths r7is_bezier_pathrHjs# dD ! Gc#.?*F&GGr9cLt|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).)rD) list_of_pathsrGr>s r7 concatpathsrKps) -@$4@C#@#@ 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.?)r.rDreversed)xminxmaxyminymaxbtrls r7 bbox2pathrWvs TBtG^TBtG^,A TBtG^TBtG^,A TBtG^TBtG^,A TBtG^TBtG^,A 1ajjlAJJL 11r9c 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()`.rrDranger-r.pointsis r7polyliner^sL  Vq13vay&1+.3 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()`.rrYr[s r7polygonr`sR  V-/vay&!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.rr,r*>r*r,r+N)r-r/r0r.)r1orders r7bpoints2bezierrcsY L1 E zG$$ !(( !W~7|y(((r9c6t|}|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.)rrc)polyreturn_bpointsr1s r7poly2bezrgs! %Gg&&r9cTt|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)r?r1r)bezrirjs r7bez2polyrls,kkm S,:+8 ::r9c|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) enumeratejointsr3r2r-rD)rGtransformationr>transformed_segsr]sasbs r7transform_segments_togetherrts7;<s+<< /R 8B 66RXX &6AT7J&K&Q&Q Q  #R ! "" =sBc*fd}.t|tr |jn|jdt|trfd}t ||St |r-t|jDcgc] }|| c}St|trb||j}||j}|jz}t||j||j|j|Stdcc}w)zReturns curve rotated by `degs` degrees (CCW) around the point `origin` (a complex number). By default origin is either `curve.point(0.5)`, or in the case that curve is an Arc object, `origin` defaults to `curve.center`. cDtdtz|z zzS)NrM)rr)zdegsorigins r7 rotate_pointzrotate..rotate_points%2gdm#$a&j1F::r9g?c t|S)Nryrotate)r>rxrys r7zrotate..sVCf%Er9radiusrotation large_arcsweepr3RInput `curve` should be a Path, Line, QuadraticBezier, CubicBezier, or Arc object.)r<rAcenterpointrDrtr?rcr1r2r3rrrr TypeError) curverxryrzrpbpt new_startnew_end new_rotations `` r7r~r~s ;~ eS !\\F[[%F%E*5.AA 5 !EMMOLS|C0LMM 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|Sr; translate)r>z0s r7rztranslate..YsB%7r9rr)r<rDrtr?rcr1rAr2r3rrrrr)rrrprrrs ` r7rrs%7*5.AA 5 !5==?CCsRxCDD 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 rMcP|zS|jz|jzzSr;)r$r#)rwisysxsys r7_scalezscale.._scale s, :a4K!&&y3qvv:%%r9ct|Dcgc] }| }}|dxxz z cc<t|Scc}w)N)rlrg)rkcprrys r7 scale_bezierzscale..scale_beziersD ( .1VAY . . "&.(({ /sAc t|Sr;scale)r>ryrrs r7rzscale..sU3B%?r9r2rrrrr3zG For `Arc` objects, only scale transforms with sx==sy are implemented. r) r<rDrtr?rAr2rrrrr3 Exceptionr)rrrryrrprrs ``` @@r7rrs zee&  %?*5.AA 5 !E"" E3  :rRv!56? o %!&"[[uyy612V; = ==> >GH Hr9c 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/| \}}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 StAd cc}w)z@Transforms the curve by the homogeneous transformation matrix tfr,c`tj|jg|jgdggS)N?nparrayr$r#)rs r7to_pointztransform..to_point.&xx!&&AFF8cU344r9c`tj|jg|jgdggS)Nr)rws r7 to_vectorztransform..to_vector1rr9cN|jdd|jdzzS)NrrMr)item)vs r7 to_complexztransform..to_complex4s!vvay2q >))r9ct|Sr;) transform)r>tfs r7rztransform..8rr9r*rrNrTrrrrr3autoscale_radiusr)!rEreyeravelr<rDrtr?rcr1dotrAr2r3rr$r#rlinalginvrmatmulTeigr complexrarctan2r.rrrr)rrrrrrprrrrx2ry2QinvTDeigvalseigvecsrxry new_radiusxeigvecrot new_sweeps ` r7rr(s} B"&&)O " " $% 55*%7*5.AA 5 !(- 9#$ *"&&!*=>9: : E3 rvvhu{{&;<= RVVHUYY$789ll1$ll1$ HHquaj1ae*- .yy}}R2A2Y' 299tvvq$/ 099==+ $ $ $ $R_ !Q$-jjGAJ ;< ??a :??a#7 7+ +!uQx"Q%("c)!KK % O yenns>R!& w(,. . GH HI9s?$KcR|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) = {}) derivativeabsZeroDivisionErrorFloatingPointErrorrederivr$r#csqrtr ValueErrorformat) r>rTdseg unit_tangent dseg_polydseg_abs_squared_polybefaftmess r7bezier_unit_tangentrds9 >>! 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*nraise)invalidr,r) rr$r#rseterrrr rrrerr )selfrTuse_infdzddzdxdyddxddy old_np_seterrkappardpddpf2g2lim2s r7segment_curvaturersl  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 Sr;rr)tauryr>s r7_radiusz#bezier_radialrange.._radiuss399S>F*++r9r*rrkey) rer$r#r"rNotImplementedErrorminrmax) r>ryreturn_all_global_extremarshifted_seg_poly r_squared extremizersrTextremaseg_global_minseg_global_maxs `` r7bezier_radialranger s,xxzF*%&!+%&!+,Ia&;y'899K(341 A4G4 !!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 radialrangeptrGs r7closest_point_in_pathrs   B  ""r9c*|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 r7farthest_point_in_pathrs   B  ""r9c|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)isclosedrDr. intersectr-)roptrG intersectionss r7path_encloses_ptrs@ ==??b#'11$7M =Ar9c ||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)rr2r3 start_point end_pointerror min_depthdepthmid mid_pointlength first_half second_halflength2s r7rrs 3;/C C I [( )FY,-Ji)+,K;&G&5 ei&7  ueS+y$i8uc3 9$i88 9 Nr9c |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.rrrz)s is not in interval [0, curve.length()].rs_tolmaxitsrrr*)t1rrzQt 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.)r!rr<rDrn inv_arclengtht2Tr.r0r/rArrrrr)rsr(r)rr curve_lengthr> seg_lengthslsumklen_krTt_uppert_lower iterations_ts r7r+r+s <t0r* cropped_segpt1 trimmed_segt1_adjs r7r9r9Bs 7N7 QwiimA&   qiimA&  iim"#r1- ((-a03!+q&9 r9ceZdZdZddZdZdZdZdZdZ ddZ d Z d Z d d Z eeeefd ZdZddZd!dZd"dZd"dZdZdZd"dZdZdZdZdZdZd"dZ dZ!d#dZ"y )$r.c ||_||_yr;r2r3)rr2r3s r7__init__z Line.__init__Zs r9cDt|j|jfSr;)hashr2r3rs r7__hash__z Line.__hash__^sTZZ*++r9c<d|jd|jdS)Nz Line(start=, end=)rArEs r7__repr__z Line.__repr__as+/::txx@@r9ct|tsy|j|jk(xr|j|jk(SNF)r<r.r2r3rothers r7__eq__z Line.__eq__ds4%&zzU[[(BTXX-BBr9c:t|tstS||k( Sr;)r<r.NotImplementedrMs r7__ne__z Line.__ne__i%&! !5=  r9c(|j|Sr;r1rrs r7 __getitem__zLine.__getitem__n||~d##r9cy)Nr*rrEs r7__len__z Line.__len__qr9cB|rO|j|jk(xr4tj|j d|j dS|j|jk(xr4tj|j d|j dSaJChecks if this segment joins smoothly with previous segment. By default, this only checks that this segment 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.rrr2r3riscloserrrpreviouswrt_parameterizations r7joins_smoothly_withzLine.joins_smoothly_witht ::-<"**"H$7$7$:3< <::-@"**!!!$h&;&;A&>3@ @r9cX|j|jz }|j||zzS);returns the coordinates of the Bezier curve evaluated at t.r3r2)rrTdistances r7rz Line.points'88djj(zzHQJ&&r9c.|j|Sz*Faster than running Path.point many times.rertss r7r\z Line.pointstyy{2r9NcRt|j|jz ||z zS)z9returns the length of the line segment between t0 and t1.)rr3r2)rr:r*rrs r7r!z Line.lengths#488djj()2b511r9c$t||||||SzReturns a float, t, such that self.length(0, t) is approximately s. See the inv_arclength() docstring for more details.r'r+rr-r(r)rrs r7ilengthz Line.ilengthT1E&'02 2r9c2|j|jfSz1returns the Bezier control points of the segment.rArEs r7r1z Line.bpointsszz488##r9ct|j}|d|dz |dg}|r|Stj|S)z(returns the line as a Polynomial object.rrr1rpoly1dr return_coeffsrcoeffss r7rez Line.polys> LLNQ4!A$;!% M99V$ $r9c|j|jk7sJ|dk(r|j|jz S|dkDrytd)/returns the nth derivative of the segment at t.rrn should be a positive integer.)r3r2r)rrTrs r7rzLine.derivativesHxx4::%%% 688djj( ( U>? ?r9c|j|jk7sJ|j|jz }|t|z S)z-returns the unit tangent of the segment at t.)r3r2rrrTrs r7rzLine.unit_tangents8xx4::%%%xx$**$CI~r9c*d|j|zSz>returns the (right hand rule) unit normal vector to self at t.yrrrTs r7normalz Line.normal4$$Q'''r9cy)z8returns the curvature of the line, which is always zero.rrrs r7 curvaturezLine.curvaturesr9cBt|j|jS)z@returns a copy of the Line object with its orientation reversed.)r.r3r2rEs r7rNz Line.reversedsDHHdjj))r9ct|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.)r<r.r0r/r1r$rrr#r3r2rr_rrArrDr)r other_segtoleobrsarSrddenomr*t2t2t1ss r7rzLine.intersects i$!E F"+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  2wR  "+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  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+01RRH1 1  ; /0DAE+01RRH1 1  3 '''-E+01RRH1 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).)rr2r$r3rr#)rrOrPrQrRs r7bboxz Line.bboxs4::??DHHMM24::??DHHMM24::??DHHMM24::??DHHMM2T4%%r9cdtj||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)rr_r2r3rer#r$)rrrrTs r7 point_to_tzLine.point_to_t s ::eTZZad ; ZZtxxad ; IIKQqT\QqT ! ::affa affm!&&C-66Mr9cVt|j||j|Sireturns a cropped copy of this segment which starts at self.point(t0) and ends at self.point(t1).)r.rrr:r*s r7croppedz Line.cropped"s!DJJrNDJJrN33r9c||j|}t|j|t||jfSzZreturns two segments, whose union is this segment and which join at self.point(t).)rr.r2r3)rrTrs r7r8z Line.split's2ZZ]DJJ#T"dhh%777r9c 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#r2r3rr)rrykwargsxyp0p1x0y0x1y1rr numerator denominatorrTd0d1dts r7r zLine.radialrange-sN{{FKK1TXXB"''277BGG;BBb"r'B!#q2vq2v!>R"r'@Q;  # q919BK BK DJJqMF*+B BwAwQ''7RG# #f%s2;'7BBwAwQ''7RG# #r9ct|||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`.r|r}rrxrys r7rotatedz Line.rotatedQ dD00r9ct||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 r7 translatedzLine.translatedXr""r9c t||||Sz?Scale transform. See `scale` function for further explanation.)rrryrrrrrys r7scaledz Line.scaled]TbR77r9returnintFrrNN)Nrr;N)#__name__ __module__ __qualname__rBrFrJrOrRrWrZrcrr\r! ILENGTH_S_TOLILENGTH_MAXITS ILENGTH_ERRORILENGTH_MIN_DEPTHrtr1rerrrrrNrrrrr8r rrrrr9r7r.r.Ys,AC ! $ @' 2 -^#/@2$%@ (*8At&.4 8 "$H1# 8r9r.ceZdZdddZdZddZdZdZdZdZ d Z d d Z d!d Z d Z d Zd"dZeeeefdZdZd#dZd$dZdZdZdZdZd%dZdZdZdZd#dZ d&dZ!dZ"d'dZ#y)(r0Nr!r1cB||_||_||_ddd|_y)Nr)r2r3r6 _length_info)rr2r6r3s r7rBzQuadraticBezier.__init__fs&  (,=r9cZt|j|j|jfSr;)rDr2r6r3rEs r7rFzQuadraticBezier.__hash__ns TZZtxx899r9cVd|jd|jd|jdS)NzQuadraticBezier(start=z , control=rHrIr2r6r3rEs r7rJzQuadraticBezier.__repr__qs JJ dhh0 0r9ct|tsy|j|jk(xr4|j|jk(xr|j|jk(SrL)r<r0r2r3r6rMs r7rOzQuadraticBezier.__eq__usM%1zzU[[(.TXX-B.  - .r9c:t|tstS||k( Sr;)r<r0rQrMs r7rRzQuadraticBezier.__ne__{s%1! !5=  r9c(|j|Sr;rUrVs r7rWzQuadraticBezier.__getitem__rXr9cy)Nr,rrEs r7rZzQuadraticBezier.__len__r[r9c|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_warningr<r0r2r3r6rra warning_ons r7is_smooth_fromzQuadraticBezier.is_smooth_fromsp  ( ) h 0JJ(,,.9\\DJJ. x'7'779 :<<4::- -r9c.|rJ|j|jk(xr/t|jd|jdz |kS|j|jk(xr/t|j d|j dz |kSr]r2r3rrrrrarbrs r7rcz#QuadraticBezier.joins_smoothly_with ::-F#"X%8%8%;;3=@E3F F::-J#!!!$x'<'AR AaffkAFFaK/0BWB1qvv{*BR=DGdai'E2a<"r'1B67G2a<"r'1B67GRBI.8RBI.8:Hdg%dg(==R 3x=01A 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. .Hr9c$t||||||Srqrrrss r7rtzQuadraticBezier.ilengthrur9cH|j|j|jfSrwrrEs r7r1zQuadraticBezier.bpointsszz4<<11r9c|j}|dd|dzz |dzd|d|dz z|df}|r|Stj|S)z-returns the quadratic as a Polynomial object.rr*rryr{s r7rezQuadraticBezier.polys] LLNA$1Q4-!A$&1Q4!A$;1> M99V$ $r9c|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*rrr1rrrTrrs r7rzQuadraticBezier.derivatives LLN 6qtad{QU+qtad{Ao=> > !VadQqtVmad*+ + U>? ?r9ct||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 r7rzQuadraticBezier.unit_tangent #4++r9c*d|j|zSrrrs r7rzQuadraticBezier.normalrr9ct||Sz*returns the curvature of the segment at t.rrs r7rzQuadraticBezier.curvature q))r9ct|j|j|j}|jdrA|j|_|j|j|jf|jd<|S)zSreturns a copy of the QuadraticBezier object with its orientation reversed.r!r1)r0r3r6r2r)rnew_quads r7rNzQuadraticBezier.reversedsd#488T\\4::F   X &$($5$5H !$,, 04H ! !) ,r9ct|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_deCrrr<r.r0r/r1r$rrr#rr!rrArrDr) rrrrrrsr rrr*s r7rzQuadraticBezier.intersects i$!E F"+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  2wR  "+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  2wR  i &/i@ @  ? 39$ $$ y/?/?/ABM'i6C,/> > ; / y/?/?/ABM'i6C,/> > 3 '''-E+01RRH1 1  4 ($% %?@ @C71 71(2sH.H3/H8H=6Ict|SrrrEs r7rzQuadraticBezier.bboxGs#4((r9c\t|j|\}}t|t|fSr)rr1r0rrTbpoints1bpoints2s r7r8zQuadraticBezier.splitLs0*$,,.!<()?H+EEEr9c(tt|||Sr)r0r9rs r7rzQuadraticBezier.croppedRs D"b 9::r9ct|||Szreturns the tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance d = |self.point(t)-origin|.)rr rryrs r7r zQuadraticBezier.radialrangeWs"$*CE Er9ct|||Srr}rs r7rzQuadraticBezier.rotated]rr9ct||Srrrs r7rzQuadraticBezier.translateddrr9c t||||Srrrs r7rzQuadraticBezier.scaledirr9rTFrrrrr(r;r)$rrrrrBrFrJrOrRrWrZrrcrr\r!rrrrrtr1rerrrrrNrrr8rr rrrrr9r7r0r0bs"t4L>:0. ! $ .BG"# JE (T -^#/@22% @,(*(AT) F ; E 1# 8r9r0ceZdZdddddZdZd!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)(r/Nr!r1rrcT||_||_||_||_ddddd|_y)Nr!)r2r4r5r3r)rr2r4r5r3s r7rBzCubicBezier.__init__ss4     (,t*.0r9cpt|j|j|j|jfSr;)rDr2r4r5r3rEs r7rFzCubicBezier.__hash__}s&TZZ txxHIIr9c pd|jd|jd|jd|jd S)NzCubicBezier(start=z , control1=z , control2=rHrIr2r4r5r3rEs r7rJzCubicBezier.__repr__s' JJ t}}dhh@ @r9ct|tsy|j|jk(xrO|j|jk(xr4|j|jk(xr|j |j k(SrL)r<r/r2r3r4r5rMs r7rOzCubicBezier.__eq__sb%-zzU[[(0TXX-B0 /0 / 0r9c:t|tstS||k( Sr;)r<r/rQrMs r7rRzCubicBezier.__ne__s%-! !5=  r9c(|j|Sr;rUrVs r7rWzCubicBezier.__getitem__rXr9cy)Nr+rrEs r7rZzCubicBezier.__len__r[r9c|rttt|trN|j|j k(xr3|j |jz |j |jz k(S|j |jk(Sr)rrr<r/r2r3r4r5rs r7rzCubicBezier.is_smooth_fromsp  ( ) h ,JJ(,,.:]]TZZ/ x'8'88: ;==DJJ. .r9cB|rO|j|jk(xr4tj|j d|j dS|j|jk(xr4tj|j d|j dSr]r^r`s r7rczCubicBezier.joins_smoothly_withrdr9c 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.r,r%rs r7rzCubicBezier.points zzA t}}tzz) *Q4:: -.4==@1ZZK!T]]T]]%B"CCdhhND.  r9c.|j|Srjrkrls r7r\zCubicBezier.pointsrnr9rrc "|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 positionrrr1rrr!c8tj|Sr;rrrrs r7rz$CubicBezier.length..sT__S%9!:r9epsabslimit)rr1_quad_availablerrr)rr:r*rrr-s` r7r!zCubicBezier.lengths 7rQw  +t||~=))'2e;))+6)C((22 :B#(6679AtRTZZ^TZZ^$i4A 7rQw*+D  h '+/<<>D  i ().D  g &-6D  k *$$X. .Hr9c$t||||||Srqrrrss r7rtzCubicBezier.ilengthrur9c^|j|j|j|jfSrwr%rEs r7r1zCubicBezier.bpointss!zz4==$--AAr9c|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.rr,rr*ryr{s r7rezCubicBezier.polys LLNQ4%!QqTAaD[/)AaD0QqTAadF]QqT)*adUQqT\"A$ M99V$ $r9c|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)rrr,rr*r-rrrs r7rzCubicBezier.derivatives/ LLN 6adQqTk?AEA:-1Q4!A$;Q0G0IIA!qt MTM"" " !VQ1!A$1-.AaD1QqT6MAaD4H1IIK K !VadQ!qt _,qt34 4 U>? ?r9ct||Srrrs r7rzCubicBezier.unit_tangentrr9c*d|j|zSrrrs r7rzCubicBezier.normal sT&&q)))r9ct||Srrrs r7rzCubicBezier.curvaturerr9c(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.r!r1)r/r3r5r4r2r)rnew_cubs r7rNzCubicBezier.reversedstdhh t}}"jj*   X &#'#4#4G $-- /DG  +r9ct|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 ) rrrrrrsr rr*s r7rzCubicBezier.intersect)s i$!E F"+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  2wR  "+"3"3"56Q!&&6B6"&,,.1Q!&&1B12wR  2wR  i &/i@ @O4K09$ $$ y/?/?/ABM'i}#s  3 '+4+>+>t+DERRHE E  4 (EF FAB B771 71FsG4G9/G>H<Hct|S)z8returns bounding box in format (xmin, xmax, ymin, ymax).rrEs r7rzCubicBezier.bboxRs "4((r9c\t|j|\}}t|t|fS)z=Splits a copy of `self` at t and returns the two subsegments.)rr1r/rs r7r8zCubicBezier.splitVs.)$,,.!<(H%{H'===r9c(tt|||Sr)r/r9rs r7rzCubicBezier.cropped[sKb"566r9ct|||Srrrs r7r zCubicBezier.radialrange`s" &4MO Or9ct|||Srr}rs r7rzCubicBezier.rotatedfrr9ct||Srrrs r7rzCubicBezier.translatedmrr9c t||||Srrrs r7rzCubicBezier.scaledrrr9rrrrrr;r)&rrrrrBrFrJrOrRrWrZrrcrr\ LENGTH_ERRORLENGTH_MIN_DEPTHr!rrrrrtr1rerrrrrNrrr8rr rrrrr9r7r/r/ns"td!%'L0J@0! $ / @ a|?O2 -^#/@2B %@&,** 'CR)> 7 O 1# 8r9r/ceZdZ 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)-rAc||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). rrMN)r$r#r2rrrboolrrr3rsegment_length_hashrrphir rot_matrix _parameterize)rr2rrrrr3rs r7rBz Arc.__init__xsX||{{aFKK1$444 &++&C ,<)<<   i%[  0#' "4==)bk* r9c|j|j|j|j|j|j fS)z>Analog of the Bezier path method, .bpoints(), for Arc objects.rrEs r7apointsz Arc.apointss0zz4;; t~~tzzSWS[S[[[r9c4t|jSr;)rDrSrEs r7rFz Arc.__hash__sDLLN##r9c|j|j|j|j|j|j f}dj |S)NzEArc(start={}, radius={}, rotation={}, large_arc={}, sweep={}, end={}))r2rrrrr3r)rparamss r7rJz Arc.__repr__sL**dkk4==..$**dhh89228&&B Cr9cdt|tsy|j|jk(xr|j|jk(xrj|j|jk(xrO|j |j k(xr4|j |j k(xr|j|jk(SrL)r<rAr2r3rrrrrMs r7rOz Arc.__eq__s%%zzU[[(PTXX-BP u||+P /P%//1P7;jjEKK6O Pr9c:t|tstS||k( Sr;)r<rArQrMs r7rRz Arc.__ne__s%%! !5=  r9c& |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*rMzNo such elliptic arc exists.rrh)rr$r#rPr2r3rr rrr_rrrrOrclipracosthetadelta)rrrrx_sqdry_sqdzp1x1py1px1p_sqdy1p_sqd radius_checktmpradicandradicalcpu1u2det_uvacosands r7rQzArc._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^r9c|j||jzztzdz }|jj}|jj }|j j}|j j }||zt|z||zt|zz |jjz}||zt|z||zt|zz|jj z}||dzzS)NrZrM) r^r_rrPr$r#rr r r) rrTrcosphisinphirrrrs r7rz Arc.point[sa l*B.s2%%%% [[   [[   vIc%j 2f9SZ#7 7$++:J:J J vIc%j 2f9SZ#7 7$++:J:J J1R4xr9cd}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\Sr;r)rrvals r7in_rangez Arc.point_to_t..in_rangels3J0SCZ 0r9rrrrz0Arc.point_to_t() only works on non-rotated Arcs.Nggv@rZ@)rr_r2r3rrrr r$r#rrrr^r_rr]asin)rrrvrdistance_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_1rTs r7rzArc.point_to_tgs  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  H18Hr9c@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). rrPr)rrws r7 centerisoz Arc.centerisos $//!A O44r9c:|j|z|jzS)z(The inverse of the `centeriso()` method.r)rzetas r7 icenterisozArc.icenterisost#dkk11r9c|j|}t|t|}}||jjz d|z|jjz zS)zASimilar to the `centeriso()` method, but maps to the unit circle.rM)rr$r#r)rrwrrrs r7 u1transformzArc.u1transformsN~~a Dz4:1!!!BqD)9)9$999r9ct|}t|}||jjz||jjzz}|j|z|jzS)z*The inverse of the `u1transform()` method.)r$r#rrPr)rrrrrws r7 iu1transformzArc.iu1transformsT J J dkk 4;;#3#3!3 3q 4;;..r9rrc $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|Sr;r1r2s r7rzArc.length..s3ts?S;Tr9r3r4c8tj|Sr;r1r2s r7rzArc.length..sC(<$=r9)rDrNr7rrr)rr:r*rrhs` r7r!z Arc.lengths-B|!|,,R 1 ,, ,, 7rQwT A''/43K3Kq3P+,("*./T/12e4+QQR+TD' && &+9r2tzzRT~9=BPY[\+^D'&& & =r2$D2235 5"$B 2 2"'A7 7r9c$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'rrrss r7rtz Arc.ilength!sT1E&'02 2r9c.|rJ|j|jk(xr/t|jd|jdz |kS|j|jk(xr/t|j d|j dz |kSr]rrs r7rczArc.joins_smoothly_with1rr9ct|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) rrZr+rrMrr*r,r) rr^r_rrr$r#rr r r)rrTrrrOrrr1s r7rzArc.derivative?sd 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>? ?r9c@|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 r7rzArc.unit_tangentVs q!CI~r9c*d|j|zSrrrs r7rz Arc.normal\rr9ct||Srrrs r7rz Arc.curvature`rr9ct|j|j|j|j|j |j S)z?returns a copy of the Arc object with its orientation reversed.)rAr3rrrrr2rEs r7rNz Arc.reverseds6488T[[$--zz>4::/ /r9cd}|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*r[)rr)radsdomain_lower_limitrxr1s r7_degzArc.phase2t.._degsD41R4=)D#c)A AGOD(( Kr9r)r)r_r^)rpsirrxs r7phase2tz Arc.phase2tsL  ::> ;D ;Dtzz!4::--r9c ^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.rrArrNr*rrc|j|}|r2tj|dddstj|dddryy)NrrrrFT)rrr_)rr>rTs r7point_in_seg_interiorz,Arc.intersect..point_in_seg_interior]s=NN51 ! " 1c$ G " 1c$ G#(#r9)rr)rr)rr)rrrwrr cf|\}}tj|j|z Sr;r)tpairr*rrrs r7keyfcnzArc.intersect..keyfcns-"FBtzz"~ 0CCDDr9rrzHother_seg should be a Arc, Line, QuadraticBezier, or CubicBezier object.)$rr<r.rr$r#r2rr3rer appendrrr?rrzrr"rphaseziprAsysrr_rrpowrr!rr-sortrZr)7rrrrrSrVrrx_values discriminanty_valuesrumrx_sqrtrx2y_sqrtry2rrrmy_tother_tu1poly u1poly_mag2rTt2srt1sr*rr0r1rrrpossible_intersrlittle_rrp2x30x31y30y31p30p31intersself_tr]r ridxs7`` r7rz Arc.intersectsG  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)+/:Ja1kk1JCJ=@Ar4<<fRj 12ACA+.sC=IRALqLRHI 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)Nr[r*)rr^r_)angr1rs r7 angle_invzArc.bbox..angle_invs02a4Z#qt*- :DJJF Fr9r'r)mathrr r rOrr rr$r#r2r3rZrrrr)rrr atan_xatan_yrrrxtremaytremar1txtyrOs` r7rzArc.bboxsv& # txx=A TFF ]a FTF[[%%t{{'7'7BBrE(3txx=01F2b5#dhh-/0F G**//488==1**//488==1r1 3A61%B61%BB|!| djjn112B|!| djjn112  36{6{CKVc&kAAr9cJ|jd||j|dfS)zZreturns two segments, whose union is this segment and which join at self.point(t).rr)rrs r7r8z Arc.splits%||Aq!4<<1#555r9c t|j||z zdkrd}nd}t|j||j|j ||j |j||jS)rrZrrr)rr_rArrrrr)rr:r* new_large_arcs r7rz Arc.cropped si tzz27# $ +MM4::b>$++ *$**zz"~8M8MO Or9ct)zreturns the tuples (d_min, t_min) and (d_max, t_max) which minimize and maximize, respectively, the distance, d = |self.point(t)-origin|.)_NotImplemented4ArcExceptionrs r7r zArc.radialrange s \+*r9Nct|||Srr}rs r7rz Arc.rotated= rr9ct||Srrrs r7rzArc.translatedD rr9c t||||Srrrs r7rz Arc.scaledI rr9c #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+r,rwr*r@rMN)rr_floatr^rr$r#r2rrr r rZr rr r3r/)rcurvesslice_t current_trrp_startr^rr cos_theta sin_thetar]next_talpha cos_start_t sin_start_t ePrimen1x ePrimen1y cos_end_t sin_end_tp2En2xp2En2yp_end ePrimen2x ePrimen2yp_c1p_c2s r7as_cubic_curveszArc.as_cubic_curvesM sZ$**%f 5DJJ' [[   [[  ** & [[   [[  J J v A(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 9GI9 sH3H5c#`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*rMrg@rN)rr_rr^rr$r#r2rrr r rZr3r0)rrrrrrSrr^cxcyrrr]rmid_trrrrr cos_mid_t sin_mid_trpxpys r7as_quad_curveszArc.as_quad_curvesz s$**%f 5DJJ' KK   KK  ** & [[   [[  J J v A(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.r)rz3tuple[complex, complex, float, bool, bool, complex]rrrrrr;r))rrrrBrSrFrJrOrRrQrrrrrrrIrJr!rrrrrtrcrrrrrNrrrr8rr rrrrrrr9r7rArAws"&_B\$C P! fP xt5$2: /a|?O7: -^#/@2 BG"# J@. (*R/ .>^G@ .B`6 O.+`1# 8+Z!r9rAceZdZdZdZdZdZdZdZdZ 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)BrDz%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_lengthsrr-r<strlist _segments _parse_pathr2_startr3_end _tree_element)rsegmentskwrs r7rBz 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  r9cxdtfd|jD}t||jfzS)Ncbt|tr|jS|jSr;)r<rArSr1)segments r7 _pointifyz Path.__hash__.._pointify s$(27C(@7??$ WgooFW Wr9c3<K|]}|D]}|ywr;r).0rrrs r7 z Path.__hash__.. s"P'Yw=OPAPAPs)tupler rD_closed)rptsrs @r7rFz Path.__hash__ s5 XPT^^PPC4<newpaths r7rNz Path.reversed s4-12c3<<>22W~3s6c,t|jSr;)r-r rEs r7rZz Path.__len__ s4>>""r9cddjdjd|jDS)NzPath({})z, c32K|]}t|ywr;)repr)rrs r7rz Path.__repr__.. s<DG >r9ct|tsyt|t|k7ryt|j|jD] \}}||k(r yy)NFT)r<rDr-rr )rrNr-os r7rOz Path.__eq__ sS%& t9E "8 DAq6 r9c:t|tstS||k( Sr;)r<rDrQrMs r7rRz Path.__ne__ rSr9c|jy|jDcgc]}|j||}}t||_|jdk(r||_y|Dcgc]}||jz c}|_ycc}wcc}w)Nr&r)r r r!sumr )rrreachlengthss r7 _calc_lengthszPath._calc_lengths s << # >>#T4;;Ui;@##7| <<1 #DM=DETTDLL0EDM # 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 {}) r-r rrr=rnr  RuntimeErrorr)rpos segment_startr r segment_end segment_poss r7rz Path.point s t~~ ! #>? ? #:>>!$**3/ / #:>>"%++C0 0  '7 (NE7'$--*>>Kc!"]2-/1 }}[11'M (dkkloquvwwr9rrcj|||dk(r|dk(r jStdk(rdj||Sj |\}}j |\}}||k(r|j||S|j|t fdt |dz|Dz|j|zS)Nr&rr)r:r*)r:c3DK|]}|jywr;)r!)rrrs r7rzPath.length..8 sLsS ((*Ls )r*)r=r r-r!T2tr:rZ) rT0T1rridx0r:idx1r*s ` r7r!z Path.length, s )< 7rQw<< 4yA~Aw~~~33xx|HD"xx|HD"t|Dz((B2(66J%%%,LeD1Hd6KLLMJ%%%,- .r9c$t||||||Srqrrrss r7rtz Path.ilength; rur9cVtfdttdz DS)zLChecks if a path is continuous with respect to its parameterization.c3bK|]&}|j|dzjk((yw)rNrg)rr]rs r7rz$Path.iscontinuous..E s*Pa47;;$qs)//1Ps,/r)rErZr-rEs`r7 iscontinuouszPath.iscontinuousB s#P5TQ;OPPPr9c .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)rZr-r3r2rrD)rsubpaths subpath_startr]s r7continuous_subpathszPath.continuous_subpathsG s s4y1}% $AAw{{dAaC3t9#45;;;d=!A#&> ?@ !!  $ d=#d)<=>r9cxt|dk7sJ|jsJ|j|jk(S)z7This function determines if a connected path is closed.r)r-rNr2r3rEs r7rz Path.isclosedX s74yA~~  """zzTXX%%r9cTt|dk7sJ|j|jk(SNr)r-r2r3rEs r7 isclosedaczPath.isclosedac^ s%4yA~~zzTXX%%r9cr |dj}|D]}|j|k(syy#t$rYywxYw)NrTF)r3 IndexErrorr2)rr3rs r7 _is_closablezPath._is_closableb sM r(,,C G}}#    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.)rrrY)rrrs r7rz Path.closedl s-*  I||3 1 1 33r9cbt|}|r|js td||_y)Nz+End does not coincide with a segment start.)rMrYrr)rr$s r7rz Path.closedy s,U  **,JK K r9c|js6t|jdkDr|jdj|_|jSrUrr-r r2rEs r7r2z Path.start s9{{s4>>214..+11DK{{r9cl||_t|jdkDr||jd_yyrUr]rrs r7r2z Path.start s0 t~~ q &(DNN1  # !r9c|js6t|jdkDr|jdj|_|jSr"rr-r r3rEs r7r3zPath.end s9yyS02r*..DIyyr9cl||_t|jdkDr||jd_yyr"rar_s r7r3zPath.end s0 t~~ q %'DNN2  " !r9c, 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} {},{}Z )r-rNrr3r2rrr$r#r<r.r/rr5r4r0r6rArrrrrr5lower)ruseSandTuse_closed_attribrel self_closedrrpartsprevious_segmentr3r seg_start _seg_start_seg_end _seg_control2args _seg_control1 _seg_controlr-s r7rzPath.d s  t9> ++-A$--/K97KAwH 2hllJ 'G 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& UJ 'X  LL  HHUOq**r9c |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)r2r3rrr`s r7rczPath.joins_smoothly_with s 7==HLL0-T__6))!,6- -7==HLL0/T5F5F6++A.6/ /r9c|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)r-r=rnr r)rrrGseg_idx seg_lengthrHrTs r7rFzPath.T2t s 6t9Q;> ! 6  #,T]]#;  GZjBQwVZ'z!B  A{{{{r9c0|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)r=r<rr rrBr:r )rr>rTrwrArBrs r7r,zPath.t2T" 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)rFr rr!)rrrrwrTr>s r7rzPath.derivative: sE XXa[ nnW%~~a1~%cjjlAo55r9cf|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.)rFr r)rrrwrTs r7rzPath.unit_tangentD s/ XXa[ ~~g&33A66r9c*d|j|zSrrrs r7rz Path.normalL rr9c|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?) rFrr_r3r2r r-rcrrr$r#r) rrrwrTr>previous_seg_in_pathnext_seg_in_pathrrrrrrs r7rzPath.curvatureP 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$888r9cd}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$rer#rinteg)rG area_enclosedr>rr integrandintegrals r7area_without_arcsz$Path.area..area_without_arcs ssM ;$#((*%++-bD $??,!x{!::  ; ! r9c &tt|jz }tjdd|dzDcgc]}|j |}}t |Dcgc]}t||||dzc}Scc}wcc}w)z-Find piecewise-linear approximation of `seg`.rr)rrr!rlinspacerrZr.)seg_ num_linesrTrr] chord_lengths r7 seg2lineszPath.area..seg2lines s{D!=>?I*,++aIaK*HIQ4::a=ICI49)4DEqDQQqS*E EJEs B *B)rr<rArrD)rrrrbezier_path_approximationr>s ` r7areaz Path.areap sm. ! F }}$&! 6C#s#)Ys^;))005  6 !'@!ABBr9c |}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) r<rDrr,rr rrrZr-rrn)r other_curve justonemoderpath1path2intersection_listseg1seg2r*rrHT2_T1_seg1_t1rindices2removeind1ind2indinters r7rzPath.intersect s()+t< ${BS~~ OD O#4,Q//"nnTsn;OFB4,B4,B%,,r4nr4n-MNO O O ,$Q' ' ;?EV@W;XYZ;[\\UC5;;s#\C\Nc#h 4!$(CH54D3t9s4y01C7&--d34 4 "++bbsxminsxmaxsyminsymaxsrOrPrQrRs r7rz Path.bbox sm%)^^4csxxz44%)#s)_"ueU5z5z5z5zT4%% 5sA0cd|cxkrdkrnJd|cxkrdksJJ||k7sJ|dk(r|dk(rJ|dk(r0d|cxkrdkr%nn"|jr|jd|S|dk(r|d}d}t|dz }nh|j|\}}||}t j |dr(|j |dz t|z}||}d}n|j |}|dk(r |d}d}d} nh|j|\} }|| }t j |dr(|j |dzt|z} || }d}n|j |} ||kr"| |k(rt|j||} | St|j|d} ||krr|js tdt| dzt|D]} | j|| td|D]} | j|| n(t| dz|D]} | j|| |dk7r!| j|jd|| S)z#returns a cropped copy of the path.rrrz6This path is not closed, thus T0 must be less than T1.) rrr-rFrr_r rDrrZr) rrGrHrt_seg1i1seg1_idxseg0t_seg0i0seg0_idxnew_pathr]s r7rz Path.cropped s{B|!|++R ! ++ ++Rxx!Ga(( 7q2zzdmmo<<2& & 78DFTQB#xx| Hf>Dzz&!$jj&*c$i7BxZZ% 77DFB#xx| Hf>Dzz&!$jj&*c$i7BxZZ% 7rRxDLL89H,)DLL34HBw}}$&899#263t951 Q01"1b\1 Q01 rAvr*-AOODG,-{ Q 78r9c|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)rrr~rnr ) rryr global_min global_maxrwr>rrs r7r zPath.radialrange s %% %&&$-J(J )$ = 141H.!!$z!}4!/7*!>%T> 2 ZZ]!&dD$bgg--LDBGG4Kt4K d1fd1f%C//r9c.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) rrrZr-r<rArrrr_r rrrr sweep_limitr-r arc_requireds r7approximate_arcs_with_cubicsz!Path.approximate_arcs_with_cubicsR s1fcEk* s4y{B+ FA1gGgs+tC $6$DEFLw66|DED1Q3K  Fr9c.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) rrrZr-r<rArrrr_r rrs r7approximate_arcs_with_quadsz Path.approximate_arcs_with_quads_ s1fcEk* s4y{B+ EA1gGgs+tC $6$DEFLw55lCDD1Q3K  Er9cNt|\}}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)rrrSs r7roz Path.jointsl s&4y1 Q 1ayr9c#Ktj|D],}|tvr|tj |D]}|.ywr;) COMMAND_REr8COMMANDSFLOAT_REfindall)rpathdefrtokens r7_tokenize_pathzPath._tokenize_pathx sK!!'* AH}!))!,    sAAc  t|j|}|j|j}d}d}|r|dtvr+|}|j }|t v} |j}n8|4td|dt|jt|z |}|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| |jdzz}  s| |j z } |jt|| | }nb|d k(r^|j } |j t| dzz}  s| |jdzz } |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|d vr|} 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|jdk(rNt+dj-||||||dj-||z|jt||n|jt/|||||||}|r|S)NrzUnallowed implicit command in z , position MrMLreTHVCSCSrrQTArzyReplacing degenerate (zero radius) Arc with a Line: Arc(start={}, radius={}, rotation={}, large_arc={}, sweep={}, end={})z --> Line(start={}, end={}))r rr/r rpop UPPERCASEupperrr-r8rrr.rr#r$r/r5r0r6rrrA)rrrrelementsr start_poscommand last_commandabsoluterrr@r4r5r3r6rrarcrs r7rzPath._parse_path s ++G45>> |x'& ",,."i/!--/?$W]]_!5H !E&GHH& #~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 t+ +H +[88B<;P;PPH 053H23MMHLLN+eHLLN.Cb.HH +H;&C K8S QR! C /% 2G"2LLHLLN+eHLLN.Cb.HH{*G;&C Wc JK! C t+*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! MPr9r)FFFrr)r)Fr(r;r)g?)rN)Brrr__doc__rrrelementrmetarBrFrWr%r'r)r+r-rNrZrJrOrRrIrJr=rr!rrrrrtrNrRrrVrYpropertyCLOSED_WARNING_ONrsetterr2r3rrcrFr,rrrrrrrrr rrrrrrrorrrr9r7rDrD 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 vr9rDr)TFr;r)ir __future__rrecollections.abcr ImportError collectionswarningsroperatorrnumpyr itertoolsr functoolsrr r r r r r]rrxrrrrrrrrrrscipy.integraterr7bezierrrrrrr misctoolsr polytoolsr r!r"r#r$ basestringr  NameErrorsetrrcompilerrrJrIUSE_SCIPY_QUADrrrrrrrrr8r?rBrHrKrWr^r`rcrgrlrtr~rrrrrr rrrrr+r9objectr.r0r/rArDrr9r7rs # ,/$$$$;;$O (($II C % &   RZZ3 4 2::A B     IJ  )* :H B 240 ) ' :"#H<H$-H`9Hx#L!H.0# # &1A*#0%1BA=L.F86F8RI8fI8XF8&F8Rd&dN!W?WiL,++,"O  s/E&E8F& E54E58E?F  F