KGRKJGETMRETU895U-589TY5MIGM5JGB5SDFESFREWTGR54TY
Server : Apache
System : Linux server112.speedpacket.com 3.10.0-962.3.2.lve1.5.36.el7.x86_64 #1 SMP Mon May 18 02:16:06 EDT 2020 x86_64
User : equistyl ( 1341)
PHP Version : 8.1.30
Disable Function : NONE
Directory :  /lib64/python2.7/site-packages/matplotlib/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //lib64/python2.7/site-packages/matplotlib/path.pyo
�
r`]c@s�dZddlmZddlZddlmZddlZddlmZddl	m
Z
mZmZm
Z
mZmZmZmZmZddlmZmZddlmZd	efd
��YZe
Zd�Z
gd�ZdS(
s2
Contains a class for managing paths (polylines).
i����(tprint_functionN(tWeakValueDictionary(tma(	t
point_in_pathtget_path_extentstpoint_in_path_collectiontget_path_collection_extentstpath_in_pathtpath_intersects_pathtconvert_path_to_polygonstcleanup_pathtpoints_in_path(tsimple_linear_interpolationtmaxdict(trcParamstPathcBs	eZdZdZdZdZdZdZdZddddddddddddddddgZ	e
jZd$ded�Zed��Zed	��Zd
�Zd�Zd$ed$edd$ed
�Zd�Zd$dd�Zd$dd�Zd$d�Zd$d�Zed�Zed�Zd�Zd$ddd�Zd$Z ed��Z!e"�Z#ed��Z$e"�Z%edd��Z&ed��Z'd$Z(ed��Z)d$Z*ed��Z+ed$ed��Z,ed$d ��Z-e.d!�Z/ed"d#��Z0RS(%s�
    :class:`Path` represents a series of possibly disconnected,
    possibly closed, line and curve segments.

    The underlying storage is made up of two parallel numpy arrays:
      - *vertices*: an Nx2 float array of vertices
      - *codes*: an N-length uint8 array of vertex types

    These two arrays always have the same length in the first
    dimension.  For example, to represent a cubic curve, you must
    provide three vertices as well as three codes ``CURVE3``.

    The code types are:

       - ``STOP``   :  1 vertex (ignored)
           A marker for the end of the entire path (currently not
           required and ignored)

       - ``MOVETO`` :  1 vertex
            Pick up the pen and move to the given vertex.

       - ``LINETO`` :  1 vertex
            Draw a line from the current position to the given vertex.

       - ``CURVE3`` :  1 control point, 1 endpoint
          Draw a quadratic Bezier curve from the current position,
          with the given control point, to the given end point.

       - ``CURVE4`` :  2 control points, 1 endpoint
          Draw a cubic Bezier curve from the current position, with
          the given control points, to the given end point.

       - ``CLOSEPOLY`` : 1 vertex (ignored)
          Draw a line segment to the start point of the current
          polyline.

    Users of Path objects should not access the vertices and codes
    arrays directly.  Instead, they should use :meth:`iter_segments`
    to get the vertex/code pairs.  This is important, since many
    :class:`Path` objects, as an optimization, do not store a *codes*
    at all, but have a default one provided for them by
    :meth:`iter_segments`.

    .. note::

        The vertices and codes arrays should be treated as
        immutable -- there are a number of optimizations and assumptions
        made up front in the constructor that will not change when the
        data changes.

    iiiiiiOcCsQtj|�r0|jtj�jtj�}ntj|tj�}|dk	rxtj||j	�}t
|�r�q�nQ|r�tjt
|�d|j	�}|j|d<|j
|dd+|j|d<ntdot
|�dko|dkptj|tj
k�|_td|_tj|�j�|_||_||_||_dS(	s�
        Create a new path with the given vertices and codes.

        *vertices* is an Nx2 numpy float array, masked array or Python
        sequence.

        *codes* is an N-length numpy array or Python sequence of type
        :attr:`matplotlib.path.Path.code_type`.

        These two arrays must have the same length in the first
        dimension.

        If *codes* is None, *vertices* will be treated as a series of
        line segments.

        If *vertices* contains masked values, they will be converted
        to NaNs which are then handled correctly by the Agg
        PathIterator and other consumers of path data, such as
        :meth:`iter_segments`.

        *interpolation_steps* is used as a hint to certain projections,
        such as Polar, that this path should be linearly interpolated
        immediately before drawing.  This attribute is primarily an
        implementation detail and is not intended for public use.
        tdtypeiii����s
path.simplifyi�spath.simplify_thresholdN(Rt
isMaskedArraytastypetnptfloat_tfilledtnantasarraytNonet	code_typetlentemptytMOVETOtLINETOt	CLOSEPOLYRtallRtshould_simplifytsimplify_thresholdtisfinitet
has_nonfinitetcodestverticest_interpolation_steps(tselfR%R$R&tclosed((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt__init__Ws(!

'
		c
Cs�|j\}}}|d}||}tj|df�}tj|t�|j}|j|dd|�<|j||d|�<x7t|�D])}	|dd�|	f||	d|�<q�W|||�S(s'
        (static method) Make a compound path object to draw a number
        of polygons with equal numbers of sides XY is a (numpolys x
        numsides x 2) numpy array of vertices.  Return object is a
        :class:`Path`

        .. plot:: mpl_examples/api/histogram_path_demo.py

        iiiN(	tshapeRtzerostonestintRRRtrange(
tclstXYtnumpolystnumsidesttwotstridetnvertstvertsR$ti((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytmake_compound_path_from_polys�s

'c
Gs�x|D]}qWg|D]}t|�^q}t|�}tjg|D]}|j^qI�}|j|df�|jtj|�}d}x%|D]}	|j||<||	7}q�W|||�S(s�
        (staticmethod) Make a compound path from a list of Path
        objects.  Only polygons (not curves) are supported.
        ii(	RtsumRtvstackR%treshapeRR,R(
R/targstptxtlengthsttotal_lengthR%R$R7tlength((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytmake_compound_path�s
%

cCsd|j|jfS(NsPath(%s, %s)(R%R$(R'((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt__repr__�scCs
t|j�S(N(RR%(R'((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt__len__�sg�?c	cs�|j}t|�sdS|j}	|j}
|j}|j}|j}
|j}t||||||||�\}}	t|�}d}xj||kr�|	|}||kr�dS|
t	|�d@}||||!j
�}||fV||7}q�WdS(sl
        Iterates over all of the curve segments in the path.  Each
        iteration returns a 2-tuple (*vertices*, *code*), where
        *vertices* is a sequence of 1 - 3 coordinate pairs, and *code* is
        one of the :class:`Path` codes.

        Additionally, this method can provide a number of standard
        cleanups and conversions to the path.

        *transform*: if not None, the given affine transformation will
         be applied to the path.

        *remove_nans*: if True, will remove all NaNs from the path and
         insert MOVETO commands to skip over them.

        *clip*: if not None, must be a four-tuple (x1, y1, x2, y2)
         defining a rectangle in which to clip the path.

        *snap*: if None, auto-snap to pixels, to reduce
         fuzziness of rectilinear lines.  If True, force snapping, and
         if False, don't snap.

        *stroke_width*: the width of the stroke being drawn.  Needed
         as a hint for the snapping algorithm.

        *simplify*: if True, perform simplification, to remove
         vertices that do not affect the appearance of the path.  If
         False, perform no simplification.  If None, use the
         should_simplify member variable.

        *curves*: If True, curve segments will be returned as curve
         segments.  If False, all curves will be converted to line
         segments.
        Nii(R%RR$tNUM_VERTICESRRRtSTOPR
R-tflatten(R't	transformtremove_nanstcliptsnaptstroke_widthtsimplifytcurvesR%R$RERRRRFtlen_verticesR7tcodetnum_verticest
curr_vertices((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt
iter_segments�s*%							
cCs"t|j|j�|j|j�S(s/
        Return a transformed copy of the path.

        .. seealso::

            :class:`matplotlib.transforms.TransformedPath`
                A specialized path class that will cache the
                transformed result and automatically update when the
                transform changes.
        (RRHR%R$R&(R'RH((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyttransformedsgcCs?|dk	r|j�}nt|d|d|||�}|S(s�
        Returns *True* if the path contains the given point.

        If *transform* is not *None*, the path will be transformed
        before performing the test.

        *radius* allows the path to be made slightly larger or
        smaller.
        iiN(RtfrozenR(R'tpointRHtradiustresult((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytcontains_points
 cCs4|dk	r|j�}nt||||�}|S(s%
        Returns a bool array which is *True* if the path contains the
        corresponding point.

        If *transform* is not *None*, the path will be transformed
        before performing the test.

        *radius* allows the path to be made slightly larger or
        smaller.
        N(RRUR(R'tpointsRHRWRX((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytcontains_points$scCs.|dk	r|j�}nt|d||�S(s�
        Returns *True* if this path completely contains the given path.

        If *transform* is not *None*, the path will be transformed
        before performing the test.
        N(RRUR(R'tpathRH((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt
contains_path4scCseddlm}|}|dk	rR|j�}|jsR|j|�}d}qRn|t||��S(s
        Returns the extents (*xmin*, *ymin*, *xmax*, *ymax*) of the
        path.

        Unlike computing the extents on the *vertices* alone, this
        algorithm will take into account the curves and deal with
        control points appropriately.
        i����(tBboxN(t
transformsR^RRUt	is_affineRTR(R'RHR^R\((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytget_extents?s		cCst|||�S(s
        Returns *True* if this path intersects another given path.

        *filled*, when True, treats the paths as if they were filled.
        That is, if one path completely encloses the other,
        :meth:`intersects_path` will return True.
        (R(R'totherR((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytintersects_pathQscCsAddlm}|j�j||��}|j||�}|S(s
        Returns *True* if this path intersects a given
        :class:`~matplotlib.transforms.Bbox`.

        *filled*, when True, treats the path as if it was filled.
        That is, if one path completely encloses the other,
        :meth:`intersects_path` will return True.
        i����(tBboxTransformTo(R_Rdtunit_rectangleRTRc(R'tbboxRRdt	rectangleRX((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytintersects_bbox[s
	cCs�|dkr|St|j|�}|j}|dk	rxtjtjt|�d|df�}||dd|�<nd}t||�S(s|
        Returns a new path resampled to length N x steps.  Does not
        currently handle interpolating curves.
        iiN(	RR%R$RRRRR,R(R'tstepsR%R$t	new_codes((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytinterpolatedjs	+cCs�t|j�dkrgS|dk	r4|j�}n|jdkr�|dks[|dkr�|dkrq|jgS|j|j�gSnt||||�S(s�
        Convert this path to a list of polygons.  Each polygon is an
        Nx2 array of vertices.  In other words, each polygon has no
        ``MOVETO`` instructions or curves.  This is useful for
        displaying in backends that do not support compound paths or
        Bezier curves, such as GDK.

        If *width* and *height* are both non-zero then the lines will
        be simplified so that vertices outside of (0, 0), (width,
        height) will be clipped.
        iN(RR%RRUR$RHR	(R'RHtwidththeight((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytto_polygons{s'
cCsv|jdkro|ddgddgddgddgddgg|j|j|j|j|jg�|_n|jS(sm
        (staticmethod) Returns a :class:`Path` of the unit rectangle
        from (0, 0) to (1, 1).
        gg�?N(t_unit_rectangleRRRR(R/((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyRe�s3-cCs|dkr!|jj|�}nd}|dkrdtj|tj|d�j|ddf�}|tjd7}tjtj|�tj	|�fd�}tj
|df�}|j|d<|j|dd+|j
|d<|||�}|dkr||j|<qn|S(s�
        (staticmethod) Returns a :class:`Path` for a unit regular
        polygon with the given *numVertices* and radius of 1.0,
        centered at (0, 0).
        iiig@ii����N(t_unit_regular_polygonstgetRRtpitarangeR;tconcatenatetcostsinRRRR(R/tnumVerticesR\tthetaR6R$((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytunit_regular_polygon�s '*

g�?c	CsI|dkr'|jj||f�}nd}|dkrE|d}dtj|tj|d�}|tjd7}tj|d�}||ddd�<tj|tj|�|tj	|�f�j
�}tj|df�}|j|d<|j
|dd+|j|d<|||�}|dkrE||j||f<qEn|S(s�
        (staticmethod) Returns a :class:`Path` for a unit regular star
        with the given numVertices and radius of 1.0, centered at (0,
        0).
        iiig@Nii����(t_unit_regular_starsRqRRRrRsR,R:RuRvt	transposeRRRRRp(	R/RwtinnerCircleR\tns2RxtrR6R$((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytunit_regular_star�s$
"5

cCs|j|d�S(s�
        (staticmethod) Returns a :class:`Path` for a unit regular
        asterisk with the given numVertices and radius of 1.0,
        centered at (0, 0).
        g(R(R/Rw((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytunit_regular_asterisk�scCs�|jd
kr�d}tjd�}tj||d�}tjddg|dg||||g||g||||gd|gddgd|g||||g||g||||g|dgddg|dg||||g||g||||gd|gddgd|g||||g||g||||g|dgddgddggtj�}|jtjd�}|j|d<|j	|d	<|||�|_n|jS(s}
        (staticmethod) Returns a :class:`Path` of the unit circle.
        The circle is approximated using cubic Bezier curves.  This
        uses 8 splines around the circle using the approach presented
        here:

          Lancaster, Don.  `Approximating a Circle or an Ellipse Using Four
          Bezier Cubic Splines <http://www.tinaja.com/glib/ellipse4.pdf>`_.
        grSl��?g�?g@gg�g�?iii����N(
t_unit_circleRRtsqrttarrayRtCURVE4R,RR(R/tMAGICtSQRTHALFtMAGIC45R%R$((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytunit_circle�sJ		

					

		

	

cCs>|jd
kr7d}tjd�}tj||d�}tjddg|dg||||g||g||||gd|gddgd|g||||g||g||||g|dgddgddggtj�}|jtjd�}|j|d<|j	|d	<|||�|_n|jS(s�
        (staticmethod) Returns a :class:`Path` of the right half
        of a unit circle. The circle is approximated using cubic Bezier
        curves.  This uses 4 splines around the circle using the approach
        presented here:

          Lancaster, Don.  `Approximating a Circle or an Ellipse Using Four
          Bezier Cubic Splines <http://www.tinaja.com/glib/ellipse4.pdf>`_.
        grSl��?g�?g@gg�g�?iii����N(
t_unit_circle_righthalfRRR�R�RR�R,RR(R/R�R�R�R%R$((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytunit_circle_righthalf*s2		

					

cCs�|tjd9}|tjd9}tjd}tjd}tjtj|�tj|��}tjtj|�tj|��}||tj|||�8}||tjkr�||tjkr�||7}n|dkrtdtj|||��}n|dkr!t	d��n|||}	tj
d|	�}
tj|	�tjdd|
|
�dd}tj|||dt
�}tj|�}
tj|�}|
d	 }|d	 }|}|}|
d}|d}|}|}|r�|d
d}tj|dftj�}|jtj|f|j�}|d|dg|d<|j|jg|dd+|j|jg|d
)d}|d}ny|d
d}tj|dftj�}|jtj|f|j�}|d|dg|d<|j|d<d}|}||||||d
�df<||||||d
�df<|||||d|d
�df<|||||d|d
�df<|||d|d
�df<|||d|d
�df<|||�S(s
        (staticmethod) Returns an arc on the unit circle from angle
        *theta1* to angle *theta2* (in degrees).

        If *n* is provided, it is the number of spline segments to make.
        If *n* is not provided, the number of spline segments is
        determined based on the delta between *theta1* and *theta2*.

           Masionobe, L.  2003.  `Drawing an elliptical arc using
           polylines, quadratic or cubic Bezier curves
           <http://www.spaceroots.org/documents/ellipse/index.html>`_.
        g�f@g@g�?iisn must be >= 1 or Noneg@g@i����iiii����N(RRrtarctan2RvRutfloorRR-tceilt
ValueErrorttanR�tlinspacetTrueR+RR�R,RRRRR(R/ttheta1ttheta2tntis_wedgettwopithalfpiteta1teta2tdetatttalphaRitcos_etatsin_etatxAtyAtxA_dottyA_dottxBtyBtxB_dottyB_dotRAR%R$t
vertex_offsettend((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytarcXsd

$$&
$0





!!%%cCs|j|||t�S(sO
        (staticmethod) Returns a wedge of the unit circle from angle
        *theta1* to angle *theta2* (in degrees).

        If *n* is provided, it is the number of spline segments to make.
        If *n* is not provided, the number of spline segments is
        determined based on the delta between *theta1* and *theta2*.
        (R�R�(R/R�R�R�((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytwedge�s
iicCsnddlm}|dkr dS|jj||f�}|dk	rH|S|||�}||j||f<|S(s�
        Given a hatch specifier, *hatchpattern*, generates a Path that
        can be used in a repeated hatching pattern.  *density* is the
        number of lines per unit square.
        i����(tget_pathN(tmatplotlib.hatchR�Rt_hatch_dictRq(R/thatchpatterntdensityR�t
hatch_path((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pythatch�sN(1t__name__t
__module__t__doc__RFRRtCURVE3R�RRERtuint8RRtFalseR)tclassmethodR8RBRCRDR�RSRTRYR[R]RaRcRhRkRnRoReRRpRyRzRR�R�R�R�R�R�R�R
R�R�(((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyRs`3	7				>	
				=.McCsPddlm}t|�dkr1td��n|jt|||||��S(s�
    Given a sequence of :class:`Path` objects,
    :class:`~matplotlib.transforms.Transform` objects and offsets, as
    found in a :class:`~matplotlib.collections.PathCollection`,
    returns the bounding box that encapsulates all of them.

    *master_transform* is a global transformation to apply to all paths

    *paths* is a sequence of :class:`Path` instances.

    *transforms* is a sequence of
    :class:`~matplotlib.transforms.Affine2D` instances.

    *offsets* is a sequence of (x, y) offsets (or an Nx2 array)

    *offset_transform* is a :class:`~matplotlib.transforms.Affine2D`
    to apply to the offsets before applying the offset to the path.

    The way that *paths*, *transforms* and *offsets* are combined
    follows the same method as for collections.  Each is iterated over
    independently, so if you have 3 paths, 2 transforms and 1 offset,
    their combinations are as follows:

        (A, A, A), (B, B, A), (C, A, A)
    i����(R^isNo paths provided(R_R^RR�tfrom_extentst_get_path_collection_extents(tmaster_transformtpathsR_toffsetstoffset_transformR^((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyR�s
	cCs\ddlm}m}t|�dkr7td��n|jt|�||g|���S(si
    Given a sequence of :class:`Path` objects and optional
    :class:`~matplotlib.transforms.Transform` objects, returns the
    bounding box that encapsulates all of them.

    *paths* is a sequence of :class:`Path` instances.

    *transforms* is an optional sequence of
    :class:`~matplotlib.transforms.Affine2D` instances to apply to
    each path.
    i����(R^tAffine2DisNo paths provided(R_R^R�RR�R�R�(R�R_R^R�((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pytget_paths_extents�s
	(R�t
__future__RtmathtweakrefRtnumpyRRtmatplotlib._pathRRRRRRR	R
Rtmatplotlib.cbookRR
t
matplotlibRtobjectRR�R�(((s5/usr/lib64/python2.7/site-packages/matplotlib/path.pyt<module>s@���	!

Anon7 - 2021