B
    ò¶I`L  ã               @   s  d Z ddlmZ ddlZddlZddlZddlmZ ej	edd�dd„ ƒƒZ
G dd	„ d	eƒZd
d„ Zdd„ Zdd„ Zdd„ Zd4dd„ZG dd„ dƒZd5dd„Zd6dd„Zdd„ Zd d!„ Zd7d#d$„Zd%d&„ Zd'd(„ Zd8d*d+„Zejd,d-d.�d/d0„ ƒZejd,d1d.�d2d3„ ƒZdS )9zO
A module providing some utility functions regarding Bezier path manipulation.
é    )Ú	lru_cacheNé€   )Úmaxsizec             C   sF   || krdS t || | ƒ}t d|d ¡}t | d | | ¡ t¡S )Nr   é   )ÚminÚnpÚarangeÚprodZastypeÚint)ÚnÚkÚi© r   ú5/tmp/pip-unpacked-wheel-tvo012g9/matplotlib/bezier.pyÚ_comb   s
    r   c               @   s   e Zd ZdS )ÚNonIntersectingPathExceptionN)Ú__name__Ú
__module__Ú__qualname__r   r   r   r   r      s   r   c                s¾   ||  ||  }|| ||  }	||  }
}||  }}|
| ||  ‰ t ˆ ƒdk r\tdƒ‚||  }}| |
 }}‡ fdd„||||gD ƒ\}}}}|| ||	  }|| ||	  }||fS )zŽ
    Return the intersection between the line through (*cx1*, *cy1*) at angle
    *t1* and the line through (*cx2*, *cy2*) at angle *t2*.
    gê-�™—q=zcGiven lines do not intersect. Please verify that the angles are not equal or differ by 180 degrees.c                s   g | ]}|ˆ  ‘qS r   r   )Ú.0r   )Úad_bcr   r   ú
<listcomp>9   s    z$get_intersection.<locals>.<listcomp>)ÚabsÚ
ValueError)Zcx1Zcy1Úcos_t1Úsin_t1Zcx2Zcy2Úcos_t2Úsin_t2Z	line1_rhsZ	line2_rhsÚaÚbÚcÚdZa_Zb_Zc_Zd_ÚxÚyr   )r   r   Úget_intersection    s    
"r$   c             C   sl   |dkr| || |fS ||  }}| | }}|| |  || |  }	}
|| |  || |  }}|	|
||fS )z·
    For a line passing through (*cx*, *cy*) and having an angle *t*, return
    locations of the two points located along its perpendicular line at the
    distance of *length*.
    g        r   )ÚcxÚcyZcos_tZsin_tÚlengthr   r   r   r   Úx1Úy1Zx2Úy2r   r   r   Úget_normal_pointsA   s    r+   c             C   s(   | d d… d|  | dd … |  }|S )Néÿÿÿÿr   r   )ÚbetaÚtZ	next_betar   r   r   Ú_de_casteljau1Z   s    $r/   c             C   s`   t  | ¡} | g}x&t| |ƒ} | | ¡ t| ƒdkrP qW dd„ |D ƒ}dd„ t|ƒD ƒ}||fS )z”
    Split a Bezier segment defined by its control points *beta* into two
    separate segments divided at *t* and return their control points.
    r   c             S   s   g | ]}|d  ‘qS )r   r   )r   r-   r   r   r   r   k   s    z&split_de_casteljau.<locals>.<listcomp>c             S   s   g | ]}|d  ‘qS )r,   r   )r   r-   r   r   r   r   l   s    )r   Úasarrayr/   ÚappendÚlenÚreversed)r-   r.   Z	beta_listZ	left_betaZ
right_betar   r   r   Úsplit_de_casteljau_   s    


r4   ç        ç      ð?ç{®Gáz„?c             C   s°   | |ƒ}| |ƒ}||ƒ}||ƒ}||kr8||kr8t dƒ‚xrt |d |d  |d |d  ¡|k rj||fS d||  }	| |	ƒ}
||
ƒ}||A rœ|	}|
}|}q:|	}|
}|}q:W dS )a‰  
    Find the intersection of the Bezier curve with a closed path.

    The intersection point *t* is approximated by two parameters *t0*, *t1*
    such that *t0* <= *t* <= *t1*.

    Search starts from *t0* and *t1* and uses a simple bisecting algorithm
    therefore one of the end points must be inside the path while the other
    doesn't. The search stops when the distance of the points parametrized by
    *t0* and *t1* gets smaller than the given *tolerance*.

    Parameters
    ----------
    bezier_point_at_t : callable
        A function returning x, y coordinates of the Bezier at parameter *t*.
        It must have the signature::

            bezier_point_at_t(t: float) -> Tuple[float, float]

    inside_closedpath : callable
        A function returning True if a given point (x, y) is inside the
        closed path. It must have the signature::

            inside_closedpath(point: Tuple[float, float]) -> bool

    t0, t1 : float
        Start parameters for the search.

    tolerance : float
        Maximal allowed distance between the final points.

    Returns
    -------
    t0, t1 : float
        The Bezier path parameters.
    z3Both points are on the same side of the closed pathr   r   g      à?N)r   r   Úhypot)Úbezier_point_at_tÚinside_closedpathÚt0Út1Ú	toleranceÚstartÚendZstart_insideZ
end_insideZmiddle_tZmiddleZmiddle_insider   r   r   Ú*find_bezier_t_intersecting_with_closedpathq   s(    &(r@   c               @   s`   e Zd ZdZdd„ Zdd„ Zdd„ Zedd	„ ƒZed
d„ ƒZ	edd„ ƒZ
edd„ ƒZdd„ ZdS )ÚBezierSegmentz–
    A d-dimensional Bezier segment.

    Parameters
    ----------
    control_points : (N, d) array
        Location of the *N* control points.
    c                sV   t  |¡ˆ _ˆ jj\ˆ _ˆ _t  ˆ j¡ˆ _‡ fdd„tˆ jƒD ƒ}ˆ jj	| j	ˆ _
d S )Nc                s:   g | ]2}t  ˆ jd  ¡t  |¡t  ˆ jd  | ¡  ‘qS )r   )ÚmathÚ	factorialÚ_N)r   r   )Úselfr   r   r   Ä   s   z*BezierSegment.__init__.<locals>.<listcomp>)r   r0   Ú_cpointsÚshaperD   Ú_dr   Ú_ordersÚrangeÚTÚ_px)rE   Úcontrol_pointsZcoeffr   )rE   r   Ú__init__À   s    
zBezierSegment.__init__c             C   s>   t  |¡}t j d| | jddd… ¡t j || j¡ | j S )a9  
        Evaluate the Bezier curve at point(s) t in [0, 1].

        Parameters
        ----------
        t : float (k,), array_like
            Points at which to evaluate the curve.

        Returns
        -------
        float (k, d), array_like
            Value of the curve for each point in *t*.
        r   Nr,   )r   r0   ÚpowerÚouterrI   rL   )rE   r.   r   r   r   Ú__call__É   s    
zBezierSegment.__call__c             C   s   t | |ƒƒS )z?Evaluate curve at a single point *t*. Returns a Tuple[float*d].)Útuple)rE   r.   r   r   r   Ú
point_at_tÛ   s    zBezierSegment.point_at_tc             C   s   | j S )z The control points of the curve.)rF   )rE   r   r   r   rM   ß   s    zBezierSegment.control_pointsc             C   s   | j S )zThe dimension of the curve.)rH   )rE   r   r   r   Ú	dimensionä   s    zBezierSegment.dimensionc             C   s
   | j d S )z@Degree of the polynomial. One less the number of control points.r   )rD   )rE   r   r   r   Údegreeé   s    zBezierSegment.degreec             C   s|   | j }|dkrt dt¡ | j}t |d ¡dd…df }t |d ¡ddd…f }d||  t||ƒ }t||ƒ| | S )aÄ  
        The polynomial coefficients of the Bezier curve.

        .. warning:: Follows opposite convention from `numpy.polyval`.

        Returns
        -------
        float, (n+1, d) array_like
            Coefficients after expanding in polynomial basis, where :math:`n`
            is the degree of the bezier curve and :math:`d` its dimension.
            These are the numbers (:math:`C_j`) such that the curve can be
            written :math:`\sum_{j=0}^n C_j t^j`.

        Notes
        -----
        The coefficients are calculated as

        .. math::

            {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i

        where :math:`P_i` are the control points of the curve.
        é
   zFPolynomial coefficients formula unstable for high order Bezier curves!r   Nr,   )rU   ÚwarningsÚwarnÚRuntimeWarningrM   r   r   r   )rE   r   ÚPÚjr   Z	prefactorr   r   r   Úpolynomial_coefficientsî   s    z%BezierSegment.polynomial_coefficientsc       
      C   sä   | j }|dkr"t g ¡t g ¡fS | j}t d|d ¡dd…df |dd…  }g }g }xFt|jƒD ]8\}}t |ddd… ¡}| |¡ | t 	||¡¡ qdW t 
|¡}t 
|¡}t |¡|dk@ |dk@ }	||	 t |¡|	 fS )aé  
        Return the dimension and location of the curve's interior extrema.

        The extrema are the points along the curve where one of its partial
        derivatives is zero.

        Returns
        -------
        dims : int, array_like
            Index :math:`i` of the partial derivative which is zero at each
            interior extrema.
        dzeros : float, array_like
            Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) =
            0`
        r   Nr,   r   )rU   r   Úarrayr\   r   Ú	enumeraterK   Úrootsr1   Z	full_likeÚconcatenateZisrealÚreal)
rE   r   ZCjZdCjZdimsr_   r   ÚpiÚrZin_ranger   r   r   Úaxis_aligned_extrema  s    (


z"BezierSegment.axis_aligned_extremaN)r   r   r   Ú__doc__rN   rQ   rS   ÚpropertyrM   rT   rU   r\   rd   r   r   r   r   rA   ¶   s   	$rA   c       	      C   s>   t | ƒ}|j}t|||d�\}}t| || d ƒ\}}||fS )an  
    Split a Bezier curve into two at the intersection with a closed path.

    Parameters
    ----------
    bezier : array-like(N, 2)
        Control points of the Bezier segment. See `.BezierSegment`.
    inside_closedpath : callable
        A function returning True if a given point (x, y) is inside the
        closed path. See also `.find_bezier_t_intersecting_with_closedpath`.
    tolerance : float
        The tolerance for the intersection. See also
        `.find_bezier_t_intersecting_with_closedpath`.

    Returns
    -------
    left, right
        Lists of control points for the two Bezier segments.
    )r=   g       @)rA   rS   r@   r4   )	Zbezierr:   r=   Zbzr9   r;   r<   Ú_leftZ_rightr   r   r   Ú)split_bezier_intersecting_with_closedpath3  s    rh   Fc             C   s  ddl m} |  ¡ }t|ƒ\}}||dd… ƒ}|}	d}
d}x\|D ]L\}}|}
|t|ƒd 7 }||dd… ƒ|krŠt |	dd… |g¡}P |}	qBW tdƒ‚| d¡}t	|||ƒ\}}t|ƒdkrÖ|j
g}|j|j
g}nht|ƒd	k�r|j|jg}|j|j|jg}n<t|ƒd
k�r6|j|j|jg}|j|j|j|jg}ntdƒ‚|dd… }|dd… }| jdk�rœ|t | jd|… |g¡ƒ}|t || j|d… g¡ƒ}nd|t | jd|
… |g¡t | jd|
… |g¡ƒ}|t || j|d… g¡t || j|d… g¡ƒ}|�r|�s|| }}||fS )z`
    Divide a path into two segments at the point where ``inside(x, y)`` becomes
    False.
    r   )ÚPathéþÿÿÿNr   é   z*The path does not intersect with the patch)r,   rk   é   é   zThis should never be reached)Úpathri   Ziter_segmentsÚnextr2   r   r`   r   Zreshaperh   ÚLINETOÚMOVETOZCURVE3ZCURVE4ÚAssertionErrorÚcodesÚvertices)rn   Zinsider=   Zreorder_inoutri   Z	path_iterZ
ctl_pointsÚcommandZbegin_insideZctl_points_oldZioldr   Zbezier_pathZbpÚleftÚrightZ
codes_leftZcodes_rightZ
verts_leftZverts_rightZpath_inZpath_outr   r   r   Úsplit_path_inoutV  sP    

rx   c                s   |d ‰‡ ‡‡fdd„}|S )zÎ
    Return a function that checks whether a point is in a circle with center
    (*cx*, *cy*) and radius *r*.

    The returned function has the signature::

        f(xy: Tuple[float, float]) -> bool
    rk   c                s$   | \}}|ˆ  d |ˆ d  ˆk S )Nrk   r   )Zxyr"   r#   )r%   r&   Úr2r   r   Ú_fž  s    zinside_circle.<locals>._fr   )r%   r&   rc   rz   r   )r%   r&   ry   r   Úinside_circle“  s    	r{   c             C   sB   ||  ||  }}|| ||  d }|dkr2dS || || fS )Ng      à?r   )g        g        r   )Zx0Zy0r(   r)   ZdxZdyr!   r   r   r   Úget_cos_sin¦  s
    r|   çñhãˆµøä>c             C   sN   t  | |¡}t  ||¡}t|| ƒ}||k r0dS t|t j ƒ|k rFdS dS dS )aË  
    Check if two lines are parallel.

    Parameters
    ----------
    dx1, dy1, dx2, dy2 : float
        The gradients *dy*/*dx* of the two lines.
    tolerance : float
        The angular tolerance in radians up to which the lines are considered
        parallel.

    Returns
    -------
    is_parallel
        - 1 if two lines are parallel in same direction.
        - -1 if two lines are parallel in opposite direction.
        - False otherwise.
    r   r,   FN)r   Zarctan2r   rb   )Zdx1Zdy1Zdx2Zdy2r=   Ztheta1Ztheta2Zdthetar   r   r   Úcheck_if_parallel¯  s    r~   c          	   C   s~  | d \}}| d \}}| d \}}t || || || || ƒ}|dkrrt d¡ t||||ƒ\}	}
|	|
 }}n$t||||ƒ\}	}
t||||ƒ\}}t|||	|
|ƒ\}}}}t|||||ƒ\}}}}y8t|||	|
||||ƒ\}}t|||	|
||||ƒ\}}W nJ tk
�rH   d||  d||   }}d||  d||   }}Y nX ||f||f||fg}||f||f||fg}||fS )z«
    Given the quadratic Bezier control points *bezier2*, returns
    control points of quadratic Bezier lines roughly parallel to given
    one separated by *width*.
    r   r   rk   r,   z8Lines do not intersect. A straight line is used instead.g      à?)r~   ÚcbookZ_warn_externalr|   r+   r$   r   )Úbezier2ÚwidthÚc1xÚc1yÚcmxÚcmyÚc2xÚc2yZparallel_testr   r   r   r   Úc1x_leftÚc1y_leftÚ	c1x_rightÚ	c1y_rightZc2x_leftZc2y_leftZ	c2x_rightZ	c2y_rightZcmx_leftZcmy_leftZ	cmx_rightZ	cmy_rightÚ	path_leftÚ
path_rightr   r   r   Úget_parallelsÍ  s>     

rŽ   c             C   s>   dd| | |   }dd| ||   }| |f||f||fgS )z�
    Find control points of the Bezier curve passing through (*c1x*, *c1y*),
    (*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1.
    g      à?rm   r   )r‚   rƒ   ZmmxZmmyr†   r‡   r„   r…   r   r   r   Úfind_control_points  s    r�   ç      à?c       %      C   s(  | d \}}| d \}}| d \}	}
t ||||ƒ\}}t |||	|
ƒ\}}t|||||| ƒ\}}}}t|	|
|||| ƒ\}}}}|| d || d  }}||	 d ||
 d  }}|| d || d  }}t ||||ƒ\}}t|||||| ƒ\}} }!}"t|||| ||ƒ}#t|||!|"||ƒ}$|#|$fS )z©
    Being similar to get_parallels, returns control points of two quadratic
    Bezier lines having a width roughly parallel to given one separated by
    *width*.
    r   r   rk   g      à?)r|   r+   r�   )%r€   r�   Zw1ZwmZw2r‚   rƒ   r„   r…   Zc3xZc3yr   r   r   r   rˆ   r‰   rŠ   r‹   Zc3x_leftZc3y_leftZ	c3x_rightZ	c3y_rightZc12xZc12yZc23xZc23yZc123xZc123yZcos_t123Zsin_t123Z
c123x_leftZ
c123y_leftZc123x_rightZc123y_rightrŒ   r�   r   r   r   Úmake_wedged_bezier2!  s&    r‘   z3.3z2Path.cleaned() and remove the final STOP if needed)Úalternativec             C   sR   ddl m} | j}|dkrJtjt| jƒ|j|jd�}|j	|d< || j|ƒS | S dS )z³
    If the ``codes`` attribute of `.Path` *p* is None, return a copy of *p*
    with ``codes`` set to (MOVETO, LINETO, LINETO, ..., LINETO); otherwise
    return *p* itself.
    r   )ri   N)Zdtyper   )
rn   ri   rs   r   Úfullr2   rt   rp   Z	code_typerq   )Úpri   r    r   r   r   Úmake_path_regularT  s    
r•   zPath.make_compound_path()c             C   s   ddl m} |j| Ž S )z/Concatenate a list of paths into a single path.r   )ri   )rn   ri   Zmake_compound_path)Úpathsri   r   r   r   Úconcatenate_pathsf  s    r—   )r5   r6   r7   )r7   )r7   F)r}   )r6   r�   r5   )re   Ú	functoolsr   rB   rW   Znumpyr   Zmatplotlib.cbookr   Z	vectorizer   r   r   r$   r+   r/   r4   r@   rA   rh   rx   r{   r|   r~   rŽ   r�   r‘   Ú
deprecatedr•   r—   r   r   r   r   Ú<module>   s2   	!
D~
"
=	
J

3