a
    èÝEb€•  ã                   @   s  d Z ddlmZmZmZ ddlmZ ddlZddlm	Z	 e	dg d¢ƒZ
g d¢Zdgd
d„Zdd„ Zdd„ Zdhdd„ZdZdZdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ Zd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,d-„ Zd.d/„ Zd0d1„ Z d2d3„ Z!d4d5„ Z"dd6lm#Z#m$Z$m%Z%m&Z& e#fd7d8„Z'd9d:„ Z(d;d<„ Z)d=d>„ Z*d?d@„ Z+dAdB„ Z,dCdD„ Z-dEdF„ Z.dGdH„ Z/dIdJ„ Z0dKdL„ Z1dMdN„ Z2dOdP„ Z3dQdR„ Z4dSdT„ Z5dUdV„ Z6dWdX„ Z7dYdZ„ Z8did\d]„Z9d^d_„ Z:d`da„ Z;dbdc„ Z<ddde„ Z=e>dfk�rddl?Z?ddl@Z@e? Ae@ B¡ jC¡ dS )jzNfontTools.misc.bezierTools.py -- tools for working with Bezier path segments.
é    )Ú
calcBoundsÚsectRectÚrectArea)ÚIdentityN)Ú
namedtupleÚIntersection©ÚptÚt1Út2)ÚapproximateCubicArcLengthÚapproximateCubicArcLengthCÚapproximateQuadraticArcLengthÚapproximateQuadraticArcLengthCÚcalcCubicArcLengthÚcalcCubicArcLengthCÚcalcQuadraticArcLengthÚcalcQuadraticArcLengthCÚcalcCubicBoundsÚcalcQuadraticBoundsÚ	splitLineÚsplitQuadraticÚ
splitCubicÚsplitQuadraticAtTÚsplitCubicAtTÚsolveQuadraticÚ
solveCubicÚquadraticPointAtTÚcubicPointAtTÚlinePointAtTÚsegmentPointAtTÚlineLineIntersectionsÚcurveLineIntersectionsÚcurveCurveIntersectionsÚsegmentSegmentIntersectionsç{®Gázt?c                 C   s    t t| Ž t|Ž t|Ž t|Ž |ƒS )aÄ  Calculates the arc length for a cubic Bezier segment.

    Whereas :func:`approximateCubicArcLength` approximates the length, this
    function calculates it by "measuring", recursively dividing the curve
    until the divided segments are shorter than ``tolerance``.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
        tolerance: Controls the precision of the calcuation.

    Returns:
        Arc length value.
    )r   Úcomplex)Úpt1Úpt2Úpt3Úpt4Ú	tolerance© r,   úZ/home/ja/django-apps/lartica_env/lib/python3.9/site-packages/fontTools/misc/bezierTools.pyr   *   s    ÿr   c                 C   s\   | d||   | d }|| | |  d }| | | d || |f||| || d |ffS )Né   g      À?ç      à?r,   )Úp0Úp1Úp2Úp3ÚmidZderiv3r,   r,   r-   Ú_split_cubic_into_two=   s
    þr5   c           	      C   s~   t || ƒ}t || ƒt || ƒ t || ƒ }||  |krH|| d S t||||ƒ\}}t| g|¢R Ž t| g|¢R Ž  S d S ©Nr/   )Úabsr5   Ú_calcCubicArcLengthCRecurse)	Úmultr0   r1   r2   r3   ÚarchÚboxÚoneÚtwor,   r,   r-   r8   F   s    $ÿÿr8   c                 C   s   dd|  }t || |||ƒS )zôCalculates the arc length for a cubic Bezier segment.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
        tolerance: Controls the precision of the calcuation.

    Returns:
        Arc length value.
    ç      ð?g      ø?)r8   )r'   r(   r)   r*   r+   r9   r,   r,   r-   r   R   s    
r   é   g»½×Ùß|Û=c                 C   s   | |  ¡  jS ©N)Ú	conjugateÚreal)Úv1Úv2r,   r,   r-   Ú_dotd   s    rE   c                 C   s(   | t  | d d ¡ d t  | ¡d  S )Né   é   )ÚmathÚsqrtÚasinh)Úxr,   r,   r-   Ú_intSecAtanh   s    rL   c                 C   s   t t| Ž t|Ž t|Ž ƒS )až  Calculates the arc length for a quadratic Bezier segment.

    Args:
        pt1: Start point of the Bezier as 2D tuple.
        pt2: Handle point of the Bezier as 2D tuple.
        pt3: End point of the Bezier as 2D tuple.

    Returns:
        Arc length value.

    Example::

        >>> calcQuadraticArcLength((0, 0), (0, 0), (0, 0)) # empty segment
        0.0
        >>> calcQuadraticArcLength((0, 0), (50, 0), (80, 0)) # collinear points
        80.0
        >>> calcQuadraticArcLength((0, 0), (0, 50), (0, 80)) # collinear points vertical
        80.0
        >>> calcQuadraticArcLength((0, 0), (50, 20), (100, 40)) # collinear points
        107.70329614269008
        >>> calcQuadraticArcLength((0, 0), (0, 100), (100, 0))
        154.02976155645263
        >>> calcQuadraticArcLength((0, 0), (0, 50), (100, 0))
        120.21581243984076
        >>> calcQuadraticArcLength((0, 0), (50, -10), (80, 50))
        102.53273816445825
        >>> calcQuadraticArcLength((0, 0), (40, 0), (-40, 0)) # collinear points, control point outside
        66.66666666666667
        >>> calcQuadraticArcLength((0, 0), (40, 0), (0, 0)) # collinear points, looping back
        40.0
    )r   r&   ©r'   r(   r)   r,   r,   r-   r   n   s     r   c                 C   sÞ   ||  }|| }|| }|d }t |ƒ}|dkr<t ||  ƒS t||ƒ}t |ƒtk r–t||ƒdkrlt ||  ƒS t |ƒt |ƒ }	}
|	|	 |
|
  |	|
  S t||ƒ| }t||ƒ| }t dt|ƒt|ƒ  | |||   ƒ}|S )a$  Calculates the arc length for a quadratic Bezier segment.

    Args:
        pt1: Start point of the Bezier as a complex number.
        pt2: Handle point of the Bezier as a complex number.
        pt3: End point of the Bezier as a complex number.

    Returns:
        Arc length value.
    y              ð?ç        r   rF   )r7   rE   ÚepsilonrL   )r'   r(   r)   Zd0Zd1ÚdÚnÚscaleZorigDistÚaÚbÚx0Úx1ZLenr,   r,   r-   r   ‘   s"    
(r   c                 C   s   t t| Ž t|Ž t|Ž ƒS )a«  Calculates the arc length for a quadratic Bezier segment.

    Uses Gauss-Legendre quadrature for a branch-free approximation.
    See :func:`calcQuadraticArcLength` for a slower but more accurate result.

    Args:
        pt1: Start point of the Bezier as 2D tuple.
        pt2: Handle point of the Bezier as 2D tuple.
        pt3: End point of the Bezier as 2D tuple.

    Returns:
        Approximate arc length value.
    )r   r&   rM   r,   r,   r-   r   ±   s    r   c                 C   sT   t d|  d|  d|  ƒ}t ||  ƒd }t d|  d|  d|  ƒ}|| | S )aÃ  Calculates the arc length for a quadratic Bezier segment.

    Uses Gauss-Legendre quadrature for a branch-free approximation.
    See :func:`calcQuadraticArcLength` for a slower but more accurate result.

    Args:
        pt1: Start point of the Bezier as a complex number.
        pt2: Handle point of the Bezier as a complex number.
        pt3: End point of the Bezier as a complex number.

    Returns:
        Approximate arc length value.
    gÌ”xùbŒß¿g¾ðb�ŠÛ?gF�V¨W°?gÇqÇqÜ?gF�V¨W°¿gÌ”xùbŒß?©r7   )r'   r(   r)   Úv0rC   rD   r,   r,   r-   r   Â   s    ÿÿr   c                    sŽ   t | ||ƒ\\‰ ‰\‰‰\‰‰ˆ d }ˆd }g }|dkrJ| ˆ | ¡ |dkrb| ˆ | ¡ ‡ ‡‡‡‡‡fdd„|D ƒ| |g }t|ƒS )a  Calculates the bounding rectangle for a quadratic Bezier segment.

    Args:
        pt1: Start point of the Bezier as a 2D tuple.
        pt2: Handle point of the Bezier as a 2D tuple.
        pt3: End point of the Bezier as a 2D tuple.

    Returns:
        A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.

    Example::

        >>> calcQuadraticBounds((0, 0), (50, 100), (100, 0))
        (0, 0, 100, 50.0)
        >>> calcQuadraticBounds((0, 0), (100, 0), (100, 100))
        (0.0, 0.0, 100, 100)
    ç       @r   c                    sT   g | ]L}d |  krdk rn qˆ | | ˆ|  ˆ ˆ| | ˆ|  ˆ f‘qS ©r   rG   r,   ©Ú.0Út©ÚaxÚayÚbxÚbyÚcxÚcyr,   r-   Ú
<listcomp>ý   s   þz'calcQuadraticBounds.<locals>.<listcomp>)ÚcalcQuadraticParametersÚappendr   )r'   r(   r)   Zax2Zay2ÚrootsÚpointsr,   r^   r-   r   ã   s    þür   c                 C   s   t t| Ž t|Ž t|Ž t|Ž ƒS )a®  Approximates the arc length for a cubic Bezier segment.

    Uses Gauss-Lobatto quadrature with n=5 points to approximate arc length.
    See :func:`calcCubicArcLength` for a slower but more accurate result.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.

    Returns:
        Arc length value.

    Example::

        >>> approximateCubicArcLength((0, 0), (25, 100), (75, 100), (100, 0))
        190.04332968932817
        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 50), (100, 100))
        154.8852074945903
        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (150, 0)) # line; exact result should be 150.
        149.99999999999991
        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (-50, 0)) # cusp; exact result should be 150.
        136.9267662156362
        >>> approximateCubicArcLength((0, 0), (50, 0), (100, -50), (-50, 0)) # cusp
        154.80848416537057
    )r   r&   )r'   r(   r)   r*   r,   r,   r-   r     s    ÿr   c           	      C   s”   t ||  ƒd }t d|  d|  d|  d|  ƒ}t ||  | | ƒd }t d|  d|  d|  d|  ƒ}t || ƒd }|| | | | S )	z¹Approximates the arc length for a cubic Bezier segment.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.

    Returns:
        Arc length value.
    g333333Ã?g�c’‰1ãá¿g8Ø5$t×Ô?guÁ|Yù¿Ê?gæâ#$ï˜?gÑ?gæâ#$ï˜¿g�c’‰1ãá?rW   )	r'   r(   r)   r*   rX   rC   rD   Zv3Zv4r,   r,   r-   r   #  s,    ÿþýÿÿþýÿr   c                    sª   t | |||ƒ\\‰ ‰\‰‰\‰‰\‰‰ˆ d }ˆd }ˆd }ˆd }dd„ t||ˆƒD ƒ}dd„ t||ˆƒD ƒ}	||	 }
‡ ‡‡‡‡‡‡‡fdd„|
D ƒ| |g }t|ƒS )aX  Calculates the bounding rectangle for a quadratic Bezier segment.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.

    Returns:
        A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.

    Example::

        >>> calcCubicBounds((0, 0), (25, 100), (75, 100), (100, 0))
        (0, 0, 100, 75.0)
        >>> calcCubicBounds((0, 0), (50, 0), (100, 50), (100, 100))
        (0.0, 0.0, 100, 100)
        >>> print("%f %f %f %f" % calcCubicBounds((50, 0), (0, 100), (100, 100), (50, 0)))
        35.566243 0.000000 64.433757 75.000000
    ç      @rY   c                 S   s(   g | ] }d |  krdk rn q|‘qS rZ   r,   r[   r,   r,   r-   re   _  ó    z#calcCubicBounds.<locals>.<listcomp>c                 S   s(   g | ] }d |  krdk rn q|‘qS rZ   r,   r[   r,   r,   r-   re   `  rk   c                    s\   g | ]T}ˆ | | | ˆ| |  ˆ|  ˆ ˆ| | | ˆ| |  ˆ|  ˆ f‘qS r,   r,   r[   ©r_   r`   ra   rb   rc   rd   ÚdxÚdyr,   r-   re   c  s   ý&&þ)ÚcalcCubicParametersr   r   )r'   r(   r)   r*   Zax3Zay3Zbx2Zby2ZxRootsZyRootsrh   ri   r,   rl   r-   r   G  s    &ûúr   c                 C   s¨   | \}}|\}}|| }|| }	|}
|}||	f| }|dkrF| |fgS ||
|f|  | }d|  krndk ršn n(|| |
 |	| | f}| |f||fgS | |fgS dS )a  Split a line at a given coordinate.

    Args:
        pt1: Start point of line as 2D tuple.
        pt2: End point of line as 2D tuple.
        where: Position at which to split the line.
        isHorizontal: Direction of the ray splitting the line. If true,
            ``where`` is interpreted as a Y coordinate; if false, then
            ``where`` is interpreted as an X coordinate.

    Returns:
        A list of two line segments (each line segment being two 2D tuples)
        if the line was successfully split, or a list containing the original
        line.

    Example::

        >>> printSegments(splitLine((0, 0), (100, 100), 50, True))
        ((0, 0), (50, 50))
        ((50, 50), (100, 100))
        >>> printSegments(splitLine((0, 0), (100, 100), 100, True))
        ((0, 0), (100, 100))
        >>> printSegments(splitLine((0, 0), (100, 100), 0, True))
        ((0, 0), (0, 0))
        ((0, 0), (100, 100))
        >>> printSegments(splitLine((0, 0), (100, 100), 0, False))
        ((0, 0), (0, 0))
        ((0, 0), (100, 100))
        >>> printSegments(splitLine((100, 0), (0, 0), 50, False))
        ((100, 0), (50, 0))
        ((50, 0), (0, 0))
        >>> printSegments(splitLine((0, 100), (0, 0), 50, True))
        ((0, 100), (0, 50))
        ((0, 50), (0, 0))
    r   rG   Nr,   )r'   r(   ÚwhereÚisHorizontalZpt1xZpt1yZpt2xZpt2yr_   r`   ra   rb   rS   r]   ZmidPtr,   r,   r-   r   m  s    $
r   c           	      C   sd   t | ||ƒ\}}}t|| || || | ƒ}tdd„ |D ƒƒ}|sP| ||fgS t|||g|¢R Ž S )a  Split a quadratic Bezier curve at a given coordinate.

    Args:
        pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
        where: Position at which to split the curve.
        isHorizontal: Direction of the ray splitting the curve. If true,
            ``where`` is interpreted as a Y coordinate; if false, then
            ``where`` is interpreted as an X coordinate.

    Returns:
        A list of two curve segments (each curve segment being three 2D tuples)
        if the curve was successfully split, or a list containing the original
        curve.

    Example::

        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 150, False))
        ((0, 0), (50, 100), (100, 0))
        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, False))
        ((0, 0), (25, 50), (50, 50))
        ((50, 50), (75, 50), (100, 0))
        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, False))
        ((0, 0), (12.5, 25), (25, 37.5))
        ((25, 37.5), (62.5, 75), (100, 0))
        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, True))
        ((0, 0), (7.32233, 14.6447), (14.6447, 25))
        ((14.6447, 25), (50, 75), (85.3553, 25))
        ((85.3553, 25), (92.6777, 14.6447), (100, -7.10543e-15))
        >>> # XXX I'm not at all sure if the following behavior is desirable:
        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, True))
        ((0, 0), (25, 50), (50, 50))
        ((50, 50), (50, 50), (50, 50))
        ((50, 50), (75, 50), (100, 0))
    c                 s   s*   | ]"}d |  krdk rn q|V  qdS ©r   rG   Nr,   r[   r,   r,   r-   Ú	<genexpr>Í  rk   z!splitQuadratic.<locals>.<genexpr>)rf   r   ÚsortedÚ_splitQuadraticAtT)	r'   r(   r)   rp   rq   rS   rT   ÚcÚ	solutionsr,   r,   r-   r   ¦  s    #ÿr   c                 C   sr   t | |||ƒ\}}}}	t|| || || |	| | ƒ}
tdd„ |
D ƒƒ}
|
s\| |||fgS t||||	g|
¢R Ž S )aÞ  Split a cubic Bezier curve at a given coordinate.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
        where: Position at which to split the curve.
        isHorizontal: Direction of the ray splitting the curve. If true,
            ``where`` is interpreted as a Y coordinate; if false, then
            ``where`` is interpreted as an X coordinate.

    Returns:
        A list of two curve segments (each curve segment being four 2D tuples)
        if the curve was successfully split, or a list containing the original
        curve.

    Example::

        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 150, False))
        ((0, 0), (25, 100), (75, 100), (100, 0))
        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 50, False))
        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
        ((50, 75), (68.75, 75), (87.5, 50), (100, 0))
        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 25, True))
        ((0, 0), (2.29379, 9.17517), (4.79804, 17.5085), (7.47414, 25))
        ((7.47414, 25), (31.2886, 91.6667), (68.7114, 91.6667), (92.5259, 25))
        ((92.5259, 25), (95.202, 17.5085), (97.7062, 9.17517), (100, 1.77636e-15))
    c                 s   s*   | ]"}d |  krdk rn q|V  qdS rr   r,   r[   r,   r,   r-   rs   ò  rk   zsplitCubic.<locals>.<genexpr>)ro   r   rt   Ú_splitCubicAtT)r'   r(   r)   r*   rp   rq   rS   rT   rv   rP   rw   r,   r,   r-   r   Ó  s    ÿr   c                 G   s&   t | ||ƒ\}}}t|||g|¢R Ž S )a•  Split a quadratic Bezier curve at one or more values of t.

    Args:
        pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
        *ts: Positions at which to split the curve.

    Returns:
        A list of curve segments (each curve segment being three 2D tuples).

    Examples::

        >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5))
        ((0, 0), (25, 50), (50, 50))
        ((50, 50), (75, 50), (100, 0))
        >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5, 0.75))
        ((0, 0), (25, 50), (50, 50))
        ((50, 50), (62.5, 50), (75, 37.5))
        ((75, 37.5), (87.5, 25), (100, 0))
    )rf   ru   )r'   r(   r)   ÚtsrS   rT   rv   r,   r,   r-   r   ø  s    r   c           	      G   s,   t | |||ƒ\}}}}t||||g|¢R Ž S )a   Split a cubic Bezier curve at one or more values of t.

    Args:
        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
        *ts: Positions at which to split the curve.

    Returns:
        A list of curve segments (each curve segment being four 2D tuples).

    Examples::

        >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5))
        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
        ((50, 75), (68.75, 75), (87.5, 50), (100, 0))
        >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5, 0.75))
        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
        ((50, 75), (59.375, 75), (68.75, 68.75), (77.3438, 56.25))
        ((77.3438, 56.25), (85.9375, 43.75), (93.75, 25), (100, 0))
    )ro   rx   )	r'   r(   r)   r*   ry   rS   rT   rv   rP   r,   r,   r-   r     s    r   c                 G   s  t |ƒ}g }| dd¡ | d¡ | \}}|\}}|\}	}
tt|ƒd ƒD ]¾}|| }||d  }|| }|| }|| }|| }d| | | | }d| | | | }|| }|| ||  |	 }|| ||  |
 }t||f||f||fƒ\}}}| |||f¡ qJ|S )Nr   rN   r>   rG   rF   )ÚlistÚinsertrg   ÚrangeÚlenÚcalcQuadraticPoints)rS   rT   rv   ry   Úsegmentsr_   r`   ra   rb   rc   rd   Úir
   r   ÚdeltaÚdelta_2Úa1xÚa1yÚb1xÚb1yÚt1_2Úc1xÚc1yr'   r(   r)   r,   r,   r-   ru   (  s,    
ru   c           "      G   s‚  t |ƒ}| dd¡ | d¡ g }| \}}|\}}	|\}
}|\}}tt|ƒd ƒD �](}|| }||d  }|| }|| }|| }|| }|| }|| }|| }d| | | | }d| | |	 | }d| | |
 d| |  | }d|	 | | d| |  | }|| ||  |
|  | }|| |	|  ||  | }t||f||f||f||fƒ\}}} }!| ||| |!f¡ qR|S )Nr   rN   r>   rG   r.   rF   )rz   r{   rg   r|   r}   ÚcalcCubicPoints)"rS   rT   rv   rP   ry   r   r_   r`   ra   rb   rc   rd   rm   rn   r€   r
   r   r�   r‚   Zdelta_3r‡   Zt1_3rƒ   r„   r…   r†   rˆ   r‰   Zd1xZd1yr'   r(   r)   r*   r,   r,   r-   rx   C  s:    
  ÿrx   )rI   ÚacosÚcosÚpic                 C   s~   t | ƒtk r,t |ƒtk rg }qz| | g}nN|| d|  |  }|dkrv||ƒ}| | d |  | | d |  g}ng }|S )uK  Solve a quadratic equation.

    Solves *a*x*x + b*x + c = 0* where a, b and c are real.

    Args:
        a: coefficient of *xÂ²*
        b: coefficient of *x*
        c: constant term

    Returns:
        A list of roots. Note that the returned list is neither guaranteed to
        be sorted nor to contain unique values!
    ç      @rN   rY   ©r7   rO   )rS   rT   rv   rI   rh   ZDDZrDDr,   r,   r-   r   m  s    &r   c                 C   sŽ  t | ƒtk rt|||ƒS t| ƒ} ||  }||  }||  }|| d|  d }d| | | d| |  d|  d }|| }	|| | }
|	tk r”dn|	}	t |
ƒtk r¨dn|
}
|	|
 }|	dkrÞ|
dkrÞt| d tƒ}|||gS |td k�r@ttt|t	|
ƒ d	ƒd
ƒƒ}dt	|ƒ }|d }|t
|d ƒ | }|t
|dt  d ƒ | }|t
|dt  d ƒ | }t|||gƒ\}}}|| tk �r¸|| tk �r¸t|| | d tƒ } }}n~|| tk �rèt|| d tƒ }}t|tƒ}nN|| tk �rt|tƒ}t|| d tƒ }}nt|tƒ}t|tƒ}t|tƒ}|||gS tt	|ƒt |ƒ dƒ}|||  }|dk�rr| }t||d  tƒ}|gS dS )ut  Solve a cubic equation.

    Solves *a*x*x*x + b*x*x + c*x + d = 0* where a, b, c and d are real.

    Args:
        a: coefficient of *xÂ³*
        b: coefficient of *xÂ²*
        c: coefficient of *x*
        d: constant term

    Returns:
        A list of roots. Note that the returned list is neither guaranteed to
        be sorted nor to contain unique values!

    Examples::

        >>> solveCubic(1, 1, -6, 0)
        [-3.0, -0.0, 2.0]
        >>> solveCubic(-10.0, -9.0, 48.0, -29.0)
        [-2.9, 1.0, 1.0]
        >>> solveCubic(-9.875, -9.0, 47.625, -28.75)
        [-2.911392, 1.0, 1.0]
        >>> solveCubic(1.0, -4.5, 6.75, -3.375)
        [1.5, 1.5, 1.5]
        >>> solveCubic(-12.0, 18.0, -9.0, 1.50023651123)
        [0.5, 0.5, 0.5]
        >>> solveCubic(
        ...     9.0, 0.0, 0.0, -7.62939453125e-05
        ... ) == [-0.0, -0.0, -0.0]
        True
    rj   g      "@rY   g      ;@g      K@r   rN   r/   r>   g      ð¿g       ÀrŽ   gUUUUUUÕ?N)r7   rO   r   ÚfloatÚroundÚepsilonDigitsr‹   ÚmaxÚminrI   rŒ   r�   rt   Úpow)rS   rT   rv   rP   Za1Za2Úa3ÚQÚRZR2ZQ3ZR2_Q3rK   ÚthetaZrQ2Za1_3rU   rV   Úx2r,   r,   r-   r   Ž  sT    &(
 





r   c                 C   s^   |\}}|\}}| \}}|| d }	|| d }
|| |	 }|| |
 }||f|	|
f||ffS )NrY   r,   )r'   r(   r)   rš   Úy2Úx3Úy3rc   rd   ra   rb   r_   r`   r,   r,   r-   rf   ï  s    rf   c                 C   s”   |\}}|\}}|\}}	| \}
}||
 d }|| d }|| d | }|| d | }||
 | | }|	| | | }||f||f||f|
|ffS ©Nrj   r,   )r'   r(   r)   r*   rš   r›   rœ   r�   Úx4Úy4rm   rn   rc   rd   ra   rb   r_   r`   r,   r,   r-   ro   ú  s    ro   c                 C   sf   | \}}|\}}|\}}|}	|}
|d | }|d | }|| | }|| | }|	|
f||f||ffS r6   r,   )rS   rT   rv   r_   r`   ra   rb   rc   rd   rV   Úy1rš   r›   rœ   r�   r,   r,   r-   r~     s    r~   c                 C   sœ   | \}}|\}}|\}}	|\}
}|
}|}|d |
 }|	d | }|| d | }||	 d | }||
 | | }|| |	 | }||f||f||f||ffS rž   r,   )rS   rT   rv   rP   r_   r`   ra   rb   rc   rd   rm   rn   rV   r¡   rš   r›   rœ   r�   rŸ   r    r,   r,   r-   rŠ     s    rŠ   c                 C   s8   | d d|  |d |  | d d|  |d |  fS )zÖFinds the point at time `t` on a line.

    Args:
        pt1, pt2: Coordinates of the line as 2D tuples.
        t: The time along the line.

    Returns:
        A 2D tuple with the coordinates of the point.
    r   rG   r,   )r'   r(   r]   r,   r,   r-   r   *  s    
r   c                 C   sˆ   d| d|  | d  dd|  | |d   || |d   }d| d|  | d  dd|  | |d   || |d   }||fS )zèFinds the point at time `t` on a quadratic curve.

    Args:
        pt1, pt2, pt3: Coordinates of the curve as 2D tuples.
        t: The time along the curve.

    Returns:
        A 2D tuple with the coordinates of the point.
    rG   r   rF   r,   )r'   r(   r)   r]   rK   Úyr,   r,   r-   r   7  s    
@@r   c                 C   sè   d| d|  d|  | d  dd|  d|  | |d   dd|  | | |d   || | |d   }d| d|  d|  | d  dd|  d|  | |d   dd|  | | |d   || | |d   }||fS )zéFinds the point at time `t` on a cubic curve.

    Args:
        pt1, pt2, pt3, pt4: Coordinates of the curve as 2D tuples.
        t: The time along the curve.

    Returns:
        A 2D tuple with the coordinates of the point.
    rG   r   r.   r,   )r'   r(   r)   r*   r]   rK   r¢   r,   r,   r-   r   F  s"    ÿþýÿÿþýÿr   c                 C   sf   t | ƒdkrtg | ¢|‘R Ž S t | ƒdkr<tg | ¢|‘R Ž S t | ƒdkrZtg | ¢|‘R Ž S tdƒ‚d S ©NrF   r.   é   úUnknown curve degree)r}   r   r   r   Ú
ValueError)Úsegr]   r,   r,   r-   r    _  s    r    c           	      C   sx   | \}}|\}}|\}}t || ƒtk r<t || ƒtk r<dS t || ƒt || ƒkrd|| ||  S || ||  S d S )Néÿÿÿÿr�   )	ÚsÚer	   ÚsxZsyÚexZeyZpxÚpyr,   r,   r-   Ú_line_t_of_ptn  s     r®   c                 C   sR   | d |d  |d |d   }| d |d  |d |d   }|dkoN|dk S )Nr   rG   rN   r,   )rS   rT   ÚoriginZxDiffZyDiffr,   r,   r-   Ú'_both_points_are_on_same_side_of_origin|  s      r°   c                 C   s  | \}}|\}}|\}}	|\}
}t  ||
¡rHt  ||¡rHt  ||¡sHg S t  |	|¡rpt  ||¡rpt  ||	¡spg S t  ||
¡rŒt  |	|¡rŒg S t  ||¡r¨t  ||¡r¨g S t  ||¡�r|}||	 |
|  }|||  |	 }||f}t|t| ||ƒt|||ƒd�gS t  ||
¡�r\|}|| ||  }|||  | }||f}t|t| ||ƒt|||ƒd�gS || ||  }||	 |
|  }t  ||¡�rŽg S || | ||  |	 ||  }|||  | }||f}t||| ƒ�rt|||ƒ�rt|t| ||ƒt|||ƒd�gS g S )aí  Finds intersections between two line segments.

    Args:
        s1, e1: Coordinates of the first line as 2D tuples.
        s2, e2: Coordinates of the second line as 2D tuples.

    Returns:
        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
        and ``t2`` attributes containing the intersection point, time on first
        segment and time on second segment respectively.

    Examples::

        >>> a = lineLineIntersections( (310,389), (453, 222), (289, 251), (447, 367))
        >>> len(a)
        1
        >>> intersection = a[0]
        >>> intersection.pt
        (374.44882952482897, 313.73458370177315)
        >>> (intersection.t1, intersection.t2)
        (0.45069111555824465, 0.5408153767394238)
    r   )rH   Úiscloser   r®   r°   )Ús1Úe1Ús2Úe2Zs1xZs1yZe1xZe1yZs2xZs2yZe2xZe2yrK   Zslope34r¢   r	   Zslope12r,   r,   r-   r!   ‚  sr    
ÿ
ÿ
ÿ
ÿ
ÿ
ÿÿÿÿÿ ÿ
þÿÿr!   c                 C   sT   | d }| d }t  |d |d  |d |d  ¡}t | ¡ |d  |d  ¡S )Nr   r¨   rG   )rH   Úatan2r   ÚrotateÚ	translate)ÚsegmentÚstartÚendZangler,   r,   r-   Ú_alignment_transformationÐ  s    $r¼   c                 C   s˜   t |ƒ | ¡}t| ƒdkrBt|Ž \}}}t|d |d |d ƒ}nDt| ƒdkr~t|Ž \}}}}t|d |d |d |d ƒ}ntdƒ‚tdd„ |D ƒƒS )Nr.   rG   r¤   r¥   c                 s   s*   | ]"}d |  krdkrn q|V  qdS )rN   rG   Nr,   ©r\   r€   r,   r,   r-   rs   ä  rk   z._curve_line_intersections_t.<locals>.<genexpr>)	r¼   ZtransformPointsr}   rf   r   ro   r   r¦   rt   )ÚcurveÚlineZaligned_curverS   rT   rv   ÚintersectionsrP   r,   r,   r-   Ú_curve_line_intersections_tÚ  s     rÁ   c                 C   sŽ   t | ƒdkrt}nt | ƒdkr$t}ntdƒ‚g }t| |ƒD ]N}|g | ¢|‘R Ž }tg |¢|‘R Ž }tg |¢|‘R Ž }| t|||d�¡ q:|S )aæ  Finds intersections between a curve and a line.

    Args:
        curve: List of coordinates of the curve segment as 2D tuples.
        line: List of coordinates of the line segment as 2D tuples.

    Returns:
        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
        and ``t2`` attributes containing the intersection point, time on first
        segment and time on second segment respectively.

    Examples::
        >>> curve = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
        >>> line  = [ (25, 260), (230, 20) ]
        >>> intersections = curveLineIntersections(curve, line)
        >>> len(intersections)
        3
        >>> intersections[0].pt
        (84.9000930760723, 189.87306176459828)
    r.   r¤   r¥   r   )	r}   r   r   r¦   rÁ   r®   r   rg   r   )r¾   r¿   ZpointFinderrÀ   r]   r	   Zline_tr,   r,   r-   r"   ç  s    r"   c                 C   s4   t | ƒdkrt| Ž S t | ƒdkr(t| Ž S tdƒ‚d S )Nr.   r¤   r¥   )r}   r   r   r¦   )rv   r,   r,   r-   Ú_curve_bounds  s
    rÂ   c                 C   sx   t | ƒdkr0| \}}t|||ƒ}||f||fgS t | ƒdkrNtg | ¢|‘R Ž S t | ƒdkrltg | ¢|‘R Ž S tdƒ‚d S r£   )r}   r   r   r   r¦   )rv   r]   r©   rª   Úmidpointr,   r,   r-   Ú_split_segment_at_t  s    rÄ   çü©ñÒMbP?c              	      sx  t | ƒ}t |ƒ}|sd}|s d}t||ƒ\}}|s6g S dd„ }	t|ƒˆ k rht|ƒˆ k rh|	|ƒ|	|ƒfgS t| dƒ\}
}|d |	|ƒf}|	|ƒ|d f}t|dƒ\}}|d |	|ƒf}|	|ƒ|d f}g }| t|
|ˆ ||d�¡ | t||ˆ ||d�¡ | t|
|ˆ ||d�¡ | t||ˆ ||d�¡ ‡ fdd	„}tƒ }g }|D ]0}||ƒ}||v �r\�qB| |¡ | |¡ �qB|S )
N)rN   r>   c                 S   s   d| d | d   S )Nr/   r   rG   r,   )Úrr,   r,   r-   rÃ   1  s    z._curve_curve_intersections_t.<locals>.midpointr/   r   rG   )Úrange1Úrange2c                    s    t | d ˆ  ƒt | d ˆ  ƒfS )Nr   rG   )Úint)ry   ©Ú	precisionr,   r-   Ú<lambda>V  rk   z._curve_curve_intersections_t.<locals>.<lambda>)	rÂ   r   r   rÄ   ÚextendÚ_curve_curve_intersections_tÚsetÚaddrg   )Úcurve1Úcurve2rË   rÇ   rÈ   Zbounds1Zbounds2Z
intersectsÚ_rÃ   Zc11Zc12Z	c11_rangeZ	c12_rangeZc21Zc22Z	c21_rangeZ	c22_rangeÚfoundZ
unique_keyÚseenZunique_valuesry   Úkeyr,   rÊ   r-   rÎ   !  sb    
ÿÿ
ÿÿ
ÿÿ
ÿÿ

rÎ   c                    s   t ˆ |ƒ}‡ fdd„|D ƒS )a  Finds intersections between a curve and a curve.

    Args:
        curve1: List of coordinates of the first curve segment as 2D tuples.
        curve2: List of coordinates of the second curve segment as 2D tuples.

    Returns:
        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
        and ``t2`` attributes containing the intersection point, time on first
        segment and time on second segment respectively.

    Examples::
        >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
        >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
        >>> intersections = curveCurveIntersections(curve1, curve2)
        >>> len(intersections)
        3
        >>> intersections[0].pt
        (81.7831487395506, 109.88904552375288)
    c                    s,   g | ]$}t tˆ |d  ƒ|d  |d d�‘qS )r   rG   r   )r   r    )r\   ry   ©rÑ   r,   r-   re   z  s   ÿz+curveCurveIntersections.<locals>.<listcomp>)rÎ   )rÑ   rÒ   Zintersection_tsr,   r×   r-   r#   d  s    

þr#   c                 C   sœ   d}t |ƒt | ƒkr"| | }} d}t | ƒdkrRt |ƒdkrFt| |ƒ}q†t| |ƒ}n4t | ƒdkr~t |ƒdkr~tg | ¢|¢R Ž }ntdƒ‚|sŽ|S dd„ |D ƒS )a)  Finds intersections between two segments.

    Args:
        seg1: List of coordinates of the first segment as 2D tuples.
        seg2: List of coordinates of the second segment as 2D tuples.

    Returns:
        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
        and ``t2`` attributes containing the intersection point, time on first
        segment and time on second segment respectively.

    Examples::
        >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
        >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
        >>> intersections = segmentSegmentIntersections(curve1, curve2)
        >>> len(intersections)
        3
        >>> intersections[0].pt
        (81.7831487395506, 109.88904552375288)
        >>> curve3 = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
        >>> line  = [ (25, 260), (230, 20) ]
        >>> intersections = segmentSegmentIntersections(curve3, line)
        >>> len(intersections)
        3
        >>> intersections[0].pt
        (84.9000930760723, 189.87306176459828)

    FTrF   z4Couldn't work out which intersection function to usec                 S   s    g | ]}t |j|j|jd �‘qS )r   )r   r	   r   r
   r½   r,   r,   r-   re   ­  rk   z/segmentSegmentIntersections.<locals>.<listcomp>)r}   r#   r"   r!   r¦   )Zseg1Zseg2ZswappedrÀ   r,   r,   r-   r$   €  s    
r$   c                 C   sD   zt | ƒ}W n ty&   d|   Y S 0 dd dd„ |D ƒ¡ S dS )zw
    >>> _segmentrepr([1, [2, 3], [], [[2, [3, 4], [0.1, 2.2]]]])
    '(1, (2, 3), (), ((2, (3, 4), (0.1, 2.2))))'
    z%gz(%s)z, c                 s   s   | ]}t |ƒV  qd S r@   )Ú_segmentrepr)r\   rK   r,   r,   r-   rs   º  rk   z_segmentrepr.<locals>.<genexpr>N)ÚiterÚ	TypeErrorÚjoin)ÚobjÚitr,   r,   r-   rØ   °  s
    rØ   c                 C   s   | D ]}t t|ƒƒ qdS )zlHelper for the doctests, displaying each segment in a list of
    segments on a single line as a tuple.
    N)ÚprintrØ   )r   r¹   r,   r,   r-   ÚprintSegments½  s    rß   Ú__main__)r%   )r%   )rÅ   NN)DÚ__doc__ZfontTools.misc.arrayToolsr   r   r   ZfontTools.misc.transformr   rH   Úcollectionsr   r   Ú__all__r   r5   r8   r   r’   rO   rE   rL   r   r   r   r   r   r   r   r   r   r   r   r   r   ru   rx   rI   r‹   rŒ   r�   r   r   rf   ro   r~   rŠ   r   r   r   r    r®   r°   r!   r¼   rÁ   r"   rÂ   rÄ   rÎ   r#   r$   rØ   rß   Ú__name__ÚsysÚdoctestÚexitÚtestmodÚfailedr,   r,   r,   r-   Ú<module>   st   
	
# !"$&9-%'!aN
& ÿ
C0
