3jTSrSSKJr SSKrSSKrSSKrSSKJr Sr Sr \"SS9S 5r "S S \ 5r S rS rSrSrSSjr"SS5rSSjrSSjrSrSrSSjrSrSrSSjrg) uP A module providing some utility functions regarding Bézier path manipulation. ) lru_cacheN)_apicj[U5S:ah[U5S:a[R"/5$U*U- nSUs=::aS::aO O[R"U/5$[R"/5$X-SU-U-- nUS:a[R"/5$[R"U5nUS:aSX--nOSX- -n/n[U5S:aUR X- 5 [U5S:aUR Xb- 5 [R "U5nXwS:US:*-$)z,Real roots of c0 + c1*x + c2*x**2 in [0, 1].-q=rg)absnparraysqrtappendasarray)c0c1c2rootdisc sqrt_discqrootss K/home/wildlama/miniconda3/lib/python3.13/site-packages/matplotlib/bezier.py_quadratic_roots_in_01rs  2w r7U?88B< sRx#$>>rxxCrxx|C 7QVb[ D axxx| I Qw BN # BN # E 1v~ RV 2w QV JJu E 1*!, --c[R"U[S9n[U5S- nUS:a/[ X5S:aUS-nUS:a[ X5S:aMUS::a[R "/5$US:XaIUS*US- nSUs=::aS::aO O[R "U/5$[R "/5$US:Xa[ USUSUS5nOvSn[R"XSS25n[R"UR5U:nXVRnXt*:USU-:*-n[R"XxSS5n[R"U5$) aP Find real roots of a polynomial in the interval [0, 1]. For polynomials of degree <= 2, closed-form solutions are used. For higher degrees, `numpy.roots` is used as a fallback. In practice, matplotlib only ever uses cubic bezier curves and axis_aligned_extrema() differentiates, so we only ever find roots for degree <= 2. Parameters ---------- coeffs : array-like Polynomial coefficients in ascending order: ``c[0] + c[1]*x + c[2]*x**2 + ...`` Note this is the opposite convention from `numpy.roots`. Returns ------- roots : ndarray Sorted array of real roots in [0, 1]. )dtyperrrg|=N) r rfloatlenr r rrimagrealclipsort) coeffsdegrreps all_roots real_mask real_rootsin_ranges r_real_roots_in_01r++sP*ZZe ,F f+/C 'c&+&. q 'c&+&. axxx| q zF1I%#$>>rxxCrxx|C &vay&)VAYGHHVGG_- FF9>>*S0 ).. $&:S+@A ,a3 775>r)maxsizecSn[R"US-5SS2S4n[R"US-5SSS24nSX2--U"X#5-nU"X5U-R[5$)a Compute the matrix for converting Bezier control points to polynomial coefficients for a curve of degree n. The matrix M is such that M @ control_points gives polynomial coefficients. Entry M[j, i] = C(n, j) * (-1)^(i+j) * C(j, i) where C is the binomial coefficient. cV[R"[R5"X5$N)r vectorizemathcomb)nks r_comb _get_coeff_matrix.._combds||DII&q,,rrNr)r arangeastyper)r4r6ji prefactors r_get_coeff_matrixr=Zsm- !a%D!A !a%q!A%+-I !K) # + +E 22rc\rSrSrSrg)NonIntersectingPathExceptionmN)__name__ __module__ __qualname____firstlineno____static_attributes__rArrr?r?msrr?c^X0-X!-- nXt-Xe-- n X2*pXv*pX-X-- m[T5S:a [S5eX*pU *U nnU4SjXUU45upnnX-X--nUU-UU --nUU4$)z Return the intersection between the line through (*cx1*, *cy1*) at angle *t1* and the line through (*cx2*, *cy2*) at angle *t2*. rzcGiven lines do not intersect. Please verify that the angles are not equal or differ by 180 degrees.c3,># UH oT- v M g7fr0rA).0r5ad_bcs r #get_intersection..s:)9A%i)9s)r ValueError)cx1cy1cos_t1sin_t1cx2cy2cos_t2sin_t2 line1_rhs line2_rhsabcda_b_c_d_xyrJs @rget_intersectionrbts v|+I v|+I 7q 7q EAEME 5zENO ORB:""b)9:NBB 'A Yi'A a4Krc`US:XaXX4$X2*peU*UpXE-U-XF-U-pXG-U-XH-U-pXX4$)z For a line passing through (*cx*, *cy*) and having an angle *t*, return locations of the two points located along its perpendicular line at the distance of *length*. rA) cxcycos_tsin_tlengthrPrQrTrUx1y1x2y2s rget_normal_pointsrnsY|r~FFVUF _r !6?R#7 _r !6?R#7 2>rc.USSSU- -USSU--nU$)NrrrA)betat next_betas r_de_casteljau1rss+Sb QU#d12hl2I rc[R"U5nU/n[X5nURU5 [ U5S:XaOM.UVs/sHoSPM nn[ U5Vs/sHoSPM nnX44$s snfs snf)u Split a Bézier segment defined by its control points *beta* into two separate segments divided at *t* and return their control points. rrr)r rrsr rreversed)rprq beta_list left_beta right_betas rsplit_de_casteljaurys ::d DI d& t9>   &//YTaYI/'/ ':;':tr(':J;   0;s A=*BcHU"U5nU"U5nU"U5nU"U5nXx:XaXV:wa [S5e[R"USUS- USUS- 5U:aX#4$SX#--n U"U 5n U"U 5n X{- (a U nXj:XaX#4$U nOU nXZ:XaX#4$U nU nMm)u$ Find the intersection of the Bézier curve with a closed path. The intersection point *t* is approximated by two parameters *t0*, *t1* such that *t0* <= *t* <= *t1*. Search starts from *t0* and *t1* and uses a simple bisecting algorithm therefore one of the end points must be inside the path while the other doesn't. The search stops when the distance of the points parametrized by *t0* and *t1* gets smaller than the given *tolerance*. Parameters ---------- bezier_point_at_t : callable A function returning x, y coordinates of the Bézier at parameter *t*. It must have the signature:: bezier_point_at_t(t: float) -> tuple[float, float] inside_closedpath : callable A function returning True if a given point (x, y) is inside the closed path. It must have the signature:: inside_closedpath(point: tuple[float, float]) -> bool t0, t1 : float Start parameters for the search. tolerance : float Maximal allowed distance between the final points. Returns ------- t0, t1 : float The Bézier path parameters. z3Both points are on the same side of the closed pathrr?)r?r hypot) bezier_point_at_tinside_closedpatht0t1 tolerancestartend start_inside end_insidemiddle_tmiddle middle_insides r*find_bezier_t_intersecting_with_closedpathrsL b !E B C$U+L"3'J!el* AC C  88E!Hs1v%uQx#a&'8 9I E6M"'?"8,)&1  'B}v CBv E(L3 rc\rSrSrSrSrSr\R"SSS9S5r \ S 5r \ S 5r \ S 5r \ S 5rS rSrg) BezierSegmentiu  A d-dimensional Bézier segment. A BezierSegment can be called with an argument, either a scalar or an array-like object, to evaluate the curve at that/those location(s). Parameters ---------- control_points : (N, d) array Location of the *N* control points. c ,[R"U5UlURRuUlUl[R "UR5Ul[UR5Vs/sHdn[R"URS- 5[R"U5[R"URS- U- 5--PMf nnURRU-RUl gs snf)Nr) r r_cpointsshape_N_dr8_ordersranger2 factorialT_px)selfcontrol_pointsr;coeffs r__init__BezierSegment.__init__s >2 ==..yy)  .*(Q! ,^^A&! a)HHJ( *MMOOe+..*s;A+Dc[R"U5n[RRSU- URSSS25[RRXR5-UR -$)u Evaluate the Bézier curve at point(s) *t* in [0, 1]. Parameters ---------- t : (k,) array-like Points at which to evaluate the curve. Returns ------- (k, d) array Value of the curve for each point in *t*. rNr)r rpowerouterrrrrqs r__call__BezierSegment.__call__'s^ JJqMq1udll4R4&89((..LL1259XX> >rz3.11z/Call the BezierSegment object with an argument.) alternativec$[U"U55$)zH Evaluate the curve at a single point, returning a tuple of *d* floats. tuplers r point_at_tBezierSegment.point_at_t9s T!W~rcUR$)z The control points of the curve.)rrs rrBezierSegment.control_pointsAs}}rcUR$)zThe dimension of the curve.)rrs r dimensionBezierSegment.dimensionFs wwrc URS- $)z@Degree of the polynomial. One less the number of control points.r)rrs rdegreeBezierSegment.degreeKsww{rcURnUS:a[R"S[5 [ U5UR -$)u: The polynomial coefficients of the Bézier curve. .. warning:: Follows opposite convention from `numpy.polyval`. Returns ------- (n+1, d) array Coefficients after expanding in polynomial basis, where :math:`n` is the degree of the Bézier curve and :math:`d` its dimension. These are the numbers (:math:`C_j`) such that the curve can be written :math:`\sum_{j=0}^n C_j t^j`. Notes ----- The coefficients are calculated as .. math:: {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i where :math:`P_i` are the control points of the curve. zFPolynomial coefficients formula unstable for high order Bezier curves!)rwarningswarnRuntimeWarningr=r)rr4s rpolynomial_coefficients%BezierSegment.polynomial_coefficientsPs?2 KK r6 MM12@ B #d&9&999rcURnUS::a,[R"/5[R"/54$URn[R"SUS-5SS2S4USS-n/n/n[ UR 5Haupg[U5n[U5S:dM!URU5 UR[R"[U5U55 Mc U(d,[R"/5[R"/54$[R"U5[R"U54$)a Return the dimension and location of the curve's interior extrema. The extrema are the points along the curve where one of its partial derivatives is zero. Returns ------- dims : array of int Index :math:`i` of the partial derivative which is zero at each interior extrema. dzeros : array of float Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) = 0` rNr) rr r rr8 enumeraterr+rr full concatenate) rr4CjdCjall_dimsr'r;pirs raxis_aligned_extrema"BezierSegment.axis_aligned_extremaps KK 688B<"- -  ) )ii1q5!!T'*RV3 suu%EA!"%A1vz  #A 23 & 88B<"- -~~h' )BBBr)rrrrrN)rBrCrDrE__doc__rrr deprecatedrpropertyrrrrrrFrArrrrs />$ __MOO ::>"Crrcf^[U5m[U4SjXS9up4[XU-S- 5upVXV4$)u2 Split a Bézier curve into two at the intersection with a closed path. Parameters ---------- bezier : (N, 2) array-like Control points of the Bézier segment. See `.BezierSegment`. inside_closedpath : callable A function returning True if a given point (x, y) is inside the closed path. See also `.find_bezier_t_intersecting_with_closedpath`. tolerance : float The tolerance for the intersection. See also `.find_bezier_t_intersecting_with_closedpath`. Returns ------- left, right Lists of control points for the two Bézier segments. c&>[T"U55$r0r)rqbzs r;split_bezier_intersecting_with_closedpath..s %1,r)rg@)rrry)bezierr~rrr_left_rightrs @r)split_bezier_intersecting_with_closedpathrs@, v B 7 1HFB'vR2~>ME =rc rSSKJn UR5n[U5upgU"USS5nUn Sn Sn UHFupgU n U [ U5S-- n U"USS5U:wa[ R "U SSU/5n OUn MH [S5eU RS5n [XU5up[ U5S:Xa&UR/nURUR/nO[ U5S :Xa<URUR/nURURUR/nOl[ U5S :XaRURURUR/nURURURUR/nO [S 5eUSSnUSSnURcWU"[ R "UR SU U/55nU"[ R "UUR U S/55nOU"[ R "UR SU U/5[ R "URSU U/55nU"[ R "UUR U S/5[ R "UURU S/55nU(a U(dUUnnUU4$) zT Divide a path into two segments at the point where ``inside(x, y)`` becomes False. r)PathNrrz*The path does not intersect with the patch)rrrzThis should never be reached)pathr iter_segmentsnextrr rrMreshaperLINETOMOVETOCURVE3CURVE4AssertionErrorcodesvertices)rinsider reorder_inoutr path_iter ctl_pointscommand begin_insidectl_points_oldioldr; bezier_pathbpleftright codes_left codes_right verts_left verts_rightpath_inpath_outs rsplit_path_inoutrsy ""$Iy/J*RS/*LN D A(  S_ !! *RS/ "l 2...*=z)JKK # )EFF   W %B; IKD 4yA~kk] {{DKK0 Takk4;;/ {{DKK= Takk4;; < {{DKKdkkJ ;<<abJ(K zzr~~t}}Ra'8*&EFG T]]125F'GHIr~~t}}Ud';Z&HI~~tzz%4'8*&EFH T]]125F'GH TZZ^'DEG\$g H rc&^^^US-mUUU4SjnU$)z Return a function that checks whether a point is in a circle with center (*cx*, *cy*) and radius *r*. The returned function has the signature:: f(xy: tuple[float, float]) -> bool rc4>UupUT- S-UT- S--T:$)NrrA)xyr`rarerfr2s r_finside_circle.._fs*B1}B1},r11rrA)rerfrrrs`` @r inside_circlers aB2 IrcFX - X1- pTXD-XU--S-nUS:XagXF- XV- 4$)Nr{r)rdrdrA)x0y0rjrkdxdyr[s r get_cos_sinrs8 Wbg 27 r!AAv 626>rc[R"X5n[R"X#5n[XV- 5nXt:ag[U[R- 5U:agg)a Check if two lines are parallel. Parameters ---------- dx1, dy1, dx2, dy2 : float The gradients *dy*/*dx* of the two lines. tolerance : float The angular tolerance in radians up to which the lines are considered parallel. Returns ------- is_parallel - 1 if two lines are parallel in same direction. - -1 if two lines are parallel in opposite direction. - False otherwise. rrF)r arctan2r r)dx1dy1dx2dy2rtheta1theta2dthetas rcheck_if_parallelrsP&ZZ !F ZZ !F  !F  Vbee^ y (rc USup#USupEUSupg[X$- X5- XF- XW- 5nUS:Xa'[R"S5 [X#Xg5upXpO[X#XE5up[XEXg5up[ X#XU5upnn[ XgXU5unnnn[ XU U UUX5unn[ UUU U UUX5unnX4UU4UU4/nUU4UU4UU4/nUU4$![ a# SU U--SUU--nnSUU--SUU--nnNEf=f)u Given the quadratic Bézier control points *bezier2*, returns control points of quadratic Bézier lines roughly parallel to given one separated by *width*. rrrrz8Lines do not intersect. A straight line is used instead.r{)rr warn_externalrrnrbrM)bezier2widthc1xc1ycmxcmyc2xc2y parallel_testrPrQrTrUc1x_leftc1y_left c1x_right c1y_rightc2x_leftc2y_left c2x_right c2y_rightcmx_leftcmy_left cmx_right cmy_right path_left path_rights r get_parallelsr .sqzHCqzHCqzHC%ci&)i( 0 9f06 906 @ 9 %H%H%'Ii(i(i(*J j  )   8h& '80C)D 9y( )3)i2G+H 9  s'C*DDcFSSU-X-- -nSSU-X-- -nX4Xg4XE4/$)u Find control points of the Bézier curve passing through (*c1x*, *c1y*), (*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1. r{rrA)r r mmxmmyrrr rs rfind_control_pointsr$xsA C39% &C C39% &C J SJ //rcUSupVUSupxUSup[XVXx5up[XxX5up[XVXX-5unnnn[XXX-5unnnnXW-S-Xh-S-nnXy-S-X-S-nnUU-S-UU-S-nn[UUUU5unn[UUUUX-5unn n!n"[UUUU UU5n#[UUU!U"UU5n$U#U$4$)u Being similar to `get_parallels`, returns control points of two quadratic Bézier lines having a width roughly parallel to given one separated by *width*. rrrr{)rrnr$)%r r w1wmw2r r r rc3xc3yrPrQrTrUrrrrc3x_leftc3y_left c3x_right c3y_rightc12xc12yc23xc23yc123xc123ycos_t123sin_t123 c123x_left c123y_left c123x_right c123y_rightrrs% rmake_wedged_bezier2r;sAqzHCqzHCqzHC!34NF 34NF #FEJ?-Hh 9 #FEJ?-Hh 9 )r!CI#3$D)r!CI#3$D4K2%t r'95E%T4t<Hh %(EJG5J K$Hh$. $,h8I%Y %0+%. ;J j  r)rd?{Gz?)r=)r=F)gh㈵>)r<r{rd)r functoolsrr2rnumpyr matplotlibrrr+r=rMr?rbrnrsryrrrrrrrr r$r;rArrrAs .:,^ 233$ : B2 !&GKI)XACACJ.2D:z&