mrhavens/intellecton
1
0
Fork 0
mirror of http://forgejo.openclaw.svc.cluster.local:3000/mrhavens/intellecton.git synced 2026-06-18 01:22:57 +00:00
Code Issues Projects Packages Wiki Activity
intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/collections.cpython-312.pyc

1172 lines
121 KiB
Text
Raw Normal View History

feat: rigorous physics revision for Paper 1 based on adversarial review
2026-06-01 22:22:35 +00:00
<EFBFBD>
<00>Rj7x<00> <00>f<00>dZddlZddlZddlZddlmZmZddlZddlZ ddl
Z ddl m Z mZmZmZmZmZmZmZmZmZmZddlmZmZe j@ddgd d
gd d ggd <0A>ddgdgd<11><06>Gd<12>dejB<00><00>Z"Gd<14>de"<22>Z#Gd<16>de#<23>Z$Gd<18>de#<23>Z%Gd<1A>de%<25>Z&Gd<1C>de#<23>Z'Gd<1E>de'<27>Z(Gd <20>d!e'<27>Z)Gd"<22>d#e"<22>Z*Gd$<24>d%e*<2A>Z+Gd&<26>d'e#<23>Z,Gd(<28>d)e"<22>Z-Gd*<2A>d+e"<22>Z.Gd,<2C>d-e"<22>Z/Gd.<2E>d/<2F>Z0Gd0<64>d1e0e"<22>Z1Gd2<64>d3e0e%<25>Z2y)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)<02>Number<65>Real<61>) <0B>_api<70>_path<74>artist<73>cbook<6F> colorizer<65>colors<72>
_docstring<EFBFBD>hatch<63>lines<65>path<74>
transforms)<02> JoinStyle<6C>CapStyle<6C> antialiaseds<64>aa<61>
edgecolors<EFBFBD>ec<65>
facecolors<EFBFBD>fc)<03>
linestyles<EFBFBD>dashes<65>ls<6C>
linewidths<EFBFBD>lw<6C> transOffset)<06> antialiased<65> edgecolor<6F> facecolor<6F> linestyle<6C> linewidth<74>offset_transformc<00><><00><00>eZdZdZej
d<02>ZdZejddddddddddddddddd<08><10>fd <09>
<EFBFBD>Z
d
<EFBFBD>Z d <0B>Z d <0C>Z d <0A>Zd<0E>Zd<0F>Zd9d<10>Zd<11>Zej(d<12><00>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Zd<19>Zd<1A>Zd<1B>Zd<1C>Zd<1D>Z d<1E>Z!d<1F>Z"d <20>Z#ejd!<21><00>Z$ejd"<22><00>Z%ejd#<23><00>Z&ejd$<24><00>Z'e(d%<25><00>Z)d&<26>Z*d'<27>Z+d(<28>Z,d)<29>Z-d*<2A>Z.d+<2B>Z/d,<2C>Z0d-<2D>Z1d.<2E>Z2d/<2F>Z3d0<64>Z4d1<64>Z5d2<64>Z6ejnjpje6_d3<64>Z9d4<64>Z:d5<64>Z;d6<64>Z<d7<64>Z=d8<64>Z><3E>xZ?S):<3A>
Collectiona<EFBFBD>
Base class for Collections. Must be subclassed to be usable.
A Collection represents a sequence of `.Patch`\es that can be drawn
more efficiently together than individually. For example, when a single
path is being drawn repeatedly at different offsets, the renderer can
typically execute a ``draw_marker()`` call much more efficiently than a
series of repeated calls to ``draw_path()`` with the offsets put in
one-by-one.
Most properties of a collection can be configured per-element. Therefore,
Collections have "plural" versions of many of the properties of a `.Patch`
(e.g. `.Collection.get_paths` instead of `.Patch.get_path`). Exceptions are
the *zorder*, *hatch*, *pickradius*, *capstyle* and *joinstyle* properties,
which can only be set globally for the whole collection.
Besides these exceptions, all properties can be specified as single values
(applying to all elements) or sequences of values. The property of the
``i``\th element of the collection is::
prop[i % len(prop)]
Each Collection can optionally be used as its own `.ScalarMappable` by
passing the *norm* and *cmap* parameters to its constructor. If the
Collection's `.ScalarMappable` matrix ``_A`` has been set (via a call
to `.Collection.set_array`), then at draw time this internal scalar
mappable will be used to set the ``facecolors`` and ``edgecolors``,
ignoring those that were manually passed in.
<20>r<00>r(FN<46>solidg@r)rrrr<00>capstyle<6C> joinstyler<00>offsetsr$<00>norm<72>cmapr
<00>
pickradiusr <00>urls<6C>zorderc <00><><00><01>t<00>|<00>|j| |
| <0C><00>dg|_dg|_dg|_dg|_d|_d|_d|_ d|_
tjtjd<00>|_tjd|_|j#|<02>|j%|<01>|j'|<03>|j)|<04>|j+|<07>|j-| <0A>|j/|<0F>|j1|<0E>|j3|<10>|r|j5|<05>nd|_|r|j9|<06>nd|_|<08>2t=j>|t@<00>}|jBdk(r |ddd<03>f}||_"| |_#d|_$|jK|<11>d|_&y)a<>
Parameters
----------
edgecolors : :mpltype:`color` or list of colors, default: :rc:`patch.edgecolor`
Edge color for each patch making up the collection. The special
value 'face' can be passed to make the edgecolor match the
facecolor.
facecolors : :mpltype:`color` or list of colors, default: :rc:`patch.facecolor`
Face color for each patch making up the collection.
linewidths : float or list of floats, default: :rc:`patch.linewidth`
Line width for each patch making up the collection.
linestyles : str or tuple or list thereof, 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 lengths
in points. For examples, see
:doc:`/gallery/lines_bars_and_markers/linestyles`.
capstyle : `.CapStyle`-like, default: 'butt'
Style to use for capping lines for all paths in the collection.
Allowed values are %(CapStyle)s.
joinstyle : `.JoinStyle`-like, default: 'round'
Style to use for joining lines for all paths in the collection.
Allowed values are %(JoinStyle)s.
antialiaseds : bool or list of bool, default: :rc:`patch.antialiased`
Whether each patch in the collection should be drawn with
antialiasing.
offsets : (float, float) or list thereof, default: (0, 0)
A vector by which to translate each patch after rendering (default
is no translation). The translation is performed in screen (pixel)
coordinates (i.e. after the Artist's transform is applied).
offset_transform : `~.Transform`, default: `.IdentityTransform`
A single transform which will be applied to each *offsets* vector
before it is used.
cmap, norm
Data normalization and colormapping parameters. See
`.ScalarMappable` for a detailed description.
hatch : str, optional
Hatching pattern to use in filled paths, if any. Valid strings are
['/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*']. See
:doc:`/gallery/shapes_and_collections/hatch_style_reference` for
the meaning of each hatch type.
pickradius : float, default: 5.0
If ``pickradius <= 0``, then `.Collection.contains` will return
``True`` whenever the test point is inside of one of the polygons
formed by the control points of a Path in the Collection. On the
other hand, if it is greater than 0, then we instead check if the
test point is contained in a stroke of width ``2*pickradius``
following any of the Paths in the Collection.
urls : list of str, default: None
A URL for each patch to link to once drawn. Currently only works
for the SVG backend. See :doc:`/gallery/misc/hyperlinks_sgskip` for
examples.
zorder : float, default: 1
The drawing order, shared by all Patches in the Collection. See
:doc:`/gallery/misc/zorder_demo` for all defaults and examples.
**kwargs
Remaining keyword arguments will be used to set properties as
``Collection.set_{key}(val)`` for each key-value pair in *kwargs*.
<20>rNrNz hatch.colorzhatch.linewidth<74><01>)'<27>super<65>__init__<5F>_get_colorizer<65>_us_linestyles<65> _linestyles<65>_us_lw<6C> _linewidths<68> _gapcolor<6F>_face_is_mapped<65>_edge_is_mapped<65>_mapped_colors<72>mcolors<72>to_rgba<62>mpl<70>rcParams<6D> _hatch_color<6F>_hatch_linewidth<74> 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_zorder<EFBFBD> set_capstyle<6C> _capstyle<6C> set_joinstyle<6C>
_joinstyle<EFBFBD>np<6E>
asanyarray<EFBFBD>float<61>shape<70>_offsets<74>_offset_transform<72> _path_effects<74>_internal_update<74>_paths)<13>selfrrrrr*r+rr,r$r-r.r
r/r r0r1<00>kwargs<67> __class__s <20><>Y/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/collections.pyr7zCollection.__init__Ns<><00><><00>f <0E><07><18><14>,<2C>,<2C>T<EFBFBD>4<EFBFBD><19>C<>D<> )<29>k<EFBFBD><04><1B>%<25>;<3B><04><18><18>c<EFBFBD><04> <0B><1D>3<EFBFBD><04><18><1D><04><0E> $<24><04><1C>#<23><04><1C>"<22><04><1B>#<23>O<EFBFBD>O<EFBFBD>C<EFBFBD>L<EFBFBD>L<EFBFBD><1D>,G<>H<><04><19> #<23> <0C> <0C>-><3E> ?<3F><04><1D> <0C><1A><1A>:<3A>&<26> <0C><1A><1A>:<3A>&<26> <0C><1A><1A>:<3A>&<26> <0C><1A><1A>:<3A>&<26> <0C><1C><1C>\<5C>*<2A> <0C><1B><1B>J<EFBFBD>'<27> <0C> <0A> <0A>d<EFBFBD><1B> <0C><0E><0E>u<EFBFBD><1D> <0C><0F><0F><06><1F> <13> <10> <1D> <1D>h<EFBFBD> '<27>!<21>D<EFBFBD>N<EFBFBD> <14> <10> <1E> <1E>y<EFBFBD> )<29>"<22>D<EFBFBD>O<EFBFBD> <12> <1E><18>m<EFBFBD>m<EFBFBD>G<EFBFBD>U<EFBFBD>3<>G<EFBFBD><16>}<7D>}<7D><04>$<24>!<21>$<24><01>'<27>*<2A><07><1F><04> <0A>!1<><04><1E>!<21><04><1A> <0C><1D><1D>f<EFBFBD>%<25><1A><04> <0B>c<00><00>|jS<00>N<>r\<00>r]s r`<00> get_pathszCollection.get_paths<68><00> <00><00><13>{<7B>{<7B>rac<00> <00>||_d|_y<00>NT)r\<00>stale)r]<00>pathss r`<00> set_pathszCollection.set_paths<68>s<00><00><1B><04> <0B><19><04>
rac<00><00>|jSrc)<01> _transformsres r`<00>get_transformszCollection.get_transforms<6D><00><00><00><13><1F><1F>rac<00>D<00>|j<00>%tj<00>|_|jSt|jtj<00>s@t |jd<01>r*|jj |j<00>|_|jS)z<Return the `.Transform` instance used by this artist offset.<2E>_as_mpl_transform)rYr<00>IdentityTransform<72>
isinstance<EFBFBD> Transform<72>hasattrrr<00>axesres r`<00>get_offset_transformzCollection.get_offset_transform<72>s<><00><00> <0F> !<21> !<21> )<29>%/<2F>%A<>%A<>%C<>D<EFBFBD> "<22>
<14>%<25>%<25>%<25> <1D>T<EFBFBD>3<>3<>Z<EFBFBD>5I<35>5I<35>J<><19>$<24>0<>0<>2E<32>F<><14>&<26>&<26>8<>8<><14><19><19>C<> <11> "<22><13>%<25>%<25>%rac<00><00>||_y)z<>
Set the artist offset transform.
Parameters
----------
offset_transform : `.Transform`
N)rY)r]r$s r`<00>set_offset_transformzCollection.set_offset_transform<72>s <00><00>"2<><04>rac<00><><00>|j<00>}|j<00>}t|tj<00>s/|j |<01>stj j<00>S|j<00>}t|<04>stj j<00>S|js|D<00>cgc]}|j|<05><00><02>}}|j<00>}t|j|<01><00>r<>t|tj j"<00>r|j%tj&<00>}t)j*|j-<00>|z
||j/<00>|j1|<06>|j-<00>j3<00><00>S|j4<00>~||z
j7|<06>}tj j9|<06>}|j:j=<00>s1tj j<00>}|j?|<06>|Stj j<00>Scc}wrc) <20> get_transformrxrtrrs<00>contains_branch<63>Bbox<6F>nullrf<00>len<65> is_affine<6E>transform_path_non_affine<6E> get_offsets<74>any<6E>contains_branch_seperatelyrT<00>ma<6D> MaskedArray<61>filled<65>nan<61>mpath<74>get_path_collection_extents<74>
get_affinero<00>transform_non_affine<6E>frozenrX<00> transform<72>masked_invalid<69>mask<73>all<6C>update_from_data_xy)r]<00> transDatar<61><00>
offset_trfrk<00>pr,<00>bboxs r`<00> get_datalimzCollection.get_datalim<69>s<><00><00>"<19>&<26>&<26>(<28> <09><19>.<2E>.<2E>0<>
<EFBFBD><1A>:<3A>z<EFBFBD>'C<>'C<>D<><1D>-<2D>-<2D>i<EFBFBD>8<><1E>?<3F>?<3F>'<27>'<27>)<29> )<29><14><0E><0E> <20><05><12>5<EFBFBD>z<EFBFBD><1D>?<3F>?<3F>'<27>'<27>)<29> )<29><18>"<22>"<22>EJ<45>K<><01>Y<EFBFBD>8<>8<><11>;<3B>K<>E<EFBFBD>K<> <17>"<22>"<22>$<24><07> <0E>y<EFBFBD>3<>3<>I<EFBFBD>><3E> ?<3F>
<1A>'<27>2<EFBFBD>5<EFBFBD>5<EFBFBD>#4<>#4<>5<>!<21>.<2E>.<2E><12><16><16>0<><07><18>4<>4<><19>$<24>$<24>&<26><19>2<>E<EFBFBD><14>#<23>#<23>%<25><1A>/<2F>/<2F><07>8<><1A>%<25>%<25>'<27>.<2E>.<2E>0<> 2<> 2<> <10>=<3D>=<3D> $<24> "<22>I<EFBFBD>-<2D>8<>8<><17>A<>G<EFBFBD><18>e<EFBFBD>e<EFBFBD>*<2A>*<2A>7<EFBFBD>3<>G<EFBFBD><1A><<3C><<3C>#<23>#<23>%<25>!<21><EFBFBD><EFBFBD>+<2B>+<2B>-<2D><04><14>(<28>(<28><17>1<><1B> <0B><19><EFBFBD><EFBFBD>#<23>#<23>%<25>%<25><>ILs<00>3Ic<00>H<00>|jtj<00><00>Src)r<>rrs)r]<00>renderers r`<00>get_window_extentzCollection.get_window_extent7s<00><00><14><1F><1F>
<EFBFBD> <<3C> <<3C> ><3E>?<3F>?rac <00><><00>|j<00>}|j<00>}|j<00>}|j<00>}|j <00>r<>g}|j<00>D]<5D>}|j
}|dd<00>df|dd<00>df}}|j |<07>}|j|<08>}|jtjtj||g<02>|j<00><00><00><>|j |dd<00>df<00>}|j|dd<00>df<00>}tjj||g<02>}|js.|D<00>cgc]}|j!|<05><00><02>}}|j#<00>}|js!|j%|<03>}|j#<00>}t'|tjj(<00>r|j+tj,<00>}||||fScc}w)Nrr)r|rxr<>rf<00>
have_units<EFBFBD>vertices<65>convert_xunits<74>convert_yunits<74>appendr<64><00>PathrT<00> column_stack<63>codesr<73>r<>r<>r<>r<>rtr<>r<>r<>) r]r<>r<>r,rkrr<><00>xs<78>yss r`<00>_prepare_pointszCollection._prepare_points<s<><00><00><19>&<26>&<26>(<28> <09><19>.<2E>.<2E>0<>
<EFBFBD><16>"<22>"<22>$<24><07><14><0E><0E> <20><05> <0F>?<3F>?<3F> <1C><16>E<EFBFBD><1C><0E><0E>(<28> P<01><04><1F>=<3D>=<3D><08>!<21>!<21>Q<EFBFBD>$<24><1E><18>!<21>Q<EFBFBD>$<24><1E>B<EFBFBD><02><19>(<28>(<28><12>,<2C><02><19>(<28>(<28><12>,<2C><02><15> <0C> <0C>U<EFBFBD>Z<EFBFBD>Z<EFBFBD><02><0F><0F><12>R<EFBFBD><08>(A<>4<EFBFBD>:<3A>:<3A>N<>O<>  P<01> <16>$<24>$<24>W<EFBFBD>Q<EFBFBD><01>T<EFBFBD>]<5D>3<>B<EFBFBD><15>$<24>$<24>W<EFBFBD>Q<EFBFBD><01>T<EFBFBD>]<5D>3<>B<EFBFBD><18>e<EFBFBD>e<EFBFBD>(<28>(<28>"<22>b<EFBFBD><18>2<>G<EFBFBD><18>"<22>"<22>!&<26>(<28><1D><1F>8<>8<><14>><3E>(<28>E<EFBFBD>(<28>!<21>,<2C>,<2C>.<2E>I<EFBFBD><19>#<23>#<23> <20>5<>5<>g<EFBFBD>><3E>G<EFBFBD>#<23>.<2E>.<2E>0<>J<EFBFBD> <15>g<EFBFBD>r<EFBFBD>u<EFBFBD>u<EFBFBD>0<>0<> 1<><1D>n<EFBFBD>n<EFBFBD>R<EFBFBD>V<EFBFBD>V<EFBFBD>,<2C>G<EFBFBD><19>*<2A>g<EFBFBD>u<EFBFBD>4<>4<><34>(s<00> G-c<00><>
<00>|j<00>sy|j|jj|j <00><00>|j <00>|j <00>\}}}}|j<00>}|j|<06>|j|j<00><00>|jrQ|j|j<00>|j|j<00>|j|j <00>|j#<00><00>|j$|j#<00><00>|j'<00>rddlm}||j'<00>|<01>}|j-<00>}|j/<00>} |j1<00>}
d} t3|<05>dk(<00>rGt3|<08>dk<00>r8t3| <09>dk(<00>r)t3|
<EFBFBD>dk(<00>rt3|j4<00>dk(<00>rt7d<05>|j8D<00><00>r<>t3|j:<00>dk(r<>t3|j<<00>dk(r<>|j?<00><00><>t3|<08>rtAjB|d<00>|z} n|} |djE| <0C>} | jF|jId<06><07>jJjFkr5| jL|jId<06><07>jJjLkrd} |jNr|jQ|jN<00>|jRr|jU|jR<00>| r<>|jWtY|
d<00><00>|j[|j4d<00>|j\|j8d<00>|j_|j:d<00>|ja|j<d<00>|jc||d je<00>tgjh|<04>|tY| d<00><00><00>n|jj<00><>|jm<00>\}}|jo||je<00>||j-<00>||tqjrd<08>g|jj|j4||j:|j<d <09> |jo||je<00>||j-<00>|||j/<00>|j1<00>|j4|j8|j:|j<d <09> |ju<00>|jw|jj<00>d|_<y)
Nr)<01>PathEffectRendererFrc3<00>*K<00>|] }|ddu<00><01><00> y<01>w)rN<>)<02>.0rs r`<00> <genexpr>z"Collection.draw.<locals>.<genexpr><3E>s<00><00><><00>=<3D>b<EFBFBD>B<EFBFBD>q<EFBFBD>E<EFBFBD>T<EFBFBD>M<EFBFBD>=<3D>s<00>T<><01>root<6F>none<6E>screen)=<3D> get_visible<6C>
open_groupr_<00>__name__<5F>get_gid<69>update_scalarmappabler<65><00>new_gc<67> _set_gc_clip<69>set_snap<61>get_snap<61>_hatchrN<00>set_hatch_colorrE<00>set_hatch_linewidthrF<00>get_sketch_params<6D>set_sketch_params<6D>get_path_effects<74>matplotlib.patheffectsr<73>ro<00> get_facecolor<6F> get_edgecolorr<72>r<r<>r:<00> _antialiaseds<64>_urls<6C> get_hatchr<00>Affine2D<32> get_extents<74>width<74>
get_figurer<EFBFBD><00>heightrSrRrQrP<00>set_foreground<6E>tuplerI<00>
set_dashesrK<00>set_url<72> draw_markersr<73>r<>r<>r=<00>_get_inverse_paths_linestyles<65>draw_path_collectionrArB<00>restore<72> close_grouprj)r]r<>r<>r<>r,rk<00>gcr<63><00>transrr<00>do_single_path_optimization<6F>combined_transform<72>extents<74>ipaths<68> ilinestyless r`<00>drawzCollection.draw`s@<00><00><13><1F><1F>!<21> <12><10><1B><1B>D<EFBFBD>N<EFBFBD>N<EFBFBD>3<>3<>T<EFBFBD>\<5C>\<5C>^<5E>D<> <0C>"<22>"<22>$<24>04<30>0D<30>0D<30>0F<30>-<2D> <09>:<3A>w<EFBFBD><05> <15>_<EFBFBD>_<EFBFBD> <1E><02> <0C><19><19>"<22><1D>
<EFBFBD> <0B> <0B>D<EFBFBD>M<EFBFBD>M<EFBFBD>O<EFBFBD>$<24> <0F>;<3B>;<3B> <0E>L<EFBFBD>L<EFBFBD><14><1B><1B> %<25> <0E> <1E> <1E>t<EFBFBD>0<>0<> 1<> <0E> "<22> "<22>4<EFBFBD>#8<>#8<> 9<> <0F> !<21> !<21> #<23> /<2F> <20>B<EFBFBD> <20> <20>$<24>"8<>"8<>":<3A> ;<3B> <0F> <20> <20> "<22> A<>)<29>$<24>*?<3F>*?<3F>*A<>8<EFBFBD>L<>H<EFBFBD><15>#<23>#<23>%<25><05><19>'<27>'<27>)<29>
<EFBFBD><19>'<27>'<27>)<29>
<EFBFBD>&+<2B>#<23> <0F><05>J<EFBFBD>!<21>O<EFBFBD><03>E<EFBFBD>
<EFBFBD>a<EFBFBD><0F><13>J<EFBFBD><0F>1<EFBFBD>$<24><13>Z<EFBFBD><1F>A<EFBFBD>)=<3D><13>D<EFBFBD>$<24>$<24>%<25><11>*<2A><13>=<3D>D<EFBFBD>,<<3C>,<<3C>=<3D>=<3D><13>D<EFBFBD>&<26>&<26>'<27>1<EFBFBD>,<2C><13>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><1F>A<EFBFBD>1E<31><14><0E><0E> <20>(<28><12>5<EFBFBD>z<EFBFBD>%/<2F>%8<>%8<><15>q<EFBFBD><18>%B<>Y<EFBFBD>%N<>"<22>%.<2E>"<22><1B>A<EFBFBD>h<EFBFBD>*<2A>*<2A>+=<3D>><3E>G<EFBFBD><17> <0A> <0A><04><0F><0F>T<EFBFBD><0F> :<3A> ?<3F> ?<3F> E<> E<>E<><1F><0E><0E><14><1F><1F>d<EFBFBD><1F>)C<>)H<>)H<>)O<>)O<>O<>.2<EFBFBD>+<2B> <0F>?<3F>?<3F> <0E> <1C> <1C>T<EFBFBD>_<EFBFBD>_<EFBFBD> -<2D> <0F>><3E>><3E> <0E>O<EFBFBD>O<EFBFBD>D<EFBFBD>N<EFBFBD>N<EFBFBD> +<2B> &<26> <0E> <1D> <1D>e<EFBFBD>J<EFBFBD>q<EFBFBD>M<EFBFBD>2<> 3<> <0E> <1C> <1C>T<EFBFBD>-<2D>-<2D>a<EFBFBD>0<> 1<> <19>B<EFBFBD>M<EFBFBD>M<EFBFBD>4<EFBFBD>+<2B>+<2B>A<EFBFBD>.<2E> /<2F> <0E> <1E> <1E>t<EFBFBD>1<>1<>!<21>4<> 5<> <0E>J<EFBFBD>J<EFBFBD>t<EFBFBD>z<EFBFBD>z<EFBFBD>!<21>}<7D> %<25> <14> !<21> !<21><12>E<EFBFBD>!<21>H<EFBFBD>0<>7<>7<>9<><15>
<EFBFBD>
<EFBFBD>7<EFBFBD>#<23>Z<EFBFBD><15>z<EFBFBD>!<21>}<7D>1E<31> G<01><14>~<7E>~<7E>)<29>&*<2A>&H<>&H<>&J<>#<23><06> <0B><18>-<2D>-<2D><16> <09>(<28>(<28>*<2A>F<EFBFBD><18>'<27>'<27>)<29>7<EFBFBD>J<EFBFBD><1C>_<EFBFBD>_<EFBFBD>V<EFBFBD>,<2C>-<2D>t<EFBFBD>~<7E>~<7E><18>$<24>$<24>k<EFBFBD><18>&<26>&<26><04>
<EFBFBD>
<EFBFBD><1C> <1E> <15> )<29> )<29><12>I<EFBFBD>$<24>$<24>&<26><05><14>#<23>#<23>%<25>w<EFBFBD>
<EFBFBD><14>"<22>"<22>$<24>d<EFBFBD>&8<>&8<>&:<3A><14> <20> <20>$<24>"2<>"2<><14>"<22>"<22>D<EFBFBD>J<EFBFBD>J<EFBFBD><18>  <1A> <0B>
<EFBFBD>
<EFBFBD> <0C><10><1C><1C>T<EFBFBD>^<5E>^<5E>4<>4<>5<><1A><04>
rac<00>N<00>t|t<00>std|<01><02><02><00>||_y)z<>
Set the pick radius used for containment tests.
Parameters
----------
pickradius : float
Pick radius, in points.
z-pickradius must be a real-valued number, not N)rtr<00>
ValueError<EFBFBD> _pickradius)r]r/s r`rLzCollection.set_pickradius<75>s/<00><00><1A>*<2A>d<EFBFBD>+<2B><1C>?<3F>
<EFBFBD>~<7E>N<>P<01> P<01>%<25><04>rac<00><00>|jSrc)r<>res r`<00>get_pickradiuszCollection.get_pickradius<75>rprac <00>(<00>|j|<01>s|j<00>sdifSt|jt<00>r#|jdurt |j<00>n |j }|jr|jj<00>|j<00>\}}}}tj|j|j||j<00>||j<00>|||dk<00> }t!|<07>dkDt#|<07><04>fS)z<>
Test whether the mouse event occurred in the collection.
Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
contains the event.
FTr)<01>ind)<12>_different_canvasr<73>rt<00>_pickerrrVr<>rw<00>_unstale_viewLimr<6D>r<00>point_in_path_collection<6F>x<>yr<79>ror<><00>dict)r]<00>
mouseeventr/r<>r<>r,rkr<>s r`<00>containszCollection.contains<6E>s<><00><00> <10> !<21> !<21>*<2A> -<2D>T<EFBFBD>5E<35>5E<35>5G<35><18>"<22>9<EFBFBD> <1C><1A>$<24>,<2C>,<2C><06>/<2F><13>|<7C>|<7C>4<EFBFBD>'<27> <12>$<24>,<2C>,<2C> <1F><16>!<21>!<21> <13>
<10>9<EFBFBD>9<EFBFBD> <10>I<EFBFBD>I<EFBFBD> &<26> &<26> (<28>04<30>0D<30>0D<30>0F<30>-<2D> <09>:<3A>w<EFBFBD><05> <14>,<2C>,<2C> <16>L<EFBFBD>L<EFBFBD>*<2A>,<2C>,<2C>
<EFBFBD> <15> <1C> <1C> <1E><05>t<EFBFBD>':<3A>':<3A>'<<3C> <13>Z<EFBFBD><1A>q<EFBFBD><1F>2<><03><13>3<EFBFBD>x<EFBFBD>!<21>|<7C>T<EFBFBD>c<EFBFBD>]<5D>*<2A>*rac<00>*<00>|<01>|ndg|_d|_y)z<>
Parameters
----------
urls : list of str or None
Notes
-----
URLs are currently only implemented by the SVG backend. They are
ignored by all other backends.
NT)r<>rj)r]r0s r`rMzCollection.set_urls<6C>s<00><00>"<22>-<2D>T<EFBFBD>D<EFBFBD>6<EFBFBD><04>
<EFBFBD><19><04>
rac<00><00>|jS)z<>
Return a list of URLs, one for each element of the collection.
The list contains *None* for elements without a URL. See
:doc:`/gallery/misc/hyperlinks_sgskip` for an example.
)r<>res r`<00>get_urlszCollection.get_urls<6C>s<00><00><14>z<EFBFBD>z<EFBFBD>rac<00>J<00>tj|<01>||_d|_y)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.
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)<04>mhatch<63>_validate_hatch_patternr<6E>rj)r]r s r`rNzCollection.set_hatch<63>s <00><00>< <0F>&<26>&<26>u<EFBFBD>-<2D><1B><04> <0B><19><04>
rac<00><00>|jS)z$Return the current hatching pattern.)r<>res r`r<>zCollection.get_hatch s <00><00><13>{<7B>{<7B>rac<00><00>||_y)zSet the hatch linewidth.N<>rF<00>r]rs r`r<>zCollection.set_hatch_linewidth$s
<00><00> "<22><04>rac<00><00>|jS)zReturn the hatch linewidth.r<>res r`<00>get_hatch_linewidthzCollection.get_hatch_linewidth(s<00><00><13>$<24>$<24>$rac
<00><><00>tj|<01>}|jdk(r |ddd<02>f}t|tjj
<00>rtjj ntj }|tj|j|dd<02>df<00>t<00>tj|j|dd<02>df<00>t<00>f<02>|_
d|_ y)z<>
Set the offsets for the collection.
Parameters
----------
offsets : (N, 2) or (2,) array-like
r4NrrT) rTrUrWrtr<>r<>r<>r<>rVr<>rXrj)r]r,<00>cstacks r`<00> set_offsetszCollection.set_offsets,s<><00><00><15>-<2D>-<2D><07>(<28><07> <12>=<3D>=<3D>D<EFBFBD> <20><1D>d<EFBFBD>A<EFBFBD>g<EFBFBD>&<26>G<EFBFBD>(2<>7<EFBFBD>B<EFBFBD>E<EFBFBD>E<EFBFBD><M<><M<>(N<>"<22>%<25>%<25>$<24>$<24><19><EFBFBD><EFBFBD> <0F><1E> <0F>]<5D>]<5D>4<EFBFBD>.<2E>.<2E>w<EFBFBD>q<EFBFBD>!<21>t<EFBFBD>}<7D>=<3D>u<EFBFBD> E<> <0F>]<5D>]<5D>4<EFBFBD>.<2E>.<2E>w<EFBFBD>q<EFBFBD>!<21>t<EFBFBD>}<7D>=<3D>u<EFBFBD> E<> G<01>H<01><04> <0A><1A><04>
rac<00>\<00>|j<00>tjd<01>S|jS)z&Return the offsets for the collection.<2E>rr5)rXrT<00>zerosres r`r<>zCollection.get_offsets>s%<00><00>$(<28>=<3D>=<3D>#8<>r<EFBFBD>x<EFBFBD>x<EFBFBD><06><1F>K<>d<EFBFBD>m<EFBFBD>m<EFBFBD>Krac<00>(<00>tjdS)Nzpatch.linewidth<74>rCrDres r`<00>_get_default_linewidthz!Collection._get_default_linewidthC<00><00><00><12>|<7C>|<7C>-<2D>.<2E>.rac<00><><00>|<01>|j<00>}tj|<01>|_|j |j|j
<00>\|_|_d|_y)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 list of floats
NT) rrT<00>
atleast_1dr;<00> _bcast_lwlsr9r<r:rjr<>s r`rIzCollection.set_linewidthGsZ<00><00> <0E>:<3A><15>,<2C>,<2C>.<2E>B<EFBFBD><18>m<EFBFBD>m<EFBFBD>B<EFBFBD>'<27><04> <0B>.2<EFBFBD>-=<3D>-=<3D> <10>K<EFBFBD>K<EFBFBD><14>,<2C>,<2C>..<2E>*<2A><04><18>$<24>*<2A><19><04>
rac<00><><00>tj|<01>|_|j|j|j<00>\|_|_y)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 : str or tuple or list thereof
Valid values for individual linestyles include {'-', '--', '-.',
':', '', (offset, on-off-seq)}. See `.Line2D.set_linestyle` for a
complete description.
N)<07>mlines<65>_get_dash_patternsr9rr;r<r:)r]rs r`rJzCollection.set_linestyle[sC<00><00>6%<25>7<>7<><02>;<3B><04><1B>.2<EFBFBD>-=<3D>-=<3D> <10>K<EFBFBD>K<EFBFBD><14>,<2C>,<2C>..<2E>*<2A><04><18>$<24>*rac<00>$<00>t|<01>|_y)z<>
Set the `.CapStyle` for the collection (for all its elements).
Parameters
----------
cs : `.CapStyle` or %(CapStyle)s
N)rrQ)r]<00>css r`rPzCollection.set_capstyle|s<00><00>"<22>"<22><1C><04>rac<00>J<00>|jr|jjSdS)z<>
Return the cap style for the collection (for all its elements).
Returns
-------
%(CapStyle)s or None
N)rQ<00>nameres r`<00> get_capstylezCollection.get_capstyle<6C>s<00><00>'+<2B>n<EFBFBD>n<EFBFBD>t<EFBFBD>~<7E>~<7E>"<22>"<22>><3E>$<24>>rac<00>$<00>t|<01>|_y)z<>
Set the `.JoinStyle` for the collection (for all its elements).
Parameters
----------
js : `.JoinStyle` or %(JoinStyle)s
N)rrS)r]<00>jss r`rRzCollection.set_joinstyle<6C>s<00><00>$<24>B<EFBFBD>-<2D><04>rac<00>J<00>|jr|jjSdS)z<>
Return the join style for the collection (for all its elements).
Returns
-------
%(JoinStyle)s or None
N)rSr res r`<00> get_joinstylezCollection.get_joinstyle<6C>s<00><00>(,<2C><EFBFBD><EFBFBD>t<EFBFBD><EFBFBD><EFBFBD>#<23>#<23>@<40>D<EFBFBD>@rac
<00><><00>tjdr||fSt|<01>t|<00>k7rNt|<01>}t|<00>}tj||<03>}t |<01>||zz}t |<00>||zz}t ||<00>D<00><05><06>cgc]\\}}}tj|||<07><00><02>!}}}}||fScc}}}w)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_mode) rCrDr<><00>math<74>gcd<63>list<73>zipr<00> _scale_dashes)rr<00>l_dashes<65>l_lwr<00>o<>drs r`rzCollection._bcast_lwls<6C>s<><00><00>, <0F><<3C><<3C>0<> 1<><1D>v<EFBFBD>%<25> %<25> <0E>v<EFBFBD>;<3B>#<23>j<EFBFBD>/<2F> )<29><1A>6<EFBFBD>{<7B>H<EFBFBD><16>z<EFBFBD>?<3F>D<EFBFBD><16>(<28>(<28>8<EFBFBD>T<EFBFBD>*<2A>C<EFBFBD><19>&<26>\<5C>T<EFBFBD>S<EFBFBD>[<5B>1<>F<EFBFBD><1D>j<EFBFBD>)<29>X<EFBFBD><13>_<EFBFBD>=<3D>J<EFBFBD>%(<28><06>
<EFBFBD>$;<3B>=<3D>=<3D> <20>f<EFBFBD>q<EFBFBD>!<21>b<EFBFBD><19>&<26>&<26>q<EFBFBD>!<21>R<EFBFBD>0<>=<3D><06>=<3D><1A>6<EFBFBD>!<21>!<21><>=s<00> $B9c<00><00>|jS)zs
Get the antialiasing state for rendering.
Returns
-------
array of bools
)r<>res r`<00>get_antialiasedzCollection.get_antialiased<65>s<00><00><14>!<21>!<21>!rac<00><><00>|<01>|j<00>}tjtj|t<00><00>|_d|_y)z<>
Set the antialiasing state for rendering.
Parameters
----------
aa : bool or list of bools
NT)<07>_get_default_antialiasedrTr<00>asarray<61>boolr<6C>rj)r]rs r`rKzCollection.set_antialiased<65>s:<00><00> <0E>:<3A><15>.<2E>.<2E>0<>B<EFBFBD><1F>]<5D>]<5D>2<EFBFBD>:<3A>:<3A>b<EFBFBD>$<24>+?<3F>@<40><04><1A><19><04>
rac<00>(<00>tjdS)Nzpatch.antialiasedrres r`rz#Collection._get_default_antialiased<65>s<00><00><12>|<7C>|<7C>/<2F>0<>0rac<00>H<00>|j|<01>|j|<01>y)a1
Set both the edgecolor and the facecolor.
Parameters
----------
c : :mpltype:`color` or list of RGBA tuples
See Also
--------
Collection.set_facecolor, Collection.set_edgecolor
For setting the edge or face color individually.
N)rGrH<00>r]<00>cs r`<00> set_colorzCollection.set_color<6F>s <00><00> <0A><1A><1A>1<EFBFBD><1D> <0C><1A><1A>1<EFBFBD>rac<00>(<00>tjdS)Nzpatch.facecolorrres r`<00>_get_default_facecolorz!Collection._get_default_facecolor<6F>rrac<00><><00>|<01>|j<00>}tj||j<00>|_d|_yri)r(rA<00> to_rgba_array<61>_alpha<68> _facecolorsrjr$s r`<00>_set_facecolorzCollection._set_facecolor<6F>s5<00><00> <0C>9<EFBFBD><14>+<2B>+<2B>-<2D>A<EFBFBD>"<22>0<>0<><11>D<EFBFBD>K<EFBFBD>K<EFBFBD>@<40><04><18><19><04>
rac<00><><00>t|t<00>r"|j<00>dvr|j<00>}||_|j |<01>y)an
Set the facecolor(s) of the collection. *c* can be a color (all patches
have same color), or a sequence of colors; if it is a sequence the
patches will cycle through the sequence.
If *c* is 'none', the patch will not be filled.
Parameters
----------
c : :mpltype:`color` or list of :mpltype:`color`
<20>r<><00>faceN)rt<00>str<74>lower<65>_original_facecolorr-r$s r`rGzCollection.set_facecolors=<00><00> <16>a<EFBFBD><13> <1D>!<21>'<27>'<27>)<29>/?<3F>"?<3F><11><07><07> <09>A<EFBFBD>#$<24><04> <20> <0C><1B><1B>A<EFBFBD>rac<00><00>|jSrc)r,res r`r<>zCollection.get_facecolorrprac<00>z<00>tj|jd<01>r|j<00>S|jS)Nr0)r <00>
_str_equal<EFBFBD> _edgecolorsr<73>res r`r<>zCollection.get_edgecolors3<00><00> <10> <1B> <1B>D<EFBFBD>,<2C>,<2C>f<EFBFBD> 5<><17>%<25>%<25>'<27> '<27><17>#<23>#<23> #rac<00>(<00>tjdS)Nzpatch.edgecolorrres r`<00>_get_default_edgecolorz!Collection._get_default_edgecolorrrac<00><><00>d}|<01>Ttjds,|js tj|j
d<03>r|j <00>}nd}d}tj|d<05>rd|_d|_ ytj||j<00>|_|r2t|j<00>rt|jd<00>|_d|_ y)NTzpatch.force_edgecolorr<72>Fr0r)rCrD<00> _edge_defaultr r6r3r9<00>_str_lower_equalr7rjrAr*r+r<>r<>rE)r]r%r<>s r`<00>_set_edgecolorzCollection._set_edgecolor"s<><00><00><1E><0F> <0C>9<EFBFBD><13> <0C> <0C>4<>5<><1B>)<29>)<29><1C>'<27>'<27><04>(@<40>(@<40>&<26>I<><18>/<2F>/<2F>1<><01><1A><01>"'<27><0F> <10> !<21> !<21>!<21>V<EFBFBD> ,<2C>%<25>D<EFBFBD> <1C><1D>D<EFBFBD>J<EFBFBD> <12>"<22>0<>0<><11>D<EFBFBD>K<EFBFBD>K<EFBFBD>@<40><04><18> <1A>s<EFBFBD>4<EFBFBD>#3<>#3<>4<> %<25>d<EFBFBD>&6<>&6<>q<EFBFBD>&9<> :<3A>D<EFBFBD> <1D><19><04>
rac<00><><00>t|t<00>r"|j<00>dvr|j<00>}||_|j |<01>y)a'
Set the edgecolor(s) of the collection.
Parameters
----------
c : :mpltype:`color` or list of :mpltype:`color` or 'face'
The collection edgecolor(s). If a sequence, the patches cycle
through it. If 'face', match the facecolor.
r/N)rtr1r2<00>_original_edgecolorr=r$s r`rHzCollection.set_edgecolor5s=<00><00> <16>a<EFBFBD><13> <1D>!<21>'<27>'<27>)<29>/?<3F>"?<3F><11><07><07> <09>A<EFBFBD>#$<24><04> <20> <0C><1B><1B>A<EFBFBD>rac<00><><00>tjj||<01>|j|j<00>|j |j <00>y)a<>
Set the transparency of the collection.
Parameters
----------
alpha : float or array of float or None
If not None, *alpha* values must be between 0 and 1, inclusive.
If an array is provided, its length must match the number of
elements in the collection. Masked values and nans are not
supported.
N)r<00>Artist<73>_set_alpha_for_arrayr-r3r=r?)r]<00>alphas r`<00> set_alphazCollection.set_alphaGs@<00><00> <0F> <0A> <0A>*<2A>*<2A>4<EFBFBD><15>7<> <0C><1B><1B>D<EFBFBD>4<>4<>5<> <0C><1B><1B>D<EFBFBD>4<>4<>5rac<00><00>|jSrc)r<res r`<00> get_linewidthzCollection.get_linewidthYrprac<00><00>|jSrc)r:res r`<00> get_linestylezCollection.get_linestyle\rprac<00><><00>|j}|j}d|_d|_|j<00>btj|j
d<03>s/d|_tj|j d<05>rd|_n|j <00>d|_|jxs |j}|duxs&|duxs |j|k7xs|j|k7}|xs|S)aF
Determine whether edges and/or faces are color-mapped.
This is a helper for update_scalarmappable.
It sets Boolean flags '_edge_is_mapped' and '_face_is_mapped'.
Returns
-------
mapping_change : bool
True if either flag is True, or if a flag has changed.
FNr<4E>Tr0)r?r><00>_Ar r6r3r?)r]<00>edge0<65>face0<65>mapped<65>changeds r`<00>_set_mappable_flagszCollection._set_mappable_flags_s<><00><00><15>$<24>$<24><05><14>$<24>$<24><05>$<24><04><1C>$<24><04><1C> <0F>7<EFBFBD>7<EFBFBD> <1E><18>#<23>#<23>D<EFBFBD>$<<3C>$<<3C>f<EFBFBD>E<>'+<2B><04>$<24><18>#<23>#<23>D<EFBFBD>$<<3C>$<<3C>f<EFBFBD>E<>+/<2F>D<EFBFBD>(<28><17>+<2B>+<2B>3<>+/<2F>D<EFBFBD>(<28><15>%<25>%<25>=<3D><14>)=<3D>)=<3D><06><18>D<EFBFBD>=<3D>4<>E<EFBFBD>T<EFBFBD>M<EFBFBD>4<><1A>*<2A>*<2A>e<EFBFBD>3<>4<><1A>*<2A>*<2A>e<EFBFBD>3<> <10><16> <20><17> rac<00>r<00>|j<00>sy|j<00><01>|jjdkDrt|t<00>s t d<03><00>t j|j<00>r<>|jj|jjk7r:t d|jj<00>d|jj<00>d<06><05><00>|jj|jj<00>|_|j|j|j<00>|_ |jr|j|_n|j!|j"<00>|j$r|j|_d|_y|j)|j*<00>d|_y)z<>
Update colors from the scalar mappable array, if any.
Assign colors to edges and faces based on the array and/or
colors that were directly set, as appropriate.
Nrz&Collections can only map rank 1 arrayszData array shape, z) is incompatible with alpha array shape, z<>. This can occur with the deprecated behavior of the "flat" shading option, in which a row and/or column of the data array is dropped.T)rOrJ<00>ndimrt<00> _MeshDatar<61>rT<00>iterabler+<00>sizerW<00>reshaperBr@r>r,r-r3r?r7r=r?rjres r`r<>z Collection.update_scalarmappable<6C>sK<00><00><14>'<27>'<27>)<29> <12> <0F>7<EFBFBD>7<EFBFBD> <1E><13>w<EFBFBD>w<EFBFBD>|<7C>|<7C>a<EFBFBD><1F>
<EFBFBD>4<EFBFBD><19>(C<> <20>!I<>J<>J<><11>{<7B>{<7B>4<EFBFBD>;<3B>;<3B>'<27><17>;<3B>;<3B>#<23>#<23>t<EFBFBD>w<EFBFBD>w<EFBFBD>|<7C>|<7C>3<>$<24>,<2C>T<EFBFBD>W<EFBFBD>W<EFBFBD>]<5D>]<5D>O<EFBFBD><C<01><1F>;<3B>;<3B>,<2C>,<2C>-<2D>.,<2C>,<2C>-<2D>-<2D>#<23>k<EFBFBD>k<EFBFBD>1<>1<>$<24>'<27>'<27>-<2D>-<2D>@<40><04> <0B>"&<26>,<2C>,<2C>t<EFBFBD>w<EFBFBD>w<EFBFBD><04> <0B> <0B>"D<>D<EFBFBD> <1F> <0F> <1F> <1F>#<23>2<>2<>D<EFBFBD> <1C> <10> <1F> <1F><04> 8<> 8<> 9<> <0F> <1F> <1F>#<23>2<>2<>D<EFBFBD> <1C><1A><04>
<EFBFBD> <11> <1F> <1F><04> 8<> 8<> 9<><19><04>
rac<00>D<00>tj|jd<01> S)zReturn whether face is colored.r<>)r r<r3res r`<00>get_fillzCollection.get_fill<6C>s<00><00><18>)<29>)<29>$<24>*B<>*B<>F<EFBFBD>K<>K<>Krac<00>r<00>tjj||<01>|j|_|j|_|j
|_|j |_|j|_|j|_|j|_ |j|_
|j|_ |j|_ |j|_ |j|_|j|_|j |_|j"|_|j$|_d|_y)z#Copy properties from other to self.TN)rrA<00> update_fromr<6D>r@r?r?r7r>r3r,r<r:r9r<>r<>rJr-r.rj)r]<00>others r`rYzCollection.update_from<6F>s<><00><00> <0F> <0A> <0A>!<21>!<21>$<24><05>.<2E>"<22>0<>0<><04><1A>#<23>2<>2<><04><1B>$<24>4<>4<><04><1C>#(<28>#<<3C>#<<3C><04> <20> <20>,<2C>,<2C><04><18>$<24>4<>4<><04><1C>#(<28>#<<3C>#<<3C><04> <20> <20>,<2C>,<2C><04><18> <20>,<2C>,<2C><04><18> <20>,<2C>,<2C><04><18>#<23>2<>2<><04><1B> <20>,<2C>,<2C><04><18><1B>l<EFBFBD>l<EFBFBD><04> <0B><18>(<28>(<28><04><07><19>J<EFBFBD>J<EFBFBD><04> <09><19>J<EFBFBD>J<EFBFBD><04> <09><19><04>
rarc)@r<><00>
__module__<EFBFBD> __qualname__<5F>__doc__rT<00>emptyrnr;r <00>interpdr7rfrlrorxrzr<>r<>r<>r<00>allow_rasterizationr<6E>rLr<>r<>rMr<>rNr<>r<>r<>r<>r<>rrIrJrPr rRr<00> staticmethodrrrKrr&r(r-rGr<>r<>r9r=rHrDrArBrFrHrOr<>rWrY<00> __classcell__<5F>r_s@r`r&r&s<><00><><00><08>F<1B>"<22>(<28>(<28>9<EFBFBD>%<25>K<EFBFBD><1A>M<EFBFBD><0F><17><17> <20> <20> <20>#<23><1E><1F>"<22><1D>"&<26><1A><1A><1F><1F><1B><1A><19>!C<1B><18>C<1B>J<1B><1A> <20>&<26>2<>C&<26>J@<01>
"5<>H <0C><1F><1F>W<1B> <20>W<1B>r &<26> <20>+<2B>8 <1A><1A> <1A>D<1B>#<23>%<25><1A>$L<01>
/<2F><1A>(.<2E>B<10><17><17>&<26><18>&<26><10><17><17>?<3F><18>?<3F><10><17><17>(<28><18>(<28><10><17><17>A<01><18>A<01><12>#"<22><12>#"<22>J"<22> <1A>1<><1E> /<2F><1A><1F>" <20>$<24> /<2F><1A>&<1F>$6<> <1F> <0A> <0A>:<3A>:<3A>B<>B<>I<EFBFBD><15> <20> <20> !<21>D$<1A>LL<01>rar&c<00>R<00><00>eZdZdZdZd<03>Zdd<04>Zej<00>fd<05><08>Z <09>xZ
S)<07>_CollectionWithSizeszA
Base class for collections that have an array of sizes.
<20><00>?c<00><00>|jS)z<>
Return the sizes ('areas') of the elements in the collection.
Returns
-------
array
The 'area' of each element.
)<01>_sizesres r`<00> get_sizesz_CollectionWithSizes.get_sizes<65>s<00><00><14>{<7B>{<7B>rac<00><><00>|<01><tjg<00>|_tjd<02>|_d |_
ytj
|<01>|_tj t|j<00>ddf<03>|_tj|j<00>|zdz |jz}||jdd<01>ddf<||jdd<01>ddf<d|jdd<01>ddf<d |_
y)
aI
Set the sizes of each member of the collection.
Parameters
----------
sizes : `numpy.ndarray` or None
The size to set for each element of the collection. The
value is the 'area' of the element.
dpi : float, default: 72
The dpi of the canvas.
Nr'r(<00>R@rrrfr5T) rT<00>arrayrhr^rnr r<>r<><00>sqrt<72>_factorrj)r]<00>sizes<65>dpi<70>scales r`<00> set_sizesz_CollectionWithSizes.set_sizes<65>s<><00><00> <11>=<3D><1C>(<28>(<28>2<EFBFBD>,<2C>D<EFBFBD>K<EFBFBD>!<21>x<EFBFBD>x<EFBFBD> <09>2<>D<EFBFBD> <1C><1A><04>
<EFBFBD> <1D>*<2A>*<2A>U<EFBFBD>+<2B>D<EFBFBD>K<EFBFBD>!<21>x<EFBFBD>x<EFBFBD><13>T<EFBFBD>[<5B>[<5B>)9<>1<EFBFBD>a<EFBFBD>(@<40>A<>D<EFBFBD> <1C><16>G<EFBFBD>G<EFBFBD>D<EFBFBD>K<EFBFBD>K<EFBFBD>(<28>3<EFBFBD>.<2E><14>5<><04> <0C> <0C>D<>E<EFBFBD>(-<2D>D<EFBFBD> <1C> <1C>Q<EFBFBD><01>1<EFBFBD>W<EFBFBD> %<25>(-<2D>D<EFBFBD> <1C> <1C>Q<EFBFBD><01>1<EFBFBD>W<EFBFBD> %<25>(+<2B>D<EFBFBD> <1C> <1C>Q<EFBFBD><01>1<EFBFBD>W<EFBFBD> %<25><19><04>
rac<00><><00><01>|j|j|jd<01><02>j<00>t<00>|<00>|<01>y<00>NTr<54>)rrrhr<>rpr6r<><00>r]r<>r_s <20>r`r<>z_CollectionWithSizes.draw<61>s2<00><><00> <0C><0E><0E>t<EFBFBD>{<7B>{<7B>D<EFBFBD>O<EFBFBD>O<EFBFBD><14>O<EFBFBD>$><3E>$B<>$B<>C<> <0A><07> <0C>X<EFBFBD>ra)rk) r<>r[r\r]rnrirrrr`r<>rbrcs@r`rere<00>s3<00><><00><08><12>G<EFBFBD> <1B><1A>0 <0C><1F><1F><1F> <20>rarec<00><<00><00>eZdZdZd <09>fd<03> Zd<04>Zdddd<07>fd<08>Z<06>xZS)
<EFBFBD>PathCollectionzO
A collection of `~.path.Path`\s, as created by e.g. `~.Axes.scatter`.
Nc <00>v<00><01>t<00>|<00>di|<03><01>|j|<01>|j|<02>d|_y)a<>
Parameters
----------
paths : list of `.path.Path`
The paths that will make up the `.Collection`.
sizes : array-like
The factor by which to scale each drawn `~.path.Path`. One unit
squared in the Path's data space is scaled to be ``sizes**2``
points when rendered.
**kwargs
Forwarded to `.Collection`.
TNr<4E>)r6r7rlrrrj)r]rkror^r_s <20>r`r7zPathCollection.__init__<5F>s4<00><><00> <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>u<EFBFBD><1D> <0C><0E><0E>u<EFBFBD><1D><19><04>
rac<00><00>|jSrcrdres r`rfzPathCollection.get_paths rgrar <00>autoc<00><00>|Srcr<>)r<>s r`<00><lambda>zPathCollection.<lambda>s<00><00><11>rac <00><><00>g}g}|j<00>du}|<03>"tjjdd<03><04>}n/t |t
<00>rtjj |<03>}|j<00>|dk(rb|stjd<06>||fStj|j<00><00>} |jdtjd<00>}
nJ|d k(r6tj|j<00><00>} |jd
d <0B>} ntd |<01>d <0A><03><00>|| <09>} |j j#| j%<00>| j'<00><00>|j j)| j%<00>| j'<00><00>|dk(rd}t+| <09>|krd}|<02> | } || <0A>}<0E>n<>|dk(r|j<00>}n|d k(r|j<00>}t |tjj,<00>r|}ngtj.|<02>r tjj1|<02>}n2t3|<02>}tjj5||dz
gd<11><01><12>}|j7|<0F>j%<00>||<0F>j'<00><00>}|||<0F>j%<00>k\|||<0F>j'<00>kz}||}tj8|j%<00>|j'<00>d<13>}||<12>}tj:|<13>}tj<|||||<00>} |j?<00>d|jA<00>d<15>|<05>}tC| |<0E>D]<5D>\}}|dk(r!|jE|jG|<16><00>} n1|d k(r,tjH|<16>}
tjJ|
d<16>r<01>]tMjNdgdgfd 
|jQ<00>dd<18>|<15><01>}|jS|<18>tU|d<19>r|jW|<0E>||<17>}|jS|<19><00><>||fS)a
Create legend handles and labels for a PathCollection.
Each legend handle is a `.Line2D` representing the Path that was drawn,
and each label is a string that represents the Path.
This is useful for obtaining a legend for a `~.Axes.scatter` plot;
e.g.::
scatter = plt.scatter([1, 2, 3], [4, 5, 6], c=[7, 2, 3], num=None)
plt.legend(*scatter.legend_elements())
creates three legend elements, one for each color with the numerical
values passed to *c* as the labels.
Also see the :ref:`automatedlegendcreation` example.
Parameters
----------
prop : {"colors", "sizes"}, default: "colors"
If "colors", the legend handles will show the different colors of
the collection. If "sizes", the legend will show the different
sizes. To set both, use *kwargs* to directly edit the `.Line2D`
properties.
num : int, None, "auto" (default), array-like, or `~.ticker.Locator`
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 : str, `~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 `~.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 = lambda
x: 10**x``.
**kwargs
Allowed keyword arguments 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
-------
handles : list of `.Line2D`
Visual representation of each element of the legend.
labels : list of str
The string labels for elements of the legend.
NFT)<02> useOffset<65> useMathTextr zfCollection without array used. Make sure to specify the values to be colormapped via the `c` argument.rTzlines.markersizero<00>color<6F>kz?Valid values for `prop` are 'colors' or 'sizes'. You supplied 'z
' instead.rz<00> r)rr5g@r(<00><00><00><00>
)<03>nbins<6E> min_n_ticks<6B>steps<70>r)<02>markeredgewidthrCg<00>)rr<><00>ms<6D>marker<65>set_locs),<2C> get_arrayrC<00>ticker<65>ScalarFormatterrtr1<00>StrMethodFormatter<65>create_dummy_axis<69>warnings<67>warnrT<00>unique<75>poprDrir<><00>axis<69>set_view_interval<61>min<69>max<61>set_data_intervalr<6C><00>LocatorrS<00> FixedLocator<6F>int<6E> MaxNLocator<6F> tick_values<65>linspace<63>argsort<72>interp<72>get_linewidths<68> get_alpharr.r-rm<00>iscloser<00>Line2Drfr<>rvr<>)r]<00>prop<6F>num<75>fmt<6D>funcr^<00>handles<65>labels<6C>hasarray<61>urTr<><00>fu<66>values<65> label_values<65>arr<72>loc<6F>cond<6E>yarr<72>xarr<72>ix<69>kw<6B>val<61>lab<61>h<>ls r`<00>legend_elementszPathCollection.legend_elementss<><00><00>~<15><07><13><06><17>><3E>><3E>#<23>4<EFBFBD>/<2F><08> <0E>;<3B><15>*<2A>*<2A>,<2C>,<2C>u<EFBFBD>$<24>,<2C>O<>C<EFBFBD> <17><03>S<EFBFBD> !<21><15>*<2A>*<2A>/<2F>/<2F><03>4<>C<EFBFBD> <0B><1D><1D><1F> <0F>8<EFBFBD> <1B><1B><18> <0A> <0A>.<2E>/<2F><1F><06><EFBFBD>&<26><12> <09> <09>$<24>.<2E>.<2E>*<2A>+<2B>A<EFBFBD><19>:<3A>:<3A>f<EFBFBD>c<EFBFBD>l<EFBFBD>l<EFBFBD>3E<33>&F<>G<>D<EFBFBD> <11>W<EFBFBD>_<EFBFBD><12> <09> <09>$<24>.<2E>.<2E>*<2A>+<2B>A<EFBFBD><1A>J<EFBFBD>J<EFBFBD>w<EFBFBD><03>,<2C>E<EFBFBD><1C>7<>7;<3B>f<EFBFBD>J<EFBFBD>H<01>I<01> I<01><12>!<21>W<EFBFBD><02> <0B><08><08>"<22>"<22>2<EFBFBD>6<EFBFBD>6<EFBFBD>8<EFBFBD>R<EFBFBD>V<EFBFBD>V<EFBFBD>X<EFBFBD>6<> <0B><08><08>"<22>"<22>2<EFBFBD>6<EFBFBD>6<EFBFBD>8<EFBFBD>R<EFBFBD>V<EFBFBD>V<EFBFBD>X<EFBFBD>6<> <0E>&<26>=<3D><13>C<EFBFBD><12>1<EFBFBD>v<EFBFBD><13>}<7D><1A><03> <0E>;<3B><16>F<EFBFBD><1F><06><<3C>L<EFBFBD><13>x<EFBFBD><1F><1A>n<EFBFBD>n<EFBFBD>&<26><03><15><17><1F><1A>n<EFBFBD>n<EFBFBD>&<26><03><19>#<23>s<EFBFBD>z<EFBFBD>z<EFBFBD>1<>1<>2<><19><03><13><1B><1B>S<EFBFBD>!<21><19>j<EFBFBD>j<EFBFBD>-<2D>-<2D>c<EFBFBD>2<><03><19>#<23>h<EFBFBD><03><19>j<EFBFBD>j<EFBFBD>,<2C>,<2C>3<EFBFBD>C<EFBFBD><01>E<EFBFBD>3N<33>-<2D>P<01><03><1E>?<3F>?<3F>4<EFBFBD><03>9<EFBFBD>=<3D>=<3D>?<3F>D<EFBFBD><13>I<EFBFBD>M<EFBFBD>M<EFBFBD>O<EFBFBD>L<>L<EFBFBD>!<21>T<EFBFBD>#<23>Y<EFBFBD>]<5D>]<5D>_<EFBFBD>4<>!<21>T<EFBFBD>#<23>Y<EFBFBD>]<5D>]<5D>_<EFBFBD>4<>6<>D<EFBFBD>'<27><04>-<2D>L<EFBFBD><15>;<3B>;<3B>s<EFBFBD>w<EFBFBD>w<EFBFBD>y<EFBFBD>#<23>'<27>'<27>)<29>S<EFBFBD>9<>D<EFBFBD><17><04>:<3A>D<EFBFBD><13><1A><1A>D<EFBFBD>!<21>B<EFBFBD><17>Y<EFBFBD>Y<EFBFBD>|<7C>T<EFBFBD>"<22>X<EFBFBD>t<EFBFBD>B<EFBFBD>x<EFBFBD>@<40>F<EFBFBD>!%<25>!4<>!4<>!6<>q<EFBFBD>!9<><1B>~<7E>~<7E>'<27><18><16><18><02><1C>F<EFBFBD>L<EFBFBD>1<> <1D>H<EFBFBD>C<EFBFBD><13><13>x<EFBFBD><1F><1C> <09> <09>$<24>)<29>)<29>C<EFBFBD>.<2E>1<><05><15><17><1F><19>w<EFBFBD>w<EFBFBD>s<EFBFBD>|<7C><04><15>:<3A>:<3A>d<EFBFBD>C<EFBFBD>(<28><1C><16> <0A> <0A>q<EFBFBD>c<EFBFBD>A<EFBFBD>3<EFBFBD>@<01>2<EFBFBD>U<EFBFBD>t<EFBFBD>%)<29>^<5E>^<5E>%5<>a<EFBFBD>%8<>@<01><><3E>@<01>A<EFBFBD> <13>N<EFBFBD>N<EFBFBD>1<EFBFBD> <1D><16>s<EFBFBD>J<EFBFBD>'<27><13> <0C> <0C>\<5C>*<2A><13>C<EFBFBD><08>A<EFBFBD> <12>M<EFBFBD>M<EFBFBD>!<21> <1C> <1D><17><06><EFBFBD>rarc)r<>r[r\r]r7rfr<>rbrcs@r`rwrw<00>s$<00><><00><08><1A>&<1B>$,<2C><16> <20>{<7B>Jrarwc<00>8<00><00>eZdZddd<02><01>fd<03> Zdd<04>ZeZd<05>Z<06>xZS)<08>PolyCollectionT)<01>closedc <00>x<00><01>t<00>|<00>di|<04><01>|j|<02>|j||<03>d|_y)aA
Parameters
----------
verts : list of array-like
The sequence of polygons [*verts0*, *verts1*, ...] where each
element *verts_i* defines the vertices of polygon *i* as a 2D
array-like of shape (M, 2).
sizes : array-like, default: None
Squared scaling factors for the polygons. The coordinates of each
polygon *verts_i* are multiplied by the square-root of the
corresponding entry in *sizes* (i.e., *sizes* specify the scaling
of areas). The scaling is applied before the Artist master
transform.
closed : bool, default: True
Whether the polygon should be closed by adding a CLOSEPOLY
connection at the end.
**kwargs
Forwarded to `.Collection`.
TNr<4E>)r6r7rr<00> set_vertsrj)r]<00>vertsror<>r^r_s <20>r`r7zPolyCollection.__init__<5F>s6<00><><00>( <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>u<EFBFBD><1D> <0C><0E><0E>u<EFBFBD>f<EFBFBD>%<25><19><04>
rac<00>J<00>d|_t|tjj<00>r2|j t <00>jtj<00>}|s)|D<00>cgc]}tj|<03><00><02>c}|_ yt|tj<00>r<>t|j<00>dk(r<>tj||dd<02>dd<04>ffd<04><05>}tj |jdtjj"<00><06>}tjj$|ddtjj&|d<tjj(|d<|D<00>cgc]}tj||<05><00><02>c}|_ yg|_ |D]t}t|<03>r9|jj+tjj-|<03><00><00>G|jj+tj|<03><00><00>vycc}wcc}w) a<>
Set the vertices of the polygons.
Parameters
----------
verts : list of array-like
The sequence of polygons [*verts0*, *verts1*, ...] where each
element *verts_i* defines the vertices of polygon *i* as a 2D
array-like of shape (M, 2).
closed : bool, default: True
Whether the polygon should be closed by adding a CLOSEPOLY
connection at the end.
TNr(r<00>r<><00><01>dtyper<00><><EFBFBD><EFBFBD><EFBFBD>)rjrtrTr<>r<><00>astyperVr<>r<>r<>r<>r\<00>ndarrayr<79>rW<00> concatenater^<00> code_type<70>LINETO<54>MOVETO<54> CLOSEPOLYr<59><00>_create_closed)r]r<>r<><00>xy<78> verts_padr<64>s r`r<>zPolyCollection.set_verts<74>s<><00><00><1A><04>
<EFBFBD> <15>e<EFBFBD>R<EFBFBD>U<EFBFBD>U<EFBFBD>.<2E>.<2E> /<2F><19>L<EFBFBD>L<EFBFBD><15>'<27>.<2E>.<2E>r<EFBFBD>v<EFBFBD>v<EFBFBD>6<>E<EFBFBD><16>49<34>:<3A>b<EFBFBD>5<EFBFBD>:<3A>:<3A>b<EFBFBD>><3E>:<3A>D<EFBFBD>K<EFBFBD> <12> <16>e<EFBFBD>R<EFBFBD>Z<EFBFBD>Z<EFBFBD> (<28>S<EFBFBD><15><1B><1B>-=<3D><11>-B<><1A><0E><0E><05>u<EFBFBD>Q<EFBFBD><02><11><02>U<EFBFBD>|<7C>'<<3C>1<EFBFBD>E<>I<EFBFBD><17>H<EFBFBD>H<EFBFBD>Y<EFBFBD>_<EFBFBD>_<EFBFBD>Q<EFBFBD>/<2F>u<EFBFBD>z<EFBFBD>z<EFBFBD>7K<37>7K<37>L<>E<EFBFBD><1C>z<EFBFBD>z<EFBFBD>(<28>(<28>E<EFBFBD>!<21>H<EFBFBD><1C>z<EFBFBD>z<EFBFBD>(<28>(<28>E<EFBFBD>!<21>H<EFBFBD><1D>
<EFBFBD>
<EFBFBD>,<2C>,<2C>E<EFBFBD>"<22>I<EFBFBD>;D<>E<>R<EFBFBD>5<EFBFBD>:<3A>:<3A>b<EFBFBD>%<25>0<>E<>D<EFBFBD>K<EFBFBD> <12><18><04> <0B><17> 3<>B<EFBFBD><12>2<EFBFBD>w<EFBFBD><14> <0B> <0B>"<22>"<22>5<EFBFBD>:<3A>:<3A>#<<3C>#<<3C>R<EFBFBD>#@<40>A<><14> <0B> <0B>"<22>"<22>5<EFBFBD>:<3A>:<3A>b<EFBFBD>><3E>2<>  3<><33>!;<3B><>Fs <00>$H<04>4H c<00><00>t|<01>t|<02>k7r td<01><00>t||<02>D<00><03>cgc];\}}t|<03>rtj||<04>ntj|<03><00><02>=c}}|_d|_ycc}}w)z$Initialize vertices with path codes.zB'codes' must be a 1D list or array with the same length of 'verts'TN)r<>r<>rr<>r<>r\rj)r]r<>r<>r<><00>cdss r`<00>set_verts_and_codesz"PolyCollection.set_verts_and_codes<65>sw<00><00> <0E>u<EFBFBD>:<3A><13>U<EFBFBD><1A> #<23><1C>?<3F>@<01> @<01>'*<2A>%<25><15>&7<>9<>"<22>2<EFBFBD>s<EFBFBD>/2<>"<22>g<EFBFBD>u<EFBFBD>z<EFBFBD>z<EFBFBD>"<22>c<EFBFBD>*<2A>5<EFBFBD>:<3A>:<3A>b<EFBFBD>><3E>I<>9<><04> <0B><19><04>
<EFBFBD><EFBFBD>9s<00>ABrc)T)r<>r[r\r7r<>rlr<>rbrcs@r`r<>r<><00>s!<00><><00><1A>D<EFBFBD><1A>2(3<>T<1A>I<EFBFBD>rar<>c<00><><00><00>eZdZdZdddd<04><03>fd<05>
Zed<06><00>Zed<07><00>Zdd<08>d <09>Z d
<EFBFBD>Z
d <0B>Z d <0C>Z ed <0A><00>Z d<0E>Zed<0F><00>Zed<10><00>Zd<11>Z<12>xZS)<12>FillBetweenPolyCollectionzK
`.PolyCollection` that fills the area between two x- or y-curves.
NF)<03>where<72> interpolate<74>stepc <00>x<00><01>||_||_||_|j||||<05>} t <00>
|<00>| fi|<08><01>y)aY
Parameters
----------
t_direction : {{'x', 'y'}}
The axes on which the variable lies.
- 'x': the curves are ``(t, f1)`` and ``(t, f2)``.
- 'y': the curves are ``(f1, t)`` and ``(f2, t)``.
t : array-like
The ``t_direction`` coordinates of the nodes defining the curves.
f1 : array-like or float
The other coordinates of the nodes defining the first curve.
f2 : array-like or float
The other coordinates of the nodes defining the second curve.
where : array-like of bool, optional
Define *where* to exclude some {dir} regions from being filled.
The filled regions are defined by the coordinates ``t[where]``.
More precisely, fill between ``t[i]`` and ``t[i+1]`` if
``where[i] and where[i+1]``. Note that this definition implies
that an isolated *True* value between two *False* values in *where*
will not result in filling. Both sides of the *True* position
remain unfilled due to the adjacent *False* values.
interpolate : bool, default: False
This option is only relevant if *where* is used and the two curves
are crossing each other.
Semantically, *where* is often used for *f1* > *f2* or
similar. By default, the nodes of the polygon defining the filled
region will only be placed at the positions in the *t* array.
Such a polygon cannot describe the above semantics close to the
intersection. The t-sections containing the intersection are
simply clipped.
Setting *interpolate* to *True* will calculate the actual
intersection point and extend the filled region up to this point.
step : {{'pre', 'post', 'mid'}}, optional
Define *step* if the filling should be a step function,
i.e. constant in between *t*. The value determines where the
step will occur:
- 'pre': The f value is continued constantly to the left from
every *t* position, i.e. the interval ``(t[i-1], t[i]]`` has the
value ``f[i]``.
- 'post': The y value is continued constantly to the right from
every *x* position, i.e. the interval ``[t[i], t[i+1])`` has the
value ``f[i]``.
- 'mid': Steps occur half-way between the *t* positions.
**kwargs
Forwarded to `.PolyCollection`.
See Also
--------
.Axes.fill_between, .Axes.fill_betweenx
N)<06> t_direction<6F> _interpolate<74>_step<65> _make_vertsr6r7) r]r<><00>t<>f1<66>f2r<32>r<>r<>r^r<>r_s <20>r`r7z"FillBetweenPolyCollection.__init__<5F>sE<00><><00>@'<27><04><18>'<27><04><19><19><04>
<EFBFBD><14> <20> <20><11>B<EFBFBD><02>E<EFBFBD>2<><05> <0A><07><18><15>)<29>&<26>)rac<00>:<00>|dk(ry|dk(ryd|<00><02>}t|<01><00>)z/The direction that is other than `t_direction`.r<>r<>z$t_direction must be 'x' or 'y', got )r<>)r<><00>msgs r`<00> _f_dir_from_tz'FillBetweenPolyCollection._f_dir_from_t6s0<00><00> <17>#<23> <1D><16> <18>C<EFBFBD> <1F><16>8<><1B><0F>H<>C<EFBFBD><1C>S<EFBFBD>/<2F> !rac<00>8<00>|j|j<00>S)z4The direction that is other than `self.t_direction`.)r<>r<>res r`<00> _f_directionz&FillBetweenPolyCollection._f_directionAs<00><00><14>!<21>!<21>$<24>"2<>"2<>3<>3ra)r<>c<00><><00>|jj|j|j|||<03>\}}}|j ||||<04>}|j |<05>y)a-
Set new values for the two bounding curves.
Parameters
----------
t : array-like
The ``self.t_direction`` coordinates of the nodes defining the curves.
f1 : array-like or float
The other coordinates of the nodes defining the first curve.
f2 : array-like or float
The other coordinates of the nodes defining the second curve.
where : array-like of bool, optional
Define *where* to exclude some {dir} regions from being filled.
The filled regions are defined by the coordinates ``t[where]``.
More precisely, fill between ``t[i]`` and ``t[i+1]`` if
``where[i] and where[i+1]``. Note that this definition implies
that an isolated *True* value between two *False* values in *where*
will not result in filling. Both sides of the *True* position
remain unfilled due to the adjacent *False* values.
See Also
--------
.PolyCollection.set_verts, .Line2D.set_data
N)rw<00>_fill_between_process_unitsr<73>r<>r<>r<>)r]r<>r<>r<>r<>r<>s r`<00>set_dataz"FillBetweenPolyCollection.set_dataFsY<00><00>8<19>I<EFBFBD>I<EFBFBD>9<>9<> <10> <1C> <1C>d<EFBFBD>/<2F>/<2F><11>B<EFBFBD><02><<3C> <09><01>2<EFBFBD>r<EFBFBD><15> <20> <20><11>B<EFBFBD><02>E<EFBFBD>2<><05> <0C><0E><0E>u<EFBFBD>rac<00> <00>tjj<00>}|j|j <00>|z
j t j|j|jjgg<02><00><00>|S)z7Calculate the data limits and return them as a `.Bbox`.)
rr~rr<>r|r<>rTr<><00>_bbox<6F>minpos)r]r<><00>datalims r`r<>z%FillBetweenPolyCollection.get_datalimhse<00><00><1C>/<2F>/<2F>&<26>&<26>(<28><07><0F>#<23>#<23>T<EFBFBD>%7<>%7<>%9<>I<EFBFBD>%E<>$P<>$P<> <0E>N<EFBFBD>N<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD><14><1A><1A>):<3A>):<3A>(;<3B><<3C> =<3D>%?<3F> @<01><16>rac<00><><00>|j|j|j|||<03>|j||||<04>}t j
t j |<01>||d<01><02>\}}}tjj<00>|_
|jj|jt j||fD<00>cgc]!}t j||||fd<03><04><00><02>#c}<05><00><00>tj |<04>D<00><06>cgc]\}}|j#|||||<07><00><02>c}}Scc}wcc}}w)zH
Make verts that can be forwarded to `.PolyCollection`.
T)<01>subokr<6B>r<>)<12>_validate_shapesr<73>r<><00>_get_data_maskrT<00>broadcast_arraysrrr~rr<>r<><00>_fix_pts_xy_orderr<72><00>stackr <00>contiguous_regions<6E>_make_verts_for_region)r]r<>r<>r<>r<><00>f<>idx0<78>idx1s r`r<>z%FillBetweenPolyCollection._make_vertsos <00><00> <0A><1D><1D>d<EFBFBD>.<2E>.<2E><04>0A<30>0A<30>1<EFBFBD>b<EFBFBD>"<22>M<><14>#<23>#<23>A<EFBFBD>r<EFBFBD>2<EFBFBD>u<EFBFBD>5<><05><16>'<27>'<27><02> <0A> <0A>a<EFBFBD>(8<>"<22>b<EFBFBD><04>M<> <09><01>2<EFBFBD>r<EFBFBD><1F>_<EFBFBD>_<EFBFBD>)<29>)<29>+<2B><04>
<EFBFBD> <0C>
<EFBFBD>
<EFBFBD>&<26>&<26>t<EFBFBD>'=<3D>'=<3D>b<EFBFBD>n<EFBFBD>n<EFBFBD>>@<40>"<22>X<EFBFBD>NG<01>89<38>B<EFBFBD>H<EFBFBD>H<EFBFBD>a<EFBFBD><05>h<EFBFBD><01>%<25><08>)<29><02> 3<>NG<01>?H<01>(I<01> J<01>
$<24>6<>6<>u<EFBFBD>=<3D>
<EFBFBD><1A><04>d<EFBFBD> <11> '<27> '<27><01>2<EFBFBD>r<EFBFBD>4<EFBFBD><14> ><3E>
<EFBFBD>
<EFBFBD><EFBFBD>NG<01><>
s <00>&D6<10>D;c
<00><><00>|<04>d}nptj|t<00><02>}|j|jk7r<dj |j|j
|j<00>}t |<05><00>|tjtjttjj|||g<03><00>zS)z<>
Return a bool array, with True at all points that should eventually be rendered.
The array is True at a point if none of the data inputs
*t*, *f1*, *f2* is masked and if the input *where* is true at that point.
Tr<54>z-where size ({}) does not match {!r} size ({})) rTr r!rT<00>formatr<74>r<><00> functools<6C>reduce<63>
logical_or<EFBFBD>mapr<70><00> getmaskarray)r]r<>r<>r<>r<>r<>s r`r<>z(FillBetweenPolyCollection._get_data_mask<73>s<><00><00> <11>=<3D><18>E<EFBFBD><16>J<EFBFBD>J<EFBFBD>u<EFBFBD>D<EFBFBD>1<>E<EFBFBD><14>z<EFBFBD>z<EFBFBD>Q<EFBFBD>V<EFBFBD>V<EFBFBD>#<23>E<>L<>L<><19>J<EFBFBD>J<EFBFBD><04> 0<> 0<>!<21>&<26>&<26>:<3A><03> <20><13>o<EFBFBD>%<25><14> <09>(<28>(<28> <0E>M<EFBFBD>M<EFBFBD>3<EFBFBD>r<EFBFBD>u<EFBFBD>u<EFBFBD>1<>1<>A<EFBFBD>r<EFBFBD>2<EFBFBD>;<3B>?<3F>A<01>A<01>A<01> Arac<00>p<00>d<01>t|||fd<02>D<00>}t||||g<03>D]<5D>\}}|jdkDrt|<06>d<04><02><00>|jdkDs<01>3|jdkDs<01>C|j|jk7s<01>]dj ||j||j<00>}t|<08><00>y)zFValidate that t, f1 and f2 are 1-dimensional and have the same length.c3<00>,K<00>|] \}}||z<00><01><00>y<00>wrcr<>)r<>r<00>ss r`r<>z=FillBetweenPolyCollection._validate_shapes.<locals>.<genexpr><3E>s<00><00><><00>N<>4<EFBFBD>1<EFBFBD>a<EFBFBD><11>Q<EFBFBD><15>N<>s<00>)r<><00>1<>2rz is not 1-dimensionalz4{!r} has size {}, but {!r} has an unequal size of {}N)rrQr<>rTr<>) <09>t_dir<69>f_dirr<72>r<>r<><00>namesr rlr<>s r`r<>z*FillBetweenPolyCollection._validate_shapes<65>s<><00><00>O<01>3<EFBFBD><05>u<EFBFBD>e<EFBFBD>'<<3C>n<EFBFBD>#M<>N<><05><1E>u<EFBFBD>q<EFBFBD>"<22>b<EFBFBD>k<EFBFBD>2<> &<26>K<EFBFBD>D<EFBFBD>%<25><14>z<EFBFBD>z<EFBFBD>A<EFBFBD>~<7E> <20>D<EFBFBD>8<EFBFBD>+@<40>!A<>B<>B<><10>v<EFBFBD>v<EFBFBD><01>z<EFBFBD>e<EFBFBD>j<EFBFBD>j<EFBFBD>1<EFBFBD>n<EFBFBD><11><16><16>5<EFBFBD>:<3A>:<3A>1E<31>L<>S<>S<><19>1<EFBFBD>6<EFBFBD>6<EFBFBD>4<EFBFBD><15><1A><1A>5<><03> <20><13>o<EFBFBD>%<25>  &rac <00>2<00>|||}|||}|||}|j<00>.tjd|jz} | |||<08>\}}}|jr)|j ||||<04>}
|j ||||<05>} n|d|df}
|d|df} t j t j|
g<01>t j||fd<04><05>t j| g<01>t j||fd<04><05>ddd<04>f<04>} |j| <0C>S)z<>
Make ``verts`` for a contiguous region between ``idx0`` and ``idx1``, taking
into account ``step`` and ``interpolate``.
Nzsteps-rr<>r<>)
r<EFBFBD>r <00>STEP_LOOKUP_MAPr<50><00>_get_interpolating_pointsrTr<>r r<>r<>) r]r<>r<>r<>r<>r<><00>t_slice<63>f1_slice<63>f2_slice<63> step_func<6E>start<72>end<6E>ptss r`r<>z0FillBetweenPolyCollection._make_verts_for_region<6F>s)<00><00>
<14>D<EFBFBD><14>,<2C><07><15>d<EFBFBD>4<EFBFBD>=<3D><08><15>d<EFBFBD>4<EFBFBD>=<3D><08> <0F>:<3A>:<3A> !<21><1D>-<2D>-<2D>h<EFBFBD><14><1A><1A>.C<>D<>I<EFBFBD>*3<>G<EFBFBD>X<EFBFBD>x<EFBFBD>*P<> '<27>G<EFBFBD>X<EFBFBD>x<EFBFBD> <0F> <1C> <1C><18>2<>2<>1<EFBFBD>b<EFBFBD>"<22>d<EFBFBD>C<>E<EFBFBD><16>0<>0<><11>B<EFBFBD><02>D<EFBFBD>A<>C<EFBFBD><1C>A<EFBFBD>J<EFBFBD><08><11> <0B>+<2B>E<EFBFBD><19>"<22>+<2B>x<EFBFBD><02>|<7C>+<2B>C<EFBFBD><10>n<EFBFBD>n<EFBFBD> <0E>J<EFBFBD>J<EFBFBD><05>w<EFBFBD> <1F> <0E>H<EFBFBD>H<EFBFBD>g<EFBFBD>x<EFBFBD>(<28>r<EFBFBD> 2<> <0E>J<EFBFBD>J<EFBFBD><03>u<EFBFBD> <1D> <0E>H<EFBFBD>H<EFBFBD>g<EFBFBD>x<EFBFBD>(<28>r<EFBFBD> 2<>4<EFBFBD>R<EFBFBD>4<EFBFBD> 8<> :<3A>;<3B><03> <14>%<25>%<25>c<EFBFBD>*<2A>*rac<00><><00>t|dz
d<02>}|||dz}|||dz|||dzz
}|||dz}t|<07>dk(rXtjj |d<00>r
||||fStjj |d<00>r
||||fS|j d||<06>} |j | ||<08>}
| |
fS)zCalculate interpolating points.rrr5)r<>r<>rTr<><00> is_masked<65>_get_diff_root) <0B>clsr<73>r<>r<><00>idx<64>im1<6D>t_values<65> diff_values<65> f1_values<65> diff_root_t<5F> diff_root_fs r`rz3FillBetweenPolyCollection._get_interpolating_points<74>s<><00><00><12>#<23><01>'<27>1<EFBFBD>o<EFBFBD><03><14>S<EFBFBD><13>Q<EFBFBD><15><<3C><08><18><13>S<EFBFBD><11>U<EFBFBD>m<EFBFBD>b<EFBFBD><13>S<EFBFBD><11>U<EFBFBD>m<EFBFBD>3<> <0B><16>s<EFBFBD>3<EFBFBD>q<EFBFBD>5<EFBFBD>M<EFBFBD> <09> <0E>{<7B> <1B>q<EFBFBD> <20><11>u<EFBFBD>u<EFBFBD><EFBFBD><EFBFBD>{<7B>1<EFBFBD>~<7E>.<2E><18><13>v<EFBFBD>r<EFBFBD>#<23>w<EFBFBD><EFBFBD>&<26><13><15><15><1F><1F><1B>Q<EFBFBD><1E>0<><18><13>v<EFBFBD>r<EFBFBD>#<23>w<EFBFBD><EFBFBD>&<26><19>(<28>(<28><11>K<EFBFBD><18>B<> <0B><19>(<28>(<28><1B>h<EFBFBD> <09>J<> <0B><1A>K<EFBFBD>'<27>'rac<00>\<00>|j<00>}tj|||||<00>S)zCalculate diff root.)r<>rTr<>)r<><00>xp<78>fp<66>orders r`rz(FillBetweenPolyCollection._get_diff_root<6F>s*<00><00><13>
<EFBFBD>
<EFBFBD> <0C><05><11>y<EFBFBD>y<EFBFBD><11>B<EFBFBD>u<EFBFBD>I<EFBFBD>r<EFBFBD>%<25>y<EFBFBD>1<>1rac<00><<00>|jdk(r |dd<02>ddd<03>fS|S)z<>
Fix pts calculation results with `self.t_direction`.
In the workflow, it is assumed that `self.t_direction` is 'x'. If this
is not true, we need to exchange the coordinates.
r<>Nr<4E>)r<>)r]rs r`r<>z+FillBetweenPolyCollection._fix_pts_xy_order<65>s(<00><00> $<24>/<2F>/<2F>3<EFBFBD>6<>s<EFBFBD>1<EFBFBD>d<EFBFBD><02>d<EFBFBD>7<EFBFBD>|<7C>?<3F>C<EFBFBD>?ra)r<>r[r\r]r7rar<><00>propertyr<79>r<>r<>r<>r<>r<>r<><00> classmethodrrr<>rbrcs@r`r<>r<><00>s<><00><><00><08>
<17>E<EFBFBD><04>D*<2A>L<12>"<22><12>"<22><0E>4<><0E>4<>,0<> <1E>D<17>
<EFBFBD>$A<01>$<12> &<26><12> &<26>+<2B>:<11>(<28><11>(<28>"<12>2<><12>2<>
@rar<>c<00><><00><00>eZdZdZej
j ZejdzZ
ddd<05><02>fd<06>
Z d<07>Z d<08>Z ejd <09><00>Z<10>xZS)
<EFBFBD>RegularPolyCollectionz)A collection of n-sided regular polygons.<2E><00><>r)r)<02>rotationroc <00><><00><01>t<00>|<00>di|<04><01>|j|<03>||_|j |<01>g|_||_|jtj<00><00>y)a<>
Parameters
----------
numsides : int
The number of sides of the polygon.
rotation : float
The rotation of the polygon in radians.
sizes : tuple of float
The area of the circle circumscribing the polygon in points^2.
**kwargs
Forwarded to `.Collection`.
Examples
--------
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)]
collection = RegularPolyCollection(
numsides=5, # a pentagon
rotation=0, sizes=(50,),
facecolors=facecolors,
edgecolors=("black",),
linewidths=(1,),
offsets=offsets,
offset_transform=ax.transData,
)
Nr<4E>)
r6r7rr<00> _numsides<65>_path_generatorr\<00> _rotation<6F> set_transformrrs)r]<00>numsidesr,ror^r_s <20>r`r7zRegularPolyCollection.__init__<5F>s\<00><><00>F <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>u<EFBFBD><1D>!<21><04><0E><1B>+<2B>+<2B>H<EFBFBD>5<>6<><04> <0B>!<21><04><0E> <0C><1A><1A>:<3A>7<>7<>9<>:rac<00><00>|jSrc)r.res r`<00> get_numsidesz"RegularPolyCollection.get_numsides<00> <00><00><13>~<7E>~<7E>rac<00><00>|jSrc)r0res r`<00> get_rotationz"RegularPolyCollection.get_rotationr5rac<00>Z<00>|j|j|jd<01><02>j<00>|jD<00>cgc]?}t j |<02>j|j <00>j<00><00><02>Ac}|_tj||<01>ycc}wrt) rrrhr<>rprnrr<><00>rotater0<00>
get_matrixr&r<>)r]r<>r<>s r`r<>zRegularPolyCollection.draws<><00><00> <0C><0E><0E>t<EFBFBD>{<7B>{<7B>D<EFBFBD>O<EFBFBD>O<EFBFBD><14>O<EFBFBD>$><3E>$B<>$B<>C<><1A>%<25>%<25>
<EFBFBD><11> <17> <1F> <1F><01> "<22> )<29> )<29>4<EFBFBD>><3E>><3E>/<2F> :<3A> E<> E<> G<>
<EFBFBD><04><18> <13><0F><0F><04>h<EFBFBD>'<27><> 
s<00>AB()r<>r[r\r]r<>r<><00>unit_regular_polygonr/rT<00>pirnr7r4r7rr`r<>rbrcs@r`r*r*<00>sT<00><><00>3<><1B>j<EFBFBD>j<EFBFBD>5<>5<>O<EFBFBD><10>e<EFBFBD>e<EFBFBD><04>o<EFBFBD>G<EFBFBD>
<1C><1B> (;<3B>T<1E><1E> <0C><1F><1F>(<28> <20>(rar*c<00><<00>eZdZdZej
j Zy)<03>StarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r<>r[r\r]r<>r<><00>unit_regular_starr/r<>rar`r>r> s<00><00>D<><1B>j<EFBFBD>j<EFBFBD>2<>2<>Orar>c<00><<00>eZdZdZej
j Zy)<03>AsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r<>r[r\r]r<>r<><00>unit_regular_asteriskr/r<>rar`rArA%s<00><00>H<><1B>j<EFBFBD>j<EFBFBD>6<>6<>OrarAc<00><><00><00>eZdZdZdZdd<04><01>fd<05>
Zd<06>ZeZeZd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z d <0B>Z <0A>fd <0C>Zd <0A>ZeZd<0E>ZeZd<0F>Zd<10>Zd<11>Zd<12>Z<16>xZS)<13>LineCollectiona<6E>
Represents a sequence of `.Line2D`\s that should be drawn together.
This class extends `.Collection` to represent a sequence of
`.Line2D`\s instead of just a sequence of `.Patch`\s.
Just as in `.Collection`, each property of a *LineCollection* may be either
a single value or a list of values. This list is then used cyclically for
each element of the LineCollection, so the property of the ``i``\th element
of the collection is::
prop[i % len(prop)]
The properties of each member of a *LineCollection* default to their values
in :rc:`lines.*` instead of :rc:`patch.*`, and the property *colors* is
added in place of *edgecolors*.
Tr5)r1c <00>n<00><01>|jdd<02>t<00>|<00>dd|i|<03><01>|j|<01>y)a<>
Parameters
----------
segments : list of (N, 2) array-like
A sequence ``[line0, line1, ...]`` where each line is a (N, 2)-shape
array-like containing points::
line0 = [(x0, y0), (x1, y1), ...]
Each line can contain a different number of points.
linewidths : float or list of float, default: :rc:`lines.linewidth`
The width of each line in points.
colors : :mpltype:`color` or list of color, default: :rc:`lines.color`
A sequence of RGBA tuples (e.g., arbitrary color strings, etc, not
allowed).
antialiaseds : bool or list of bool, default: :rc:`lines.antialiased`
Whether to use antialiasing for each line.
zorder : float, default: 2
zorder of the lines once drawn.
facecolors : :mpltype:`color` or list of :mpltype:`color`, default: 'none'
When setting *facecolors*, each line is interpreted as a boundary
for an area, implicitly closing the path from the last point to the
first point. The enclosed area is filled with *facecolor*.
In order to manually specify what should count as the "interior" of
each line, please use `.PathCollection` instead, where the
"interior" can be specified by appropriate usage of
`~.path.Path.CLOSEPOLY`.
**kwargs
Forwarded to `.Collection`.
rr<>r1Nr<4E>)<04>
setdefaultr6r7<00> set_segments)r]<00>segmentsr1r^r_s <20>r`r7zLineCollection.__init__>sC<00><><00>L <0F><19><19>,<2C><06>/<2F> <0A><07><18> <16><19> <16><14> <16> <0A><19><19>(<28>#rac <00><00>|<01>y|D<00>cgc]h}t|tjj<00>rt j
|<02>n,t j
tj |t<00><00><00><02>jc}|_d|_ ycc}wri)
rtrTr<>r<>r<>r<>r rVr\rj)r]rH<00>segs r`rGzLineCollection.set_segmentsjsl<00><00> <13> <1B> <12>#+<2B>,<2C><1E>+5<>S<EFBFBD>"<22>%<25>%<25>:K<>:K<>*L<>u<EFBFBD>z<EFBFBD>z<EFBFBD>#<23><EFBFBD>!<21>J<EFBFBD>J<EFBFBD>r<EFBFBD>z<EFBFBD>z<EFBFBD>#<23>u<EFBFBD>'=<3D>><3E>?<3F>,<2C><04> <0B><1A><04>
<EFBFBD><EFBFBD>,s<00>A-Bc<00><><00>g}|jD]L}|jd<01><02>D<00><03>cgc]\}}|<03><02> }}}tj|<05>}|j |<05><00>N|Scc}}w)z<>
Returns
-------
list
List of segments in the LineCollection. Each list item contains an
array of vertices.
F)<01>simplify)r\<00> iter_segmentsrTr r<>)r]rHr<00>vertex<65>_r<5F>s r`<00> get_segmentszLineCollection.get_segmentsvsu<00><00><16><08><18>K<EFBFBD>K<EFBFBD>
&<26>D<EFBFBD><18>%<25>%<25>u<EFBFBD>%<25>5<> <0E><1D>F<EFBFBD>A<EFBFBD><17><0E>H<EFBFBD><0E><1A>z<EFBFBD>z<EFBFBD>(<28>+<2B>H<EFBFBD> <14>O<EFBFBD>O<EFBFBD>H<EFBFBD> %<25>
&<26><18><0F><>s<00> A c<00>(<00>tjdS)Nzlines.linewidthrres r`rz%LineCollection._get_default_linewidth<74>s<00><00><12>|<7C>|<7C>-<2D>.<2E>.rac<00>(<00>tjdS)Nzlines.antialiasedrres r`rz'LineCollection._get_default_antialiased<65>s<00><00><12>|<7C>|<7C>/<2F>0<>0rac<00>(<00>tjdS)Nz lines.colorrres r`r9z%LineCollection._get_default_edgecolor<6F>s<00><00><12>|<7C>|<7C>M<EFBFBD>*<2A>*rac<00><00>y)Nr<4E>r<>res r`r(z%LineCollection._get_default_facecolor<6F>s<00><00>rac<00>t<00><01>t<00>|<00>|<01>|j<00>|j|j<00>yyrc)r6rDr=<00> set_gapcolor<6F>_original_gapcolor)r]rCr_s <20>r`rDzLineCollection.set_alpha<68>s3<00><><00> <0A><07><19>%<25> <20> <0F>><3E>><3E> %<25> <10> <1D> <1D>d<EFBFBD>5<>5<> 6<> &rac<00>&<00>|j|<01>y)aH
Set the edgecolor(s) of the LineCollection.
Parameters
----------
c : :mpltype:`color` or list of :mpltype:`color`
Single color (all lines have same color), or a
sequence of RGBA tuples; if it is a sequence the lines will
cycle through the sequence.
N)rHr$s r`r&zLineCollection.set_color<6F>s<00><00> <0A><1A><1A>1<EFBFBD>rac<00><00>|jSrc)r7res r`<00> get_colorzLineCollection.get_color<6F>rprac<00>4<00>||_|j|<01>y)a1
Set a color to fill the gaps in the dashed line style.
.. note::
Striped lines are created by drawing two interleaved dashed lines.
There can be overlaps between those two, which may result in
artifacts when using transparency.
This functionality is experimental and may change.
Parameters
----------
gapcolor : :mpltype:`color` or list of :mpltype:`color` or None
The color with which to fill the gaps. If None, the gaps are
unfilled.
N)rW<00> _set_gapcolor<6F>r]<00>gapcolors r`rVzLineCollection.set_gapcolor<6F>s<00><00>$#+<2B><04><1F> <0C><1A><1A>8<EFBFBD>$rac<00>d<00>|<01> tj||j<00>}||_d|_yri)rAr*r+r=rjr]s r`r\zLineCollection._set_gapcolor<6F>s,<00><00> <13> <1F><1E>,<2C>,<2C>X<EFBFBD>t<EFBFBD>{<7B>{<7B>C<>H<EFBFBD>!<21><04><0E><19><04>
rac<00><00>|jSrc)r=res r`<00> get_gapcolorzLineCollection.get_gapcolor<6F>r5rac
<00>H<00>t|jtj|j<00><00>D<00><01>cgc]W\}}|dk(r9t j tjdtj<00><00>|fn|tj|<02>f<02><02>Y}}}t|<03>Scc}}w)a%
Returns the path and pattern for the gaps in the non-solid lines.
This path and pattern is the inverse of the path and pattern used to
construct the non-solid lines. For solid lines, we set the inverse path
to nans to prevent drawing an inverse line.
r3r<>) rr\<00> itertools<6C>cycler:r<>r<>rT<00>fullr<6C>r<00>_get_inverse_dash_pattern)r]rr<00> path_patternss r`r<>z,LineCollection._get_inverse_paths_linestyles<65>s<><00><00> <10><04> <0B> <0B>Y<EFBFBD>_<EFBFBD>_<EFBFBD>T<EFBFBD>-=<3D>-=<3D>><3E> ?<3F> A<01><1B><14>r<EFBFBD><12>Y<EFBFBD><EFBFBD><13>Z<EFBFBD>Z<EFBFBD><02><07><07><06><02><06><06>/<2F> 0<>"<22> 5<> <11>6<EFBFBD>3<>3<>R<EFBFBD>8<> 9<> :<3A>A<01> <0A>A<01><13>M<EFBFBD>"<22>"<22><>As<00>AB)r<>r[r\r]r;r7rGr<>rlrPrrr9r(rDr&<00>
set_colorsrZ<00>
get_colorsrVr\rar<>rbrcs@r`rDrD*su<00><><00><08>"<19>M<EFBFBD><1A>*$<24>X<1A><1D>I<EFBFBD><1C>I<EFBFBD><18>0/<2F>1<>+<2B><16>7<> <1E><1B>J<EFBFBD> <20><1B>J<EFBFBD>%<25>*<1A> <1E>#rarDc<00><><00><00>eZdZdZdZ dddddddd<07><06>fd<08> Zd <09>Zd
<EFBFBD>Zd <0B>ZexZ Z
d <0C>Z d <0A>Z d<0E>Z d<0F>Zd<10>Zd<11>Zd<12>Zd<13>Z<12>fd<14>Z<13>fd<15>Zd<16>Z<15>xZS)<18>EventCollectionz<6E>
A collection of locations along a single axis at which an "event" occurred.
The events are given by a 1-dimensional array. They do not have an
amplitude and are displayed as parallel lines.
TrrNr))<06>
lineoffset<EFBFBD>
linelengthr#r<>r"rc <00><><00><01>t<00>
|<00>gf||||d<01>| <09><01>d|_||_||_|j |<02>|j |<01>y)aY
Parameters
----------
positions : 1D array-like
Each value is an event.
orientation : {'horizontal', 'vertical'}, default: 'horizontal'
The sequence of events is plotted along this direction.
The marker lines of the single events are along the orthogonal
direction.
lineoffset : float, default: 0
The offset of the center of the markers from the origin, in the
direction orthogonal to *orientation*.
linelength : float, default: 1
The total height of the marker (i.e. the marker stretches from
``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).
linewidth : float or list thereof, default: :rc:`lines.linewidth`
The line width of the event lines, in points.
color : :mpltype:`color` or list of :mpltype:`color`, default: :rc:`lines.color`
The color of the event lines.
linestyle : str or tuple or list thereof, 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 : bool or list thereof, default: :rc:`lines.antialiased`
Whether to use antialiasing for drawing the lines.
**kwargs
Forwarded to `.LineCollection`.
Examples
--------
.. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py
)rrr rTN)r6r7<00>_is_horizontal<61> _linelength<74> _lineoffset<65>set_orientation<6F> set_positions) r]<00> positions<6E> orientationrlrmr#r<>r"rr^r_s <20>r`r7zEventCollection.__init__<5F>sd<00><><00>` <0E><07><18><12> #<23>$-<2D>)<29> %<25>K<EFBFBD> #<23>"<22> #<23>#<23><04><1B>%<25><04><18>%<25><04><18> <0C><1C><1C>[<5B>)<29> <0C><1A><1A>9<EFBFBD>%rac<00>z<00>|j<00>rdnd}|j<00>D<00>cgc] }|d|f<00><02> c}Scc}w)zX
Return an array containing the floating-point values of the positions.
rr)<02> is_horizontalrP)r]<00>pos<6F>segments r`<00> get_positionszEventCollection.get_positions(s;<00><00><18>%<25>%<25>'<27>a<EFBFBD>Q<EFBFBD><03>/3<>/@<40>/@<40>/B<>C<>G<EFBFBD><07><01>3<EFBFBD><06><0F>C<>C<><43>Cs<00>8c<00><><00>|<01>g}tj|<01>dk7r td<03><00>|j<00>}|j <00>}|j <00>rdnd}tj t|<01>ddf<03>}tj|<01>dd<01>df|dd<01>dd<01>|f<||dz z|dd<01>dd|z
f<||dz z
|dd<01>dd|z
f<|j|<05>y)z Set the positions of the events.Nrz!positions must be one-dimensionalrr5)
rTrQr<><00>get_lineoffset<65>get_linelengthrwr^r<><00>sortrG)r]rtrlrm<00>pos_idxrHs r`rszEventCollection.set_positions/s<><00><00> <14> <1C><1A>I<EFBFBD> <0A>7<EFBFBD>7<EFBFBD>9<EFBFBD> <1D><11> "<22><1C>@<40>A<> A<><19>(<28>(<28>*<2A>
<EFBFBD><19>(<28>(<28>*<2A>
<EFBFBD><1B>)<29>)<29>+<2B>!<21><11><07><15>8<EFBFBD>8<EFBFBD>S<EFBFBD><19>^<5E>Q<EFBFBD><01>2<>3<><08>"$<24>'<27>'<27>)<29>"4<>Q<EFBFBD><04>W<EFBFBD>"=<3D><08><11>A<EFBFBD>w<EFBFBD><1D><1F>&0<>:<3A><01>><3E>&A<><08><11>A<EFBFBD>q<EFBFBD>7<EFBFBD>{<7B>"<22>#<23>&0<>:<3A><01>><3E>&A<><08><11>A<EFBFBD>q<EFBFBD>7<EFBFBD>{<7B>"<22>#<23> <0C><19><19>(<28>#rac<00><><00>|<01>t|d<02>rt|<01>dk(ry|j<00>}tj|tj
|<01>g<02>}|j |<02>y)z2Add one or more events at the specified positions.Nr<4E>r)rvr<>rzrT<00>hstackrUrs)r]<00>positionrts r`<00> add_positionszEventCollection.add_positions>sX<00><00> <13> <1B><07><08>%<25> 8<> #<23>H<EFBFBD> <0A><11> 2<> <12><18>&<26>&<26>(<28> <09><16>I<EFBFBD>I<EFBFBD>y<EFBFBD>"<22>-<2D>-<2D><08>*A<>B<>C<> <09> <0C><1A><1A>9<EFBFBD>%rac<00><00>|jS)z=True if the eventcollection is horizontal, False if vertical.)rores r`rwzEventCollection.is_horizontalHs<00><00><13>"<22>"<22>"rac<00>*<00>|j<00>rdSdS)zX
Return the orientation of the event line ('horizontal' or 'vertical').
<20>
horizontal<EFBFBD>vertical)rwres r`<00>get_orientationzEventCollection.get_orientationLs<00><00> $<24>1<>1<>3<>|<7C>C<><1A>Crac<00><><00>|j<00>}t|<01>D]\}}tj|<03>||<<00>|j |<01>|j <00> |_d|_y)zv
Switch the orientation of the event line, either from vertical to
horizontal or vice versus.
TN)rP<00> enumeraterT<00>fliplrrGrwrorj)r]rH<00>irys r`<00>switch_orientationz"EventCollection.switch_orientationRse<00><00>
<18>$<24>$<24>&<26><08>#<23>H<EFBFBD>-<2D> -<2D>J<EFBFBD>A<EFBFBD>w<EFBFBD><1C>)<29>)<29>G<EFBFBD>,<2C>H<EFBFBD>Q<EFBFBD>K<EFBFBD> -<2D> <0C><19><19>(<28>#<23>"&<26>"4<>"4<>"6<>6<><04><1B><19><04>
rac<00><><00>tjddd<03>|<01><04>}||j<00>k(ry|j<00>y)z<>
Set the orientation of the event line.
Parameters
----------
orientation : {'horizontal', 'vertical'}
TF)r<>r<>)ruN)r<00> check_getitemrwr<>)r]rurws r`rrzEventCollection.set_orientation^sA<00><00><1D>*<2A>*<2A><1F>U<EFBFBD> 3<>#<23>%<25> <0A> <19>D<EFBFBD>.<2E>.<2E>0<> 0<> <12> <0C><1F><1F>!rac<00><00>|jS)z7Return the length of the lines used to mark each event.)rpres r`r}zEventCollection.get_linelengthm<00><00><00><13><1F><1F>rac<00><00>||j<00>k(ry|j<00>}|j<00>}|j<00>rdnd}|D]}||dz z|d|f<||dz z
|d|f<<00>|j |<03>||_y)z4Set the length of the lines used to mark each event.Nrr<00>@)r}r|rPrwrGrp)r]rmrlrHrxrys r`<00>set_linelengthzEventCollection.set_linelengthq<00><><00><00> <15><14>,<2C>,<2C>.<2E> .<2E> <12><19>(<28>(<28>*<2A>
<EFBFBD><17>$<24>$<24>&<26><08><17>%<25>%<25>'<27>a<EFBFBD>Q<EFBFBD><03><1F> ;<3B>G<EFBFBD>(<28>:<3A><02>?<3F>:<3A>G<EFBFBD>A<EFBFBD>s<EFBFBD>F<EFBFBD>O<EFBFBD>(<28>:<3A><02>?<3F>:<3A>G<EFBFBD>A<EFBFBD>s<EFBFBD>F<EFBFBD>O<EFBFBD> ;<3B> <0A><19><19>(<28>#<23>%<25><04>rac<00><00>|jS)z7Return the offset of the lines used to mark each event.)rqres r`r|zEventCollection.get_lineoffset~r<>rac<00><00>||j<00>k(ry|j<00>}|j<00>}|j<00>rdnd}|D]}||dz z|d|f<||dz z
|d|f<<00>|j |<03>||_y)z4Set the offset of the lines used to mark each event.Nrrr<>)r|r}rPrwrGrq)r]rlrmrHrxrys r`<00>set_lineoffsetzEventCollection.set_lineoffset<65>r<>rac<00>&<00><01>t<00>|<00><00>dS)z3Get the width of the lines used to mark each event.r<00>r6rF<00>r]r_s <20>r`rFzEventCollection.get_linewidth<74>s<00><><00><14>w<EFBFBD>$<24>&<26>q<EFBFBD>)<29>)rac<00> <00><01>t<00>|<00><00>Srcr<>r<>s <20>r`r<>zEventCollection.get_linewidths<68>s<00><><00><14>w<EFBFBD>$<24>&<26>&rac<00>(<00>|j<00>dS)z6Return the color of the lines used to mark each event.r)rires r`rZzEventCollection.get_color<6F>s<00><00><13><EFBFBD><EFBFBD> <20><11>#<23>#ra)r<>)r<>r[r\r]r;r7rzrsr<><00>extend_positions<6E>append_positionsrwr<>r<>rrr}r<>r|r<>rFr<>rZrbrcs@r`rkrk<00>s<><00><><00><08><19>M<EFBFBD>*<2A>8&<26><1E><1D><1F><1B>"<22>!<21>8&<26>tD<01> $<24>&<26>+8<>7<><14>'<27>#<23>D<01>
<1A> "<22> <20> &<26> <20> &<26>*<2A>'<27>$rarkc<00>@<00><00>eZdZdZej
dzZ<06>fd<03>Z<07>xZS)<04>CircleCollectionz-A collection of circles, drawn using splines.r+c <00><><00><01>t<00>|<00>di|<02><01>|j|<01>|jt j
<00><00>t jj<00>g|_ y)z<>
Parameters
----------
sizes : float or array-like
The area of each circle in points^2.
**kwargs
Forwarded to `.Collection`.
Nr<4E>)
r6r7rrr1rrsr<>r<><00> unit_circler\)r]ror^r_s <20>r`r7zCircleCollection.__init__<5F>sO<00><><00> <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>u<EFBFBD><1D> <0C><1A><1A>:<3A>7<>7<>9<>:<3A><1C>z<EFBFBD>z<EFBFBD>-<2D>-<2D>/<2F>0<><04> ra) r<>r[r\r]rTr<rnr7rbrcs@r`r<>r<><00>s<00><><00>7<><10>e<EFBFBD>e<EFBFBD><04>o<EFBFBD>G<EFBFBD> 1<> 1rar<>c<00>z<00><00>eZdZdZdd<03><01>fd<04>
Zd<05>Zd<06>Zd<07>Zd<08>Zd <09>Z d
<EFBFBD>Z
d <0B>Z e j<00>fd <0C><08>Z<0E>xZS) <0A>EllipseCollectionz.A collection of ellipses, drawn using splines.<2E>points)<01>unitsc <00>Z<00><01>t<00>|<00>di|<05><01>|j|<01>|j|<02>|j |<03>||_|j tj<00><00>tjd<01>|_ tjj<00>g|_y)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 `~.patches.Ellipse` with
``axes.transData`` as its transform.
**kwargs
Forwarded to `Collection`.
r'Nr<4E>)r6r7<00>
set_widths<EFBFBD> set_heights<74>
set_angles<EFBFBD>_unitsr1rrsrTr^rnr<>r<>r<>r\)r]<00>widths<68>heights<74>anglesr<73>r^r_s <20>r`r7zEllipseCollection.__init__<5F>s<><00><><00>* <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0F><0F><06><1F> <0C><18><18><17>!<21> <0C><0F><0F><06><1F><1B><04> <0B> <0C><1A><1A>:<3A>7<>7<>9<>:<3A><1D>8<EFBFBD>8<EFBFBD>I<EFBFBD>.<2E><04><18><1C>z<EFBFBD>z<EFBFBD>-<2D>-<2D>/<2F>0<><04> rac<00><><00>|j}|jd<01><02>}|jdk(rd}<03>n+|jdk(r.|jj|j
jz }n<>|jdk(r.|jj |j
j z }n<>|jdk(r |j}n<>|jdk(r|jd z }nv|jd
k(r|jj}nP|jd k(r|jj }n*|jd k(rd }ntd|j<00><02><02><00>tjt|j<00>ddf<03>|_ |j|z}|j|z}tj|j <00>}tj"|j <00>}||z|jdd<10>ddf<|| z|jdd<10>ddf<||z|jdd<10>ddf<||z|jdd<10>ddf<d |jdd<10>ddf<t$j&}|jdk(rY|j(j+<00>j-<00>j/<00>} d| dd<12>dd<10>f<|j1|| <09><00>yy)z0Calculate transforms immediately before drawing.Fr<46>r<>rr<>r<><00>inchesr<73>rkr<>r<><00>dotsrfzUnrecognized units: r(Nrr5)rwr<>r<>r<>r<><00>viewLimr<6D>rpr<>rTr<>r<><00>_widthsrn<00>_heights<74>sin<69>_angles<65>cosrr<>r<>r<>r:<00>copyr1)
r]<00>ax<61>fig<69>scr<63>r<><00> sin_angle<6C> cos_angle<6C>_affine<6E>ms
r`<00>_set_transformsz!EllipseCollection._set_transforms<6D>sP<00><00><12>Y<EFBFBD>Y<EFBFBD><02><12>o<EFBFBD>o<EFBFBD>5<EFBFBD>o<EFBFBD>)<29><03> <0F>;<3B>;<3B>$<24> <1E><12>B<EFBFBD> <11>[<5B>[<5B>C<EFBFBD> <1F><13><17><17><1D><1D><12><1A><1A>!1<>!1<>1<>B<EFBFBD> <11>[<5B>[<5B>C<EFBFBD> <1F><13><17><17><1E><1E>"<22>*<2A>*<2A>"3<>"3<>3<>B<EFBFBD> <11>[<5B>[<5B>H<EFBFBD> $<24><14><17><17>B<EFBFBD> <11>[<5B>[<5B>H<EFBFBD> $<24><14><17><17>4<EFBFBD><1E>B<EFBFBD> <11>[<5B>[<5B>G<EFBFBD> #<23><13><17><17><1D><1D>B<EFBFBD> <11>[<5B>[<5B>H<EFBFBD> $<24><13><17><17><1E><1E>B<EFBFBD> <11>[<5B>[<5B>F<EFBFBD> "<22><14>B<EFBFBD><1C>3<>D<EFBFBD>K<EFBFBD>K<EFBFBD>?<3F>C<>D<> D<><1D>8<EFBFBD>8<EFBFBD>S<EFBFBD><14><1C><1C>%6<><01>1<EFBFBD>$=<3D>><3E><04><18><15><1C><1C><02>"<22><06><16>-<2D>-<2D>"<22>$<24><07><16>F<EFBFBD>F<EFBFBD>4<EFBFBD><<3C><<3C>(<28> <09><16>F<EFBFBD>F<EFBFBD>4<EFBFBD><<3C><<3C>(<28> <09>$*<2A>Y<EFBFBD>$6<><04><18><18><11>A<EFBFBD>q<EFBFBD><17>!<21>$+<2B>y<EFBFBD>j<EFBFBD>$8<><04><18><18><11>A<EFBFBD>q<EFBFBD><17>!<21>$*<2A>Y<EFBFBD>$6<><04><18><18><11>A<EFBFBD>q<EFBFBD><17>!<21>$+<2B>i<EFBFBD>$7<><04><18><18><11>A<EFBFBD>q<EFBFBD><17>!<21>$'<27><04><18><18><11>A<EFBFBD>q<EFBFBD><17>!<21><1C>%<25>%<25><07> <0F>;<3B>;<3B>$<24> <1E><12> <0C> <0C>'<27>'<27>)<29>4<>4<>6<>;<3B>;<3B>=<3D>A<EFBFBD><19>A<EFBFBD>b<EFBFBD>q<EFBFBD>b<EFBFBD>!<21>"<22>f<EFBFBD>I<EFBFBD> <10> <1E> <1E>w<EFBFBD>q<EFBFBD>z<EFBFBD> *<2A> rac<00>h<00>dtj|<01>j<00>z|_d|_y)z5Set the lengths of the first axes (e.g., major axis).<2E><00>?TN)rTr <00>ravelr<6C>rj)r]r<>s r`r<>zEllipseCollection.set_widths<68>s'<00><00><1A>R<EFBFBD>Z<EFBFBD>Z<EFBFBD><06>/<2F>5<>5<>7<>7<><04> <0C><19><04>
rac<00>h<00>dtj|<01>j<00>z|_d|_y)<04>2Set the lengths of second axes (e.g., minor axes).r<>TN)rTr r<>r<>rj)r]r<>s r`r<>zEllipseCollection.set_heights<74>s'<00><00><1B>b<EFBFBD>j<EFBFBD>j<EFBFBD><17>1<>7<>7<>9<>9<><04> <0A><19><04>
rac<00>b<00>tj|<01>j<00>|_d|_y)z>Set the angles of the first axes, degrees CCW from the x-axis.TN)rT<00>deg2radr<64>r<>rj)r]r<>s r`r<>zEllipseCollection.set_angless"<00><00><19>z<EFBFBD>z<EFBFBD>&<26>)<29>/<2F>/<2F>1<><04> <0C><19><04>
rac<00> <00>|jdzS)z5Get the lengths of the first axes (e.g., major axis).r5)r<>res r`<00>
get_widthszEllipseCollection.get_widths s<00><00><13>|<7C>|<7C>a<EFBFBD><1F>rac<00> <00>|jdzS)r<>r5)r<>res r`<00> get_heightszEllipseCollection.get_heights s<00><00><13>}<7D>}<7D>q<EFBFBD> <20> rac<00>@<00>tj|j<00>S)z>Get the angles of the first axes, degrees CCW from the x-axis.)rT<00>rad2degr<67>res r`<00>
get_angleszEllipseCollection.get_angless<00><00><11>z<EFBFBD>z<EFBFBD>$<24>,<2C>,<2C>'<27>'rac<00>D<00><01>|j<00>t<00>|<00> |<01>yrc)r<>r6r<>rus <20>r`r<>zEllipseCollection.draws<00><><00> <0C><1C><1C><1E> <0A><07> <0C>X<EFBFBD>ra)r<>r[r\r]r7r<>r<>r<>r<>r<>r<>r<>rr`r<>rbrcs@r`r<>r<><00>sL<00><><00>8<>9A<39>1<><(+<2B>T<1A>
<1A>
<1A>
 <20>!<21>(<28> <0C><1F><1F><1F> <20>rar<>c<00>.<00><00>eZdZdZdd<03><01>fd<04>
Zd<05>Z<05>xZS)<06>PatchCollectionz<6E>
A generic collection of patches.
PatchCollection draws faster than a large number of equivalent individual
Patches. It also makes it easier to assign a colormap to a heterogeneous
collection of patches.
F)<01>match_originalc <00><><00><01>|r<>d<01>}|D<00>cgc]
}||<05><00><02> c}|d<|D<00>cgc]}|j<00><00><02>c}|d<|D<00>cgc]}|j<00><00><02>c}|d<|D<00>cgc]}|j<00><00><02>c}|d<|D<00>cgc]}|j<00><00><02>c}|d<t <00>|<00>di|<03><01>|j |<01>ycc}wcc}wcc}wcc}wcc}w) a?
Parameters
----------
patches : list of `.Patch`
A sequence of Patch objects. This list may include
a heterogeneous assortment of different patch types.
match_original : bool, default: False
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.
**kwargs
All other parameters are forwarded to `.Collection`.
If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds*
are None, they default to their `.rcParams` patch setting, in
sequence form.
Notes
-----
The use of `~matplotlib.cm.ScalarMappable` functionality is optional.
If the `~matplotlib.cm.ScalarMappable` matrix ``_A`` has been set (via
a call to `~.ScalarMappable.set_array`), at draw time a call to scalar
mappable will be made to set the face colors.
c<00>J<00>|j<00>r|j<00>Sgd<01>S)N)rrrr)rWr<>)<01>patchs r`<00>determine_facecolorz5PatchCollection.__init__.<locals>.determine_facecolorBs!<00><00><18>><3E>><3E>#<23> <20>.<2E>.<2E>0<>0<>#<23>#rarrrrrNr<4E>)r<>rFrHrr6r7rl)r]<00>patchesr<73>r^r<>r<>r_s <20>r`r7zPatchCollection.__init__$s<><00><><00>: <1A> $<24>
EL<01>#L<>q<EFBFBD>$7<><01>$:<3A>#L<>F<EFBFBD><<3C> <20>?F<>#G<>!<21>A<EFBFBD>O<EFBFBD>O<EFBFBD>$5<>#G<>F<EFBFBD><<3C> <20>?F<>#G<>!<21>A<EFBFBD>O<EFBFBD>O<EFBFBD>$5<>#G<>F<EFBFBD><<3C> <20>?F<>#G<>!<21>A<EFBFBD>O<EFBFBD>O<EFBFBD>$5<>#G<>F<EFBFBD><<3C> <20>CJ<43>%K<>a<EFBFBD>a<EFBFBD>&7<>&7<>&9<>%K<>F<EFBFBD>><3E> "<22> <0A><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>w<EFBFBD><1F><>$M<01><>#G<><47>#G<><47>#G<><47>%Ks<00>C<04>C
<04>C<04>&C<04>Cc<00><><00>|D<00>cgc]/}|j<00>j|j<00><00><00><02>1}}||_ycc}wrc)r|<00>transform_path<74>get_pathr\)r]r<>r<>rks r`rlzPatchCollection.set_pathsQsC<00><00>!<21>#<23><16><13><1F><1F>"<22>1<>1<>!<21>*<2A>*<2A>,<2C>?<3F>#<23><05>#<23><1B><04> <0B><>#s<00>4A)r<>r[r\r]r7rlrbrcs@r`r<>r<>s<00><><00><08>38<33>+ <20>Zrar<>c<00>b<00><00>eZdZdZ<03>fd<02>Zd<03>Zd<04>Zed<05><00>Ze jd<06><00>Z <0B>xZ S)<07>TriMeshz<68>
Class for the efficient drawing of a triangular mesh using Gouraud shading.
A triangular mesh is a `~matplotlib.tri.Triangulation` object.
c <00>R<00><01>t<00>|<00>di|<02><01>||_d|_tj
j <00>|_tj|jjdd<03>|jjdd<03>f<02>}|jj|<03>y)N<>gouraudr<64>rr<>)r6r7<00>_triangulation<6F>_shadingrr~<00>unitr<74>rTr<>r<>rUr<>r<>)r]<00> triangulationr^r<>r_s <20>r`r7zTriMesh.__init__]s<><00><><00> <0A><07><18>"<22>6<EFBFBD>"<22>+<2B><04><1B>!<21><04> <0A><1F>_<EFBFBD>_<EFBFBD>)<29>)<29>+<2B><04>
<EFBFBD><10>Y<EFBFBD>Y<EFBFBD> <0A><0F><0F>/<2F>/<2F><02>A<EFBFBD>6<>%<25><0F><0F>/<2F>/<2F><02>A<EFBFBD>6<>8<>9<><02> <0C>
<EFBFBD>
<EFBFBD>&<26>&<26>r<EFBFBD>*rac<00>R<00>|j<00>|j<00>|jSrc<00>r\rlres r`rfzTriMesh.get_pathsj<00> <00><00> <0F>;<3B>;<3B> <1E> <10>N<EFBFBD>N<EFBFBD> <1C><13>{<7B>{<7B>rac<00>D<00>|j|j<00>|_yrc)<03>convert_mesh_to_pathsr<73>r\res r`rlzTriMesh.set_pathsos<00><00><1A>0<>0<><14>1D<31>1D<31>E<><04> rac<00><><00>|j<00>}tj|j||j|fd<01><02>}|D<00>cgc]}t j |<03><00><02>c}Scc}w)z<>
Convert 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<>r<>)<07>get_masked_trianglesrTr<>r<>r<>r<>r<>)<04>tri<72> trianglesr<73>r<>s r`r<>zTriMesh.convert_mesh_to_pathsrsU<00><00><18>,<2C>,<2C>.<2E> <09><12><08><08>#<23>%<25>%<25> <09>*<2A>C<EFBFBD>E<EFBFBD>E<EFBFBD>)<29>,<<3C>=<3D>B<EFBFBD>G<><05>',<2C>-<2D>!<21><05>
<EFBFBD>
<EFBFBD>1<EFBFBD> <0A>-<2D>-<2D><>-s<00>A'c<00><><00>|j<00>sy|j|jj|j <00><00><01>|j <00>}|j }|j<00>}tj|j||j|fd<02><03>}|j<00>|j|}|j<00>}|j|<07>|j!|j#<00>d<00>|j%||||j'<00><00>|j)<00>|j+|jj<00>y)N)<01>gidr<64>r<>r)r<>r<>r_r<>r<>r|r<>r<>rTr<>r<>r<>r<>r,r<>r<>rIrF<00>draw_gouraud_trianglesr<73>r<>r<>)r]r<>r<>r<>r<>r<>r r<>s r`r<>z TriMesh.draw~s<00><00><13><1F><1F>!<21> <12><10><1B><1B>D<EFBFBD>N<EFBFBD>N<EFBFBD>3<>3<><14><1C><1C><1E><1B>H<><18>&<26>&<26>(<28> <09><13>!<21>!<21><03><17>,<2C>,<2C>.<2E> <09><12><08><08>#<23>%<25>%<25> <09>*<2A>C<EFBFBD>E<EFBFBD>E<EFBFBD>)<29>,<<3C>=<3D>B<EFBFBD>G<><05> <0C>"<22>"<22>$<24><15>!<21>!<21>)<29>,<2C><06> <15>_<EFBFBD>_<EFBFBD> <1E><02> <0C><19><19>"<22><1D>
<EFBFBD><18><18><14>+<2B>+<2B>-<2D>a<EFBFBD>0<>1<><10>'<27>'<27><02>E<EFBFBD>6<EFBFBD>9<EFBFBD>;K<>;K<>;M<>N<>
<EFBFBD>
<EFBFBD>
<EFBFBD> <0C><10><1C><1C>T<EFBFBD>^<5E>^<5E>4<>4<>5ra) r<>r[r\r]r7rfrlrar<>rr`r<>rbrcs@r`r<>r<>WsF<00><><00><08>
+<2B><1B>
F<01><12> .<2E><12> .<2E> <0C><1F><1F>6<> <20>6rar<>c<00>^<00><00>eZdZdZdd<03>d<04>Z<04>fd<05>Zd<06>Z<06>fd<07>Z<07>fd<08>Ze d <09><00>Z
d
<EFBFBD>Z <0B>xZ S) rRa<>
Class for managing the two dimensional coordinates of Quadrilateral meshes
and the associated data with them. This class is a mixin and is intended to
be used with another collection that will implement the draw separately.
A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
defined by the vertices ::
(m+1, n) ----------- (m+1, n+1)
/ /
/ /
/ /
(m, n) -------- (m, n+1)
The mesh need not be regular and the polygons need not be convex.
Parameters
----------
coordinates : (M+1, N+1, 2) array-like
The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
of vertex (m, n).
shading : {'flat', 'gouraud'}, default: 'flat'
<20>flat)<01>shadingc<00>N<00>tjd|<01><02>||_||_y)N)NNr5<00><01> coordinates)r<00> check_shape<70> _coordinatesr<73>)r]r<>r<>s r`r7z_MeshData.__init__<5F>s!<00><00> <0C><18><18><1F>k<EFBFBD>B<>'<27><04><19><1F><04> rac<00><><00><01>|jjdd\}}|jdk(r |dz
|dz
}}n||}}||df||df||f||zfg}|<01>dtj|<01>}||vrKt d|<03>d|<02>d |j<00>d
d j t t|<06><00><00>d |j<00><00>
<EFBFBD><00>t<00>|<00>%|<01>S) au
Set the data values.
Parameters
----------
A : array-like
The mesh data. Supported array shapes are:
- (M, N) or (M*N,): a mesh with scalar data. The values are mapped
to colors using normalization and a colormap. See parameters
*norm*, *cmap*, *vmin*, *vmax*.
- (M, N, 3): an image with RGB values (0-1 float or 0-255 int).
- (M, N, 4): an image with RGBA values (0-1 float or 0-255 int),
i.e. including transparency.
If the values are provided as a 2D grid, the shape must match the
coordinates grid. If the values are 1D, they are reshaped to 2D.
M, N follow from the coordinates grid, where the coordinates grid
shape is (M, N) for 'gouraud' *shading* and (M+1, N+1) for 'flat'
shading.
rr<>r<>rr(<00>zFor X (z ) and Y (z) with z shading, A should have shape z or z, not )
r<EFBFBD>rWr<>rTr<><00>joinrr1r6<00> set_array) r]<00>Ar<41>r<>r<><00>w<> ok_shapesrWr_s <20>r`r<>z_MeshData.set_array<61>s<><00><><00>,<1D>)<29>)<29>/<2F>/<2F><01>"<22>5<> <0A><06><05> <0F>=<3D>=<3D>F<EFBFBD> "<22><19>A<EFBFBD>:<3A>u<EFBFBD>q<EFBFBD>y<EFBFBD>q<EFBFBD>A<EFBFBD><19>5<EFBFBD>q<EFBFBD>A<EFBFBD><17><11>A<EFBFBD>Y<EFBFBD><11>A<EFBFBD>q<EFBFBD> <09>A<EFBFBD>q<EFBFBD>6<EFBFBD>A<EFBFBD><01>E<EFBFBD>8<EFBFBD><<3C> <09> <0C>=<3D><16>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD>E<EFBFBD><14>I<EFBFBD>%<25> <20><1D>e<EFBFBD>W<EFBFBD>I<EFBFBD>f<EFBFBD>X<EFBFBD>W<EFBFBD>T<EFBFBD>]<5D>]<5D>O<EFBFBD>L4<><1D>{<7B>{<7B>3<EFBFBD>s<EFBFBD>I<EFBFBD>#6<>7<>8<><06>q<EFBFBD>w<EFBFBD>w<EFBFBD>i<EFBFBD>I<01>J<01>J<01><15>w<EFBFBD> <20><11>#<23>#rac<00><00>|jS)a
Return the vertices of the mesh as an (M+1, N+1, 2) array.
M, N are the number of quadrilaterals in the rows / columns of the
mesh, corresponding to (M+1, N+1) vertices.
The last dimension specifies the components (x, y).
)r<>res r`<00>get_coordinatesz_MeshData.get_coordinates<65>s<00><00><14> <20> <20> rac<00>@<00><01>t<00>|<00><00>jdd<02>S<00>Nr<4E>r<>)r6r<>rUr<>s <20>r`r<>z_MeshData.get_edgecolor<6F><00> <00><><00><15>w<EFBFBD>$<24>&<26>.<2E>.<2E>r<EFBFBD>1<EFBFBD>5<>5rac<00>@<00><01>t<00>|<00><00>jdd<02>Sr)r6r<>rUr<>s <20>r`r<>z_MeshData.get_facecolor<6F>rrac
<00>h<00>t|tjj<00>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>fgd<04><05>j d<06>}|D<00>cgc]}tj|<03><00><02>c}Scc}w)z<>
Convert 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<4E>rr5r<>)r<>r<>r5) rtrTr<>r<><00>datar<61>rUr<>r<>)r<>r%r<>r<>s r`<00>_convert_mesh_to_pathsz _MeshData._convert_mesh_to_paths<68>s<><00><00> <16>k<EFBFBD>2<EFBFBD>5<EFBFBD>5<EFBFBD>#4<>#4<> 5<><1B> <20> <20>A<EFBFBD><1B>A<EFBFBD><13><1E><1E> <0A>c<EFBFBD>r<EFBFBD>c<EFBFBD>3<EFBFBD>B<EFBFBD>3<EFBFBD>h<EFBFBD>K<EFBFBD> <0A>c<EFBFBD>r<EFBFBD>c<EFBFBD>1<EFBFBD>2<EFBFBD>g<EFBFBD>J<EFBFBD> <0A>a<EFBFBD>b<EFBFBD>!<21>"<22>f<EFBFBD>I<EFBFBD> <0A>a<EFBFBD>b<EFBFBD>#<23>2<EFBFBD>#<23>g<EFBFBD>J<EFBFBD> <0A>c<EFBFBD>r<EFBFBD>c<EFBFBD>3<EFBFBD>B<EFBFBD>3<EFBFBD>h<EFBFBD>K<EFBFBD> !
<EFBFBD> <12> <13> <1B>7<EFBFBD>:<3A>&<26> <0F>(.<2E>.<2E>!<21><05>
<EFBFBD>
<EFBFBD>1<EFBFBD> <0A>.<2E>.<2E><>.s<00>B/c<00>j<00>t|tjj<00>r |j}n|}|dd<02>dd<02>f}|dd<02>dd<01>f}|dd<01>dd<01>f}|dd<01>dd<02>f}||z|z|zdz }tj
||||||||||||g d<05><06>j d<07>}|j<00>j g|jdd<00>d<08><01><06>} |j<00>}
tjj|
<EFBFBD>r |
jnd} | <0B>tj| | d f<| dd<02>dd<02>f} | dd<02>dd<01>f} | dd<01>dd<01>f}| dd<01>dd<02>f}| | z|z|zdz }tj
| | || ||||||| |g d<05><06>j d
<EFBFBD>}tj|d <00>}||||fS) z<>
Convert a given mesh into a sequence of triangles, each point
with its own color. The result can be used to construct a call to
`~.RendererBase.draw_gouraud_triangles`.
Nr<4E>rg@r5r<>)r<>r(r5r<>r()r<>r(r<>).r5r()rtrTr<>r<>rr<>rUr<>rWr<>rr<>r<><00>isnan)r]r<>r<><00>p_a<5F>p_b<5F>p_c<5F>p_d<5F>p_centerr<72>r%<00>zr<7A><00>c_a<5F>c_b<5F>c_c<5F>c_d<5F>c_centerr <00>tmasks r`<00>_convert_mesh_to_trianglesz$_MeshData._convert_mesh_to_triangles s<00><00> <16>k<EFBFBD>2<EFBFBD>5<EFBFBD>5<EFBFBD>#4<>#4<> 5<><1B> <20> <20>A<EFBFBD><1B>A<EFBFBD><0F><03><12><03>S<EFBFBD>b<EFBFBD>S<EFBFBD><08>k<EFBFBD><03><0F><03><12><03>Q<EFBFBD>R<EFBFBD><07>j<EFBFBD><03><0F><01><02>A<EFBFBD>B<EFBFBD><06>i<EFBFBD><03><0F><01><02>C<EFBFBD>R<EFBFBD>C<EFBFBD><07>j<EFBFBD><03><17>#<23>I<EFBFBD><03>O<EFBFBD>c<EFBFBD>)<29>S<EFBFBD>0<><08><16>N<EFBFBD>N<EFBFBD> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> $
<EFBFBD>
<12> <13>
<1B>7<EFBFBD>:<3A>&<26> <12> <11> <1E> <1E> <20> (<28> (<28>)D<>;<3B>+<<3C>+<<3C>R<EFBFBD>a<EFBFBD>+@<40>)D<>!<21>)D<> E<><01> <10>N<EFBFBD>N<EFBFBD> <1C><01><1B><15><15><1F><1F><11>+<2B>q<EFBFBD>v<EFBFBD>v<EFBFBD><14><04> <0F> <1B><1B><16><16>A<EFBFBD>d<EFBFBD>A<EFBFBD>g<EFBFBD>J<EFBFBD><0F><03><12><03>S<EFBFBD>b<EFBFBD>S<EFBFBD><08>k<EFBFBD><03><0F><03><12><03>Q<EFBFBD>R<EFBFBD><07>j<EFBFBD><03><0F><01><02>A<EFBFBD>B<EFBFBD><06>i<EFBFBD><03><0F><01><02>C<EFBFBD>R<EFBFBD>C<EFBFBD><07>j<EFBFBD><03><17>#<23>I<EFBFBD><03>O<EFBFBD>c<EFBFBD>)<29>S<EFBFBD>0<><08><13><1E><1E> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> <0F><13>h<EFBFBD> !
<EFBFBD>
<12> <13>
<1B>7<EFBFBD>:<3A>&<26> <0F> <13><08><08><16> <09>*<2A>+<2B><05><18>%<25><16> <20>&<26>%<25><16>.<2E>0<>0ra) r<>r[r\r]r7r<>rr<>r<>rarrrbrcs@r`rRrR<00>s@<00><><00><08>206<30> <20>
#$<24>J!<21>6<> 6<> <12>/<2F><12>/<2F>((1rarRc<00>f<00><00>eZdZdZddd<04><02>fd<05>
Zd<06>Zd<07>Zd<08>Zejd <09><00>Z
d
<EFBFBD>Z <0B>xZ S) <0B>QuadMesha<68>
Class for the efficient drawing of a quadrilateral mesh.
A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
defined by the vertices ::
(m+1, n) ----------- (m+1, n+1)
/ /
/ /
/ /
(m, n) -------- (m, n+1)
The mesh need not be regular and the polygons need not be convex.
Parameters
----------
coordinates : (M+1, N+1, 2) array-like
The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
of vertex (m, n).
antialiased : bool, default: True
shading : {'flat', 'gouraud'}, default: 'flat'
Notes
-----
Unlike other `.Collection`\s, the default *pickradius* of `.QuadMesh` is 0,
i.e. `~.Artist.contains` checks whether the test point is within any of the
mesh quadrilaterals.
Tr<54>)rr<>c <00>X<00><01>|jdd<02>t<00>|<00> ||<03><03>tj|fi|<04><01>||_t
j j<00>|_|jj|jjdd<05><00>|jd<06>y)Nr/r)r<>r<>r<>r5F) rFr6r7r&<00> _antialiasedrr~r<>r<>r<>r<>rU<00> set_mouseover)r]r<>rr<>r^r_s <20>r`r7zQuadMesh.__init__R s<><00><><00><0E><19><19>,<2C><01>*<2A> <0A><07><18>[<5B>'<27><18>B<><12><1B><1B>D<EFBFBD>+<2B>F<EFBFBD>+<2B>'<27><04><19><1F>_<EFBFBD>_<EFBFBD>)<29>)<29>+<2B><04>
<EFBFBD> <0C>
<EFBFBD>
<EFBFBD>&<26>&<26>t<EFBFBD>'8<>'8<>'@<40>'@<40><12>Q<EFBFBD>'G<>H<> <0C><1A><1A>5<EFBFBD>!rac<00>R<00>|j<00>|j<00>|jSrcr<>res r`rfzQuadMesh.get_paths] r<>rac<00>R<00>|j|j<00>|_d|_yri)rr<>r\rjres r`rlzQuadMesh.set_pathsb s!<00><00><1A>1<>1<>$<24>2C<32>2C<32>D<><04> <0B><19><04>
rac<00>Z<00>|j<00>|z
j|j<00>Src)r|<00>transform_bboxr<78>)r]r<>s r`r<>zQuadMesh.get_datalimf s%<00><00><14>"<22>"<22>$<24>y<EFBFBD>0<>@<40>@<40><14><1A><1A>L<>Lrac<00><><00>|j<00>sy|j|jj|j <00><00>|j <00>}|j <00>}|j<00>}|j<00>rG|j|dd<00>df<00>}|j|dd<00>df<00>}tj||g<02>}|j<00>|jsf|jj!d<03>}|j#|<07>}|j!|jj$<00>}t'j(<00>}n |j}|js!|j+|<04>}|j-<00>}|j/<00>}|j1|j3<00><00>|j5|<08>|j7|j9<00>d<00>|j:dk(r7|j=|<07>\} }
|j?|| |
|jA<00><00>n<>|jC||jA<00>|j$ddz
|j$ddz
||||jE<00>j!d<05>|jF|jI<00>j!d<05><00>
|jK<00>|jM|jj<00>d|_'y)Nrr)r<>r5r<>)r<>r<>F)(r<>r<>r_r<>r<>r|rxr<>r<>r<>r<>rTr<>r<>r<>r<>rUr<>rWrrsr<>r<>r<>r<>r<>r<>rIrFr<>rr<>r<><00>draw_quad_meshr<68>r<00>get_edgecolorsr<73>r<>rj) r]r<>r<>r<>r,r<>r<>r<>r<>r<>r s r`r<>z QuadMesh.drawi sr<00><00><13><1F><1F>!<21> <12><10><1B><1B>D<EFBFBD>N<EFBFBD>N<EFBFBD>3<>3<>T<EFBFBD>\<5C>\<5C>^<5E>D<><18>&<26>&<26>(<28> <09><19>.<2E>.<2E>0<>
<EFBFBD><16>"<22>"<22>$<24><07> <0F>?<3F>?<3F> <1C><15>$<24>$<24>W<EFBFBD>Q<EFBFBD><01>T<EFBFBD>]<5D>3<>B<EFBFBD><15>$<24>$<24>W<EFBFBD>Q<EFBFBD><01>T<EFBFBD>]<5D>3<>B<EFBFBD><18>o<EFBFBD>o<EFBFBD>r<EFBFBD>2<EFBFBD>h<EFBFBD>/<2F>G<EFBFBD> <0C>"<22>"<22>$<24><18>"<22>"<22><1E>+<2B>+<2B>3<>3<>G<EFBFBD><<3C>K<EFBFBD>#<23>-<2D>-<2D>k<EFBFBD>:<3A>K<EFBFBD>%<25>-<2D>-<2D>d<EFBFBD>.?<3F>.?<3F>.E<>.E<>F<>K<EFBFBD>"<22>4<>4<>6<>I<EFBFBD><1E>+<2B>+<2B>K<EFBFBD><19>#<23>#<23> <20>5<>5<>g<EFBFBD>><3E>G<EFBFBD>#<23>.<2E>.<2E>0<>J<EFBFBD> <15>_<EFBFBD>_<EFBFBD> <1E><02>
<EFBFBD> <0B> <0B>D<EFBFBD>M<EFBFBD>M<EFBFBD>O<EFBFBD>$<24> <0C><19><19>"<22><1D>
<EFBFBD><18><18><14>+<2B>+<2B>-<2D>a<EFBFBD>0<>1<> <0F>=<3D>=<3D>I<EFBFBD> %<25> $<24> ?<3F> ?<3F> <0B> L<> <1D>I<EFBFBD>v<EFBFBD> <14> +<2B> +<2B><12>I<EFBFBD>v<EFBFBD>y<EFBFBD>'7<>'7<>'9<> ;<3B> <15> #<23> #<23><12>I<EFBFBD>$<24>$<24>&<26><1B>!<21>!<21>!<21>$<24>q<EFBFBD>(<28>+<2B>*;<3B>*;<3B>A<EFBFBD>*><3E><11>*B<><1B>W<EFBFBD>j<EFBFBD><14>"<22>"<22>$<24>,<2C>,<2C>W<EFBFBD>5<><14>!<21>!<21>4<EFBFBD>#6<>#6<>#8<>#@<40>#@<40><17>#I<>  K<01> <0B>
<EFBFBD>
<EFBFBD> <0C><10><1C><1C>T<EFBFBD>^<5E>^<5E>4<>4<>5<><1A><04>
rac<00><><00>|j|<01>\}}|r4|j<00><00>$|j<00>j<00>|dSy)Nr<4E>)r<>r<>r<>)r]<00>event<6E> contained<65>infos r`<00>get_cursor_datazQuadMesh.get_cursor_data<74> sE<00><00><1E>-<2D>-<2D><05>.<2E><0F> <09>4<EFBFBD> <14><14><1E><1E>)<29>5<><17>><3E>><3E>#<23>)<29>)<29>+<2B>D<EFBFBD><15>K<EFBFBD>8<> 8<>ra) r<>r[r\r]r7rfrlr<>rr`r<>r'rbrcs@r`rr0 sE<00><><00><08>B48<34><16> "<22><1B>
<1A>M<01> <0C><1F><1F>.<1B> <20>.<1B>`rarc<00>L<00><00>eZdZdZ<03>fd<02>Zd<03>Zd<04>Z<06>fd<05>Z<07>fd<06>Z<08>fd<07>Z <09>xZ
S)<08> PolyQuadMeshas
Class for drawing a quadrilateral mesh as individual Polygons.
A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are
defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is
defined by the vertices ::
(m+1, n) ----------- (m+1, n+1)
/ /
/ /
/ /
(m, n) -------- (m, n+1)
The mesh need not be regular and the polygons need not be convex.
Parameters
----------
coordinates : (M+1, N+1, 2) array-like
The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates
of vertex (m, n).
Notes
-----
Unlike `.QuadMesh`, this class will draw each cell as an individual Polygon.
This is significantly slower, but allows for more flexibility when wanting
to add additional properties to the cells, such as hatching.
Another difference from `.QuadMesh` is that if any of the vertices or data
of a cell are masked, that Polygon will **not** be drawn and it won't be in
the list of paths returned.
c <00>v<00><01>t<00>|<00>|<01><01>tj|fdgi|<02><01>|j<00>y)Nr<4E>r<>)r6r7r<><00>_set_unmasked_verts)r]r<>r^r_s <20>r`r7zPolyQuadMesh.__init__<5F> s9<00><><00> <0A><07><18>[<5B><18>1<><16><1F><1F><04>9<>B<EFBFBD>9<>&<26>9<> <0A> <20> <20>"rac<00>8<00>tjtjj|j<00>d<01><02>}|dd<01>dd<01>f|dd<05>dd<05>fz|dd<01>dd<05>fz|dd<05>dd<01>fz}|j <00>}|<02><>tjj|<02>}|j dk(r|tj|d<01><02>z}|S|j dk(r||z}|S||j|jdd<01>dd<01>dd<05>fjdd<00>z}|S)z8Get the unmasked regions using the coordinates and arrayr<79>r<>rrNr(r5) rTr<>r<>rr<>r<>rQrUrW)r]r<>r<>s r`<00>_get_unmasked_polysz PolyQuadMesh._get_unmasked_polys<79> s'<00><00><12>v<EFBFBD>v<EFBFBD>b<EFBFBD>e<EFBFBD>e<EFBFBD>(<28>(<28><14>):<3A>):<3A>;<3B>"<22>E<><04><15>Q<EFBFBD>r<EFBFBD>T<EFBFBD>1<EFBFBD>R<EFBFBD>4<EFBFBD>Z<EFBFBD> <20>4<EFBFBD><01><02>A<EFBFBD>B<EFBFBD><06><<3C>/<2F>$<24>q<EFBFBD><12>t<EFBFBD>Q<EFBFBD>R<EFBFBD>x<EFBFBD>.<2E>@<40>4<EFBFBD><01><02>A<EFBFBD>b<EFBFBD>D<EFBFBD><08>><3E>Q<><04><12>n<EFBFBD>n<EFBFBD><1E><03> <0E>?<3F><14>%<25>%<25>$<24>$<24>S<EFBFBD>)<29>C<EFBFBD><12>x<EFBFBD>x<EFBFBD>1<EFBFBD>}<7D><14><02><06><06>s<EFBFBD><12>,<2C>,<2C><04>
<15>u<EFBFBD> <0C> <15><18><18>Q<EFBFBD><1D><14><03> <0B><04><15>u<EFBFBD> <0C><15><03> <0B> <0B>D<EFBFBD>$5<>$5<>c<EFBFBD>r<EFBFBD>c<EFBFBD>3<EFBFBD>B<EFBFBD>3<EFBFBD><01>k<EFBFBD>$B<>$H<>$H<><12>!<21>$L<>M<>M<><04><14>u<EFBFBD> rac <00><><00>|jd}|jd}|j<00>}tjj |dd<03>dd<03>f<00>|}tjj |dd<03>dd<03>f<00>|}tjj |dd<00>dd<03>f<00>|}tjj |dd<00>dd<03>f<00>|}tjj |dd<00>dd<00>f<00>|}tjj |dd<00>dd<00>f<00>|} tjj |dd<03>dd<00>f<00>|}
tjj |dd<03>dd<00>f<00>|} t |<04>} tjj |||||| |
| ||g
d<03><05>} | j| ddf<03>}|j|<0E>y)N).r).rr<>rr<>r<>r5) r<>r-rTr<>r<>r<>r<>rUr<>)r]<00>X<>Y<>unmask<73>X1<58>Y1<59>X2<58>Y2<59>X3<58>Y3<59>X4<58>Y4<59>npolyr<79>r<>s r`r+z PolyQuadMesh._set_unmasked_verts<74> s<><00><00> <10> <1D> <1D>f<EFBFBD> %<25><01> <10> <1D> <1D>f<EFBFBD> %<25><01><15>)<29>)<29>+<2B><06> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>C<EFBFBD>R<EFBFBD>C<EFBFBD><13>"<22><13>H<EFBFBD>+<2B> &<26>v<EFBFBD> .<2E><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>C<EFBFBD>R<EFBFBD>C<EFBFBD><13>"<22><13>H<EFBFBD>+<2B> &<26>v<EFBFBD> .<2E><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>A<EFBFBD>B<EFBFBD><03><12><03>G<EFBFBD>*<2A> %<25>f<EFBFBD> -<2D><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>A<EFBFBD>B<EFBFBD><03><12><03>G<EFBFBD>*<2A> %<25>f<EFBFBD> -<2D><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>A<EFBFBD>B<EFBFBD><01><02>F<EFBFBD>)<29> $<24>V<EFBFBD> ,<2C><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>A<EFBFBD>B<EFBFBD><01><02>F<EFBFBD>)<29> $<24>V<EFBFBD> ,<2C><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>C<EFBFBD>R<EFBFBD>C<EFBFBD><11><12>G<EFBFBD>*<2A> %<25>f<EFBFBD> -<2D><02> <0F>U<EFBFBD>U<EFBFBD>\<5C>\<5C>!<21>C<EFBFBD>R<EFBFBD>C<EFBFBD><11><12>G<EFBFBD>*<2A> %<25>f<EFBFBD> -<2D><02><13>B<EFBFBD><07><05> <0F>U<EFBFBD>U<EFBFBD>[<5B>[<5B>"<22>b<EFBFBD>"<22>b<EFBFBD>"<22>b<EFBFBD>"<22>b<EFBFBD>"<22>b<EFBFBD>A<><02>[<5B> K<><02><12>
<EFBFBD>
<EFBFBD>E<EFBFBD>1<EFBFBD>a<EFBFBD>=<3D>)<29><05> <0C><0E><0E>u<EFBFBD>rac<00><><00><01>t<00>|<00><00>}|j<00>j<00>}t |<01>t |<02>k7r|S||dd<00>fSrc)r6r<>r-r<>r<>)r]r<00>unmasked_polysr_s <20>r`r<>zPolyQuadMesh.get_edgecolor<6F> <00>O<00><><00><13>W<EFBFBD> "<22> $<24><02><1D>1<>1<>3<>9<>9<>;<3B><0E> <0E>r<EFBFBD>7<EFBFBD>c<EFBFBD>.<2E>)<29> )<29><15>I<EFBFBD><11>.<2E>!<21>#<23>$<24>$rac<00><><00><01>t<00>|<00><00>}|j<00>j<00>}t |<01>t |<02>k7r|S||dd<00>fSrc)r6r<>r-r<>r<>)r]rr<r_s <20>r`r<>zPolyQuadMesh.get_facecolor<6F> r=rac<00><><00><01>|j<00>}t<00>|<00> |<01>tj||j<00><00>s|j <00>yyrc)r-r6r<>rT<00> array_equalr+)r]r<><00> prev_unmaskr_s <20>r`r<>zPolyQuadMesh.set_array
sI<00><><00><1A>.<2E>.<2E>0<> <0B> <0A><07><19>!<21><1C><12>~<7E>~<7E>k<EFBFBD>4<EFBFBD>+C<>+C<>+E<>F<> <10> $<24> $<24> &<26>Gra) r<>r[r\r]r7r-r+r<>r<>r<>rbrcs@r`r)r)<00> s,<00><><00><08>@#<23><15>&<1E>& %<25> %<25>'<27>'rar))3r]rcrr<00>numbersrrr<><00>numpyrT<00>
matplotlibrCr<>rrrr r
<00>
mcolorizerr rAr r r<>rrrr<>r<00>_enumsrr<00>define_aliases<65>ColorizingArtistr&rerwr<>r<>r*r>rArDrkr<>r<>r<>r<>rRrr)r<>rar`<00><module>rIs<><00><01> <04><11><10> <0B> <20><0F><12><18>X<01>X<01>X<01>X<01>'<27>
<15><14><14><14>"<22>D<EFBFBD>)<29><1E><04>%<25><1E><04>%<25>/<2F><1E><04>%<25>&<26><0F> <02><03>]<1A><1A>,<2C>,<2C>]<1A><03>]<1A>@,<1F>:<3A>,<1F>^e<1F>)<29>e<1F>PN<1A>)<29>N<1A>bo@<01><0E>o@<01>d?(<28>0<>?(<28>D3<>1<>3<>
7<> 5<>7<>
w#<23>Z<EFBFBD>w#<23>tt$<24>n<EFBFBD>t$<24>n1<>+<2B>1<>(i<1F>
<EFBFBD>i<1F>X9<1C>j<EFBFBD>9<1C>x<6<>j<EFBFBD><6<>~W1<>W1<>tn<14>y<EFBFBD>*<2A>n<14>bl'<27>9<EFBFBD>n<EFBFBD>l'ra
Reference in a new issue Copy permalink