o ¼Ç h¶=ã@sÆdZddlmZddlZddlmZddlmZgd¢ZdZ de Z d e Z dd d„Z Gdd„deƒZ e ƒZdddd„Zdddd„ZeGdd„dƒƒZedkraddlZddlZe e ¡j¡dSdS) a7Affine 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)Ú TransformÚIdentityÚOffsetÚScaleÚDecomposedTransformgV瞯Ò<ééÿÿÿÿÚvÚfloatÚreturncCs4t|ƒtkr d}|S|tkrd}|S|tkrd}|S)Nrr r )ÚabsÚ_EPSILONÚ _ONE_EPSILONÚ_MINUS_ONE_EPSILON)r ©rúl/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/fontTools/misc/transform.pyÚ _normSinCosFs üþrc@sèeZdZUdZdZded<dZded<dZded<dZded<dZ ded <dZ ded <d d „Z d d„Z dd„Z dd„Zd2d3dd„Zd4d5dd„Zd6dd„Zd2d3dd„Zd d!„Zd"d#„Zd$d%„Zd7d(d)„Zd8d+d,„Zd9d.d/„Zd7d0d1„ZdS):raœ 2x2 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 r ÚxxrÚxyÚyxÚyyÚdxÚdyc Cs@|\}}|\}}}}}} |||||||||| fS)zÍTransform a point. :Example: >>> t = Transform() >>> t = t.scale(2.5, 5.5) >>> t.transformPoint((100, 100)) (250.0, 550.0) r) ÚselfÚpÚxÚyrrrrrrrrrÚtransformPoint¦s (zTransform.transformPointcs,|\‰‰‰‰‰‰‡‡‡‡‡‡fdd„|DƒS)zùTransform 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|]\}}ˆ|ˆ|ˆˆ|ˆ|ˆf‘qSrr)Ú.0rr©rrrrrrrrÚ ¿s8z-Transform.transformPoints..r)rÚpointsrr"rÚtransformPoints´s zTransform.transformPointscCs<|\}}|dd…\}}}}||||||||fS)zéTransform an (dx, dy) vector, treating translation as zero. :Example: >>> t = Transform(2, 0, 0, 2, 10, 20) >>> t.transformVector((3, -4)) (6, -8) >>> Nér)rr rrrrrrrrrÚtransformVectorÁs  zTransform.transformVectorcs,|dd…\‰‰‰‰‡‡‡‡fdd„|DƒS)aTransform 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|]\}}ˆ|ˆ|ˆ|ˆ|f‘qSrr)r!rr©rrrrrrr#Ùs0z.Transform.transformVectors..r)rÚvectorsrr(rÚtransformVectorsÏs zTransform.transformVectorsrrcCs| dddd||f¡S)záReturn a new transformation, translated (offset) by x, y. :Example: >>> t = Transform() >>> t.translate(20, 30) >>> r r©Ú transform©rrrrrrÚ translateÛs zTransform.translateNú float | NonecCs"|dur|}| |dd|ddf¡S)akReturn 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-rrrÚscaleæs zTransform.scaleÚanglecCs4tt |¡ƒ}tt |¡ƒ}| ||| |ddf¡S)aReturn a new transformation, rotated by 'angle' (radians). :Example: >>> import math >>> t = Transform() >>> t.rotate(math.pi / 2) >>> r)rÚmathÚcosÚsinr,)rr1ÚcÚsrrrÚrotateös zTransform.rotatecCs"| dt |¡t |¡dddf¡S)zõReturn a new transformation, skewed by x and y. :Example: >>> import math >>> t = Transform() >>> t.skew(math.pi / 4) >>> r r)r,r2Útanr-rrrÚskews" zTransform.skewc Cs„|\}}}}}}|\}} } } } } | |||| || || |||| || || ||| || | || || ¡S)aReturn 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ÚotherÚxx1Úxy1Úyx1Úyy1Údx1Údy1Úxx2Úxy2Úyx2Úyy2Údx2Údy2rrrr,s úzTransform.transformc Cs„|\}}}}}}|\}} } } } } | |||| || || |||| || || ||| || | || || ¡S)aíReturn 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)) >>> r:r<rrrÚreverseTransform%s úzTransform.reverseTransformcCsŽ|tkr|S|\}}}}}}||||}||| || |||f\}}}}| |||| |||}}| ||||||¡S)aKReturn 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) >>> )rr;)rrrrrrrÚdetrrrÚinverse=s (&zTransform.inverserÚstrcCsd|S)zÎReturn 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©rrrrÚtoPSQs zTransform.toPSú'DecomposedTransform'cCs t |¡S)z%Decompose into a DecomposedTransform.)r Ú fromTransformrNrrrÚ toDecomposed]s zTransform.toDecomposedÚboolcCs|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 )rrNrrrÚ__bool__aszTransform.__bool__cCsd|jjf|S)Nz<%s [%g %g %g %g %g %g]>)r;Ú__name__rNrrrÚ__repr__wszTransform.__repr__©rr)rr rr )r N)rr rr/)r1r )rrM)rrP)rrS)rUÚ __module__Ú __qualname__Ú__doc__rÚ__annotations__rrrrrr r%r'r*r.r0r7r9r,rJrLrOrRrTrVrrrrrPs.  N           rrrcCstdddd||ƒS)z™Return the identity transformation offset by x, y. :Example: >>> Offset(2, 3) >>> r r©r©rrrrrr~srr/cCs|dur|}t|dd|ddƒS)zêReturn 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) >>> Nrr\r]rrrr‰s rc@sœeZdZUdZdZded<dZded<dZded<dZded<dZ ded <dZ ded <dZ ded <dZ ded <dZ ded <dd„Zedd„ƒZddd„ZdS)r z˜The DecomposedTransform class implements a transformation with separate translate, rotation, scale, skew, and transformation-center components. rr Ú translateXÚ translateYÚrotationr ÚscaleXÚscaleYÚskewXÚskewYÚtCenterXÚtCenterYcCsZ|jdkp,|jdkp,|jdkp,|jdkp,|jdkp,|jdkp,|jdkp,|jdkp,|jdkS)Nrr ) r^r_r`rarbrcrdrerfrNrrrrT§s" ÿþýüûúù÷zDecomposedTransform.__bool__c Csd|\}}}}}}t d|¡}|dkr||9}||9}||||} d} d} } d} |dks2|dkrgt ||||¡}|dkrHt ||¡nt ||¡ } || |} } t ||||||¡} n5|dkso|dkr›t ||||¡}tjd|dkrŠt | |¡nt ||¡ } | ||} } n t||t | ¡| || t | ¡|dddƒ S)auReturn 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 rég)r2ÚcopysignÚsqrtÚacosÚatanÚpir Údegrees)rr,ÚaÚbr5ÚdrrÚsxÚdeltar`rarbrcÚrr6rrrrQ´s@ & &ÿ ÷z!DecomposedTransform.fromTransformrrcCsxtƒ}| |j|j|j|j¡}| t |j ¡¡}|  |j |j ¡}|  t |j¡t |j¡¡}| |j |j ¡}|S)zÝReturn the Transform() equivalent of this transformation. :Example: >>> DecomposedTransform(scaleX=2, scaleY=2).toTransform() >>> )rr.r^rer_rfr7r2Úradiansr`r0rarbr9rcrd)rÚtrrrÚ toTransformísÿzDecomposedTransform.toTransformN)rr)rUrXrYrZr^r[r_r`rarbrcrdrerfrTÚ classmethodrQrvrrrrr —s           8r Ú__main__)r r rr rW)rr rr rr)N)rr rr/rr)rZÚ __future__rr2ÚtypingrÚ dataclassesrÚ__all__rrrrrrrrr rUÚsysÚdoctestÚexitÚtestmodÚfailedrrrrÚs. 6    -  hü