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

955 lines
63 KiB
Plaintext
Raw Normal View History

2019-11-17 12:44:16 +01:00
B
U<>]<5D><00>@s<>dZddlZddlmZddlZddlZddlm Z m
Z
m Z m Z m ZmZmZmZmZddlZe <0B>ddgdd gd
d gd 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<>eZdZdZe<04>d<02>Ze<07><08>Z e<04>
d<03>Z dZ 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>dg|_dg|_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
)NNrTz hatch.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__cCs|jS)N)rB)rCrNrNrO<00> get_paths<68>szCollection.get_pathscCst<00>dS)N)<01>NotImplementedError)rCrNrNrO<00> set_paths<68>szCollection.set_pathscCs|jS)N)<01> _transforms)rCrNrNrO<00>get_transforms<6D>szCollection.get_transformscCs,|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>fdd<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)Ncsg|]}<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>df|dd<00>df}}|<00>|<06>}|<00>|<07>}|<03>t <09>
t <0B> ||g<02>|j <0A><02>q4W|jr<>|<00>|dd<00>df<00>}|<00>|dd<00>df<00>}t <0B> ||g<02>}<02>js<><73>fdd<04>|D<00>}<03><00><10><00>|j<0F>s|<01>|<02>}|<01><10>}t|t jj<14><02>r,|<02>t j<16>}<02>|||fS)Nrrcsg|]}<01><00>|<01><01>qSrN)r[)r\r )r^rNrOr_<00>sz.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)rCrErDrnr ru<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>|j r<>|<06> |j <0B>y|<06> |j<0E>Wn"tk
r<EFBFBD>tjddd<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<>|jdgk<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>Affine2DZ get_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
||_dS)z<>
Set the pick radius used for containment tests.
Parameters
----------
d : float
Pick radius, in points.
N)<01> _pickradius)rC<00>prrNrNrOr1Os zCollection.set_pickradiuscCs|jS)N)r<>)rCrNrNrO<00>get_pickradiusZszCollection.get_pickradiusc Cs<>|jdk 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|dk r |ndg|_d|_dS)zP
Parameters
----------
urls : List[str] or None
NT)r<>r<>)rCrJrNrNrOr2zszCollection.set_urlscCs|jS)N)r<>)rCrNrNrO<00>get_urls<6C>szCollection.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_hatchcCs|jS)z$Return the current hatching pattern.)r<>)rCrNrNrOr<><00>szCollection.get_hatchcCsHt<00>|t<02>}|jdkr&|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_offsetscCs|jdkr|jS|jSdS)z&Return the offsets for the collection.N)r<r;)rCrNrNrO<00> get_offsets<74>s
zCollection.get_offsetscCs"tjddg|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_positioncCs|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|dkr$tjd}|dkr$tjd}t<02>t<02>|<01><01>|_|<00>|j|j<07>\|_|_ d|_
dS)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
rZdd<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.
cSsg|]}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 |dkr||_n td|<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_capstylecCs|jS)N)r6)rCrNrNrO<00> get_capstyle4szCollection.get_capstylecCs |dkr||_n td|<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_joinstylecCs|jS)N)r8)rCrNrNrO<00> get_joinstyleEszCollection.get_joinstylecCsztjdr||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_modecSs"g|]\\}}}t<00>|||<03><03>qSrN)r<>Z _scale_dashes)r\<00>o<>drrNrNrOr_isz*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|dkrtjd}t<02>t<02>|t<05><02>|_d|_dS)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>dS)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^|dkrtjd}d|_y|<01><03>dkr,d|_Wntk
rBYnXt<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>dS)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_facecolorcCs|jS)N)r<>)rCrNrNrOr<><00>szCollection.get_facecolorcCs t<00>|jd<01>r|<00><03>S|jSdS)N<>face)rZ
_str_equal<EFBFBD> _edgecolorsr<73>)rCrNrNrOr<><00>szCollection.get_edgecolorcCs<>d}|dkr6tjds"|jr"|jr.tjd}nd}d}d|_y|<01><05>dkrPd|_Wntk
rfYnXy|<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>dS)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|dk r2y t|<01>Wntk
r0td<02><01>YnXd|jd<tj<04>||<01>|<00>|j<07>|<00>|j <09>dS)z<>
Set the alpha transparencies of the collection.
Parameters
----------
alpha : float or None
Nzalpha must be a float or NoneT<65>array)
r><00> TypeErrorZ update_dictrr<00> set_alphar<61>r<>r<>r<>)rC<00>alpharNrNrOr<><00>s 
 zCollection.set_alphacCs|jS)N)r%)rCrNrNrO<00> get_linewidth<74>szCollection.get_linewidthcCs|jS)N)r#)rCrNrNrO<00> get_linestyle<6C>szCollection.get_linestylecCsl|jdkrdS|jjdkr"td<03><01>|<00>d<04>s0dS|jrJ|<00>|j|j<06>|_n|jrb|<00>|j|j<06>|_ d|_
dS)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_scalarmappablecCs|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<>szCollection.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@s4eZdZdZdZdd<04>Zd dd<07>Zejdd <09><00>Z d
S) <0C>_CollectionWithSizeszA
Base class for collections that have an array of sizes.
g<00>?cCs|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<>|dkr"t<00>g<00>|_t<00>d<02>|_nzt<00>|<01>|_t<00>t|j<02>ddf<03>|_t<00>|j<02>|d|j }||jdd<01>ddf<||jdd<01>ddf<d|jdd<01>ddf<d |_
dS)
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)rrrrgR@rrg<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<>_sz_CollectionWithSizes.drawN)r<>)
r<EFBFBD>r<>r<>r<>r<>r<>r<>rr<>r<>rNrNrNrOr<>5s

r<>c@sFeZdZdZejddd<04><01>Zdd<06>Zdd<08>Zd d
dd d <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<>)rCrnrNrNrOrRxszPathCollection.set_pathscCs|jS)N)rB)rCrNrNrOrP|szPathCollection.get_pathsr<00>autocCs|S)NrN)r<>rNrNrO<00><lambda><3E><00>zPathCollection.<lambda>c Ks<>g}g}|<00><00>dk }|dkr.tjjddd<04>}nt|t<05>rDtj<02>|<03>}|<03><07>|dkr<>|sjt<08> d<06>||fSt
<EFBFBD> |<00><00><00>} |<05> dtj 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>|kr<>d}|dk<08>r| } || <0C>} n<>|dk<02>r$|<00><00>}n|d k<02>r6|<00><0E>}t|tjj<14><02>rL|}nHt
<EFBFBD>|<02><01>rftj<02>|<02>}n.t|<02>}tjj||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&dgdgfd| |
|<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 useOffsetZ useMathTextrzfCollection 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>
)ZnbinsZ min_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>intZ MaxNLocatorZ tick_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 rRrPrrNrNrNrOr<>es r<>c@s2eZdZejd dd<04><01>Zd
dd<06>ZeZdd<08>ZdS) <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|tjj<03>r |<01>t<05><01>tj<07>}|r<>g|_x<>|D]<5D>}t |<03>r<>t|tjj<03>rdtj<02>
||dd<02>g<02>}n t<01> |<03>}t<01>
||dd<02>g<02>}tj |j dtjjd<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.rr)ZdtypeN<65><4E><EFBFBD><EFBFBD><EFBFBD>cSsg|]}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<>)rCrrrr{rNrNrOrs$

  zPolyCollection.set_vertscCspt|<01>t|<02>krtd<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<>)rCrr{rZcdsrNrNrO<00>set_verts_and_codes4sz"PolyCollection.set_verts_and_codes)NT)T) r<>r<>r<>r rr rrRrrNrNrNrOr<00>s
 
rc@s*eZdZdZejdd<03><00>Zedd<05><00>ZdS)<07>BrokenBarHCollectionz]
A collection of horizontal bars spanning *yrange* with a sequence of
*xranges*.
c s8|\<02>}<04>|<00><00><00>fdd<02>|D<00>}tj||f|<03>dS)z<>
*xranges*
sequence of (*xmin*, *xwidth*)
*yrange*
*ymin*, *ywidth*
%(Collection)s
cs: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)rr )rC<00>xrangesZyrangerMZywidthrrN)rrrOr Gs
 zBrokenBarHCollection.__init__c
Ksjg}xJt<00>|<03>D]<\}}|||<07>}t|<08>s.q|<05>|d|d|df<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.
rr)rZcontiguous_regionsrhrxr)
r<EFBFBD>rr<00>whererMrZind0Zind1ZxsliceZ
collectionrNrNrO<00>
span_where[s
 "zBrokenBarHCollection.span_whereN) r<>r<>r<>r<>r rr r<>rrNrNrNrOrBsrc@sPeZdZdZejjZej dZ
e j ddd<06><01>Z dd<08>Zd d
<EFBFBD>Zejd d <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>dS)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__cCs|jS)N)r!)rCrNrNrO<00> get_numsides<65>sz"RegularPolyCollection.get_numsidescCs|jS)N)r#)rCrNrNrO<00> get_rotation<6F>sz"RegularPolyCollection.get_rotationcs8<00><00><00>j<01>jj<03><00>fdd<02><08>jD<00><01>_t<05><06>|<01>dS)Ncs$g|]}t<00>|<01><01><02>j <00><01><04><00>qSrN)r r<><00>rotater#<00>
get_matrix)r\r<>)rCrNrOr_<00>sz.RegularPolyCollection.draw.<locals>.<listcomp>)r<>r<>r<>r<>rSrr<>)rCrrrN)rCrOr<><00>s
 zRegularPolyCollection.drawN)rr )r<>r<>r<>r<>riryZunit_regular_polygonr"r9<00>pir<69>r rr r%r&rr<>r<>rNrNrNrOrqs
 'rc@seZdZdZejjZdS)<03>StarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r<>r<>r<>r<>riryZunit_regular_starr"rNrNrNrOr*<00>sr*c@seZdZdZejjZdS)<03>AsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r<>r<>r<>r<>riryZunit_regular_asteriskr"rNrNrNrOr+<00>sr+c @sReZdZdZdZddd <09>Zd
d <0B>ZeZeZd d <0A>Z dd<0F>Z
dd<11>Z dd<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||dkrtjd}|dkr&tjdf}|dkr:tjdf}t<02>|<03>}tj|f|| ||||||| |
| d<05> | <0A><02>|<00>|<01>dS)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.
Nz lines.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|tjj<03>s4t<01>|t<05>}|<02>|<03>qW|jdk rV|<00>|<02>}dd<02>|D<00>|_ d|_
dS)NcSsg|]}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_segmentscCs>g}x4|jD]*}dd<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.
cSsg|] \}}|<01>qSrNrN)r\Zvertex<65>_rNrNrOr_Usz/LineCollection.get_segments.<locals>.<listcomp>)rBZ iter_segmentsr9r<>rx)rCr.r rurNrNrO<00> get_segmentsJs  
zLineCollection.get_segmentscCs<>|j}t|<01>}|jd}|dkrHx\t|<03>D]}||||||<q*Wn6x4t|<03>D](}||}|||||d<00>||<qRW|S)Nrr)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_colorcCs|jS)N)r<>)rCrNrNrO<00> get_colorvszLineCollection.get_color) NNNrNNNNr<4E>rr<>)r<>r<>r<>r<>r<>r r-rrRr2r/r<>r6<00>
get_colorsrNrNrNrOr,<00>s*

b r,cs<>eZdZdZdZd%dd<08>Zd d
<EFBFBD>Zd d <0C>Zd d<0E>ZeZ Z
dd<10>Z dd<12>Z dd<14>Z d&dd<16>Zdd<18>Zdd<1A>Zdd<1C>Zdd<1E>Z<12>fdd <20>Z<13>fd!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.
TNrrrc  s||d||df<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>fd d
<EFBFBD>|D<00>}
d |_n@|<02><04>d kr<>|<01><05><00>fd 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@Nrr<>rz:positions cannot be an array with more than one dimension.r<><00>
horizontalcsg|]<16><00>fdd<01><08>D<00><01>qS)csg|] }<01>|f<02>qSrNrN)r\<00>coord2)<01>coord1rNrOr_<00>sz7EventCollection.__init__.<locals>.<listcomp>.<listcomp>rN)r\)<01>segment)r;rOr_<00>sz,EventCollection.__init__.<locals>.<listcomp>T<>verticalcsg|]<16><00>fdd<01><08>D<00><01>qS)csg|] }|<01>f<02>qSrNrN)r\r:)r;rNrOr_<00>sz7EventCollection.__init__.<locals>.<listcomp>.<listcomp>rN)r\)r<)r;rOr_<00>sF)<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__cs.|<00><00>}|<00><01>rdnd<02><00>fdd<04>|<00><00>D<00>S)zW
return an array containing the floating-point values of the positions
rrcsg|]}|d<00>f<00>qS)rrN)r\r<)<01>posrNrOr_<00>sz1EventCollection.get_positions.<locals>.<listcomp>)r2<00> is_horizontal)rCr.rN)rFrO<00> get_positions<6E>szEventCollection.get_positionscs<>|dkst|d<02>r,t|<01>dkr,|<00>g<00>dS|<00><03>}|<00><04>}||d||df<02>t<05>|<01>}|<01><07>|<00><08>r<><72>fdd<06>|D<00>}n<12>fdd<06>|D<00>}|<00>|<04>dS)zH
set the positions of the events to the specified value
Nrhrg@csg|]<16><00>fdd<01><08>D<00><01>qS)csg|] }<01>|f<02>qSrNrN)r\r:)r;rNrOr_<00>sz<EventCollection.set_positions.<locals>.<listcomp>.<listcomp>rN)r\)r<)r;rOr_<00>sz1EventCollection.set_positions.<locals>.<listcomp>csg|]<16><00>fdd<01><08>D<00><01>qS)csg|] }|<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)rCrCrDrEr.rN)r<rO<00> set_positions<6E>s  





zEventCollection.set_positionscCsL|dkst|d<02>r"t|<01>dkr"dS|<00><02>}t<03>|t<03>|<01>g<02>}|<00>|<02>dS)zC
add one or more events at the specified positions
Nrhr)rWrhrHr9<00>hstackr=rK)rC<00>positionrCrNrNrO<00> add_positionss  zEventCollection.add_positionscCs|jS)zN
True if the eventcollection is horizontal, False if vertical
)r@)rCrNrNrOrGszEventCollection.is_horizontalcCs|<00><00>r dSdS)zf
get the orientation of the event line, may be:
[ 'horizontal' | 'vertical' ]
r9r=)rG)rCrNrNrO<00>get_orientationszEventCollection.get_orientationcCsL|<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-rGr@r<>)rCr.r4r<rNrNrO<00>switch_orientations 
 z"EventCollection.switch_orientationcCsf|dks |<01><00>dks |<01><00>dkr&d}n$|<01><00>dkr8d}ntjddg|d<07>||<00><03>krZdS|<00><04>dS)z<>
set the orientation of the event line
[ 'horizontal' | 'vertical' | None ]
defaults to 'horizontal' if not specified or None
Nr<4E>r9Tr=F)r>)r<>rr<>rGrQ)rCr>rGrNrNrO<00>set_orientation's  
 zEventCollection.set_orientationcCs|jS)zE
get the length of the lines used to mark each event
)rA)rCrNrNrOrJ9szEventCollection.get_linelengthcCsz||<00><00>krdS|<00><01>}|<00><02>}|<00><03>r,dnd}x4|D],}||d|d|f<||d|d|f<q6W|<00>|<03>||_dS)zE
set the length of the lines used to mark each event
Nrrg@)rJrIr2rGr-rA)rCrErDr.rFr<rNrNrO<00>set_linelength?s 

zEventCollection.set_linelengthcCs|jS)zE
get the offset of the lines used to mark each event
)rB)rCrNrNrOrINszEventCollection.get_lineoffsetcCsz||<00><00>krdS|<00><01>}|<00><02>}|<00><03>r,dnd}x4|D],}||d|d|f<||d|d|f<q6W|<00>|<03>||_dS)zE
set the offset of the lines used to mark each event
Nrrg@)rIrJr2rGr-rB)rCrDrEr.rFr<rNrNrO<00>set_lineoffsetTs 

zEventCollection.set_lineoffsetcstt|<00><02><02>dS)z3Get the width of the lines used to mark each event.r)<03>superr8r<>)rC)r<>rNrOr<>cszEventCollection.get_linewidthcstt|<00><02><02>S)N)rUr8r<>)rC)r<>rNrOrgszEventCollection.get_linewidthscCs |<00><00>dS)zD
get the color of the lines used to mark each event
r)r7)rCrNrNrOr6jszEventCollection.get_color)NrrNNrN)N)r<>r<>r<>r<>r<>r rHrKrNZextend_positionsZappend_positionsrGrOrQrRrJrSrIrTr<>rr6<00> __classcell__rNrN)r<>rOr8|s0
T

  r8c@s(eZdZdZejdZejdd<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|_ dS)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 rr rNrNrNrOrWqs
rWc@s6eZdZdZejd
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>dt<02>|<01><01><04>|_dt<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>?)rrrN)rr r9r<>Zravel<65>_widths<68>_heightsZdeg2rad<61>_angles<65>_unitsr$r rqr<>rSriryrXrB)rC<00>widths<68>heightsZanglesZunitsrMrNrNrOr <00>s  zEllipseCollection.__init__c
Cs<>|j}|j}|jdkrd}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}|jdk<02>r<>|j<14><15><00><16><00><17>} d| dd<10>dd<0E>f<|<00>|| <09><01>dS)z0Calculate transforms immediately before drawing.rrr<>r<>ZinchesrZgR@r<>r<><00>dotsg<00>?zunrecognized units: %srNrr)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)rgrr<>)rCrrrNrNrOr<><00>szEllipseCollection.drawN)rZ) r<>r<>r<>r<>r rr rgrr<>r<>rNrNrNrOrY<00>s
 (*rYc@s"eZdZdZddd<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.
Fc s<>|rjdd<02><00><00>fdd<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.
cSs|<00><00>r|<00><01>SddddgS)Nr)r<>r<>)<01>patchrNrNrO<00>determine_facecolorsz5PatchCollection.__init__.<locals>.determine_facecolorcsg|] }<01>|<01><01>qSrNrN)r\r])rjrNrOr_sz,PatchCollection.__init__.<locals>.<listcomp>rcSsg|] }|<01><00><00>qSrN)r<>)r\r]rNrNrOr_srcSsg|] }|<01><00><00>qSrN)r<>)r\r]rNrNrOr_ srcSsg|] }|<01><00><00>qSrN)r<>)r\r]rNrNrOr_
srcSsg|] }|<01><00><00>qSrN)Zget_antialiased)r\r]rNrNrOr_ sr N)rr rR)rC<00>patchesZmatch_originalrMrN)rjrOr <00>szPatchCollection.__init__cCsdd<02>|D<00>}||_dS)NcSsg|]}|<01><00><00>|<01><02><00><01>qSrN)r`Ztransform_path<74>get_path)r\r]rNrNrOr_sz-PatchCollection.set_paths.<locals>.<listcomp>)rB)rCrkrnrNrNrOrRszPatchCollection.set_pathsN)F)r<>r<>r<>r<>r rRrNrNrNrOrh<00>s 
&rhc@sBeZdZdZdd<03>Zdd<05>Zdd<07>Zedd <09><00>Ze j
d
d <0B><00>Z d 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<>gouraudTrr)rr <00>_triangulation<6F>_shadingr&r rk<00>unit<69>_bboxr9rLr<><00>reshaper<65><00>update_from_data_xy)rCZ triangulationrMrrNrNrOr s zTriMesh.__init__cCs|jdkr|<00><01>|jS)N)rBrR)rCrNrNrOrP+s
zTriMesh.get_pathscCs|<00>|j<01>|_dS)N)<03>convert_mesh_to_pathsrorB)rCrNrNrOrR0szTriMesh.set_pathscCs4|<00><00>}tj|j||j|fdd<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>axiscSsg|]}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> trianglesrrNrNrOru3szTriMesh.convert_mesh_to_pathscCs<>|<00><00>s dS|<01>|jj<03>|<00><04>}|j}|<03><06>}tj|j ||j
|fdd<02>}|<00> <0B>|j |}|<01> <0A>}|<00>|<07>|<07>|<00><10>d<00>|<01>||||<02><12><00>|<07><13>|<01>|jj<03>dS)Nr)rvr)r<>r<>r<>r<>r`rorwr9rxr<>r<>r<>r<>r<>r<>r.r<><00>draw_gouraud_trianglesrjr<>r<>)rCrrr^ryrzrrr<>rNrNrOr<>?s

z TriMesh.drawN) r<>r<>r<>r<>r rPrRr<>rurr<>r<>rNrNrNrOrms  rmc@sTeZdZdZddd<05>Zdd<07>Zdd <09>Zd
d <0B>Zed d <0A><00>Z dd<0F>Z
e j 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|ddf<03>|_||_ ||_
t j <0C> <0A>|_|j<0E>|<03>|d|ddf<02><01>dS)Nrr)rr <00>
_meshWidth<EFBFBD> _meshHeightr9r<>r>rs<00> _coordinates<65> _antialiasedrpr rkrqrrrt)rC<00> meshWidth<74>
meshHeight<EFBFBD> coordinatesrZshadingrMrNrNrOr vs  
zQuadMesh.__init__cCs|jdkr|<00><01>|jS)N)rBrR)rCrNrNrOrP<00>s
zQuadMesh.get_pathscCs |<00>|j|j|j<03>|_d|_dS)NT)rur~rr<>rBr<>)rCrNrNrOrR<00>szQuadMesh.set_pathscCs|<00><00>|<00>|j<02>S)N)r`Ztransform_bboxrr)rCrmrNrNrOrp<00>szQuadMesh.get_datalimc Cs<>t|tjj<03>r|j}n|}tj|dd<02>dd<02>f|dd<02>dd<01>f|dd<01>dd<01>f|dd<01>dd<02>f|dd<02>dd<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.
Nrrr)rvr<>cSsg|]}t<00>|<01><01>qSrN)riry)r\r<>rNrNrOr_<00>sz2QuadMesh.convert_mesh_to_paths.<locals>.<listcomp>)rVr9rdrer<>rrs)r<>r<>r<>r<>rZrNrNrOru<00>szQuadMesh.convert_mesh_to_pathsc Cs<>t|tjj<03>r|j}n|}|dd<02>dd<02>f}|dd<02>dd<01>f}|dd<01>dd<01>f}|dd<01>dd<02>f}||||d} tj||| ||| ||| ||| f dd<06>}
|
<EFBFBD>||dddf<03>}
|<00><07><00>|d|ddf<03>} | dd<02>dd<02>f} | dd<02>dd<01>f} | dd<01>dd<01>f}| dd<01>dd<02>f}| | ||d}tj| | || ||||||| |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`.
Nrrg@r)rv<00>r)rVr9rdrer<>rrsr<>)rCr<>r<>r<>r]Zp_aZp_bZp_cZp_dZp_centerrzr<>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>df<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)Nrr)rrrnF))r<>r<>r<>r<>r<>r`rZr;rtrhrvrwr9rzr<>rar<>rsr^r?r rqrcrbr<>r<>r.r<>rpr<>r~rr{rjZdraw_quad_meshr<68>r<>Zget_edgecolorsr<73>r<>r<>) rCrrr^rErDr}r~r<>r<>rzrrNrNrOr<><00>sH
 



  z QuadMesh.drawN)Tr})r<>r<>r<>r<>r rPrRrpr<>rur<>rr<>r<>rNrNrNrOr|Ws
 *r|)
r|rmrrrr<>r*rhrWr)r,)-r<>r<><00>numbersrZnumpyr9Z
matplotlibr)r<>rrrrrr'r r
r<>r rir r<>Z_define_aliasesrr!rZinterpdrAr<>r<>rrrr*r+r,r8rWrYrhrmr|ZkwdocZpatchstrr<72>rNrNrNrO<00><module>
sV ,0C/AAv\7@,