�
�)�Uc	@sgdZd
dl
Z
d
dlZd
dljZd
dlZd
dlj	Z	d
dl
jZd
dl
jZd
dlmZ
d
dljZd
dljZd
dlmZ
d
dljZd
dljZd
dljZdejejfd��YZejj dd�

def
d	��YZ!d
ef
d��YZ"de"f
d
��YZ#def
d��YZ$de$f
d��YZ%de$f
d��YZ&def
d��YZ'def
d��YZ(def
d��YZ)def
d��YZ*def
d��YZ+ej,e�
Z-x@dd
dddddddf	D]Z.ejj i
e-e.6�

q&Wejj 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����N(
t	docstring(
tallow_rasterizationt
CollectioncBs�
eZ
dZejgej�Zej�Z	gZ
d
Zd)d)d)dd)d)d)d)d)dd)d�Z
ed��
Zed��
Zd�Zd�Zd	�Zd
�Zd�Zd�Zed
��
Zd�Zd�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+e+Z,d!�Z-e-Z.d"�Z/d#�Z0d$�Z1d%�Z2e2Z3d&�Z4e4Z5Z6d'�Z7d(�Z8RS(*s�
    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()
        * *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.

    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.
    i
tsolidg@c
Ks1
tj
j|�

tjj|||	�
|j|
�

|j|�

|j|�

|j|�

|j	|�

|j
|�

d|_t
jgt
j�|_|dk	r
t
j|�
}t|j�
d
kr�|t
jdd�f}n|dk	r
||_||_q
||_n|
|_|j|�

d|_dS(s=
        Create a Collection

        %(Collection)s
        i
N(tartisttArtistt__init__tcmtScalarMappablet
set_edgecolort
set_facecolort
set_linewidtht
set_linestyletset_antialiasedtset_urlstNonet_uniform_offsetstnptarraytfloat_t_offsetstasarraytlentshapetnewaxist_transOffsett_pickradiustupdatet_paths(
tselft
edgecolorst
facecolorst
linewidthst
linestylestantialiasedstoffsetsttransOffsettnormtcmapt
pickradiusturlstkwargs((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRBs*











	






	
	


c

Cs�yt|�
f
SWn_t
k
rr


tj|�
rst|�
rsyt|d
�

Wnt
tfk
rg


qoX|Sqsn
Xt
d�
�
dS(Nis1val must be a float or nonzero sequence of floats(tfloatt	TypeErrortcbooktiterableRt
ValueError(
tval((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt
_get_valueps







c

CsWtj
|�
s|f
}nyt|d
�

Wn#ttfk
rR


td�
�
n
X|S(Nis.val must be a bool or nonzero sequence of them(R,R-tboolR+t
IndexError(
R/((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	_get_bools





c


Cs|jS(
N(
R(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_paths�s
c


Cs
t�
dS(
N(
tNotImplementedError(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	set_paths�s
c


Cs|jS(
N(
t_transforms(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_transforms�s
cCs�|j�}|j
}|j}|j�}|jsdg|D]}|j|�
^q:}|j�}n|js�|j|�
}|j�}ntj	|tj
�}tj|j
�||j�||j
��}|j|
�
}|S(
N(t
get_transformRRR4t	is_affinettransform_path_non_affinet
get_affinettransform_non_affineRRRtmpathtget_path_collection_extentstfrozenR8tinverse_transformed(Rt	transDatat	transformR$R#tpathst
ptresult((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_datalim�s 

	
	

	
"

	






cCs|jt
j��
}|S(
N(RGt
transformstIdentityTransform(Rtrenderertbbox((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_window_extent�s
c
	Cs�
|j�}
|j
}|j}|j�}|j�r4
g}x�|j�D]}|j}|d
d
�df|d
d
�df}}|j|�
}|j|�
}|jt	j
t||�|j��

qIWt
|j�
r4
|j|jd
d
�df�
}|j|jd
d
�df�
}t||�}q4
ntj|tj�}|
js�
g|D]}|
j|�
^qY
}|
j�}
n|js�
|j|�
}|j�}n|
|||fS(s&Point prep for drawing and hit testingNii
(R9RRR4t
have_unitstverticestconvert_xunitstconvert_yunitstappendR>tPathtziptcodesRRRRR:R;R<R=(	RRCR$R#RDtpathRNtxstys((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt_prepare_points�s0
	
	



	
-


)

"
"
	
"

	

c
Cs�|j�sdS|
j
|jj�

|j�
|j�\}}}}|
j�}|j|�

|j|j	��

|
j
||j�||j�|||j
�|j�|j|j|j|j�
|j�
|
j|jj�

dS(
N(tget_visiblet
open_groupt	__class__t__name__tupdate_scalarmappableRXtnew_gct_set_gc_cliptset_snaptget_snaptdraw_path_collectionR@R8t
get_facecolort
get_edgecolort_linewidthst_linestylest
_antialiasedst_urlstrestoretclose_group(RRJRCR$R#RDtgc((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytdraw�s









cCs�t|j
�
r|j
||
�S|j�s5tifS|j�\}}}}tj|
j|
j|j	|j
�||j�||t|j
�
d
k�	}t|�
d
ktd|�
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.
        itind(tcallablet	_containsRYtFalseRXR>tpoint_in_path_collectiont
xt
yRR@R8Rt_facecolorstdict(Rt
mouseeventRCR$R#RDRm((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytcontains�s





cCs
d
|_dS(Ni(
R'(RR'((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_pickradius�sc


Cs|jS(
N(
R'(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_pickradius�scCs(|
dkrdg
|_
n	|
|_
dS(
N(RRh(RR(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s

c


Cs|jS(
N(
Rh(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_urls�scCsntj
|
tj�}
t|
j�
d
krF|
tjdd�f}
n|jdkra|
|_n	|
|_dS(s�
        Set the offsets for the collection.  *offsets* can be a scalar
        or a sequence.

        ACCEPTS: float or sequence of floats
        i
N(	RRRRRRRRR(RR#((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_offsets�s


c

Cs!|jd
kr|jS|jSd
S(s8
        Return the offsets for the collection.
        N(RRR(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_offsets

s
cCs2|
dkrt
jd
}
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(RtmpltrcParamsR0Re(Rtlw((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR
s
cCs
|j|
�
S(
salias for set_linewidth(
R(RR((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_linewidths"
scCs
|j|
�
S(
salias for set_linewidth(
R(RR((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_lw&
scCs�
yz
tj
j}tj|
�
rl|
|kr:||
g
}qy
|
tjkr`|tj|
g
}qy
t��
n

tj|
�
rp
y�g}x�|
D]�}tj|�
r�||kr�|j||�

q0
|tjkr�|j|tj|�

q0
t��
q�tj|�
r'
t	|�
d
kr'
|j|�

q�t��
q�WWqy
tk
rl



t	|
�
d
kr`
|
}qm
t��
qy
Xn	t��
Wn!tk
r�



td|
�
�
n
X||_
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_basestGraphicsContextBasetdashdR,tis_string_liket	ls_mapperR.R-RQRRf(RtlsR�tdashesRr((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR*
s:
















!




	




cCs
|j|
�
S(
salias for set_linestyle(
R(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_linestylesT
scCs
|j|
�
S(
salias for set_linestyle(
R(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt
set_dashesX
scCs2|
dkrt
jd
}
n|j|
�
|_dS(sm
        Set the antialiasing state for rendering.

        ACCEPTS: Boolean or sequence of booleans
        spatch.antialiasedN(RR}R~R3Rg(Rtaa((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR
\
s

cCs
|j|
�
S(
salias for set_antialiased(
R
(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_antialiasedsf
scCs|j|
�

|j
|
�

d
S(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	(Rt
c((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	set_colorj
s

cCs�t|_
y"|
j�d
kr*t|_
nWntk
r>


n
X|
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(tTruet
_is_filledtlowerRptAttributeErrorRR}R~t_facecolors_originaltmcolorstcolorConvertert
to_rgba_arrayt_alphaRt(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR
x
s	







	
cCs
|j|
�
S(
salias for set_facecolor(
R
(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_facecolors�
sc


Cs|jS(
N(
Rt(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRc�
s
c

Cs$|jd
kr|j
�S|jSdS(Ntface(t_edgecolorstget_facecolors(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRd�
s


cCs�t|_
y"|
j�d
kr*t|_
nWntk
r>


n
X|
dkr`d|_d|_n@|
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�spatch.edgecolorN(R�t_is_strokedR�RpR�R�t_edgecolors_originalRR}R~R�R�R�R�(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR	�
s
	







	

	
cCs
|j|
�
S(
salias for set_edgecolor(
R	(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytset_edgecolors�
scCs�|
dk	r=yt
|
�

Wq=tk
r9


td
�
�
q=Xntjj||
�
y"tjj|j	|j
�|_Wnttt
fk
r�


n
Xy4|jdkr�tjj|j|j
�|_nWnttt
fk
r�


n
XdS(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�RtR�R2R�R�(Rtalpha((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��
s"







	





	


c


Cs|jS(
N(
Re(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_linewidths�
s
c


Cs|jS(
N(
Rf(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_linestyles�
s
c

Cs�|jd
krd
S|jjdkr4td�
�
n|jr[|j|j|j�|_n'|jr�|j|j|j�|_	nd
S(sb
        If the scalar mappable array is not none, update colors
        from scalar data
        Ni
s&Collections can only map rank 1 arrays(
t_ARtndimR.R�tto_rgbaR�RtR�R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR]�
s


	

	
cCs�tj
j||
�
|
j|_|
j|_|
j|_|
j|_|
j|_|
j|_|
j	|_	|
j
|_
|
j|_|
j|_|
j
|_
d
S(s"copy properties from other to selfN(RRtupdate_fromRgR�R�R�RtReRfRR�R%R&(Rtother((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��
s









N(9R\t
__module__t__doc__RRRRRHRIRR7tzorderRRtstaticmethodR0R3R4R6R8RGRLRXR
RlRwRxRyRRzR{R|RR�R�RR�R�R
R�R�R
R�RcR�Rdtget_edgecolorsR	R�R�R�t
get_linewidthR�t
get_dashest
get_linestyleR]R�(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRsp"












#
						 		
					
				*			
											
	
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.
tPathCollectioncBs)eZ
dZejd
��
Zd�ZRS(s>
    This is the most basic :class:`Collection` subclass.
    cKs!tj
||�

|j|
�

d
S(ss
        *paths* is a sequence of :class:`matplotlib.path.Path`
        instances.

        %(Collection)s
        N(RRR6(RRDR)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRs	
cCs
|
|_dS(
N(
R(RRD((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR6's
(R\R�R�Rtdedent_interpdRR6(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s

tPolyCollectioncBsAeZ
ejded��
Zed
�
ZeZe	d��
Z
RS(cKs-tj
||�

||_|j|
|�
d
S(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(RRt_sizest	set_verts(RtvertstsizestclosedR)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR,s
	
cCsu
tj
j|
�
r3|
jtj�
jtj�
}
n|rL
g|_x,
|
D]�}t|�
r,
tj
j|�
r�tj
j	|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.i
iitdtypei����N(i
i(i
i(Rtmat
isMaskedArraytastypeRtfilledtnanRRtconcatenatetzerosRtemptyRR>RRt	code_typetLINETOtMOVETOt	CLOSEPOLYRQ(RR�R�txyRT((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�Ds"
!
	




$

"




 cCsg|jdk	rWg|jD]2}tj�jtj|�
|jjd
�
^q|_	nt
j||
�S(NgR@(R�RRHtAffine2DtscaleRtsqrttfiguretdpiR7RRl(RRJRr((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRl^sE
N(R\R�RR�RR�RR�R6R
Rl(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�+s


tBrokenBarHCollectioncBs/eZ
dZejd
��
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
||	|�
d
S(s�
        *xranges*
            sequence of (*xmin*, *xwidth*)

        *yrange*
            *ymin*, *ywidth*

        %(Collection)s
        N(R�R(
RtxrangestyrangeR)tymintywidthtymaxtxmintxwidthR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRms


T
c
Ks�g}x_tj
|�
D]N\}}|||!}t|�
sAqn|j|d
|d|d
f�

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_regionsRRQR�(
RrR�R�twhereR)R�tind0tind1txslicet
collection((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt
span_where~s






'
(R\R�R�RR�RR�R�(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�hs
tRegularPolyCollectioncBs\eZ
dZejjZejd
dd��
Z	e
d��
Zd�Zd�Z
d�ZRS(	s6Draw a collection of regular polygons with *numsides*.ii
cKsWtj
||�

||_|
|_|j|
�
g
|_||_|jtj	��

d
S(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_transformRHRI(RtnumsidestrotationR�R)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s$
	
	

	
cCsrg|jD]O}t
j�j|j�
jtj|�
|jj	d
tjtj
�
�
^q
|_tj
||
�S(NgR@(R�RHR�trotateR�R�RR�R�R�tpiR7RRl(RRJRr((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRl�s_
c


Cs|jS(
N(
R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_numsides�s
c


Cs|jS(
N(
R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytget_rotation�s
c


Cs|jS(
N(
R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_sizes�s
(
i
(R\R�R�R>RRtunit_regular_polygonR�RR�RR
RlR�R�R�(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��s


'		tStarPolygonCollectionc
BseZ
dZejjZRS(
s?
    Draw a collection of regular stars with *numsides* points.(R\R�R�R>RRtunit_regular_starR�(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��stAsteriskPolygonCollectionc
BseZ
dZejjZRS(
sC
    Draw a collection of regular asterisks with *numsides* points.(R\R�R�R>RRtunit_regular_asteriskR�(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��stLineCollectionc
BsweZ
dZd
Zd
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�|dkrt
jd
}n|dkr;t
jdf
}n|dkrZt
jdf
}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` matrix
        :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.antialiasedRRR�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)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s,B















cCs�|
dkrdSg}xE|
D]=}t
jj|�
sMt
j|t
j�}n|j|�

qW|jdk	r|j|�
}ng|D]}t	j
|�
^q�|_dS(
N(RRR�R�RRRQRt_add_offsetsR>RRR(RR�t	_segmentstseg((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�Fs







cCs�|j}t
|
�
}|jd
}|dkr^xkt|�
D]}|
||||
|<q;Wn>x;t|�
D]-}||}|
||||d!|
|<qkW|
S(Nii
(RRRtrange(RtsegsR#tNsegstNoffst
itio((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�Vs
	








!
cCs|j|
�

d
S(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�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�cs	cCstj
d
�

|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(twarningstwarnR�(RR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytcolorns	

c


Cs|jS(
N(
R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt	get_colorzs
N(R\R�R�R�RRR�R�R6R�R�R�R�t
get_colors(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��s&









P	

	
			tCircleCollectioncBs8eZ
dZejd
��
Zd�Zed��
ZRS(s7
    A collection of circles, drawn using splines.
    cKsEtj
||�

|
|_|jtj��

tjj�g
|_	d
S(sf
        *sizes*
            Gives the area of the circle in points^2

        %(Collection)s
        N(
RRR�R�RHRIR>RRtunit_circleR(RR�R)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s
	

c


Cs|jS(
sreturn sizes of circles(
R�(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR��scCseg|jD]B}t
j�jtj|�
|jjd
tjtj�
�
^q
|_	t
j||
�S(NgR@(R�RHR�R�RR�R�R�R�R7RRl(RRJRr((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRl�sR
(	R\R�R�RR�RR�R
Rl(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�~s

	tEllipseCollectioncBs;eZ
dZejd
d�
�
Zd�Zed��
ZRS(s8
    A collection of ellipses, drawn using splines.
    tpointscKs�tj
||�

d
tj|
�
j�|_d
tj|�
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(RRRRtravelt_widthst_heightsR�t_anglest_unitsR�RHRIR7R>RRR
R(RtwidthstheightstanglestunitsR)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s


#
	

	
c

Cs�
g|_|j
}
|j}|jd
kr3d}n�|jdkr[|
jj|
jj}n�|jdkr�|
jj|
jj}n�|jdkr�|j}n�|jdkr�|jd}ng|jdkr�|
jj}nI|jd	kr�|
jj}n+|jd
kr
d}nt	d|j�
�
t
j}xbt|j
|j|j�D]E\}}}|�j||||�j|�
}|jj|�

qI
W|jd
kr�
|
jj�j�j�}	d
|	dd�dd�f<|j||	�
�

ndS(sB
        Calculate transforms immediately before drawing.
        R�i
RrRstinchesR
gR@twidththeighttdotsg�?sunrecognized units: %siNi(R7taxesR�R
RKR

tviewLimR
R�R.RHR�RSR
R
R
R�R�RQRBR<t
get_matrixtcopyR�(
Rtaxtfigtsct_affineRrRst
attranst
m((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt_set_transforms�s8	
	
	
	













		
+
&



cCs|j�
t
j||
�
dS(
N(R
RRl(RRJ((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRl�s

(	R\R�R�RR�RR
R
Rl(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR

�s


#	%tPatchCollectioncBs#eZ
dZed
�
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.
        c

Ss&|j�r|j
�Sd
d
d
d
gS(Ni(tget_fillRc(
tpatch((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytdetermine_facecolors



RRR R!R"N(RdR�R�tget_antialiasedRRR6(Rtpatchestmatch_originalR)R
RERRR R!R"((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR�s 
	










cCs;g|
D]!}|j�j
|j��
^q}||_dS(
N(R9ttransform_pathtget_pathR(RR!
RERD((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR6)s

+
(R\R�R�RpRR6(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR
�s	.tQuadMeshcBs_eZ
dZed
d�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', 'faceted' or 'gouraud'
    tflatcKs�tj
||�

|
|_||_||_||_||_||_tj	j
�|_|jj|j
|
d
|d
df�
�

|jj
|d
|
d
df�
|_tj|jtj�|_dS(Ni
i(RRt
_meshWidtht_meshHeightt_coordinatest
_showedgest_antialiasedt_shadingRHtBboxtunitt_bboxtupdate_from_data_xytreshapeRRR(Rt	meshWidtht
meshHeighttcoordinatest	showedgestantialiasedtshadingR)((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRNs
	
	
	
	
	
	

&
c

Cs#|jdkr|j�
n|jS(
N(RRR6(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR4`s



c

Cs%|j|j
|j|j�|_dS(
N(tconvert_mesh_to_pathsR'
R(
R)
R(
R((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR6es

c	Cs�tj
}tj|�
r$|j}n|}tj|d
d�d
d�f|d
d�dd�f|dd�dd�f|dd�d
d�f|d
d�d
d�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����i
Ntaxisii(R>RRR�R�tdataRR�R1
(R2
R3
R4
RRR�R
Rr((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR8
is		






	

c
Cstj
}tj|�
r$|j}n|}|d
d�d
d�f}|d
d�dd�f}|dd�dd�f}|dd�d
d�f}	||||	d}
tj|||
|||
||	|
|	||
fdd�

}|j|
|dd	df�
}|j�j|d|
ddf�
}|d
d�d
d�f}
|d
d�dd�f}|dd�dd�f}|dd�d
d�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����i
Ng@R9
iii(	R>RRR�R�R:
RR�R1
Rc(RR2
R3
R4
RRREtp_atp_btp_ctp_dtp_centert	trianglesR�tc_atc_btc_ctc_dtc_centerR�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pytconvert_mesh_to_triangles�s<	





	
	
	

	
 &





	
	
	

	
 c
Cs|jS(
N(
R/
(RRB((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRG�s
cCsJ|j�sdS|
j
|jj�

|j�}|j}|j}|j�r�t|j�
r�|j	|jd
 �
}|j
|jd �
}t||�}q�ntj
|tj�}|jd�
r�|j�
n|js:
|jj|jjd
|jjddf�
}|j|�
}|j|jj�
}tj�}n	|j}|jsj
|j|�
}|j�}n|
j�}|j|�

|j|j�d
�

|jdkr�
|j|j |j!|�\}	}
|
j"||	|
|j#��
n@|
j$||j#�|j |j!||||j%�|j&|j'�

|j(�
|
j)|jj�

dS(Nii
Ritgouraud(*RYRZR[R\R9RRRMRRORPRSRRRtcheck_updateR]R:R)
R1
RRCRHRIR=R<R^R_RR�R,
RF
R'
R(
tdraw_gouraud_trianglesR@tdraw_quad_meshRcR+
R*
RiRj(RRJRCR$R#RVRWR4
RkR@
R�((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyRl�sN


	
	





	
	






		













(
R\R�R�R�RR4R6R�R8
RF
RGR
Rl(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyR%
/s			,	(/R�R�tnumpyRtnumpy.maR�t
matplotlibR}tmatplotlib.cbookR,tmatplotlib.colorsR�R�t
matplotlib.cmRRtmatplotlib.transformsRHtmatplotlib.artistRR
tmatplotlib.backend_basesR�tmatplotlib.pathRUR>tmatplotlib.mlabR�RRRtinterpdRR�R�R�R�R�R�R�R�R

R
R%
tkwdoctpatchstrt
k(((sI/opt/alt/python27/lib64/python2.7/site-packages/matplotlib/collections.pyt<module>
sH













��=*A� R?�