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/collections.pyc
�
r`]c
@s�dZddlmZddlZddlZddljZddlZ	ddl
jZddlj
ZddljZddlmZddljZddljZddlmZddljZddljZddljZdejejfd��YZ ej!j"dd�d	e fd
��YZ#de fd��YZ$d
e$fd��YZ%de fd��YZ&de&fd��YZ'de&fd��YZ(de fd��YZ)de fd��YZ*de fd��YZ+de fd��YZ,de fd��YZ-de fd ��YZ.ej/e �Z0xCdddd
dd	ddddf
D]Z1ej!j"ie0e16�qOWej!j"dej/e)��dS(!su
Classes for the efficient drawing of large collections of objects that
share most properties, e.g. a large number of line segments or
polygons.

The classes are not meant to be as flexible as their single element
counterparts (e.g. you may not be able to select all line styles) but
they are meant to be fast for common use cases (e.g. a large set of solid
line segemnts)
i����(tprint_functionN(t	docstring(tallow_rasterizationt
CollectioncBseZdZejgej�Zd1e_ej	�Z
gZdZd2d2d2dd2d2d2d2d2dd2d2dd�
Zed��Zed	��Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zed��Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d�Z&d�Z'd�Z(d �Z)d!�Z*d"�Z+d#�Z,d$�Z-d%�Z.d&�Z/d'�Z0d(�Z1e1Z2d)�Z3e3Z4d*�Z5d+�Z6d,�Z7d-�Z8e8Z9d.�Z:e:Z;Z<d/�Z=d0�Z>RS(3sS
    Base class for Collections.  Must be subclassed to be usable.

    All properties in a collection must be sequences or scalars;
    if scalars, they will be converted to sequences.  The
    property of the ith element of the collection is::

      prop[i % len(props)]

    Keyword arguments and default values:

        * *edgecolors*: None
        * *facecolors*: None
        * *linewidths*: None
        * *antialiaseds*: None
        * *offsets*: None
        * *transOffset*: transforms.IdentityTransform()
        * *offset_position*: 'screen' (default) or 'data'
        * *norm*: None (optional for
          :class:`matplotlib.cm.ScalarMappable`)
        * *cmap*: None (optional for
          :class:`matplotlib.cm.ScalarMappable`)
        * *hatch*: None

    *offsets* and *transOffset* are used to translate the patch after
    rendering (default no offsets).  If offset_position is 'screen'
    (default) the offset is applied after the master transform has
    been applied, that is, the offsets are in screen coordinates.  If
    offset_position is 'data', the offset is applied before the master
    transform, i.e., the offsets are in data coordinates.

    If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds*
    are None, they default to their :data:`matplotlib.rcParams` patch
    setting, in sequence form.

    The use of :class:`~matplotlib.cm.ScalarMappable` is optional.  If
    the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not None
    (ie a call to set_array has been made), at draw time a call to
    scalar mappable will be made to set the face colors.
    iiitsolidg@tscreencKs3tjj|�tjj|||	�|j|�|j|�|j|�|j|�|j	|�|j
|
�|j|�|j|�|j
|
�d|_tjgtj�|_d|j_|dk	rtj|�}d|_|dk	r
||_||_q||_n|j|�d|_dS(s=
        Create a Collection

        %(Collection)s
        iii����N(ii(i����i(tartisttArtistt__init__tcmtScalarMappablet
set_edgecolort
set_facecolort
set_linewidtht
set_linestyletset_antialiasedtset_pickradiustset_urlst	set_hatchtset_offset_positiontNonet_uniform_offsetstnptarraytfloat_t_offsetstshapet
asanyarrayt_transOffsettupdatet_paths(tselft
edgecolorst
facecolorst
linewidthst
linestylestantialiasedstoffsetsttransOffsettnormtcmapt
pickradiusthatchturlstoffset_positiontkwargs((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRKs.








			
cCs�yt|�fSWn_tk
rrtj|�rst|�rsyt|d�Wnttfk
rgqoX|SqsnXtd��dS(Nis1val must be a float or nonzero sequence of floats(tfloatt	TypeErrortcbooktiterabletlent
ValueError(tval((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt
_get_value}s
cCsWtj|�s|f}nyt|d�Wn#ttfk
rRtd��nX|S(Nis.val must be a bool or nonzero sequence of them(R0R1tboolR/t
IndexError(R4((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	_get_bool�scCs|jS(N(R(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_paths�scCs
t�dS(N(tNotImplementedError(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	set_paths�scCs|jS(N(t_transforms(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_transforms�scCsD|j}t|tj�r@t|d�r@|j|j�}n|S(Nt_as_mpl_transform(Rt
isinstancet
transformst	TransformthasattrR>taxes(Rtt((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_offset_transform�s
	cCs|j�}|j�}|j}|j�}|jsgg|D]}|j|�^q=}|j�}n|js�|j|�}|j�}ntj	|tj
�}tjj|�r�|j
tj�}nd|_tj|j�||j�||j��}|j|�}|S(Ni����i(i����i(t
get_transformRERR9t	is_affinettransform_path_non_affinet
get_affinettransform_non_affineRRRtmat
isMaskedArraytfilledtnanRtmpathtget_path_collection_extentstfrozenR=tinverse_transformed(Rt	transDatat	transformR&R%tpathstptresult((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_datalim�s&		"		cCs|jtj��}|S(N(RXR@tIdentityTransform(Rtrenderertbbox((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_window_extent�sc	Cs�|j�}|j�}|j}|j�}|j�r1g}x�|j�D]}|j}|dd�df|dd�df}}|j|�}|j|�}|jt	j
t||�|j��qLW|j
dkr1|j|dd�df�}|j|dd�df�}t||�}q1ntj|tj�}d|_|js�g|D]}|j|�^q_}|j�}n|js�|j|�}|j�}ntjj|�r�|jtj�}n||||fS(s&Point prep for drawing and hit testingNiii����i(i����i(RFRERR9t
have_unitstverticestconvert_xunitstconvert_yunitstappendROtPathtziptcodestsizeRRRRRGRHRIRJRKRLRMRN(	RRTR&R%RUtpathR^txstys((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt_prepare_points�s6		-)		"	cCs|j�sdS|j|jj|j��|j�|j�\}}}}|j�}|j|�|j	|j
��|jr�|j|j�n|j
||j�||j�|||j�|j�|j|j|j|j|j�
|j�|j|jj�dS(N(tget_visiblet
open_groupt	__class__t__name__tget_gidtupdate_scalarmappableRitnew_gct_set_gc_cliptset_snaptget_snapt_hatchRtdraw_path_collectionRQR=t
get_facecolort
get_edgecolort_linewidthst_linestylest
_antialiasedst_urlst_offset_positiontrestoretclose_group(RRZRTR&R%RUtgc((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytdraw�s"

	

cCs
||_dS(N(t_pickradius(Rtpr((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRscCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_pickradiusscCs
t|j�r|j||�S|j�s5tifS|jtkrP|j}nDyt|j�}Wn.tk
r�t	j
d|j�|j}nX|j�\}}}}tj
|j|j||j�||j�|||dk�	}t|�dktd|�fS(s�
        Test whether the mouse event occurred in the collection.

        Returns True | False, ``dict(ind=itemlist)``, where every
        item in itemlist contains the event.
        s4Collection picker %s could not be converted to floatitind(tcallablet	_containsRjtFalset_pickertTrueR�R.R/twarningstwarnRiROtpoint_in_path_collectiontxtyRQR=R2tdict(Rt
mouseeventR)RTR&R%RUR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytcontainss&


cCs(|dkrdg|_n	||_dS(N(RR{(RR+((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR3scCs|jS(N(R{(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_urls9scCs
||_dS(sk
        Set the hatching pattern

        *hatch* can be one of::

          /   - diagonal hatching
          \   - back diagonal
          |   - vertical
          -   - horizontal
          +   - crossed
          x   - crossed diagonal
          o   - small circle
          O   - large circle
          .   - dots
          *   - stars

        Letters can be combined, in which case all the specified
        hatchings are done.  If same letter repeats, it increases the
        density of hatching of that pattern.

        Hatching is supported in the PostScript, PDF, SVG and Agg
        backends only.

        Unlike other properties such as linewidth and colors, hatching
        can only be specified for the collection as a whole, not separately
        for each member.

        ACCEPTS: [ '/' | '\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ]
        N(Rt(RR*((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;scCs|jS(s#Return the current hatching pattern(Rt(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_hatch[scCsFtj|tj�}d|_|jdkr9||_n	||_dS(s�
        Set the offsets for the collection.  *offsets* can be a scalar
        or a sequence.

        ACCEPTS: float or sequence of floats
        i����iN(i����i(RRRRRRR(RR%((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_offsets_s
	cCs!|jdkr|jS|jSdS(s8
        Return the offsets for the collection.
        N(RRR(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_offsetsnscCs(|dkrtd��n||_dS(si
        Set how offsets are applied.  If *offset_position* is 'screen'
        (default) the offset is applied after the master transform has
        been applied, that is, the offsets are in screen coordinates.
        If offset_position is 'data', the offset is applied before the
        master transform, i.e., the offsets are in data coordinates.
        Rtdatas*offset_position must be 'screen' or 'data'N(Rsdata(R3R|(RR,((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRxscCs|jS(s�
        Returns how offsets are applied for the collection.  If
        *offset_position* is 'screen', the offset is applied after the
        master transform has been applied, that is, the offsets are in
        screen coordinates.  If offset_position is 'data', the offset
        is applied before the master transform, i.e., the offsets are
        in data coordinates.
        (R|(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_offset_position�s	cCs2|dkrtjd}n|j|�|_dS(s�
        Set the linewidth(s) for the collection.  *lw* can be a scalar
        or a sequence; if it is a sequence the patches will cycle
        through the sequence

        ACCEPTS: float or sequence of floats
        spatch.linewidthN(RtmpltrcParamsR5Rx(Rtlw((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR
�scCs
|j|�S(salias for set_linewidth(R
(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_linewidths�scCs
|j|�S(salias for set_linewidth(R
(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_lw�scCs�yztjj}tj|�rl||kr:||g}qy|tjkr`|tj|g}qyt��n
tj|�rpy�g}x�|D]�}tj|�r�||kr�|j||�q0|tjkr�|j|tj|�q0t��q�tj|�r't	|�dkr'|j|�q�t��q�WWqytk
rlt	|�dkr`|}qmt��qyXn	t��Wn!tk
r�td|��nX||_
dS(s�
        Set the linestyle(s) for the collection.

        ACCEPTS: ['solid' | 'dashed', 'dashdot', 'dotted' |
        (offset, on-off-dash-seq) ]
        is'Do not know how to convert %s to dashesN(t
backend_basestGraphicsContextBasetdashdR0tis_string_liket	ls_mapperR3R1RaR2Ry(RtlsR�tdashesR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s:
!
	

cCs
|j|�S(salias for set_linestyle(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_linestyles�scCs
|j|�S(salias for set_linestyle(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt
set_dashes�scCs2|dkrtjd}n|j|�|_dS(sm
        Set the antialiasing state for rendering.

        ACCEPTS: Boolean or sequence of booleans
        spatch.antialiasedN(RR�R�R8Rz(Rtaa((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�scCs
|j|�S(salias for set_antialiased(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_antialiaseds�scCs|j|�|j|�dS(s

        Set both the edgecolor and the facecolor.

        ACCEPTS: matplotlib color arg or sequence of rgba tuples

        .. seealso::

            :meth:`set_facecolor`, :meth:`set_edgecolor`
               For setting the edge or face color individually.
        N(RR(Rtc((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	set_color�s
cCs�t|_y"|j�dkr*t|_nWntk
r>nX|dkr[tjd}n||_t	j
j||j�|_
dS(sm
        Set the facecolor(s) of the collection.  *c* can be a
        matplotlib color arg (all patches have same color), or a
        sequence of rgba tuples; if it is a sequence the patches will
        cycle through the sequence.

        If *c* is 'none', the patch will not be filled.

        ACCEPTS: matplotlib color arg or sequence of rgba tuples
        tnonespatch.facecolorN(R�t
_is_filledtlowerR�tAttributeErrorRR�R�t_facecolors_originaltmcolorstcolorConvertert
to_rgba_arrayt_alphat_facecolors(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s	
	cCs
|j|�S(salias for set_facecolor(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_facecolorsscCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRv	scCs$|jdkr|j�S|jSdS(Ntface(t_edgecolorstget_facecolors(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRw
s
cCs�t|_y"|j�dkr*t|_nWntk
r>nXy,|j�dkrjd|_d|_dSWntk
r~nX|dkr�tj	d}n||_t
jj||j
�|_dS(s�
        Set the edgecolor(s) of the collection. *c* can be a
        matplotlib color arg (all patches have same color), or a
        sequence of rgba tuples; if it is a sequence the patches will
        cycle through the sequence.

        If *c* is 'face', the edge color will always be the same as
        the face color.  If it is 'none', the patch boundary will not
        be drawn.

        ACCEPTS: matplotlib color arg or sequence of rgba tuples
        R�R�Nspatch.edgecolor(R�t_is_strokedR�R�R�R�t_edgecolors_originalRR�R�R�R�R�R�(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRs"
	
		
	cCs
|j|�S(salias for set_edgecolor(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytset_edgecolors4scCs�|dk	r=yt|�Wq=tk
r9td��q=Xntjj||�y"tjj|j	|j
�|_Wnttt
fk
r�nXy4|jdkr�tjj|j|j
�|_nWnttt
fk
r�nXdS(s�
        Set the alpha tranparencies of the collection.  *alpha* must be
        a float or *None*.

        ACCEPTS: float or None
        salpha must be a float or NoneR�N(RR.R/RRt	set_alphaR�R�R�R�R�R�R�R7R�R�(Rtalpha((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�8s"
		cCs|jS(N(Rx(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_linewidthsQscCs|jS(N(Ry(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_linestylesUscCs�|jdkrdS|jjdkr4td��n|jd�sGdS|jrn|j|j|j�|_n'|j	r�|j|j|j�|_
ndS(sb
        If the scalar mappable array is not none, update colors
        from scalar data
        Nis&Collections can only map rank 1 arraysR(t_ARtndimR3tcheck_updateR�tto_rgbaR�R�R�R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRoYs		cCs�tjj||�|j|_|j|_|j|_|j|_|j|_|j|_|j	|_	|j
|_
|j|_|j|_|j
|_
|j|_dS(s"copy properties from other to selfN(RRtupdate_fromRzR�R�R�R�RxRyR�RtR�R'R((Rtother((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�is(iiN(?Rmt
__module__t__doc__RRRRRR@RYRR<tzorderRRtstaticmethodR5R8R9R;R=RERXR\RiRR�RR�R�RR�RR�R�R�RR�R
R�R�RR�R�RR�R�RR�RvR�Rwtget_edgecolorsRR�R�R�t
get_linewidthR�t
get_dashest
get_linestyleRoR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRs�(	%
							)			%			 			
						*			
							 				
	s�    Valid Collection keyword arguments:

        * *edgecolors*: None
        * *facecolors*: None
        * *linewidths*: None
        * *antialiaseds*: None
        * *offsets*: None
        * *transOffset*: transforms.IdentityTransform()
        * *norm*: None (optional for
          :class:`matplotlib.cm.ScalarMappable`)
        * *cmap*: None (optional for
          :class:`matplotlib.cm.ScalarMappable`)

    *offsets* and *transOffset* are used to translate the patch after
    rendering (default no offsets)

    If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds*
    are None, they default to their :data:`matplotlib.rcParams` patch
    setting, in sequence form.
tPathCollectioncBsMeZdZejdd��Zd�Zd�Zd�Z	e
d��ZRS(s>
    This is the most basic :class:`Collection` subclass.
    cKs*tj||�|j|�||_dS(ss
        *paths* is a sequence of :class:`matplotlib.path.Path`
        instances.

        %(Collection)s
        N(RRR;t_sizes(RRUtsizesR-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s	
cCs
||_dS(N(R(RRU((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;�scCs|jS(N(R(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR9�scCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_sizes�scCsg|jdk	rWg|jD]2}tj�jtj|�|jjd�^q|_	nt
j||�S(NgR@(R�RR@tAffine2DtscaleRtsqrttfiguretdpiR<RR�(RRZR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��sEN(RmR�R�Rtdedent_interpdRRR;R9R�RR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��s			tPolyCollectioncBsAeZejded��Zed�ZeZe	d��Z
RS(cKs-tj||�||_|j||�dS(s�
        *verts* is a sequence of ( *verts0*, *verts1*, ...) where
        *verts_i* is a sequence of *xy* tuples of vertices, or an
        equivalent :mod:`numpy` array of shape (*nv*, 2).

        *sizes* is *None* (default) or a sequence of floats that
        scale the corresponding *verts_i*.  The scaling is applied
        before the Artist master transform; if the latter is an identity
        transform, then the overall scaling is such that if
        *verts_i* specify a unit square, then *sizes_i* is the area
        of that square in points^2.
        If len(*sizes*) < *nv*, the additional values will be
        taken cyclically from the array.

        *closed*, when *True*, will explicitly close the polygon.

        %(Collection)s
        N(RRR�t	set_verts(RtvertsR�tclosedR-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s	cCsutjj|�r3|jtj�jtj�}n|rLg|_x,|D]�}t|�r,tjj|�r�tjj	|tj
d�g�}n-tj|�}tj	|tj
d�g�}tj|j
ddtjj�}tjj|(tjj|d<tjj|d<|jjtj||��qI|jjtj|��qIWn%g|D]}tj|�^qS|_dS(	s8This allows one to delay initialization of the vertices.iiitdtypei����N(ii(ii(RRKRLtastypeRRMRNRR2tconcatenatetzerostasarraytemptyRRORbt	code_typetLINETOtMOVETOt	CLOSEPOLYRa(RR�R�txyRd((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��s"!	
$"
 cCsg|jdk	rWg|jD]2}tj�jtj|�|jjd�^q|_	nt
j||�S(NgR@(R�RR@R�R�RR�R�R�R<RR�(RRZR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��sEN(RmR�RR�RR�RR�R;RR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��s
tBrokenBarHCollectioncBs/eZdZejd��Zed��ZRS(s]
    A collection of horizontal bars spanning *yrange* with a sequence of
    *xranges*.
    c
Ks�|\}}||}g|D]G\}}||f||f|||f|||f||fg^q}	tj||	|�dS(s�
        *xranges*
            sequence of (*xmin*, *xwidth*)

        *yrange*
            *ymin*, *ywidth*

        %(Collection)s
        N(R�R(
RtxrangestyrangeR-tymintywidthtymaxtxmintxwidthR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s
Tc
Ks�g}x_tj|�D]N\}}|||!}t|�sAqn|j|d|d|df�qWt||||g|�}	|	S(s(
        Create a BrokenBarHCollection to plot horizontal bars from
        over the regions in *x* where *where* is True.  The bars range
        on the y-axis from *ymin* to *ymax*

        A :class:`BrokenBarHCollection` is returned.  *kwargs* are
        passed on to the collection.
        ii����(tmlabtcontiguous_regionsR2RaR�(
R�R�R�twhereR-R�tind0tind1txslicet
collection((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt
span_wheres

'(RmR�R�RR�RR�R�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��stRegularPolyCollectioncBs\eZdZejjZejddd��Z	e
d��Zd�Zd�Z
d�ZRS(	s6Draw a collection of regular polygons with *numsides*.iicKsWtj||�||_||_|j|�g|_||_|jtj	��dS(s]
        *numsides*
            the number of sides of the polygon

        *rotation*
            the rotation of the polygon in radians

        *sizes*
            gives the area of the circle circumscribing the
            regular polygon in points^2

        %(Collection)s

        Example: see :file:`examples/dynamic_collection.py` for
        complete example::

            offsets = np.random.rand(20,2)
            facecolors = [cm.jet(x) for x in np.random.rand(20)]
            black = (0,0,0,1)

            collection = RegularPolyCollection(
                numsides=5, # a pentagon
                rotation=0, sizes=(50,),
                facecolors = facecolors,
                edgecolors = (black,),
                linewidths = (1,),
                offsets = offsets,
                transOffset = ax.transData,
                )
        N(
RRR�t	_numsidest_path_generatorRt	_rotationt
set_transformR@RY(RtnumsidestrotationR�R-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR$s$			cCsrg|jD]O}tj�j|j�jtj|�|jj	dtjtj
��^q
|_tj
||�S(NgR@(R�R@R�trotateR�R�RR�R�R�tpiR<RR�(RRZR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�Os_cCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_numsidesWscCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytget_rotationZscCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�]s(i(RmR�R�RORbtunit_regular_polygonR�RR�RRR�R�RR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR� s'		tStarPolygonCollectioncBseZdZejjZRS(s?
    Draw a collection of regular stars with *numsides* points.(RmR�R�RORbtunit_regular_starR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRastAsteriskPolygonCollectioncBseZdZejjZRS(sC
    Draw a collection of regular asterisks with *numsides* points.(RmR�R�RORbtunit_regular_asteriskR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRhstLineCollectionc
BsweZdZdZd
d
d
dd
d
d
d
dd�	Zd�ZeZeZd�Z	d�Z
d�Zd	�ZeZ
RS(s
    All parameters must be sequences or scalars; if scalars, they will
    be converted to sequences.  The property of the ith line
    segment is::

       prop[i % len(props)]

    i.e., the properties cycle if the ``len`` of props is less than the
    number of segments.
    iRicKs�|dkrtjd}n|dkr;tjdf}n|dkrZtjdf}n|j|�tjj|�}tj|d|ddd|d|d	|d
|d|d|d
|	d|
|�
|j	|�dS(s�
        *segments*
            a sequence of (*line0*, *line1*, *line2*), where::

                linen = (x0, y0), (x1, y1), ... (xm, ym)

            or the equivalent numpy array with two columns. Each line
            can be a different length.

        *colors*
            must be a sequence of RGBA tuples (eg arbitrary color
            strings, etc, not allowed).

        *antialiaseds*
            must be a sequence of ones or zeros

        *linestyles* [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ]
            a string or dash tuple. The dash tuple is::

                (offset, onoffseq),

            where *onoffseq* is an even length tuple of on and off ink
            in points.

        If *linewidths*, *colors*, or *antialiaseds* is None, they
        default to their rcParams setting, in sequence form.

        If *offsets* and *transOffset* are not None, then
        *offsets* are transformed by *transOffset* and applied after
        the segments have been transformed to display coordinates.

        If *offsets* is not None but *transOffset* is None, then the
        *offsets* are added to the segments before any transformation.
        In this case, a single offset can be specified as::

            offsets=(xo,yo)

        and this value will be added cumulatively to each successive
        segment, so as to produce a set of successively offset curves.

        *norm*
            None (optional for :class:`matplotlib.cm.ScalarMappable`)
        *cmap*
            None (optional for :class:`matplotlib.cm.ScalarMappable`)

        *pickradius* is the tolerance for mouse clicks picking a line.
        The default is 5 pt.

        The use of :class:`~matplotlib.cm.ScalarMappable` is optional.
        If the :class:`~matplotlib.cm.ScalarMappable` array
        :attr:`~matplotlib.cm.ScalarMappable._A` is not None (ie a call to
        :meth:`~matplotlib.cm.ScalarMappable.set_array` has been made), at
        draw time a call to scalar mappable will be made to set the colors.
        slines.colorslines.linewidthslines.antialiasedR R!R�R"R#R$R%R&R'R(R)N(
RR�R�R�R�R�R�RRtset_segments(RtsegmentsR"tcolorsR$R#R%R&R'R(R)R-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR{s,B
cCs�|dkrdSg}xE|D]=}tjj|�sMtj|tj�}n|j|�qW|jdk	r|j|�}ng|D]}t	j
|�^q�|_dS(N(RRRKRLR�RRaRt_add_offsetsRORbR(RRt	_segmentstseg((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s
cCs�|j}t|�}|jd}|dkr^xkt|�D]}||||||<q;Wn>x;t|�D]-}||}|||||d!||<qkW|S(Nii(RR2Rtrange(RtsegsR%tNsegstNoffstitio((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR
�s	

!cCs|j|�dS(s5
        Set the color(s) of the line collection.  *c* can be a
        matplotlib color arg (all patches have same color), or a
        sequence or rgba tuples; if it is a sequence the patches will
        cycle through the sequence.

        ACCEPTS: matplotlib color arg or sequence of rgba tuples
        N(R(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��s	cCstjd�|j|�S(s4
        Set the color(s) of the line collection.  *c* can be a
        matplotlib color arg (all patches have same color), or a
        sequence or rgba tuples; if it is a sequence the patches will
        cycle through the sequence

        ACCEPTS: matplotlib color arg or sequence of rgba tuples
        s6LineCollection.color deprecated; use set_color instead(R�R�R�(RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytcolor�s	
cCs|jS(N(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_colorsN(RmR�R�R�RRRR�R;R
R�RRt
get_colors(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRos&
P	
	
			tCircleCollectioncBs8eZdZejd��Zd�Zed��ZRS(s7
    A collection of circles, drawn using splines.
    cKsEtj||�||_|jtj��tjj�g|_	dS(sf
        *sizes*
            Gives the area of the circle in points^2

        %(Collection)s
        N(
RRR�R�R@RYRORbtunit_circleR(RR�R-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRs	cCs|jS(sreturn sizes of circles(R�(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�scCseg|jD]B}tj�jtj|�|jjdtjtj��^q
|_	t
j||�S(NgR@(R�R@R�R�RR�R�R�R�R<RR�(RRZR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�!sR(	RmR�R�RR�RR�RR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRs
	tEllipseCollectioncBs;eZdZejdd��Zd�Zed��ZRS(s8
    A collection of ellipses, drawn using splines.
    tpointscKs�tj||�dtj|�j�|_dtj|�j�|_tj|�j�tjd|_||_	|j
tj��g|_
tjj�g|_dS(s�
        *widths*: sequence
            lengths of first axes (e.g., major axis lengths)

        *heights*: sequence
            lengths of second axes

        *angles*: sequence
            angles of first axes, degrees CCW from the X-axis

        *units*: ['points' | 'inches' | 'dots' | 'width' | 'height'
        | 'x' | 'y' | 'xy']

            units in which majors and minors are given; 'width' and
            'height' refer to the dimensions of the axes, while 'x'
            and 'y' refer to the *offsets* data units. 'xy' differs
            from all others in that the angle as plotted varies with
            the aspect ratio, and equals the specified angle only when
            the aspect ratio is unity.  Hence it behaves the same as
            the :class:`~matplotlib.patches.Ellipse` with
            axes.transData as its transform.

        Additional kwargs inherited from the base :class:`Collection`:

        %(Collection)s
        g�?g�f@N(RRRR�travelt_widthst_heightsR�t_anglest_unitsR�R@RYR<RORbRR(RtwidthstheightstanglestunitsR-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR0s#		c
Cs�g|_|j}|j}|jdkr3d}n�|jdkr[|jj|jj}n�|jdkr�|jj|jj}n�|jdkr�|j}n�|jdkr�|jd}ng|jdkr�|jj}nI|jd	kr�|jj}n+|jd
krd}nt	d|j��t
j}xbt|j
|j|j�D]E\}}}|�j||||�j|�}|jj|�qIW|jdkr�|jj�j�j�}	d
|	dd�dd�f<|j||	��ndS(sB
        Calculate transforms immediately before drawing.
        R�iR�R�tinchesRgR@twidththeighttdotsg�?sunrecognized units: %siNi(R<RCR�RR[R$tviewLimR%R�R3R@R�RcRRRR�R�RaRSRIt
get_matrixtcopyR�(
Rtaxtfigtsct_affineR�R�tattranstm((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt_set_transformsUs8						+&cCs|j�tj||�dS(N(R1RR�(RRZ((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�zs
(	RmR�R�RR�RR1RR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR,s
$	%tPatchCollectioncBs#eZdZed�Zd�ZRS(s�
    A generic collection of patches.

    This makes it easier to assign a color map to a heterogeneous
    collection of patches.

    This also may improve plotting speed, since PatchCollection will
    draw faster than a large number of patches.
    cKs�|r�d�}g|D]}||�^q}g|D]}|j�^q5}g|D]}|j�^qT}g|D]}|j�^qs}	g|D]}|j�^q�}
tj|d|d|d|d|	d|
�ntj||�|j|�dS(s}
        *patches*
            a sequence of Patch objects.  This list may include
            a heterogeneous assortment of different patch types.

        *match_original*
            If True, use the colors and linewidths of the original
            patches.  If False, new colors may be assigned by
            providing the standard collection arguments, facecolor,
            edgecolor, linewidths, norm or cmap.

        If any of *edgecolors*, *facecolors*, *linewidths*,
        *antialiaseds* are None, they default to their
        :data:`matplotlib.rcParams` patch setting, in sequence form.

        The use of :class:`~matplotlib.cm.ScalarMappable` is optional.
        If the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not
        None (ie a call to set_array has been made), at draw time a
        call to scalar mappable will be made to set the face colors.
        cSs&|j�r|j�SddddgS(Ni(tget_fillRv(tpatch((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytdetermine_facecolor�s
R R!R"R#R$N(RwR�R�tget_antialiasedRRR;(Rtpatchestmatch_originalR-R5RVR!R R"R#R$((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s 	
cCs;g|D]!}|j�j|j��^q}||_dS(N(RFttransform_pathtget_pathR(RR7RVRU((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;�s+(RmR�R�R�RR;(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR2s	.tTriMeshcBsGeZdZd�Zd�Zd�Zed��Zed��Z	RS(s�
    Class for the efficient drawing of a triangular mesh using
    Gouraud shading.

    A triangular mesh is a :class:`~matplotlib.tri.Triangulation`
    object.
    cKs�tj||�||_d|_t|_tjj�|_	t
j|jj
dd�|jj
dd�f�}|j	j|�dS(Ntgouraudi����i(RRt_triangulationt_shadingR�R�R@tBboxtunitt_bboxRthstackR�treshapeR�tupdate_from_data_xy(Rt
triangulationR-R�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR�s			cCs#|jdkr|j�n|jS(N(RRR;(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR9�s
cCs|j|j�|_dS(N(tconvert_mesh_to_pathsR=R(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;�scCsutj}|j�}tj|j|dtjf|j|dtjffdd�}g|D]}||�^q_S(s�
        Converts a given mesh into a sequence of
        :class:`matplotlib.path.Path` objects for easier rendering by
        backends that do not directly support meshes.

        This function is primarily of use to backend implementers.
        .taxisi(RORbtget_masked_trianglesRR�R�tnewaxisR�(ttriRbt	trianglesR�R�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRF�s
		&cCs|j�sdS|j|jj�|j�}|j}|j�}tj|j	|dtj
f|j|dtj
ffdd�}|j�|j
|}|j�}|j|�|j|j�d�|j||||j��|j�|j|jj�dS(N.RGii(RjRkRlRmRFR=RHRR�R�RIR�RoR�RpRqR
R�tdraw_gouraud_trianglesRQR}R~(RRZRTRJRKR�R	R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��s 	&



(
RmR�R�RR9R;R�RFRR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;�s			tQuadMeshcBs_eZdZedd�Zd�Zd�Zed��Zd�Z	d�Z
ed��ZRS(	s�
    Class for the efficient drawing of a quadrilateral mesh.

    A quadrilateral mesh consists of a grid of vertices. The
    dimensions of this array are (*meshWidth* + 1, *meshHeight* +
    1). Each vertex in the mesh has a different set of "mesh
    coordinates" representing its position in the topology of the
    mesh. For any values (*m*, *n*) such that 0 <= *m* <= *meshWidth*
    and 0 <= *n* <= *meshHeight*, the vertices at mesh coordinates
    (*m*, *n*), (*m*, *n* + 1), (*m* + 1, *n* + 1), and (*m* + 1, *n*)
    form one of the quadrilaterals in the mesh. There are thus
    (*meshWidth* * *meshHeight*) quadrilaterals in the mesh.  The mesh
    need not be regular and the polygons need not be convex.

    A quadrilateral mesh is represented by a (2 x ((*meshWidth* + 1) *
    (*meshHeight* + 1))) numpy array *coordinates*, where each row is
    the *x* and *y* coordinates of one of the vertices.  To define the
    function that maps from a data point to its corresponding color,
    use the :meth:`set_cmap` method.  Each of these arrays is indexed in
    row-major order by the mesh coordinates of the vertex (or the mesh
    coordinates of the lower left vertex, in the case of the
    colors).

    For example, the first entry in *coordinates* is the
    coordinates of the vertex at mesh coordinates (0, 0), then the one
    at (0, 1), then at (0, 2) .. (0, meshWidth), (1, 0), (1, 1), and
    so on.

    *shading* may be 'flat', or 'gouraud'
    tflatcKs�tj||�||_||_||_||_||_tjj	�|_
|j
j|j|d|ddf��|jj|d|ddf�|_t
j|jt
j�|_dS(Nii(RRt
_meshWidtht_meshHeightt_coordinatest_antialiasedR>R@R?R@RARDRCRRR(Rt	meshWidtht
meshHeighttcoordinatestantialiasedtshadingR-((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR!s					&cCs#|jdkr|j�n|jS(N(RRR;(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR92s
cCs%|j|j|j|j�|_dS(N(RFRORPRQR(R((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR;7sc	Cs�tj}tj|�r$|j}n|}tj|dd�dd�f|dd�dd�f|dd�dd�f|dd�dd�f|dd�dd�ffdd�}|j||ddf�}g|D]}||�^q�S(s�
        Converts a given mesh into a sequence of
        :class:`matplotlib.path.Path` objects for easier rendering by
        backends that do not directly support quadmeshes.

        This function is primarily of use to backend implementers.
        ii����iNRGii(RORbRKRLR�RR�RC(RSRTRURbR�RR�((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRF;s			c
Cstj}tj|�r$|j}n|}|dd�dd�f}|dd�dd�f}|dd�dd�f}|dd�dd�f}	||||	d}
tj|||
|||
||	|
|	||
fdd�}|j||dd	df�}|j�j|d|ddf�}|dd�dd�f}
|dd�dd�f}|dd�dd�f}|dd�dd�f}|
|||d}tj|
||||||||||
|fdd�}|j||dd	df�}||fS(
s�
        Converts a given mesh into a sequence of triangles, each point
        with its own color.  This is useful for experiments using
        `draw_qouraud_triangle`.
        ii����iNg@RGiii(	RORbRKRLR�RR�RCRv(RRSRTRURbRVtp_atp_btp_ctp_dtp_centerRKR�tc_atc_btc_ctc_dtc_centerR	((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pytconvert_mesh_to_trianglesUs<					 &				 cCs|jS(N(RA(RRS((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRX�scCsP|j�sdS|j|jj|j��|j�}|j�}|j}|j�r�t	|j�r�|j
|jd �}|j|jd �}t||�}q�nt
j|t
j�}d|_|j�|js=|jj|jjd|jjddf�}|j|�}|j|jj�}tj�}n	|j}|jsm|j|�}|j�}n|j�}|j|�|j|j�d�|jdkr�|j|j |j!|�\}	}
|j"||	|
|j#��nC|j$||j#�|j |j!||||j%�|j&|j'��
|j(�|j)|jj�dS(Niii����iR<(i����i(*RjRkRlRmRnRFRERR]R2R_R`RcRR�RRRoRGRQRCRTR@RYRJRIRpRqR
R�R>RbRORPRLRQtdraw_quad_meshRvRRR�R}R~(RRZRTR&R%RgRhRURRKR	((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyR��sN		
		
		

(
RmR�R�R�RR9R;R�RFRbRXRR�(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyRMs			,	(2R�t
__future__RR�tnumpyRtnumpy.maRKt
matplotlibR�tmatplotlib.cbookR0tmatplotlib.colorsR	R�t
matplotlib.cmR	Rtmatplotlib.transformsR@tmatplotlib.artistRRtmatplotlib.backend_basesR�tmatplotlib.pathRfROtmatplotlib.mlabR�RR
RtinterpdRR�R�R�R�RRRRRR2R;RMtkwdoctpatchstrtk(((s</usr/lib64/python2.7/site-packages/matplotlib/collections.pyt<module>
sN��g#=*A� S>E�

Anon7 - 2021