old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/matplotlib/__pycache__/collections.cpython-37.pyc

B
U<>]<5D>
<00>@s<>
dZd
dl
Z
d
dlmZ
d
dlZd
dlZddlm	Z	m
Z
mZmZm
ZmZmZmZmZ
d
dlZe<0B>ddgdd	gd
dgdd
dgddgd<11><05>
Gdd<13>de
jej<18><04>
Zejjdd<15>

Gdd<17>de<19>ZGdd<19>de<1C>ZGdd<1B>de<1C>ZGdd<1D>de<1E>ZGdd<1F>de<1C>Z Gd d!<21>d!e <20>Z!Gd"d#<23>d#e <20>Z"Gd$d%<25>d%e<19>Z#Gd&d'<27>d'e#<23>Z$Gd(d)<29>d)e<1C>Z%Gd*d+<2B>d+e<19>Z&Gd,d-<2D>d-e<19>Z'Gd.d/<2F>d/e<19>Z(Gd0d1<64>d1e<19>Z)e
<EFBFBD>*e<19>
Z+xd2D]Z,ej<1A>e,e+i
<01>

<00>
q<>Wejje
<EFBFBD>*e#<23>
d3<64>

dS)4ay

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 segments).
<EFBFBD>N)
<01>Number<65>
)	<09>_path<74>artist<73>cbook<6F>cm<63>colors<72>	docstring<6E>lines<65>path<74>
transforms<EFBFBD>antialiaseds<64>aa<61>
edgecolorsZec<65>
facecolorsZfc<66>
linestyles<EFBFBD>dashes<65>ls<6C>
linewidths<EFBFBD>lw)<05>antialiasedZ	edgecolorZ	facecolor<6F>	linestyle<6C>	linewidthc@s<>
eZ
dZd
Ze<04>d<02>
Ze<07><08>Z	e<04>
d<03>
ZdZd\d
d<0B>
Z
dd
<0A>Zdd<0F>Zdd<11>Zdd<13>Zdd<15>Zdd<17>Zdd<19>Zejdd<1B><00>
Zdd<1D>Zdd<1F>Zd d!<21>Zd"d#<23>Zd$d%<25>Zd&d'<27>Zd(d)<29>Zd*d+<2B>Zd,d-<2D>Z d.d/<2F>Z!d0d1<64>Z"d2d3<64>Z#d4d5<64>Z$d6d7<64>Z%d8d9<64>Z&d:d;<3B>Z'd<d=<3D>Z(e)d>d?<3F><00>
Z*d@dA<64>Z+dBdC<64>Z,dDdE<64>Z-dFdG<64>Z.dHdI<64>Z/dJdK<64>Z0dLdM<64>Z1dNdO<64>Z2dPdQ<64>Z3dRdS<64>Z4dTdU<64>Z5dVdW<64>Z6dXdY<64>Z7dZd[<5B>Z8dS)]<5D>
Collectiona
    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)]

    Exceptions are *capstyle* and *joinstyle* properties, these can
    only be set globally for the whole collection.

    Keyword arguments and default values:

        * *edgecolors*: None
        * *facecolors*: None
        * *linewidths*: None
        * *capstyle*:   None
        * *joinstyle*:  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
        * *zorder*: 1

    *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
    (i.e., a call to set_array has been made), at draw time a call to
    scalar mappable will be made to set the face colors.
    )r
<00>)r
<00>rFN<46>solid<69>@<40>screenrcKs`
tj
<01>|<00>

tj<04>||
|<0B>
d
g
|_d
g
|_dg
|_dg
|_d|_	t
<EFBFBD>tj
d<00>
|_|<00>|<02>

|<00>|
<01>

|<00>|<03>

|<00>|<04>

|<00>|<07>

|<00>|<0C>

|<00>|<0E>

|<00>|
<0A>

|<00>|<0F>

|<00>|<10>

|r<>|<00>|<05>

nd|_|r<>|<00>|<06>

nd|_t<1D>d<06>
|_d|_ |dk	<09>
rFt<1D>!|t"<22>}|j#dk<02>
r(|ddd<05>f}|	dk	<09>
r@||_|	|_$n||_ d|_%|<00>&|<11>

d|_'dS)z=
        Create a Collection

        %(Collection)s
        )NNr
Tzhatch.colorN)rr)
r)(r<00>Artist<73>__init__r<00>ScalarMappable<6C>_us_linestyles<65>_linestyles<65>_us_lw<6C>_linewidths<68>
_is_filled<EFBFBD>mcolors<72>to_rgba<62>mpl<70>rcParams<6D>_hatch_color<6F>
set_facecolor<6F>
set_edgecolor<6F>
set_linewidth<74>
set_linestyle<6C>set_antialiased<65>set_pickradius<75>set_urls<6C>	set_hatch<63>set_offset_positionZ
set_zorder<EFBFBD>set_capstyle<6C>	_capstyle<6C>
set_joinstyle<6C>
_joinstyle<EFBFBD>np<6E>zeros<6F>_offsets<74>_uniform_offsets<74>
asanyarray<EFBFBD>float<61>shape<70>_transOffsetZ
_path_effects<74>update<74>_paths)<12>selfrrrrZcapstyleZ	joinstyler
<00>offsets<74>transOffset<65>norm<72>cmap<61>
pickradius<EFBFBD>hatch<63>urls<6C>offset_position<6F>zorder<65>kwargs<67>rN<00>>/tmp/pip-install-i8dhxrtk/matplotlib/matplotlib/collections.pyr ZsJ




































zCollection.__init__c


Cs|jS)
N)
rB)
rCrNrNrO<00>	get_paths<68>s
zCollection.get_pathsc


Cst<00>
dS)
N)
<01>NotImplementedError)
rCrNrNrO<00>	set_paths<68>s
zCollection.set_pathsc


Cs|jS)
N)
<01>_transforms)
rCrNrNrO<00>get_transforms<6D>s
zCollection.get_transformsc
Cs,|j}
t
|
tj<03>s(t|
d
<01>r(|
<01>|j<06>
}
|
S)N<>_as_mpl_transform)r@<00>
isinstancerZ	Transform<72>hasattrrU<00>axes)rC<00>
trNrNrO<00>get_offset_transform<72>s






zCollection.get_offset_transformcs<>|<00><00><00>|<00>
<01>}|j}|<00><03>}<04>js><3E>f
d
d<02>|D<00>
}<04><00><05><00>|jsV|<02>|<03>
}|<02><05>}t|tj	j
<EFBFBD>rp|<03>tj<0C>
}t
|<04>
r<>t
|<03>
r<>t<0E><0F><00><10>||<00><11>||<02><10><00>}|<05>|
<01>
}n
tj<14><15>}|S)Nc
sg|]}
<01><00>|
<01>
<01>qSrN)
<01>transform_path_non_affine)<02>.0<EFBFBD>
p)
<01>	transformrNrO<00>
<listcomp><3E>sz*Collection.get_datalim.<locals>.<listcomp>)<16>
get_transformrZr;rP<00>	is_affine<6E>
get_affine<EFBFBD>transform_non_affinerVr9<00>ma<6D>MaskedArray<61>filled<65>nan<61>len<65>mpathZget_path_collection_extents<74>frozenrTZinverse_transformedr<00>Bbox<6F>null)rC<00>	transDatarErD<00>paths<68>resultrN)
r^rO<00>get_datalim<69>s&
















zCollection.get_datalimcCs|<00>t
<01><02><00>
S)
N)rpr<00>IdentityTransform)rC<00>rendererrNrNrO<00>get_window_extent<6E>szCollection.get_window_extentc
	s8
|<00><00><00>|<00>
<01>}
|j}|<00><03>}|<00><04>r<>g}xj|<00><03>D]^}|j}|dd<00>d
f|dd<00>df}}|<00>|<06>
}|<00>|<07>
}|<03>t	<09>
t<0B>||g<02>
|j
<0A><02>

q4W|jr<>|<00>|dd<00>d
f<00>
}|<00>|dd<00>df<00>
}t<0B>||g<02>
}<02>js<><73>f
dd<04>|D<00>
}<03><00><10><00>|
j<0F>
s|
<01>|<02>
}|
<01><10>}
t|tjj<14><02>
r,|<02>tj<16>
}<02>|
||fS)Nr
rc
sg|]}
<01><00>|
<01>
<01>qSrN)
r[)r\r)
r^rNrOr_<00>s
z.Collection._prepare_points.<locals>.<listcomp>)r`rZr;rP<00>
have_units<EFBFBD>vertices<65>convert_xunits<74>convert_yunits<74>appendri<00>Pathr9<00>column_stack<63>codes<65>sizerarbrcrVrdrerfrg)rCrErDrnrru<00>xs<78>ysrN)
r^rO<00>_prepare_points<74>s4






"




"











zCollection._prepare_pointscCs<>|<00><00>sdS|
<01>
|jj|<00><04><00>
|<00><05>
|<00><06>\}}}}|
<01><07>}|<00>|<06>

|<06>	|<00>
<EFBFBD><00>

|jr<>|<06>|j<0B>

y|<06>
|j<0E>

Wn"tk
r<EFBFBD>


tjd
dd<03>
YnX|<00><12>dk	r<>|j|<00><12><00>
|<00><14>r<>ddlm}
||<00><14>|
<01>}
|<00><17>}|<00><18>}	|<00><19>}
d}t|<05>
dk<02>
r<>t|<08>
dk
<01>
r<>t|	<09>
dk<02>
r<>t|
<EFBFBD>
dk<02>
r<>t|j<1B>
dk<02>
r<>|jdg
k<02>
r<>t|j<1D>
dk<02>
r<>t|j<1E>
dk<02>
r<>|<00><1F>dk<08>
r<>t|<08>
<01>
r<>t <20>!|d<00>
|}n|}|d<00>"|<0C>
}
|
<01>#<23>\}}|
j$|k<00>
r<>|
j%|k<00>
r<>d	}|j&<26>
r<>|<06>'|j&<26>

|j(<28>
r<>|<06>)|j(<28>

|<0B>r~|<06>*t+|
d<00>
<01>

|<06>,|jd<00>

|j-|jd<00>
|<06>.|jd<00>

|<06>/|jd<00>

|
<01>0||d|<0C>1<EFBFBD>t2<74>3|<04>
|t+|	d<00>
<01>
n<|
<01>4||<02>1<EFBFBD>||<00><17>|||<00><18>|<00><19>|j|j|j|j|j5<6A>

|<06>6<EFBFBD>
|
<01>7|jj<03>

d|_8dS)
Nz3.1zoYour backend does not support setting the hatch color; such backends will become unsupported in Matplotlib 3.3.)
<01>messager
)
<01>PathEffectRendererFr)NNT)9<>get_visible<6C>
open_group<EFBFBD>	__class__<5F>__name__<5F>get_gid<69>update_scalarmappabler<00>new_gc<67>_set_gc_clipZset_snapZget_snap<61>_hatchr3<00>set_hatch_colorr+<00>AttributeErrorrZwarn_deprecatedZget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsr<73>rT<00>
get_facecolor<6F>
get_edgecolorrhr%r#<00>
_antialiaseds<64>_urls<6C>	get_hatchr<00>Affine2DZget_extentsZget_canvas_width_height<68>width<74>heightr8r7r6r5Zset_foreground<6E>tupler.Z
set_dashesr0Zset_urlZdraw_markersrjriryZdraw_path_collection<6F>_offset_position<6F>restore<72>close_group<75>stale)rCrrr^rErDrn<00>gcr<63>ZtransrrZdo_single_path_optimizationZcombined_transformZextentsr<73>r<>rNrNrO<00>draw<61>sz




















 




























zCollection.drawcCs
|
|_d
S)z<>
        Set the pick radius used for containment tests.

        Parameters
        ----------
        d : float
            Pick radius, in points.
        N)
<01>_pickradius)rC<00>prrNrNrOr1O
s	zCollection.set_pickradiusc


Cs|jS)
N)
r<>)
rCrNrNrO<00>get_pickradiusZ
s
zCollection.get_pickradiusc
Cs<>|jd
k	r|<00>||
<01>S|<00>
<01>s&difSt|jt<04>rF|jdk	rFt|j<03>
n|j}|<00><07>\}}}}t<08>	|
j
|
j||<03><0C>||<00>
<0A>|||dk
|<00><0E><00>
}t|<07>
dkt|d<05>
fS)z<>
        Test whether the mouse event occurred in the collection.

        Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
        contains the event.
        NFTr
)
<01>ind)Z	_containsr<73>rVZ_pickerrr>r<>rrZpoint_in_path_collection<6F>
x<>
yrjrT<00>get_offset_positionrh<00>dict)rCZ
mouseeventrHr^rErDrnr<>rNrNrO<00>contains]
s











zCollection.containscCs|
d
k	r|
nd
g
|_d|_
d
S)zP
        Parameters
        ----------
        urls : List[str] or None
        NT)r<>r<>)rCrJrNrNrOr2z
s
zCollection.set_urlsc


Cs|jS)
N)
r<>)
rCrNrNrO<00>get_urls<6C>
s
zCollection.get_urlscCs|
|_d
|_
dS)a<>
        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.

        Parameters
        ----------
        hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
        TN)r<>r<>)rCrIrNrNrOr3<00>
s 
zCollection.set_hatchc


Cs|jS)
z$Return the current hatching pattern.)
r<>)
rCrNrNrOr<><00>
szCollection.get_hatchcCsHt<00>
|
t<02>}
|
jd
kr&|
ddd<02>f}
|jdkr8|
|_n|
|_d|_dS)z<>
        Set the offsets for the collection.

        Parameters
        ----------
        offsets : float or sequence of floats
        )
rNT)r9r=r>r?r<r;r<>)rCrDrNrNrO<00>set_offsets<74>
s





zCollection.set_offsetsc

Cs|jd
kr|j
S|jSd
S)z&Return the offsets for the collection.N)r<r;)
rCrNrNrO<00>get_offsets<74>
s

zCollection.get_offsetscCs"tj
d
dg|
d<03>
|
|_d|_dS)a<>

        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.

        Parameters
        ----------
        offset_position : {'screen', 'data'}
        r<00>data)
rKTN)r<00>_check_in_listr<74>r<>)rCrKrNrNrOr4<00>
s



zCollection.set_offset_positionc


Cs|jS)
a<>

        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<>)
rCrNrNrOr<><00>
s	zCollection.get_offset_positioncCsX|
d
kr$tj
d}
|
d
kr$tj
d}
t<02>t<02>|
<01>
<01>
|_|<00>|j|j<07>\|_|_	d|_
d
S)z<>
        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

        Parameters
        ----------
        lw : float or sequence of floats
        Nzpatch.linewidthzlines.linewidthT)r)r*r9<00>
atleast_1d<EFBFBD>asarrayr$<00>_bcast_lwlsr"r%r#r<>)rCrrNrNrOr.<00>
s







zCollection.set_linewidthcCs<>y^t|
t
<01>r(tj<03>|
|
<01>}
t<05>|
<01>
g
}n4yt<05>|
<01>
g
}Wn"tk
rZ


d
d<02>|
D<00>
}YnXWn"tk
r<EFBFBD>


td<03>|
<01>
<01>
<01>
YnX||_	|<00>
|j|j	<09>\|_|_
dS)a%
        Set the linestyle(s) for the collection.

        ===========================   =================
        linestyle                     description
        ===========================   =================
        ``'-'`` or ``'solid'``        solid line
        ``'--'`` or  ``'dashed'``     dashed line
        ``'-.'`` or  ``'dashdot'``    dash-dotted line
        ``':'`` or ``'dotted'``       dotted line
        ===========================   =================

        Alternatively a dash tuple of the following form can be provided::

            (offset, onoffseq),

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

        Parameters
        ----------
        ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            The line style.
        c
Ssg|]}
t<00>
|
<01>
<01>qSrN)<02>mlines<65>_get_dash_pattern)r\r<>rNrNrOr_sz,Collection.set_linestyle.<locals>.<listcomp>z)Do not know how to convert {!r} to dashesN)rV<00>strrZ	ls_mapper<65>getr<74>r<><00>
ValueError<EFBFBD>formatr"r<>r$r%r#)rCrrrNrNrOr/<00>
s









zCollection.set_linestylecCs |
d
kr|
|_nt
d|
<00>
<01>
dS)z<>
        Set the capstyle for the collection (for all its elements).

        Parameters
        ----------
        cs : {'butt', 'round', 'projecting'}
            The capstyle
        )Zbutt<74>roundZ
projectingz!Unrecognized cap style.  Found %sN)r6r<>)rC<00>csrNrNrOr5&s	
zCollection.set_capstylec


Cs|jS)
N)
r6)
rCrNrNrO<00>get_capstyle4s
zCollection.get_capstylecCs |
d
kr|
|_nt
d|
<00>
<01>
dS)z<>
        Set the joinstyle for the collection (for all its elements).

        Parameters
        ----------
        js : {'miter', 'round', 'bevel'}
            The joinstyle
        )Zmiterr<72>Zbevelz"Unrecognized join style.  Found %sN)r8r<>)rCZjsrNrNrOr77s	
zCollection.set_joinstylec


Cs|jS)
N)
r8)
rCrNrNrO<00>
get_joinstyleEs
zCollection.get_joinstylecCsztj
d
r||
fSt|
<01>
t|<00>
kr^t|
<01>
}t|<00>
}t<03>||<03>}t|
<01>
||}
t|<00>
||}dd<03>t|
|<00>D<00>
}
||
fS)a<>
        Internal helper function to broadcast + scale ls/lw

        In the collection drawing code, the linewidth and linestyle are cycled
        through as circular buffers (via ``v[i % len(v)]``).  Thus, if we are
        going to scale the dash pattern at set time (not draw time) we need to
        do the broadcasting now and expand both lists to be the same length.

        Parameters
        ----------
        linewidths : list
            line widths of collection
        dashes : list
            dash specification (offset, (dash pattern tuple))

        Returns
        -------
        linewidths, dashes : list
             Will be the same length, dashes are scaled by paired linewidth
        z_internal.classic_modec
Ss"g|]\\}
}}t<00>
|
||<03><03>qSrN)r<>Z
_scale_dashes)r\<00>
o<>
drrNrNrOr_is
z*Collection._bcast_lwls.<locals>.<listcomp>)r)r*rh<00>math<74>gcd<63>list<73>zip)rrZl_dashesZl_lwr<77>rNrNrOr<>Hs







zCollection._bcast_lwlscCs0|
d
krtj
d}
t<02>t<02>|
t<05><02>
|_d|_d
S)z<>
        Set the antialiasing state for rendering.

        Parameters
        ----------
        aa : bool or sequence of bools
        Nzpatch.antialiasedT)r)r*r9r<>r<><00>boolr<6C>r<>)rCrrNrNrOr0ns



zCollection.set_antialiasedcCs|<00>|
<01>

|<00>
|
<01>

d
S)a*

        Set both the edgecolor and the facecolor.

        Parameters
        ----------
        c : color or sequence of rgba tuples

        See Also
        --------
        Collection.set_facecolor, Collection.set_edgecolor
            For setting the edge or face color individually.
        N)r,r-)rC<00>
crNrNrO<00>	set_color{s

zCollection.set_colorcCs^|
dkrtj
d
}
d|_y|
<01><03>dkr,d|_Wntk
rB


YnXt<05>|
|j<07>|_d|_	dS)Nzpatch.facecolorT<72>noneF)
r)r*r&<00>lowerr<72>r'<00>
to_rgba_array<61>_alpha<68>_facecolorsr<73>)rCr<>rNrNrO<00>_set_facecolor<6F>s










zCollection._set_facecolorcCs|
|_|<00>
|
<01>

d
S)au

        Set the facecolor(s) of the collection.  *c* can be a
        matplotlib color spec (all patches have same color), or a
        sequence of specs; if it is a sequence the patches will
        cycle through the sequence.

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

        Parameters
        ----------
        c : color or sequence of colors
        N)<02>_original_facecolorr<72>)rCr<>rNrNrOr,<00>s

zCollection.set_facecolorc


Cs|jS)
N)
r<>)
rCrNrNrOr<><00>s
zCollection.get_facecolorc

Cs t<00>
|jd
<01>r|<00><03>S|jSdS)N<>face)rZ
_str_equal<EFBFBD>_edgecolorsr<73>)
rCrNrNrOr<><00>s

zCollection.get_edgecolorcCs<>d
}|
dkr6tj
ds"|jr"|jr.tj
d}
nd}
d}d
|_y|
<01><05>dkrPd|_Wntk
rf


YnXy|
<01><05>dkr<>d|_dSWntk
r<EFBFBD>


YnXt<08>	|
|j
<EFBFBD>|_|r<>t|j<07>
r<>t|jd<00>
|_
d
|_dS)NTzpatch.force_edgecolorzpatch.edgecolorr<72>Fr<46>r
)r)r*r&<00>
_edge_default<6C>_is_strokedr<64>r<>r<>r'r<>r<>rhr<>r+r<>)rCr<>r<>rNrNrO<00>_set_edgecolor<6F>s.





















zCollection._set_edgecolorcCs|
|_|<00>
|
<01>

d
S)a

        Set the edgecolor(s) of the collection.

        Parameters
        ----------
        c : color or sequence of colors or 'face'
            The collection edgecolor(s).  If a sequence, the patches cycle
            through it.  If 'face', match the facecolor.
        N)<02>_original_edgecolorr<72>)rCr<>rNrNrOr-<00>s

zCollection.set_edgecolorcCsf|
d
k	r2yt|
<01>

Wnt
k
r0


t
d<02>
<01>
YnXd|jd<tj<04>||
<01>
|<00>|j<07>

|<00>|j	<09>

d
S)z<>
        Set the alpha transparencies of the collection.

        Parameters
        ----------
        alpha : float or None
        Nzalpha must be a float or NoneT<65>array)
r><00>	TypeErrorZupdate_dictrr<00>	set_alphar<61>r<>r<>r<>)rC<00>alpharNrNrOr<><00>s








zCollection.set_alphac


Cs|jS)
N)
r%)
rCrNrNrO<00>
get_linewidth<74>s
zCollection.get_linewidthc


Cs|jS)
N)
r#)
rCrNrNrO<00>
get_linestyle<6C>s
zCollection.get_linestylec

Csl|jd
krd
S|jj
dkr"td<03>
<01>
|<00>d<04>
s0d
S|jrJ|<00>|j|j<06>|_n|jrb|<00>|j|j<06>|_	d|_
d
S)z@Update colors from the scalar mappable array, if it is not None.Nrz&Collections can only map rank 1 arraysr<73>T)<0B>_A<5F>ndimr<6D>Zcheck_updater&r(r<>r<>r<>r<>r<>)
rCrNrNrOr<><00>s











z Collection.update_scalarmappablec


Cs|jS)
zreturn whether fill is set)
r&)
rCrNrNrO<00>get_fillszCollection.get_fillcCs<>tj
<01>||
<01>
|
j|_|
j|_|
j|_|
j|_|
j|_|
j|_|
j	|_	|
j
|_
|
j|_|
j|_|
j
|_
|
j|_|
j|_d
|_dS)z"copy properties from other to selfTN)rr<00>update_fromr<6D>r<>r<>r<>r<>r%r#r"r<>r<>r<>rFrGr<>)rC<00>otherrNrNrOr<>s











zCollection.update_from)NNNrNNNNNNNrNNrr)9r<39><00>
__module__<EFBFBD>__qualname__<5F>__doc__r9r:r;rrqr@<00>emptyrSr<>r rPrRrTrZrprsrr<00>allow_rasterizationr<6E>r1r<>r<>r2r<>r3r<>r<>r<>r4r<>r.r/r5r<>r7r<><00>staticmethodr<64>r0r<>r<>r,r<>r<>r<>r-r<>r<>r<>r<>r<>r<>rNrNrNrOrsz5



















;%V	#-&


ra<>    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.
)
rc@s4eZ
dZd
ZdZdd<04>Zddd<07>
Zejdd	<09><00>
Z	d
S)<0C>_CollectionWithSizeszA
    Base class for collections that have an array of sizes.
    g<00>?c


Cs|jS)
z<>
        Returns the sizes of the elements in the collection.  The
        value represents the 'area' of the element.

        Returns
        -------
        sizes : array
            The 'area' of each element.
        )
<01>_sizes)
rCrNrNrO<00>	get_sizes;s
z_CollectionWithSizes.get_sizes<65>R@cCs<>|
d
kr"t<00>
g<00>
|_t<00>d<02>
|_nzt<00>|
<01>
|_t<00>t|j<02>
ddf<03>
|_t<00>|j<02>
|d|j	}||jd
d
<01>ddf<||jd
d
<01>ddf<d|jd
d
<01>ddf<d	|_
d
S)
aF

        Set the sizes of each member of the collection.

        Parameters
        ----------
        sizes : ndarray or None
            The size to set for each element of the collection.  The
            value is the 'area' of the element.
        dpi : float
            The dpi of the canvas. Defaults to 72.0.
        N)r
rrrgR@r
rg<00>?rT)r9r<>r<>r<>rSr<>r:rh<00>sqrt<72>_factorr<72>)rC<00>sizes<65>dpiZscalerNrNrO<00>	set_sizesGs







z_CollectionWithSizes.set_sizescCs"|<00>|j
|jj<03>
t<04>||
<01>
dS)
N)r<>r<><00>figurer<65>rr<>)rCrrrNrNrOr<>_s
z_CollectionWithSizes.drawN)
r<>)
r<EFBFBD>r<>r<>r<>r<>r<>r<>rr<>r<>rNrNrNrOr<>5s


r<>c@sFeZ
dZd
Zejddd<04>
<01>
Zdd<06>Zdd<08>Zd	d
ddd<0C>fd
d<0E>
Z	dS)<10>PathCollectionz<6E>
    This is the most basic :class:`Collection` subclass.
    A :class:`PathCollection` is e.g. created by a :meth:`~.Axes.scatter` plot.
    NcKs,tj
|f
|<03>

|<00>|
<01>

|<00>|<02>

d
|_dS)zs
        *paths* is a sequence of :class:`matplotlib.path.Path`
        instances.

        %(Collection)s
        TN)rr rRr<>r<>)rCrnr<>rMrNrNrOr js	




zPathCollection.__init__cCs|
|_d
|_
dS)NT)rBr<>)rCrnrNrNrOrRxs

zPathCollection.set_pathsc


Cs|jS)
N)
rB)
rCrNrNrOrP|s
zPathCollection.get_pathsr<00>autoc


Cs|S)
NrN)
r<>rNrNrO<00><lambda><3E><00>zPathCollection.<lambda>cKs<>g}g}|<00><00>d
k	}|d
kr.t
jjddd<04>}nt|t<05>rDt
j<02>|<03>
}|<03><07>
|
dkr<>|sjt<08>	d<06>

||fSt
<EFBFBD>|<00><00><00>
}	|<05>dt
j
d<00>}
n4|
d	kr<>t
<EFBFBD>|<00><0E><00>
}	|<05>d
d<0B>}ntd|
<01>d
<0A><03>
<01>
|<03>||	<09>
<01><11>||	<09>
<01><12><00>
|dkr<>d}t|	<09>
|k
r<>d
}|d
k<08>
r|	}||<0C>
}
n<>|
dk<02>
r$|<00><00>}n|
d	k<02>
r6|<00><0E>}t|t
jj<14><02>
rL|}nHt
<EFBFBD>|<02>
<01>
rft
j<02>|<02>
}n.t|<02>
}t
jj||dddddddddgd<18>}|<0F>||<0E>
<01><11>||<0E>
<01><12><00>}
|
||<0E>
<01><11>k|
||<0E>
<01><12>k
@}|
|}
t
<EFBFBD>|<0E><11>|<0E><12>d<19>}t
<EFBFBD>|
||<11>
|<11>}t|<00><1D>d|<00><1E>d<1B>}|<12>|<05>

x<>t ||
<0A>D]<5D>\}}|
dk<02>rR|<00>!|<00>"|<13>
<01>
}n&|
d	k<02>rxt
<EFBFBD>#|<13>
}
t
<EFBFBD>$|
d<1C><02>rx<72>q.t%j&dg
dg
fd||
|<00>'<27>dd<1E>|<12><02>
}|<06>(|<15>

t)|d<1F><02>r<>|<03>*|
<0A>

||<14>
}|<07>(|<16>

<00>q.W||fS) a<>

        Creates legend handles and labels for a PathCollection. This is useful
        for obtaining a legend for a :meth:`~.Axes.scatter` plot. E.g.::

            scatter = plt.scatter([1,2,3], [4,5,6], c=[7,2,3])
            plt.legend(*scatter.legend_elements())

        Also see the :ref:`automatedlegendcreation` example.

        Parameters
        ----------
        prop : string, optional, default *"colors"*
            Can be *"colors"* or *"sizes"*. In case of *"colors"*, the legend
            handles will show the different colors of the collection. In case
            of "sizes", the legend will show the different sizes.
        num : int, None, "auto" (default), array-like, or `~.ticker.Locator`,
            optional
            Target number of elements to create.
            If None, use all unique elements of the mappable array. If an
            integer, target to use *num* elements in the normed range.
            If *"auto"*, try to determine which option better suits the nature
            of the data.
            The number of created elements may slightly deviate from *num* due
            to a `~.ticker.Locator` being used to find useful locations.
            If a list or array, use exactly those elements for the legend.
            Finally, a `~.ticker.Locator` can be provided.
        fmt : string, `~matplotlib.ticker.Formatter`, or None (default)
            The format or formatter to use for the labels. If a string must be
            a valid input for a `~.StrMethodFormatter`. If None (the default),
            use a `~.ScalarFormatter`.
        func : function, default *lambda x: x*
            Function to calculate the labels. Often the size (or color)
            argument to :meth:`~.Axes.scatter` will have been pre-processed
            by the user using a function *s = f(x)* to make the markers
            visible; e.g. *size = np.log10(x)*. Providing the inverse of this
            function here allows that pre-processing to be inverted, so that
            the legend labels have the correct values;
            e.g. *func = np.exp(x, 10)*.
        kwargs : further parameters
            Allowed kwargs are *color* and *size*. E.g. it may be useful to
            set the color of the markers if *prop="sizes"* is used; similarly
            to set the size of the markers if *prop="colors"* is used.
            Any further parameters are passed onto the `.Line2D` instance.
            This may be useful to e.g. specify a different *markeredgecolor* or
            *alpha* for the legend handles.

        Returns
        -------
        tuple (handles, labels)
            with *handles* being a list of `.Line2D`  objects
            and *labels* a matching list of strings.
        NFT)Z	useOffsetZuseMathTextrzfCollection without array used. Make sure to specify the values to be colormapped via the `c` argument.r|zlines.markersizer<65><00>color<6F>
kz?Valid values for `prop` are 'colors' or 'sizes'. You supplied 'z
' instead.r<><00>	rrg@r<00><00><00><00>
)ZnbinsZmin_n_ticksZsteps<70>
r
)Zmarkeredgewidthr<68>g<00>)rr<><00>ms<6D>marker<65>set_locs)+Z	get_arrayr)ZtickerZScalarFormatterrVr<>ZStrMethodFormatterZcreate_dummy_axis<69>warnings<67>warnr9<00>unique<75>popr*r<>r<>Z
set_bounds<EFBFBD>min<69>maxrh<00>Locator<6F>iterableZFixedLocator<6F>intZMaxNLocatorZtick_valuesZlinspaceZinterpr<70><00>get_linewidthsZ	get_alpharAr<>rGrFr<><00>iscloser<65>ZLine2DrPrxrWr<>)rC<00>prop<6F>num<75>fmt<6D>funcrMZhandles<65>labelsZhasarray<61>
ur|r<><00>valuesZlabel_valuesZarr<72>locZcondZxarr<72>kw<6B>valZlab<61>
h<>
lrNrNrO<00>legend_elementssz6































































zPathCollection.legend_elements)
N)
r<EFBFBD>r<>r<>r<>r	<00>dedent_interpdr rRrPr
rNrNrNrOr<>es



r<>c@s2eZ
dZejd	dd<04>
<01>
Zd
dd<06>
ZeZdd<08>Zd
S)<0B>PolyCollectionNTcKs.tj
|f
|<04>

|<00>|<02>

|<00>|
|<03>
d
|_dS)a<>
        *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
        TN)rr r<><00>	set_vertsr<73>)rC<00>vertsr<73><00>closedrMrNrNrOr s



zPolyCollection.__init__cCs
t|
t
jj<03>r |
<01>t<05>
<01>t
j<07>
}
|r<>g|_x<>|
D]<5D>}t	|<03>
r<>t|t
jj<03>rdt
j<02>
||d
d<02>g<02>
}n t
<01>|<03>
}t
<01>
||d
d<02>g<02>
}t
j|j
d
tjjd<03>}tjj|dd<04><tjj|d
<tjj|d<|j<08>t<0E>||<04><02>

q0|j<08>t<0E>|<03>
<01>

q0Wndd<07>|
D<00>
|_d|_dS)	z8This allows one to delay initialization of the vertices.r
r)
ZdtypeN<65><4E><EFBFBD><EFBFBD><EFBFBD>c
Ssg|]}
t<00>
|
<01>
<01>qSrN)riry)r\<00>xyrNrNrOr_/sz,PolyCollection.set_verts.<locals>.<listcomp>T)rVr9rdreZastyper>rfrgrBrh<00>concatenater<65>r<>r?riryZ	code_typeZLINETOZMOVETOZ	CLOSEPOLYrxr<>)rCr
r
r
r{rNrNrOr
s$














zPolyCollection.set_vertscCspt|
<01>
t|<02>
krt
d
<01>
<01>
g|_xFt|
|<02>D]8\}}t|<03>
rP|j<02>t<05>||<04><02>

q*|j<02>t<05>|<03>
<01>

q*Wd|_dS)z7This allows one to initialize vertices with path codes.zB'codes' must be a 1D list or array with the same length of 'verts'TN)rhr<>rBr<>rxriryr<>)rCr
r{r
ZcdsrNrNrO<00>set_verts_and_codes4s




z"PolyCollection.set_verts_and_codes)NT)
T)	r<>r<>r<>r	r
r r
rRr
rNrNrNrOr
<00>s



r
c@s*eZ
dZd
Zejdd<03><00>
Zedd<05><00>
ZdS)<07>BrokenBarHCollectionz]
    A collection of horizontal bars spanning *yrange* with a sequence of
    *xranges*.
    cs8|\<02>
}<04>
|<00><00><00>
fd
d<02>|
D<00>
}tj
||f|<03>

dS)z<>
        *xranges*
            sequence of (*xmin*, *xwidth*)

        *yrange*
            *ymin*, *ywidth*

        %(Collection)s
        c
s:g|]2\}
}|
<01>
f|
<01>f|
|<00>f|
|<00>
f|
<01>
fg<05>qSrNrN)r\ZxminZxwidth)<02>ymax<61>yminrNrOr_Tsz1BrokenBarHCollection.__init__.<locals>.<listcomp>N)r
r )rC<00>xrangesZyrangerMZywidthr
rN)r
r
rOr Gs



zBrokenBarHCollection.__init__c
Ksjg}xJt<00>
|<03>
D]<\}}|||<07>}t|<08>
s.q|<05>|d
|d|d
f<02>

qWt||
||
gf|<04>
}	|	S)a(

        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.
        r
r
)rZcontiguous_regionsrhrxr
)
r<EFBFBD>r
r
<00>whererMr
Zind0Zind1ZxsliceZ
collectionrNrNrO<00>
span_where[s





"

zBrokenBarHCollection.span_whereN)	r<>r<>r<>r<>r	r
r r<>r
rNrNrNrOr
Bs
r
c@sPeZ
dZd
ZejjZej	dZ
ejddd<06>
<01>
Z
dd<08>Zd	d
<EFBFBD>Zejdd<0C><00>
Zd
S)<0F>RegularPolyCollectionz6Draw a collection of regular polygons with *numsides*.g<00><>r
<00>
rcKsDtj
|f
|<04>

|<00>|<03>

|
|_|<00>|
<01>
g
|_||_|<00>t<08>	<09><00>

d
S)aX
        *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 :doc:`/gallery/event_handling/lasso_demo` for a
        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)
rr r<><00>	_numsides<65>_path_generatorrB<00>	_rotation<6F>
set_transformrrq)rCZnumsidesZrotationr<6E>rMrNrNrOr ws$





zRegularPolyCollection.__init__c


Cs|jS)
N)
r!
)
rCrNrNrO<00>get_numsides<65>s
z"RegularPolyCollection.get_numsidesc


Cs|jS)
N)
r#
)
rCrNrNrO<00>get_rotation<6F>s
z"RegularPolyCollection.get_rotationcs8<00><00><00>j
<01>jj<03>
<00>f
d
d<02><08>jD<00>
<01>_t<05><06>|
<01>
dS)Nc
s$g|]}
t<00>
|
<01>
<01><02>j<00>
<01><04><00>qSrN)rr<><00>rotater#
<00>
get_matrix)r\r<>)
rCrNrOr_<00>s
z.RegularPolyCollection.draw.<locals>.<listcomp>)r<>r<>r<>r<>rSrr<>)rCrrrN)
rCrOr<><00>s

zRegularPolyCollection.drawN)r
r 
)r<>r<>r<>r<>riryZunit_regular_polygonr"
r9<00>pir<69>r	r
r r%
r&
rr<>r<>rNrNrNrOr
qs



'r
c
@seZ
dZd
ZejjZdS)<03>StarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r<>r<>r<>r<>riryZunit_regular_starr"
rNrNrNrOr*
<00>s

r*
c
@seZ
dZd
ZejjZdS)<03>AsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r<>r<>r<>r<>riryZunit_regular_asteriskr"
rNrNrNrOr+
<00>s

r+
c@sReZ
dZd
ZdZddd	<09>
Zd
d<0B>ZeZeZdd
<0A>Z	dd<0F>Z
dd<11>Zdd<13>ZeZ
dS)<15>LineCollectiona

    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.
    TNrr<>rr<>c
Ks||d
krtj
d}|d
kr&tj
df
}|d
kr:tj
df
}t<02>|<03>
}tj|f
|||||||||	|
|d<05>|
<0A><02>

|<00>|
<01>

d
S)a<>	
        Parameters
        ----------
        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 : sequence, optional
            A sequence of RGBA tuples (e.g., arbitrary color
            strings, etc, not allowed).

        antialiaseds : sequence, optional
            A sequence of ones or zeros.

        linestyles : string, tuple, optional
            Either one of [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ], or
            a dash tuple. The dash tuple is::

                (offset, onoffseq)

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

        norm : Normalize, optional
            `~.colors.Normalize` instance.

        cmap : string or Colormap, optional
            Colormap name or `~.colors.Colormap` instance.

        pickradius : float, optional
            The tolerance in points for mouse clicks picking a line.
            Default is 5 pt.

        zorder : int, optional
           zorder of the LineCollection. Default is 2.

        facecolors : optional
           The facecolors of the LineCollection. Default is 'none'.
           Setting to a value other than 'none' will lead to a filled
           polygon being drawn between points on each line.

        Notes
        -----
        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.

        The use of :class:`~matplotlib.cm.ScalarMappable` is optional.
        If the :class:`~matplotlib.cm.ScalarMappable` array
        :attr:`~matplotlib.cm.ScalarMappable._A` is not None (i.e., 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.
        Nzlines.colorzlines.linewidthzlines.antialiased)rrrrr
rDrErFrGrHrL)r)r*r'r<>rr <00>set_segments)rC<00>segmentsrrr
rrDrErFrGrHrLrrMrNrNrOr <00>s,S



















zLineCollection.__init__cCsp|
dkrdSg}x0|
D](}t|t
jj<03>s4t
<01>|t<05>}|<02>|<03>

qW|jdk	rV|<00>|<02>
}d
d<02>|D<00>
|_	d|_
dS)Nc
Ssg|]}
t<00>
|
<01>
<01>qSrN)riry)r\Z_segrNrNrOr_Dsz/LineCollection.set_segments.<locals>.<listcomp>T)rVr9rdrer<>r>rxr<<00>_add_offsetsrBr<>)rCr.
Z	_segments<74>segrNrNrOr-
7s










zLineCollection.set_segmentsc
Cs>g}
x4|jD]*}d
d<02>|<02>
<01>D<00>
}t<02>|<03>
}|
<01>|<03>

qW|
S)z<>
        Returns
        -------
        segments : list
            List of segments in the LineCollection. Each list item contains an
            array of vertices.
        c
Ssg|]\}
}|
<01>qSrNrN)r\Zvertex<65>
_rNrNrOr_Usz/LineCollection.get_segments.<locals>.<listcomp>)rBZ
iter_segmentsr9r<>rx)rCr.
rrurNrNrO<00>get_segmentsJs



zLineCollection.get_segmentscCs<>|j}t
|
<01>
}|jd
}|dkrHx\t|<03>
D]}|
||||
|<q*Wn6x4t|<03>
D](}||}|
||||d<00>|
|<qRW|
S)Nr
r)r<rhr?<00>range)rCZsegsrDZNsegsZNoffs<66>
i<>iorNrNrOr/
[s








 
zLineCollection._add_offsetscCs|<00>|
<01>

d
|_
dS)a@

        Set the color(s) of the LineCollection.

        Parameters
        ----------
        c : color or list of colors
            Matplotlib color argument (all patches have same color), or a
            sequence or rgba tuples; if it is a sequence the patches will
            cycle through the sequence.
        TN)r-r<>)rCr<>rNrNrOr<>hs

zLineCollection.set_colorc


Cs|jS)
N)
r<>)
rCrNrNrO<00>	get_colorvs
zLineCollection.get_color)NNNrNNNNr<4E>rr<>)r<>r<>r<>r<>r<>r r-
r
rRr2
r/
r<>r6
<00>
get_colorsrNrNrNrOr,
<00>s*











b

r,
cs<>eZ
dZd
ZdZd%dd<08>
Zd	d
<EFBFBD>Zdd<0C>Zd
d<0E>ZeZ	Z
dd<10>Zdd<12>Zdd<14>Z
d&dd<16>
Zdd<18>Zdd<1A>Zdd<1C>Zdd<1E>Z<12>f
dd <20>Z<13>f
d!d"<22>Zd#d$<24>Z<15>ZS)'<27>EventCollectiona	

    A collection of discrete events.

    The events are given by a 1-dimensional array, usually the position of
    something along an axis, such as time or length.  They do not have an
    amplitude and are displayed as vertical or horizontal parallel bars.
    TNr
rrc	s
||d
||d
f<02>|
dks,t|
<01>
dkr2g}
n<EFBFBD>t
|
d<04>rP|
jdkrPtd<06>
<01>
n<>|dksp|<02><04>dksp|<02><04>dkr<>|
<01><05>
<00>f
d	d
<EFBFBD>|
D<00>
}
d|_n@|<02><04>dkr<>|
<01><05>
<00>f
d
d
<EFBFBD>|
D<00>
}
d|_ntjddg|d<0F>
t	j
||
f||||d<10>|	<09><02>

||_||_dS)a 
        Parameters
        ----------
        positions : 1D array-like object
            Each value is an event.

        orientation : {None, 'horizontal', 'vertical'}, optional
            The orientation of the **collection** (the event bars are along
            the orthogonal direction). Defaults to 'horizontal' if not
            specified or None.

        lineoffset : scalar, optional, default: 0
            The offset of the center of the markers from the origin, in the
            direction orthogonal to *orientation*.

        linelength : scalar, optional, default: 1
            The total height of the marker (i.e. the marker stretches from
            ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).

        linewidth : scalar or None, optional, default: None
            If it is None, defaults to its rcParams setting, in sequence form.

        color : color, sequence of colors or None, optional, default: None
            If it is None, defaults to its rcParams setting, in sequence form.

        linestyle : str or tuple, optional, default: 'solid'
            Valid strings are ['solid', 'dashed', 'dashdot', 'dotted',
            '-', '--', '-.', ':']. Dash tuples should be of the form::

                (offset, onoffseq),

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

        antialiased : {None, 1, 2}, optional
            If it is None, defaults to its rcParams setting, in sequence form.

        **kwargs : optional
            Other keyword arguments are line collection properties.  See
            :class:`~matplotlib.collections.LineCollection` for a list of
            the valid properties.

        Examples
        --------

        .. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py
        g@Nr
r<>rz:positions cannot be an array with more than one dimension.r<><00>
horizontalc

sg|]<16><00>f
dd
<01><08>
D<00>
<01>qS)c
sg|]}
<01>|
f<02>qSrNrN)r\<00>coord2)
<01>coord1rNrOr_<00>sz7EventCollection.__init__.<locals>.<listcomp>.<listcomp>rN)
r\)
<01>segment)
r;
rOr_<00>s
z,EventCollection.__init__.<locals>.<listcomp>T<>verticalc

sg|]<16><00>f
dd
<01><08>
D<00>
<01>qS)c
sg|]}
|
<01>f<02>qSrNrN)r\r:
)
r;
rNrOr_<00>sz7EventCollection.__init__.<locals>.<listcomp>.<listcomp>rN)
r\)
r<
)
r;
rOr_<00>s
F)
<01>orientation)rrr
r)
rhrWr<>r<>r<><00>sort<72>_is_horizontalrr<>r,
r <00>_linelength<74>_lineoffset)rC<00>	positionsr>
<00>
lineoffset<EFBFBD>
linelengthrr<>rrrMr.
rN)
r<
rOr <00>s8;



























zEventCollection.__init__c
s.|<00><00>}
|<00>
<01>rd
nd<02><00>f
dd<04>|<00><00>D<00>
S)zW
        return an array containing the floating-point values of the positions
        r
rc
sg|]}
|
d<00>f<00>qS)
r
rN)r\r<
)
<01>posrNrOr_<00>sz1EventCollection.get_positions.<locals>.<listcomp>)r2
<00>
is_horizontal)rCr.
rN)
rF
rO<00>
get_positions<6E>s

zEventCollection.get_positionscs<>|
d
kst|
d<02>r,t
|
<01>
dkr,|<00>g<00>

d
S|<00><03>}|<00><04>}||d||df<02>t<05>|
<01>
}
|
<01><07>
|<00><08>r<><72>f
dd<06>|
D<00>
}n<12>f
dd<06>|
D<00>
}|<00>|<04>

d
S)zH
        set the positions of the events to the specified value
        Nrhr
g@c

sg|]<16><00>f
dd
<01><08>
D<00>
<01>qS)c
sg|]}
<01>|
f<02>qSrNrN)r\r:
)
r;
rNrOr_<00>sz<EventCollection.set_positions.<locals>.<listcomp>.<listcomp>rN)
r\)
r<
)
r;
rOr_<00>s
z1EventCollection.set_positions.<locals>.<listcomp>c

sg|]<16><00>f
dd
<01><08>
D<00>
<01>qS)c
sg|]}
|
<01>f<02>qSrNrN)r\r:
)
r;
rNrOr_<00>sz<EventCollection.set_positions.<locals>.<listcomp>.<listcomp>rN)
r\)
r<
)
r;
rOr_<00>s
)	rWrhr-
<00>get_lineoffset<65>get_linelengthr9r=r?
rG
)rCrC
rD
rE
r.
rN)
r<
rO<00>
set_positions<6E>s 


















zEventCollection.set_positionscCsL|
d
kst|
d<02>r"t
|
<01>
dkr"d
S|<00><02>}t<03>|t<03>|
<01>
g<02>
}|<00>|<02>

d
S)zC
        add one or more events at the specified positions
        Nrhr
)rWrhrH
r9<00>hstackr=rK
)rC<00>positionrC
rNrNrO<00>
add_positionss




zEventCollection.add_positionsc


Cs|jS)
zN
        True if the eventcollection is horizontal, False if vertical
        )
r@
)
rCrNrNrOrG
szEventCollection.is_horizontalc

Cs|<00><00>rd
SdS)zf
        get the orientation of the event line, may be:
        [ 'horizontal' | 'vertical' ]
        r9
r=
)
rG
)
rCrNrNrO<00>get_orientationszEventCollection.get_orientationc
CsL|<00><00>}
x"t
|
<01>
D]\}}t<02>|<03>
|
|<qW|<00>|
<01>

|<00><05>|_d
|_dS)zu
        switch the orientation of the event line, either from vertical to
        horizontal or vice versus
        TN)r2
<00>	enumerater9Zfliplrr-
rG
r@
r<>)rCr.
r4
r<
rNrNrO<00>switch_orientations





z"EventCollection.switch_orientationcCsf|
d
ks |
<01><00>dks |
<01><00>dkr&d}n$|
<01><00>dkr8d}nt
jddg|
d<07>
||<00><03>krZd
S|<00><04>
d
S)z<>
        set the orientation of the event line
        [ 'horizontal' | 'vertical' | None ]
        defaults to 'horizontal' if not specified or None
        Nr<4E>r9
Tr=
F)
r>
)r<>rr<>rG
rQ
)rCr>
rG
rNrNrO<00>set_orientation's








zEventCollection.set_orientationc


Cs|jS)
zE
        get the length of the lines used to mark each event
        )
rA
)
rCrNrNrOrJ
9szEventCollection.get_linelengthcCsz|
|<00><00>krd
S|<00>
<01>}|<00><02>}|<00><03>r,dnd}x4|D],}||
d|d|f<||
d|d|f<q6W|<00>|<03>

|
|_d
S)zE
        set the length of the lines used to mark each event
        Nrr
g@)rJ
rI
r2
rG
r-
rA
)rCrE
rD
r.
rF
r<
rNrNrO<00>set_linelength?s










zEventCollection.set_linelengthc


Cs|jS)
zE
        get the offset of the lines used to mark each event
        )
rB
)
rCrNrNrOrI
NszEventCollection.get_lineoffsetcCsz|
|<00><00>krd
S|<00>
<01>}|<00><02>}|<00><03>r,dnd}x4|D],}|
|d|d|f<|
|d|d|f<q6W|<00>|<03>

|
|_d
S)zE
        set the offset of the lines used to mark each event
        Nrr
g@)rI
rJ
r2
rG
r-
rB
)rCrD
rE
r.
rF
r<
rNrNrO<00>set_lineoffsetTs










zEventCollection.set_lineoffsetc

stt
|<00><02><02>d
S)z3Get the width of the lines used to mark each event.r
)<03>superr8
r<>)
rC)
r<>rNrOr<>cszEventCollection.get_linewidthc

stt
|<00><02><02>S)
N)rU
r8
r<>)
rC)
r<>rNrOr

gs
zEventCollection.get_linewidthsc

Cs|<00><00>d
S)zD
        get the color of the lines used to mark each event
        r
)
r7
)
rCrNrNrOr6
jszEventCollection.get_color)Nr
rNNrN)
N)r<>r<>r<>r<>r<>r rH
rK
rN
Zextend_positionsZappend_positionsrG
rO
rQ
rR
rJ
rS
rI
rT
r<>r

r6
<00>
__classcell__rNrN)
r<>rOr8
|s0






T

r8
c@s(eZ
dZd
ZejdZejdd<04><00>
Z	dS)<06>CircleCollectionz-A collection of circles, drawn using splines.g<00><>cKs8tj
|f
|<02>

|<00>|
<01>

|<00>t<04><05><00>

tj<07><08>g
|_	d
S)zf
        *sizes*
            Gives the area of the circle in points^2

        %(Collection)s
        N)
rr r<>r$
rrqriry<00>unit_circlerB)rCr<>rMrNrNrOr vs



zCircleCollection.__init__N)
r<EFBFBD>r<>r<>r<>r9r)
r<>r	r
r rNrNrNrOrW
qs

rW
c@s6eZ
dZd
Zejd
dd<04>
<01>
Zdd<06>Zej	dd<08><00>
Z
d	S)<0B>EllipseCollectionz.A collection of ellipses, drawn using splines.<2E>pointscKsxtj
|f
|<05>

d
t<02>|
<01>
<01><04>|_d
t<02>|<02>
<01><04>|_t<02>|<03>
<01><04>|_||_	|<00>
t<0B><0C><00>

t<02>
d<02>
|_tj<10><11>g
|_dS)a@
        Parameters
        ----------
        widths : array-like
            The lengths of the first axes (e.g., major axis lengths).

        heights : array-like
            The lengths of second axes.

        angles : array-like
            The angles of the first axes, degrees CCW from the x-axis.

        units : {'points', 'inches', 'dots', 'width', 'height', 'x', 'y', 'xy'}

            The 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.

        Other Parameters
        ----------------
        **kwargs
            Additional kwargs inherited from the base :class:`Collection`.

        %(Collection)s
        g<00>?)r
rrN)rr r9r<>Zravel<65>_widths<68>_heightsZdeg2rad<61>_angles<65>_unitsr$
rrqr<>rSriryrX
rB)rC<00>widths<68>heightsZanglesZunitsrMrNrNrOr <00>s 






zEllipseCollection.__init__c

Cs<>
|j}
|j
}|jd
krd}n<>|jdkr8|
jj|
jj}n<>|jdkrT|
jj|
jj}nn|jdkrf|j}n\|jdkr||jd}nF|jdkr<>|
jj}n2|jd	kr<>|
jj}n|jd
kr<>d}ntd|j<00>
<01>
t	<09>
t|j<0C>
d
d
f<03>
|_
|j|}|j|}t	<09>|j<10>
}t	<09>|j<10>
}|||j
dd<0E>ddf<|||j
dd<0E>ddf<|||j
dd<0E>ddf<|||j
dd<0E>ddf<d|j
dd<0E>ddf<tj}|jd
k<02>
r<>|
j<14><15><00><16><00><17>}	d|	dd<10>dd<0E>f<|<00>||	<09>
<01>

dS)z0Calculate transforms immediately before drawing.r
rr<>r<>ZinchesrZ
gR@r<>r<><00>dotsg<00>?zunrecognized units: %srNr
r)rXr<>r^
Zbboxr<78>ZviewLimr<6D>r<>r<>r9r:rhr[
rSr\
<00>sinr]
<00>cosrr<>rmrbr(
<00>copyr$
)
rCZaxZfig<69>scr_
r`
Z	sin_angleZ	cos_angleZ_affine<6E>
mrNrNrO<00>_set_transforms<6D>sD








































z!EllipseCollection._set_transformscCs|<00><00>
t
<01>||
<01>
dS)
N)rg
rr<>)rCrrrNrNrOr<><00>s
zEllipseCollection.drawN)
rZ
)r<>r<>r<>r<>r	r
r rg
rr<>r<>rNrNrNrOrY
<00>s


(*rY
c@s"eZ
dZd
Zddd<04>
Zdd<06>ZdS)	<09>PatchCollectionz<6E>
    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.
    Fcs<>|rjd
d<02><00><00>f
dd<04>|
D<00>
|d<dd<04>|
D<00>
|d<dd<04>|
D<00>
|d	<d
d<04>|
D<00>
|d<dd<04>|
D<00>
|d
<tj
|f
|<03>

|<00>|
<01>

dS)a<>
        *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 (i.e., 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|<00><00>r|<00>
<01>Sd
d
d
d
gS)Nr
)r<>r<>)
<01>patchrNrNrO<00>determine_facecolors


z5PatchCollection.__init__.<locals>.determine_facecolorc
sg|]}
<01>|
<01>
<01>qSrNrN)r\r])
rj
rNrOr_sz,PatchCollection.__init__.<locals>.<listcomp>rc
Ssg|]}
|
<01><00><00>qSrN)
r<>)r\r]rNrNrOr_src
Ssg|]}
|
<01><00><00>qSrN)
r<>)r\r]rNrNrOr_	src
Ssg|]}
|
<01><00><00>qSrN)
r<>)r\r]rNrNrOr_
src
Ssg|]}
|
<01><00><00>qSrN)
Zget_antialiased)r\r]rNrNrOr_sr
N)rr rR)rC<00>patchesZmatch_originalrMrN)
rj
rOr <00>s




zPatchCollection.__init__cCsd
d<02>|
D<00>
}||_dS)Nc
Ssg|]}
|
<01><00><00>
|
<01><02><00>
<01>qSrN)r`Ztransform_path<74>get_path)r\r]rNrNrOr_s
z-PatchCollection.set_paths.<locals>.<listcomp>)
rB)rCrk
rnrNrNrOrRs


zPatchCollection.set_pathsN)
F)r<>r<>r<>r<>r rRrNrNrNrOrh
<00>s	
&rh
c@sBeZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zedd	<09><00>
Ze	j
d
d<0B><00>
ZdS)
<0A>TriMeshz<68>
    Class for the efficient drawing of a triangular mesh using Gouraud shading.

    A triangular mesh is a `~matplotlib.tri.Triangulation` object.
    cKs^tj
|f
|<02>

|
|_d
|_d|_tj<06><07>|_t	<09>
|
j<0B>dd<04>|
j
<0A>dd<04>f<02>
}|j<08>|<03>

dS)N<>gouraudTr
r)rr <00>_triangulation<6F>_shadingr&rrk<00>unit<69>_bboxr9rL
r<><00>reshaper<65><00>update_from_data_xy)rCZ
triangulationrMr
rNrNrOr s





zTriMesh.__init__c

Cs|jdkr|<00>
<01>
|jS)
N)rBrR)
rCrNrNrOrP+s



zTriMesh.get_pathsc

Cs|<00>|j
<01>
|_dS)
N)<03>convert_mesh_to_pathsro
rB)
rCrNrNrOrR0s
zTriMesh.set_pathsc
Cs4|<00><00>}
t
j|j|
|j|
fd
d<02>}dd<04>|D<00>
S)z<>
        Converts a given mesh into a sequence of `~.Path` objects.

        This function is primarily of use to implementers of backends that do
        not directly support meshes.
        r
)
<01>axisc
Ssg|]}
t<00>
|
<01>
<01>qSrN)riry)r\r<>rNrNrOr_=sz1TriMesh.convert_mesh_to_paths.<locals>.<listcomp>)<05>get_masked_trianglesr9<00>stackr<6B>r<>)<03>tri<72>	trianglesr
rNrNrOru
3s

zTriMesh.convert_mesh_to_pathscCs<>|<00><00>sdS|
<01>
|jj<03>

|<00><04>}|j}|<03><06>}tj|j	||j
|fd
d<02>}|<00><0B>
|j|}|
<01>
<0A>}|<00>|<07>

|<07>|<00><10>d<00>

|
<01>||||<02><12><00>
|<07><13>
|
<01>|jj<03>

dS)Nr
)
rv
r
)r<>r<>r<>r<>r`ro
rw
r9rx
r<>r<>r<>r<>r<>r<>r.r<><00>draw_gouraud_trianglesrjr<>r<>)rCrrr^ry
rz
r
rr<>rNrNrOr<>?s











zTriMesh.drawN)r<>r<>r<>r<>r rPrRr<>ru
rr<>r<>rNrNrNrOrm
s
rm
c@sTeZ
dZd
Zddd<05>
Zdd<07>Zdd	<09>Zd
d<0B>Zedd
<0A><00>
Z	dd<0F>Z
ejdd<11><00>
Z
dS)<14>QuadMesha<68>
    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'
    T<>flatcKsztj
|f
|<06>

|
|_||_t<04>|t<06><02>|d
|
d
df<03>
|_||_	||_
tj<0C>
<0A>|_|j<0E>|<03>|
d
|d
df<02>
<01>

dS)Nrr)rr <00>
_meshWidth<EFBFBD>_meshHeightr9r<>r>rs
<00>_coordinates<65>_antialiasedrp
rrkrq
rr
rt
)rC<00>	meshWidth<74>
meshHeight<EFBFBD>coordinatesrZshadingrMrNrNrOr vs







zQuadMesh.__init__c

Cs|jdkr|<00>
<01>
|jS)
N)rBrR)
rCrNrNrOrP<00>s



zQuadMesh.get_pathsc

Cs |<00>|j
|j|j<03>|_d
|_dS)NT)ru
r~
r
r<>
rBr<>)
rCrNrNrOrR<00>s


zQuadMesh.set_pathscCs|<00><00>|
<00>
|j<02>
S)
N)r`Ztransform_bboxrr
)rCrmrNrNrOrp<00>s
zQuadMesh.get_datalimc	Cs<>t|t
jj<03>r|j}n|}t
j|d
d<02>d
d<02>f|d
d<02>dd
<01>f|dd
<01>dd
<01>f|dd
<01>d
d<02>f|d
d<02>d
d<02>ffdd<05>}|<04>||
ddf<03>
}dd<08>|D<00>
S)	z<>
        Converts a given mesh into a sequence of `~.Path` objects.

        This function is primarily of use to implementers of backends that do
        not directly support quadmeshes.
        Nr
rr)
rv
r<>c
Ssg|]}
t<00>
|
<01>
<01>qSrN)riry)r\r<>rNrNrOr_<00>sz2QuadMesh.convert_mesh_to_paths.<locals>.<listcomp>)rVr9rdrer<>r
rs
)r<>
r<>
r<>
r<>rZ
rNrNrOru
<00>s









zQuadMesh.convert_mesh_to_pathsc
Cs<>
t|t
jj<03>r|j}n|}|d
d<02>d
d<02>f}|d
d<02>dd
<01>f}|dd
<01>dd
<01>f}|dd
<01>d
d<02>f}||||d}	t
j|||	|||	|||	|||	fdd<06>}
|
<EFBFBD>|
|dddf<03>
}
|<00><07><00>|d|
ddf<03>
}|d
d<02>d
d<02>f}|d
d<02>dd
<01>f}
|dd
<01>dd
<01>f}|dd
<01>d
d<02>f}||
||d}t
j||
||
||||||||fdd<06>}|<11>|
|dddf<03>
}|
|fS)	z<>
        Converts a given mesh into a sequence of triangles, each point
        with its own color.  This is useful for experiments using
        `draw_gouraud_triangle`.
        Nr
rg@r)
rv
<00>r)rVr9rdrer<>r
rs
r<>)rCr<>
r<>
r<>
r]Zp_aZp_bZp_cZp_dZp_centerrz
r<>Zc_aZc_b<5F>c_c<5F>c_dZc_centerrrNrNrO<00>convert_mesh_to_triangles<65>s:





















z"QuadMesh.convert_mesh_to_trianglesc
Cs<>
|<00><00>sdS|
<01>
|jj|<00><04><00>
|<00><05>}|<00><06>}|j}|<00><08>r<>t	|j<07>
r<>|<00>
|jdd<00>d
f<00>
}|<00>|jdd<00>df<00>
}t<0C>
||g<02>
}|<00><0E>
|js<>|j<10>d<03>
}|<02>|<07>
}|<07>|jj<13>
}t<14><15>}n|j}|js<>|<03>|<04>
}|<03><17>}|
<01><18>}|<00>|<08>

|<08>|<00><1B>d
<00>

|jdk<02>
r<|<00>|j|j|<07>\}	}
|
<01> ||	|
|<02>!<21><00>
n.|
<01>"||<02>!<21>|j|j||||<00>#<23>|j$|<00>%<25><00>

|<08>&<26>
|
<01>'|jj<03>

d|_(dS)Nr
r)r
rrn
F))r<>r<>r<>r<>r<>r`rZr;rtrhrvrwr9rzr<>rar<>
rs
r^r?rrqrcrbr<>r<>r.r<>rp
r<>
r~
r
r{
rjZdraw_quad_meshr<68>r<>
Zget_edgecolorsr<73>r<>r<>)rCrrr^rErDr}r~r<>
r<>rz
rrNrNrOr<><00>sH































z
QuadMesh.drawN)Tr}
)r<>r<>r<>r<>r rPrRrpr<>ru
r<>
rr<>r<>rNrNrNrOr|
Ws
*r|
)
r|
rm
r
r
r
r<>r*
rh
rW
r)
r,
)-r<>r<><00>numbersrZnumpyr9Z
matplotlibr)r<>rrrrrr'r	r
r<>rrirr<>Z_define_aliasesrr!rZinterpdrAr<>r<>r
r
r
r*
r+
r,
r8
rW
rY
rh
rm
r|
ZkwdocZpatchstrr<72>rNrNrNrO<00><module>
sV


,




0C/AAv\7@,