Ë
    £eh¶=  ã                  ó$  — d Z ddlmZ ddlZddlmZ ddlmZ g d¢ZdZ	de	z
  Z
d	e	z   Zdd
„Z G d„ de«      Z e«       Zddd„Zddd„Ze G d„ d«      «       Zedk(  r4ddlZddlZ ej*                   ej,                  «       j.                  «       yy)a7  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)Ú	TransformÚIdentityÚOffsetÚScaleÚDecomposedTransformgVçž¯Ò<é   éÿÿÿÿc                ób   — t        | «      t        k  rd} | S | t        kD  rd} | S | t        k  rd} | S )Nr   r   r   )ÚabsÚ_EPSILONÚ_ONE_EPSILONÚ_MINUS_ONE_EPSILON)Úvs    úV/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/fontTools/misc/transform.pyÚ_normSinCosr   F   sE   € Ü
ˆ1ƒv”ÒØˆð
 €Hð	 
Œ\Ò	Øˆð €Hð 
ÔÒ	ØˆØ€Hó    c                  óÖ   — e Zd ZU dZdZded<   dZded<   dZded<   dZded<   dZ	ded	<   dZ
ded
<   d„ Zd„ Zd„ Zd„ Zddd„Zddd„Zdd„Zddd„Zd„ Zd„ Zd„ Zd d„Zd!d„Zd"d„Zd d„Zy)#r   aœ	  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
            <Transform [1 0 0 1 0 0]>
            >>> t.scale(2)
            <Transform [2 0 0 2 0 0]>
            >>> t.scale(2.5, 5.5)
            <Transform [2.5 0 0 5.5 0 0]>
            >>>
            >>> 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 [12 0 0 1 0 0]>
            >>> Transform(dx=12)
            <Transform [1 0 0 1 12 0]>
            >>> Transform(yx=12)
            <Transform [1 0 12 1 0 0]>

    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
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t2
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t1 == t2
            0

    Transform instances are hashable, meaning you can use them as
    keys in dictionaries::

            >>> d = {Scale(12, 13): None}
            >>> d
            {<Transform [12 0 0 13 0 0]>: 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
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t2
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> d = {t1: None}
            >>> d
            {<Transform [0.2 0 0 0.3 0.08 0.18]>: None}
            >>> d[t2]
            Traceback (most recent call last):
              File "<stdin>", line 1, in ?
            KeyError: <Transform [0.2 0 0 0.3 0.08 0.18]>
    r   ÚfloatÚxxr   ÚxyÚyxÚyyÚdxÚdyc                óV   — |\  }}| \  }}}}}}	||z  ||z  z   |z   ||z  ||z  z   |	z   fS )zÍTransform a point.

        :Example:

                >>> t = Transform()
                >>> t = t.scale(2.5, 5.5)
                >>> t.transformPoint((100, 100))
                (250.0, 550.0)
        © )
ÚselfÚpÚxÚyr   r   r   r   r   r   s
             r   ÚtransformPointzTransform.transformPoint¦   sL   € ð ‰ˆˆAØ!%ÑˆˆB��B˜˜BØ�Q‘˜˜a™‘ "Ñ$ b¨1¡f¨r°A©v¡o¸Ñ&:Ð;Ð;r   c                ó~   — | \  }}}}}}|D ��	cg c]!  \  }}	||z  ||	z  z   |z   ||z  ||	z  z   |z   f‘Œ# c}	}S c c}	}w )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)]
                >>>
        r   )
r    Úpointsr   r   r   r   r   r   r"   r#   s
             r   ÚtransformPointszTransform.transformPoints´   sU   € ð "&ÑˆˆB��B˜˜BØIO×PÁÀÀA��a‘˜"˜q™&‘ 2Ñ% r¨A¡v°°Q±¡¸Ñ';Ò<ÓPÐPùÓPs   �&9c                óL   — |\  }}| dd \  }}}}||z  ||z  z   ||z  ||z  z   fS )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   )r    r   r   r   r   r   r   r   s           r   ÚtransformVectorzTransform.transformVectorÁ   sE   € ð ‰ˆˆRØ˜b˜q˜‰ˆˆB��BØ�R‘˜"˜r™'Ñ! 2¨¡7¨R°"©WÑ#4Ð5Ð5r   c                ót   — | dd \  }}}}|D ��cg c]  \  }}||z  ||z  z   ||z  ||z  z   f‘Œ c}}S c c}}w )a  Transform 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    Úvectorsr   r   r   r   r   r   s           r   ÚtransformVectorszTransform.transformVectorsÏ   sN   € ð ˜b˜q˜‰ˆˆB��BØEL×M¹6¸2¸r��b‘˜2 ™7Ñ" B¨¡G¨b°2©gÑ$5Ò6ÓMÐMùÓMs   � 4c                ó0   — | j                  dddd||f«      S )záReturn a new transformation, translated (offset) by x, y.

        :Example:
                >>> t = Transform()
                >>> t.translate(20, 30)
                <Transform [1 0 0 1 20 30]>
                >>>
        r   r   ©Ú	transform©r    r"   r#   s      r   Ú	translatezTransform.translateÛ   s    € ð �~‰~˜q ! Q¨¨1¨aÐ0Ó1Ð1r   Nc                ó8   — |€|}| j                  |dd|ddf«      S )ak  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)
                <Transform [5 0 0 5 0 0]>
                >>> t.scale(5, 6)
                <Transform [5 0 0 6 0 0]>
                >>>
        r   r/   r1   s      r   ÚscalezTransform.scaleæ   s*   € ð ˆ9ØˆAØ�~‰~˜q ! Q¨¨1¨aÐ0Ó1Ð1r   c                óª   — t        t        j                  |«      «      }t        t        j                  |«      «      }| j	                  ||| |ddf«      S )a  Return a new transformation, rotated by 'angle' (radians).

        :Example:
                >>> import math
                >>> t = Transform()
                >>> t.rotate(math.pi / 2)
                <Transform [0 1 -1 0 0 0]>
                >>>
        r   )r   ÚmathÚcosÚsinr0   )r    ÚangleÚcÚss       r   ÚrotatezTransform.rotateö   sF   € ô œŸ™ ›Ó(ˆÜœŸ™ ›Ó(ˆØ�~‰~˜q ! a R¨¨A¨qÐ1Ó2Ð2r   c                ó|   — | j                  dt        j                  |«      t        j                  |«      dddf«      S )zõReturn a new transformation, skewed by x and y.

        :Example:
                >>> import math
                >>> t = Transform()
                >>> t.skew(math.pi / 4)
                <Transform [1 0 1 1 0 0]>
                >>>
        r   r   )r0   r6   Útanr1   s      r   ÚskewzTransform.skew  s0   € ð �~‰~˜q¤$§(¡(¨1£+¬t¯x©x¸«{¸A¸qÀ!ÐDÓEÐEr   c           
     óÊ   — |\  }}}}}}| \  }}	}
}}}| j                  ||z  ||
z  z   ||	z  ||z  z   ||z  ||
z  z   ||	z  ||z  z   ||z  |
|z  z   |z   |	|z  ||z  z   |z   «      S )a  Return a new transformation, transformed by another
        transformation.

        :Example:
                >>> t = Transform(2, 0, 0, 3, 1, 6)
                >>> t.transform((4, 3, 2, 1, 5, 6))
                <Transform [8 9 4 3 11 24]>
                >>>
        ©Ú	__class__©r    ÚotherÚxx1Úxy1Úyx1Úyy1Údx1Údy1Úxx2Úxy2Úyx2Úyy2Údx2Údy2s                 r   r0   zTransform.transform  s£   € ð (-Ñ$ˆˆS�#�s˜C Ø'+Ñ$ˆˆS�#�s˜C Ø�~‰~Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ! CÑ'Ø�#‰I˜˜c™	Ñ! CÑ'ó
ð 	
r   c           
     óÊ   — | \  }}}}}}|\  }}	}
}}}| j                  ||z  ||
z  z   ||	z  ||z  z   ||z  ||
z  z   ||	z  ||z  z   ||z  |
|z  z   |z   |	|z  ||z  z   |z   «      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 [8 6 6 3 21 15]>
                >>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6))
                <Transform [8 6 6 3 21 15]>
                >>>
        rA   rC   s                 r   ÚreverseTransformzTransform.reverseTransform%  s£   € ð (,Ñ$ˆˆS�#�s˜C Ø',Ñ$ˆˆS�#�s˜C Ø�~‰~Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ! CÑ'Ø�#‰I˜˜c™	Ñ! CÑ'ó
ð 	
r   c                óÎ   — | t         k(  r| S | \  }}}}}}||z  ||z  z
  }||z  | |z  | |z  ||z  f\  }}}}| |z  ||z  z
  | |z  ||z  z
  }}| j                  ||||||«      S )aK  Return 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)
                >>>
        )r   rB   )r    r   r   r   r   r   r   Údets           r   ÚinversezTransform.inverse=  sŸ   € ð ”8ÒØˆKØ!%ÑˆˆB��B˜˜BØ�2‰g˜˜R™ÑˆØ˜c™ B 3¨¡9¨r¨c°C©i¸¸c¹ÐA‰ˆˆB��BØ��r‘˜B ™GÑ# b S¨2¡X°°R±Ñ%7ˆBˆØ�~‰~˜b " b¨"¨b°"Ó5Ð5r   c                ó   — d| z  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   ©r    s    r   ÚtoPSzTransform.toPSQ  s   € ð % tÑ+Ð+r   c                ó,   — t         j                  | «      S )z%Decompose into a DecomposedTransform.)r
   ÚfromTransformrW   s    r   ÚtoDecomposedzTransform.toDecomposed]  s   € ä"×0Ñ0°Ó6Ð6r   c                ó   — | t         k7  S )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
        )r   rW   s    r   Ú__bool__zTransform.__bool__a  s   € ð( ”xÑÐr   c                ó<   — d| j                   j                  f| z   z  S )Nz<%s [%g %g %g %g %g %g]>)rB   Ú__name__rW   s    r   Ú__repr__zTransform.__repr__w  s   € Ø)¨d¯n©n×.EÑ.EÐ-GÈ$Ñ-NÑOÐOr   ©r   r   )r"   r   r#   r   )r   N)r"   r   r#   úfloat | None)r9   r   )ÚreturnÚstr)rc   z'DecomposedTransform')rc   Úbool)r_   Ú
__module__Ú__qualname__Ú__doc__r   Ú__annotations__r   r   r   r   r   r$   r'   r*   r-   r2   r4   r<   r?   r0   rR   rU   rX   r[   r]   r`   r   r   r   r   r   P   s�   … ñLð\ €BˆƒMØ€BˆƒMØ€BˆƒMØ€BˆƒMØ€BˆƒMØ€BˆƒMò<òQò6ò
Nô	2ô2ó 3ô
Fò
ò*
ò06ó(
,ó7ó ô,Pr   r   c                ó"   — t        dddd| |«      S )z™Return the identity transformation offset by x, y.

    :Example:
            >>> Offset(2, 3)
            <Transform [1 0 0 1 2 3]>
            >>>
    r   r   ©r   ©r"   r#   s     r   r   r   ~  s   € ô �Q˜˜1˜a  AÓ&Ð&r   c                ó*   — |€| }t        | dd|dd«      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)
            <Transform [2 0 0 3 0 0]>
            >>>
    r   rk   rl   s     r   r	   r	   ‰  s#   € ð 	€yØˆÜ�Q˜˜1˜a  AÓ&Ð&r   c                  ó®   — e Zd ZU dZdZded<   dZded<   dZded<   dZded<   dZ	ded	<   dZ
ded
<   dZded<   dZded<   dZded<   d„ Zed„ «       Zdd„Zy)r
   z˜The DecomposedTransform class implements a transformation with separate
    translate, rotation, scale, skew, and transformation-center components.
    r   r   Ú
translateXÚ
translateYÚrotationr   ÚscaleXÚscaleYÚskewXÚskewYÚtCenterXÚtCenterYc                ó0  — | j                   dk7  xs† | j                  dk7  xsu | j                  dk7  xsd | j                  dk7  xsS | j                  dk7  xsB | j
                  dk7  xs1 | j                  dk7  xs  | j                  dk7  xs | j                  dk7  S )Nr   r   )	ro   rp   rq   rr   rs   rt   ru   rv   rw   rW   s    r   r]   zDecomposedTransform.__bool__§  s¥   € à�O‰O˜qÑ ò "Ø�‰ !Ñ#ò"à�}‰} Ñ!ò"ð �{‰{˜aÑò"ð �{‰{˜aÑò	"ð
 �z‰z˜Q‰ò"ð �z‰z˜Q‰ò"ð �}‰} Ñ!ò"ð �}‰} Ñ!ð
	
r   c                ó  — |\  }}}}}}t        j                  d|«      }|dk  r
||z  }||z  }||z  ||z  z
  }	d}
dx}}d}|dk7  s|dk7  r€t        j                  ||z  ||z  z   «      }|dk\  rt        j                  ||z  «      nt        j                  ||z  «       }
||	|z  }}t        j                  ||z  ||z  z   ||z  z  «      }n||dk7  s|dk7  rqt        j                  ||z  ||z  z   «      }t         j
                  dz  |dk\  rt        j                  | |z  «      nt        j                  ||z  «       z
  }
|	|z  |}}n	 t        ||t        j                  |
«      ||z  |t        j                  |«      |z  ddd«	      S )au  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   r   é   g        )r6   ÚcopysignÚsqrtÚacosÚatanÚpir
   Údegrees)r    r0   ÚaÚbr:   Údr"   r#   ÚsxÚdeltarq   rr   rs   rt   Úrr;   s                   r   rZ   z!DecomposedTransform.fromTransform´  s¡  € ð  %Ñˆˆ1ˆa��A�qä�]‰]˜1˜aÓ ˆØ�Š6Ø�‰GˆAØ�‰GˆAà�A‘˜˜A™‘ˆàˆØÐˆ�Øˆð �Š6�Q˜!’VÜ—	‘	˜!˜a™% ! a¡%™-Ó(ˆAØ+,°ª6”t—y‘y  Q¡Ô'¼¿	¹	À!ÀaÁ%Ó8HÐ7HˆHØ ¨¡�FˆFÜ—I‘I˜q 1™u q¨1¡u™}°°Q±Ñ7Ó8‰EØ�!ŠV�q˜A’vÜ—	‘	˜!˜a™% ! a¡%™-Ó(ˆAÜ—w‘w ‘{Ø%&¨!¢V”—	‘	˜1˜"˜q™&Ô!´$·)±)¸AÀ¹EÓ2BÐ1BñˆHð $ a™i¨�F‰Fð ä"ØØÜ�L‰L˜Ó"Ø�R‰KØÜ�L‰L˜Ó "Ñ$ØØØó

ð 
	
r   c                ó*  — t        «       }|j                  | j                  | j                  z   | j                  | j
                  z   «      }|j                  t        j                  | j                  «      «      }|j                  | j                  | j                  «      }|j                  t        j                  | j                  «      t        j                  | j                  «      «      }|j                  | j                   | j
                   «      }|S )zÝReturn the Transform() equivalent of this transformation.

        :Example:
                >>> DecomposedTransform(scaleX=2, scaleY=2).toTransform()
                <Transform [2 0 0 2 0 0]>
                >>>
        )r   r2   ro   rv   rp   rw   r<   r6   Úradiansrq   r4   rr   rs   r?   rt   ru   )r    Úts     r   ÚtoTransformzDecomposedTransform.toTransformí  s¸   € ô ‹KˆØ�K‰KØ�O‰O˜dŸm™mÑ+¨T¯_©_¸t¿}¹}Ñ-Ló
ˆð �H‰H”T—\‘\ $§-¡-Ó0Ó1ˆØ�G‰G�D—K‘K §¡Ó-ˆØ�F‰F”4—<‘< §
¡
Ó+¬T¯\©\¸$¿*¹*Ó-EÓFˆØ�K‰K˜Ÿ™˜¨¯©¨Ó7ˆØˆr   N)rc   r   )r_   rf   rg   rh   ro   ri   rp   rq   rr   rs   rt   ru   rv   rw   r]   ÚclassmethodrZ   rŠ   r   r   r   r
   r
   —  s‚   … ñð €J�ÓØ€J�ÓØ€HˆeÓØ€FˆEÓØ€FˆEÓØ€Eˆ5ÓØ€Eˆ5ÓØ€HˆeÓØ€HˆeÓò
ð ñ6
ó ð6
ôpr   r
   Ú__main__)r   r   rc   r   ra   )r"   r   r#   r   rc   r   )N)r"   r   r#   rb   rc   r   )rh   Ú
__future__r   r6   Útypingr   Údataclassesr   Ú__all__r   r   r   r   r   r   r   r	   r
   r_   ÚsysÚdoctestÚexitÚtestmodÚfailedr   r   r   ú<module>r–      s³   ðñ4õl #ã Ý Ý !ò N€ð €Ø�8‰|€Ø˜(‘]Ð óôhP�
ô hPñV	 ‹;€ô'ô'ð ÷eð eó ðeðP ˆzÒÛÛà€C‡H�Hˆ_ˆW�_‰_Ó×%Ñ%Õ&ð	 r   