o:i=0SrSSKJr SSKrSSKJr SSKJr /SQrSr S\ - r S \ -r SS jr "S S \5r \ "5rSSS jjrSSSjjr\"SS55r\S:Xa4SSKrSSKr\R*"\R,"5R.5 gg)a Affine 2D transformation matrix class. The Transform class implements various transformation matrix operations, both on the matrix itself, as well as on 2D coordinates. Transform instances are effectively immutable: all methods that operate on the transformation itself always return a new instance. This has as the interesting side effect that Transform instances are hashable, ie. they can be used as dictionary keys. This module exports the following symbols: Transform this is the main class Identity Transform instance set to the identity transformation Offset Convenience function that returns a translating transformation Scale Convenience function that returns a scaling transformation The DecomposedTransform class implements a transformation with separate translate, rotation, scale, skew, and transformation-center components. :Example: >>> t = Transform(2, 0, 0, 3, 0, 0) >>> t.transformPoint((100, 100)) (200, 300) >>> t = Scale(2, 3) >>> t.transformPoint((100, 100)) (200, 300) >>> t.transformPoint((0, 0)) (0, 0) >>> t = Offset(2, 3) >>> t.transformPoint((100, 100)) (102, 103) >>> t.transformPoint((0, 0)) (2, 3) >>> t2 = t.scale(0.5) >>> t2.transformPoint((100, 100)) (52.0, 53.0) >>> import math >>> t3 = t2.rotate(math.pi / 2) >>> t3.transformPoint((0, 0)) (2.0, 3.0) >>> t3.transformPoint((100, 100)) (-48.0, 53.0) >>> t = Identity.scale(0.5).translate(100, 200).skew(0.1, 0.2) >>> t.transformPoints([(0, 0), (1, 1), (100, 100)]) [(50.0, 100.0), (50.550167336042726, 100.60135501775433), (105.01673360427253, 160.13550177543362)] >>> ) annotationsN) NamedTuple) dataclass) TransformIdentityOffsetScaleDecomposedTransformgV瞯<ch[U5[:aSnU$U[:aSnU$U[:aSnU$)Nrr r )abs_EPSILON _ONE_EPSILON_MINUS_ONE_EPSILON)vs [/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/fontTools/misc/transform.py _normSinCosrFsE 1v  H \   H    Hc\rSrSr%SrSrS\S'SrS\S'SrS\S'Sr S\S 'Sr S\S 'Sr S\S 'S r S r SrSrSSSjjrSS SjjrS!SjrSSSjjrSrSrSrS"SjrS#SjrS$SjrS"SjrSrg)%rPa2x2 transformation matrix plus offset, a.k.a. Affine transform. Transform instances are immutable: all transforming methods, eg. rotate(), return a new Transform instance. :Example: >>> t = Transform() >>> t >>> t.scale(2) >>> t.scale(2.5, 5.5) >>> >>> t.scale(2, 3).transformPoint((100, 100)) (200, 300) Transform's constructor takes six arguments, all of which are optional, and can be used as keyword arguments:: >>> Transform(12) >>> Transform(dx=12) >>> Transform(yx=12) Transform instances also behave like sequences of length 6:: >>> len(Identity) 6 >>> list(Identity) [1, 0, 0, 1, 0, 0] >>> tuple(Identity) (1, 0, 0, 1, 0, 0) Transform instances are comparable:: >>> t1 = Identity.scale(2, 3).translate(4, 6) >>> t2 = Identity.translate(8, 18).scale(2, 3) >>> t1 == t2 1 But beware of floating point rounding errors:: >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6) >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3) >>> t1 >>> t2 >>> t1 == t2 0 Transform instances are hashable, meaning you can use them as keys in dictionaries:: >>> d = {Scale(12, 13): None} >>> d {: None} But again, beware of floating point rounding errors:: >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6) >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3) >>> t1 >>> t2 >>> d = {t1: None} >>> d {: None} >>> d[t2] Traceback (most recent call last): File "", line 1, in ? KeyError: r floatxxrxyyxyydxdycFUup#UupEpgpXB-Xc--U-XR-Xs--U -4$)zTransform a point. :Example: >>> t = Transform() >>> t = t.scale(2.5, 5.5) >>> t.transformPoint((100, 100)) (250.0, 550.0) ) selfpxyrrrrrrs rtransformPointTransform.transformPoints<!%"$bfrvo&:;;rctUup#pEpgUVV s/sHupX(-XI--U-X8-XY--U-4PM sn n$s sn nf)zTransform a list of points. :Example: >>> t = Scale(2, 3) >>> t.transformPoints([(0, 0), (0, 100), (100, 100), (100, 0)]) [(0, 0), (0, 300), (200, 300), (200, 0)] >>> r ) r!pointsrrrrrrr#r$s rtransformPointsTransform.transformPointssI"&IOP"&2%rv';<PPPs$4c>Uup#USSupEpgXB-Xc--XR-Xs--4$)zTransform an (dx, dy) vector, treating translation as zero. :Example: >>> t = Transform(2, 0, 0, 2, 10, 20) >>> t.transformVector((3, -4)) (6, -8) >>> Nr )r!rrrrrrrs rtransformVectorTransform.transformVectors7bq"'!27RW#455rclUSSup#pEUVVs/sHupgX&-XG--X6-XW--4PM snn$s snnf)zTransform a list of (dx, dy) vector, treating translation as zero. :Example: >>> t = Transform(2, 0, 0, 2, 10, 20) >>> t.transformVectors([(3, -4), (5, -6)]) [(6, -8), (10, -12)] >>> Nr,r )r!vectorsrrrrrrs rtransformVectorsTransform.transformVectorssDbqELMW6227"BGbg$56WMMMs0c.URSSSSX45$)zReturn a new transformation, translated (offset) by x, y. :Example: >>> t = Transform() >>> t.translate(20, 30) >>> r r transformr!r#r$s r translateTransform.translates~~q!Q1011rNc:UcUnURUSSUSS45$)a#Return a new transformation, scaled by x, y. The 'y' argument may be None, which implies to use the x value for y as well. :Example: >>> t = Transform() >>> t.scale(5) >>> t.scale(5, 6) >>> rr4r6s rscaleTransform.scales* 9A~~q!Q1a011rc[[R"U55n[[R"U55nUR X#U*USS45$)zReturn a new transformation, rotated by 'angle' (radians). :Example: >>> import math >>> t = Transform() >>> t.rotate(math.pi / 2) >>> r)rmathcossinr5)r!anglecss rrotateTransform.rotatesD  (  (~~qaRAq122rcURS[R"U5[R"U5SSS45$)zReturn a new transformation, skewed by x and y. :Example: >>> import math >>> t = Transform() >>> t.skew(math.pi / 4) >>> r r)r5r=tanr6s rskewTransform.skews0~~q$((1+txx{Aq!DEErc Uup#pEpgUupppURX(-X:--X)-X;--XH-XZ--XI-X[--X-X--U -X-X--U -5$)zReturn a new transformation, transformed by another transformation. :Example: >>> t = Transform(2, 0, 0, 3, 1, 6) >>> t.transform((4, 3, 2, 1, 5, 6)) >>>  __class__r!otherxx1xy1yx1yy1dx1dy1xx2xy2yx2yy2dx2dy2s rr5Transform.transforms(-$#C'+$#C~~ I ! I ! I ! I ! I !C ' I !C '   rc Uup#pEpgUupppURX(-X:--X)-X;--XH-XZ--XI-X[--X-X--U -X-X--U -5$)aReturn a new transformation, which is the other transformation transformed by self. self.reverseTransform(other) is equivalent to other.transform(self). :Example: >>> t = Transform(2, 0, 0, 3, 1, 6) >>> t.reverseTransform((4, 3, 2, 1, 5, 6)) >>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6)) >>> rJrLs rreverseTransformTransform.reverseTransform%s(,$#C',$#C~~ I ! I ! I ! I ! I !C ' I !C '   rcU[:XaU$Uupp4pVX-X2-- nXG- U*U- U*U- X- 4upp4U*U-X6-- U*U-XF-- peURXX4XV5$)aReturn the inverse transformation. :Example: >>> t = Identity.translate(2, 3).scale(4, 5) >>> t.transformPoint((10, 20)) (42, 103) >>> it = t.inverse() >>> it.transformPoint((42, 103)) (10.0, 20.0) >>> )rrK)r!rrrrrrdets rinverseTransform.inverse=s 8 K!%gB39rcCiArBG#bS2X%7B~~bbb55rc SU-$)zReturn a PostScript representation :Example: >>> t = Identity.scale(2, 3).translate(4, 5) >>> t.toPS() '[2 0 0 3 8 15]' >>> z[%s %s %s %s %s %s]r r!s rtoPSTransform.toPSQs%t++rc,[RU5$)z%Decompose into a DecomposedTransform.)r fromTransformrcs r toDecomposedTransform.toDecomposed]s"0066rcU[:g$)akReturns True if transform is not identity, False otherwise. :Example: >>> bool(Identity) False >>> bool(Transform()) False >>> bool(Scale(1.)) False >>> bool(Scale(2)) True >>> bool(Offset()) False >>> bool(Offset(0)) False >>> bool(Offset(2)) True )rrcs r__bool__Transform.__bool__as(xrc<SURR4U--$)Nz<%s [%g %g %g %g %g %g]>)rK__name__rcs r__repr__Transform.__repr__ws)dnn.E.E-G$-NOOrr rr)r#rr$r)r N)r#rr$ float | None)r@r)returnstr)rsz'DecomposedTransform')rsbool)rn __module__ __qualname____firstlineno____doc__r__annotations__rrrrrr%r)r-r1r7r:rCrGr5r\r`rdrhrkro__static_attributes__r rrrrPsL\BMBMBMBMBMBM < Q 6 N 22 3 F * 06( ,7 ,Prrc [SSSSX5$)zReturn the identity transformation offset by x, y. :Example: >>> Offset(2, 3) >>> r rrr#r$s rrr~s Q1a &&rc,UcUn[USSUSS5$)zReturn the identity transformation scaled by x, y. The 'y' argument may be None, which implies to use the x value for y as well. :Example: >>> Scale(2, 3) >>> rr}r~s rr r s# y  Q1aA &&rc\rSrSr%SrSrS\S'SrS\S'SrS\S'Sr S\S 'Sr S\S 'Sr S\S 'Sr S\S 'Sr S\S 'SrS\S'Sr\S5rSSjrSrg)r izThe DecomposedTransform class implements a transformation with separate translate, rotation, scale, skew, and transformation-center components. rr translateX translateYrotationr scaleXscaleYskewXskewYtCenterXtCenterYcURS:g=(d URS:g=(d URS:g=(d} URS:g=(dg URS:g=(dQ UR S:g=(d; UR S:g=(d% URS:g=(d URS:g$)Nrr ) rrrrrrrrrrcs rrkDecomposedTransform.__bool__s OOq  "!# "}}! "{{a "{{a  " zzQ  " zzQ  "}}! "}}! rc Uup#pEpg[R"SU5nUS:aX(-nX8-nX%-X4-- n Sn S=pSn US:wdUS:wa|[R"X"-X3--5nUS:a[R"X.- 5O[R"X.- 5*n XU- p[R"X$-X5--X-- 5n O}US:wdUS:wap[R"XD-XU--5n[R S- US:a[R"U*U- 5O[R"XO- 5*- n X- UpO[ UU[R"U 5X-U [R"U 5U-SSS5 $)a-Return a DecomposedTransform() equivalent of this transformation. The returned solution always has skewY = 0, and angle in the (-180, 180]. :Example: >>> DecomposedTransform.fromTransform(Transform(3, 0, 0, 2, 0, 0)) DecomposedTransform(translateX=0, translateY=0, rotation=0.0, scaleX=3.0, scaleY=2.0, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0) >>> DecomposedTransform.fromTransform(Transform(0, 0, 0, 1, 0, 0)) DecomposedTransform(translateX=0, translateY=0, rotation=0.0, scaleX=0.0, scaleY=1.0, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0) >>> DecomposedTransform.fromTransform(Transform(0, 0, 1, 1, 0, 0)) DecomposedTransform(translateX=0, translateY=0, rotation=-45.0, scaleX=0.0, scaleY=1.4142135623730951, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0) r rg)r=copysignsqrtacosatanpir degrees)r!r5abrAdr#r$sxdeltarrrrrrBs rrg!DecomposedTransform.fromTransformss %aA ]]1a  6 GA GA  6Q!V !%!%-(A+,6tyy' !%8H7HHFIIququ}78E !VqAv !%!%-(Aww{%&!V 1"q&!$))AE2B1BH$iF " LL " K  LL " $    rc0[5nURURUR-URUR -5nUR [R"UR55nURURUR5nUR[R"UR5[R"UR55nURUR*UR *5nU$)zReturn the Transform() equivalent of this transformation. :Example: >>> DecomposedTransform(scaleX=2, scaleY=2).toTransform() >>> )rr7rrrrrCr=radiansrr:rrrGrr)r!ts r toTransformDecomposedTransform.toTransforms K KK OOdmm +T__t}}-L  HHT\\$--0 1 GGDKK - FF4<< +T\\$**-E F KK 7rr N)rsr)rnrvrwrxryrrzrrrrrrrrrk classmethodrgrr{r rrr r sJJHeFEFEE5E5HeHe  6 6 prr __main__)rrrsrrq)r#rr$rrsr)N)r#rr$rrrsr)ry __future__rr=typingr dataclassesr__all__rrrrrrrr r rnsysdoctestexittestmodfailedr rrrs4l# ! N 8| (] hP hPV ;' ' ee eP zHHW__  % %& r