intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/collections.cpython-312.pyc

Ë
†Rj7x
ã	óf—dZd
dl
Z
d
dlZd
dlZd
dlmZmZ
d
dlZd
dlZ	d
dl
Zddlm
Z
mZmZmZmZmZmZmZmZmZmZ
ddlmZmZ
e
j@ddgd	d
gddggd
¢
ddgdg
dœ«
Gd„dejB««Z"Gd„de"«Z#Gd„de#«Z$Gd„de#«Z%Gd„de%«Z&Gd„de#«Z'Gd„de'«Z(Gd „d!e'«Z)Gd"„d#e"«Z*Gd$„d%e*«Z+Gd&„d'e#«Z,Gd(„d)e"«Z-Gd*„d+e"«Z.Gd,„d-e"«Z/Gd.„d/«Z0Gd0„d1e0e"«Z1Gd2„d3e0e%«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).
éN)ÚNumberÚRealé
)Ú_apiÚ_pathÚartistÚcbookÚ	colorizerÚcolorsÚ
_docstringÚhatchÚlinesÚpathÚ
transforms)Ú	JoinStyleÚCapStyleÚantialiasedsÚaaÚ
edgecolorsÚecÚ
facecolorsÚfc)Ú
linestylesÚdashesÚlsÚ
linewidthsÚlwÚtransOffset)ÚantialiasedÚ	edgecolorÚ	facecolorÚ	linestyleÚ	linewidthÚoffset_transformcó’‡—eZ
dZd
Zej
d«
ZdZejdddddddddddddddddœˆf
d	„
«Z
d
„Zd„Zd„Z
d
„Zd„Zd„Zd9d„
Zd„Zej(d„«Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z!d„Z"d „Z#ejd!„«Z$ejd"„«Z%ejd#„«Z&ejd$„«Z'e(d%„«Z)d&„Z*d'„Z+d(„Z,d)„Z-d*„Z.d+„Z/d,„Z0d-„Z1d.„Z2d/„Z3d0„Z4d1„Z5d2„Z6ejnjpje6_d3„Z9d4„Z:d5„Z;d6„Z<d7„Z=d8„Z>ˆx
Z?S):Ú
CollectionaÅ
    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.
    ©rér(FNÚsolidg@r)rrrrÚcapstyleÚ	joinstylerÚoffsetsr$ÚnormÚcmapr
Ú
pickradiusr
ÚurlsÚzorderc
ó¤•
—t‰|�|j||
|««

d
g
|_d
g
|_dg
|_dg
|_d|_d|_d|_	d|_
tjtjd«
|_tjd|_|j#|«

|j%|
«

|j'|«

|j)|«

|j+|«

|j-|
«

|j/|«

|j1|«

|j3|«

|r|j5|«

nd|_|r|j9|«

nd|_|�2t=j>|t@«}|jBdk(r	|ddd…f}||_"|	|_#d|_$|jK|«

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*.
        ©rNrNzhatch.colorzhatch.linewidth©
é)'ÚsuperÚ__init__Ú_get_colorizerÚ_us_linestylesÚ_linestylesÚ_us_lwÚ_linewidthsÚ	_gapcolorÚ_face_is_mappedÚ_edge_is_mappedÚ_mapped_colorsÚmcolorsÚto_rgbaÚmplÚrcParamsÚ_hatch_colorÚ_hatch_linewidthÚ
set_facecolorÚ
set_edgecolorÚ
set_linewidthÚ
set_linestyleÚset_antialiasedÚset_pickradiusÚset_urlsÚ	set_hatchÚ
set_zorderÚset_capstyleÚ	_capstyleÚ
set_joinstyleÚ
_joinstyleÚnpÚ
asanyarrayÚfloatÚshapeÚ_offsetsÚ_offset_transformÚ
_path_effectsÚ_internal_updateÚ_paths)Úselfrrrrr*r+rr,r$r-r.r
r/r
r0r1ÚkwargsÚ	__class__s                  €úY/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/collections.pyr7zCollection.__init__Nsœ
ø€ôf	‰Ñ˜×,Ñ,¨T°4¸ÓCÔDð )˜kˆÔà%˜;ˆÔà�cˆŒØ˜3ˆÔàˆŒð $ˆÔØ#ˆÔØ"ˆÔÜ#ŸO™O¬C¯L©L¸Ñ,GÓHˆÔÜ #§¡Ð->Ñ ?ˆÔØ×ј:Ô&Ø×ј:Ô&Ø×ј:Ô&Ø×ј:Ô&Ø×ј\Ô*Ø×јJÔ'Ø�
‰
�dÔØ�‰�uÔØ�‰˜ÔáØ×Ñ˜hÕ'à!ˆDŒNáØ×Ñ˜yÕ)à"ˆDŒOàÐÜ—m‘m G¬UÓ3ˆGà�}‰} Ò$Ø! $ª
 'Ñ*�àˆŒ
Ø!1ˆÔà!ˆÔØ×јfÔ%؈�óc

ó—|jS©
N©
r\©
r]s
 r`Ú	get_pathszCollection.get_pathsÔó€Ø�{‰{Ðracó —|
|_d
|_
y©NT)r\Ústale)r]Úpathss  r`Ú	set_pathszCollection.set_paths×s€ØˆŒØˆ�
rac

ó—|jSrc)
Ú_transformsres
 r`Úget_transformszCollection.get_transformsÛó€Ø×ÑÐrac
óD
—|j€%tj«|_|jSt|jtj«s@t|jd
«r*|jj
|j«
|_|jS)z<Return the `.Transform` instance used by this artist offset.Ú_as_mpl_transform)rYrÚIdentityTransformÚ
isinstanceÚ	TransformÚhasattrrrÚaxesres
 r`Úget_offset_transformzCollection.get_offset_transformÞs‚€à×!Ñ!Ð)Ü%/×%AÑ%AÓ%CˆDÔ"ð
×%Ñ%Ð%ô	˜T×3Ñ3´Z×5IÑ5IÔJܘ$×0Ñ0Ð2EÔFà×&Ñ&×8Ñ8¸¿¹ÓCð
Ô"à×%Ñ%Ð%racó—|
|_y
)z�
        Set the artist offset transform.

        Parameters
        ----------
        offset_transform : `.Transform`
        N)
rY)r]r$s  r`Úset_offset_transformzCollection.set_offset_transformès€ð"2ˆÕracó”—|j
«}|j«}t|tj«s/|j|
«
stjj«S|j«}t|«
stjj«S|js|D�cgc]}|j|«
‘Œ}}|j«}t|j|
«
«
r¦t|tj j"«r|j%tj&«
}t)j*|j-«|
z
||j/«|j1|«
|j-«j3««S|j4�~||
z
j7|«
}tj j9|«
}|j:j=«s1tjj«}|j?|«

|Stjj«Sc
c}wrc) Ú
get_transformrxrtrrsÚcontains_branchÚBboxÚnullrfÚlenÚ	is_affineÚtransform_path_non_affineÚget_offsetsÚanyÚcontains_branch_seperatelyrTÚmaÚMaskedArrayÚfilledÚnanÚmpathÚget_path_collection_extentsÚ
get_affineroÚtransform_non_affineÚfrozenrXÚ	transformÚmasked_invalidÚmaskÚallÚupdate_from_data_xy)r]Ú	transDatar�Ú
offset_trfrkÚ
pr,Úbboxs        r`Úget_datalimzCollection.get_datalimòsÆ
€ð"×&Ñ&Ó(ˆ	Ø×.Ñ.Ó0ˆ
ܘ:¤z×'CÑ'CÔDØ×-Ñ-¨iÔ8ô—?‘?×'Ñ'Ó)Ð)à—‘Ó ˆÜ�5Œzä—?‘?×'Ñ'Ó)Ð)à×"Ò"ØEJÖKÀ
�Y×8Ñ8¸Õ;ÐKˆEÐKð×"Ñ"Ó$ˆäˆy×3Ñ3°IÓ>Ô?ô
˜'¤2§5¡5×#4Ñ#4Ô5Ø!Ÿ.™.¬¯©Ó0�ä×4Ñ4Ø×$Ñ$Ó&¨Ñ2°EØ×#Ñ#Ó%Ø×/Ñ/°Ó8Ø×%Ñ%Ó'×.Ñ.Ó0ó	2ð
2ð�=‰=Ð$ð" IÑ-×8Ñ8¸ÓAˆGä—e‘e×*Ñ*¨7Ó3ˆGØ—<‘<×#Ñ#Ô%Ü!—‘×+Ñ+Ó-�Ø×(Ñ(¨Ô1Ø�Ü�‰×#Ñ#Ó%Ð%ùòI
L
sÂ3IcóH—|j
tj««
Src)r˜rrs)r]Úrenderers  r`Úget_window_extentzCollection.get_window_extent7
s€ð×Ѥ
× <Ñ <Ó >Ó?Ð?rac
	óä—|j
«}
|j«}|j«}|j«}|j	«rìg}|j«D]†}|j
}|dd…d
f|dd…df}}|j
|«
}|j|«
}|jtjtj||g«
|j««

Œˆ|j
|dd…d
f«
}|j|dd…df«
}tjj||g«
}|
js.|D�cgc]}|
j!|«
‘Œ}}|
j#«}
|js!|j%|«
}|j#«}t'|tjj(«r|j+tj,«
}|
|||fSc
c}w)Nrr)r|rxrƒrfÚ
have_unitsÚverticesÚconvert_xunitsÚconvert_yunitsÚappendrŠÚPathrTÚcolumn_stackÚcodesr†r�r‚rŒr�rtr‡rˆr‰)	r]r�r•r,rkrržÚxsÚyss	         r`Ú_prepare_pointszCollection._prepare_points<
s·
€ð×&Ñ&Ó(ˆ	Ø×.Ñ.Ó0ˆ
Ø×"Ñ"Ó$ˆØ—‘Ó ˆà�?‰?Ô؈EØŸ™Ó(ò
P
�ØŸ=™=�Ø!¢! Q $™¨²!°Q°$©�B�Ø×(Ñ(¨Ó,�Ø×(Ñ(¨Ó,�Ø—‘œUŸZ™Z¬¯©¸¸R¸Ó(AÀ4Ç:Á:ÓNÕOð
P
ð×$Ñ$ WªQ°
¨T¡]Ó3ˆBØ×$Ñ$ WªQ°
¨T¡]Ó3ˆBÜ—e‘e×(Ñ(¨"¨b¨Ó2ˆGà×"Ò"à!&ö
(Øð×8Ñ8¸Õ>ð
(ˆEð
(à!×,Ñ,Ó.ˆIØ×#Ò#Ø ×5Ñ5°gÓ>ˆGà#×.Ñ.Ó0ˆJä�gœrŸu™u×0Ñ0Ô1Ø—n‘n¤R§V¡VÓ,ˆGð˜* g¨uÐ4Ð4ùò
(sÅ
G-cóÆ
—|j
«s
y|
j|jj|j	««
|j«
|j
«\}}}}|
j«}|j|«

|j|j««

|jrQ|j|j«

|j|j«

|j|j «

|j#«�|j$|j#«Ž
|j'«rd
dlm}
||j'«|
«}
|j-«}|j/«}	|j1«}
d}t3|«
dk(�
rGt3|«
dk�
r8t3|	«
dk(�
r)t3|
«
dk(�
rt3|j4«
dk(�
r
t7d„|j8D««
råt3|j:«
dk(rÍt3|j<«
dk(rµ|j?«€¥t3|«
rtAjB|d
«
|z}n|}|d
jE|«
}
|
jF|jId¬«
jJjFkr5|
jL|jId¬«
jJjLkrd}|jNr|jQ|jN«

|jRr|jU|jR«

|rÛ|jWtY|
d
«
«

|j[|j4d
«

|j\|j8d
Ž
|j_|j:d
«

|ja|j<d
«

|
jc||d
je«tgjh|«
|tY|	d
«
«
�
n|jj�ˆ|jm«\}}|
jo||je«||j-«||tqjrd«
g
|jj|j4||j:|j<d	«

|
jo||je«||j-«|||j/«|j1«|j4|j8|j:|j<d	«

|ju«
|
jw|jj«

d|_<y)
Nr)
ÚPathEffectRendererFrc
3ó*K
—|]}
|
dd
u–
—

Œ
y
­w
)rN©)Ú.0rs  r`ú	<genexpr>z"Collection.draw.<locals>.<genexpr>‡
sèø€Ò= b�B�q‘E˜T”MÑ=ùs‚
T©
ÚrootÚnoneÚscreen)=Úget_visibleÚ
open_groupr_Ú__name__Úget_gidÚupdate_scalarmappabler§Únew_gcÚ_set_gc_clipÚset_snapÚget_snapÚ_hatchrNÚset_hatch_colorrEÚset_hatch_linewidthrFÚget_sketch_paramsÚset_sketch_paramsÚget_path_effectsÚmatplotlib.patheffectsr©roÚ
get_facecolorÚ
get_edgecolorr€r<r’r:Ú
_antialiasedsÚ_urlsÚ	get_hatchrÚAffine2DÚget_extentsÚwidthÚ
get_figurer—ÚheightrSrRrQrPÚset_foregroundÚtuplerIÚ
set_dashesrKÚset_urlÚdraw_markersrŽrŠr¢r=Ú_get_inverse_paths_linestylesÚdraw_path_collectionrArBÚrestoreÚclose_grouprj)r]ršr�r•r,rkÚgcr©ÚtransrrÚdo_single_path_optimizationÚcombined_transformÚextentsÚipathsÚilinestyless                r`ÚdrawzCollection.draw`
s@€à×ÑÔ!ØØ×јDŸN™N×3Ñ3°T·\±\³^ÔDà×"Ñ"Ô$à04×0DÑ0DÓ0FÑ-ˆ	�:˜w¨à
�_‰_Ó
ˆØ×ј"ÔØ
�‰�D—M‘M“OÔ$à�;Š;Ø�L‰L˜Ÿ™Ô%Ø×Ñ˜t×0Ñ0Ô1Ø×"Ñ" 4×#8Ñ#8Ô9à×!Ñ!Ó#Ð/Ø ˆB× Ñ  $×"8Ñ"8Ó":Ñ;à× Ñ Ô"ÝAÙ)¨$×*?Ñ*?Ó*AÀ8ÓLˆHð×#Ñ#Ó%ˆØ×'Ñ'Ó)ˆ
Ø×'Ñ'Ó)ˆ
Ø&+Ð#Ü�‹J˜!‹O¤ E£
¨a£Ü�J“ 1Ó$¬¨Z«¸AÓ)=Ü�D×$Ñ$Ó%¨Ó*ÜÑ=¨D×,<Ñ,<Ô=Ô=Ü�D×&Ñ&Ó'¨1Ò,´°T·Z±Z³ÀAÒ1EØ—‘Ó Ð(Ü�5ŒzÜ%/×%8Ñ%8¸¸q¹Ó%BÀYÑ%NÑ"à%.Ð"ؘA‘h×*Ñ*Ð+=Ó>ˆGØ—
‘
 §¡°T Ó :× ?Ñ ?× EÑ EÒEØŸ™¨¯©¸d¨Ó)C×)HÑ)H×)OÑ)OÒOØ.2Ð+à�?Š?Ø×Ñ˜TŸ_™_Ô-à�>Š>Ø�O‰O˜DŸN™NÔ+á&Ø×Ñœe J¨q¡MÓ2Ô3Ø×Ñ˜T×-Ñ-¨aÑ0Ô1ØˆB�M‰M˜4×+Ñ+¨AÑ.Ñ/Ø×Ñ˜t×1Ñ1°!Ñ4Ô5Ø�J‰J�t—z‘z !‘}Ô%Ø×!Ñ!Ø�E˜!‘HÐ0×7Ñ7Ó9Ü—
‘
˜7Ó# Z´°zÀ!±}Ó1Eö
G
ð�~‰~Ð)à&*×&HÑ&HÓ&JÑ#�˜Ø×-Ñ-ؘ	×(Ñ(Ó*¨FØ×'Ñ'Ó)¨7°JÜ—_‘_ VÓ,Ð-¨t¯~©~Ø×$Ñ$ kØ×&Ñ&¨¯
©
Øô
ð
×)Ñ)Ø�I×$Ñ$Ó&¨Ø×#Ñ#Ó% w°
Ø×"Ñ"Ó$ d×&8Ñ&8Ó&:Ø× Ñ  $×"2Ñ"2Ø×"Ñ" D§J¡JØô

ð	�
‰
ŒØ×јTŸ^™^×4Ñ4Ô5؈�
racóN—t
|
t«std
|
›�«
‚
|
|_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Ú
ValueErrorÚ_pickradius)r]r/s  r`rLzCollection.set_pickradiusº
s/€ô˜*¤dÔ+ÜØ?À
¸~ÐNó
P
ð

P
à%ˆÕrac

ó—|jSrc)
rßres
 r`Úget_pickradiuszCollection.get_pickradiusÈ
rpracó(—|j
|
«
s|j«sd
ifSt|jt«r#|jdu
rt|j«
n|j}|jr|jj«
|j«\}}}}tj|
j|
j||j«||j«|||dk«	}t!|«
dkDt#|¬«
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)
Úind)Ú_different_canvasr²rtÚ_pickerrrVrßrwÚ_unstale_viewLimr§rÚpoint_in_path_collectionÚ
xÚ
yrŽror€Údict)r]Ú
mouseeventr/r�r•r,rkrãs        r`ÚcontainszCollection.containsË
sï€ð×!Ñ! *Ô-°T×5EÑ5EÔ5Gؘ"�9Ðô˜$Ÿ,™,¬Ô/Ø�|‰| 4Ñ'ô
�$—,‘,Ôð×!Ñ!ð		ð
�9Š9Ø�I‰I×&Ñ&Ô(Ø04×0DÑ0DÓ0FÑ-ˆ	�:˜w¨ô×,Ñ,Ø�L‰L˜*Ÿ,™,¨
Ø×ÑÓ  t×':Ñ':Ó'<Ø�Z ¨q¡ó2ˆô�3‹x˜!‰|œT cœ]Ð*Ð*racó*—|
�|
nd
g
|_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ç
s€ð"Ð-‘T°D°6ˆŒ
؈�
rac

ó—|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`Úget_urlszCollection.get_urlsõ
s€ð�z‰zÐracóJ—t
j|
«

|
|_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)ÚmhatchÚ_validate_hatch_patternr»rj)r]r
s  r`rNzCollection.set_hatchþ
s €ô<	×&Ñ& uÔ-؈ŒØˆ�
rac

ó—|jS)
z$Return the current hatching pattern.)
r»res
 r`rÆzCollection.get_hatch s€à�{‰{Ðracó—|
|_y
)zSet the hatch linewidth.N©
rF©r]rs  r`r½zCollection.set_hatch_linewidth$s
€à "ˆÕrac

ó—|jS)
zReturn the hatch linewidth.rõres
 r`Úget_hatch_linewidthzCollection.get_hatch_linewidth(s€à×$Ñ$Ð$rac
óÞ
—t
j|
«
}
|
jd
k(r	|
ddd…f}
t|
tjj
«rtjjntj}|t
j|j|
dd…df«
t«t
j|j|
dd…df«
t«f«
|_
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,Úcstacks   r`Úset_offsetszCollection.set_offsets,s¶€ô—-‘- Ó(ˆØ�=‰=˜DÒ Ø˜d¢A˜gÑ&ˆGÜ(2°7¼B¿E¹E×<MÑ<MÔ(N”"—%‘%×$Ò$Ü—‘ð	áÜ
�]‰]˜4×.Ñ.¨w²q¸!°t©}Ó=¼uÓ
EÜ
�]‰]˜4×.Ñ.¨w²q¸!°t©}Ó=¼uÓ
Eð

G
óH
ˆŒ
ðˆ�
rac
ó\—|j€tjd
«
S|jS)z&Return the offsets for the collection.©rr5)rXrTÚzerosres
 r`rƒzCollection.get_offsets>s%€ð$(§=¡=Ð#8Œr�x‰x˜ÓÐK¸d¿m¹mÐKrac
ó(—tjd
S)Nzpatch.linewidth©rCrDres
 r`Ú_get_default_linewidthz!Collection._get_default_linewidthCó€ä�|‰|Ð-Ñ.Ð.racóЗ|
€|j
«}
tj|
«
|_|j	|j|j
«\|_|_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)	r

rTÚ
atleast_1dr;Ú_bcast_lwlsr9r<r:rjrös  r`rIzCollection.set_linewidthGsZ€ðˆ:Ø×,Ñ,Ó.ˆBä—m‘m BÓ'ˆŒð.2×-=Ñ-=Ø�K‰K˜×,Ñ,ó
..Ñ*ˆÔ˜$Ô*àˆ�
racóž—t
j|
«
|_|j|j|j«\|_|_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)ÚmlinesÚ_get_dash_patternsr9r
r;r<r:)r]rs  r`rJzCollection.set_linestyle[sC€ô6%×7Ñ7¸Ó;ˆÔð.2×-=Ñ-=Ø�K‰K˜×,Ñ,ó
..Ñ*ˆÔ˜$Õ*racó$—t
|
«
|_
y
)z 
        Set the `.CapStyle` for the collection (for all its elements).

        Parameters
        ----------
        cs : `.CapStyle` or %(CapStyle)s
        N)rrQ)r]Úcss  r`rPzCollection.set_capstyle|s€ô" "›ˆ�rac

óJ—|jr|jjSd
S)z�
        Return the cap style for the collection (for all its elements).

        Returns
        -------
        %(CapStyle)s or None
        N)rQÚnameres
 r`Úget_capstylezCollection.get_capstyle‡s€ð'+§n¢nˆt�~‰~×"Ñ"Ð>¸$Ð>racó$—t
|
«
|_
y
)z£
        Set the `.JoinStyle` for the collection (for all its elements).

        Parameters
        ----------
        js : `.JoinStyle` or %(JoinStyle)s
        N)rrS)r]Újss  r`rRzCollection.set_joinstyle’s€ô$ B›-ˆ�rac

óJ—|jr|jjSd
S)z‘
        Return the join style for the collection (for all its elements).

        Returns
        -------
        %(JoinStyle)s or None
        N)rSr
res
 r`Ú
get_joinstylezCollection.get_joinstyle�s€ð(,§¢ˆt�‰×#Ñ#Ð@¸DÐ@rac
ó€
—tjd
r||
fSt|
«
t|«
k7rNt|
«
}t|«
}tj||«}t|
«
||zz}
t|«
||zz}t
|
|«D���cgc]\\}}}tj|||«‘Œ!}
}}}||
fSc
c}}}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€ÚmathÚgcdÚlistÚzipr
Ú
_scale_dashes)rrÚl_dashesÚl_lwr
Ú
oÚ
drs        r`r
zCollection._bcast_lwls¨sÇ€ô,�<‰<Ð0Ò1ؘvÐ%Ð%äˆv‹;œ#˜j›/Ò)ܘ6“{ˆHÜ�z“?ˆDÜ—(‘(˜8 TÓ*ˆCܘ&“\ T¨S¡[Ñ1ˆFܘjÓ)¨X¸©_Ñ=ˆJô%(¨°
Ó$;÷
=ð
=Ù ‘f�q˜!˜bô×&Ñ& q¨!¨RÕ0ð
=ˆò
=ð˜6Ð!Ð!ùô
=sÂ
$B9c

ó—|jS)
zs
        Get the antialiasing state for rendering.

        Returns
        -------
        array of bools
        )
rÄres
 r`Úget_antialiasedzCollection.get_antialiasedÎs€ð×!Ñ!Ð!racóš—|
€|j
«}
tjtj|
t««
|_d|_y
)z…
        Set the antialiasing state for rendering.

        Parameters
        ----------
        aa : bool or list of bools
        NT)Ú_get_default_antialiasedrTr
ÚasarrayÚboolrÄrj)r]rs  r`rKzCollection.set_antialiasedØs:€ðˆ:Ø×.Ñ.Ó0ˆBÜŸ]™]¬2¯:©:°b¼$Ó+?Ó@ˆÔ؈�
rac
ó(—tjd
S)Nzpatch.antialiasedr
res
 r`r
z#Collection._get_default_antialiasedås€ä�|‰|Ð/Ñ0Ð0racóH—|j
|
«

|j|
«

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©r]Ú
cs  r`Ú	set_colorzCollection.set_colorés €ð	
×ј1ÔØ×ј1Õrac
ó(—tjd
S)Nzpatch.facecolorr
res
 r`Ú_get_default_facecolorz!Collection._get_default_facecolorùr
racó€—|
€|j
«}
tj|
|j«|_d
|_yri)r(
rAÚ
to_rgba_arrayÚ_alphaÚ_facecolorsrjr$
s  r`Ú_set_facecolorzCollection._set_facecolorýs5€Øˆ9Ø×+Ñ+Ó-ˆAä"×0Ñ0°°D·K±KÓ@ˆÔ؈�
racó˜—t
|
t«r"|
j«d
vr|
j«}
|
|_|j	|
«

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`
        ©r°ÚfaceN)rtÚstrÚlowerÚ_original_facecolorr-
r$
s  r`rGzCollection.set_facecolors=€ô�aœÔ !§'¡'£)Ð/?Ñ"?Ø—‘“	ˆAØ#$ˆÔ Ø×јAÕrac

ó—|jSrc)
r,
res
 r`rÂzCollection.get_facecolorrprac
óz—t
j|jd
«r|j«S|jS)Nr0
)r	Ú
_str_equalÚ_edgecolorsrÂres
 r`rÃzCollection.get_edgecolors3€Ü×јD×,Ñ,¨fÔ5Ø×%Ñ%Ó'Ð'à×#Ñ#Ð#rac
ó(—tjd
S)Nzpatch.edgecolorr
res
 r`Ú_get_default_edgecolorz!Collection._get_default_edgecolorr
racó¾
—d
}|
€Ttjds,|js tj|j
d«r|j
«}
nd}
d}tj|
d«rd|_d
|_	ytj|
|j«|_|r2t|j«
rt|jd«
|_d
|_	y)NTzpatch.force_edgecolorr°Fr0
r)rCrDÚ
_edge_defaultr	r6
r3
r9
Ú_str_lower_equalr7
rjrAr*
r+
r€rÍrE)r]r%
r¼s   r`Ú_set_edgecolorzCollection._set_edgecolor"sº€ØˆØˆ9Ü—‘Ð4Ò5Ø×)Ò)Ü×'Ñ'¨×(@Ñ(@À&ÔIØ×/Ñ/Ó1‘
à�
Ø"'�Ü×!Ñ! ! VÔ,Ø%ˆDÔ؈DŒJØÜ"×0Ñ0°°D·K±KÓ@ˆÔÙœs 4×#3Ñ#3Ô4Ü % d×&6Ñ&6°qÑ&9Ó :ˆDÔ؈�
racó˜—t
|
t«r"|
j«d
vr|
j«}
|
|_|j	|
«

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)rtr1
r2
Ú_original_edgecolorr=
r$
s  r`rHzCollection.set_edgecolor5s=€ô�aœÔ !§'¡'£)Ð/?Ñ"?Ø—‘“	ˆAØ#$ˆÔ Ø×јAÕracó°—tjj||
«
|j|j«

|j|j«

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ÚArtistÚ_set_alpha_for_arrayr-
r3
r=
r?
)r]Úalphas  r`Ú	set_alphazCollection.set_alphaGs@€ô	�
‰
×*Ñ*¨4°Ô7Ø×јD×4Ñ4Ô5Ø×јD×4Ñ4Õ5rac

ó—|jSrc)
r<res
 r`Ú
get_linewidthzCollection.get_linewidthYrprac

ó—|jSrc)
r:res
 r`Ú
get_linestylezCollection.get_linestyle\rprac
óÂ
—|j}
|j}d
|_d
|_
|j�btj|j
d«s/d|_
tj|jd«rd|_n|j€d|_|jx
s
|j}|
dux
s&
|dux
s 
|j|
k7x
s
|j|k7}|x
s
|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°Tr0
)r?r>Ú_Ar	r6
r3
r?
)r]Úedge0Úface0ÚmappedÚchangeds     r`Ú_set_mappable_flagszCollection._set_mappable_flags_sä€ð×$Ñ$ˆØ×$Ñ$ˆà$ˆÔØ$ˆÔØ�7‰7ÐÜ×#Ñ# D×$<Ñ$<¸fÔEØ'+�Ô$Ü×#Ñ# D×$<Ñ$<¸fÔEØ+/�DÕ(à×+Ñ+Ð3Ø+/�DÔ(à×%Ñ%Ò=¨×)=Ñ)=ˆØ˜D�=ò4 E¨T Mò4Ø×*Ñ*¨eÑ3ò4à×*Ñ*¨eÑ3ð	ðÒ ˜Ð rac
ór—|j
«s
y
|j�
�|jjdkDrt|t«std«
‚
t
j|j«
r›|jj|jjk7r:td|jj›d|jj›d�«
‚
|jj|jj«
|_|j|j|j«|_
|jr|j|_n|j!|j"«

|j$r|j|_d|_y
|j)|j*«

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)rO
rJ
ÚndimrtÚ	_MeshDatarÞrTÚiterabler+
ÚsizerWÚreshaperBr@r>r,
r-
r3
r?r7
r=
r?
rjres
 r`r¶z Collection.update_scalarmappable�sK
€ð×'Ñ'Ô)Øà�7‰7Ñà�w‰w�|‰|˜aÒ¬
°4¼Ô(CÜ Ð!IÓJÐJÜ�{‰{˜4Ÿ;™;Ô'Ø—;‘;×#Ñ# t§w¡w§|¡|Ò3Ü$Ø,¨T¯W©W¯]©]¨Oð
<C
àŸ;™;×,Ñ,Ð-ð.,ð,ó-ð-ð#Ÿk™k×1Ñ1°$·'±'·-±-Ó@�”Ø"&§,¡,¨t¯w©w¸¿¹Ó"DˆDÔà×ÒØ#×2Ñ2ˆDÕà×Ñ × 8Ñ 8Ô9Ø×ÒØ#×2Ñ2ˆDÔðˆ�
ð
×Ñ × 8Ñ 8Ô9؈�
rac
óD—t
j|jd
«S)zReturn whether face is colored.r°)r	r<
r3
res
 r`Úget_fillzCollection.get_fill§s€ä×)Ñ)¨$×*BÑ*BÀFÓKÐKÐKracór—tjj||
«
|
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
Úupdate_fromrÄr@r?r?
r7
r>r3
r,
r<r:r9rßr»rJ
r-r.rj)r]Úothers  r`rY
zCollection.update_from«sõ€ô	�
‰
×!Ñ! $¨Ô.Ø"×0Ñ0ˆÔØ#×2Ñ2ˆÔØ$×4Ñ4ˆÔØ#(×#<Ñ#<ˆÔ Ø ×,Ñ,ˆÔØ$×4Ñ4ˆÔØ#(×#<Ñ#<ˆÔ Ø ×,Ñ,ˆÔØ ×,Ñ,ˆÔØ ×,Ñ,ˆÔØ#×2Ñ2ˆÔØ ×,Ñ,ˆÔØ—l‘lˆŒð—(‘(ˆŒØ—J‘JˆŒ	Ø—J‘JˆŒ	؈�
rarc)@r´Ú
__module__Ú__qualname__Ú__doc__rTÚemptyrnr;
rÚinterpdr7rfrlrorxrzr˜r›r§rÚallow_rasterizationrÜrLrárìrMrïrNrÆr½rørûrƒr

rIrJrPr

rRr
Ústaticmethodr
r
rKr
r&
r(
r-
rGrÂrÃr9
r=
rHrD
rA
rB
rF
rH
rO
r¶rW
rY
Ú
__classcell__©
r_s
@r`r&r&sú
ø„ñðF
�"—(‘(˜9Ó%€Kð€Mà×Ñà Ø Ø Ø#ØØØ"ØØ"&ØØØØØØØõ!CóðCòJ
òò
 ò&ò2òC
&óJ@
ò
"5ðH
×ÑñW
ó ðW
òr&ò
 ò+ò8òò òD
ò#ò%òò$L
ò
/òò(.ðB
×Ññ&óð&ð×Ññ?óð?ð×Ññ(óð(ð×ÑñA
óðA
ðñ#"óð#"òJ
"òò1òò /òòò"
 ò$ò/òò&ò$6ð Ÿ
™
×:Ñ:×BÑB€IÔò
 ò
 ò !òD
$òL
L
örar&cóR‡—eZ
dZd
ZdZd„Zdd„
Zejˆf
d„«Z	ˆx
Z
S)Ú_CollectionWithSizeszA
    Base class for collections that have an array of sizes.
    çð?c

ó—|jS)
z¦
        Return the sizes ('areas') of the elements in the collection.

        Returns
        -------
        array
            The 'area' of each element.
        )
Ú_sizesres
 r`Ú	get_sizesz_CollectionWithSizes.get_sizesÊs€ð�{‰{Ðracóþ
—|
€<t
jg«
|_t
jd«
|_d	|_
y
t
j
|
«
|_t
jt|j«
ddf«
|_t
j|j«
|zdz|jz}||jd
d
…ddf<||jd
d
…ddf<d|jd
d
…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(çR@rrrf
r5T)rTÚarrayrh
r^
rnr 
rþr€ÚsqrtÚ_factorrj)r]ÚsizesÚdpiÚscales    r`Ú	set_sizesz_CollectionWithSizes.set_sizesÕsÓ€ðˆ=ÜŸ(™( 2›,ˆDŒKÜ!Ÿx™x¨	Ó2ˆDÔðˆ�
ô
Ÿ*™* UÓ+ˆDŒKÜ!Ÿx™x¬¨T¯[©[Ó)9¸1¸aÐ(@ÓAˆDÔÜ—G‘G˜DŸK™KÓ(¨3Ñ.°Ñ5¸¿¹ÑDˆEØ(-ˆD×ÑšQ 
 1˜WÑ%Ø(-ˆD×ÑšQ 
 1˜WÑ%Ø(+ˆD×ÑšQ 
 1˜WÑ%؈�
racó�•
—|j
|j|jd
¬«
j«
t‰|�|
«

y©NTr®)rr
rh
rÊrp
r6rÜ©r]ršr_s  €r`rÜz_CollectionWithSizes.drawís2ø€à�‰�t—{‘{ D§O¡O¸ OÓ$>×$BÑ$BÔCÜ
‰‰�XÕra)
rk
)r´r[
r\
r]
rn
ri
rr
rr`
rÜrb
rc
s
@r`re
re
Äs3ø„ñð€Gò	óð0×Ñóó ôrare
có<‡—eZ
dZd
Zd	ˆf
d„	Zd„Zdddd„fd„
Zˆx
ZS)
ÚPathCollectionzO
    A collection of `~.path.Path`\s, as created by e.g. `~.Axes.scatter`.
    Ncóv•
—t
‰|�di|¤
Ž

|j|
«

|j|«

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«)r6r7rlrr
rj)r]rkro
r^r_s    €r`r7zPathCollection.__init__øs4ø€ô	‰ÑÑ"˜6Ò"Ø�‰�uÔØ�‰�uÔ؈�
rac

ó—|jSrcrdres
 r`rfzPathCollection.get_pathsrgrarÚautoc

ó—|Srcr«)
rès
 r`ú<lambda>zPathCollection.<lambda>s€°€rac	óÖ—g}g}|j
«d
u
}|€"tjjdd¬«}n/t	|t
«rtjj
|«
}|j«
|
dk(rb|stjd«

||fStj|j
««
}	|jdtjd«}
nJ|
d	k(r6tj|j««
}	|jd
d«}ntd|
›d
�«
‚
||	«
}|j j#|j%«|j'««
|j j)|j%«|j'««
|dk(rd}t+|	«
|krd
}|€|	}
||
«
}�
n˜|
dk(r|j
«}n|
d	k(r|j«}t	|tjj,«r|}ngtj.|«
r tjj1|«
}n2t3|«
}tjj5||dz
gd¢
¬«}|j7|«
j%«||«
j'««}|||«
j%«k\|||«
j'«kz
}||}tj8|j%«|j'«d«}||«
}tj:|«
}tj<|||||«}
|j?«d|jA«dœ|¥
}tC|
|«D]Ò\}}|
dk(r!|jE|jG|«
«
}n1|
d	k(r,tjH|«
}
tjJ|
d«r
Œ]tMjNdg
dg
fd
|jQ«ddœ|¤
Ž
}|jS|«

tU|d«r|jW|«

||«
}|jS|«

ŒÔ||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)Ú	useOffsetÚuseMathTextrzfCollection without array used. Make sure to specify the values to be colormapped via the `c` argument.rT
zlines.markersizero
ÚcolorÚ
kz?Valid values for `prop` are 'colors' or 'sizes'. You supplied 'z
' instead.rz
é	r)rr5g@r(éééé
)ÚnbinsÚmin_n_ticksÚstepsé
r)ÚmarkeredgewidthrC
gÚ)rr€
ÚmsÚmarkerÚset_locs),Ú	get_arrayrCÚtickerÚScalarFormatterrtr1
ÚStrMethodFormatterÚcreate_dummy_axisÚwarningsÚwarnrTÚuniqueÚpoprDri
rÞÚaxisÚset_view_intervalÚminÚmaxÚset_data_intervalr€ÚLocatorrS
ÚFixedLocatorÚintÚMaxNLocatorÚtick_valuesÚlinspaceÚargsortÚinterpÚget_linewidthsÚ	get_alphar
r.r-rm
Úiscloser
ÚLine2Drfr¡rvr�
)r]ÚpropÚnumÚfmtÚfuncr^ÚhandlesÚlabelsÚhasarrayÚ
urT
r€
ÚfuÚvaluesÚlabel_valuesÚarrÚlocÚcondÚyarrÚxarrÚixÚkwÚvalÚlabÚ
hÚ
ls                          r`Úlegend_elementszPathCollection.legend_elementssÀð~
ˆØˆØ—>‘>Ó#¨4Ð/ˆØˆ;Ü—*‘*×,Ñ,°uÈ$Ð,ÓO‰CÜ
˜œSÔ
!Ü—*‘*×/Ñ/°Ó4ˆCØ×ÑÔà�8ÒÙÜ—
‘
ð.ô/ð �Ð&Ü—	‘	˜$Ÿ.™.Ó*Ó+ˆAØ—:‘:˜f¤c§l¡lÐ3EÑ&FÓG‰DØ
�WŠ_Ü—	‘	˜$Ÿ.™.Ó*Ó+ˆAØ—J‘J˜w¨Ó,‰Eäð
7Ø7;°f¸Jð
H
ó
I
ð

I
ñ�!‹WˆØ�‰×"Ñ" 2§6¡6£8¨R¯V©V«XÔ6Ø�‰×"Ñ" 2§6¡6£8¨R¯V©V«XÔ6Ø�&Š=؈CÜ�1‹v˜Š}Ø�؈;؈FÙ ›<ŠLà�xÒØ—n‘nÓ&‘ؘ’Ø—n‘nÓ&�ܘ#œsŸz™z×1Ñ1Ô2Ø‘Ü—‘˜SÔ!Ü—j‘j×-Ñ-¨cÓ2‘ä˜#“h�Ü—j‘j×,Ñ,°3ÀCÈ
ÁEÚ3Nð-ó
P
�àŸ?™?©4°«9¯=©=«?¹DÀ»I¿M¹M»OÓLˆLØ!¡T¨#£Y§]¡]£_Ñ4Ø!¡T¨#£Y§]¡]£_Ñ4ñ
6ˆDà'¨Ñ-ˆLÜ—;‘;˜sŸw™w›y¨#¯'©'«)°SÓ9ˆDÙ˜“:ˆDÜ—‘˜DÓ!ˆBÜ—Y‘Y˜|¨T°"©X°t¸B±xÓ@ˆFà!%×!4Ñ!4Ó!6°qÑ!9Ø—~‘~Ó'ñàðˆô˜F LÓ1ò
	‰HˆC�Ø�xÒØŸ	™	 $§)¡)¨C£.Ó1‘ؘ’Ü—w‘w˜s“|�Ü—:‘:˜d CÔ(ØÜ—
‘
˜q˜c A 3ð
@
¨2°U¸tØ%)§^¡^Ó%5°aÑ%8ñ
@
Ø<>ñ
@
ˆAà�N‰N˜1ÔÜ�s˜JÔ'Ø—‘˜\Ô*Ù�C“ˆAØ�M‰M˜!Õð
	ð˜ˆÐrarc)r´r[
r\
r]
r7rfrÀ
rb
rc
s
@r`rw
rw
ós$ø„ñõò&
ð$,°Ø ¡{÷Jrarw
có8‡—eZ
dZdd
dœ
ˆf
d„Zdd„
ZeZd„Zˆx
ZS)ÚPolyCollectionT)
Úclosedc
óx•
—t
‰|�di|¤
Ž

|j|«

|j|
|«
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«)r6r7rr
Ú	set_vertsrj)r]Úvertsro
rÃ
r^r_s     €r`r7zPolyCollection.__init__�s6ø€ô(	‰ÑÑ"˜6Ò"Ø�‰�uÔØ�‰�u˜fÔ%؈�
racóJ—d
|_t|
tjj«r2|
jt«
jtj«
}
|s)|
D�cgc]}tj|«
‘Œc}|_yt|
tj«r÷t|
j«
dk(rßtj|
|
dd…dd…ffd¬«}tj |jdtjj"¬«}tjj$|ddtjj&|d<tjj(|d<|D�cgc]}tj||«‘Œc}|_yg|_|
D]t}t|«
r9|jj+tjj-|«
«

ŒG|jj+tj|«
«

Œvyc
c}wc
c}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©
r™
©
Údtyperéÿÿÿÿ)rjrtrTr†r‡ÚastyperVrˆr‰rŠr¢r\Úndarrayr€rWÚconcatenater^
Ú	code_typeÚLINETOÚMOVETOÚ	CLOSEPOLYr¡Ú_create_closed)r]rÆ
rÃ
ÚxyÚ	verts_padr¤s      r`rÅ
zPolyCollection.set_verts¶s€
€ðˆŒ
Ü�eœRŸU™U×.Ñ.Ô/Ø—L‘L¤Ó'×.Ñ.¬r¯v©vÓ6ˆEñØ49Ö:¨bœ5Ÿ:™: b�>Ò:ˆDŒKØô�eœRŸZ™ZÔ(¬S°·±Ó-=ÀÒ-BÜŸ™¨¨u²Q¸¸¸°U©|Ð'<À1ÔEˆIô—H‘H˜YŸ_™_¨QÑ/´u·z±z×7KÑ7KÔLˆEÜ—z‘z×(Ñ(ˆE‘!ˆHÜ—z‘z×(Ñ(ˆE�!‰HÜŸ
™
×,Ñ,ˆE�"‰IØ;DÖE°Rœ5Ÿ:™: b¨%Õ0ÒEˆDŒKØàˆŒØò	3ˆBÜ�2ŒwØ—‘×"Ñ"¤5§:¡:×#<Ñ#<¸RÓ#@ÕAà—‘×"Ñ"¤5§:¡:¨b£>Õ2ñ		3ùò!;ùòF
sÁ$HÅ4H có
—t
|
«
t
|«
k7rtd
«
‚
t|
|«D��cgc];\}}t
|«
rtj||«ntj|«
‘Œ=c}}|_d|_yc
c}}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Þr
rŠr¢r\rj)r]rÆ
r¤rÔ
Úcdss     r`Úset_verts_and_codesz"PolyCollection.set_verts_and_codesâsw€äˆu‹:œ˜U›Ò#Üð
?ó
@
ð

@
ô'*¨%°Ó&7÷
9Ù"˜2˜sô/2°"¬g”u—z‘z " cÔ*¼5¿:¹:Àb»>ÑIó
9ˆŒàˆ�
ùó
9s²ABrc)
T)r´r[
r\
r7rÅ
rlrØ
rb
rc
s
@r`rÂ
rÂ
›s!ø„ð°Döó2(3ðT
€IörarÂ
c󦇗eZ
dZd
Zddddœˆf
d„
Zed„«Zed„«Zddœ
d	„Z	d
„Z
d„Zd„Zed
„«Z
d„Zed„«Zed„«Zd„Zˆx
ZS)ÚFillBetweenPolyCollectionzK
    `.PolyCollection` that fills the area between two x- or y-curves.
    NF)ÚwhereÚinterpolateÚstepcóx•
—|
|_||_
||_|j||||«}	t	‰
|�|	f
i|¤
Ž

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)Út_directionÚ_interpolateÚ_stepÚ_make_vertsr6r7)r]rß
Ú
tÚf1Úf2rÛ
rÜ
rÝ
r^rÆ
r_s          €r`r7z"FillBetweenPolyCollection.__init__ðsEø€ð@'ˆÔØ'ˆÔ؈Œ
Ø× Ñ   B¨¨EÓ2ˆÜ
‰Ñ˜Ñ) &Ó)rac
ó:—|d
k(r
y|dk(r
y
d|›�}
t
|
«
‚
)z/The direction that is other than `t_direction`.rèréz$t_direction must be 'x' or 'y', got )
rÞ)rß
Úmsgs  r`Ú
_f_dir_from_tz'FillBetweenPolyCollection._f_dir_from_t6s0€ð˜#ÒØØ
˜CÒ
Øà8¸¸ÐHˆCܘS“/Ð!rac
ó8—|j
|j«
S)
z4The direction that is other than `self.t_direction`.)rè
rß
res
 r`Ú_f_directionz&FillBetweenPolyCollection._f_directionAs€ð×!Ñ! $×"2Ñ"2Ó3Ð3ra)
rÛ
c
ó¼—|jj|j|j|
||«\}
}}|j	|
|||«}|j|«

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Ú_fill_between_process_unitsrß
rê
râ
rÅ
)r]rã
rä
rå
rÛ
rÆ
s      r`Úset_dataz"FillBetweenPolyCollection.set_dataFsY€ð8—I‘I×9Ñ9Ø×Ñ˜d×/Ñ/°°B¸ó
<‰	ˆ
ˆ2ˆrð× Ñ   B¨¨EÓ2ˆØ�‰�uÕracó
—tjj«}|j|j	«|
z
jt
j|j|jjg
g«
«
«

|S)
z7Calculate the data limits and return them as a `.Bbox`.)
rr~rr“r|r�rTrÎ
Ú_bboxÚminpos)r]r”Údatalims   r`r˜z%FillBetweenPolyCollection.get_datalimhse€ä—/‘/×&Ñ&Ó(ˆØ×#Ñ# T×%7Ñ%7Ó%9¸IÑ%E×$PÑ$PÜ�N‰N˜DŸJ™J¨¯©×):Ñ):Ð(;Ð<Ó=ó
%?ô
	@
àˆracó‚—|j
|j|j|
||«
|j|
|||«}t	j
t	j|
«
||d
¬«\}
}}tjj«|_
|jj|jt	j||fD�cgc]!}t	j|
|||fd¬«‘Œ#c}«
«
«

tj |«
D��cgc]\}}|j#|
||||«‘Œc}}Sc
c}wc
c}}w)zH
        Make verts that can be forwarded to `.PolyCollection`.
        T)
ÚsubokrË
rÈ
)Ú_validate_shapesrß
rê
Ú_get_data_maskrTÚbroadcast_arraysr
rr~rrï
r“Ú_fix_pts_xy_orderrÎ
Ústackr	Úcontiguous_regionsÚ_make_verts_for_region)r]rã
rä
rå
rÛ
Ú
fÚidx0Úidx1s        r`râ
z%FillBetweenPolyCollection._make_vertsos 
€ð	
×јd×.Ñ.°×0AÑ0AÀ1ÀbÈ"ÔMà×#Ñ# A r¨2¨uÓ5ˆÜ×'Ñ'¬¯
©
°aÓ(8¸"¸bÈÔM‰	ˆ
ˆ2ˆrä—_‘_×)Ñ)Ó+ˆŒ
Ø�
‰
×&Ñ& t×'=Ñ'=¼b¿n¹nØ>@À"¸Xö
N
G
Ø89ŒB�H‰H�a˜‘h 
 %¡Ð)°Ö3ò
N
G
ó
?H
ó
(I
ô
	J
ô
$×6Ñ6°uÓ=÷
á��dð
×'Ñ'¨
¨2¨r°4¸Õ>ó
ð	
ùò
N
G
ùó
sÃ&D6ÄD;c
ó†
—|€d
}npt
j|t¬«}|j|
jk7r<dj	|j|j
|
j«}t
|«
‚
|tjtjttjj|
||g««z
S)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É
z-where size ({}) does not match {!r} size ({}))
rTr 
r!
rT
Úformatrß
rÞÚ	functoolsÚreduceÚ
logical_orÚmapr†Úgetmaskarray)r]rã
rä
rå
rÛ
rç
s      r`rõ
z(FillBetweenPolyCollection._get_data_mask�s €ðˆ=؉Eä—J‘J˜u¬DÔ1ˆEØ�z‰z˜QŸV™VÒ#ØE×LÑLØ—J‘J × 0Ñ 0°!·&±&ó
:�ä  “oÐ%Øœ	×(Ñ(Ü�M‰Mœ3œrŸu™u×1Ñ1°A°r¸2°;Ó?ó
A
ð
A
ñ
A
ð
	A
racóp
—d
„t
||
|
fd«D«}t
||||g«D]Ž\}}|jdkDrt|›d�«
‚
|jdkDs
Œ3|jdkDs
ŒC|j|jk7s
Œ]dj	||j||j«}t|«
‚
y)zFValidate that t, f1 and f2 are 1-dimensional and have the same length.c
3ó,K
—|]\}
}|
|z–
—

Œy­w
rcr«)r¬r
Ú
ss   r`r­z=FillBetweenPolyCollection._validate_shapes.<locals>.<genexpr>–sèø€ÒN™4˜1˜a��Q•ÑNùs‚
)rŒ
Ú
1Ú
2rz is not 1-dimensionalz4{!r} has size {}, but {!r} has an unequal size of {}N)r
rQ
rÞrT
rÿ
)	Út_dirÚf_dirrã
rä
rå
Únamesr
rl
rç
s	         r`rô
z*FillBetweenPolyCollection._validate_shapes“sª€ñO
¤3¨¨u°eÐ'<¸nÓ#MÔNˆÜ˜u q¨"¨b kÓ2ò	&‰KˆD�%Ø�z‰z˜AŠ~Ü  D 8Ð+@Ð!AÓBÐBØ�v‰v˜
‹z˜eŸj™j¨1›n°·±¸5¿:¹:Ó1EØL×SÑSؘ1Ÿ6™6 4¨¯©ó
5�ä  “oÐ%ñ
	&rac	ó2—|
||}|||}|||}|j�.tjd|jz}	|	|||«\}}}|jr)|j	|
|||«}
|j	|
|||«}n|d|df}
|d|df}tjtj|
g
«
tj||fd¬«tj|g
«
tj||fd¬«d
d
d…f«
}|j|«
S)z‘
        Make ``verts`` for a contiguous region between ``idx0`` and ``idx1``, taking
        into account ``step`` and ``interpolate``.
        Nzsteps-rrË
rÈ
)
rá
r	ÚSTEP_LOOKUP_MAPrà
Ú_get_interpolating_pointsrTrÎ
r 
rø
r÷
)
r]rã
rä
rå
rü
rý
Út_sliceÚf1_sliceÚf2_sliceÚ	step_funcÚstartÚendÚptss
             r`rú
z0FillBetweenPolyCollection._make_verts_for_regionŸs)
€ð
�D˜�,ˆØ�d˜4�=ˆØ�d˜4�=ˆØ�:‰:Ð!Ü×-Ñ-¨h¸¿¹Ñ.CÑDˆIÙ*3°G¸XÀxÓ*PÑ'ˆG�X˜xà×ÒØ×2Ñ2°1°b¸"¸dÓCˆEØ×0Ñ0°°B¸¸DÓA‰Cð˜A‘J ¨¡Ð+ˆEؘ"‘+˜x¨™|Ð+ˆCä�n‰nÜ�J‰J˜�wÓÜ�H‰H�g˜xÐ(¨rÔ2Ü�J‰J˜�uÓÜ�H‰H�g˜xÐ(¨rÔ2±4°R°4Ñ8ð	:ó;ˆð×%Ñ% cÓ*Ð*racó‚
—t
|d
z
d«}|
||d
z}|||d
z|||d
zz
}|||d
z}t|«
dk(rXtjj	|d
«
r
|
|||fStjj	|d«
r
|
|||fS|jd||«}	|j|	||«}
|	|
fS)zCalculate interpolating points.rrr5)rœ
r€rTr†Ú	is_maskedÚ_get_diff_root)Úclsrã
rä
rå
ÚidxÚim1Út_valuesÚdiff_valuesÚ	f1_valuesÚdiff_root_tÚdiff_root_fs           r`rz3FillBetweenPolyCollection._get_interpolating_points¼sÛ€ô�#˜
‘'˜1‹oˆØ�S˜˜Q™�<ˆØ˜˜S ™U�m b¨¨S°©U mÑ3ˆØ�s˜3˜q™5�Mˆ	äˆ{Ó˜qÒ Ü�u‰u�‰˜{¨1™~Ô.ؘ‘v˜r #™w�Ð&Ü—‘—‘ ¨Q¡Ô0ؘ‘v˜r #™w�Ð&à×(Ñ(¨¨K¸ÓBˆØ×(Ñ(¨°hÀ	ÓJˆØ˜KÐ'Ð'racó\—|
j
«}tj||
|||«S)
zCalculate diff root.)r¤
rTr¥
)rèÚxpÚfpÚorders    r`rz(FillBetweenPolyCollection._get_diff_rootÎs*€ð—
‘
“ˆÜ�y‰y˜˜B˜u™I r¨%¡yÓ1Ð1racó<—|jd
k(r|
dd…ddd…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Ë
)
rß
)r]rs  r`r÷
z+FillBetweenPolyCollection._fix_pts_xy_orderÔs(€ð $×/Ñ/°3Ò6ˆs’1‘d˜�d�7‰|Ð?¸CÐ?ra)r´r[
r\
r]
r7ra
rè
Úpropertyrê
rí
r˜râ
rõ
rô
rú
Úclassmethodrrr÷
rb
rc
s
@r`rÚ
rÚ
ìs¢ø„ñð
 E°öD
*ðLñ"óð"ðñ4óð4ð,0ô òD
ò
ò$A
ð$ñ	&óð	&ò+ð:ñ(óð(ð"ñ2óð2ö
@
rarÚ
c󤇗eZ
dZd
Zej
jZejdzZ
dddœˆf
d„
Zd„Zd„Z
ejd	„«Zˆx
ZS)
ÚRegularPolyCollectionz)A collection of n-sided regular polygons.çà¿r)
r)Úrotationro
cóÖ•
—t
‰|�di|¤
Ž

|j|«

|
|_|j	|
«
g
|_||_|jtj««

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«)
r6r7rr
Ú	_numsidesÚ_path_generatorr\Ú	_rotationÚ
set_transformrrs)r]Únumsidesr,ro
r^r_s     €r`r7zRegularPolyCollection.__init__äs\ø€ôF
	‰ÑÑ"˜6Ò"Ø�‰�uÔØ!ˆŒØ×+Ñ+¨HÓ5Ð6ˆŒØ!ˆŒØ×Ñœ:×7Ñ7Ó9Õ:rac

ó—|jSrc)
r.res
 r`Úget_numsidesz"RegularPolyCollection.get_numsidesó€Ø�~‰~Ðrac

ó—|jSrc)
r0res
 r`Úget_rotationz"RegularPolyCollection.get_rotationr5racóZ
—|j
|j|jd
¬«
j«
|jD�cgc]?}tj|«
j|j«
j«‘ŒAc}|_tj||
«
yc
c}wrt
)rr
rh
rÊrp
rnrrÇÚrotater0Ú
get_matrixr&rÜ)r]ršrès   r`rÜzRegularPolyCollection.draws‚€à�‰�t—{‘{ D§O¡O¸ OÓ$>×$BÑ$BÔCð×%Ñ%ö
àô
×Ñ 
Ó"×)Ñ)¨4¯>©>¨/Ó:×EÑEÕGò
ˆÔô	�‰˜˜hÕ'ùò

sÁAB()r´r[
r\
r]
rŠr¢Úunit_regular_polygonr/rTÚpirn
r7r4r7rr`
rÜrb
rc
s
@r`r*r*ÞsTø„Ù3à—j‘j×5Ñ5€OØ�e‰e˜‰o€Gð
Øö	(;òT

ò
ð×Ññ(ó ô(rar*c
ó<—eZ
dZd
Zej
jZy)ÚStarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r´r[
r\
r]
rŠr¢Úunit_regular_starr/r«rar`r>r> s„ÙDØ—j‘j×2Ñ2�Orar>c
ó<—eZ
dZd
Zej
jZy)ÚAsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r´r[
r\
r]
rŠr¢Úunit_regular_asteriskr/r«rar`rArA%s„ÙHØ—j‘j×6Ñ6�OrarAc󎇗eZ
dZd
ZdZddœ
ˆf
d„
Zd„ZeZeZd„Z	d„Z
d	„Zd
„Zd„Z
ˆf
d„Zd
„ZeZd„ZeZd„Zd„Zd„Zd„Zˆx
ZS)ÚLineCollectiona­
    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
ón•
—|j
d
d«
t‰|�dd|i
|¤
Ž

|j|
«

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«)Ú
setdefaultr6r7Úset_segments)r]Úsegmentsr1r^r_s    €r`r7zLineCollection.__init__>sCø€ðL
	×ј,¨Ô/Ü
‰Ññ	Øð	àò	ð	
×ј(Õ#rac	ó
—|
€
y|
D�cgc]h}t
|tjj«rt	j
|«
n,t	j
tj|t««
‘Œjc}|_d
|_	yc
c}wri)
rtrTr†r‡rŠr¢r 
rVr\rj)r]rHÚsegs   r`rGzLineCollection.set_segmentsjsl€ØÐØð#+ö,àô+5°S¼"¿%¹%×:KÑ:KÔ*L”u—z‘z #”Ü!ŸJ™J¤r§z¡z°#´uÓ'=Ó>ñ
?ò,ˆŒðˆ�
ùò,sˆA-Bc
óÌ—g}
|jD]L}|jd
¬«
D��cgc]\}}|‘Œ	}}}tj|«
}|
j	|«

ŒN|
Sc
c}}w)z¤
        Returns
        -------
        list
            List of segments in the LineCollection. Each list item contains an
            array of vertices.
        F)
Úsimplify)r\Ú
iter_segmentsrTr 
r¡)r]rHrÚvertexÚ
_ržs      r`Úget_segmentszLineCollection.get_segmentsvsu€ðˆà—K‘Kò
	&ˆDð×%Ñ%¨uÐ%Ó5÷
á�F˜AòðˆHñô—z‘z (Ó+ˆHØ�O‰O˜HÕ%ð
	&ðˆùós§A c
ó(—tjd
S)Nzlines.linewidthr
res
 r`r

z%LineCollection._get_default_linewidthŽs€Ü�|‰|Ð-Ñ.Ð.rac
ó(—tjd
S)Nzlines.antialiasedr
res
 r`r
z'LineCollection._get_default_antialiased‘s€Ü�|‰|Ð/Ñ0Ð0rac
ó(—tjd
S)Nzlines.colorr
res
 r`r9
z%LineCollection._get_default_edgecolor”s€Ü�|‰|˜MÑ*Ð*rac
ó—y
)Nr°r«res
 r`r(
z%LineCollection._get_default_facecolor—s€Øracót•
—t‰|�|
«

|j�|j|j«

yyrc)r6rD
r=Úset_gapcolorÚ_original_gapcolor)r]rC
r_s  €r`rD
zLineCollection.set_alphašs3ø€ä
‰Ñ˜%Ô Ø�>‰>Ð%Ø×Ñ˜d×5Ñ5Õ6ð&racó&—|j
|
«

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 s€ð	
×ј1Õrac

ó—|jSrc)
r7
res
 r`Ú	get_colorzLineCollection.get_color¯rpracó4—|
|_|j|
«

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Ú
_set_gapcolor©r]Úgapcolors  r`rVzLineCollection.set_gapcolor´s€ð$#+ˆÔØ×ј8Õ$racód—|
� t
j|
|j«}
|
|_d
|_yri)rAr*
r+
r=rjr]s  r`r\zLineCollection._set_gapcolorÉs,€ØÐÜ×,Ñ,¨X°t·{±{ÓCˆHØ!ˆŒØˆ�
rac

ó—|jSrc)
r=res
 r`Úget_gapcolorzLineCollection.get_gapcolorÏr5rac

óH
—t
|jtj|j«
«D�
�cgc]W\}
}|d
k(r9tjtjdtj««
|fn|
tj|Žf‘ŒY}}
}t
|ŽSc
c}}
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ý)r
r\Ú	itertoolsÚcycler:rŠr¢rTÚfullr‰r
Ú_get_inverse_dash_pattern)r]rrÚ
path_patternss    r`rÑz,LineCollection._get_inverse_paths_linestylesÒs•€ô
�—‘œYŸ_™_¨T×-=Ñ-=Ó>Ó?÷A
ñ��rð�YŠô�Z‰ZœŸ™ ¬¯©Ó/Ó
0°"Ñ5à
”6×3Ñ3°RÐ8Ð9ñ
:ðA
ˆ
ñA
ô�MÐ"Ð"ùóA
s·AB)r´r[
r\
r]
r;
r7rGrÅ
rlrPr

r
r9
r(
rD
r&
Ú
set_colorsrZÚ
get_colorsrVr\rarÑrb
rc
s
@r`rDrD*suø„ñð"€Mðö*$òX
ð€IØ€Iòò0
/ò
1ò
+ò
ô7òð€Jò
 ð€Jò%ò*ò
ö#rarDc󞇗eZ
dZd
ZdZ	ddddddddœˆf
d„Zd	„Zd
„Zd„Zex
Z	Z
d„Zd
„Zd„Z
d„Zd„Zd„Zd„Zd„Zˆf
d„Zˆf
d„Zd„Zˆx
ZS)ÚEventCollectionzÐ
    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))Ú
lineoffsetÚ
linelengthr#r€
r"rcóž•
—t
‰
|�gf
||||d
œ|	¤
Ž

d|_||_||_|j|«

|j
|
«

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
        )rrrrTN)r6r7Ú_is_horizontalÚ_linelengthÚ_lineoffsetÚset_orientationÚ
set_positions)r]Ú	positionsÚorientationrlrmr#r€
r"rr^r_s          €r`r7zEventCollection.__init__îsdø€ô`
	‰Ñ˜ð	#Ø$-¸)Ø %°Kñ	#ð"ò	#ð#ˆÔØ%ˆÔØ%ˆÔØ×ј[Ô)Ø×ј9Õ%rac
óz—|j
«rd
n
d}
|j«D�cgc]	}|d
|
f‘Œc}Sc
c}w)zX
        Return an array containing the floating-point values of the positions.
        rr)Ú
is_horizontalrP)r]ÚposÚsegments   r`Ú
get_positionszEventCollection.get_positions(s;€ð×%Ñ%Ô'‰a¨QˆØ/3×/@Ñ/@Ó/BÖC G�˜
˜3˜“ÒCÐCùÒCs§8có¶
—|
€g}
t
j|
«
dk7rtd«
‚
|j«}|j	«}|j«rdn
d}t
jt|
«
ddf«
}t
j|
«
d
d
…d
f|d
d
…d
d
…|f<||dzz|d
d
…dd|z
f<||dzz
|d
d
…dd|z
f<|j|«

y
)z Set the positions of the events.Nrz!positions must be one-dimensionalrr5)
rTrQ
rÞÚget_lineoffsetÚget_linelengthrwr^
r€ÚsortrG)r]rtrlrmÚpos_idxrHs      r`rszEventCollection.set_positions/sÝ€àÐ؈IÜ
�7‰7�9Ó Ò"ÜÐ@ÓAÐAØ×(Ñ(Ó*ˆ
Ø×(Ñ(Ó*ˆ
Ø×)Ñ)Ô+‘!°ˆÜ—8‘8œS ›^¨Q°
Ð2Ó3ˆÜ"$§'¡'¨)Ó"4²Q¸°WÑ"=ˆ’’A�w�ÑØ&0°:À
±>Ñ&Aˆ’�A�q˜7‘{Ð"Ñ#Ø&0°:À
±>Ñ&Aˆ’�A�q˜7‘{Ð"Ñ#Ø×ј(Õ#racóÔ—|
�t
|
d«rt|
«
dk(r
y
|j«}tj|tj
|
«
g«
}|j
|«

y
)z2Add one or more events at the specified positions.Nr€r)rvr€rzrTÚhstackrUrs)r]Úpositionrts   r`Ú
add_positionszEventCollection.add_positions>sX€àФ¨°%Ô 8Ü # H£
°Ò 2ØØ×&Ñ&Ó(ˆ	Ü—I‘I˜y¬"¯-©-¸Ó*AÐBÓCˆ	Ø×ј9Õ%rac

ó—|jS)
z=True if the eventcollection is horizontal, False if vertical.)
rores
 r`rwzEventCollection.is_horizontalHs€à×"Ñ"Ð"rac
ó*—|j
«rd
SdS)zX
        Return the orientation of the event line ('horizontal' or 'vertical').
        Ú
horizontalÚvertical)
rwres
 r`Úget_orientationzEventCollection.get_orientationLs€ð $×1Ñ1Ô3ˆ|ÐC¸ÐCrac
óÖ—|j
«}
t|
«
D]\}}tj|«
|
|<Œ|j	|
«

|j«|_d
|_y)zv
        Switch the orientation of the event line, either from vertical to
        horizontal or vice versus.
        TN)rPÚ	enumeraterTÚfliplrrGrwrorj)r]rHÚ
irys    r`Úswitch_orientationz"EventCollection.switch_orientationRse€ð
×$Ñ$Ó&ˆÜ# HÓ-ò
	-‰JˆAˆwÜŸ)™) GÓ,ˆH�QŠKð
	-à×ј(Ô#Ø"&×"4Ñ"4Ó"6Ð6ˆÔ؈�
racó€—t
jd
ddœ|
¬«}||j«k(r
y|j«
y)z�
        Set the orientation of the event line.

        Parameters
        ----------
        orientation : {'horizontal', 'vertical'}
        TF)r†r‡)
ruN)rÚ
check_getitemrwr�)r]rurws   r`rrzEventCollection.set_orientation^sA€ô×*Ñ*بUÑ3Ø#ô%ˆ
ð˜D×.Ñ.Ó0Ò0ØØ×ÑÕ!rac

ó—|jS)
z7Return the length of the lines used to mark each event.)
rpres
 r`r}zEventCollection.get_linelengthmó€à×ÑÐracó
—|
|j
«k(r
y
|j«}|j«}|j«rdn
d}|D]}||
dzz|d|f<||
dzz
|d|f<Œ|j	|«

|
|_y
)z4Set the length of the lines used to mark each event.Nrrç@)r}r|rPrwrGrp)r]rmrlrHrxrys      r`Úset_linelengthzEventCollection.set_linelengthqó—€à˜×,Ñ,Ó.Ò.ØØ×(Ñ(Ó*ˆ
Ø×$Ñ$Ó&ˆØ×%Ñ%Ô'‰a¨QˆØò	;ˆGØ(¨:¸©?Ñ:ˆG�A�s�F‰OØ(¨:¸©?Ñ:ˆG�A�s�FŠOð	;ð	
×ј(Ô#Ø%ˆÕrac

ó—|jS)
z7Return the offset of the lines used to mark each event.)
rqres
 r`r|zEventCollection.get_lineoffset~r‘racó
—|
|j
«k(r
y
|j«}|j«}|j«rdn
d}|D]}|
|dzz|d|f<|
|dzz
|d|f<Œ|j	|«

|
|_y
)z4Set the offset of the lines used to mark each event.Nrrr“)r|r}rPrwrGrq)r]rlrmrHrxrys      r`Úset_lineoffsetzEventCollection.set_lineoffset‚r•rac
ó&•
—t‰
|�«d
S)z3Get the width of the lines used to mark each event.r©r6rF
©r]r_s €r`rF
zEventCollection.get_linewidth�sø€ä‰wÑ$Ó& qÑ)Ð)rac
ó •
—t‰
|�«Srcršr›s €r`r¦
zEventCollection.get_linewidths“sø€Ü‰wÑ$Ó&Ð&rac
ó(—|j
«d
S)z6Return the color of the lines used to mark each event.r)
rires
 r`rZzEventCollection.get_color–s€à�‰Ó  Ñ#Ð#ra)
r†)r´r[
r\
r]
r;
r7rzrsrƒÚextend_positionsÚappend_positionsrwrˆr�rrr}r”r|r˜rF
r¦
rZrb
rc
s
@r`rkrkäs‰ø„ñð€Mð*ð8&ðØØØØ"Ø!ö8&òt
D
ò
$ò&ð+8Ð7ÐÐ'ò#òD
ò
ò
"ò ò&ò ò&ô*ô
'ö$rarkcó@‡—eZ
dZd
Zej
dzZˆf
d„Zˆx
ZS)ÚCircleCollectionz-A collection of circles, drawn using splines.r+cóÔ•
—t
‰|�di|¤
Ž

|j|
«

|jt	j
««

tjj«g
|_	y
)z½
        Parameters
        ----------
        sizes : float or array-like
            The area of each circle in points^2.
        **kwargs
            Forwarded to `.Collection`.
        Nr«)
r6r7rr
r1rrsrŠr¢Úunit_circler\)r]ro
r^r_s   €r`r7zCircleCollection.__init__ sOø€ô	‰ÑÑ"˜6Ò"Ø�‰�uÔØ×Ñœ:×7Ñ7Ó9Ô:Ü—z‘z×-Ñ-Ó/Ð0ˆ�ra)	r´r[
r\
r]
rTr<rn
r7rb
rc
s
@r`r¡r¡›sø„Ù7à�e‰e˜‰o€G÷1ð1rar¡cóz‡—eZ
dZd
Zddœ
ˆf
d„
Zd„Zd„Zd„Zd„Zd	„Z	d
„Z
d„Zejˆf
d„«Zˆx
ZS)
ÚEllipseCollectionz.A collection of ellipses, drawn using splines.Úpoints)
Úunitsc
óZ
•
—t
‰|�di|¤
Ž

|j|
«

|j|«

|j	|«

||_|j
tj««

tjd
«
|_tjj«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«)r6r7Ú
set_widthsÚset_heightsÚ
set_anglesÚ_unitsr1rrsrTr^
rnrŠr¢r£r\)r]ÚwidthsÚheightsÚanglesr§r^r_s      €r`r7zEllipseCollection.__init__²s�ø€ô*	‰ÑÑ"˜6Ò"Ø�‰˜ÔØ×јÔ!Ø�‰˜Ô؈ŒØ×Ñœ:×7Ñ7Ó9Ô:ÜŸ8™8 IÓ.ˆÔÜ—z‘z×-Ñ-Ó/Ð0ˆ�rac
ó¦—|j}
|jd
¬«
}|jdk(rd}�
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|jdk(r|
jj}n*|jdk(rd
}ntd|j›�«
‚
tjt|j«
ddf«
|_
|j|z}|j|z}tj|j «
}tj"|j «
}||z|jdd…ddf<||z|jdd…ddf<||z|jdd…ddf<||z|jdd…ddf<d
|jdd…ddf<t$j&}|jdk(rY|
j(j+«j-«j/«}	d|	dd…dd…f<|j1||	«
«

yy)z0Calculate transforms immediately before drawing.Fr®rÔ
rrèréÚinchesr¦rk
rÉrËÚdotsrf
zUnrecognized units: r(Nrr5)rwrÊr¬r—rÉÚviewLimrËrp
rÞrTrþr€Ú_widthsrnÚ_heightsÚsinÚ_anglesÚcosrrÇr”rŒr:Úcopyr1)
r]ÚaxÚfigÚscr­r®Ú	sin_angleÚ	cos_angleÚ_affineÚ
ms
          r`Ú_set_transformsz!EllipseCollection._set_transformsÐsP€ð�Y‰YˆØ�o‰o 5ˆoÓ)ˆà�;‰;˜$ÒØŠBØ
�[‰[˜CÒ
Ø—‘—‘ §¡×!1Ñ!1Ñ1‰BØ
�[‰[˜CÒ
Ø—‘—‘ "§*¡*×"3Ñ"3Ñ3‰BØ
�[‰[˜HÒ
$Ø—‘‰BØ
�[‰[˜HÒ
$Ø—‘˜4‘‰BØ
�[‰[˜GÒ
#Ø—‘—‘‰BØ
�[‰[˜HÒ
$Ø—‘—‘‰BØ
�[‰[˜FÒ
"؉BäÐ3°D·K±K°?ÐCÓDÐDäŸ8™8¤S¨¯©Ó%6¸
¸1Ð$=Ó>ˆÔØ—‘ Ñ"ˆØ—-‘- "Ñ$ˆÜ—F‘F˜4Ÿ<™<Ó(ˆ	Ü—F‘F˜4Ÿ<™<Ó(ˆ	Ø$*¨YÑ$6ˆ×Ñš˜A˜q˜Ñ!Ø$+¨y¨jÑ$8ˆ×Ñš˜A˜q˜Ñ!Ø$*¨YÑ$6ˆ×Ñš˜A˜q˜Ñ!Ø$+¨iÑ$7ˆ×Ñš˜A˜q˜Ñ!Ø$'ˆ×Ñš˜A˜q˜Ñ!ä×%Ñ%ˆØ�;‰;˜$ÒØ—‘×'Ñ'Ó)×4Ñ4Ó6×;Ñ;Ó=ˆA؈Aˆbˆqˆb�!‘"ˆf‰IØ×Ñ™w q›zÕ*ðracóh—d
t
j|
«
j«z|_d|_y)z5Set the lengths of the first axes (e.g., major axis).çà?TN)rTr 
Úravelr´rj)r]r­s  r`r©zEllipseCollection.set_widthsús'€àœRŸZ™Z¨Ó/×5Ñ5Ó7Ñ7ˆŒ؈�
racóh—d
t
j|
«
j«z|_d|_y)ú2Set the lengths of second axes (e.g., minor axes).rÃTN)rTr 
rÄrµrj)r]r®s  r`rªzEllipseCollection.set_heightsÿs'€àœbŸj™j¨Ó1×7Ñ7Ó9Ñ9ˆŒ
؈�
racób—t
j|
«
j«|_d
|_y)z>Set the angles of the first axes, degrees CCW from the x-axis.TN)rTÚdeg2radrÄr·rj)r]r¯s  r`r«zEllipseCollection.set_angless"€ä—z‘z &Ó)×/Ñ/Ó1ˆŒ؈�
rac
ó —|jd
zS)z5Get the lengths of the first axes (e.g., major axis).r5)
r´res
 r`Ú
get_widthszEllipseCollection.get_widths	s€à�|‰|˜aÑÐrac
ó —|jd
zS)rÆr5)
rµres
 r`Úget_heightszEllipseCollection.get_heights
s€à�}‰}˜qÑ Ð rac
ó@—t
j|j«
S)
z>Get the angles of the first axes, degrees CCW from the x-axis.)rTÚrad2degr·res
 r`Ú
get_angleszEllipseCollection.get_angless€ä�z‰z˜$Ÿ,™,Ó'Ð'racóD•
—|j
«
t‰|�	|
«

yrc)rÁr6rÜru
s  €r`rÜzEllipseCollection.drawsø€à×ÑÔÜ
‰‰�XÕra)r´r[
r\
r]
r7rÁr©rªr«rÊrÌrÏrr`
rÜrb
rc
s
@r`r¥r¥¯sLø„Ù8à9Aö1ò<(+òT
ò
ò
ò
 ò!ò(ð×Ñóó ôrar¥có.‡—eZ
dZd
Zddœ
ˆf
d„
Zd„Zˆx
ZS)ÚPatchCollectionzá
    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)
Úmatch_originalc
ó¼
•
—|r d
„}|
D�cgc]
}||«
‘Œc}|d<|
D�cgc]}|j
«‘Œc}|d<|
D�cgc]}|j«‘Œc}|d<|
D�cgc]}|j«‘Œc}|d<|
D�cgc]}|j«‘Œc}|d<t	‰|�di|¤
Ž

|j
|
«

yc
c}wc
c}wc
c}wc
c}wc
c}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
óJ—|j
«r|j«Sgd
¢
S)N)rrrr)rW
rÂ)
Úpatchs
 r`Údetermine_facecolorz5PatchCollection.__init__.<locals>.determine_facecolorBs!€Ø—>‘>Ô#Ø ×.Ñ.Ó0Ð0Ú#Ð#rarrrrrNr«)rÃrF
rH
r
r6r7rl)r]ÚpatchesrÓr^r×r–r_s      €r`r7zPatchCollection.__init__$sÌø€ñ:ò
$ð
E
L
Ö#L¸qÑ$7¸
Õ$:Ò#LˆF�<Ñ Ø?FÖ#G¸! A§O¡OÕ$5Ò#GˆF�<Ñ Ø?FÖ#G¸! A§O¡OÕ$5Ò#GˆF�<Ñ Ø?FÖ#G¸! A§O¡OÕ$5Ò#GˆF�<Ñ ØCJÖ%K¸a a×&7Ñ&7Õ&9Ò%KˆF�>Ñ"ä
‰ÑÑ"˜6Ò"à�‰�wÕùò$M
ùÚ#GùÚ#GùÚ#GùÚ%Ks‹C¤C
ÁCÁ&CÂCcó�—|
D�cgc]/}|j
«j|j««
‘Œ1}}||_yc
c}wrc)r|Útransform_pathÚget_pathr\)r]rØr–rks    r`rlzPatchCollection.set_pathsQsC€à!ö
#Øð—‘Ó"×1Ñ1°!·*±*³,Õ?ð
#ˆð
#àˆ�ùò
#s…4A)r´r[
r\
r]
r7rlrb
rc
s
@r`rÒrÒsø„ñð38ö+ öZ
rarÒcób‡—eZ
dZd
Zˆf
d„Zd„Zd„Zed„«Ze	jd„«Zˆx
ZS)ÚTriMeshz™
    Class for the efficient drawing of a triangular mesh using Gouraud shading.

    A triangular mesh is a `~matplotlib.tri.Triangulation` object.
    cóR
•
—t
‰|�di|¤
Ž

|
|_d
|_tj
j
«|_tj|
jjdd«|
jjdd«f«
}|jj|«

y)NÚgouraudrË
rr«)r6r7Ú_triangulationÚ_shadingrr~Úunitrï
rTr�rèrU
rér“)r]Ú
triangulationr^rÔ
r_s    €r`r7zTriMesh.__init__]s„ø€Ü
‰ÑÑ"˜6Ò"Ø+ˆÔØ!ˆŒ
ä—_‘_×)Ñ)Ó+ˆŒ
ô�Y‰Y˜
Ÿ™×/Ñ/°°AÓ6Ø%Ÿ™×/Ñ/°°AÓ6ð
8ó
9ˆà�
‰
×&Ñ& rÕ*rac
óR—|j€|j«
|jSrc©r\rlres
 r`rfzTriMesh.get_pathsjó €Ø�;‰;ÐØ�N‰NÔØ�{‰{Ðrac
óD—|j
|j«
|_yrc)Úconvert_mesh_to_pathsràr\res
 r`rlzTriMesh.set_pathsos€Ø×0Ñ0°×1DÑ1DÓEˆ�rac
óØ—|j
«}
tj|j|
|j|
fd
¬«}|D�cgc]}tj|«
‘Œc}Sc
c}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È
)Úget_masked_trianglesrTrø
rèrérŠr¢)ÚtriÚ	trianglesrÆ
rès    r`rèzTriMesh.convert_mesh_to_pathsrsU€ð×,Ñ,Ó.ˆ	Ü—‘˜#Ÿ%™% 	Ñ*¨C¯E©E°)Ñ,<Ð=ÀBÔGˆØ',Ö- !”—
‘
˜1•
Ò-Ð-ùÒ-sÁA'cóÀ—|j
«s
y|
j|jj|j	«¬
«
|j«}|j}|j«}tj|j||j|fd¬«}|j«
|j|}|
j«}|j|«

|j!|j#«d«

|
j%||||j'««
|j)«
|
j+|jj«

y)N)
ÚgidrË
rÈ
r)r²r³r_r´rµr|ràrêrTrø
rèrér¶r,
r·r¸rIrF
Údraw_gouraud_trianglesrŽrÓrÔ)r]ršr�rërìrÆ
rrÕs        r`rÜzTriMesh.draw~s
€à×ÑÔ!ØØ×јDŸN™N×3Ñ3¸¿¹»ÐÔHØ×&Ñ&Ó(ˆ	ð×!Ñ!ˆØ×,Ñ,Ó.ˆ	ä—‘˜#Ÿ%™% 	Ñ*¨C¯E©E°)Ñ,<Ð=ÀBÔGˆà×"Ñ"Ô$Ø×!Ñ! )Ñ,ˆà
�_‰_Ó
ˆØ×ј"ÔØ
×ј×+Ñ+Ó-¨aÑ0Ô1Ø×'Ñ'¨¨E°6¸9×;KÑ;KÓ;MÔNØ
�
‰
ŒØ×јTŸ^™^×4Ñ4Õ5ra)
r´r[
r\
r]
r7rfrlra
rèrr`
rÜrb
rc
s
@r`rÝrÝWsFø„ñô
+òò