
    BPc*                       d Z ddlmZ ddlZddlZddlZddlmZmZm	Z	m
Z
mZmZmZ ddlmZmZmZmZmZmZmZmZmZ ddlmZmZmZmZmZ ddlmZm Z   ed	d
          Z! edd          Z"dZ# ej$        d          Z%d Z& G d de'          Z( G d d
ej)                  Z* G d de*          Z+ G d de*          Z, G d de,          Z- G d de+          Z. G d de,          Z/ G d de+          Z0 G d d e,          Z1 G d! d"e+          Z2 G d# d$e,          Z3 G d% d&e+          Z4 G d' d(e,          Z5 G d) d*e+          Z6 G d+ d,e,          Z7 G d- d.e+          Z8 G d/ d0e,          Z9 G d1 d2e+          Z: G d3 d4e,          Z; G d5 d6e+          Z< G d7 d8e,          Z= G d9 d:e+          Z> G d; d<e,          Z? G d= d>e+          Z@i d?e/d@e-dAe5dBe3dCe?dDe7dEe9dFe1dGe;dHe=dIe0dJe.dKe6dLe4dMe@dNe8dOe:e2e<e>dPe*_A         G dQ dReB          ZC G dS dTeB          ZDdU ZEdV ZFdW ZGdX ZHdY ZIdS )Zz
functions for digesting paths
    )annotationsN)atan2cospisinsqrtacostan)	AnyTypeDictOptionalUnionTupleList	GeneratorTypeVar   )	TransformBoundingBoxVector2dcubic_extremaquadratic_extrema)classpropertystrargsPathlikePathCommand)boundAbsolutePathlikeAbsolutePathCommand)PathCubicSuperPathr   r    RelativePathCommandLinelineMovemove	ZoneClose	zoneCloseHorzhorzVertvertCurvecurveSmoothsmooth	Quadratic	quadraticTepidQuadratictepidQuadraticArcarcInvalidPathz2([MLHVCSQTAZmlhvcsqtaz])([^MLHVCSQTAZmlhvcsqtaz]*)c                
    | d uS N )objs    -/usr/share/inkscape/extensions/inkex/paths.py<lambda>r>   V   s
    3d?     c                      e Zd ZdZdS )r8   z(Raised when given an invalid path stringN)__name__
__module____qualname____doc__r;   r?   r=   r8   r8   Y   s        2222r?   r8   c                  H   e Zd ZdZdZed             Zed             Zed             Ze	d             Z
e	d             Zd Zd	 Zd
 Zd ZdZi Zed             Ze	d             Zd$dZed             Zd Zd Zd Zd Zd%dZ e            fd Z e            fd!Zd" Z d#S )&r   z)
    Base class of all path commands
    c                    | j         S z2The full name of the segment (i.e. Line, Arc, etc))rA   clss    r=   namezPathCommand.namee   s     |r?   c                    | j         d         S )AThe single letter representation of this command (i.e. L, A, etc)r   )rK   rI   s    r=   letterzPathCommand.letterj   s     x{r?   c                    | S )zThe implicit next command. This is for automatic chains where the next
        command isn't given, just a bunch on numbers which we automatically parse.r;   selfs    r=   next_commandzPathCommand.next_commando   s	     r?   c                    t           )zWhether the command is defined in relative coordinates, i.e. relative to
        the previous endpoint (lower case path command letter)NotImplementedErrorrP   s    r=   is_relativezPathCommand.is_relativeu   
     "!r?   c                    t           )z_Whether the command is defined in absolute coordinates (upper case path
        command letter)rT   rP   s    r=   is_absolutezPathCommand.is_absolute{   rW   r?   c                    t           )zFReturn absolute counterpart for absolute commands or copy for relativerT   rQ   prevs     r=   to_relativezPathCommand.to_relative       !!r?   c                    t           zFReturn relative counterpart for relative commands or copy for absoluterT   r[   s     r=   to_absolutezPathCommand.to_absolute   r^   r?   c                    dS )z3Reverse path command

        .. versionadded:: 1.1Nr;   rQ   firstr\   s      r=   reversezPathCommand.reverse   s      r?   c                ,    |                      |          S )zGReturn an absolute non-shorthand command

        .. versionadded:: 1.1)ra   rQ   r\   prev_controls      r=   to_non_shorthandzPathCommand.to_non_shorthand   s    
 %%%r?   z{:.6g}c                &    t           j        |          S )z+Returns class for given path command letter)r   _letter_to_class)rN   s    r=   letter_to_classzPathCommand.letter_to_class   s     +F33r?   c                    t                      z1Returns path command arguments as tuple of floatsrT   rP   s    r=   argszPathCommand.args   s     "###r?   rd   r   r\   	prev_prevreturn6Union[List[Vector2d], Generator[Vector2d, None, None]]c                    t           z+Returns list of path command control pointsrT   rQ   rd   r\   rp   s       r=   control_pointszPathCommand.control_points   rW   r?   c                H    |                     | j        g| j        z            S r:   )joinnumber_templatenargs)rJ   seps     r=   _argtzPathCommand._argt   s!    xx,-	9:::r?   c                ~    | j          d |                     d          j        | j                                          S )N )rN   r|   formatro   striprP   s    r=   __str__zPathCommand.__str__   s;    +DD 6

3 6	 BDDJJLLLr?   c                ~     d                     |                     d                    j         | j        g| j        R  S )Nz{{}}({})z, )r   r|   rK   ro   rP   s    r=   __repr__zPathCommand.__repr__   s;    9z  D!1!1229$)PdiPPPPr?   c                   t                      }t          |           t          |          k    r| j        |j        k    S t          |t                    r| j        |k    S t          |t
                    st          d          	 | j        |j        k    r,|                     |          |                    |          k    S n# t          $ r Y nw xY wdS )NzCan't compare typesF)	r   typero   
isinstancetupler   
ValueErrorrV   to_curve)rQ   otherpreviouss      r=   __eq__zPathCommand.__eq__   s    ::::e$$9
**eU## 	&9%%%-- 	42333	5#444}}X..%..2J2JJJ 5 	 	 	D	us   ;C 
CCc                    t                      z*Returns last control point of path commandrT   rc   s      r=   	end_pointzPathCommand.end_point   s    !###r?   last_two_pointsList[Vector2d]bboxr   c                0    t          d| j                   )a=  Enlarges given bbox to contain path element.

        Args:
            first (Vector2d): first point of path. Required to calculate Z segment
            last_two_points (List[Vector2d]): list with last two control points in abs
                coords.
            bbox (BoundingBox): bounding box to update
        z$Bounding box is not implemented for rU   rK   rQ   rd   r   r   s       r=   update_bounding_boxzPathCommand.update_bounding_box   s     ""T"T"TUUUr?   c                0    t          d| j                   )zXConvert command to :py:class:`Curve`

        Curve().to_curve() returns a copy
        zTo curve not supported for r   rQ   r\   rp   s      r=   r   zPathCommand.to_curve   s     ""K	"K"KLLLr?   c                0    |                      ||          gS z5Convert command to list of :py:class:`Curve` commandsr   r   s      r=   	to_curveszPathCommand.to_curves   s     dI..//r?   c                T    t          |                     t                      |           S )z:Converts this segment to a line (copies if already a line))r$   r   r   r[   s     r=   to_linezPathCommand.to_line   s!     T^^HJJ5566r?   Nrd   r   r\   r   rp   r   rq   rr   )rd   r   r   r   r   r   )!rA   rB   rC   rD   rz   r   rK   rN   rR   propertyrV   rY   r]   ra   re   ri   ry   rk   staticmethodrl   ro   rv   classmethodr|   r   r   r   r   r   r   r   r   r   r;   r?   r=   r   r   ]   s        
 E  ]   ]   ]
 " " X"
 " " X"
" " "" " "! ! !
& & & O 4 4 \4 $ $ X$" " " " ; ; [;M M MQ Q Q  $ $ $V V V V (0xzz M M M M )1

 0 0 0 0
7 7 7 7 7r?   c                      e Zd ZdZed             Zed             Zdd
Zd Zd Z	d Z
 e            fdZ e            fdZdS )r#   z
    Abstract base class for relative path commands.

    Implements most of methods of :py:class:`PathCommand` through
    conversion to :py:class:`AbsolutePathCommand`
    c                    dS NTr;   rP   s    r=   rV   zRelativePathCommand.is_relative       tr?   c                    dS NFr;   rP   s    r=   rY   zRelativePathCommand.is_absolute       ur?   rd   r   r\   rp   rq   rr   c                V    |                      |                              |||          S r:   )ra   rv   ru   s       r=   rv   z"RelativePathCommand.control_points   s*     %%44UD)LLLr?   c                      | j         | j         S r:   	__class__ro   r[   s     r=   r]   zRelativePathCommand.to_relative  s    t~ty))r?   c                f    |                      |d                                       |||           d S NrF   )ra   r   r   s       r=   r   z'RelativePathCommand.update_bounding_box  s>    ,--AA?D	
 	
 	
 	
 	
r?   c                T    |                      |                              ||          S r:   )ra   r   rc   s      r=   r   zRelativePathCommand.end_point
  s&    %%//t<<<r?   c                T    |                      |                              ||          S r:   )ra   r   r   s      r=   r   zRelativePathCommand.to_curve  s&    %%..tY???r?   c                T    |                      |                              ||          S r:   )ra   r   r   s      r=   r   zRelativePathCommand.to_curves  s&    %%//i@@@r?   Nr   )rA   rB   rC   rD   r   rV   rY   rv   r]   r   r   r   r   r   r;   r?   r=   r#   r#      s            X   XM M M M
* * *
 
 

= = = (0xzz @ @ @ @ )1

 A A A A A Ar?   r#   c                  \    e Zd ZdZed             Zed             Zd Zd Zd Z	d Z
d Zd	S )
r    z^Absolute path command. Unlike :py:class:`RelativePathCommand` can be transformed
    directly.c                    dS r   r;   rP   s    r=   rV   zAbsolutePathCommand.is_relative  r   r?   c                    dS r   r;   rP   s    r=   rY   zAbsolutePathCommand.is_absolute  r   r?   c                      | j         | j         S r:   r   r[   s     r=   ra   zAbsolutePathCommand.to_absolute#  s     t~ty))r?   c                    t                      )z]Returns new transformed segment

        :param transform: a transformation to apply
        rT   rQ   	transforms     r=   r   zAbsolutePathCommand.transform(  s     "###r?   c                f    |                      t          ||d         |d         f                    S )z
        Returns new transformed segment

        :param degrees: rotation angle in degrees
        :param center: invariant point of rotation
        r   r   rotater   r   )rQ   degreescenters      r=   r   zAbsolutePathCommand.rotate1  s0     ~~iF1I/NOOOPPPr?   c                H    |                      t          |                    S )z*Translate or scale this path command by dr	translater   )rQ   drs     r=   r   zAbsolutePathCommand.translate<  s    ~~i"555666r?   c                H    |                      t          |                    S )z\Returns new transformed segment

        :param factor: scale or (scale_x, scale_y)
        scaler   )rQ   factors     r=   r   zAbsolutePathCommand.scale@  s!     ~~if555666r?   N)rA   rB   rC   rD   r   rV   rY   ra   r   r   r   r   r;   r?   r=   r    r      s            X   X* * *
$ $ $	Q 	Q 	Q7 7 77 7 7 7 7r?   c                  p    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Z e            fd
Zd ZdS )r$   zLine segment   c                    | j         | j        fS r:   xyrP   s    r=   ro   z	Line.argsO      vtv~r?   c                "    || _         || _        d S r:   r   rQ   r   r   s      r=   __init__zLine.__init__S      r?   c                t    |t          |d         j        | j        f|d         j        | j        f          z  }d S r   r   r   r   r   s       r=   r   zLine.update_bounding_boxW  s?    R "DF+ob.A.CTV-L
 
 	
r?   c              #  B   K   t          | j        | j                  V  d S r:   r   r   r   ru   s       r=   rv   zLine.control_points\  &      tvtv&&&&&&&r?   c                V    t          | j        |j        z
  | j        |j        z
            S r:   r%   r   r   r[   s     r=   r]   zLine.to_relative`  "    DFTVOTVdf_555r?   c                R    t          |                    | j        | j        f           S r:   )r$   apply_to_pointr   r   r   s     r=   r   zLine.transformd  $    Y--tvtv.>??@@r?   c                6    t          | j        | j                  S r:   r   rc   s      r=   r   zLine.end_pointh      '''r?   c                f    t          |j        |j        | j        | j        | j        | j                  S r:   )r.   r   r   r   s      r=   r   zLine.to_curvel  s&    TVTVTVTVTVTVDDDr?   c                6    t          |j        |j                  S r:   r$   r   r   rc   s      r=   re   zLine.reversep      DFDF###r?   NrA   rB   rC   rD   rz   r   ro   r   r   rv   r]   r   r   r   r   re   r;   r?   r=   r$   r$   J  s        E  X  
 
 

' ' '6 6 6A A A( ( ( (0xzz E E E E$ $ $ $ $r?   r$   c                  >    e Zd ZdZdZed             Zd Zd Zd Z	dS )r%   zRelative line segmentr   c                    | j         | j        fS r:   dxdyrP   s    r=   ro   z	line.argsy      wr?   c                "    || _         || _        d S r:   r   rQ   r   r   s      r=   r   zline.__init__}      r?   c                V    t          |j        | j        z   |j        | j        z             S r:   )r$   r   r   r   r   r[   s     r=   ra   zline.to_absolute  $    DFTW$dftw&6777r?   c                :    t          | j         | j                   S r:   )r%   r   r   rc   s      r=   re   zline.reverse  s    TWHtwh'''r?   N
rA   rB   rC   rD   rz   r   ro   r   ra   re   r;   r?   r=   r%   r%   t  se        E    X   8 8 8( ( ( ( (r?   r%   c                  t    e Zd ZdZdZeZed             Zd Z	d Z
d Zd Zd Zd	 Z e            fd
Zd ZdS )r&   zMove pen segment without a liner   c                    | j         | j        fS r:   r   rP   s    r=   ro   z	Move.args  r   r?   c                "    || _         || _        d S r:   r   r   s      r=   r   zMove.__init__  r   r?   c                @    |t          | j        | j                  z  }d S r:   r   r   s       r=   r   zMove.update_bounding_box  s    DFDF+++r?   c              #  B   K   t          | j        | j                  V  d S r:   r   ru   s       r=   rv   zMove.control_points  r   r?   c                V    t          | j        |j        z
  | j        |j        z
            S r:   r'   r   r   r[   s     r=   r]   zMove.to_relative  r   r?   c                R    t          |                    | j        | j        f           S r:   )r&   r   r   r   r   s     r=   r   zMove.transform  r   r?   c                6    t          | j        | j                  S r:   r   rc   s      r=   r   zMove.end_point  r   r?   c                     t          d          )Nz-Move segments can not be changed into curves.r   r   s      r=   r   zMove.to_curve  s    HIIIr?   c                6    t          |j        |j                  S r:   )r&   r   r   rc   s      r=   re   zMove.reverse  r   r?   N)rA   rB   rC   rD   rz   r$   rR   r   ro   r   r   rv   r]   r   r   r   r   re   r;   r?   r=   r&   r&     s        ))EL  X  , , ,' ' '6 6 6A A A( ( ( (0xzz J J J J$ $ $ $ $r?   r&   c                  B    e Zd ZdZdZeZed             Zd Z	d Z
d ZdS )r'   zRelative move segmentr   c                    | j         | j        fS r:   r   rP   s    r=   ro   z	move.args  r   r?   c                "    || _         || _        d S r:   r   r   s      r=   r   zmove.__init__  r   r?   c                V    t          |j        | j        z   |j        | j        z             S r:   )r&   r   r   r   r   r[   s     r=   ra   zmove.to_absolute  r   r?   c                V    t          |j        |j        z
  |j        |j        z
            S r:   r   rc   s      r=   re   zmove.reverse  $    DFUW$dfuw&6777r?   N)rA   rB   rC   rD   rz   r%   rR   r   ro   r   ra   re   r;   r?   r=   r'   r'     sj        EL    X   8 8 88 8 8 8 8r?   r'   c                  n    e Zd ZdZdZeZed             Zd Z	d Z
d Zd Zd Z e            fd	Zd
 ZdS )r(   zClose segment to finish a pathr   c                    dS Nr;   r;   rP   s    r=   ro   zZoneClose.args      rr?   c                    d S r:   r;   r   s       r=   r   zZoneClose.update_bounding_box  s    r?   c                    t                      S r:   r(   r   s     r=   r   zZoneClose.transform      {{r?   c              #     K   |V  d S r:   r;   ru   s       r=   rv   zZoneClose.control_points  s      r?   c                    t                      S r:   )r)   r[   s     r=   r]   zZoneClose.to_relative  r  r?   c                    |S r:   r;   rc   s      r=   r   zZoneClose.end_point  s    r?   c                     t          d          )Nz2ZoneClose segments can not be changed into curves.r   r   s      r=   r   zZoneClose.to_curve  s    MNNNr?   c                6    t          |j        |j                  S r:   r   rc   s      r=   re   zZoneClose.reverse  r   r?   N)rA   rB   rC   rD   rz   r&   rR   r   ro   r   r   rv   r]   r   r   r   re   r;   r?   r=   r(   r(     s        ((EL  X           (0xzz O O O O$ $ $ $ $r?   r(   c                  <    e Zd ZdZdZeZed             Zd Z	d Z
dS )r)   z&Same as above (svg says no difference)r   c                    dS r  r;   rP   s    r=   ro   zzoneClose.args  r  r?   c                    t                      S r:   r
  r[   s     r=   ra   zzoneClose.to_absolute  s    {{r?   c                V    t          |j        |j        z
  |j        |j        z
            S r:   r   rc   s      r=   re   zzoneClose.reverse  r  r?   N)rA   rB   rC   rD   rz   r&   rR   r   ro   ra   re   r;   r?   r=   r)   r)     s[        00EL  X  8 8 8 8 8r?   r)   c                  |    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Zd
 Z e            fdZd Zd ZdS )r*   zHorizontal Line segmentr   c                    | j         fS r:   r   rP   s    r=   ro   z	Horz.args      yr?   c                    || _         d S r:   r  )rQ   r   s     r=   r   zHorz.__init__      r?   c                f    |t          |d         j        | j        f|d         j                  z  }d S r   r   r   s       r=   r   zHorz.update_bounding_box  s1    _R02DF;_R=P=RSSSr?   c              #  B   K   t          | j        |j                  V  d S r:   r   ru   s       r=   rv   zHorz.control_points  r   r?   c                :    t          | j        |j        z
            S r:   )r+   r   r[   s     r=   r]   zHorz.to_relative      DFTVO$$$r?   c                ,    |                      |          S r:   r   rg   s      r=   ri   zHorz.to_non_shorthand      ||D!!!r?   c                     t          d          )Nz/Horizontal lines can't be transformed directly.r   r   s     r=   r   zHorz.transform  s    JKKKr?   c                6    t          | j        |j                  S r:   r   rc   s      r=   r   zHorz.end_point  r   r?   c                R    |                      |                              |          S z&Convert a horizontal line into a curver   r   r   s      r=   r   zHorz.to_curve  s$     ||D!!**4000r?   c                6    t          | j        |j                  S z*Return this path command as a Line insteadr   r[   s     r=   r   zHorz.to_line$       DFDF###r?   c                *    t          |j                  S r:   )r*   r   rc   s      r=   re   zHorz.reverse)      DF||r?   N)rA   rB   rC   rD   rz   r   ro   r   r   rv   r]   ri   r   r   r   r   r   re   r;   r?   r=   r*   r*     s        !!E  X  T T T' ' '% % %" " "L L L( ( ( (0xzz 1 1 1 1
$ $ $
    r?   r*   c                  J    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	S )
r+   zRelative horz line segmentr   c                    | j         fS r:   r   rP   s    r=   ro   z	horz.args2      zr?   c                    || _         d S r:   r.  )rQ   r   s     r=   r   zhorz.__init__6      r?   c                :    t          |j        | j        z             S r:   )r*   r   r   r[   s     r=   ra   zhorz.to_absolute9      DFTW$%%%r?   c                ,    |                      |          S r:   r   rg   s      r=   ri   zhorz.to_non_shorthand<  r!  r?   c                F    t          |j        | j        z   |j                  S r(  )r$   r   r   r   r[   s     r=   r   zhorz.to_line@  s    DFTW$df---r?   c                ,    t          | j                   S r:   )r+   r   rc   s      r=   re   zhorz.reverseD      TWH~~r?   NrA   rB   rC   rD   rz   r   ro   r   ra   ri   r   re   r;   r?   r=   r+   r+   -  s        $$E  X  & & &" " ". . .    r?   r+   c                  |    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Zd
 Zd Z e            fdZd ZdS )r,   zVertical Line segmentr   c                    | j         fS r:   r   rP   s    r=   ro   z	Vert.argsM  r  r?   c                    || _         d S r:   r;  )rQ   r   s     r=   r   zVert.__init__Q  r  r?   c                f    |t          |d         j        |d         j        | j        f          z  }d S r   r   r   s       r=   r   zVert.update_bounding_boxT  s1    OB/1OB4G4I463RSSSr?   c                     t          d          )Nz-Vertical lines can't be transformed directly.r   r   s     r=   r   zVert.transformW  s    HIIIr?   c              #  B   K   t          |j        | j                  V  d S r:   r   ru   s       r=   rv   zVert.control_pointsZ  r   r?   c                ,    |                      |          S r:   r   rg   s      r=   ri   zVert.to_non_shorthand^  r!  r?   c                :    t          | j        |j        z
            S r:   )r-   r   r[   s     r=   r]   zVert.to_relativeb  r  r?   c                6    t          |j        | j                  S r:   r   rc   s      r=   r   zVert.end_pointf  r   r?   c                6    t          |j        | j                  S z*Return this path command as a line insteadr   r[   s     r=   r   zVert.to_linej  r)  r?   c                R    |                      |                              |          S r%  r&  r   s      r=   r   zVert.to_curveo  s$     ||D!!**4000r?   c                *    t          |j                  S r:   )r,   r   rc   s      r=   re   zVert.reverseu  r+  r?   N)rA   rB   rC   rD   rz   r   ro   r   r   r   rv   ri   r]   r   r   r   r   re   r;   r?   r=   r,   r,   H  s        E  X  T T TJ J J' ' '" " "% % %( ( ($ $ $ 'hjj1 1 1 1    r?   r,   c                  J    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	S )
r-   zRelative vertical line segmentr   c                    | j         fS r:   r   rP   s    r=   ro   z	vert.args~  r/  r?   c                    || _         d S r:   rI  )rQ   r   s     r=   r   zvert.__init__  r1  r?   c                :    t          |j        | j        z             S r:   )r,   r   r   r[   s     r=   ra   zvert.to_absolute  r3  r?   c                ,    |                      |          S r:   r   rg   s      r=   ri   zvert.to_non_shorthand  r!  r?   c                F    t          |j        |j        | j        z             S rD  )r$   r   r   r   r[   s     r=   r   zvert.to_line  s    DFDFTW,---r?   c                ,    t          | j                   S r:   )r-   r   rc   s      r=   re   zvert.reverse  r7  r?   Nr8  r;   r?   r=   r-   r-   y  s        ((E  X  & & &" " ". . .    r?   r-   c                  v    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Z e            fd
Zd Zd ZdS )r.   zAbsolute Curved Line segment   c                N    | j         | j        | j        | j        | j        | j        fS r:   x2y2x3y3x4y4rP   s    r=   ro   z
Curve.args  s!    w$'47DGCCr?   c                Z    || _         || _        || _        || _        || _        || _        d S r:   rR  )rQ   rS  rT  rU  rV  rW  rX  s          r=   r   zCurve.__init__  s0    r?   c                   |d         j         | j        | j        | j        f\  }}}}|d         j        | j        | j        | j        f\  }}	}
}||j         v r||j         v r||j         v r	||j         v s |xj         t          ||||          z  c_         ||j        v r|	|j        v r|
|j        v r	||j        v s"|xj        t          ||	|
|          z  c_        d S d S r   )	r   rS  rU  rW  r   rT  rV  rX  r   )rQ   rd   r   r   x1rS  rU  rW  y1rT  rV  rX  s               r=   r   zCurve.update_bounding_box  s    (,.$'IBB(,.$'IBBdftv",,2<<FFmBB333FFdftv",,2<<FFmBB333FFFF DP<r?   c                   |                     | j        | j        f          \  }}|                     | j        | j        f          \  }}|                     | j        | j        f          \  }}t          ||||||          S r:   )r   rS  rT  rU  rV  rW  rX  r.   )rQ   r   rS  rT  rU  rV  rW  rX  s           r=   r   zCurve.transform  sz    ))47DG*<==B))47DG*<==B))47DG*<==BRRR,,,r?   c              #     K   t          | j        | j                  V  t          | j        | j                  V  t          | j        | j                  V  d S r:   )r   rS  rT  rU  rV  rW  rX  ru   s       r=   rv   zCurve.control_points  sZ      tw(((((tw(((((tw(((((((r?   c           	         t          | j        |j        z
  | j        |j        z
  | j        |j        z
  | j        |j        z
  | j        |j        z
  | j        |j        z
            S r:   )	r/   rS  r   rT  r   rU  rV  rW  rX  r[   s     r=   r]   zCurve.to_relative  s\    GdfGdfGdfGdfGdfGdf
 
 	
r?   c                6    t          | j        | j                  S r:   r   rW  rX  rc   s      r=   r   zCurve.end_point      )))r?   c                    t          | j         S )z0No conversion needed, pass-through, returns self)r.   ro   r   s      r=   r   zCurve.to_curve  s     di  r?   c                    t          | j        dd                   t          | j        dd                   t          | j        dd                   gS )z(Returns the list of coords for SuperPathNr      rP  )listro   rP   s    r=   to_bezzCurve.to_bez  sE    TYrr]##T$)AaC.%9%94	!A#;O;OPPr?   c                f    t          | j        | j        | j        | j        |j        |j                  S r:   )r.   rU  rV  rS  rT  r   r   rc   s      r=   re   zCurve.reverse  s&    TWdgtwHHHr?   N)rA   rB   rC   rD   rz   r   ro   r   r   r   rv   r]   r   r   r   rg  re   r;   r?   r=   r.   r.     s        &&ED D XD  	4 	4 	4- - -) ) )
 
 
* * * 'hjj! ! ! !Q Q QI I I I Ir?   r.   c                  >    e Zd ZdZdZed             Zd Zd Zd Z	dS )r/   zRelative curved line segmentrP  c                N    | j         | j        | j        | j        | j        | j        fS r:   dx2dy2dx3dy3dx4dy4rP   s    r=   ro   z
curve.args  s!    x48TXtxIIr?   c                Z    || _         || _        || _        || _        || _        || _        d S r:   rk  )rQ   rl  rm  rn  ro  rp  rq  s          r=   r   zcurve.__init__  s2     r?   c           	         t          | j        |j        z   | j        |j        z   | j        |j        z   | j        |j        z   | j        |j        z   | j        |j        z             S r:   )	r.   rl  r   rm  r   rn  ro  rp  rq  r[   s     r=   ra   zcurve.to_absolute  s\    HtvHtvHtvHtvHtvHtv
 
 	
r?   c                    t          | j         | j        z   | j         | j        z   | j         | j        z   | j         | j        z   | j         | j                   S r:   )r/   rp  rn  rq  ro  rl  rm  rc   s      r=   re   zcurve.reverse  sZ    XI XI XI XI XIXI
 
 	
r?   Nr   r;   r?   r=   r/   r/     sh        &&EJ J XJ
 
 

 
 

 
 
 
 
r?   r/   c                  v    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Zd
 Z e            fdZd ZdS )r0   z%Absolute Smoothed Curved Line segmentre  c                6    | j         | j        | j        | j        fS r:   rU  rV  rW  rX  rP   s    r=   ro   zSmooth.args	      w$'11r?   c                >    || _         || _        || _        || _        d S r:   rw  )rQ   rU  rV  rW  rX  s        r=   r   zSmooth.__init__  "    r?   c                t    |                      |d         |d                                       |||           d S NrF   )r   r   r   s       r=   r   zSmooth.update_bounding_box  sC    ob)?2+>??SS?D	
 	
 	
 	
 	
r?   c              #    K   |j         |j         | j        | j        f\  }}}}|j        |j        | j        | j        f\  }}	}
}d|z  |z
  }d|	z  |z
  }	t          ||	          V  t          ||
          V  t          ||          V  d S Nr   )r   rU  rW  r   rV  rX  r   )rQ   rd   r\   rp   r[  rS  rU  rW  r\  rT  rV  rX  s               r=   rv   zSmooth.control_points  s       #dfdgtw>BB"dfdgtw>BB Vb[Vb[r2r2r2r?   c                .    |                      ||          S r:   r   rg   s      r=   ri   zSmooth.to_non_shorthand(  s    }}T<000r?   c                    t          | j        |j        z
  | j        |j        z
  | j        |j        z
  | j        |j        z
            S r:   )r1   rU  r   rV  r   rW  rX  r[   s     r=   r]   zSmooth.to_relative,  sA    Gdfdg.$&0@$'DFBR
 
 	
r?   c                    |                     | j        | j        f          \  }}|                     | j        | j        f          \  }}t          ||||          S r:   )r   rU  rV  rW  rX  r0   )rQ   r   rU  rV  rW  rX  s         r=   r   zSmooth.transform1  sV    ))47DG*<==B))47DG*<==Bb"b"%%%r?   c                6    t          | j        | j                  S r:   ra  rc   s      r=   r   zSmooth.end_point7  rb  r?   c                r    |                      |||          \  \  }}\  }}\  }}t          ||||||          S )z
        Convert this Smooth curve to a regular curve by creating a mirror
        set of nodes based on the previous node. Previous should be a curve.
        )rv   r.   )	rQ   r\   rp   rS  rT  rU  rV  rW  rX  s	            r=   r   zSmooth.to_curve:  sF     (,':':4y'Q'Q$R(2rHRRRR,,,r?   c                N    t          | j        | j        |j        |j                  S r:   )r0   rU  rV  r   r   rc   s      r=   re   zSmooth.reverseC  s    dgtw777r?   N)rA   rB   rC   rD   rz   r   ro   r   r   rv   ri   r]   r   r   r   r   re   r;   r?   r=   r0   r0     s        //E2 2 X2  
 
 

  1 1 1
 
 

& & &* * * (0xzz - - - -8 8 8 8 8r?   r0   c                  D    e Zd ZdZdZed             Zd Zd Zd Z	d Z
dS )	r1   z%Relative smoothed curved line segmentre  c                6    | j         | j        | j        | j        fS r:   rn  ro  rp  rq  rP   s    r=   ro   zsmooth.argsL      x48TX55r?   c                >    || _         || _        || _        || _        d S r:   r  )rQ   rn  ro  rp  rq  s        r=   r   zsmooth.__init__P  s"    r?   c                    t          | j        |j        z   | j        |j        z   | j        |j        z   | j        |j        z             S r:   )r0   rn  r   ro  r   rp  rq  r[   s     r=   ra   zsmooth.to_absoluteW  sC    Htvtx$&0$(TV2CTXPTPVEV
 
 	
r?   c                T    |                      |                              ||          S r:   ra   ri   rg   s      r=   ri   zsmooth.to_non_shorthand\  &    %%66t\JJJr?   c                v    t          | j         | j        z   | j         | j        z   | j         | j                   S r:   )r1   rp  rn  rq  ro  rc   s      r=   re   zsmooth.reverse`  s4    txi$(*TXI,@48)dhYWWWr?   NrA   rB   rC   rD   rz   r   ro   r   ra   ri   re   r;   r?   r=   r1   r1   G  s|        //E6 6 X6  
 
 

K K KX X X X Xr?   r1   c                  p    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Z e            fd
Zd ZdS )r2   z&Absolute Quadratic Curved Line segmentre  c                6    | j         | j        | j        | j        fS r:   rS  rT  rU  rV  rP   s    r=   ro   zQuadratic.argsi  rx  r?   c                >    || _         || _        || _        || _        d S r:   r  )rQ   rS  rT  rU  rV  s        r=   r   zQuadratic.__init__m  rz  r?   c                ^   |d         j         | j        | j        }}}|d         j        | j        | j        }	}}||j         v r||j         v r	||j         v s|xj         t          |||          z  c_         ||j        v r||j        v r	|	|j        v s!|xj        t          |||	          z  c_        d S d S r   )r   rS  rU  r   rT  rV  r   )
rQ   rd   r   r   r[  rS  rU  r\  rT  rV  s
             r=   r   zQuadratic.update_bounding_boxu  s    $R(*DGTWB$R(*DGTWBdftv",,FF'B333FFdftv",,FF'B333FFFF 3?,r?   c              #  z   K   t          | j        | j                  V  t          | j        | j                  V  d S r:   )r   rS  rT  rU  rV  ru   s       r=   rv   zQuadratic.control_points  s@      tw(((((tw(((((((r?   c                    t          | j        |j        z
  | j        |j        z
  | j        |j        z
  | j        |j        z
            S r:   )r3   rS  r   rT  r   rU  rV  r[   s     r=   r]   zQuadratic.to_relative  sA    Gdfdg.$&0@$'DFBR
 
 	
r?   c                    |                     | j        | j        f          \  }}|                     | j        | j        f          \  }}t          ||||          S r:   )r   rS  rT  rU  rV  r2   )rQ   r   rS  rT  rU  rV  s         r=   r   zQuadratic.transform  sV    ))47DG*<==B))47DG*<==BRR(((r?   c                6    t          | j        | j                  S r:   r   rU  rV  rc   s      r=   r   zQuadratic.end_point      )))r?   c                   t          |          }d|j        z  d| j        z  z   }d| j        z  d| j        z  z   }d|j        z  d| j        z  z   }d| j        z  d| j        z  z   }t          ||||| j        | j                  S )z)Attempt to convert a quadratic to a curvegUUUUUU?gUUUUUU?)r   r   rS  rU  r   rT  rV  r.   )rQ   r\   rp   r[  rS  r\  rT  s          r=   r   zQuadratic.to_curve  s     ~~tv$' 11tw47!22tv$' 11tw47!22RRTWdg666r?   c                N    t          | j        | j        |j        |j                  S r:   )r2   rS  rT  r   r   rc   s      r=   re   zQuadratic.reverse  s    $'4646:::r?   Nr   r;   r?   r=   r2   r2   d  s        00E2 2 X2  	4 	4 	4) ) )

 
 
) ) )* * * (0xzz 7 7 7 7; ; ; ; ;r?   r2   c                  >    e Zd ZdZdZed             Zd Zd Zd Z	dS )r3   zRelative quadratic line segmentre  c                6    | j         | j        | j        | j        fS r:   )rl  rm  rn  ro  rP   s    r=   ro   zquadratic.args  r  r?   c                >    || _         || _        || _        || _        d S r:   )rl  rn  rm  ro  )rQ   rl  rm  rn  ro  s        r=   r   zquadratic.__init__  s"    r?   c                    t          | j        |j        z   | j        |j        z   | j        |j        z   | j        |j        z             S r:   )r2   rl  r   rm  r   rn  ro  r[   s     r=   ra   zquadratic.to_absolute  sC    Htvtx$&0$(TV2CTXPTPVEV
 
 	
r?   c                v    t          | j         | j        z   | j         | j        z   | j         | j                   S r:   )r3   rn  rl  ro  rm  rc   s      r=   re   zquadratic.reverse  s;    XI 48)dh"6	DH9
 
 	
r?   Nr   r;   r?   r=   r3   r3     se        ))E6 6 X6  
 
 


 
 
 
 
r?   r3   c                  |    e Zd ZdZdZed             Zd Zd Zd Z	d Z
d Zd	 Zd
 Z e            fdZd Zd ZdS )r4   z Continued Quadratic Line segmentr   c                    | j         | j        fS r:   rU  rV  rP   s    r=   ro   zTepidQuadratic.args  r   r?   c                "    || _         || _        d S r:   r  )rQ   rU  rV  s      r=   r   zTepidQuadratic.__init__  r   r?   c                t    |                      |d         |d                                       |||           d S r|  )to_quadraticr   r   s       r=   r   z"TepidQuadratic.update_bounding_box  sE    /"-r/BCCWW?D	
 	
 	
 	
 	
r?   c              #     K   |j         |j         | j        }}}|j        |j        | j        }	}}d|z  |z
  }d|z  |z
  }t	          ||          V  t	          ||	          V  d S r  )r   rU  r   rV  r   )
rQ   rd   r\   rp   r[  rS  rU  r\  rT  rV  s
             r=   rv   zTepidQuadratic.control_points  s|       [$&$'B[$&$'B Vb[Vb[r2r2r?   c                .    |                      ||          S r:   )r  rg   s      r=   ri   zTepidQuadratic.to_non_shorthand  s      |444r?   c                V    t          | j        |j        z
  | j        |j        z
            S r:   )r5   rU  r   rV  r   r[   s     r=   r]   zTepidQuadratic.to_relative  s$    dg.$&0@AAAr?   c                j    |                     | j        | j        f          \  }}t          ||          S r:   )r   rU  rV  r4   )rQ   r   rU  rV  s       r=   r   zTepidQuadratic.transform  s2    ))47DG*<==Bb"%%%r?   c                6    t          | j        | j                  S r:   r  rc   s      r=   r   zTepidQuadratic.end_point  r  r?   c                T    |                      ||                              |          S r:   )r  r   r   s      r=   r   zTepidQuadratic.to_curve  s&      y11::4@@@r?   c                f    |                      |||          \  \  }}\  }}t          ||||          S )zH
        Convert this continued quadratic into a full quadratic
        )rv   r2   )rQ   r\   rp   rS  rT  rU  rV  s          r=   r  zTepidQuadratic.to_quadratic  s<    
 "00tYGGR(2rRR(((r?   c                6    t          |j        |j                  S r:   )r4   r   r   rc   s      r=   re   zTepidQuadratic.reverse  s    dfdf---r?   N)rA   rB   rC   rD   rz   r   ro   r   r   rv   ri   r]   r   r   r   r   r  re   r;   r?   r=   r4   r4     s        **E    X   
 
 

  5 5 5B B B& & &
* * * (0xzz A A A A) ) ). . . . .r?   r4   c                  D    e Zd ZdZdZed             Zd Zd Zd Z	d Z
dS )	r5   z)Relative continued quadratic line segmentr   c                    | j         | j        fS r:   rn  ro  rP   s    r=   ro   ztepidQuadratic.args  s    x!!r?   c                "    || _         || _        d S r:   r  )rQ   rn  ro  s      r=   r   ztepidQuadratic.__init__  s    r?   c                V    t          | j        |j        z   | j        |j        z             S r:   )r4   rn  r   ro  r   r[   s     r=   ra   ztepidQuadratic.to_absolute	  s$    dh/DF1BCCCr?   c                T    |                      |                              ||          S r:   r  rg   s      r=   ri   ztepidQuadratic.to_non_shorthand  r  r?   c                :    t          | j         | j                   S r:   )r5   rn  ro  rc   s      r=   re   ztepidQuadratic.reverse  s    txi$(333r?   Nr  r;   r?   r=   r5   r5     sz        33E" " X"  D D DK K K4 4 4 4 4r?   r5   c                  p    e Zd ZdZdZed             Zd Zd Zd Z	 e
            fdZd Zd	 Zd
 Zd ZdS )r6   zSpecial Arc segment   c                Z    | j         | j        | j        | j        | j        | j        | j        fS r:   rxryx_axis_rotation	large_arcsweepr   r   rP   s    r=   ro   zArc.args  s2     GG NJFF
 	
r?   c                h    || _         || _        || _        || _        || _        || _        || _        d S r:   r  )rQ   r  r  r  r  r  r   r   s           r=   r   zArc.__init__&  s:     ."
r?   c                    |d         }|                      |          D ]1}|                    |d |g|           |                    ||          }2d S )NrF   )r\   )r   r   r   )rQ   rd   r   r   r\   segs         r=   r   zArc.update_bounding_box1  sd    r">>t>,, 	. 	.C##ED$<>>>==--DD	. 	.r?   c              #  B   K   t          | j        | j                  V  d S r:   r   ru   s       r=   rv   zArc.control_points7  r   r?   c                    t          t          t          |          | j                  g                              d          }t          |          dd         S )z#Convert this arc into bezier curvesT)curves_onlyr   N)r"   arc_to_pathrf  ro   to_path)rQ   r\   rp   paths       r=   r   zArc.to_curves;  sU     {4::tyAABCCKK L 
 
 Dzz!""~r?   c           	     T   |                     | j        | j        f          \  }}|}| j        dk    r|t	          | j                  z  }t          |                                          \  }}}}}	}	||z  ||z  z
  }
|
dz  }t          | j                  }t          | j	                  }|dk    s|dk    s|dk    r.t          | j        | j	        | j        | j        | j        ||          S |dz  |dz  z  |dz  |dz  z  z   |z  }||z  |dz  z  ||z  |dz  z  z    |z  }|dz  |dz  z  |dz  |dz  z  z   |z  }t          d|z  ||z
            dz  }|dz  t          z  }||z
  }d|dz  z  |dz  z   }|dk    rd}n"d|dz   d|dz  z  z
  z  t          |          z  }||z   dz  }d	t          ||z             z  }d	t          ||z
            z  }|                     | j        | j        f          \  }}|
dk    r| j        }n| j        dk    rdnd
}t          |||| j        |||          S )Nr   r   r           r}       f@re  g      ?      ?r   )r   r   r   r  r   rf  to_hexadfloatr  r  r6   r  r  r   r   r   )rQ   r   x_y_Tacbd_detTdetT2r  r  ABDtheta	theta_degDAl2deltahalfrx_ry_r  s                             r=   r   zArc.transformD  s    ))4646*:;;B1$$IT%9::::A

--1aAq 1uq1u}a47^^47^^99c		Uc\\ $
   TBE\AqD2q5L(E1!eb!ema!eb!em+,u4TBE\AqD2q5L(E1b1fa!e$$q(EMB&	UAXA77EERU8a!Q$h./$r((:EA{D&&&D&&&))4646*:;;B!88JEEaAAQE3Yr2FFFr?   c           
         t          | j        | j        | j        | j        | j        | j        |j        z
  | j        |j        z
            S r:   )r7   r  r  r  r  r  r   r   r[   s     r=   r]   zArc.to_relative  sD    GG NJFTVOFTVO
 
 	
r?   c                6    t          | j        | j                  S r:   r   rc   s      r=   r   zArc.end_point  r   r?   c           	     x    t          | j        | j        | j        | j        d| j        z
  |j        |j                  S Nr   )r6   r  r  r  r  r  r   r   rc   s      r=   re   zArc.reverse  s<    GG N
NFF
 
 	
r?   N)rA   rB   rC   rD   rz   r   ro   r   r   rv   r   r   r   r]   r   re   r;   r?   r=   r6   r6     s        E	
 	
 X	
	 	 	. . .' ' ' )1

    9G 9G 9Gv

 

 

( ( (	
 	
 	
 	
 	
r?   r6   c                  >    e Zd ZdZdZed             Zd Zd Zd Z	dS )r7   zRelative Arc line segmentr  c                Z    | j         | j        | j        | j        | j        | j        | j        fS r:   r  r  r  r  r  r   r   rP   s    r=   ro   zarc.args  s2     GG NJGG
 	
r?   c                h    || _         || _        || _        || _        || _        || _        || _        d S r:   r  )rQ   r  r  r  r  r  r   r   s           r=   r   zarc.__init__  s:     ."
r?   c           
         |\  }}t          | j        | j        | j        | j        | j        | j        |z   | j        |z             S r:   )r6   r  r  r  r  r  r   r   )rQ   r\   r[  r\  s       r=   ra   zarc.to_absolute  sI    BGG NJGbLGbL
 
 	
r?   c           	     |    t          | j        | j        | j        | j        d| j        z
  | j         | j                   S r  )r7   r  r  r  r  r  r   r   rc   s      r=   re   zarc.reverse  s@    GG N
NWHWH
 
 	
r?   Nr   r;   r?   r=   r7   r7     se        ##E	
 	
 X	
	 	 	

 

 

	
 	
 	
 	
 	
r?   r7   MLVHr  CSZQr  mlvhr  r  s)zqtc                       e Zd ZdZ G d d          Zd fd	Zed             Zd Z fdZ	d d
Z
d dZd!dZed             Zed             Zd dZd Zd Zd Zd Zd Zd"dZd Zd Zd Zd Zd Zd Z xZS )#r!   z8A list of segment commands which combine to draw a shapec                      e Zd ZdZd Zed             Zed             Zed             Zed             Z	ed             Z
ed             Zed	             Zed
             Zd Zd Zd Zd Zd Zd ZdS )Path.PathCommandProxyz
        A handy class for Path traverse and coordinate access

        Reduces number of arguments in user code compared to bare
        :class:`PathCommand` methods
        c                >    || _         || _        || _        || _        d S r:   )commandfirst_pointprevious_end_pointprev2_control_point)rQ   r  r  r  r  s        r=   r   zPath.PathCommandProxy.__init__  s)     #DL*D&8D#':D$$$r?   c                    | j         j        S rH   )r  rK   rP   s    r=   rK   zPath.PathCommandProxy.name       <$$r?   c                    | j         j        S )rM   )r  rN   rP   s    r=   rN   zPath.PathCommandProxy.letter  s     <&&r?   c                    | j         j        S )zThe implicit next command.)r  rR   rP   s    r=   rR   z"Path.PathCommandProxy.next_command  s     <,,r?   c                    | j         j        S )zWhether the command is defined in relative coordinates, i.e. relative to
            the previous endpoint (lower case path command letter))r  rV   rP   s    r=   rV   z!Path.PathCommandProxy.is_relative	       <++r?   c                    | j         j        S )zcWhether the command is defined in absolute coordinates (upper case path
            command letter))r  rY   rP   s    r=   rY   z!Path.PathCommandProxy.is_absolute  r  r?   c                    | j         j        S rn   )r  ro   rP   s    r=   ro   zPath.PathCommandProxy.args  r  r?   c                X    | j                             | j        | j        | j                  S rt   )r  rv   r  r  r  rP   s    r=   rv   z$Path.PathCommandProxy.control_points  s.     <.. $"94;S  r?   c                L    | j                             | j        | j                  S r   )r  r   r  r  rP   s    r=   r   zPath.PathCommandProxy.end_point!  s"     <))$*:D<STTTr?   c                L    | j                             | j        | j                  S )zReverse path command)r  re   r   r  rP   s    r=   re   zPath.PathCommandProxy.reverse&  s    <''8OPPPr?   c                L    | j                             | j        | j                  S )z_Convert command to :py:class:`Curve`
            Curve().to_curve() returns a copy
            )r  r   r  r  rP   s    r=   r   zPath.PathCommandProxy.to_curve*  s)     <((')A  r?   c                L    | j                             | j        | j                  S r   )r  r   r  r  rP   s    r=   r   zPath.PathCommandProxy.to_curves2  s'    <))')A  r?   c                @    | j                             | j                  S r`   )r  ra   r  rP   s    r=   ra   z!Path.PathCommandProxy.to_absolute8  s    <++D,CDDDr?   c                *    t          | j                  S r:   )strr  rP   s    r=   r   zPath.PathCommandProxy.__str__<  s    t|$$$r?   c                P    d| j         j        z   dz   t          | j                  z   S )N<>)r   rA   reprr  rP   s    r=   r   zPath.PathCommandProxy.__repr__?  s&    0036dl9K9KKKr?   N)rA   rB   rC   rD   r   r   rK   rN   rR   rV   rY   ro   rv   r   re   r   r   ra   r   r   r;   r?   r=   PathCommandProxyr    sm       	 		; 	; 	; 
	% 	% 
	% 
	' 	' 
	' 
	- 	- 
	- 
	, 	, 
	,
 
	, 	, 
	,
 
	% 	% 
	% 
	 	 
	 
	U 	U 
	U	Q 	Q 	Q	 	 		 	 		E 	E 	E	% 	% 	%	L 	L 	L 	L 	Lr?   r  Nc           	         t                                                       t          |t                    r|                     |          }n)t          |t
                    r|                                }|pdD ]}t          |t                    r|                     |           .t          |t          t          f          rt          |          dk    r{t          |d         t          t          f          r<|                     t                              |d                   |d                     |                     t          |            t          dt          |          j         dt          |          j         d|           d S )Nr;   r   r   r   zBad path type: (z, ...): )superr   r   r  parse_stringr"   r  r   appendrf  r   lenrl   r$   	TypeErrorr   rA   )rQ   path_ditemr   s      r=   r   zPath.__init__B  s{   fc"" 	&&&v..FF// 	&^^%%FLb 	 	D$,, D!!!!D4-00 	SYY!^^d1ge}55 -KK ; ;DG D Dd1g NOOOOKKd,,,,<d6ll&; < <T

+< <59< <  	 	r?   c              #    K   t                               |          D ]\  }}t          t          |                    }t                              |          }d}|t          |          k     s|j        dk    rst          ||||j        z                      |j        k    r dS  |||||j        z             }||j        z  }|j        }|V  |t          |          k     h|j        dk    sdS )z0Parse a path string and generate segment objectsr   N)	LEX_REXfindallrf  r   r   rl   r!  rz   rR   )rJ   r#  cmdnumbersro   ir  s          r=   r  zPath.parse_stringX  s       $OOF33 
	 
	LC(())D--c22CAc$ii--39>>tACI-.//39<<FFc4A	M 123SY&			 c$ii--39>>	
	 
	r?   c                :   | sdS |                                  }t          |          }t          |j        j        |j        j                  }	 	 t          |          }|j                            |j        |j        |j	        g|           =# t          $ r |cY S w xY w)zReturn bounding box of the PathN)proxy_iteratornextr   r  r   r   r  r   r  r  StopIteration)rQ   iteratorproxyr   s       r=   bounding_boxzPath.bounding_boxg  s      	4&&((X5,.0A0CDD		X11%10   	  	 	 	KKK	s   >B BBc                    t          |t                    r|                     |           dS t          |t                    r#t	                                          |           dS dS )z<Append a command to this path including any chained commandsN)r   rf  extendr   r  r   )rQ   r(  r   s     r=   r   zPath.append}  se    c4   	 KK[)) 	 GGNN3	  	 r?   Fc                P    |                      t          ||f          |          S )z0Move all coords in this path by the given amountr   inplacer   rQ   r   r   r6  s       r=   r   zPath.translate  s'    ~~i1a&9997~KKKr?   c                P    |                      t          ||f          |          S )z2Scale all coords in this path by the given amountsr   r5  r   r7  s       r=   r   z
Path.scale  s'    ~~iq!f555w~GGGr?   c                    |,|                                  }|r|j        }nt                      }t          |          }|                     t	          ||j        |j        f          |          S )z&Rotate the path around the given pointNr   r5  )r1  r   r   r   r   r   r   )rQ   degr   r6  r   s        r=   r   zPath.rotate  su    >$$&&D $!&!!~~c68VX6777  
 
 	
r?   c              #  *  K   t                      }t                      }t                      }| D ]c}t          |                    |||                    }t          |t          t
          t          t          f          r|d         }|D ]
}|}|}|V  ddS )z&Returns all control points of the PathrF   N)r   rf  rv   r   r)   r(   r'   r&   )rQ   r\   rp   rd   r  cptscpts          r=   rv   zPath.control_points  s       zzJJ	

 	 	C**5$	BBCCD#	9dDABB !R   							 	r?   c              #     K   t                      }t                      }| D ]H}|                    ||          }t          |t          t          t
          t          f          r|}|}|V  IdS )z;Returns all endpoints of all path commands (i.e. the nodes)N)r   r   r   r)   r(   r'   r&   )rQ   r\   rd   r  r   s        r=   
end_pointszPath.end_points  sv       zz

 	 	CeT22I#	9dDABB "!DOOOO	 	r?   c                    t                      }t                      }t                      }d}t                      }t                      }t          |           D ]0\  }	}
|r|
                    ||          }t	          |
t
          t          t          t          f          r|
	                    |          }
|
j
        r<|
                    |                              |                              |          }n|
                    |          }|r|                    ||          }|r|| |	<   n|                    |           |
                    ||          }|                    ||          }t	          |
t          t           f          }2|r| S |S )zConvert to new pathT)r!   r   	enumerater   r   r+   r*   r,   r-   r   rV   ra   r   r]   r   r)   r(   )rQ   r   r6  resultr   previous_new
start_zonerd   	first_newr*  r  new_segs               r=   r   zPath.transform  sv   ::zz


JJ	oo 	A 	AFAs 7eX66#dD$788 ,kk(++ 3OOH--Yy)) [..  --	22 G#--iFF	 '!Qg&&&}}UH55H",,YEEL#C)Y)?@@JJ 	Kr?   c           
        t                      }| j        ^ }}d}t          t          t	          |                                                               D ]y\  }}t          |j        t          t          t          t          f          r|vt          |          dk    rNt          |d         t          t          t          t           t"          t$          f          r|                                 |                    |           t          |j        t          t          f          r|j        }nd}|dk    rv|j        dk    r0|                    dt          |j        |j                             |j        dk    r.|                    dt          |j        |j                             R|                    |                                           {|S )zReturns a reversed pathNr   rF   r  r  )r!   r?  reversedrf  rA  r,  r   r  r&   r'   r(   r)   r!  r$   r%   r,   r-   r*   r+   popr   rN   insertr   r   re   )rQ   rB  r  rd   closerindexprcoms          r=   re   zPath.reverse  s   O	E %T)D4G4G4I4I*J*J%K%KLL 	/ 	/LE5%-$i)KLL 
"%6{{Q:r
T4tT4$H, , 

MM&)))emi-CDD ""]FF!Fzz<3&&MM!T%'57%;%;<<<<\S((MM!T%'57%;%;<<<emmoo....r?   c                    | rEt          | d         t          t          f          s%|                     t                                 dS dS dS )z&Attempt to close the last path segmentrF   N)r   r)   r(   r   rP   s    r=   closez
Path.close  sT     	%
48i-CDD 	%KK	$$$$$	% 	% 	% 	%r?   c              #  "  K   t                      }t                      }t                      }| D ]}t          |t          t          t          t
          f          r|                    ||          }t                              ||||          V  t          |t          t          t          t          t          t          t          t           f          r*t#          |                    |||                    d         }|                    ||          }dS )zm
        Yields :py:class:`AugmentedPathIterator`

        :rtype: Iterator[ Path.PathCommandProxy ]
        r}  N)r   r   r)   r(   r'   r&   r   r!   r  r/   r5   r3   r1   r.   r4   r2   r0   rf  rv   )rQ   r   rp   rd   r  s        r=   r,  zPath.proxy_iterator  s       ::JJ	

 	6 	6C#	9dDABB 7eX66''UHiHHHHH""	  U !!3!3E8Y!O!OPPQST	}}UH55HH%	6 	6r?   c                ,    |                      d          S )z2Convert this path to use only absolute coordinatesT_to_absoluterP   s    r=   ra   zPath.to_absolute   s      &&&r?   c                ,    |                      d          S )z_Convert this path to use only absolute non-shorthand coordinates

        .. versionadded:: 1.1FrR  rP   s    r=   ri   zPath.to_non_shorthand$  s    
   '''r?   	shorthandboolrq   c           	        t                      }t                      }t                      }| D ]}t          |t          t          f          r|                    ||          }|r)|                    |                    |                     n|rwt          |d         t          t          f          rUt          |d                             t                      t                      t                                          d         }n|}|                    |                    ||                     |                    ||          }|S )zMake entire Path absolute.

        Args:
            shorthand (bool): If false, then convert all shorthand commands to
                non-shorthand.

        Returns:
            Path: the input path, converted to absolute coordinates.
        rF   r}  )r!   r   r   r'   r&   r   r   ra   r.   r2   rf  rv   ri   )rQ   rU  abspathr   rd   r  rh   s          r=   rS  zPath._to_absolute+  s$    &&::

 	6 	6C#d|,, 7eX66 
Msx889999 ,z'"+y7IJJ ,#'228::xzz8::VV$ $$LL $,Ls33HlKKLLL}}UH55HHr?   c                D   t                      }t                      }t                      }| D ]r}t          |t          t          f          r|                    ||          }|                    |                    |                     |                    ||          }s|S )z2Convert this path to use only relative coordinates)r!   r   r   r'   r&   r   r   r]   )rQ   rX  r   rd   r  s        r=   r]   zPath.to_relativeO  s    &&::

 	6 	6C#d|,, 7eX66NN3??844555}}UH55HHr?   c                @    d                     d | D                       S )Nr~   c                ,    g | ]}t          |          S r;   )r  .0r  s     r=   
<listcomp>z Path.__str__.<locals>.<listcomp>`  s    222cS222r?   )rx   rP   s    r=   r   zPath.__str___  s#    xx22T222333r?   c                    t          j        |           }t          |t                    rt	          |          }t          |t
                    r|                    |           |S r:   )copydeepcopyr   r  r!   rf  r3  )rQ   r   acopys      r=   __add__zPath.__add__b  sW    d##eS!! 	 KKEeT"" 	 LLr?   c                >    d |                                  D             S )zReturns path in format of parsePath output, returning arrays of absolute
        command data

        .. deprecated:: 1.0
            This is compatibility function for older API. Should not be used in new code

        c                D    g | ]}|j         t          |j                  gS r;   )rN   rf  ro   r\  s     r=   r^  z"Path.to_arrays.<locals>.<listcomp>r  s'    PPPT#(^^,PPPr?   )ri   rP   s    r=   	to_arrayszPath.to_arraysj  s%     QP8M8M8O8OPPPPr?   c                     t          |           S )z)Convert this path into a cubic super path)r"   rP   s    r=   to_superpathzPath.to_superpatht  s    d###r?   c                *    t          j        |           S )zMake a copy)r`  ra  rP   s    r=   r`  z	Path.copyx  s    }T"""r?   r:   Fr   )rU  rV  rq   r!   )rA   rB   rC   rD   r  r   r   r  r1  r   r   r   r   r   rv   r?  r   re   rO  r,  ra   ri   rS  r]   r   rc  rf  rh  r`  __classcell__r   s   @r=   r!   r!     s       BBVL VL VL VL VL VL VL VLp     ,   [  ,         L L L LH H H H
 
 
 
   X 
 
 X
% % % %N  <% % %
6 6 6>' ' '( ( (" " " "H   4 4 4  Q Q Q$ $ $# # # # # # #r?   r!   c                       e Zd ZdZ fdZd Zd fd	Zd Zed             Z	dd
Z
ddZd Zedd            Zedd            Zed             Zedd            Z xZS )r"   a>  
    A conversion of a path into a predictable list of cubic curves which
    can be operated on as a list of simplified instructions.

    When converting back into a path, all lines, arcs etc will be converted
    to curve instructions.

    Structure is held as [SubPath[(point_a, bezier, point_b), ...]], ...]
    c                p   t                                                       d| _        t                      | _        t                      | _        t          |t                    rt          |          }t          |t                    r|	                                }|D ]}| 
                    |           d S r   )r  r   _closedr   _prev
_prev_prevr   r  r!   ra   r   )rQ   itemsr$  r   s      r=   r   zCubicSuperPath.__init__  s    ZZ
"**eS!! 	 KKEeT"" 	(%%''E 	 	DKK	 	r?   c                D    t          |                                           S r:   )r  r  rP   s    r=   r   zCubicSuperPath.__str__  s    4<<>>"""r?   Fc                   t          |t                    rVt          |          dk    rCt          |d         t                    r(t	                              |d                   |d          }d}t          |t                    rt          |          dk    r|sd}d}t          |t                    rut          |t                    rg| j        du r!t                      	                    g            t          |j
                  t          |j
                  t          |j
                  g}nt          |t                    r| r| d         r| d         	                    | d         d         d         dd         | d         d         d         dd         | d         d         d         dd         g           d| _        | j                            | j                   dS t          |t                    rn|                    | j        | j                  D ]K}|j
        \  }}}}	}
}| 	                    ||g||	g|
|ggd	           | j                            ||	           LdS t          |t$          t&          t(          t*          f          }t          |t,          t.          f          r|                    | j                  }| j        }|rAt          |                    | j        | j        |                    d
d         d         | _        |                    | j        |          }t          |t6                    r|                                }t          |t                    st;          d|           t          |          dk    st=          d |D                       st          |d                   dk    rt=          d |d         D                       rt                      	                    |                     |                     tA          | d         d         d                   | _        tA          | d         d         d                   | _        dS t;          d|           | j        r(d| _        t                      	                    g            |rh| d         r|d         dd         | d         d         d<   | d         	                    |dd         tC          j"        |          dd         z              n-| d         	                    tC          j"        |                     tA          | d         d         d                   | _        |s(tA          | d         d         d                   | _        dS dS )zAccept multiple different formats for the data

        .. versionchanged:: 1.2
            ``force_shift`` parameter has been added
        r   r   r   T   FrF   N)force_shiftr}  zUnknown super curve item type: c              3  <   K   | ]}t          |          d k    V  dS r   Nr!  r]  bits     r=   	<genexpr>z(CubicSuperPath.append.<locals>.<genexpr>  s,      $C$CsSXX]$C$C$C$C$C$Cr?   c              3  <   K   | ]}t          |          d k    V  dS rx  ry  rz  s     r=   r|  z(CubicSuperPath.append.<locals>.<genexpr>  s,      (J(J3SQ(J(J(J(J(J(Jr?   z!Unknown super curve list format: )#r   rf  r!  r  r   rl   r&   ro  r  r   ro   r(   rp  assign_firstr6   r   rq  r2   r4   r3   r5   r*   r,   r   rv   r   r.   rg  r   all_cleanr   r`  ra  )rQ   r$  rv  coordinate_shiftis_quadratic	arc_curverS  rT  rU  rV  rW  rX  prpr   s                r=   r   zCubicSuperPath.append  s    dD!! 	Bc$ii1nnDGS9Q9Qn..tAw77aADdD!! 	%c$ii1nn[n$dK(( "	6$%% !6<5((GGNN2&&&TYdi$ty//JD),, 6 6$r( 6 R"Xa[^AAA&RAqqq(948A;q>!!!;LM    $
!!$+...D#&& 6!%
DO!L!L 3 3I-6^*BBBKK"bB8b"X >DKQQQO**2r2222)9niP    dT4L11 4<<
33Do  &*++DKSII' 'e'' DO }}TZ55dE"" 	!;;==D$%% 	GEtEEFFFt99>>$C$Cd$C$C$C!C!C>47||q  S(J(J$q'(J(J(J%J%J t{{400111"*48B<?";";%d2hrl1o66
GGGHHH< 	 !DLGGNN2 		1Bx . $(7111:RR HOODHt}T':':233'??@@@@ HOODM$//000d2hrl1o..
 	8&tBx|A77DOOO	8 	8r?   c                \     t          |t          t          f          r fd|D             S |S )z2Recursively clean lists so they have the same typec                :    g | ]}                     |          S r;   )r  )r]  childrQ   s     r=   r^  z)CubicSuperPath._clean.<locals>.<listcomp>  s%    8885DKK&&888r?   )r   r   rf  )rQ   lsts   ` r=   r  zCubicSuperPath._clean  s8    cE4=)) 	98888C8888
r?   c                    	 t          | d         d         d                   S # t          $ r t                      cY S w xY w)NrF   r   )r   
IndexErrorrP   s    r=   r  zCubicSuperPath._first  sL    	DHQKN+++ 	 	 	::	s    # >>h㈵>:0yE>c           	     d    t          t          |                     |||                              S )zeConvert the super path back to an svg path

        Arguments: see :func:`to_segments` for parameters)r!   rf  to_segments)rQ   r  rtolatols       r=   r  zCubicSuperPath.to_path  s,     D))+tTBBCCDDDr?   c              #    K   | D ]}g }|D ]}|st          |d         dd          V  n|                     ||||          rm|sk||d         u rGt          |d                                       |d         d         ||          rt	                      V  nUt          |d         dd          V  n;t          |d         dd         |d         dd         z   |d         dd         z    V  |}dS )a  Generate a set of segments for this cubic super path

        Arguments:
            curves_only (bool, optional): If False, curves that can be represented
                by Lineto / ZoneClose commands, will be. Defaults to False.
            rtol (float, optional): relative tolerance, passed to :func:`is_line` and
                :func:`inkex.transforms.ImmutableVector2d.is_close` for checking if a
                line can be replaced by a ZoneClose command. Defaults to 1e-5.

                .. versionadded:: 1.2
            atol: absolute tolerance, passed to :func:`is_line` and
                :func:`inkex.transforms.ImmutableVector2d.is_close`. Defaults to 1e-8.

                .. versionadded:: 1.2r   NrF   r   r   )r&   is_liner   is_closer(   r$   r.   )rQ   r  r  r  subpathr   segments          r=   r  zCubicSuperPath.to_segments  s@       	# 	#GH" # # 
S
111.....\\(GT4@@ S S'"+--(71:2F2F2O2O
1tT3 3- (kk))))"GAJqqqM22222(1+aaa.71:aaa="@71:aaa="PRRRR"#	# 	#r?   c                t    |                                                      |                                          S )z0Apply a transformation matrix to this super path)r  r   rh  r   s     r=   r   zCubicSuperPath.transform!  s*    ||~~''	22??AAAr?   c                   t                               | |||          om| d         |d         k    r.t                               | d         |d         |d                   n-t                               | d         |d         |d                   S )z_Checks if point pt_a is on the line between points pt_b and pt_c

        .. versionadded:: 1.2r   r   )r"   	collinearwithinpt_apt_bpt_ctols       r=   is_onzCubicSuperPath.is_on%  s    
 ''dD#>> 
Aw$q'!! !!$q'47DG<<<&&tAwQaAA	
r?   c                    t          |d         | d         z
  |d         | d         z
  z  |d         | d         z
  |d         | d         z
  z  z
            |k     S )zChecks if points pt_a, pt_b, pt_c lie on the same line,
        i.e. that the cross product (b-a) x (c-a) < tol

        .. versionadded:: 1.2r   r   )absr  s       r=   r  zCubicSuperPath.collinear0  si     a47"tAwa'897T!W$a47):;<  		
r?   c                B    || cxk    o|k    nc p|| cxk    o|k    nc S )zOChecks if float val_b is between val_a and val_c

        .. versionadded:: 1.2r;   )val_bval_aval_cs      r=   r  zCubicSuperPath.within>  sG    
 &&&&&&&&A%5*A*A*A*AE*A*A*A*AAr?   c                   t          | d                                       | d         ||          o/t          |d                                       |d         ||          }|rdS t                              |d         |d         | d         |          o.t                              | d         | d         |d         |          S )a  Check whether csp segment (two points) can be expressed as a line has retracted handles or the handles
        can be retracted without loss of information (i.e. both handles lie on the
        line)

        .. versionchanged:: 1.2
            Previously, it was only checked if both control points have retracted
            handles. Now it is also checked if the handles can be retracted without
            (visible) loss of information (i.e. both handles lie on the line connecting
            the nodes).

        Arguments:
            previous: first node in superpath notation
            segment: second node in superpath notation
            rtol (float, optional): relative tolerance, passed to
                :func:`inkex.transforms.ImmutableVector2d.is_close` for checking handle
                retraction. Defaults to 1e-5.

                .. versionadded:: 1.2
            atol (float, optional): absolute tolerance, passed to
                :func:`inkex.transforms.ImmutableVector2d.is_close` for checking handle
                retraction and
                :func:`inkex.paths.CubicSuperPath.is_on` for checking if all points
                (nodes + handles) lie on a line. Defaults to 1e-8.

                .. versionadded:: 1.2
        r   r   r   T)r   r  r"   r  )r   r  r  r  	retracteds        r=   r  zCubicSuperPath.is_lineE  s    : Xa[))22QKt
 
 Dwqz""++GAJdCC 	  	4 ##AJ
HQK
 
 O""8A;WQZNN	Or?   rj  )Fr  r  )r  )r  r  )rA   rB   rC   rD   r   r   r   r  r   r  r  r  r   r   r  r  r  r  rk  rl  s   @r=   r"   r"   }  sd            # # #S8 S8 S8 S8 S8 S8j     XE E E E# # # #>B B B 
 
 
 \
 
 
 
 \
 B B \B *O *O *O \*O *O *O *O *Or?   r"   c                v	   | dd         }|dd         \  }}}}}}}	|t           z  dz  }||	g}
|dk    s|dk    s||
k    r:|dd         |dd         |dd         g|
dd         |
dd         |
dd         ggS t          t          |          d|z  dgdd|z  ggt          |           f          }t          ||           t          ||
           |
d         |d         z
   |
d         |d         z
  g}|d         |d         z  |d         |d         z  z   }|dxx         t	          |          z  cc<   |dxx         t	          |          z  cc<   t	          t          dd|dz  z
                      }||k    r|dz  }|
d         |d         z   d	z  ||d         z  z   |
d         |d         z   d	z  ||d         z  z   g}|d         |d         z
  |d         |d         z
  g}|
d         |d         z
  |
d         |d         z
  g}t          |d         t          |          z            }|d         dk     r|dz  }t          |d         t          |          z            }|d         dk     r|dz  }|r||k    r|d
t           z  z  }|s||k     r|d
t           z  z  }t          t          ||z
            d
z  t           z            dz   }||z
  |z  }dt          |dz            z  dz  }g }t          d|dz   d          D ]}|||z  z   }|d         t          |          z   | t          |          z  z
  |d         t          |          z   | t          |          z  z   g}|d         t          |          z   |d         t          |          z   g}|d         t          |          z   |t          |          z  z
  |d         t          |          z   |t          |          z  z   g}|                    |||g           |d         d         dd         |d         d<   |d         d         dd         |d         d
<   t          t          |          |dgd|ggt          |           f          }|D ]D}t          ||d                    t          ||d                    t          ||d
                    E|S )a  Approximates an arc with cubic bezier segments.

    Arguments:
        point:  Starting point (absolute coords)
        params: Arcs parameters as per
              https://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands

    Returns a list of triplets of points :
    [control_point_before, node, control_point_after]
    (first and last returned triplets are [p1, p1, *] and [*, p2, p2])
    Nr  r   r  r  r   g      @rF   g       @r   re  g      @)r   matprodrotmatapplymatr   maxr	   normintr  r
   ranger   r   r   )pointparamsr  r  r  tetalongflag	sweepflagrS  rT  r  matkr  OOAOBstartend	NbSectorsdTetar  pr*  anglev1ptv2ptss                                r=   r  r  s  s    	aaaA06qqq	-BD(Ir2"9uD	RA	Qww"''Q!VV111qtQqqqT"QqqqT1QQQ4111$677 6$<<38S/Cr?!CVTE]]S
T
TCS!S!Q4!A$;1!%A	!qtadQqTk!AaDDDDGGODDDaDDDDGGODDDSACK  !!A 9 	
R
A$1+	q1Q4x	'!A$1+)<q1Q4x)GHA
A$1+qtad{	#B
A$1+qtad{	#BAb!""E	!uqyy
r!utBxx
 
 C	!uqyyr	  US[[q2v 53;;q2vC$$q(2-..2I5[I%E	Cs"A
A1i!mQ''  E	!aD3u::!s5zz 11aD3u::!s5zz 11
 dSZZ1E

!23dSZZ!c%jj.0!A$U2Ca#e**n2TU	"b"d1gaaajAaDGuQx{AbE!H 6$<<2q'Ar7!3VTE]]C
D
DC  c!fc!fc!fHr?   c                   | d         }| dd         D ]}|d         d         |d         d         z  |d         d         |d         d         z  z   }|d         d         |d         d         z  |d         d         |d         d         z  z   }|d         d         |d         d         z  |d         d         |d         d         z  z   }|d         d         |d         d         z  |d         d         |d         d         z  z   }||g||gg}|S )zGet the product of the matr   r   Nr;   )mlistprodr  a00a01a10a11s          r=   r  r    s   8DQRRy ( (1gaj3q6!9$tAwqzCF1I'==1gaj3q6!9$tAwqzCF1I'==1gaj3q6!9$tAwqzCF1I'==1gaj3q6!9$tAwqzCF1I'==c
S#J'Kr?   c                |    t          |           t          |            gt          |           t          |           ggS )zRotate the mat)r   r   )r  s    r=   r  r    s1    YYT
#c$iiT%;<<r?   c                    | d         d         |d         z  | d         d         |d         z  z   }| d         d         |d         z  | d         d         |d         z  z   }||d<   ||d<   dS )zApply the given matr   r   Nr;   )r  r  r   r   s       r=   r  r    sp    Aq	E!Hs1vay5833AAq	E!Hs1vay5833AE!HE!HHHr?   c                b    t          | d         | d         z  | d         | d         z  z             S )	Normaliser   r   )r   )r  s    r=   r  r    s/    a58#eAhq&99:::r?   )JrD   
__future__r   rer`  abcmathr   r   r   r   r   r	   r
   typingr   r   r   r   r   r   r   r   r   
transformsr   r   r   r   r   utilsr   r   r   r   __all__compiler&  NONEr   r8   ABCr   r#   r    r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   rk   rf  r!   r"   r  r  r  r  r  r;   r?   r=   <module>r     s  &  # " " " " " 				  



 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
              * ) ) ) ) ) ) ) 7:]3337-5JKKK > "*J
K
K""3 3 3 3 3* 3 3 3L7 L7 L7 L7 L7#' L7 L7 L7^(A (A (A (A (A+ (A (A (AV07 07 07 07 07+ 07 07 07f'$ '$ '$ '$ '$ '$ '$ '$T( ( ( ( ( ( ( ((&$ &$ &$ &$ &$ &$ &$ &$R8 8 8 8 8 8 8 8*"$ "$ "$ "$ "$# "$ "$ "$J8 8 8 8 8# 8 8 8". . . . . . . .b       6. . . . . . . .b       6CI CI CI CI CI CI CI CIL'
 '
 '
 '
 '
 '
 '
 '
T@8 @8 @8 @8 @8  @8 @8 @8FX X X X X  X X X:<; <; <; <; <;# <; <; <;~
 
 
 
 
# 
 
 
4<. <. <. <. <.( <. <. <.~4 4 4 4 4( 4 4 42C
 C
 C
 C
 C

 C
 C
 C
L1
 1
 1
 1
 1

 1
 1
 1
h      	 
                        ! " # $ 
		)      0S# S# S# S# S#4 S# S# S#lsO sO sO sO sOT sO sO sOlQ Q Qh	 	 	= = =
  ; ; ; ; ;r?   