
    +g=                    $   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    p/home/viktor/gitlab-persoonlijk/factuur-applicatie/venv/lib/python3.12/site-packages/fontTools/misc/transform.py_normSinCosr   F   sE    
1v
 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 )zTransform 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"$b1frAvo&:;;r   c                ~    | \  }}}}}}|D 	cg c]!  \  }}	||z  ||	z  z   |z   ||z  ||	z  z   |z   f# c}	}S c c}	}w )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    pointsr   r   r   r   r   r   r"   r#   s
             r   transformPointszTransform.transformPoints   sU     "&BBBIOPAa"q&2%rAvQ';<PPPs   &9c                L    |\  }}| dd \  }}}}||z  ||z  z   ||z  ||z  z   fS )zTransform 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bqBBR"r'!27R"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     bqBBELM62rb27"BGb2g$56MMMs    4c                0    | j                  dddd||f      S )zReturn 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1a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1a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!aRAq122r   c                |    | j                  dt        j                  |      t        j                  |      dddf      S )zReturn 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+txx{Aq!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#sC'+$S#sC~~#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#sC',$S#sC~~#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2gRcB39rcCicABBrBG#bS2XR%7B~~b"b"b"55r   c                    d| z  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]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    )dnn.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 )zReturn 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1aA&&r   c                *    || }t        | dd|dd      S )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)
            <Transform [2 0 0 3 0 0]>
            >>>
    r   rk   rl   s     r   r	   r	     s#     	yQ1a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
   zThe 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    OOq  "!#"}}!" {{a" {{a	"
 zzQ" zzQ" }}!" }}!
	
r   c                   |\  }}}}}}t        j                  d|      }|dk  r
||z  }||z  }||z  ||z  z
  }	d}
dx}}d}|dk7  s|dk7  rt        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     %1aAq]]1a 6GAGAAA 6Q!V		!a%!a%-(A+,6tyyQ'		!a%8H7HHFFIIq1uq1u}Q78E!VqAv		!a%!a%-(Aww{%&!V		1"q&!$))AE2B1BH $aiFF "LL"RKLL"$

 
	
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 )zReturn 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KKOOdmm+T__t}}-L
 HHT\\$--01GGDKK-FF4<<

+T\\$**-EFKK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HeFEFEE5E5HeHe
 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CHH_W__%%&	 r   