h SrSSKJrJrJr SSKJr SSKrSSKJ r SSK r \ RrSr\ "S/S Q5r/S QrSUS jrS r\ R*"\ R,5\ R."\ R0\ R0\ R0\ R0S 9\ R."\ R,\ R,\ R,S9S555r\ R*"\ R,5\ R."\ R0\ R0\ R0\ R0S9\ R."\ R,\ R,S9SUSj555rSrSr\ R:\ R<\ R*"\ R,5\ R."\ R0\ R0S9S5555r\ R:\ R<\ R*"\ R,5\ R."\ R,S9S5555r Sr!\ R*"\ R,5\ R."\ R0\ R0\ R0\ R0\ R0\ R0\ R0S9\ R."\ R,\ R,\ R,\ R,\ R,\ R,\ R,S9S555r"Sr#\ R*"\ R,5\ R."\ R0\ R0\ R0S9\ R."\ R,\ R,\ R,S9S 555r$S!r%S"r&\ R*"\ R,5\ R."\ R0\ R0\ R0\ R0S9\ R."\ R,\ R,\ R,\ R,\ R,S#9S$555r'S%r(S&r)S'r*S(r+S)r,S*r-\ R."\ R0\ R0\ R0\ R0\ R0\ R0\ R0\ R0S+9S,5r.\ R*"\ R05\ R."\ R,\ R0\ R0\ R0\ R0\ R0\ R0\ R0S-9\ R."\ R,\ R,\ R,\ R,S.9S/555r/S0r0S1r1\ R."\ R0\ R0\ R0\ R0\ R,\ R,\ R,\ R,\ R,\ R0\ R0\ R0\ R0S29 S35r2SS4KJ3r3J4r4J5r5J6r6 \34S5jr7S6r8S7r9S8r:\ R:\ R<\ R."\ R0\ R0\ R0\ R0\ R0\ R0\ R0S99S:555r;S;r555r>S?r?S@r@SArA\ R*"\ R05\ R."\ R,\ R0\ R0\ R0\ R0SB9\ R."\ R,\ R,\ R,SC9SD555rBSErCSFrDSGrESHrFSIrGSJrHSKrISLrJSMrKSVSNjrLSOrMSPrNSQrOSRrPSSrQ\RST:Xa4SSKSrSSSKTrT\SR"\TR"5R5 gg!\ \ 4a SSK J r GN_f=f)WzNfontTools.misc.bezierTools.py -- tools for working with Bezier path segments. ) calcBoundssectRectrectArea)IdentityN) namedtuple)cythong& .> Intersectionptt1t2)approximateCubicArcLengthapproximateCubicArcLengthCapproximateQuadraticArcLengthapproximateQuadraticArcLengthCcalcCubicArcLengthcalcCubicArcLengthCcalcQuadraticArcLengthcalcQuadraticArcLengthCcalcCubicBoundscalcQuadraticBounds splitLinesplitQuadratic splitCubicsplitQuadraticAtT splitCubicAtTsplitCubicAtTCsplitCubicIntoTwoAtTCsolveQuadratic solveCubicquadraticPointAtT cubicPointAtTcubicPointAtTC linePointAtTsegmentPointAtTlineLineIntersectionscurveLineIntersectionscurveCurveIntersectionssegmentSegmentIntersectionscP[[U6[U6[U6[U6U5$)aCalculates the arc length for a cubic Bezier segment. Whereas :func:`approximateCubicArcLength` approximates the length, this function calculates it by "measuring", recursively dividing the curve until the divided segments are shorter than ``tolerance``. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. tolerance: Controls the precision of the calcuation. Returns: Arc length value. )rcomplex)pt1pt2pt3pt4 tolerances L/var/www/html/env/lib/python3.13/site-packages/fontTools/misc/bezierTools.pyrr8s,  w}gsmWc]I cpUSX---U-S-nX2-U- U- S-nXU-S-XE- U4XDU-X#-S-U44$)Ng??)p0p1p2p3midderiv3s r1_split_cubic_into_twor=Ksc RW  "e +CglR5 (F 2g_clC0 FlRWOR0 r2)r7r8r9r:)multarchboxc[X- 5n[X- 5[X#- 5-[X4- 5-nXP-[-U:aXV-S-$[XX45upx[U/UQ76[U/UQ76-$Nr5)absEPSILONr=_calcCubicArcLengthCRecurse) r>r7r8r9r:r?r@onetwos r1rErETs rwc,SSU--n[XPXU5$)zCalculates the arc length for a cubic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. tolerance: Controls the precision of the calcuation. Returns: Arc length value. ?g?)rE)r,r-r.r/r0r>s r1rrhs!* y D &t#C @@r2g|=v1v2c:XR5-R$N) conjugaterealrLs r1_dotrSs   % %%r2xczU[R"US-S-5-S- [R"U5S- -$)N)mathsqrtasinhrTs r1 _intSecAtanr\s7 tyyA" "Q &A): ::r2c@[[U6[U6[U65$)a6Calculates the arc length for a quadratic Bezier segment. Args: pt1: Start point of the Bezier as 2D tuple. pt2: Handle point of the Bezier as 2D tuple. pt3: End point of the Bezier as 2D tuple. Returns: Arc length value. Example:: >>> calcQuadraticArcLength((0, 0), (0, 0), (0, 0)) # empty segment 0.0 >>> calcQuadraticArcLength((0, 0), (50, 0), (80, 0)) # collinear points 80.0 >>> calcQuadraticArcLength((0, 0), (0, 50), (0, 80)) # collinear points vertical 80.0 >>> calcQuadraticArcLength((0, 0), (50, 20), (100, 40)) # collinear points 107.70329614269008 >>> calcQuadraticArcLength((0, 0), (0, 100), (100, 0)) 154.02976155645263 >>> calcQuadraticArcLength((0, 0), (0, 50), (100, 0)) 120.21581243984076 >>> calcQuadraticArcLength((0, 0), (50, -10), (80, 50)) 102.53273816445825 >>> calcQuadraticArcLength((0, 0), (40, 0), (-40, 0)) # collinear points, control point outside 66.66666666666667 >>> calcQuadraticArcLength((0, 0), (40, 0), (0, 0)) # collinear points, looping back 40.0 )rr+r,r-r.s r1rrs @ #7C='3-# OOr2)r,r-r.d0d1dn)scaleorigDistabx0x1LencX- nX!- nXC- nUS-n[U5nUS:Xa [X - 5$[Xc5n[U5[:a?[X45S:a [X - 5$[U5[U5pX-X--X-- $[XS5U- n [XT5U- n [S[U 5[U 5- -U-X|U - -- 5n U $)aCalculates the arc length for a quadratic Bezier segment. Args: pt1: Start point of the Bezier as a complex number. pt2: Handle point of the Bezier as a complex number. pt3: End point of the Bezier as a complex number. Returns: Arc length value. y?rrW)rCrSepsilonr\)r,r-r.r_r`rarbrcrdrerfrgrhris r1rrs@ B B A BA FE |39~A{H 8}w <1 sy> !2wB1 !%(( ax B ax B a;r?[_45@ERTWDUV WC Jr2c@[[U6[U6[U65$)aCalculates the arc length for a quadratic Bezier segment. Uses Gauss-Legendre quadrature for a branch-free approximation. See :func:`calcQuadraticArcLength` for a slower but more accurate result. Args: pt1: Start point of the Bezier as 2D tuple. pt2: Handle point of the Bezier as 2D tuple. pt3: End point of the Bezier as 2D tuple. Returns: Approximate arc length value. )rr+r^s r1rrs  *'3-#QT VVr2r^)v0rMrNc[SU-SU--SU--5n[X - 5S-n[SU-SU-- SU--5nX4-U-$)aCalculates the arc length for a quadratic Bezier segment. Uses Gauss-Legendre quadrature for a branch-free approximation. See :func:`calcQuadraticArcLength` for a slower but more accurate result. Args: pt1: Start point of the Bezier as a complex number. pt2: Handle point of the Bezier as a complex number. pt3: End point of the Bezier as a complex number. Returns: Approximate arc length value. g̔xb߿gb?gFVW?gqq?gFVWg̔xb?rC)r,r-r.rnrMrNs r1rrsxB S #4s#::=ORU=UU B SY, ,B c!$5$;;>ORU>UU B 7R<r2c^[XU5uup4upVupxUS-n US-n /n U S:waU RU*U - 5 U S:waU RU*U - 5 U V s/sH4n SU s=::aS:dMO MX<-U -X\--U-XL-U -Xl--U-4PM6 sn X/-n [U 5$s sn f)aCalculates the bounding rectangle for a quadratic Bezier segment. Args: pt1: Start point of the Bezier as a 2D tuple. pt2: Handle point of the Bezier as a 2D tuple. pt3: End point of the Bezier as a 2D tuple. Returns: A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``. Example:: >>> calcQuadraticBounds((0, 0), (50, 100), (100, 0)) (0, 0, 100, 50.0) >>> calcQuadraticBounds((0, 0), (100, 0), (100, 100)) (0.0, 0.0, 100, 100) @rrX)calcQuadraticParametersappendr)r,r-r.axaybxbycxcyax2ay2rootstpointss r1rr*s$$;3S#I HRhr s(C s(C E ax bS3Y ax bS3YA :A: =  =!bf r !26A:#6#;< F f  sB*2B*6"B*cN[[U6[U6[U6[U65$)afApproximates the arc length for a cubic Bezier segment. Uses Gauss-Lobatto quadrature with n=5 points to approximate arc length. See :func:`calcCubicArcLength` for a slower but more accurate result. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. Returns: Arc length value. Example:: >>> approximateCubicArcLength((0, 0), (25, 100), (75, 100), (100, 0)) 190.04332968932817 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 50), (100, 100)) 154.8852074945903 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (150, 0)) # line; exact result should be 150. 149.99999999999991 >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (-50, 0)) # cusp; exact result should be 150. 136.9267662156362 >>> approximateCubicArcLength((0, 0), (50, 0), (100, -50), (-50, 0)) # cusp 154.80848416537057 )rr+rHs r1rrLs*2 & w}gsmWc] r2)rnrMrNv3v4c[X- 5S-n[SU-SU--SU--SU--5n[X0- U-U- 5S-n[SU-SU-- SU-- SU--5n[X2- 5S-nXE-U-U-U-$) zApproximates the arc length for a cubic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. Returns: Arc length value. g333333?gc1g85$t?gu|Y?g#$?g?g#$gc1?rp) r,r-r.r/rnrMrNrrs r1rrjs> SY$ B S c ! " c ! " c ! " B SY_s " #&9 9B S c ! " c ! " c ! " B SY$ B 7R<" r !!r2c[XX#5uupEupgupupUS-n US-n US-nUS-n[XU5Vs/sHnSUs=::aS:dMO MUPM nn[XU 5Vs/sHnSUs=::aS:dMO MUPM nnUU-nUVs/sH=nUU-U-U-UU-U--UU--U -UU-U-U-UU-U--U U--U -4PM? snX/-n[U5$s snfs snfs snf)a(Calculates the bounding rectangle for a quadratic Bezier segment. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. Returns: A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``. Example:: >>> calcCubicBounds((0, 0), (25, 100), (75, 100), (100, 0)) (0, 0, 100, 75.0) >>> calcCubicBounds((0, 0), (50, 0), (100, 50), (100, 100)) (0.0, 0.0, 100, 100) >>> print("%f %f %f %f" % calcCubicBounds((50, 0), (0, 100), (100, 100), (50, 0))) 35.566243 0.000000 64.433757 75.000000 @rrrrX)calcCubicParametersrr)r,r-r.r/rurvrwrxryrzdxdyax3ay3bx2by2r~xRootsyRootsr}rs r1rrsE$.A3-T*HRhr(2 s(C s(C s(C s(C'"5 D5Aa!aa5F D'"5 D5Aa!aa5F D VOE  A FQJNR!VaZ '"q& 02 5 FQJNR!VaZ '"q& 02 5   F f E Ds*C+C+C++C0C0C0AC5cUupEUupgXd- nXu- n Un Un X4Un U S:XaX4/$X*U 4U- U - n SU s=::aS:aO OX-U -X-U -4nX4X4/$X4/$)aSplit a line at a given coordinate. Args: pt1: Start point of line as 2D tuple. pt2: End point of line as 2D tuple. where: Position at which to split the line. isHorizontal: Direction of the ray splitting the line. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two line segments (each line segment being two 2D tuples) if the line was successfully split, or a list containing the original line. Example:: >>> printSegments(splitLine((0, 0), (100, 100), 50, True)) ((0, 0), (50, 50)) ((50, 50), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 100, True)) ((0, 0), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 0, True)) ((0, 0), (0, 0)) ((0, 0), (100, 100)) >>> printSegments(splitLine((0, 0), (100, 100), 0, False)) ((0, 0), (0, 0)) ((0, 0), (100, 100)) >>> printSegments(splitLine((100, 0), (0, 0), 50, False)) ((100, 0), (50, 0)) ((50, 0), (0, 0)) >>> printSegments(splitLine((0, 100), (0, 0), 50, True)) ((0, 100), (0, 50)) ((0, 50), (0, 0)) rrXr6)r,r-where isHorizontalpt1xpt1ypt2xpt2yrurvrwrxrer~midPts r1rrsHJDJD B B B B AAv | b,' '1,AAzz RVb[( ul++ |r2c[XU5upVn[XTXdXtU- 5n[SU55nU(dXU4/$[XVU/UQ76$)aSplit a quadratic Bezier curve at a given coordinate. Args: pt1,pt2,pt3: Control points of the Bezier as 2D tuples. where: Position at which to split the curve. isHorizontal: Direction of the ray splitting the curve. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two curve segments (each curve segment being three 2D tuples) if the curve was successfully split, or a list containing the original curve. Example:: >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 150, False)) ((0, 0), (50, 100), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, False)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, False)) ((0, 0), (12.5, 25), (25, 37.5)) ((25, 37.5), (62.5, 75), (100, 0)) >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, True)) ((0, 0), (7.32233, 14.6447), (14.6447, 25)) ((14.6447, 25), (50, 75), (85.3553, 25)) ((85.3553, 25), (92.6777, 14.6447), (100, -7.10543e-15)) >>> # XXX I'm not at all sure if the following behavior is desirable: >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, True)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (50, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) c3L# UHnSUs=::aS:dMO MUv M g7frrXNr6.0r~s r1 !splitQuadratic..":)QqAzzqzq) $$ $)rsrsorted_splitQuadraticAtT) r,r-r.rrrerfc solutionss r1rrseF&c4GA! !/E*AI:)::I 3  aA 2 22r2c[XX#5upgp[XeXuXXU- 5n [SU 55n U (dXX#4/$[XgX/U Q76$)aSplit a cubic Bezier curve at a given coordinate. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. where: Position at which to split the curve. isHorizontal: Direction of the ray splitting the curve. If true, ``where`` is interpreted as a Y coordinate; if false, then ``where`` is interpreted as an X coordinate. Returns: A list of two curve segments (each curve segment being four 2D tuples) if the curve was successfully split, or a list containing the original curve. Example:: >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 150, False)) ((0, 0), (25, 100), (75, 100), (100, 0)) >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 50, False)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (68.75, 75), (87.5, 50), (100, 0)) >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 25, True)) ((0, 0), (2.29379, 9.17517), (4.79804, 17.5085), (7.47414, 25)) ((7.47414, 25), (31.2886, 91.6667), (68.7114, 91.6667), (92.5259, 25)) ((92.5259, 25), (95.202, 17.5085), (97.7062, 9.17517), (100, 1.77636e-15)) c3L# UHnSUs=::aS:dMO MUv M g7frr6rs r1rsplitCubic..Grr)rr r_splitCubicAtT) r,r-r.r/rrrerfrrars r1rr(si6%Ss8JA! !/1?U;RI:)::I 3$%% ! 1y 11r2c:[XU5upEn[XEU/UQ76$)a]Split a quadratic Bezier curve at one or more values of t. Args: pt1,pt2,pt3: Control points of the Bezier as 2D tuples. *ts: Positions at which to split the curve. Returns: A list of curve segments (each curve segment being three 2D tuples). Examples:: >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (75, 50), (100, 0)) >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5, 0.75)) ((0, 0), (25, 50), (50, 50)) ((50, 50), (62.5, 50), (75, 37.5)) ((75, 37.5), (87.5, 25), (100, 0)) )rsr)r,r-r.tsrerfrs r1rrMs&(&c4GA! aA + ++r2c|[XX#5upVpx[XVXx/UQ76n U/U SSSQ7U S'/U SSSQUP7U S'U $)aSplit a cubic Bezier curve at one or more values of t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples. *ts: Positions at which to split the curve. Returns: A list of curve segments (each curve segment being four 2D tuples). Examples:: >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (68.75, 75), (87.5, 50), (100, 0)) >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5, 0.75)) ((0, 0), (12.5, 50), (31.25, 75), (50, 75)) ((50, 75), (59.375, 75), (68.75, 68.75), (77.3438, 56.25)) ((77.3438, 56.25), (85.9375, 43.75), (93.75, 25), (100, 0)) rrXN)rr) r,r-r.r/rrerfrrasplits r1rresd(%Ss8JA! 1 + +E #eAhqrl#E!H&%)CR.&#&E"I Lr2)r,r-r.r/rerfrrac'X# [XX#5upVpx[XVXx/UQ76ShvN gN7f)aSplit a cubic Bezier curve at one or more values of t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.. *ts: Positions at which to split the curve. Yields: Curve segments (each curve segment being four complex numbers). N)calcCubicParametersC_splitCubicAtTC) r,r-r.r/rrerfrras r1rrs,(&c9JA!qQ/B///s *(*)r~r,r-r.r/pointAtToff1off2)r _1_t_1_t_2_2_t_1_tcXD-nSU- nXf-nSU-U-nXv-U-SXt-U-Xe-U----XT-U--n Xp-X--XR--n Xq-X--XS--n XU- U--nX2U- U--nXX4XX#44$)zSplit a cubic Bezier curve at t. Args: pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers. t: Position at which to split the curve. Returns: A tuple of two curve segments (each curve segment being four complex numbers). rXrWr4r6) r,r-r.r/r~r rrrrrrs r1rrs0 B q5D [F1ut|H a6:#3di#o#EFFRUU  <(. (28 3D <(. (28 3D sa C sd" "C t &(B CCr2c[U5n/nURSS5 URS5 UupVUupxUup[[ U5S- 5Hn X;n X;S-n X- nX-nX_-nXo-nSU-U -U-U-nSU-U -U-U-nX-nUU-X|--U -nUU-X--U -n[ UU4UU4UU45unnnURUUU45 M U$)NrrkrJrXrW)listinsertrtrangelencalcQuadraticPoints)rerfrrsegmentsrurvrwrxryrzir r deltadelta_2a1xa1yb1xb1yt1_2c1xc1yr,r-r.s r1rrs bBHIIaIIcN FB FB FB 3r7Q;  U AY-ll2v{R5(2v{R5(w4i"'!B&4i"'!B&+S#Jc S#JO S#c3( Or2c\[U5nURSS5 URS5 /nUupgUupUupUup[[ U5S- 5HnXNnXNS-nUU- nUU-nUU-nX-nUU-nUU-nUU-nSU-U-U-U-nSU-U-U -U-nSU-U-U -SU-U--U-nSU -U-U -SU-U--U-nUU-UU--X--U -nUU-U U--X--U -n[ UU4UU4UU4UU45unnn n!URUUU U!45 M U$NrrkrJrXr4rW)rrrtrrcalcCubicPoints)"rerfrrarrrurvrwrxryrzrrrr r rrdelta_3rt1_3rrrrrrd1xd1yr,r-r.r/s" r1rrs bBIIaIIcNH FB FB FB FB 3r7Q;  U AYR%-'/wDy7l7l2v{R7*2v{R7*2v{R!b&4-/582v{R!b&4-/584i"t)#bg-24i"t)#bg-2, #Jc S#Jc  S#s c3,-- . Or2) rerfrrar r rrra1b1c1r`c'# [U5nURSS5 URS5 [[ U5S- 5HvnXEnXES-nXv- nX-n X-n Xf-n Xk-n X -n SU-U-U-U -nSU-U-U-SU-U --U-nX -X--X&--U-n[ XUU5unnnnUUUU4v Mx g7fr)rrrtrrcalcCubicPointsC)rerfrrarrr r rrrrrrrrr`r,r-r.r/s r1rrs bBIIaIIcN 3r7Q;  U AY-/wy[!ebj1n '!ebj1nq1ut|+u 4 X 16 )A --bb"=S#sCc""! sCC)rZacoscospic[U5[:a![U5[:a/nU$U*U- /nU$X-SU-U-- nUS:a"U"U5nU*U-S- U- U*U- S- U- /nU$/nU$)u'Solve a quadratic equation. Solves *a*x*x + b*x + c = 0* where a, b and c are real. Args: a: coefficient of *x²* b: coefficient of *x* c: constant term Returns: A list of roots. Note that the returned list is neither guaranteed to be sorted nor to contain unique values! @rkrrrCrl)rerfrrZr}DDrDDs r1rr/s 1v q6G E LR!VHE LUS1Wq[  9r(Cb3h#%)QBH+;a+?@E LE Lr2c [U5[:a [XU5$[U5nX- nX - nX0- nXD-SU-- S- nSU-U-U-SU-U-- SU--S- nX-n Xw-U-n U [:aSOU n [U 5[:aSOU n X- n U S:XaU S:Xa[ U*S- [ 5n XU /$U [S-::Gay[ [[U[U 5- S 5S 55n S [U5-nUS- nU[U S- 5-U- nU[U S[--S- 5-U- nU[U S [--S- 5-U- n[UUU/5unnnUU- [:a+UU- [:a[ UU-U-S- [ 5=n=nnOUU- [:a)[ UU-S- [ 5=nn[ U[ 5nOfUU- [:a)[ U[ 5n[ UU-S- [ 5=nnO0[ U[ 5n[ U[ 5n[ U[ 5nUUU/$[[U 5[U5-S 5n XU - -n US:aU *n [ XS- - [ 5n U /$)uSolve a cubic equation. Solves *a*x*x*x + b*x*x + c*x + d = 0* where a, b, c and d are real. Args: a: coefficient of *x³* b: coefficient of *x²* c: coefficient of *x* d: constant term Returns: A list of roots. Note that the returned list is neither guaranteed to be sorted nor to contain unique values! Examples:: >>> solveCubic(1, 1, -6, 0) [-3.0, -0.0, 2.0] >>> solveCubic(-10.0, -9.0, 48.0, -29.0) [-2.9, 1.0, 1.0] >>> solveCubic(-9.875, -9.0, 47.625, -28.75) [-2.911392, 1.0, 1.0] >>> solveCubic(1.0, -4.5, 6.75, -3.375) [1.5, 1.5, 1.5] >>> solveCubic(-12.0, 18.0, -9.0, 1.50023651123) [0.5, 0.5, 0.5] >>> solveCubic( ... 9.0, 0.0, 0.0, -7.62939453125e-05 ... ) == [-0.0, -0.0, -0.0] True rg"@rrg;@gK@rrkr5rJggrUUUUUU?)rCrlrfloatround epsilonDigitsrmaxminrZrrrpow)rerfrrara2a3QRR2Q3R2_Q3rUthetarQ2a1_3rgrhx2s r1r r PsL 1vaA&& aA B B B 38 s"A rB cBhm +dRi 74?A B B7lB"gRB GE SyR3Y 2#)] +ay 'C- SQb\3/67T!WnCx 3us{# #d * 3b(C/0 04 7 3b(C/0 04 7RRL) B 7W b7!2 "r'B,#!5}E EB Eb "Ww R"WO]; ;Br=)B "Ww r=)BR"WO]; ;Br=)Br=)Br=)BB| U c!f$g . AI 8A !3h, .s r2cbUup4UupVUupxX7- S-n XH- S-n XW- U - n Xh- U - n X4X4Xx44$)Nrrr6) r,r-r.ry2x3y3ryrzrwrxrurvs r1rsrssV FB FB FB 'SB 'SB 2B 2B 8bXx ''r2cUupEUupgUupUupXJ- S-n X[- S-n Xd- S-U - nXu- S-U - nX- U - U- nX- U - U- nUU4X4X4X44$Nrr6)r,r-r.r/rrrrx4y4rrryrzrwrxrurvs r1rrs FB FB FB FB 'SB 'SB 'S2 B 'S2 B 2 B 2 B 8bXx" 11r2)r,r-r.r/rerfrc@X- S-nX!- S-U- nX0- U- U- nXeX@4$rr6)r,r-r.r/rrfres r1rrs; cA cAA A A !>r2cnUup4UupVUupxUn Un US-U-n US-U-n X5-U-n XF-U-nX4X4X44$rBr6)rerfrrurvrwrxryrzrhy1rrrrs r1rrsd FB FB FB B B s(bB s(bB 2B 2B 8bXx ''r2cUupEUupgUupUupU n U n US- U -nU S- U -nXh-S- U-nXy-S- U-nXJ-U-U-nX[-U -U-nX4X4UU4UU44$rr6)rerfrrarurvrwrxryrzrrrhrrrrrrrs r1rrs FB FB FB FB B B s(bB s(bB 'S2 B 'S2 B 2 B 2 B 8bXBx"b 11r2rerfrrar9r:p4cBUS-U-nX-S-U-nX-U-U-nX4XV4$)Nrr6rs r1rrs; eqB %E R B QB 2?r2cRUSSU- -USU--USSU- -USU--4$)zFinds the point at time `t` on a line. Args: pt1, pt2: Coordinates of the line as 2D tuples. t: The time along the line. Returns: A 2D tuple with the coordinates of the point. rrXr6)r,r-r~s r1r$r$sCVq1u A *c!fA.>Q!.K MMr2cSU- SU- -US-SSU- -U-US--X3-US--nSU- SU- -US-SSU- -U-US--X3-US--nXE4$)zFinds the point at time `t` on a quadratic curve. Args: pt1, pt2, pt3: Coordinates of the curve as 2D tuples. t: The time along the curve. Returns: A 2D tuple with the coordinates of the point. rXrrWr6)r,r-r.r~rUys r1r!r!s Q1q5CF"Q!a%[1_s1v%==ANA Q1q5CF"Q!a%[1_s1v%==ANA 6Mr2cXD-nSU- nXf-nXv-US-SXt-US-Xe-US----XT-US--nXv-US-SXt-US-Xe-US----XT-US--n X4$)zFinds the point at time `t` on a cubic curve. Args: pt1, pt2, pt3, pt4: Coordinates of the curve as 2D tuples. t: The time along the curve. Returns: A 2D tuple with the coordinates of the point. rXrr4r6) r,r-r.r/r~r rrrUrs r1r"r",s B q5D [F A vzCF"TYQ%77 8 9 &3q6/   A vzCF"TYQ%77 8 9 &3q6/  6Mr2)r~r,r-r.r/)r rrc`XD-nSU- nXf-nXv-U-SXt-U-Xe-U----XT-U--$)zFinds the point at time `t` on a cubic curve. Args: pt1, pt2, pt3, pt4: Coordinates of the curve as complex numbers. t: The time along the curve. Returns: A complex number with the coordinates of the point. rXr4r6)r,r-r.r/r~r rrs r1r#r#FsP& B q5D [F =3 fj3&6S&H!I IBFUXL XXr2c[U5S:Xa [/UQUP76$[U5S:Xa [/UQUP76$[U5S:Xa [/UQUP76$[ S5eNrWr4Unknown curve degree)rr$r!r" ValueError)segr~s r1r%r%_sh 3x1}$S$!$$ SQ )#)q)) SQ%c%1%% + ,,r2cUup4UupVUupx[X5- 5[:a[XF- 5[:ag[X5- 5[XF- 5:a Xs- XS- - $X- Xd- - $)Nrr) ser sxsyexeypxpys r1 _line_t_of_ptrnsg FB FB FB 27|g#bg,"8 27|c"'l"BG$$BG$$r2cUSUS- USUS- -nUSUS- USUS- -nUS:*=(a US:*(+$)NrrXrkr6)rerforiginxDiffyDiffs r1'_both_points_are_on_same_side_of_originr|s` qTF1I !A$"2 3E qTF1I !A$"2 3E -# ..r2c UupEUupgUupUup[R"X5(a8[R"XF5(a[R"XH5(d/$[R"X5(a8[R"XW5(a[R"XY5(d/$[R"X5(a[R"X5(a/$[R"XF5(a[R"XW5(a/$[R"Xd5(a8Un X- X- - n XU- -U -nX4n[U[XU5[X#U5S9/$[R"X5(a8Un Xu- Xd- - nUX- -U-nX4n[U[XU5[X#U5S9/$Xu- Xd- - nX- X- - n [R"UU 5(a/$UU-U- X-- U -UU - - n UX- -U-nX4n[ XU5(a1[ XU5(a [U[XU5[X#U5S9/$/$)aFinds intersections between two line segments. Args: s1, e1: Coordinates of the first line as 2D tuples. s2, e2: Coordinates of the second line as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> a = lineLineIntersections( (310,389), (453, 222), (289, 251), (447, 367)) >>> len(a) 1 >>> intersection = a[0] >>> intersection.pt (374.44882952482897, 313.73458370177315) >>> (intersection.t1, intersection.t2) (0.45069111555824465, 0.5408153767394238) r )rYiscloser rr)s1e1s2e2s1xs1ye1xe1ys2xs2ye2xe2yrUslope34rr slope12s r1r&r&sE.HCHCHCHC S4<<#9#9$,,sBXBX  S4<<#9#9$,,sBXBX  ||C$,,s"8"8  ||C$,,s"8"8  ||C 9+ 3w # %V -3 bb8Q    ||C 9+ qw # %V -3 bb8Q   ySY'GySY'G ||GW%% 3 w} ,s 2w7HIA17c!A B.  1"" = = -3 bb8Q   Ir2cUSnUSn[R"USUS- USUS- 5n[R"U*5R US*US*5$)NrrrX)rYatan2rrotate translate)segmentstartendangles r1_alignment_transformationr0sj AJE "+C JJs1va(#a&58*; .s<]cQm!m!m!]r) r0transformPointsrrsrrr rr)curveline aligned_curvererfr intersectionsras r1_curve_line_intersections_tr9s-d3CCEJM 5zQ)=9a&qtQqT1Q48 Uq(-8 a"1Q41qtQqT: /00 <]< <>> curve = [ (100, 240), (30, 60), (210, 230), (160, 30) ] >>> line = [ (25, 260), (230, 20) ] >>> intersections = curveLineIntersections(curve, line) >>> len(intersections) 3 >>> intersections[0].pt (84.9000930760723, 189.87306176459828) r4rrr ) rr!r"rr9rr$rtr )r5r6 pointFinderr8r~r line_ts r1r'r's* 5zQ' Uq# /00M ( 5  #% # #))b)  (4 ( (\R&AB 6 r2ct[U5S:Xa[U6$[U5S:Xa[U6$[S5e)Nr4rr)rrrr)rs r1 _curve_boundsr> s: 1v{"A&& Q1"" + ,,r2c[U5S:XaUup#[X#U5nX$4XC4/$[U5S:Xa [/UQUP76$[U5S:Xa [/UQUP76$[ S5er)rr$rrr)rr~r r midpoints r1_split_segment_at_trAsw 1v{a( }-- 1v{ '!'Q'' Q1#a### + ,,r2c ^[U5n[U5nU(dSnU(dSn[XV5upxU(d/$Sn [U5T:a [U5T:aU "U5U "U54/$[US5upUSU "U54n U "U5US4n [US5upUSU "U54nU "U5US4n/nUR [ XTU US95 UR [ XTU US95 UR [ XTU US95 UR [ XTU US95 U4Sjn[ 5n/nUH5nU"U5nUU;aMURU5 URU5 M7 U$)N)rkrJcSUSUS--$)Nr5rrXr6)rs r1r@._curve_curve_intersections_t..midpoint1sadQqTk""r2r5rrX)range1range2cH>[UST- 5[UST- 54$)NrrX)int)r precisions r1._curve_curve_intersections_t..Vs&SA!23SA9J5KLr2) r>rrrAextend_curve_curve_intersections_tsetaddrt)curve1curve2rJrFrGbounds1bounds2 intersects_r@c11c12 c11_range c12_rangec21c22 c21_range c22_rangefound unique_keyseen unique_valuesrkeys ` r1rNrN!sF#GF#G  W.MJ  #9$'):Y)F&!8F#3455"63/HCHV,-I&!6!9-I"63/HCHV,-I&!6!9-I E LL$ i )   LL$ i )   LL$ i )   LL$ i )  MJ 5DMn $;   R  r2cZ[U5RU5n[SU55$)Nc3V# UHn[R"USS5v M! g7f)rXrkN)rYr)rps r1r_is_linelike..fs": 1t||AaD#&& s'))r0r4all)r, maybelines r1 _is_linelikerjds()'2BB7KI : : ::r2c `[U5(a<USUS4n[U5(aUSUS4n[/UQUQ76$[X5$[U5(aUSUS4n[X5$[X5nUVs/sH n[ [ XS5USUSS9PM" sn$s snf)aFinds intersections between a curve and a curve. Args: curve1: List of coordinates of the first curve segment as 2D tuples. curve2: List of coordinates of the second curve segment as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ] >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ] >>> intersections = curveCurveIntersections(curve1, curve2) >>> len(intersections) 3 >>> intersections[0].pt (81.7831487395506, 109.88904552375288) rrrXr )rjr&r'rNr r%)rQrRline1line2intersection_tsrs r1r(r(is*Fq 6":%   1Ivbz)E(8%8%8 8)&8 8 f  q 6":%%f4426BO" !B 162a5RUK!  s'B+c Sn[U5[U5:aXpSn[U5S:a'[U5S:a [X5nOC[X5nO7[U5S:Xa[U5S:Xa[/UQUQ76nO [ S5eU(dU$UVs/sH,n[ UR URURS9PM. sn$s snf)aFinds intersections between two segments. Args: seg1: List of coordinates of the first segment as 2D tuples. seg2: List of coordinates of the second segment as 2D tuples. Returns: A list of ``Intersection`` objects, each object having ``pt``, ``t1`` and ``t2`` attributes containing the intersection point, time on first segment and time on second segment respectively. Examples:: >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ] >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ] >>> intersections = segmentSegmentIntersections(curve1, curve2) >>> len(intersections) 3 >>> intersections[0].pt (81.7831487395506, 109.88904552375288) >>> curve3 = [ (100, 240), (30, 60), (210, 230), (160, 30) ] >>> line = [ (25, 260), (230, 20) ] >>> intersections = segmentSegmentIntersections(curve3, line) >>> len(intersections) 3 >>> intersections[0].pt (84.9000930760723, 189.87306176459828) FTrWz4Couldn't work out which intersection function to user ) rr(r'r&rr r r r )seg1seg2swappedr8rs r1r)r)s<G 4y3t9d 4y1} t9q=3D?M24>M TaCIN-;t;d; OPP =J K]LADDQTTadd 3] KK Ks3Ccz[U5nSSRSU55-$![a SU-s$f=f)zk >>> _segmentrepr([1, [2, 3], [], [[2, [3, 4], [0.1, 2.2]]]]) '(1, (2, 3), (), ((2, (3, 4), (0.1, 2.2))))' z(%s)z, c38# UHn[U5v M g7frP) _segmentrepr)rrUs r1r_segmentrepr..s!>2a,q//2sz%g)iterjoin TypeError)objits r1rurusG ? #Y !>2!>>>> czs (::c>UHn[[U55 M g)zdHelper for the doctests, displaying each segment in a list of segments on a single line as a tuple. N)printru)rr,s r1 printSegmentsr~s l7#$r2__main__)g{Gzt?)gMbP?NN)X__doc__fontTools.misc.arrayToolsrrrfontTools.misc.transformrrY collectionsrrAttributeError ImportErrorfontTools.misccompiledCOMPILEDrDr __all__rr=returnsdoublelocalsr+rErrrlcfuncinlinerSr\rrrrrrrrrrrrrrrrrrrZrrrrr rsrrrrrr$r!r"r#r%rrr&r0r9r'r>rArNrjr(r)rur~__name__sysdoctestexittestmodfailedr6r2r1rsXED- "& ?? .*<=  @&  ~~ ~~ ~~ ~~  FMM 6==I  J      mm  A   A  &..V^^4&5& ; ; PF  ~~ ~~ nn nn -- ]] mm mm }} }} &@W"   }} }} }}   BD<    }} }} }} }} }} !" !"H#L6r*3Z"2J,0> nn nn nn nn  0  0 mm ^^    }}6==D  D46 F nn nn nn nn }} }} -- MM MM ~~ ~~ ~~ ~~##6%$"&BYB( 2 nn nn nn ( 2  nn nn nn nn ~~ ~~ ~~ N 4 mm &--fmmFMMJ YK  Y - %/ K\C =#L- -9=@F; $N-L` ?% zHHW__  % %& S.  $&%%&sa00bb