a Eb$@sdZddlmZgdZdZdeZdeZddZGd d d eZeZ dd d Z dddZ e dkrdd l Z dd lZe ejd S)aAffine 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 :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)] >>> ) NamedTuple) TransformIdentityOffsetScalegV瞯<cCs0t|tkrd}n|tkr d}n |tkr,d}|S)Nrrr)abs_EPSILON _ONE_EPSILON_MINUS_ONE_EPSILON)vrX/home/ja/django-apps/lartica_env/lib/python3.9/site-packages/fontTools/misc/transform.py _normSinCos?s rc@seZdZUdZdZeed<dZeed<dZeed<dZ eed<dZ eed<dZ eed <d d Z d d Z ddZddZd'ddZd(ddZddZd)ddZddZddZdd Zd!d"Zd#d$Zd%d&ZdS)*ra2x2 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: rxxrxyyxyydxdyc Cs@|\}}|\}}}}}} |||||||||| fS)zTransform a point. :Example: >>> t = Transform() >>> t = t.scale(2.5, 5.5) >>> t.transformPoint((100, 100)) (250.0, 550.0) r) selfpxyrrrrrrrrrtransformPoints zTransform.transformPointcs,|\fdd|DS)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)] >>> cs8g|]0\}}||||fqSrr).0rrrrrrrrrr z-Transform.transformPoints..r)rZpointsrrrtransformPointss zTransform.transformPointscCs<|\}}|dd\}}}}||||||||fS)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)rr rrrrrrrrrtransformVectors zTransform.transformVectorcs,|dd\fdd|DS)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!cs0g|](\}}||||fqSrr)rrrrrrrrrrrz.Transform.transformVectors..r)rZvectorsrr#rtransformVectorss zTransform.transformVectorscCs|dddd||fS)zReturn a new transformation, translated (offset) by x, y. :Example: >>> t = Transform() >>> t.translate(20, 30) >>> rr transformrrrrrr translates zTransform.translateNcCs"|dur |}||dd|ddfS)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) >>> Nrr%r'rrrscales zTransform.scalecCs<ddl}t||}t||}|||| |ddfS)zReturn a new transformation, rotated by 'angle' (radians). :Example: >>> import math >>> t = Transform() >>> t.rotate(math.pi / 2) >>> rN)mathrcossinr&)rZangler*csrrrrotates zTransform.rotatecCs*ddl}|d||||dddfS)zReturn a new transformation, skewed by x and y. :Example: >>> import math >>> t = Transform() >>> t.skew(math.pi / 4) >>> rNr)r*r&tan)rrrr*rrrskews zTransform.skewc Cs|\}}}}}}|\}} } } } } ||||| || || |||| || || ||| || | || || S)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__rotherZxx1Zxy1Zyx1Zyy1Zdx1Zdy1Zxx2Zxy2Zyx2Zyy2Zdx2Zdy2rrrr& s zTransform.transformc Cs|\}}}}}}|\}} } } } } ||||| || || |||| || || ||| || | || || S)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)) >>> r2r4rrrreverseTransform s zTransform.reverseTransformcCs|tkr |S|\}}}}}}||||}||| || |||f\}}}}| |||| |||}}|||||||S)zReturn 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) >>> )rr3)rrrrrrrZdetrrrinverse7s (&zTransform.inversecCsd|S)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]rrrrrtoPSKs zTransform.toPScCs|tkS)a)Returns 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 )rr8rrr__bool__WszTransform.__bool__cCsd|jjf|S)Nz<%s [%g %g %g %g %g %g]>)r3__name__r8rrr__repr__mszTransform.__repr__)rr)rN)rr)r; __module__ __qualname____doc__rfloat__annotations__rrrrrrr r"r$r(r)r/r1r&r6r7r9r:r<rrrrrIs* N          rcCstdddd||S)zuReturn the identity transformation offset by x, y. :Example: >>> Offset(2, 3) >>> rrrrrrrrrssrNcCs|dur |}t|dd|ddS)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) >>> NrrBrCrrrr}s r__main__)rr)N)r?typingr__all__r r r rrrrrr;sysdoctestexittestmodfailedrrrrs 3  *