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

B
U<>]<5D>Q<00>@s<>dd
lZdd
l
Z
dd
lZdd
lZddlmZ
dd
lZdd
lZdd
l	Z
ddlmZm
Z
mZmZmZmZ
ddlmZmZmZmZmZmZmZmZmZmZ
ddlmZ
e
<0A> dg
dg
d	g
d
g
dg
d<0C><05>
Gd
d<0E>dej!<21><03>
Z"e<0C>#e"<22>
Z$xdD]Z%ej&<26>'e%e$i
<01>

q<>We<0F>(e"j)<29>

Gdd<11>de"<22>Z*Gdd<13>de"<22>Z+Gdd<15>de"<22>Z,Gdd<17>de"<22>Z-Gdd<19>de"<22>Z.Gdd<1B>de"<22>Z/Gdd<1D>de"<22>Z0Gdd<1F>de.<2E>Z1ej&<26>'de1j)j2i
<01>

e
j3d d!d"<22>Gd#d$<24>d$e"<22><03>
Z4Gd%d&<26>d&e,<2C>Z5Gd'd(<28>d(e"<22>Z6Gd)d*<2A>d*e6<65>Z7Gd+d,<2C>d,e6<65>Z8dNd.d/<2F>
Z9dOd1d2<64>
Z:dPd4d5<64>
Z;d6d7<64>Z<d8d9<64>Z=Gd:d;<3B>d;e><3E>Z?dQd
d<<3C>
d=d><3E>Z@Gd?d@<40>d@e?<3F>ZAej&j'e<eAjB<6A>
e=eAjB<6A>
dA<64>
GdBdC<64>dCe"<22>ZCGdDdE<64>dEe?<3F>ZDdFdG<64>ZEGdHdI<64>dIe?<3F>ZFej&j'e<eFjB<6A>
e<eDjB<6A>
dJ<64>
GdKd!<21>d!e"<22>ZGGdLdM<64>dMeG<65>ZHd
S)R<>N)
<01>Number<65>
)<06>artist<73>cbook<6F>colors<72>	docstring<6E>lines<65>
transforms)
<EFBFBD>NonIntersectingPathException<6F>concatenate_paths<68>get_cos_sin<69>get_intersection<6F>
get_parallels<6C>
inside_circle<6C>make_path_regular<61>make_wedged_bezier2<72>)split_bezier_intersecting_with_closedpath<74>split_path_inout)
<01>Path<74>aaZecZfc<66>ls<6C>lw)<05>antialiased<65>	edgecolor<6F>	facecolor<6F>	linestyle<6C>	linewidthc
@sp
eZ
dZd
ZdZdZdZdZdTdd	<09>
Zd
d<0B>Z	dd
<0A>Z
dUdd<0F>
ZdVdd<11>
ZdWdd<13>
Z
dd<15>Zdd<17>Zdd<19>Zdd<1B>Zdd<1D>Zdd<1F>Zd d!<21>Zd"d#<23>Zd$d%<25>Zd&d'<27>Zd(d)<29>Zd*d+<2B>Zd,d-<2D>Zd.d/<2F>Zd0d1<64>Zd2d3<64>Zd4d5<64>Zd6d7<64>Zd8d9<64>Z d:d;<3B>Z!d<d=<3D>Z"e#e"e!<21>Z$d>d?<3F>Z%d@dA<64>Z&dBdC<64>Z'dDdE<64>Z(dFdG<64>Z)dHdI<64>Z*e+j,dJdK<64><00>
Z-e.j/dLdM<64><00>
Z0dNdO<64>Z1dXdPdQ<64>
Z2dRdS<64>Z3dS)Y<>Patchz<68>
    A patch is a 2D artist with a face color and an edge color.

    If any of *edgecolor*, *facecolor*, *linewidth*, or *antialiased*
    are *None*, they default to their rc params setting.
    r)<03>butt<74>roundZ
projecting)<03>miterrZbevelFNTcKs
tj
<01>|<00>

|d
krtjd}|d
kr*d}|	d
kr6d}	|
d
krBd}
|d
krTtjd}t<05>tjd<00>
|_d|_|d
k	r<>|
d
k	s<>|d
k	r<>t	<09>
d	<09>

|<00>|<03>

n|<00>|
<01>

|<00>
|<02>

d
|_d
|_|<00>|<08>

|<00>|<05>

|<00>|<04>

|<00>|<06>

|<00>|<07>

|<00>|	<09>

|<00>|
<EFBFBD>

t|<0B>
<01>
r|<00>|<0B>

d
S)zQ
        The following kwarg properties are supported

        %(Patch)s
        Nzpatch.linewidth<74>solidrr zpatch.antialiasedzhatch.colorTzQSetting the 'color' property will override the edgecolor or facecolor properties.r
)r<00>Artist<73>__init__<5F>mpl<70>rcParamsr<00>to_rgba<62>_hatch_color<6F>_fillrZ_warn_external<61>	set_color<6F>
set_edgecolor<6F>
set_facecolor<6F>
_us_dashes<EFBFBD>
_linewidth<EFBFBD>set_fill<6C>
set_linestyle<6C>
set_linewidth<74>set_antialiased<65>	set_hatch<63>set_capstyle<6C>
set_joinstyle<6C>len<65>update)<0C>selfrr<00>colorrrr<00>hatch<63>fillZcapstyleZ	joinstyle<6C>kwargs<67>r<<00>:/tmp/pip-install-i8dhxrtk/matplotlib/matplotlib/patches.pyr#*s>


































zPatch.__init__c
Cs.|<00><00>}
|<00>
<01>}|<02>|
<01>
}t|<03>
r*|d
SgS)z<>
        Return a copy of the vertices used in this patch

        If the patch contains Bezier curves, the curves will be
        interpolated by line segments.  To access the curves as
        curves, use :meth:`get_path`.
        r
)<04>
get_transform<72>get_pathZto_polygonsr5)r7<00>trans<6E>pathZpolygonsr<r<r=<00>	get_vertsbs





zPatch.get_vertscCsB|
dk	r|
St|j
t<02>r |j
}n|<00><03>d
dkr6d}n|<00><04>}|S)N<>r
)<05>
isinstanceZ_pickerr<00>
get_edgecolor<6F>
get_linewidth)r7<00>radius<75>_radiusr<r<r=<00>_process_radiusqs





zPatch._process_radiuscs<><00>jd
k	r<16><02><00><02><00>S<00><02>
<01>
<01>
<01>
<01><02><02>j}|d
k	rx<72><02><02>j}t<05>|tjk<02>
\
}|dd
<01>}t	tt<05>
||<05>t<05>
||<05><02>}n
<EFBFBD><02><02>g
}t<0B><00>
<01>fdd<04>|D<00>
<01>
}|ifS)z<>
        Test whether the mouse event occurred in the patch.

        Returns
        -------
        (bool, empty dict)
        Nrc
3s(|] }
|
<01><00>j
<01>jf<02><02><03><00>
<01>V
qdS)
N)<04>contains_point<6E>
x<>
yr>)<02>.0<EFBFBD>subpath)<03>
mouseeventrGr7r<r=<00>	<genexpr><3E>sz!Patch.contains.<locals>.<genexpr>)Z	_containsrIr?<00>codes<65>vertices<65>np<6E>wherer<00>MOVETO<54>map<61>split<69>any)r7rOrGrQrRZidxsZsubpaths<68>insider<)rOrGr7r=<00>contains}s















zPatch.containscCs |<00>|<02>
}|<00>
<01><00>|
|<00><03>|<02>S)
z<>
        Returns ``True`` if the given *point* is inside the path
        (transformed with its transform attribute).

        *radius* allows the path to be made slightly larger or smaller.
        )rIr?rJr>)r7ZpointrGr<r<r=rJ<00>s




zPatch.contains_pointcCs |<00>|<02>
}|<00>
<01><00>|
|<00><03>|<02>S)
a

        Returns a bool array which is ``True`` if the (closed) path
        contains the corresponding point.
        (transformed with its transform attribute).

        *points* must be Nx2 array.
        *radius* allows the path to be made slightly larger or smaller.
        )rIr?<00>contains_pointsr>)r7ZpointsrGr<r<r=r[<00>s	




zPatch.contains_pointscCsvtj
<01>||
<01>
|
j|_|
j|_|
j|_|
j|_|
j|_|
j|_|
j	|_	|
j
|_
|<00>|
j<0C>

|<00>
|
<01><0E><00>

|
<01><0F>|_d
S)zM
        Updates this :class:`Patch` from the properties of *other*.
        N)rr"<00>update_from<6F>
_edgecolor<EFBFBD>
_facecolor<EFBFBD>_original_edgecolor<6F>_original_facecolorr(<00>_hatchr'r,r0r-<00>
set_transform<72>get_data_transformZis_transform_setZ
_transformSet)r7<00>otherr<r<r=r\<00>s







zPatch.update_fromc

Cs|<00><00><00>
|<00><02><00>
S)
z<>
        Return a :class:`~matplotlib.transforms.Bbox` object defining
        the axis-aligned extents of the :class:`Patch`.
        )r?<00>get_extentsr>)
r7r<r<r=re<00>szPatch.get_extentsc

Cs|<00><00>t
j<02>|<00>
S)
zm
        Return the :class:`~matplotlib.transforms.Transform` applied
        to the :class:`Patch`.
        )<04>get_patch_transformrr"r>)
r7r<r<r=r><00>szPatch.get_transformc

Cstj
<01>|<00>
S)
z<>
        Return the :class:`~matplotlib.transforms.Transform` instance which
        maps data coordinates to physical coordinates.
        )rr"r>)
r7r<r<r=rc<00>szPatch.get_data_transformc

Cst<00>
<01>S)
ah

        Return the :class:`~matplotlib.transforms.Transform` instance which
        takes patch coordinates to data coordinates.

        For example, one may define a patch of a circle which represents a
        radius of 5 by providing coordinates for a unit circle, and a
        transform which scales the coordinates (the patch coordinate) by 5.
        )r	<00>IdentityTransform)
r7r<r<r=rf<00>s	zPatch.get_patch_transformc


Cs|jS)
zV
        Returns True if the :class:`Patch` is to be drawn with antialiasing.
        )
<01>_antialiased)
r7r<r<r=<00>get_antialiased<65>szPatch.get_antialiasedc


Cs|jS)
z>
        Return the edge color of the :class:`Patch`.
        )
r])
r7r<r<r=rE<00>szPatch.get_edgecolorc


Cs|jS)
z>
        Return the face color of the :class:`Patch`.
        )
r^)
r7r<r<r=<00>
get_facecolor<6F>szPatch.get_facecolorc


Cs|jS)
z2
        Return the line width in points.
        )
r-)
r7r<r<r=rF<00>szPatch.get_linewidthc


Cs|jS)
z'
        Return the linestyle.
        )
<01>
_linestyle)
r7r<r<r=<00>
get_linestyle
szPatch.get_linestylecCs"|
d
krtj
d}
|
|_d|_d
S)z{
        Set whether to use antialiased rendering.

        Parameters
        ----------
        b : bool or None
        Nzpatch.antialiasedT)r$r%rh<00>stale)r7rr<r<r=r1
s



zPatch.set_antialiasedcCs\d
}|
dkr6tj
ds"|jr"|jr.tj
d}
nd}
d}t<04>|
|j<06>|_|rR|j|_d
|_	dS)NTzpatch.force_edgecolorzpatch.edgecolor<6F>noneF)
r$r%r(<00>
_edge_defaultrr&<00>_alphar]r'rm)r7r8<00>set_hatch_colorr<r<r=<00>_set_edgecolor
s









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

d
S)zz
        Set the patch edge color.

        Parameters
        ----------
        color : color or None or 'auto'
        N)r_rr)r7r8r<r<r=r*$
s
zPatch.set_edgecolorcCs:|
dkrtj
d
}
|jr|jnd}t<04>|
|<02>|_d|_dS)Nzpatch.facecolorr
T)r$r%r(rprr&r^rm)r7r8<00>alphar<r<r=<00>_set_facecolor/
s






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

d
S)zp
        Set the patch face color.

        Parameters
        ----------
        color : color or None
        N)r`rt)r7r8r<r<r=r+6
s
zPatch.set_facecolorcCs|<00>|
<01>

|<00>
|
<01>

d
S)a

        Set both the edgecolor and the facecolor.

        Parameters
        ----------
        c : color

        See Also
        --------
        Patch.set_facecolor, Patch.set_edgecolor
            For setting the edge or face color individually.
        N)r+r*)r7<00>
cr<r<r=r)A
s

zPatch.set_colorcCs\|
d
k	r2yt|
<01>

Wnt
k
r0


t
d<02>
<01>
YnXtj<03>||
<01>
|<00>|j<06>

|<00>|j<08>

d
S)z
        Set the alpha transparency of the patch.

        Parameters
        ----------
        alpha : float or None
        Nzalpha must be a float or None)	<09>float<61>	TypeErrorrr"<00>	set_alphartr`rrr_)r7rsr<r<r=rxQ
s






zPatch.set_alphacCsZ|
d
kr$tj
d}
|
d
kr$tj
d}
t|
<01>
|_|j\}}t<05>|||j<03>\|_|_d|_	d
S)zu
        Set the patch linewidth in points.

        Parameters
        ----------
        w : float or None
        Nzpatch.linewidthzaxes.linewidthT)
r$r%rvr-r,<00>mlines<65>
_scale_dashes<65>_dashoffset<65>_dashesrm)r7<00>
w<>offsetrr<r<r=r0c
s









zPatch.set_linewidthcCsH|
d
krd}
|
|_t
<01>|
<01>
\}}
|_t
<01>||
|j<05>\|_|_d|_d
S)a
        Set the patch linestyle.

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

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

            (offset, onoffseq),

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

        Parameters
        ----------
        ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}
            The line style.
        Nr!T)	rkryZ_get_dash_patternr,rzr-r{r|rm)r7rr~r<r<r=r/w
s



zPatch.set_linestylecCs,t|
<01>
|_
|<00>|j<03>

|<00>|j<05>

d
|_dS)zh
        Set whether to fill the patch.

        Parameters
        ----------
        b : bool
        TN)<07>boolr(rtr`rrr_rm)r7<00>
br<r<r=r.<00>
s



zPatch.set_fillc


Cs|jS)
zreturn whether fill is set)
r()
r7r<r<r=<00>get_fill<6C>
szPatch.get_fillcCs<|
<01><00>}
|
|j
kr,td
|
f
d|j
f
<00>
<01>
|
|_d|_dS)z{
        Set the patch capstyle

        Parameters
        ----------
        s : {'butt', 'round', 'projecting'}
        zset_capstyle passed "%s";
zvalid capstyles are %sTN)<05>lower<65>validCap<61>
ValueError<EFBFBD>	_capstylerm)r7<00>
sr<r<r=r3<00>
s






zPatch.set_capstylec


Cs|jS)
zReturn the current capstyle)
r<>)
r7r<r<r=<00>get_capstyle<6C>
szPatch.get_capstylecCs<|
<01><00>}
|
|j
kr,td
|
f
d|j
f
<00>
<01>
|
|_d|_dS)zx
        Set the patch joinstyle

        Parameters
        ----------
        s : {'miter', 'round', 'bevel'}
        zset_joinstyle passed "%s";
zvalid joinstyles are %sTN)r<><00>	validJoinr<6E><00>
_joinstylerm)r7r<>r<r<r=r4<00>
s






zPatch.set_joinstylec


Cs|jS)
zReturn the current joinstyle)
r<>)
r7r<r<r=<00>
get_joinstyle<6C>
szPatch.get_joinstylecCs|
|_d
|_
dS)a<>
        Set the hatching pattern

        *hatch* can be one of::

          /   - diagonal hatching
          \   - back diagonal
          |   - vertical
          -   - horizontal
          +   - crossed
          x   - crossed diagonal
          o   - small circle
          O   - large circle
          .   - dots
          *   - stars

        Letters can be combined, in which case all the specified
        hatchings are done.  If same letter repeats, it increases the
        density of hatching of that pattern.

        Hatching is supported in the PostScript, PDF, SVG and Agg
        backends only.

        Parameters
        ----------
        hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
        TN)rarm)r7r9r<r<r=r2<00>
s
zPatch.set_hatchc


Cs|jS)
z#Return the current hatching pattern)
ra)
r7r<r<r=<00>	get_hatch<63>
szPatch.get_hatchccs`
|
<01>d
|<00>
<01><00>
|
<01><02>}|j|jdd<03>
|j}|jddkr@d}|<02>|<03>

|<02>|j|j	<09>
|<02>
|j<0B>

|<02>|j
<0A>

|<02>|j<0F>

|<00>|<02>

|<02>|j<12>

|<02>|<00><14><00>

|<02>|j<16>

|jr<>|<02>|j<17>

y|<02>|j<1A>

Wn"tk
r<EFBFBD>


tjddd<08>
YnX|<00><1E>d	k	<09>
r|j|<00><1E><00>
|<00> <20><00>
r4dd
l!m"}
||<00> <20>|
<01>}
t#<23>$|
j%|<02>V
|<02>&<26>
|
<01>'d
<01>

d|_(d	S)ac

        ``draw()`` helper factored out for sharing with `FancyArrowPatch`.

        Yields a callable ``dp`` such that calling ``dp(*args, **kwargs)`` is
        equivalent to calling ``renderer1.draw_path(gc, *args, **kwargs)``
        where ``renderer1`` and ``gc`` have been suitably set from ``renderer``
        and the artist's properties.
        <20>patchT)
ZisRGBArCr
z3.1zoYour backend does not support setting the hatch color; such backends will become unsupported in Matplotlib 3.3.)
<01>messageN)
<01>PathEffectRendererF))Z
open_groupZget_gidZnew_gcZset_foregroundr]r-r0Z
set_dashesr{r|r3r<>r4r<>r1rhZ_set_gc_clipZset_url<72>_urlZset_snapZget_snaprxrprar2rqr'<00>AttributeErrorr<00>warn_deprecatedZget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsr<73><00>	functools<6C>partial<61>	draw_pathZrestoreZclose_grouprm)r7<00>renderer<65>gcrr<>r<r<r=<00>_bind_draw_path_function<6F>
s>























zPatch._bind_draw_path_functionc
Cs~|<00><00>sd
St
j|dd<03><02>Z
|<00>|
<01>
<01>D}|<00><04>}|<00><05>}|<04>|<03>
}|<04><07>}||||jdr`|jnd
<01>
Wd
QRXWd
QRXd
S)z0Draw the :class:`Patch` to the given *renderer*.Nr
)
r{rC)	<09>get_visibler<00>_setattr_cmr<6D>r?r>Ztransform_path_non_affineZ
get_affiner^)r7r<>r<>rAZ	transformZtpath<74>affiner<r<r=<00>draw3s







z
Patch.drawc

Cstd
<01>
<01>
dS)z/
        Return the path of this patch
        zDerived must overrideN)
<01>NotImplementedError)
r7r<r<r=r?FszPatch.get_pathcCs|<00><00><00>
|<00><02><00>
S)
N)r?rer>)r7r<>r<r<r=<00>get_window_extentLs
zPatch.get_window_extentcCs$|<00>|
d
<00>
}|<00>
|
d<00>
}||fS)z:
        Convert x and y units for a tuple (x, y)
        r
r)<02>convert_xunits<74>convert_yunits)r7<00>xyrKrLr<r<r=<00>_convert_xy_unitsOs

zPatch._convert_xy_units)
NNNNNNNTNN)
N)
N)
N)
N)4<>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__<5F>zorderr<72>r<>ror#rBrIrZrJr[r\rer>rcrfrirErjrFrlr1rrr*rtr+r)rxr0r/r.r<><00>propertyr:r3r<>r4r<>r2r<><00>
contextlib<EFBFBD>contextmanagerr<72>r<00>allow_rasterizationr<6E>r?r<>r<>r<r<r<r=rsj













.



"

;
r)
<0A>	Rectangle<6C>Circle<6C>RegularPolygon<6F>Polygon<6F>Wedge<67>Arrow<6F>
FancyArrow<EFBFBD>YAArrow<6F>
CirclePolygon<6F>Ellipse<73>Arc<72>FancyBboxPatchrc@sleZ
dZd
d<02>Zejddd<05>
<01>
Zdd<07>Zdd	<09>Zd
d<0B>Z	dd
<0A>Z
dd<0F>Zdd<11>Zdd<13>Z
dd<15>Zdd<17>ZdS)<19>Shadowc

Csd
t|j
<01>
S)Nz
Shadow(%s))<02>strr<72>)
r7r<r<r=<00>__str__cs
zShadow.__str__NcKs:t<00>
|<00>

|
|_||_|||_|_t<06><07>|_|<00>	<09>
d
S)a

        Create a shadow of the given *patch* offset by *ox*, *oy*.
        *props*, if not *None*, is a patch property update dictionary.
        If *None*, the shadow will have have the same color as the face,
        but darkened.

        kwargs are
        %(Patch)s
        N)
rr#r<><00>props<70>_ox<6F>_oyr	<00>Affine2D<32>_shadow_transform<72>_update)r7r<><00>ox<6F>oyr<79>r;r<r<r=r#fs






zShadow.__init__c
Csz|<00>|j
<01>

|<00>t<03>|j
jtj<00><02>

|jdk	r>|<00>|j<07>

n8d
t<03>	t
<EFBFBD>|j
<01><0C><00>
<01>
}
|<00>
|
<01>

|<00>|
<01>

|<00>d<02>

dS)Ng333333<33>?g<00>?)r\r<>Z
set_zorderrSZ	nextafterr<72><00>infr<66>r6<00>asarrayrZto_rgbrjr+r*rx)r7r8r<r<r=r<>xs







zShadow._updatecCs.|
<01>|j
<01>
}|
<01>|j<02>
}|j<03><04><00>||<03>
dS)
N)<06>points_to_pixelsr<73>r<>r<><00>clear<61>	translate)r7r<>r<>r<>r<r<r=<00>_update_transform<72>s


zShadow._update_transformc


Cs|jS)
N)
r<>)
r7r<r<r=<00>_get_ox<6F>s
zShadow._get_oxcCs
|
|_dS)
N)
r<>)r7r<>r<r<r=<00>_set_ox<6F>s
zShadow._set_oxc


Cs|jS)
N)
r<>)
r7r<r<r=<00>_get_oy<6F>s
zShadow._get_oycCs
|
|_dS)
N)
r<>)r7r<>r<r<r=<00>_set_oy<6F>s
zShadow._set_oyc

Cs
|j<00>
<01>S)
N)r<>r?)
r7r<r<r=r?<00>s
zShadow.get_pathc

Cs|j<00>
<01>|jS)
N)r<>rfr<>)
r7r<r<r=rf<00>s
zShadow.get_patch_transformcCs|<00>|
<01>

t
<01>||
<01>
dS)
N)r<>rr<>)r7r<>r<r<r=r<><00>s


zShadow.draw)
N)r<>r<>r<>r<>r<00>dedent_interpdr#r<>r<>r<>r<>r<>r<>r?rfr<>r<r<r<r=r<>bs

r<>c@s<>eZ
dZd
Zdd<03>Zejd,dd<06>
<01>
Zdd<08>Zd	d
<EFBFBD>Z	dd<0C>Z
d
d<0E>Zdd<10>Zdd<12>Z
dd<14>Zdd<16>Zdd<18>Zdd<1A>Zdd<1C>Zdd<1E>Zdd <20>Zd!d"<22>Zd#d$<24>Zd%d&<26>Zd'd(<28>Zd)d*<2A>Zeee<15>Zd+S)-r<>zu
    A rectangle with lower left at *xy* = (*x*, *y*) with
    specified *width*, *height* and rotation *angle*.
    c
Cs$|j|j
|j|j|jf}
d
}||
S)Nz5Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g))<05>_x0<78>_y0<79>_width<74>_height<68>angle)r7<00>pars<72>fmtr<r<r=r<><00>s


zRectangle.__str__<5F>cKsbtj
|f
|<05>

|
d
|_|
d|_||_||_|j|j|_|j|j|_t|<04>
|_	t
<EFBFBD><0B>|_dS)a<>

        Parameters
        ----------
        xy : (float, float)
            The bottom and left rectangle coordinates
        width : float
            Rectangle width
        height : float
            Rectangle height
        angle : float, optional
          rotation in degrees anti-clockwise about *xy* (default is 0.0)
        fill : bool, optional
            Whether to fill the rectangle (default is ``True``)

        Notes
        -----
        Valid kwargs are:
        %(Patch)s
        r
rN)
rr#r<>r<>r<>r<><00>_x1<78>_y1rvr<>r	rg<00>_rect_transform)r7r<><00>width<74>heightr<74>r;r<r<r=r#<00>s





zRectangle.__init__c

Cst<00>
<01>S)
z7
        Return the vertices of the rectangle.
        )r<00>unit_rectangle)
r7r<r<r=r?<00>szRectangle.get_pathc
CsX|<00><00>\}
}}}t
j<02>|
|||<04>}t
<01><04>}|<06>|
||j<06>
t
<01>|<05>
|_|j|7_d
S)a
NOTE: This cannot be called until after this has been added
                 to an Axes, otherwise unit conversion will fail. This
                 makes it very important to call the accessor method and
                 not directly access the transformation member variable.
        N)	<09>_convert_unitsr	<00>Bbox<6F>from_extentsr<73>Zrotate_deg_aroundr<64><00>BboxTransformTor<6F>)r7<00>x0<78>y0<79>x1<78>y1<79>bboxZ	rot_transr<r<r=<00>_update_patch_transform<72>s




z!Rectangle._update_patch_transformc

Cs|j|j
|_dS)
N)r<>r<>r<>)
r7r<r<r=<00>
_update_x1<EFBFBD>s
zRectangle._update_x1c

Cs|j|j
|_dS)
N)r<>r<>r<>)
r7r<r<r=<00>
_update_y1<EFBFBD>s
zRectangle._update_y1c
Cs<|<00>|j
<01>
}
|<00>|j<03>
}|<00>|j<04>
}|<00>|j<05>
}|
|||fS)
z2
        Convert bounds of the rectangle.
        )r<>r<>r<>r<>r<>r<>)r7r<>r<>r<>r<>r<r<r=r<><00>s




zRectangle._convert_unitsc

Cs|<00><00>
|j
S)
N)r<>r<>)
r7r<r<r=rf<00>s

zRectangle.get_patch_transformc


Cs|jS)
z'Return the left coord of the rectangle.)
r<>)
r7r<r<r=<00>get_x<5F>szRectangle.get_xc


Cs|jS)
z)Return the bottom coord of the rectangle.)
r<>)
r7r<r<r=<00>get_y<5F>szRectangle.get_yc

Cs|j|j
fS)
z3Return the left and bottom coords of the rectangle.)r<>r<>)
r7r<r<r=<00>get_xy
szRectangle.get_xyc


Cs|jS)
z"Return the width of the rectangle.)
r<>)
r7r<r<r=<00>	get_widthszRectangle.get_widthc


Cs|jS)
z#Return the height of the rectangle.)
r<>)
r7r<r<r=<00>
get_height	szRectangle.get_heightcCs|
|_|<00>
<01>
d
|_dS)z$Set the left coord of the rectangle.TN)r<>r<>rm)r7rKr<r<r=<00>set_x
s

zRectangle.set_xcCs|
|_|<00>
<01>
d
|_dS)z&Set the bottom coord of the rectangle.TN)r<>r<>rm)r7rLr<r<r=<00>set_ys

zRectangle.set_ycCs&|
\|_|_
|<00><02>
|<00><03>
d
|_dS)z<>
        Set the left and bottom coords of the rectangle.

        Parameters
        ----------
        xy : (float, float)
        TN)r<>r<>r<>r<>rm)r7r<>r<r<r=<00>set_xys


zRectangle.set_xycCs|
|_|<00>
<01>
d
|_dS)zSet the width of the rectangle.TN)r<>r<>rm)r7r}r<r<r=<00>	set_width&s

zRectangle.set_widthcCs|
|_|<00>
<01>
d
|_dS)z Set the height of the rectangle.TN)r<>r<>rm)r7<00>
hr<r<r=<00>
set_height,s

zRectangle.set_heightc
Gs\t|
<01>
d
kr|
d\}}}}n|
\}}}}||_
||_||_||_|<00><05>
|<00><06>
d|_dS)zj
        Set the bounds of the rectangle: l,b,w,h

        ACCEPTS: (left, bottom, width, height)
        rr
TN)r5r<>r<>r<>r<>r<>r<>rm)r7<00>args<67>
lr<6C>r}r<>r<r<r=<00>
set_bounds2s







zRectangle.set_boundsc
Cs"|<00><00>\}
}}}t
j<02>|
|||<04>S)
N)r<>r	r<>r<>)r7r<>r<>r<>r<>r<r<r=<00>get_bboxDs

zRectangle.get_bboxN)
r<>)r<>r<>r<>r<>r<>rr<>r#r?r<>r<>r<>r<>rfr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<r<r<r=r<><00>s.
$


r<>c@s<>eZ
dZd
Zdd<03>Zejddd<07>
<01>
Zdd	<09>Ze	d
d<0B><00>
Z
e
jdd<0B><00>
Z
e	d
d<0E><00>
Zejdd<0E><00>
Ze	dd<11><00>
Z
e
jdd<11><00>
Z
e	dd<14><00>
Zejdd<14><00>
Zdd<17>Zdd<19>ZdS)r<>z"
    A regular polygon patch.
    c
Cs(d
}
|
|jd|jd|j
|j|jfS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)r
r)<04>_xy<78>_numVerticesrH<00>_orientation)r7r<>r<r<r=r<>Os


zRegularPolygon.__str__<5F>r
cKsH|
|_||_
||_||_t<04>|<02>
|_t<07><08>|_	|<00>
<EFBFBD>
tj|f
|<05>

d
S)af

        Constructor arguments:

        *xy*
          A length 2 tuple (*x*, *y*) of the center.

        *numVertices*
          the number of vertices.

        *radius*
          The distance from the center to each of the vertices.

        *orientation*
          rotates the polygon (in radians).

        Valid kwargs are:
        %(Patch)s
        N)
r<>r<>r<>rHrZunit_regular_polygon<6F>_pathr	r<><00>_poly_transformr<6D>rr#)r7r<><00>numVerticesrG<00>orientationr;r<r<r=r#Ts






zRegularPolygon.__init__c

Cs&|j<00>
<01><00>|j<03>
<01>|j<05>
j|j<07>
dS)
N)r<>r<><00>scalerG<00>rotater<65>r<>r<>)
r7r<r<r=r<>ss




z RegularPolygon._update_transformc


Cs|jS)
N)
r<>)
r7r<r<r=r<>yszRegularPolygon.xycCs|
|_|<00>
<01>
dS)
N)r<>r<>)r7r<>r<r<r=r<>}s
c


Cs|jS)
N)
r<>)
r7r<r<r=r<><00>szRegularPolygon.orientationcCs|
|_|<00>
<01>
dS)
N)r<>r<>)r7r<>r<r<r=r<><00>s
c


Cs|jS)
N)
rH)
r7r<r<r=rG<00>szRegularPolygon.radiuscCs|
|_|<00>
<01>
dS)
N)rHr<>)r7rGr<r<r=rG<00>s
c


Cs|jS)
N)
r<>)
r7r<r<r=<00>numvertices<65>szRegularPolygon.numverticescCs
|
|_dS)
N)
r<>)r7r<>r<r<r=r
<00>sc


Cs|jS)
N)
r<>)
r7r<r<r=r?<00>s
zRegularPolygon.get_pathc

Cs|<00><00>
|j
S)
N)r<>r<>)
r7r<r<r=rf<00>s

z"RegularPolygon.get_patch_transformN)r<>r
)r<>r<>r<>r<>r<>rr<>r#r<>r<>r<><00>setterr<72>rGr
r?rfr<r<r<r=r<>Ks

r<>c@s2eZ
dZd
ZdZdd<04>Zejdd<06><00>
Zdd<08>Z	d	S)
<EFBFBD>	PathPatchz)
    A general polycurve path patch.
    Tc
Cs&d
}
|
t|j
j<02>
f
t|j
jd<00>
<01>S)NzPathPatch%d((%g, %g) ...)r
)r5r<>rR<00>tuple)r7r<>r<r<r=r<><00>s

zPathPatch.__str__cKstj
|f
|<02>

|
|_d
S)zp
        *path* is a :class:`matplotlib.path.Path` object.

        Valid kwargs are:
        %(Patch)s
        N)rr#r<>)r7rAr;r<r<r=r#<00>s
zPathPatch.__init__c


Cs|jS)
N)
r<>)
r7r<r<r=r?<00>s
zPathPatch.get_pathN)
r<EFBFBD>r<>r<>r<>ror<>rr<>r#r?r<r<r<r=r
<00>s

r
c@sfeZ
dZd
Zdd<03>Zejddd<06>
<01>
Zdd<08>Zd	d
<EFBFBD>Z	dd<0C>Z
d
d<0E>Zdd<10>ZeZ
eZeeedd<12>ZdS)r<>z"
    A general polygon patch.
    c
Cs&d
}
|
t|j
j<02>
f
t|j
jd<00>
<01>S)NzPolygon%d((%g, %g) ...)r
)r5r<>rRr
)r7r<>r<r<r=r<><00>s

zPolygon.__str__TcKs"tj
|f
|<03>

||_|<00>|
<01>

d
S)z<>
        *xy* is a numpy array with shape Nx2.

        If *closed* is *True*, the polygon will be closed so the
        starting and ending points are the same.

        Valid kwargs are:
        %(Patch)s
        N)rr#<00>_closedr<64>)r7r<><00>closedr;r<r<r=r#<00>s

zPolygon.__init__c


Cs|jS)
z<>
        Get the path of the polygon

        Returns
        -------
        path : Path
           The :class:`~matplotlib.path.Path` object for
           the polygon
        )
r<>)
r7r<r<r=r?<00>s
zPolygon.get_pathc


Cs|jS)
z<>
        Returns if the polygon is closed

        Returns
        -------
        closed : bool
            If the path is closed
        )
r
)
r7r<r<r=<00>
get_closed<EFBFBD>s	zPolygon.get_closedcCs4|jt
|
<01>
krd
St
|
<01>
|_|<00>|<00><03><00>

d|_d
S)z<>
        Set if the polygon is closed

        Parameters
        ----------
        closed : bool
           True if the polygon is closed
        NT)r
rr<>r<>rm)r7r
r<r<r=<00>
set_closed<EFBFBD>s
	




zPolygon.set_closedc


Cs|jj
S)
z<>
        Get the vertices of the path.

        Returns
        -------
        vertices : (N, 2) numpy array
            The coordinates of the vertices.
        )r<>rR)
r7r<r<r=r<><00>s	zPolygon.get_xycCs<>t<00>
|
<01>
}
|jrBt|
<01>
rn|
d
|
dk<03><04>rnt<00>|
|
d
g
g<02>
}
n,t|
<01>
dkrn|
d
|
dk<02><06>rn|
dd<02>}
t|
|jd<05>|_d|_	dS)z<>
        Set the vertices of the polygon.

        Parameters
        ----------
        xy : (N, 2) array-like
            The coordinates of the vertices.
        r
<00><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N)
r
T)
rSr<>r
r5rX<00>concatenate<74>allrr<>rm)r7r<>r<r<r=r<>s	



 


zPolygon.set_xyz/The vertices of the path as (N, 2) numpy array.)
<01>docN)
T)r<>r<>r<>r<>r<>rr<>r#r?r
r
r<>r<><00>_get_xyZ_set_xyr<79>r<>r<r<r<r=r<><00>s




r<>c@s`eZ
dZd
Zdd<03>Zejddd<06>
<01>
Zdd<08>Zd	d
<EFBFBD>Z	dd<0C>Z
d
d<0E>Zdd<10>Zdd<12>Z
dd<14>ZdS)r<>z
    Wedge shaped patch.
    c
Cs0|jd
|jd|j
|j|j|jf}
d}||
S)Nr
rz<Wedge(center=(%g, %g), r=%g, theta1=%g, theta2=%g, width=%s))<05>center<65>
r<>theta1<61>theta2r<32>)r7r<>r<>r<r<r=r<>"s



z
Wedge.__str__NcKsFtj
|f
|<06>

|
|_|||_|_|||_|_t<07><08>|_	|<00>
<EFBFBD>
d
S)a#

        A wedge centered at *x*, *y* center with radius *r* that
        sweeps *theta1* to *theta2* (in degrees).  If *width* is given,
        then a partial wedge is drawn from inner radius *r* - *width*
        to outer radius *r*.

        Valid kwargs are:

        %(Patch)s
        N)rr#r
r
r<>r
r
r	rg<00>_patch_transform<72>_recompute_path)r7r
r
r
r
r<>r;r<r<r=r#(s





zWedge.__init__c
	Cs&
t|j
|jd
<00>
dk
r(d\}
}tj}n|j|j
}
}tj}t<03>|
|<02>}|jdk	r<>|j}|jddd<04>|j	|j|j	}t
<EFBFBD>|||ddd<00>fdg<04>
}t
<EFBFBD>|j
|j
|tjg<04>
}||t|j
<0A>
<n<t
<EFBFBD>|jd|jddd<00>fdgg<02>
}t
<EFBFBD>|j
||tjgg<02>
}||j	9}|t
<EFBFBD>|j<11>
7}t||<08>|_dS)Nih
g<11>-<2D><><EFBFBD>q=)r
ih
r
r
)r
r
)<13>absr
r
rrU<00>LINETO<54>arcr<63>rRr
rSZvstackZhstackrQ<00>	CLOSEPOLYr5r<>r
r<>)	r7r
r
<00>	connectorr
Zv1Zv2<76>
vrur<r<r=r
;s"




"


$



zWedge._recompute_pathcCsd|_|
|_
d
|_dS)NT)r<>r
rm)r7r
r<r<r=<00>
set_centerYs


zWedge.set_centercCsd|_|
|_
d
|_dS)NT)r<>r
rm)r7rGr<r<r=<00>
set_radius^s


zWedge.set_radiuscCsd|_|
|_
d
|_dS)NT)r<>r
rm)r7r
r<r<r=<00>
set_theta1cs


zWedge.set_theta1cCsd|_|
|_
d
|_dS)NT)r<>r
rm)r7r
r<r<r=<00>
set_theta2hs


zWedge.set_theta2cCsd|_|
|_
d
|_dS)NT)r<>r<>rm)r7r<>r<r<r=r<>ms


zWedge.set_widthc

Cs|jdkr|<00>
<01>
|jS)
N)r<>r
)
r7r<r<r=r?rs



zWedge.get_path)
N)r<>r<>r<>r<>r<>rr<>r#r
r
r
r
r
r<>r?r<r<r<r=r<>s

r<>c
@steZ
dZd
Zdd<03>Zeddgddgddgddgd	dgdd
gddgddggdd<0C>Zejdd
d<0E>
<01>
Z	dd<10>Z
dd<12>ZdS)r<>z
    An arrow patch.
    c


Csd
S)NzArrow()r<)
r7r<r<r=r<>}s
z
Arrow.__str__gg<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>g<EFBFBD><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?g333333ӿ<33><00>?g333333<33>?T)
r
cKs<>tj
|f
|<06>

t<02>||<04>}|d
kr4||}||}	nd\}}	t<04><05><00>||<05>}
tj<05>||	|	|dd<03>}t<04><05><00>|
|<02>}|
||}
|
<0A>	<09>|_
dS)a<>
        Draws an arrow from (*x*, *y*) to (*x* + *dx*, *y* + *dy*).
        The width of the arrow is scaled by *width*.

        Parameters
        ----------
        x : scalar
            x coordinate of the arrow tail
        y : scalar
            y coordinate of the arrow tail
        dx : scalar
            Arrow length in the x direction
        dy : scalar
            Arrow length in the y direction
        width : scalar, optional (default: 1)
            Scale factor for the width of the arrow. With a default value of
            1, the tail width is 0.2 and head width is 0.6.
        **kwargs
            Keyword arguments control the :class:`~matplotlib.patches.Patch`
            properties:

            %(Patch)s

        See Also
        --------
        :class:`FancyArrow` :
            Patch that allows independent control of the head and tail
            properties
        r
)r
rgN)rr#rS<00>hypotr	r<>r<>Zfrom_valuesr<73><00>frozenr
)r7rKrL<00>dx<64>dyr<79>r;<00>
L<>cx<63>sxZtrans1Ztrans2Ztrans3r@r<r<r=r#<00>s







zArrow.__init__c


Cs|jS)
N)
r<>)
r7r<r<r=r?<00>s
zArrow.get_pathc


Cs|jS)
N)
r
)
r7r<r<r=rf<00>s
zArrow.get_patch_transformN)
r
)r<>r<>r<>r<>r<>rr<>rr<>r#r?rfr<r<r<r=r<>ys





.r<>cs4eZ
dZd
ZdZdd<04>Zejd<0C>f
d
d<0B>	<09>
Z<08>Z	S)
r<>zP
    Like Arrow, but lets you set head width and head height independently.
    Tc


Csd
S)NzFancyArrow()r<)
r7r<r<r=r<><00>s
zFancyArrow.__str__<5F><5F><EFBFBD><EFBFBD><EFBFBD>MbP?FN<46>fullr
cs<>
|d
krd|}|d
kr d|}t<00>
||<04>}
|r6|
}n|
|}|sTt<00>ddg<02>
}<0F>
n4|||
|f\}}}}t<00>ddg||dg|d||dg||dg|dgg<05>
}|s<>||dg7}|r<>||ddg7}|	dkr<>|}nR|dd	g}|	d
kr<>|}n8|	dk<02>
r*t<00>|d
d	<09>|dd
d	<09>g<02>
}ntd
|	<00>
<01>
|
dk<03>
rR||
}||
}nd\}}||g||gg}t<00>||<19>|
|||f}t<07>j|f
ddi
|<0C><02>

d
S)a<>
        Constructor arguments
          *width*: float (default: 0.001)
            width of full arrow tail

          *length_includes_head*: bool (default: False)
            True if head is to be counted in calculating the length.

          *head_width*: float or None (default: 3*width)
            total width of the full arrow head

          *head_length*: float or None (default: 1.5 * head_width)
            length of arrow head

          *shape*: ['full', 'left', 'right'] (default: 'full')
            draw the left-half, right-half, or full arrow

          *overhang*: float (default: 0)
            fraction that the arrow is swept back (0 overhang means
            triangular shape). Can be negative or greater than one.

          *head_starts_at_zero*: bool (default: False)
            if True, the head starts being drawn at coordinate 0
            instead of ending at coordinate 0.

        Other valid kwargs (inherited from :class:`Patch`) are:
        %(Patch)s

        NrCg<00>?r
r	
gr<00>leftr
<00>rightr'
<00><><EFBFBD><EFBFBD><EFBFBD>zGot unknown shape: %s)r
rr
T)	rSr
<00>empty<74>arrayr

r<><00>dot<6F>superr#)r7rKrLr!
r"
r<>Zlength_includes_head<61>
head_width<EFBFBD>head_length<74>shapeZoverhangZhead_starts_at_zeror;Zdistance<63>lengthZvertsZhwZhlZhsrZleft_half_arrowZcoordsZright_half_arrowr$
r%
<00>
M)
<01>	__class__r<r=r#<00>sJ!


























zFancyArrow.__init__)r&
FNNr'
r
F)
r<EFBFBD>r<>r<>r<>ror<>rr<>r#<00>
__classcell__r<r<)
r4
r=r<><00>s


r<>z3.0<EFBFBD>FancyArrowPatch)
<01>alternativec@s@eZ
dZd
Zdd<03>Zejddd<08>
<01>
Zd	d
<EFBFBD>Zdd<0C>Z	d
d<0E>Z
dS)r<>z<>
    Yet another arrow class.

    This is an arrow that is defined in display space and has a tip at
    *x1*, *y1* and a base at *x2*, *y2*.
    c


Csd
S)Nz	YAArrow()r<)
r7r<r<r=r<>*s
zYAArrow.__str__<5F>皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F>cKs6||_||_
||_||_||_tj|f
|<07>

|
|_d
S)a	
        Constructor arguments:

        *xytip*
          (*x*, *y*) location of arrow tip

        *xybase*
          (*x*, *y*) location the arrow base mid point

        *figure*
          The `Figure` instance (used to get the dpi setting).

        *width*
          The width of the arrow in points

        *frac*
          The fraction of the arrow length occupied by the head

        *headwidth*
          The width of the base of the arrow head in points

        Valid kwargs are:
        %(Patch)s

        N)<08>xytip<69>xybaser<65><00>frac<61>	headwidthrr#<00>figure)r7r?
r;
r<
r<>r=
r>
r;r<r<r=r#-s




zYAArrow.__init__c

Cs<>|j\}
}|j
\}}|j|jjd
d}|j|jjd
d}|<00>|
||||<05>\}}}	}
|
|j||
}||j||}|<00>|
||||<05>\}
}}}|<00>|
||||<06>\}}}}|<00>||	|||
||
|g<08>
}|<00>	||
||||||g<08>
}t
t<0B>||g<02>
dd<04>S)NgR@g@T)
r
)
r;
r<
r<>r?
<00>dpir>
<00>	getpointsr=
r<>r<>rrSZcolumn_stack)r7r<>r<><00>x2<78>y2Zk1Zk2Zxb1Zyb1Zxb2Zyb2ZxmZymZxc1Zyc1Zxc2Zyc2Zxd1Zyd1Zxd2Zyd2<64>xsZysr<r<r=r?Ss









zYAArrow.get_pathc

Cst<00>
<01>S)
N)r	rg)
r7r<r<r=rfis
zYAArrow.get_patch_transformcCs"
tt
|
||||f<05>\}
}}}}||d
kr>||||||fS||
d
kr^||||||fS||||
}d|}d}d|}	|d|d|dd|d}
|	t<02>|	dd||
<00>
d|}||||}|	t<02>|	dd||
<00>
d|}
|
|||}||||
fS)	a


        For line segment defined by (*x1*, *y1*) and (*x2*, *y2*)
        return the points on the line that is perpendicular to the
        line and intersects (*x2*, *y2*) and the distance from (*x2*,
        *y2*) of the returned points is *k*.
        r
g<00><>rr*
g@g<00>?r	
r8
)rVrv<00>math<74>sqrt)r7r<>r<>rB
rC
<00>
k<>
mZpm<70>
ar<61>ruZy3aZx3aZy3bZx3br<r<r=rA
ls






$(
(

zYAArrow.getpointsN)r8
r9
r:
)r<>r<>r<>r<>r<>rr<>r#r?rfrA
r<r<r<r=r<>"s
$r<>c@s(eZ
dZd
Zdd<03>Zejd	dd<07>
<01>
ZdS)
r<EFBFBD>z4
    A polygon-approximation of a circle patch.
    c
Cs$d
}
|
|jd|jd|j
|jfS)Nz1CirclePolygon((%g, %g), radius=%g, resolution=%d)r
r)r<>rHr<>)r7r<>r<r<r=r<><00>s

zCirclePolygon.__str__r<5F><00>cKs tj
||
||fd
di
|<04><02>

dS)a/

        Create a circle at *xy* = (*x*, *y*) with given *radius*.
        This circle is approximated by a regular polygon with
        *resolution* sides.  For a smoother circle drawn with splines,
        see :class:`~matplotlib.patches.Circle`.

        Valid kwargs are:
        %(Patch)s

        r<>r
N)r<>r#)r7r<>rG<00>
resolutionr;r<r<r=r#<00>s




zCirclePolygon.__init__N)r<>rJ
)r<>r<>r<>r<>r<>rr<>r#r<r<r<r=r<><00>s



r<>c@sZeZ
dZd
Zdd<03>Zejddd<06>
<01>
Zdd<08>Zd	d
<EFBFBD>Z	dd<0C>Z
d
d<0E>Zdd<10>Ze
ee<0B>ZdS)r<>z
    A scale-free ellipse.
    c
Cs,|jd
|jd|j
|j|jf}
d}||
S)Nr
rz3Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s))<04>_centerr<72>r<>r<>)r7r<>r<>r<r<r=r<><00>s



zEllipse.__str__r
cKs@tj
|f
|<05>

|
|_|||_|_||_t<06><07>|_t	<09>
<EFBFBD>|_d
S)a<>

        Parameters
        ----------
        xy : (float, float)
            xy coordinates of ellipse centre.
        width : float
            Total length (diameter) of horizontal axis.
        height : float
            Total length (diameter) of vertical axis.
        angle : scalar, optional
            Rotation in degrees anti-clockwise.

        Notes
        -----
        Valid keyword arguments are
        %(Patch)s
        N)rr#rL
r<>r<>r<>rZunit_circler<65>r	rgr
)r7r<>r<>r<>r<>r;r<r<r=r#<00>s



zEllipse.__init__c
Csd|<00>|j
d
<00>
|<00>|j
d<00>
f}
|<00>|j<03>
}|<00>|j<04>
}t<05><06><00>|d|d<00><02>|j	<09>
j
|
<01>|_dS)a
NOTE: This cannot be called until after this has been added
                 to an Axes, otherwise unit conversion will fail. This
                 makes it very important to call the accessor method and
                 not directly access the transformation member variable.
        r
rg<00>?N)r<>rL
r<>r<>r<>r	r<>r<>Z
rotate_degr<EFBFBD>r<>r
)r7r
r<>r<>r<r<r=<00>_recompute_transform<72>s






zEllipse._recompute_transformc


Cs|jS)
z6
        Return the vertices of the rectangle
        )
r<>)
r7r<r<r=r?<00>szEllipse.get_pathc

Cs|<00><00>
|j
S)
N)rM
r
)
r7r<r<r=rf<00>s

zEllipse.get_patch_transformcCs|
|_d
|_
dS)zs
        Set the center of the ellipse.

        Parameters
        ----------
        xy : (float, float)
        TN)rL
rm)r7r<>r<r<r=r
<00>s
zEllipse.set_centerc


Cs|jS)
z2
        Return the center of the ellipse
        )
rL
)
r7r<r<r=<00>
get_center<EFBFBD>szEllipse.get_centerN)
r
)r<>r<>r<>r<>r<>rr<>r#rM
r?rfr
rN
r<>r
r<r<r<r=r<><00>s

r<>c@sBeZ
dZd
Zdd<03>Zejddd<06>
<01>
Zdd<08>Zd	d
<EFBFBD>Z	e
e	e<08>ZdS)
r<>z
    A circle patch.
    c
Cs$|jd
|jd|j
f}
d}||
S)Nr
rzCircle(xy=(%g, %g), radius=%g))r
rG)r7r<>r<>r<r<r=r<><00>s


zCircle.__str__r<5F>cKs&tj
||
|d
|d
f|<03>

||_dS)a6

        Create true circle at center *xy* = (*x*, *y*) with given
        *radius*.  Unlike :class:`~matplotlib.patches.CirclePolygon`
        which is a polygonal approximation, this uses Bezier splines
        and is much closer to a scale-free circle.

        Valid kwargs are:
        %(Patch)s

        r	
N)r<>r#rG)r7r<>rGr;r<r<r=r#
s
zCircle.__init__cCsd
|
|_|_
d|_dS)zl
        Set the radius of the circle

        Parameters
        ----------
        radius : float
        r	
TN)r<>r<>rm)r7rGr<r<r=r
s
zCircle.set_radiusc

Cs
|jd
S)z1
        Return the radius of the circle
        g@)
r<>)
r7r<r<r=<00>
get_radiusszCircle.get_radiusN)
r<>)r<>r<>r<>r<>r<>rr<>r#r
rO
r<>rGr<r<r<r=r<><00>s

r<>c@s6eZ
dZd
Zdd<03>Zejddd<07>
<01>
Zej	dd	<09><00>
Z
d
S)r<>a<>

    An elliptical arc, i.e. a segment of an ellipse.

    Due to internal optimizations, there are certain restrictions on using Arc:

    - The arc cannot be filled.

    - The arc must be used in an :class:`~.axes.Axes` instance---it can not be
      added directly to a `.Figure`---because it is optimized to only render
      the segments that are inside the axes bounding box with high resolution.
    c
Cs4|jd
|jd|j
|j|j|j|jf}
d}||
S)Nr
rzEArc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g))r
r<>r<>r<>r
r
)r7r<>r<>r<r<r=r<>0s


zArc.__str__<5F><00><00>v@c	Ks>|<07>d
d<02>}|rt
d<03>
<01>
tj||
|||f|<07>

||_||_dS)a<>
        Parameters
        ----------
        xy : (float, float)
            The center of the ellipse.

        width : float
            The length of the horizontal axis.

        height : float
            The length of the vertical axis.

        angle : float
            Rotation of the ellipse in degrees (counterclockwise).

        theta1, theta2 : float, optional
            Starting and ending angles of the arc in degrees. These values
            are relative to *angle*, e.g. if *angle* = 45 and *theta1* = 90
            the absolute starting angle is 135.
            Default *theta1* = 0, *theta2* = 360, i.e. a complete ellipse.
            The arc is drawn in the counterclockwise direction.
            Angles greater than or equal to 360, or smaller than 0, are
            represented by an equivalent angle in the range [0, 360), by
            taking the input value mod 360.

        Other Parameters
        ----------------
        **kwargs : `.Patch` properties
            Most `.Patch` properties are supported as keyword arguments,
            with the exception of *fill* and *facecolor* because filling is
            not supported.

        %(Patch)s

        r:FzArc objects can not be filledN)<06>
setdefaultr<EFBFBD>r<>r#r
r
)	r7r<>r<>r<>r<>r
r
r;r:r<r<r=r#7s&


zArc.__init__cst|d
<01>st
d<02>
<01>
|<00><02>
|<00>|j<04>
}|<00>|j<06>
}dd<04>}||j||<00>}||j||<00>}|<00>	<09><00>
||f<02>
\}}d}||kr<>||kr<>t<0B>||<06>|_
t<0E>||
<01>Sdd<07><00><00>f
dd	<09>}t<0B><10>}	t<11>|jj<14>
|<00>	<09><00><15>}
|	<09>|
<EFBFBD>
}	t<17>}x<>t|	jd
d<0B>|	jdd
<EFBFBD><00>D]<5D>\}}
|\}}|
\}}xn|||||<11>D]\\}}t<1A>|<12>
}|d
k<00>
rVdtj|}t<1A>|<14>
}||k<00>
rx|k<00>
r,n
n
|<0B>|<14>

<00>
q,W<00>
qWt|<0B>
|g
}|}t<1A> |<05>
}|	<09>!t<1A>"|<16>
t<1A>#|<16>
f<02>
}|j
}x>|D]6}|<17>rt<0B>||d<0F>|_
t<0E>||
<01>
d}nd}|}<15>
q<>W||_
d
S)a

        Draw the arc to the given *renderer*.

        Notes
        -----
        Ellipses are normally drawn using an approximation that uses
        eight cubic Bezier splines.  The error of this approximation
        is 1.89818e-6, according to this unverified source:

          Lancaster, Don.  *Approximating a Circle or an Ellipse Using
          Four Bezier Cubic Splines.*

          http://www.tinaja.com/glib/ellipse4.pdf

        There is a use case where very large ellipses must be drawn
        with very high accuracy, and it is too expensive to render the
        entire ellipse with enough segments (either splines or line
        segments).  Therefore, in the case where either radius of the
        ellipse is large enough that the error of the spline
        approximation will be visible (greater than one pixel offset
        from the ideal), a different technique is used.

        In that case, only the visible parts of the ellipse are drawn,
        with each visible arc using a fixed number of spline segments
        (8).  The algorithm proceeds as follows:

        1. The points where the ellipse intersects the axes bounding
           box are located.  (This is done be performing an inverse
           transformation on the axes bbox such that it is relative
           to the unit circle -- this makes the intersection
           calculation much easier than doing rotated ellipse
           intersection directly).

           This uses the "line intersecting a circle" algorithm
           from:

               Vince, John.  *Geometry for Computer Graphics: Formulae,
               Examples & Proofs.*  London: Springer-Verlag, 2005.

        2. The angles of each of the intersection points are
           calculated.

        3. Proceeding counterclockwise starting in the positive
           x-direction, each of the visible arc-segments between the
           pairs of vertices are drawn using the Bezier arc
           approximation technique implemented in
           :meth:`matplotlib.path.Path.arc`.
        <20>axesz'Arcs can only be used in Axes instancescSs4t<00>
|<00>
}t<00>|<00>
}t<00>|<00>
}t<00>t<00>|
||<02><02>
S)
N)rS<00>deg2rad<61>cos<6F>sin<69>rad2degZarctan2)<04>thetar<61>rKrLr<r<r=<00>
theta_stretch<63>s






zArc.draw.<locals>.theta_stretchg<68>\!<21><>Acss<>||}||
}||||}||||
}||}||}	|	d
krn|||}
|||}|
|fV
nx|	d
kr<>|d
kr<>d}nd}t<00>
|	<09>
}
xRdD]J}||||||
|}
|||t<00>|<05>
|
|}|
|fV
q<>WdS)Ngg<00><>g<00>?)g<00>?g<00><>)rSrF
r
)r<>r<>r<>r<>r!
r"
Zdr2<72>
DZD2ZdiscrimrKrLZsign_dyZsqrt_discrim<69>signr<r<r=<00>iter_circle_intersect_on_line<6E>s&
















 
z/Arc.draw.<locals>.iter_circle_intersect_on_linec3s<>d
}||kr||}}n
||}}||
kr6||
}}n
|
|}}||8}||8}||7}||7}xT<78>||
||<03>D]B\}	}
||	k
r<>|k
rpn
qp||
k
r<>|k
rpn
qp|	|
fV
qpWdS)Ng<4E><67>&<26>.>r<)r<>r<>r<>r<><00>epsilonZx0eZx1eZy0eZy1erKrL)
r\
r<r=<00>!iter_circle_intersect_on_line_seg<65>s












0
z3Arc.draw.<locals>.iter_circle_intersect_on_line_segNr
rr
r	
<00>FT)$<24>hasattr<74>RuntimeErrorrM
r<>r<>r<>r<>r
r
r><00>transform_pointrr
r<>rr<>r<>r	r<>rS
r<><00>invertedZtransformed<65>set<65>ziprRrSZarccos<6F>pirW
<00>add<64>sortedrT
rJrU
rV
)r7r<>r<>r<>rY
r
r
Z	inv_errorr^
Zbox_pathZbox_path_transformZthetasZp0<70>p1r<31>r<>r<>r<>rKrLrX
Z
last_thetaZ
theta1_radrYZ
path_originalr<)
r\
r=r<>fsX2











(























zArc.drawN)rP
rP
rQ
)r<>r<>r<>r<>r<>rr<>r#rr<>r<>r<r<r<r=r<>$s


-r<>TcCs<>|d
kri}|<02><00>}|<02>
dd<03>}|
<01>|<04>
}|<00>|
<01>
}|j\}}}}	||d8}||d8}||7}|	|7}	t||f||	|d<05>}
|
<EFBFBD>t<07><08><00>

|
<EFBFBD>	d<06>

|
<EFBFBD>
|<02>

|
<EFBFBD>|
<01>

d
S)ad

    This is a debug function to draw a rectangle around the bounding
    box returned by
    :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,
    to test whether the artist is returning the correct bbox.

    *props* is a dict of rectangle props with the additional property
    'pad' that sets the padding around the bbox in points.
    N<>padr8
g@)r<>r<>r<>r:F)<0C>copy<70>popr<70>r<><00>boundsr<73>rbr	rg<00>set_clip_onr6r<>)rr<>r<>r:rj
r<>r<>r<>r}r<>r
r<r<r=<00>bbox_artists&





















ro
rG
c	CsN|j\}}}}t
||f|||d
d<02>}|dk	r6|<08>|<03>

|<08>d
<01>

|<08>|
<01>

dS)z<>
    This is a debug function to draw a rectangle around the bounding
    box returned by
    :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist,
    to test whether the artist is returning the correct bbox.
    F)r<>r<>r<>rr:N)rm
r<>rbrn
r<>)	r<>r<>r8r@r<>r<>r}r<>r
r<r<r=<00>	draw_bbox(s









rp
r	
cs<>d
d<02>t|<00>D<00>
<01>d<03>
dd<05><00>D<00>
<01>
}d|d<03>
dd<05>t|d<00><00>D<00>
<01>
|f<04>f
d	d<02>|d
d<0B>D<00>
|df<02>}t<02>d<0C>
|<03>
d
|
<00>S)zR
    Given the list of list of strings, return a string of REST table format.
    c
Ssg|]}
tdd
<01>|
D<00>
<01>
<01>qS)c
ss|]}
t|
<01>
V
qdS)
N)
r5)rM<00>cellr<r<r=rPAsz+_pprint_table.<locals>.<listcomp>.<genexpr>)
<01>max)rM<00>columnr<r<r=<00>
<listcomp>Asz!_pprint_table.<locals>.<listcomp>z   c
ss|]}
d|
V
qd
S)<02>
=Nr<)rM<00>clr<r<r=rPBsz _pprint_table.<locals>.<genexpr><3E>c
ss|]\}
}|
<01>|<02>
V
qdS)
N)
<01>ljust)rMrq
rv
r<r<r=rPFsr
c
s&g|]}
d<00>d
d<02>t
|
<01><00>D<00>
<01>
<01>qS)z   c
ss|]\}
}|
<01>|<02>
V
qdS)
N)
rx
)rMrq
rv
r<r<r=rPHsz+_pprint_table.<locals>.<listcomp>.<genexpr>)<02>joinre
)rM<00>row)
<01>col_lenr<r=rt
Hs
rN<>

<EFBFBD>
 )re
ry
<00>textwrap<61>indent)<04>tableZleadingspaceZtable_formatstrrr<)
r{
r=<00>
_pprint_table=s








r<>
c
Cs<>d
dl}
dddgg
}xnt
|<00><02><00>
D]^\}}|
<01>|j<04>
}|jrfd<06>tdj|j	t
|j<05>
d<02>|j<05><03>
}nd}|<02>|jd	||g<03>

q"Wt
|<02>
S)
z<EFBFBD>
    A helper function for the _Style class.  Given the dictionary of
    {stylename: styleclass}, return a formatted string listing all the
    styles. Used to update the documentation.
    r
NZClass<73>NameZAttrsz, z{}={}<7D>Nonez``%s``)<0E>inspectrh
<00>items<6D>getfullargspecr#<00>defaultsry
rV<00>formatr<74>r5<00>appendr<64>r<>
)<07>_stylesr<73>
Z_table<6C>name<6D>cls<6C>specZargstrr<r<r=<00>_pprint_stylesPs



$r<>
c

Csd
<01>d<02>
tdjt|<00>
<01><02>
<01>
S)z<>
    A helper function for the _Style class.  Given the dictionary of
    {stylename: styleclass}, return a string rep of the list of keys.
    Used to update the documentation.
    z[{}]<5D>
|z '{}' )r<>
ry
rVrh
)
r<>
r<r<r=<00>_simpleprint_styleshsr<>
c@s<eZ
dZd
Zdd<03>Zedd<05><00>
Zedd<07><00>
Zedd	<09><00>
Zd
S)<0B>_Stylez<65>
    A base class for the Styles. It is meant to be a container class,
    where actual styles are declared as subclass of it, and it
    provides some helper functions.
    cKs<>|
<01>d
d<02><02>
d<03>
}|d<00><02>}y|j|}Wn tk
rL


td|
<00>
<01>
YnXy(dd<07>|dd	<09>D<00>
}d
d<0B>|D<00>
}Wn tk
r<EFBFBD>


td|
<00>
<01>
YnX|<07>|<02>

|f|<07>
S)
zP
        return the instance of the subclass with the given style name.
        r}
rw
<00>
,r
zUnknown style : %sc
Ssg|]}
|
<01>d<00>
<01>qS)
ru
)
rW)rM<00>csr<r<r=rt
<00>sz"_Style.__new__.<locals>.<listcomp>rNc
Ssi|]\}
}t|<02>
|
<01>qSr<)
rv)rMrG
r
r<r<r=<00>
<dictcomp><3E>sz"_Style.__new__.<locals>.<dictcomp>zIncorrect style argument : %s)<07>replacerWr<><00>_style_list<73>KeyErrorr<72>r6)r<>
Z	stylename<6D>kwZ_list<73>_name<6D>_clsZ
_args_pair<EFBFBD>_argsr<r<r=<00>__new__ws










z_Style.__new__c


Cs|jS)
zP
        A class method which returns a dictionary of available styles.
        )
r<>
)
r<>
r<r<r=<00>
get_styles<EFBFBD>sz_Style.get_stylesc

Cs
t|j
<01>
S)
zP
        A class method which returns a string of the available styles.
        )r<>
r<>
)
r<>
r<r<r=<00>
pprint_styles<65>sz_Style.pprint_stylescCs,t||j
<01>std
||j
f<00>
<01>
||j|
<dS)z'
        Register a new style.
        z%s must be a subclass of %sN)<04>
issubclass<EFBFBD>_Baser<65>r<>
)r<>
r<>
<00>styler<r<r=<00>register<65>s


z_Style.registerN)	r<>r<>r<>r<>r<>
<00>classmethodr<64>
r<>
r<>
r<r<r<r=r<>
qs

r<>
)
r<>
c
Cs.|
d
krtj
t||d<02>S|
||p(|
j<03><04><|
S)z=Class decorator that stashes a class in a (style) dictionary.N)
r<>
)r<>r<><00>_register_styler<65>r<>)Z
style_listr<EFBFBD>
r<>
r<r<r=r<>
<00>s


r<>
c@s
eZ
dZd
ZiZGdd<03>de<05>Zee<04>
Gdd<05>de<06><03>
Zee<04>
Gdd<07>de<06><03>
Z	ee<04>
Gdd	<09>d	e<06><03>
Z
ee<04>
Gd
d<0B>de
<EFBFBD><03>
Zee<04>
Gdd
<0A>d
e<06><03>
Zee<04>
Gdd<0F>de<06><03>
Z
ee<04>
Gdd<11>de<06><03>
Zee<04>
Gdd<13>de<06><03>
Zee<04>
Gdd<15>de<0F><03>
Ze<03>
re<11>e<03>
dee<04>
i
ZdS)<18>BoxStylea<65>
    :class:`BoxStyle` is a container class which defines several
    boxstyle classes, which are used for :class:`FancyBboxPatch`.

    A style object can be created as::

           BoxStyle.Round(pad=0.2)

    or::

           BoxStyle("Round", pad=0.2)

    or::

           BoxStyle("Round, pad=0.2")

    Following boxstyle classes are defined.

    %(AvailableBoxstyles)s

    An instance of any boxstyle class is an callable object,
    whose call signature is::

       __call__(self, x0, y0, width, height, mutation_size, aspect_ratio=1.)

    and returns a :class:`Path` instance. *x0*, *y0*, *width* and
    *height* specify the location and size of the box to be
    drawn. *mutation_scale* determines the overall size of the
    mutation (by which I mean the transformation of the rectangle to
    the fancy box).  *mutation_aspect* determines the aspect-ratio of
    the mutation.
    c@s"eZ
dZd
Zdd<03>Zddd<06>
ZdS)	zBoxStyle._Basea_

        :class:`BBoxTransmuterBase` and its derivatives are used to make a
        fancy box around a given rectangle. The :meth:`__call__` method
        returns the :class:`~matplotlib.path.Path` of the fancy box. This
        class is not an artist and actual drawing of the fancy box is done
        by the :class:`FancyBboxPatch` class.
        cCstd
<01>
<01>
dS)a<>

            The transmute method is a very core of the
            :class:`BboxTransmuter` class and must be overridden in the
            subclasses. It receives the location and size of the
            rectangle, and the mutation_size, with which the amount of
            padding and etc. will be scaled. It returns a
            :class:`~matplotlib.path.Path` instance.
            zDerived must overrideN)
r<>)r7r<>r<>r<>r<><00>
mutation_sizer<r<r=<00>	transmute<74>s	zBoxStyle._Base.transmute<74><00>?c
Csz|d
k	rd||||}}|<00>|
||||<05>}|j
|j}}	|d
d
<01>df||d
d
<01>df<t||	<09>S|<00>|
||||<05>Sd
S)aH

            Given the location and size of the box, return the path of
            the box around it.

              - *x0*, *y0*, *width*, *height* : location and size of the box
              - *mutation_size* : a reference scale for the mutation.
              - *aspect_ratio* : aspect-ration for the mutation.
            Nr)r<>
rRrQr)
r7r<>r<>r<>r<>r<>
<00>aspect_ratiorArRrQr<r<r=<00>__call__<5F>s

 

zBoxStyle._Base.__call__N)
r<>
)r<>r<>r<>r<>r<>
r<>
r<r<r<r=r<>
<00>sr<>
cs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zBoxStyle.Squarez&
        A simple square box.
        <20>333333<33>?cs|
|_t
<01><00><02>
d
S)zB
             *pad*
                amount of padding
            N)rj
r.
r#)r7rj
)
r4
r<r=r#s
zBoxStyle.Square.__init__cCs<>||j}|d
||d
|}}|
|||}
}|
|||}}|
|f||f||f|
|f|
|fg}	t
jg
t
jg
dt
jg
}
t
|	|
<EFBFBD>S)Nr	
rC)rj
rrUr
r
)r7r<>r<>r<>r<>r<>
rj
r<>r<>rRrQr<r<r=r<>
s


"

zBoxStyle.Square.transmute)
r<>
)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>Squares	r<>
cs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zBoxStyle.CirclezA simple circle box.<2E>333333<33>?cs|
|_t
<01><00><02>
d
S)z<>
            Parameters
            ----------
            pad : float
                The amount of padding around the original box.
            N)rj
r.
r#)r7rj
)
r4
r<r=r#&s
zBoxStyle.Circle.__init__cCs`||j}|d
||d
|}}|
|||}
}t
<01>|
|d
||d
ft||<04>d
<00>S)Nr	
)rj
rZcirclerr
)r7r<>r<>r<>r<>r<>
rj
r<r<r=r<>
0s





zBoxStyle.Circle.transmute)
r<>
)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=r<>#s

r<EFBFBD>cs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zBoxStyle.LArrowz"
        (left) Arrow Box
        <20>333333<33>?cs|
|_t
<01><00><02>
dS)
N)rj
r.
r#)r7rj
)
r4
r<r=r#>s

zBoxStyle.LArrow.__init__c
Cs
||j}|d
||d
|}}|
|||}
}|
|||}}||d
}	|	d}
|
|d}
|
|
|f||f||f|
|
|f|
|
||
f|
|	||	f|
|
||
f|
|
|f|
|
|fg	}t
jt
jt
jt
jt
jt
jt
jt
jt
jg	}t
||<0C>}
|
S)Ng@g<00>?gffffff<66>?)rj
rrUr
r
)r7r<>r<>r<>r<>r<>
rj
r<>r<>r!
<00>dxx<78>cp<63>comrAr<r<r=r<>
Bs 


 





zBoxStyle.LArrow.transmute)
r<>
)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>LArrow9s
r<>
cs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zBoxStyle.RArrowz#
        (right) Arrow Box
        <20>333333<33>?cst<00><00>
|
<01>

dS)
N)r.
r#)r7rj
)
r4
r<r=r#es
zBoxStyle.RArrow.__init__cCsFtj
<01>||
||||<05>}d
|
||jdd<00>df|jdd<00>df<|S)Nr	
r
)r<>
r<>
r<>
rR)r7r<>r<>r<>r<>r<>
<00>
pr<r<r=r<>
hs



,
zBoxStyle.RArrow.transmute)
r<>
)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>RArrow_sr<>
cs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zBoxStyle.DArrowz$
        (Double) Arrow Box
        <20>333333<33>?cs|
|_t
<01><00><02>
dS)
N)rj
r.
r#)r7rj
)
r4
r<r=r#vs

zBoxStyle.DArrow.__init__c
Cs$
||j}|d
|}|
|||}
}|
|||}}||d}	|	d}
|
|d}
|
|
|f||f|||
f||	|
||	f|||
f||f|
|
|f|
|
||
f|
|	||	f|
|
||
f|
|
|f|
|
|fg}t
jt
jt
jt
jt
jt
jt
jt
jt
jt
jt
jt
jg}t
||<0C>}
|
S)Ng@r	
g<00>?gffffff<66>?)rj
rrUr
r
)r7r<>r<>r<>r<>r<>
rj
r<>r<>r!
r<>
r<>
r<>
rAr<r<r=r<>
zs.
















zBoxStyle.DArrow.transmute)
r<>
)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>DArrownsr<>
cs*eZ
dZd
Zd<08>f
dd<05>	Zdd<07>Z<05>ZS)	zBoxStyle.Roundz+
        A box with round corners.
        <20>333333<33>?Ncs|
|_||_
t<02><00><03>
d
S)z<>
            *pad*
              amount of padding

            *rounding_size*
              rounding radius of corners. *pad* if None
            N)rj
<00>
rounding_sizer.
r#)r7rj
r<>
)
r4
r<r=r#<00>s

zBoxStyle.Round.__init__c
Cs(
||j}|j
r||j
}n|}|d
||d
|}}|
|||}
}|
|||}}	|
||f|||f||f|||f||	|f||	f|||	f|
||	f|
|	f|
|	|f|
||f|
|f|
||f|
||fg}
tjtjtjtjtjtjtjtjtjtjtjtjtjtjg}t|
|<0B>}|S)Ng@)rj
r<>
rrUr
<00>CURVE3r
)
r7r<>r<>r<>r<>r<>
rj
<00>drr<72>r<>r<>
r<>
rAr<r<r=r<>
<00>s:


























zBoxStyle.Round.transmute)r<>
N)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>Round<6E>sr<>
cs*eZ
dZd
Zd<08>f
dd<05>	Zdd<07>Z<05>ZS)	zBoxStyle.Round4z/
        Another box with round edges.
        <20>333333<33>?Ncs|
|_||_
t<02><00><03>
d
S)z<>
            *pad*
              amount of padding

            *rounding_size*
              rounding size of edges. *pad* if None
            N)rj
r<>
r.
r#)r7rj
r<>
)
r4
r<r=r#<00>s

zBoxStyle.Round4.__init__c
Cs\
||j}|j
r||j
}n|d
}|d
|d||d
|d|}}|
|||||}
}|
|||}}	|
|f|
|||f||||f||f||||f|||	|f||	f|||	|f|
||	|f|
|	f|
||	|f|
|||f|
|f|
|fg}
tjtjtjtjtjtjtjtjtjtjtjtjtjtjg}t|
|<0B>}|S)Ng@r	
)rj
r<>
rrUZCURVE4r
)
r7r<>r<>r<>r<>r<>
rj
r<>
r<>r<>r<>
r<>
rAr<r<r=r<>
<00>s,




"
"
"
"







zBoxStyle.Round4.transmute)r<>
N)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>Round4<64>sr<>
cs2eZ
dZd
Zd
<EFBFBD>f
dd<05>	Zdd<07>Zdd	<09>Z<06>ZS)zBoxStyle.Sawtoothz!
        A sawtooth box.
        <20>333333<33>?Ncs|
|_||_
t<02><00><03>
d
S)z<>
            *pad*
              amount of padding

            *tooth_size*
              size of the sawtooth. pad* if None
            N)rj
<00>
tooth_sizer.
r#)r7rj
r<>
)
r4
r<r=r#	s

zBoxStyle.Sawtooth.__init__cCsX||j}|j
dkr$|jd
|}n
|j
|}|d}|d|||d||}}tt<03>|||d<00>
<01>
d}	|||	}
tt<03>|||d<00>
<01>
d}|||}|
|||||}
}|
|||}
}|
f
|
||
d
t<03>|	d<00>
|
|f
<01>}|f
||||||g|	||f
<01>}|
f
|
||
|
||
g|	|
|f
<01>}|f
|||d
t<03>|d<00>
||f
<01>}|
f
|
||
d
t<03>|	d<00>
|
|f
<01>}|f
||||||g|	||f
<01>}|
f
|
||
|
||
g||
|f
<01>}|f
|||d
t<03>|d<00>
||f
<01>}t||<10>t||<12>t||<14>t||<16>|d|dff
<01>}|S)Ng<00>?g@r	
r
)rj
r<>
<00>intrSrZarangere
)r7r<>r<>r<>r<>r<>
rj
r<>
Ztooth_size2Zdsx_nZdsxZdsy_nZdsyr<79>r<>Zbottom_saw_xZbottom_saw_yZright_saw_xZright_saw_yZ	top_saw_xZ	top_saw_yZ
left_saw_xZ
left_saw_y<EFBFBD>saw_verticesr<r<r=<00>_get_sawtooth_vertices%	sV





























z(BoxStyle.Sawtooth._get_sawtooth_verticescCs"|<00>|
||||<05>}t
|d
d<02>}|S)NT)
r
)r<>
r)r7r<>r<>r<>r<>r<>
r<>
rAr<r<r=r<>
o	s




zBoxStyle.Sawtooth.transmute)r<>
N)r<>r<>r<>r<>r#r<>
r<>
r5
r<r<)
r4
r=<00>Sawtooth	sJr<4A>
cs*eZ
dZd
Zd<08>f
dd<05>	Zdd<07>Z<05>ZS)	zBoxStyle.RoundtoothzA rounded tooth box.<2E>333333<33>?Ncst<00><00>
|
|<02>
d
S)z<>
            *pad*
              amount of padding

            *tooth_size*
              size of the sawtooth. pad* if None
            N)r.
r#)r7rj
r<>
)
r4
r<r=r#x	szBoxStyle.Roundtooth.__init__cCsf|<00>|
||||<05>}t
jt
<01>|<06>
|d
g
gd
d<02>}tjg
tjtjgt|<06>
ddtjg
}t||<07>S)Nr
)
Zaxisrr	
)	r<>
rSr

r,
rrUr<>
r5r
)r7r<>r<>r<>r<>r<>
r<>
rQr<r<r=r<>
<00>	s



"


zBoxStyle.Roundtooth.transmute)r<>
N)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>
Roundtoothu	s

r<EFBFBD>
<00>AvailableBoxstylesN)r<>r<>r<>r<>r<>
<00>objectr<74>
r<>
r<>
r<>r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
<00>cleandocr<63>
r<r<r<r=r<>
<00>s0 1


%

1
=
4
a


r<>
)r<>
Z
ListBoxstylesc@s<>eZ
dZd
ZdZdd<04>Zejd,dd	<09>
<01>
Zejd-d
d<0B>
<01>
Z	dd
<0A>Z
dd<0F>Zdd<11>Zdd<13>Z
dd<15>Zdd<17>Zdd<19>Zdd<1B>Zdd<1D>Zdd<1F>Zd d!<21>Zd"d#<23>Zd$d%<25>Zd&d'<27>Zd(d)<29>Zd*d+<2B>ZdS).r<>aW

    A fancy box around a rectangle with lower left at *xy* = (*x*, *y*)
    with specified width and height.

    `.FancyBboxPatch` is similar to `.Rectangle`, but it draws a fancy box
    around the rectangle. The transformation of the rectangle box to the
    fancy box is delegated to the `.BoxTransmuterBase` and its derived classes.
    Tc
Cs$|jj
d
}
|
|j|j|j|jfS)Nz((%g, %g), width=%g, height=%g))r4
r<><00>_x<5F>_yr<79>r<>)r7r<>r<r<r=r<><00>	s

zFancyBboxPatch.__str__rN<><00>?c	Ksntj
|f
|<08>

|
d
|_|
d|_||_||_|dkrN|dkrFtd<05>
<01>
||_n
|<00>|<04>

||_	||_
d|_dS)a
        Parameters
        ----------
        xy : float, float
          The lower left corner of the box.

        width : float
            The width of the box.

        height : float
            The height of the box.

        boxstyle : str or `matplotlib.patches.BoxStyle`
            The style of the fancy box. This can either be a `.BoxStyle`
            instance or a string of the style name and optionally comma
            seprarated attributes (e.g. "Round, pad=0.2"). This string is
            passed to `.BoxStyle` to construct a `.BoxStyle` object. See
            there for a full documentation.

            The following box styles are available:

            %(AvailableBoxstyles)s

        mutation_scale : float, optional, default: 1
            Scaling factor applied to the attributes of the box style
            (e.g. pad or rounding_size).

        mutation_aspect : float, optional
            The height of the rectangle will be squeezed by this value before
            the mutation and the mutated box will be stretched by the inverse
            of it. For example, this allows different horizontal and vertical
            padding.

        Other Parameters
        ----------------
        **kwargs : `.Patch` properties

        %(Patch)s
        r
rZcustomNz7bbox_transmuter argument is needed with custom boxstyleT)rr#r<>
r<>
r<>r<>r<><00>_bbox_transmuter<65>set_boxstyle<6C>_mutation_scale<6C>_mutation_aspectrm)	r7r<>r<>r<><00>boxstyleZbbox_transmuter<65>mutation_scale<6C>mutation_aspectr;r<r<r=r#<00>	s/








zFancyBboxPatch.__init__cKsD|
d
krt<00>
<01>St|
tj<03>s$t|
<01>
r,|
|_nt|
f
|<02>
|_d|_d
S)a
        Set the box style.

        *boxstyle* can be a string with boxstyle name with optional
        comma-separated attributes. Alternatively, the attrs can
        be provided as keywords::

            set_boxstyle("round,pad=0.2")
            set_boxstyle("round", pad=0.2)

        Old attrs simply are forgotten.

        Without argument (or with *boxstyle* = None), it returns
        available box styles.

        The following boxstyles are available:
        %(AvailableBoxstyles)s

        ACCEPTS: %(ListBoxstyles)s
        NT)r<>
r<>
rDr<>
<00>callabler<65>
rm)r7r<>
r<>
r<r<r=r<>
<00>	s


zFancyBboxPatch.set_boxstylecCs|
|_d
|_
dS)zf
        Set the mutation scale.

        Parameters
        ----------
        scale : float
        TN)r<>
rm)r7r<>r<r<r=<00>set_mutation_scale	
s
z!FancyBboxPatch.set_mutation_scalec


Cs|jS)
zReturn the mutation scale.)
r<>
)
r7r<r<r=<00>get_mutation_scale
sz!FancyBboxPatch.get_mutation_scalecCs|
|_d
|_
dS)zz
        Set the aspect ratio of the bbox mutation.

        Parameters
        ----------
        aspect : float
        TN)r<>
rm)r7<00>aspectr<r<r=<00>set_mutation_aspect
s
z"FancyBboxPatch.set_mutation_aspectc


Cs|jS)
z-Return the aspect ratio of the bbox mutation.)
r<>
)
r7r<r<r=<00>get_mutation_aspect#
sz"FancyBboxPatch.get_mutation_aspectc


Cs|jS)
zReturn the boxstyle object.)
r<>
)
r7r<r<r=<00>get_boxstyle'
szFancyBboxPatch.get_boxstylec
Cs*|<00><00>|j
|j|j|j|<00><05>|<00><06><00>}
|
S)
z)Return the mutated path of the rectangle.)r<>
r<>
r<>
r<>r<>r<>
r<>
)r7r<>r<r<r=r?+
s





zFancyBboxPatch.get_pathc


Cs|jS)
z'Return the left coord of the rectangle.)
r<>
)
r7r<r<r=r<>5
szFancyBboxPatch.get_xc


Cs|jS)
z)Return the bottom coord of the rectangle.)
r<>
)
r7r<r<r=r<>9
szFancyBboxPatch.get_yc


Cs|jS)
z"Return the width of the rectangle.)
r<>)
r7r<r<r=r<>=
szFancyBboxPatch.get_widthc


Cs|jS)
z#Return the height of the rectangle.)
r<>)
r7r<r<r=r<>A
szFancyBboxPatch.get_heightcCs|
|_d
|_
dS)zo
        Set the left coord of the rectangle.

        Parameters
        ----------
        x : float
        TN)r<>
rm)r7rKr<r<r=r<>E
s
zFancyBboxPatch.set_xcCs|
|_d
|_
dS)zq
        Set the bottom coord of the rectangle.

        Parameters
        ----------
        y : float
        TN)r<>
rm)r7rLr<r<r=r<>P
s
zFancyBboxPatch.set_ycCs|
|_d
|_
dS)zc
        Set the rectangle width.

        Parameters
        ----------
        w : float
        TN)r<>rm)r7r}r<r<r=r<>[
s
zFancyBboxPatch.set_widthcCs|
|_d
|_
dS)zd
        Set the rectangle height.

        Parameters
        ----------
        h : float
        TN)r<>rm)r7r<>r<r<r=r<>f
s
zFancyBboxPatch.set_heightc
GsLt|
<01>
d
kr|
d\}}}}n|
\}}}}||_
||_||_||_d|_dS)a<>

        Set the bounds of the rectangle.

        Call signatures::

            set_bounds(left, bottom, width, height)
            set_bounds((left, bottom, width, height))

        Parameters
        ----------
        left, bottom : float
            The coordinates of the bottom left corner of the rectangle.
        width, height : float
            The width/height of the rectangle.
        rr
TN)r5r<>
r<>
r<>r<>rm)r7r<>r<>r<>r}r<>r<r<r=r<>q
s





zFancyBboxPatch.set_boundsc

Cstj
<01>|j|j|j|j<06>S)
z$Return the `.Bbox` of the rectangle.)r	r<>Zfrom_boundsr<73>
r<>
r<>r<>)
r7r<r<r=r<><00>
s
zFancyBboxPatch.get_bbox)rNr<4E>
N)
N)r<>r<>r<>r<>ror<>rr<>r#r<>
r<>
r<>
r<>
r<>
r<>
r?r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<r<r<r=r<><00>	s4


>

r<>c@s<>eZ
dZd
ZiZGdd<03>de<05>Zee<04>
Gdd<05>de<06><03>
Zee<04>
Gdd<07>de<06><03>
Z	ee<04>
Gdd	<09>d	e<06><03>
Z
ee<04>
Gd
d<0B>de<06><03>
Zee<04>
Gdd
<0A>d
e<06><03>
Zer<>e
<0A>e<03>
dee<04>
i
ZdS)<10>ConnectionStylea0
    :class:`ConnectionStyle` is a container class which defines
    several connectionstyle classes, which is used to create a path
    between two points. These are mainly used with
    :class:`FancyArrowPatch`.

    A connectionstyle object can be either created as::

           ConnectionStyle.Arc3(rad=0.2)

    or::

           ConnectionStyle("Arc3", rad=0.2)

    or::

           ConnectionStyle("Arc3, rad=0.2")

    The following classes are defined

    %(AvailableConnectorstyles)s


    An instance of any connection style class is an callable object,
    whose call signature is::

        __call__(self, posA, posB,
                 patchA=None, patchB=None,
                 shrinkA=2., shrinkB=2.)

    and it returns a :class:`Path` instance. *posA* and *posB* are
    tuples of x,y coordinates of the two points to be
    connected. *patchA* (or *patchB*) is given, the returned path is
    clipped so that it start (or end) from the boundary of the
    patch. The path is further shrunk by *shrinkA* (or *shrinkB*)
    which is given in points.

    c@s8eZ
dZd
ZGdd<03>d<03>Zdd<05>Zdd<07>Zdd
d<0B>
Zd	S)
zConnectionStyle._Basea<65>

        A base class for connectionstyle classes. The subclass needs
        to implement a *connect* method whose call signature is::

          connect(posA, posB)

        where posA and posB are tuples of x, y coordinates to be
        connected.  The method needs to return a path connecting two
        points. This base class defines a __call__ method, and a few
        helper methods.
        c@seZ
dZd
d<02>ZdS)z!ConnectionStyle._Base.SimpleEventcCs|
\|_|_
dS)
N)rKrL)r7r<>r<r<r=r#<00>
s
z*ConnectionStyle._Base.SimpleEvent.__init__N)r<>r<>r<>r#r<r<r<r=<00>SimpleEvent<6E>
s
r<>
cs<><00>r@<40>f
d
d<02>}yt|
|<04>\}}Wnt
k
r:


|
}YnX|}
<01>
r<><72>
f
dd<04>}yt|
|<07>\}}Wnt
k
rz


|
}YnX|}
|
S)aI

            Clip the path to the boundary of the patchA and patchB.
            The starting point of the path needed to be inside of the
            patchA and the end point inside the patch B. The *contains*
            methods of each patch object is utilized to test if the point
            is inside the path.
            c
stj
<01>|<00>
}
<01><00>|
<01>
d
S)Nr
)r<>
r<>
r<>
rZ)<02>
xy_display<EFBFBD>xy_event)
<01>patchAr<r=<00>insideA<65>
s

z,ConnectionStyle._Base._clip.<locals>.insideAc
stj
<01>|<00>
}
<01><00>|
<01>
d
S)Nr
)r<>
r<>
r<>
rZ)r<>
r<>
)
<01>patchBr<r=<00>insideB<65>
s

z,ConnectionStyle._Base._clip.<locals>.insideB)rr<>)r7rAr<>
r<>
r<>
r(
r)
r<>
r<)r<>
r<>
r=<00>_clip<69>
s	









zConnectionStyle._Base._clipcCs<>|r@t|
j
d
|f
<01><02>}yt|
|<04>\}}
Wntk
r>


YnX|r<>t|
j
d|f
<01><02>}yt|
|<06>\}
}Wntk
r~


YnX|
S)z]
            Shrink the path by fixed size (in points) with shrinkA and shrinkB.
            r
r
)rrRrr<>)r7rA<00>shrinkA<6B>shrinkBr<42>
r(
r<>
r)
r<r<r=<00>_shrink<6E>
s











zConnectionStyle._Base._shrink<6E>@Nc
Cs,|<00>|
|<02>}|<00>
|||<06>}|<00>|||<04>}	|	S)
z<>
            Calls the *connect* method to create a path between *posA*
             and *posB*. The path is clipped and shrunken.
            )<03>connectr<74>
r<>
)
r7<00>posA<73>posBr<42>
r<>
r<>
r<>
rAZclipped_pathZshrunk_pathr<r<r=r<>

s
zConnectionStyle._Base.__call__)r<>
r<>
NN)r<>r<>r<>r<>r<>
r<>
r<>
r<>
r<r<r<r=r<>
<00>
s
#r<>
c@s"eZ
dZd
Zddd<04>
Zdd<06>ZdS)	zConnectionStyle.Arc3aM

        Creates a simple quadratic Bezier curve between two
        points. The curve is created so that the middle control point
        (C1) is located at the same distance from the start (C0) and
        end points(C2) and the distance of the C1 to the line
        connecting C0-C2 is *rad* times the distance of C0-C2.
        <20>cCs
|
|_d
S)zE
            *rad*
              curvature of the curve.
            N)
<01>rad)r7r<>
r<r<r=r#szConnectionStyle.Arc3.__init__cCs<>|
\}}|\}}||d
||d
}}||||}	}
|j}|||
|||	}}
||f||
f||fg}t
jt
jt
jg}t
||<0F>S)Ng@)r<>
rrUr<>
)r7r<>
r<>
r<>r<>rB
rC
Zx12Zy12r!
r"
<00>
fr$
<00>cyrRrQr<r<r=r<>
 s









zConnectionStyle.Arc3.connectN)
r<>
)r<>r<>r<>r<>r#r<>
r<r<r<r=<00>Arc3s
r<>
c@s"eZ
dZd
Zd	dd<05>
Zdd<07>ZdS)
zConnectionStyle.Angle3a


        Creates a simple quadratic Bezier curve between two
        points. The middle control points is placed at the
        intersecting point of two lines which cross the start and
        end point, and have a slope of angleA and angleB, respectively.
        <20>Zr
cCs|
|_||_
d
S)z<>
            *angleA*
              starting angle of the path

            *angleB*
              ending angle of the path
            N)<02>angleA<65>angleB)r7r<>
r<>
r<r<r=r#<s	
zConnectionStyle.Angle3.__init__c	Cs<>|
\}}|\}}t<00>
t<00>|j<03>
<01>
}t<00>t<00>|j<03>
<01>
}t<00>
t<00>|j<05>
<01>
}	t<00>t<00>|j<05>
<01>
}
t|||||||	|
<EFBFBD>\}}||f||f||fg}
tjtj	tj	g}t|
|<0E>S)
N)
rE
rU
<00>radiansr<73>
rV
r<>
r
rrUr<>
)r7r<>
r<>
r<>r<>rB
rC
<00>cosA<73>sinA<6E>cosB<73>sinBr$
r<>
rRrQr<r<r=r<>
Hs







zConnectionStyle.Angle3.connectN)r<>
r
)r<>r<>r<>r<>r#r<>
r<r<r<r=<00>Angle33s
r<>
c@s"eZ
dZd
Zd
dd<06>
Zdd<08>Zd	S)zConnectionStyle.AngleaX

        Creates a piecewise continuous quadratic Bezier path between
        two points. The path has a one passing-through point placed at
        the intersecting point of two lines which cross the start
        and end point, and have a slope of angleA and angleB, respectively.
        The connecting edges are rounded with *rad*.
        r<>
r
<00>cCs|
|_||_
||_d
S)z<>
            *angleA*
              starting angle of the path

            *angleB*
              ending angle of the path

            *rad*
              rounding radius of the edge
            N)r<>
r<>
r<>
)r7r<>
r<>
r<>
r<r<r=r#cs
zConnectionStyle.Angle.__init__c	Csp
|
\}}|\}}t<00>
t<00>|j<03>
<01>
}t<00>t<00>|j<03>
<01>
}t<00>
t<00>|j<05>
<01>
}	t<00>t<00>|j<05>
<01>
}
t|||||||	|
<EFBFBD>\}}||fg
}
tjg
}|j	d
kr<>|
<0A>
||f<02>

|<0E>
tj<0B>

n<>||||}}t<0C>
||<10>}|j	|}||||}}t<0C>
||<14>}|j	|}|
<0A>||||||f||f||||||fg<03>

|<0E>tjtjtjg<03>

|
<0A>
||f<02>

|<0E>
tj<0B>

t|
|<0E>S)Ng)rE
rU
r<>
r<>
rV
r<>
r
rrUr<>
r<>
r
rSr
<00>extendr<64>
)r7r<>
r<>
r<>r<>rB
rC
r<>
r<>
r<>
r<>
r$
r<>
rRrQ<00>dx1<78>dy1Zd1<64>f1<66>dx2<78>dy2<79>d2<64>f2r<r<r=r<>
ts4























zConnectionStyle.Angle.connectN)r<>
r
r<>
)r<>r<>r<>r<>r#r<>
r<r<r<r=<00>AngleYs
rc@s"eZ
dZd
Zd	dd<06>
Zdd<08>ZdS)
zConnectionStyle.Arca:

        Creates a piecewise continuous quadratic Bezier path between
        two points. The path can have two passing-through points, a
        point placed at the distance of armA and angle of angleA from
        point A, another point with respect to point B. The edges are
        rounded with *rad*.
        r
N<>cCs"|
|_||_
||_||_||_d
S)aH

            *angleA* :
              starting angle of the path

            *angleB* :
              ending angle of the path

            *armA* :
              length of the starting arm

            *armB* :
              length of the ending arm

            *rad* :
              rounding radius of the edges
            N)r<>
r<>
<00>armA<6D>armBr<42>
)r7r<>
r<>
rrr<>
r<r<r=r#<00>s



zConnectionStyle.Arc.__init__cCsv|
\}}|\}}||fg
}g}tj
g
}	|jr<>t<03>t<03>|j<06>
<01>
}
t<03>t<03>|j<06>
<01>
}|j|j}|<08>	|||
|||f<02>

|j}|<08>	|||
|||f<02>

|j
<EFBFBD>
r<>t<03>t<03>|j<0B>
<01>
}
t<03>t<03>|j<0B>
<01>
}||j
|
||j
|}}|<08>
rl|d
\}}||||}}||||d}|<08>	||j||||j||f<02>

|<07>|<08>

|	<09>tj
tjtjg<03>

n2|d
\}}||||}}||||d}||j}||||||||f||fg}|<08>rR|d
\}}||||}}||||d}|<08>	||j||||j||f<02>

|<07>|<08>

|	<09>tj
tjtjg<03>

|<07>	||f<02>

|	<09>	tj
<0A>

t||	<09>S)Nr
g<00>?)rrUrrE
rU
r<>
r<>
rV
r<>
r<>
rr<>
r<>
r
r<>
)r7r<>
r<>
r<>r<>rB
rC
rRZroundedrQr<>
r<>
<00>
dr<64>
r<>
Zx_armBZy_armBZxpZypr!
r"
<00>ddr<r<r=r<>
<00>sZ






































zConnectionStyle.Arc.connect)r
r
NNr)r<>r<>r<>r<>r#r<>
r<r<r<r=r<><00>s
r<>c@s"eZ
dZd
Zd	dd<06>
Zdd<08>ZdS)
zConnectionStyle.Bara

        A line with *angle* between A and B with *armA* and
        *armB*. One of the arms is extended so that they are connected in
        a right angle. The length of armA is determined by (*armA*
        + *fraction* x AB distance). Same for armB.
        <20><00>333333<33>?NcCs|
|_||_
||_||_d
S)a<>

            Parameters
            ----------
            armA : float
                minimum length of armA

            armB : float
                minimum length of armB

            fraction : float
                a fraction of the distance between two points that
                will be added to armA and armB.

            angle : float or None
                angle of the connecting line (if None, parallel
                to A and B)
            N)rr<00>fractionr<6E>)r7rrr
r<>r<r<r=r#<00>s


zConnectionStyle.Bar.__init__cCs<>
|
\}}|\}}\}}t<00>
||||<00>}	||||}
}|
|
||d
}|
|||}
}|j|j}}|jdk	<09>
rt<05>|j<04>
}|	|}|t<00>|<12>
}|t<00>|<12>
}||t<00>|<11>
||t<00>|<11>
}}||}||||}
}|
|
||d
}|
|||}
}t	||<10>}|j
||}||||||
}}||||||
}}||f||f||f||fg}tjtj
tj
tj
g}t||<1D>S)Ng<00>?)rE
<00>atan2rrr<>rSrT
rV
rU
rr
r
rrUr
)r7r<>
r<>
r<>r<>Zx20Zy20rB
rC
r
r!
r"
r<00>ddx<64>ddyrrZtheta0Zdtheta<74>dlZdLZdd2Zarmr<6D>
Zcx1Zcy1Zcx2Zcy2rRrQr<r<r=r<>
s<









&













zConnectionStyle.Bar.connect)rrr	N)r<>r<>r<>r<>r#r<>
r<r<r<r=<00>Bar<61>s
r<00>AvailableConnectorstylesN)r<>r<>r<>r<>r<>
r<>
r<>
r<>
r<>
r<>
rr<>rr<>
r<>
r<>
r<r<r<r=r<>
<00>
s &T
#
%
=
]
H

r<>
c
CsL|||
|}}|||||d
}||||
||}}	||	fS)zj
    find a point along a line connecting (x0, y0) -- (x1, y1) whose
    distance from (x0, y0) is d.
    g<00>?r<)
r<EFBFBD>r<>r<>r<>rr!
r"
<00>ffrB
rC
r<r<r=<00>_point_along_a_lineCs

rc@s<>
eZ
dZd
ZiZGdd<03>de<05>ZGdd<05>de<06>Zeedd<07>Gdd	<09>d	e<07><03>
Z	eed
d<07>Gdd<0C>de<07><03>
Z
eed
d<07>Gdd<0F>de<07><03>
Zeedd<07>Gdd<12>de<07><03>
Zeedd<07>Gdd<15>de<07><03>
Z
eedd<07>Gdd<18>de<07><03>
Zeedd<07>Gdd<1B>de<07><03>
ZGdd<1D>de<06>Zeedd<07>Gdd <20>d e<10><03>
Zeed!d<07>Gd"d#<23>d#e<10><03>
Zeed$d<07>Gd%d&<26>d&e<10><03>
Zeed'd<07>Gd(d)<29>d)e<10><03>
Zee<04>
Gd*d+<2B>d+e<06><03>
Zee<04>
Gd,d-<2D>d-e<06><03>
Zee<04>
Gd.d/<2F>d/e<06><03>
Ze<03>
r<>e<18>e<03>
d0ee<04>
i
Zd1S)2<>
ArrowStylea<EFBFBD>
    :class:`ArrowStyle` is a container class which defines several
    arrowstyle classes, which is used to create an arrow path along a
    given path. These are mainly used with :class:`FancyArrowPatch`.

    A arrowstyle object can be either created as::

           ArrowStyle.Fancy(head_length=.4, head_width=.4, tail_width=.4)

    or::

           ArrowStyle("Fancy", head_length=.4, head_width=.4, tail_width=.4)

    or::

           ArrowStyle("Fancy, head_length=.4, head_width=.4, tail_width=.4")

    The following classes are defined

    %(AvailableArrowstyles)s


    An instance of any arrow style class is a callable object,
    whose call signature is::

        __call__(self, path, mutation_size, linewidth, aspect_ratio=1.)

    and it returns a tuple of a :class:`Path` instance and a boolean
    value. *path* is a :class:`Path` instance along which the arrow
    will be drawn. *mutation_size* and *aspect_ratio* have the same
    meaning as in :class:`BoxStyle`. *linewidth* is a line width to be
    stroked. This is meant to be used to correct the location of the
    head so that it does not overshoot the destination point, but not all
    classes support it.
    c@s.eZ
dZd
Zedd<03><00>
Zdd<05>Zd
dd<08>
Zd	S)zArrowStyle._Basea<65>

        Arrow Transmuter Base class

        ArrowTransmuterBase and its derivatives are used to make a fancy
        arrow around a given path. The __call__ method returns a path
        (which will be used to create a PathPatch instance) and a boolean
        value indicating the path is open therefore is not fillable.  This
        class is not an artist and actual drawing of the fancy arrow is
        done by the FancyArrowPatch class.

        c
Cs\t|<00>
<01><00>
}
t|
<01>
d
ks<|
ddtjks<|
ddtjkrDtd<04>
<01>
|
dd|
dd<00>S)a4

            Some ArrowStyle class only works with a simple quadratic Bezier
            curve (created with Arc3Connection or Angle3Connector). This static
            method is to check if the provided path is a simple quadratic
            Bezier curve and returns its control points if true.
            r	
r
rz,'path' is not a valid quadratic Bezier curve)<07>listZ
iter_segmentsr5rrUr<>
r<>)rA<00>segmentsr<r<r=<00>ensure_quadratic_bezier<65>s




z(ArrowStyle._Base.ensure_quadratic_beziercCstd
<01>
<01>
dS)a<>
            The transmute method is the very core of the ArrowStyle class and
            must be overridden in the subclasses. It receives the path object
            along which the arrow will be drawn, and the mutation_size, with
            which the arrow head etc. will be scaled. The linewidth may be
            used to adjust the path so that it does not pass beyond the given
            points. It returns a tuple of a Path instance and a boolean. The
            boolean value indicate whether the path can be filled or not. The
            return value can also be a list of paths and list of booleans of a
            same length.
            zDerived must overrideN)
r<>)r7rAr<>
rr<r<r=r<>
<00>szArrowStyle._Base.transmute<74><00>?cCs<>t|
<01>
}
|d
k	r<>|
j
d
d
<01>|
jd
d
<01>}}|d
d
<01>df||d
d
<01>df<t||<06>}|<00>|||<02>\}}	t<05>|	<09>
r<>g}
xNt|<08>
D]B}|j
|j}}
|d
d
<01>df||d
d
<01>df<|
<EFBFBD>t||
<0A><02>

q<>W|
|	fS||	fSn|<00>|
||<03>Sd
S)z<>
            The __call__ method is a thin wrapper around the transmute method
            and takes care of the aspect ratio.
            Nr)	rrRrQrr<>
rS<00>iterablere
r<>
)r7rAr<>
rr<>
rRrQZpath_shrunkZpath_mutated<65>fillable<6C>	path_listr<74>
r
rur<r<r=r<>
<00>s" 









 


zArrowStyle._Base.__call__N)
r)r<>r<>r<>r<><00>staticmethodrr<>
r<>
r<r<r<r=r<>
vsr<>
cs2eZ
dZd
Zd<0C>f
dd<07>	Zdd	<09>Zd
d<0B>Z<06>ZS)
zArrowStyle._Curvea*

        A simple arrow which will work with any path instance. The
        returned path is simply concatenation of the original path + at
        most two paths representing the arrow head at the begin point and the
        at the end point. The arrow heads can be either open or closed.
        NF皙<46><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cs8|
||_|_
|||_|_|||_|_t<06><00><07>
d
S)a>

            The arrows are drawn if *beginarrow* and/or *endarrow* are
            true. *head_length* and *head_width* determines the size
            of the arrow relative to the *mutation scale*.  The
            arrowhead at the begin (or end) is closed if fillbegin (or
            fillend) is True.
            N)<08>
beginarrow<EFBFBD>endarrowr0
r/
<00>	fillbegin<69>fillendr.
r#)r7rrr r!r0
r/
)
r4
r<r=r#<00>s



zArrowStyle._Curve.__init__c	Cs
|
|||}	}
t<00>
|	|
<EFBFBD>}d
||}|dkr6d}||	|}
||
|}|	||}	|
||}
||	||
||	||
}}||	||
||	||
}}||
||||f||
||f||
||||fg}tjtjtjg}|||
|fS)a

            Return the paths for arrow heads. Since arrow lines are
            drawn with capstyle=projected, The arrow goes beyond the
            desired point. This method also returns the amount of the path
            to be shrunken so that it does not overshoot.
            g<00>?r
r)rSr
rrUr
)r7r<>r<>r<>r<><00>	head_dist<73>cos_t<5F>sin_trr!
r"
Zcp_distanceZ
pad_projectedrr
r<>
r<>
r<>
r<>
<00>vertices_arrow<6F>codes_arrowr<r<r=<00>_get_arrow_wedge<67>s$


$
"




z"ArrowStyle._Curve._get_arrow_wedgec
Cs,|j|}|j
|}t<02>||<05>}||||}}|
jd
\}	}
|
jd\}}|job|	|
f||fk}
|
r<>|<00>|||	|
||||<03>n
ggd
d
f\}}}}|
jd\}}|
jd\}}|jo<>||f||fk}|r<>|<00>||||||||<03>n
ggd
d
f\}}}}tt<02>	|	||
|fg
|
jdd<04>||||fg
g<03>
|
j
<EFBFBD>g
}dg
}|
<0A>
r<>|j<0B>
r<>t<02>	||d
|d
gg<02>
}t<02>	|tjtj
gg<02>
}|<1B>t||<1E><02>

|<1C>d<06>

n|<1B>t||<0F><02>

|<1C>d<05>

|<16>r$|j<0F>r
|<1C>d<06>

t<02>	||d
|d
gg<02>
}t<02>	|tjtj
gg<02>
}|<1B>t||<1E><02>

n|<1C>d<05>

|<1B>t||<18><02>

||fS)Nr
rr*
r
FT)r0
r/
rSr
rRrr'rrr

rQr r
r
r<>
r!)r7rAr<>
rr0
r/
r"r#r$r<>r<>r<>r<>Zhas_begin_arrow<6F>	verticesA<73>codesAZddxAZddyArB
rC
Zx3Zy3Z
has_end_arrow<6F>	verticesB<73>codesBZddxBZddyBr<42>Z	_fillabler<65>
rur<r<r=r<>

sL






























zArrowStyle._Curve.transmute)NNFFrr)r<>r<>r<>r<>r#r'r<>
r5
r<r<)
r4
r=<00>_Curve<76>s


+r,<00>
-)
r<>
cs eZ
dZd
Z<03>f
dd<03>Z<04>ZS)zArrowStyle.Curvez8
        A simple curve without any arrow head.
        c

st<00>j
d
d
d<02>
dS)NF)rr)r.
r#)
r7)
r4
r<r=r#N
s
zArrowStyle.Curve.__init__)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveH
sr.z<-cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveAz:
        An arrow with a head at its begin point.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
d|
|d<03>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            TF)rrr0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#W
s


zArrowStyle.CurveA.__init__)r/r0)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveAQ
sr1z->cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveBz8
        An arrow with a head at its end point.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
d|
|d<03>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            FT)rrr0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#j
s


zArrowStyle.CurveB.__init__)r2r3)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveBd
sr4z<->cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveABzJ
        An arrow with heads both at the begin and the end point.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
d
|
|d<02>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            T)rrr0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#}
s


zArrowStyle.CurveAB.__init__)r5r6)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveABw
sr7z<|-cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveFilledAzB
        An arrow with filled triangle head at the begin.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
dd
d|
|d<03>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            TF)rrr r!r0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#<00>
s



z ArrowStyle.CurveFilledA.__init__)r8r9)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveFilledA<64>
sr:z-|>cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveFilledBz@
        An arrow with filled triangle head at the end.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
dd
d|
|d<03>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            FT)rrr r!r0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#<00>
s



z ArrowStyle.CurveFilledB.__init__)r;r<)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>CurveFilledB<64>
sr=z<|-|>cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.CurveFilledABzC
        An arrow with filled triangle heads at both ends.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cst<00>j
d
d
d
d
|
|d<02>
dS)z<>
            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.2
                Width of the arrow head
            T)rrr r!r0
r/
N)r.
r#)r7r0
r/
)
r4
r<r=r#<00>
s



z!ArrowStyle.CurveFilledAB.__init__)r>r?)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>
CurveFilledAB<41>
sr@c
@s&eZ
dZd
dd<05>
Zdd<07>Zdd	<09>Zd
S)zArrowStyle._BracketN<74><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cCsJ|
||_|_
|||_|_|||_|_|||_|_|	|
|_|_	dS)
N)
<EFBFBD>bracketA<74>bracketB<74>widthA<68>widthB<68>lengthA<68>lengthBr<42>
r<>
<00>scaleA<65>scaleB)r7rCrDrErFrGrHr<>
r<>
rIrJr<r<r=r#<00>
s




zArrowStyle._Bracket.__init__cCs~d
dlm
}
||
||||<05>\}}	}
}||||}}
|||	|
f||	f|
|f|
|||
fg}tjtjtjtjg}||fS)Nr
)
<01>get_normal_points)Zmatplotlib.bezierrKrrUr
)r7r<>r<>r#r$r<>r2
rKr<>r<>rB
rC
r!
r"
r%r&r<r<r=<00>_get_bracket<65>
s







z ArrowStyle._Bracket._get_bracketc	CsN
|jdkr|}n|j}|j
dkr&|}n|j
}gg}}|jr<>|
jd
\}}	|
jd\}
}t|
|||	<09>\}}
|<00>||	||
|j||j|<00>\}}|<06>|<0E>

|<07>|<0F>

|<06>|
j<03>

|<07>|
j	<09>

|j
<EFBFBD>
r(|
jd\}}	|
jd\}
}t|
|||	<09>\}}
|<00>||	||
|j||j|<00>\}}|<06>|<10>

|<07>|<11>

t
<0A>|<06>
}t
<0A>|<07>
}t||<13>}|dfS)Nr
rr
r*
F)rIrJrCrRrrLrErGr<>
rQrDrFrHrSr

r)r7rAr<>
rrIrJZ
vertices_listZ
codes_listr<EFBFBD>r<>r<>r<>r#r$r(r)r*r+rRrQr<>
r<r<r=r<>
<00>
s>





























zArrowStyle._Bracket.transmute)
NNrArArBrBNNNN)r<>r<>r<>r#rLr<>
r<r<r<r=<00>_Bracket<65>
s




rMz]-[cs"eZ
dZd
Zd<07>f
dd<06>	Z<04>ZS)zArrowStyle.BracketABz:
        An arrow with a bracket(]) at both ends.
        <20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Nc
s t<00>j
d
d
|
|||||d<02>
dS)a<>
            Parameters
            ----------
            widthA : float, optional, default : 1.0
                Width of the bracket

            lengthA : float, optional, default : 0.2
                Length of the bracket

            angleA : float, optional, default : None
                Angle between the bracket and the line

            widthB : float, optional, default : 1.0
                Width of the bracket

            lengthB : float, optional, default : 0.2
                Length of the bracket

            angleB : float, optional, default : None
                Angle between the bracket and the line
            T)rErGr<>
rFrHr<>
N)r.
r#)r7rErGr<>
rFrHr<>
)
r4
r<r=r#s


zArrowStyle.BracketAB.__init__)rNrONrNrON)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>	BracketABs
rPz]-cs"eZ
dZd
Zd<07>f
dd<06>	Z<04>ZS)zArrowStyle.BracketAz9
        An arrow with a bracket(])  at its end.
        <20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Ncst<00>j
d
d|
||d<03>
dS)a]

            Parameters
            ----------
            widthA : float, optional, default : 1.0
                Width of the bracket

            lengthA : float, optional, default : 0.2
                Length of the bracket

            angleA : float, optional, default : None
                Angle between the bracket and the line
            TN)rErGr<>
)r.
r#)r7rErGr<>
)
r4
r<r=r#;s

zArrowStyle.BracketA.__init__)rQrRN)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>BracketA5srSz-[cs"eZ
dZd
Zd<07>f
dd<06>	Z<04>ZS)zArrowStyle.BracketBz9
        An arrow with a bracket([)  at its end.
        <20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Ncst<00>j
d
d|
||d<03>
d
S)a]

            Parameters
            ----------
            widthB : float, optional, default : 1.0
                Width of the bracket

            lengthB : float, optional, default : 0.2
                Length of the bracket

            angleB : float, optional, default : None
                Angle between the bracket and the line
            NT)rFrHr<>
)r.
r#)r7rFrHr<>
)
r4
r<r=r#Qs

zArrowStyle.BracketB.__init__)rTrUN)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>BracketBKsrVz|-|cs"eZ
dZd
Zd<06>f
dd<05>	Z<04>ZS)zArrowStyle.BarABz6
        An arrow with a bar(|) at both ends.
        <20><00>?Nc
s t<00>j
d
d
|
d||d|d<03>
dS)a<>

            Parameters
            ----------
            widthA : float, optional, default : 1.0
                Width of the bracket

            angleA : float, optional, default : None
                Angle between the bracket and the line

            widthB : float, optional, default : 1.0
                Width of the bracket

            angleB : float, optional, default : None
                Angle between the bracket and the line
            Tr
)rErGr<>
rFrHr<>
N)r.
r#)r7rEr<>
rFr<>
)
r4
r<r=r#gs


zArrowStyle.BarAB.__init__)rWNrWN)r<>r<>r<>r<>r#r5
r<r<)
r4
r=<00>BarABas
rXcs*eZ
dZd
Zd<08>f
dd<05>	Zdd<07>Z<05>ZS)	zArrowStyle.SimplezK
        A simple arrow. Only works with a quadratic Bezier curve.
        <20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cs$|
|||_|_
|_t<03><00><04>
d
S)a_

            Parameters
            ----------
            head_length : float, optional, default : 0.5
                Length of the arrow head

            head_width : float, optional, default : 0.5
                Width of the arrow head

            tail_width : float, optional, default : 0.2
                Width of the arrow tail
            N)r0
r/
<00>
tail_widthr.
r#)r7r0
r/
r[)
r4
r<r=r#<00>s
zArrowStyle.Simple.__init__cCs|<00>|
<01>
\}}}}}}	|j
|}
t||	|
<EFBFBD>}||f||f||	fg}yt||d
d<02>\}
}Wn\tk
r<EFBFBD>


t||	|||
<EFBFBD>\}}d||d||	}}||f||f||	fg}d}
YnX|j|}t||ddd<05>\}}|
dk	<09>
r<>|j|}t	|
|d<00>\}}t
j|dft
j|dft
j|dft
j
|dft
j|dft
j|dft
j|dft
j|dft
j
|dft
j|dft
j|dft
j
|dft
j|dfg
}nLt
j|dft
j|dft
j|dft
j|dft
j|dft
j|dfg}t
d	d
<EFBFBD>|D<00>
dd
<EFBFBD>|D<00>
<01>}
|
dfS)
Ng{<14>G<EFBFBD>z<EFBFBD>?)
<01>	toleranceg<00>?g@)
<01>wmr
rr	
c
Ssg|]\}
}|<02>qSr<r<)rMrur<>
r<r<r=rt
<00>sz/ArrowStyle.Simple.transmute.<locals>.<listcomp>c
Ssg|]\}
}|
<01>qSr<r<)rMrur<>
r<r<r=rt
<00>sT)rr0
rrr
rr/
rr[rrrUr<>
r
r
)r7rAr<>
rr<>r<>r<>r<>rB
rC
r0
<00>in_f<5F>
arrow_pathZ	arrow_outZarrow_in<69>x1n<31>y1nr/
<00>	head_left<66>
head_rightr[<00>	tail_left<66>
tail_right<EFBFBD>
patch_pathr<r<r=r<>
<00>sP

































zArrowStyle.Simple.transmute)rYrYrZ)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>Simple}srgcs*eZ
dZd
Zd<07>f
dd<04>	Zdd<06>Z<05>ZS)zArrowStyle.FancyzJ
        A fancy arrow. Only works with a quadratic Bezier curve.
        皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?cs$|
|||_|_
|_t<03><00><04>
d
S)a_

            Parameters
            ----------
            head_length : float, optional, default : 0.4
                Length of the arrow head

            head_width : float, optional, default : 0.4
                Width of the arrow head

            tail_width : float, optional, default : 0.4
                Width of the arrow tail
            N)r0
r/
r[r.
r#)r7r0
r/
r[)
r4
r<r=r#<00>s
zArrowStyle.Fancy.__init__cCs|<00>|
<01>
\}}}}}}	|j
|}
||f||f||	fg}t||	|
<EFBFBD>}yt||d
d<02>\}
}Wn\tk
r<EFBFBD>


t||	|||
<EFBFBD>\}}d||d||	}}||f||f||	fg}|}YnX|}t||	|
d<00>}t||d
d<02>\}
}|
}|j|}t||ddd<07>\}}|j|}t||dddd	d
<EFBFBD>\}}t|||d	<00>}t||d
d<02>\}}
|d}||}}t	j
|ft	j|dft	j|d
ft	j|dft	j|dft	j|d
ft	j|dft	j|d
ft	j|dft	j|dft	j|d
ft	j|dft	j|ft	j
|fg}t	dd<10>|D<00>
dd<10>|D<00>
<01>}
|
dfS)Ng{<14>G<EFBFBD>z<EFBFBD>?)
r\g<00>?g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?g@g333333<33>?)
r]g<00>?g333333<33>?)Zw1r]Zw2r
r
rr	
c
Ssg|]\}
}|<02>qSr<r<)rMrur<>
r<r<r=rt
%sz.ArrowStyle.Fancy.transmute.<locals>.<listcomp>c
Ssg|]\}
}|
<01>qSr<r<)rMrur<>
r<r<r=rt
%sT)rr0
rrr
rr/
rr[rrUr
r<>
r
)r7rAr<>
rr<>r<>r<>r<>rB
rC
r0
r_r^Zpath_outZpath_inr`raZ	path_headZ	path_tailr/
Zhead_lZhead_rr[rdreZ
tail_startrcrbrfr<r<r=r<>
<00>s\






































zArrowStyle.Fancy.transmute)rhrhrh)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=<00>Fancy<63>srics*eZ
dZd
Zd<08>f
dd<05>	Zdd<07>Z<05>ZS)	zArrowStyle.Wedgez<65>
        Wedge(?) shape. Only works with a quadratic Bezier curve.  The
        begin point has a width of the tail_width and the end point has a
        width of 0. At the middle, the width is shrink_factor*tail_width.
        <20>333333<33>?<3F><00>?cs|
|_||_
t<02><00><03>
d
S)a

            Parameters
            ----------
            tail_width : float, optional, default : 0.3
                Width of the tail

            shrink_factor : float, optional, default : 0.5
                Fraction of the arrow width at the middle point
            N)r[<00>
shrink_factorr.
r#)r7r[rl)
r4
r<r=r#1s


zArrowStyle.Wedge.__init__c	Cs<>|<00>|
<01>
\}}}}}}	||f||f||	fg}
t
|
|j|d
|jd<02>\}}tj|dftj|dftj|dftj|dftj|dftj|dftj|dfg}
tdd<07>|
D<00>
dd<07>|
D<00>
<01>}
|
d	fS)
Ng@)
r]r
rr	
c
Ssg|]\}
}|<02>qSr<r<)rMrur<>
r<r<r=rt
Qsz.ArrowStyle.Wedge.transmute.<locals>.<listcomp>c
Ssg|]\}
}|
<01>qSr<r<)rMrur<>
r<r<r=rt
QsT)	rrr[rlrrUr<>
r
r
)r7rAr<>
rr<>r<>r<>r<>rB
rC
r_Zb_plusZb_minusrfr<r<r=r<>
?s









zArrowStyle.Wedge.transmute)rjrk)r<>r<>r<>r<>r#r<>
r5
r<r<)
r4
r=r<>)sr<><00>AvailableArrowstylesN)r<>r<>r<>r<>r<>
r<>
r<>
r,r<>
r.r1r4r7r:r=r@rMrPrSrVrXrgrir<>r<>
r<>
r<>
r<r<r<r=rOsJ#O






M
!



Q
Y
+

r)rmrc@s<>eZ
dZd
ZdZdd<04>Zejd,d
d<0B>
<01>
Zdd
<0A>Z	dd<0F>Z
dd<11>Zdd<13>Zdd<15>Z
dd<17>Zdd<19>Zd-dd<1B>
Zdd<1D>Zdd<1F>Zd d!<21>Zd"d#<23>Zd$d%<25>Zd&d'<27>Zd(d)<29>Zd*d+<2B>ZdS).r6
a%

    A fancy arrow patch. It draws an arrow using the :class:`ArrowStyle`.

    The head and tail positions are fixed at the specified start and end points
    of the arrow, but the size and shape (in display coordinates) of the arrow
    does not change when the axis is moved or zoomed.
    Tc
CsP|jdk	r4|j\\}
}\}}|j
jd
|
|||fS|j
jdt|j<04>
f
SdS)Nz((%g, %g)->(%g, %g))z(%s))<05>
_posA_posBr4
r<>r<><00>_path_original)r7r<>r<>rB
rC
r<r<r=r<>js




zFancyArrowPatch.__str__N<5F>simple<6C>arc3r	
rcKs<>|d
k	rtj
ddddd<06>
|d
k	r4tj
ddddd<06>
tj|f
|<0F>

|
d
k	r||d
k	r||d
kr||
|g|_|d
krpd	}|<00>|<06>

n(|
d
kr<>|d
kr<>|d
k	r<>d
|_ntd
<EFBFBD>
<01>
||_|	|_|
|_	||_
||_|<00>|<04>

||_
|
|_|<00>|<0E>

d
S)a<>

        If *posA* and *posB* are given, a path connecting two points is
        created according to *connectionstyle*. The path will be
        clipped with *patchA* and *patchB* and further shrunken by
        *shrinkA* and *shrinkB*. An arrow is drawn along this
        resulting path using the *arrowstyle* parameter.

        Alternatively if *path* is provided, an arrow is drawn along this path
        and *patchA*, *patchB*, *shrinkA*, and *shrinkB* are ignored.

        Parameters
        ----------

        posA, posB : None, tuple, optional (default: None)
            (x,y) coordinates of arrow tail and arrow head respectively.

        path : None, Path (default: None)
            :class:`matplotlib.path.Path` instance. If provided, an arrow is
            drawn along this path and *patchA*, *patchB*, *shrinkA*, and
            *shrinkB* are ignored.

        arrowstyle : str or ArrowStyle, optional (default: 'simple')
            Describes how the fancy arrow will be
            drawn. It can be string of the available arrowstyle names,
            with optional comma-separated attributes, or an
            :class:`ArrowStyle` instance. The optional attributes are meant to
            be scaled with the *mutation_scale*. The following arrow styles are
            available:

            %(AvailableArrowstyles)s

        arrow_transmuter
            Ignored

        connectionstyle : str, ConnectionStyle, or None, optional
        (default: 'arc3')
            Describes how *posA* and *posB* are connected. It can be an
            instance of the :class:`ConnectionStyle` class or a string of the
            connectionstyle name, with optional comma-separated attributes. The
            following connection styles are available:

            %(AvailableConnectorstyles)s

        connector
            Ignored

        patchA, patchB : None, Patch, optional (default: None)
            Head and tail patch respectively. :class:`matplotlib.patch.Patch`
            instance.

        shrinkA, shrinkB : scalar, optional (default: 2)
            Shrinking factor of the tail and head of the arrow respectively

        mutation_scale : scalar, optional (default: 1)
            Value with which attributes of *arrowstyle* (e.g., *head_length*)
            will be scaled.

        mutation_aspect : None, scalar, optional (default: None)
            The height of the rectangle will be squeezed by this value before
            the mutation and the mutated box will be stretched by the inverse
            of it.

        dpi_cor : scalar, optional (default: 1)
            dpi_cor is currently used for linewidth-related things and shrink
            factor. Mutation scale is affected by this.

        Notes
        -----
        Valid kwargs are:
        %(Patch)s
        Ng@zZThe "arrow_transmuter" keyword argument is not used, and will be removed in Matplotlib 3.1<EFBFBD>arrow_transmuterzkeyword argument)r<>r<>
Zobj_typezSThe "connector" keyword argument is not used, and will be removed in Matplotlib 3.1r
rqz.either posA and posB, or path need to provided)rr<>rr#rn<00>set_connectionstyler<65>r<>
r<>
r<>
r<>
ro<00>set_arrowstyler<65>
r<>
<00>set_dpi_cor)r7r<>
r<>
rA<00>
arrowstylerr<00>connectionstyler
r<>
r<>
r<>
r<>
r<>
r<>
<00>dpi_corr;r<r<r=r#ts<V



















zFancyArrowPatch.__init__cCs|
|_d
|_
dS)z<>
        dpi_cor is currently used for linewidth-related things and
        shrink factor. Mutation scale is affected by this.

        Parameters
        ----------
        dpi_cor : scalar
        TN)<02>_dpi_corrm)r7rxr<r<r=ru<00>s	
zFancyArrowPatch.set_dpi_corc


Cs|jS)
z<>
        dpi_cor is currently used for linewidth-related things and
        shrink factor. Mutation scale is affected by this.

        Returns
        -------
        dpi_cor : scalar
        )
ry)
r7r<r<r=<00>get_dpi_cors	zFancyArrowPatch.get_dpi_corcCs.|
d
k	r|
|jd<|d
k	r$||jd<d|_
d
S)a

        Set the begin and end positions of the connecting path.

        Parameters
        ----------
        posA, posB : None, tuple
            (x,y) coordinates of arrow tail and arrow head respectively. If
            `None` use current value.
        Nr
rT)rnrm)r7r<>
r<>
r<r<r=<00>
set_positionss







zFancyArrowPatch.set_positionscCs|
|_d
|_
dS)z<>
        Set the tail patch.

        Parameters
        ----------
        patchA : Patch
            :class:`matplotlib.patch.Patch` instance.
        TN)r<>
rm)r7r<>
r<r<r=<00>
set_patchAs	
zFancyArrowPatch.set_patchAcCs|
|_d
|_
dS)z<>
        Set the head patch.

        Parameters
        ----------
        patchB : Patch
            :class:`matplotlib.patch.Patch` instance.
        TN)r<>
rm)r7r<>
r<r<r=<00>
set_patchB's	
zFancyArrowPatch.set_patchBcKsD|
d
krt<00>
<01>St|
tj<03>s$t|
<01>
r,|
|_nt|
f
|<02>
|_d|_d
S)a<>
        Set the connection style. Old attributes are forgotten.

        Parameters
        ----------
        connectionstyle : None, ConnectionStyle instance, or string
            Can be a string with connectionstyle name with
            optional comma-separated attributes, e.g.::

                set_connectionstyle("arc,angleA=0,armA=30,rad=10")

            Alternatively, the attributes can be provided as keywords, e.g.::

                set_connectionstyle("arc", angleA=0,armA=30,rad=10)

            Without any arguments (or with ``connectionstyle=None``), return
            available styles as a list of strings.
        NT)r<>
r<>
rDr<>
r<>
<00>
_connectorrm)r7rwr<>
r<r<r=rs3s



z#FancyArrowPatch.set_connectionstylec


Cs|jS)
z?
        Return the :class:`ConnectionStyle` instance.
        )
r~)
r7r<r<r=<00>get_connectionstyleQsz#FancyArrowPatch.get_connectionstylecKs<|
d
krt<00>
<01>St|
tj<03>r$|
|_nt|
f
|<02>
|_d|_d
S)aO
        Set the arrow style. Old attributes are forgotten. Without arguments
        (or with ``arrowstyle=None``) returns available box styles as a list of
        strings.

        Parameters
        ----------
        arrowstyle : None, ArrowStyle, str, optional (default: None)
            Can be a string with arrowstyle name with optional comma-separated
            attributes, e.g.::

                set_arrowstyle("Fancy,head_length=0.2")

            Alternatively attributes can be provided as keywords, e.g.::

                set_arrowstyle("fancy", head_length=0.2)

        NT)rr<>
rDr<>
<00>_arrow_transmuterrm)r7rvr<>
r<r<r=rtWs


zFancyArrowPatch.set_arrowstylec


Cs|jS)
z/
        Return the arrowstyle object.
        )
r<>)
r7r<r<r=<00>get_arrowstyletszFancyArrowPatch.get_arrowstylecCs|
|_d
|_
dS)zg
        Set the mutation scale.

        Parameters
        ----------
        scale : scalar
        TN)r<>
rm)r7r<>r<r<r=r<>
zs
z"FancyArrowPatch.set_mutation_scalec


Cs|jS)
zd
        Return the mutation scale.

        Returns
        -------
        scale : scalar
        )
r<>
)
r7r<r<r=r<>
<00>sz"FancyArrowPatch.get_mutation_scalecCs|
|_d
|_
dS)z{
        Set the aspect ratio of the bbox mutation.

        Parameters
        ----------
        aspect : scalar
        TN)r<>
rm)r7r<>
r<r<r=r<>
<00>s
z#FancyArrowPatch.set_mutation_aspectc


Cs|jS)
z?
        Return the aspect ratio of the bbox mutation.
        )
r<>
)
r7r<r<r=r<>
<00>sz#FancyArrowPatch.get_mutation_aspectc
Cs0|<00><00>\}
}t
<01>|<02>
rt|
<01>
}
|<00><04><00><05><00>|
<01>
S)
z<>
        Return the path of the arrow in the data coordinates. Use
        get_path_in_displaycoord() method to retrieve the arrow path
        in display coordinates.
        )<07>get_path_in_displaycoordrSrrr>rc
<00>transform_path)r7r<>rr<r<r=r?<00>s

zFancyArrowPatch.get_pathc
Cs<>|<00><00>}
|j
d
k	rx|<00>|j
d<00>
}|<00>|j
d<00>
}|<00><03><00>|<02>
}|<00><03><00>|<03>
}|<00><05>|||j|j|j|
|j	|
d<04>}n|<00><03><00>
|j<0B>
}|<00><0C>||<00>
<0A>|
|<00><0E>|
|<00><0F><00>\}}||fS)zN
        Return the mutated path of the arrow in display coordinates.
        Nr
r)r<>
r<>
r<>
r<>
)rzrnr<>r>rb
rr<>
r<>
r<>
r<>
r<>ror<>r<>
rFr<>
)r7rxr<>
r<>
r<>rr<r<r=r<><00>s$
















z(FancyArrowPatch.get_path_in_displaycoordc
Cs<>|<00><00>sdSt
j|d
d
d<02><03><>
|<00>|
<01>
<01>x}|<00>|
<01>d<03>
<01>

|<00><06>\}}t<07>|<04>
s\|g
}|g
}t	<09>
<EFBFBD>}x6t||<04>D](\}}||||r<>|jdr<>|jnd<00>
qpWWdQRXWdQRXdS)Nr)r<>r<>g<00>?rC)
r<>rr<>r<>rur<>r<>rSrr	rgre
r^)r7r<>r<>rArr<>r<>
r<>
r<r<r=r<><00>s









zFancyArrowPatch.draw)NNNrpNrqNNNr	
r	
rNr)
N)r<>r<>r<>r<>ror<>rr<>r#rurzr{r|r}rsrrtr<>r<>
r<>
r<>
r<>
r?r<>r<>r<r<r<r=r6
`sB














s


 c@sZeZ
dZd
Zdd<03>Zejddd<0C>
<01>
Zdd
d<0E>
Zdd<10>Z	dd<12>Z
dd<14>Zdd<16>Zdd<18>Z
dS)<1B>ConnectionPatchz<68>
    A :class:`~matplotlib.patches.ConnectionPatch` class is to make
    connecting lines between two points (possibly in different axes).
    c

Cs(d
|jd|jd|j
d|j
dfS)Nz#ConnectionPatch((%g, %g), (%g, %g))r
r)<02>xy1<79>xy2)
r7r<r<r=r<><00>s

zConnectionPatch.__str__Nr-rq<00><00>$@F<><00>?cKsj|d
kr|}|
|_||_
||_||_||_||_tj|f
dd|||	|
|||
|||||d<04>|<13><02>

d
|_d
S)a_	
        Connect point *xyA* in *coordsA* with point *xyB* in *coordsB*


        Valid keys are


        ===============  ======================================================
        Key              Description
        ===============  ======================================================
        arrowstyle       the arrow style
        connectionstyle  the connection style
        relpos           default is (0.5, 0.5)
        patchA           default is bounding box of the text
        patchB           default is None
        shrinkA          default is 2 points
        shrinkB          default is 2 points
        mutation_scale   default is text size (in points)
        mutation_aspect  default is 1.
        ?                any key for :class:`matplotlib.patches.PathPatch`
        ===============  ======================================================


        *coordsA* and *coordsB* are strings that indicate the
        coordinates of *xyA* and *xyB*.

        =================   ===================================================
        Property            Description
        =================   ===================================================
        'figure points'     points from the lower left corner of the figure
        'figure pixels'     pixels from the lower left corner of the figure
        'figure fraction'   0,0 is lower left of figure and 1,1 is upper, right
        'axes points'       points from lower left corner of axes
        'axes pixels'       pixels from lower left corner of axes
        'axes fraction'     0,1 is lower left of axes and 1,1 is upper right
        'data'              use the coordinate system of the object being
                            annotated (default)
        'offset points'     Specify an offset (in points) from the *xy* value

        'polar'             you can specify *theta*, *r* for the annotation,
                            even in cartesian plots.  Note that if you
                            are using a polar axes, you do not need
                            to specify polar for the coordinate
                            system since that is the native "data" coordinate
                            system.
        =================   ===================================================

        Alternatively they can be set to any valid
        `~matplotlib.transforms.Transform`.
        N)r
r
)rr)r<>
r<>
rvrrrwr
r<>
r<>
r<>
r<>
r<>
r<>
<00>clip_onrx)	r<>r<><00>coords1<73>coords2<73>axesA<73>axesBr6
r#<00>_annotation_clip)r7ZxyAZxyBZcoordsAZcoordsBr<42>r<>rvrrrwr
r<>
r<>
r<>
r<>
r<>
r<>
r<>rxr;r<r<r=r#<00>s0B


















zConnectionPatch.__init__cCs:|d
kr|j}|dkrF|j
}t|<00>|
<01>
<01>
}
t|<00>|<02>
<01>
}|<05>|
|f<02>
S|dkr<>|j\}}|jdkrp|<00>||d<02>S|<00>|||j<07>\}}|j	<09>
<EFBFBD>}|
|d9}
||d9}|
|7}
||7}|
|fS|dk<02>
r|
|}	}
|
t<0B>|	<09>
}
|
t<0B>
|	<09>
}|j
}|<05>|
|f<02>
S|dk<02>
rz|j	j}|j	jj\}}}
}||
}
||}|
|d9}
||d9}|
dk<00>
r`|
|
}
|dk<00>
rr||}|
|fS|dk<02>
r<>|j	jj\}}}
}||
}
||}|
dk<00>
r<>|
|
}
|dk<00>
r<>||}|
|fS|d	k<02>
r<>|j	j}|<05>|
|f<02>
S|d
k<02>r<>|j	j}|jj\}}}
}||
}
||}|
dk<00>r@|
|
|d}
n||
|d}
|dk<00>rl|||d}n|||d}|
|fS|dk<02>r<>|jj\}}}
}||
}
||}|
dk<00>r<>|
|
}
n||
}
|dk<00>r<>||}n||}|
|fS|dk<02>r|j}|<05>|
|f<02>
St|tj<15><02>r(|<03>|
|f<02>
Std
<0A>|<03>
<01>
<01>
d
S)z=
        calculate the pixel position of given point
        N<>dataz
offset pointsgR@Zpolarz
figure pointsr
z
figure pixelszfigure fractionzaxes pointszaxes pixelsz
axes fractionz,{} is not a valid coordinate transformation.)rS
Z	transDatarvr<>r<>rb
r<>Zxycoordsr

r?
Zget_dpirSrU
rV
r@
r<>rm
ZtransFigureZ	transAxesrDr	Z	Transformr<6D>r<>
)r7rKrLr<>rS
r@r!
r"
r@
rX
r
r<>r<>r}r<><00>
tr<r<r=r

Os<>














































































zConnectionPatch._get_xycCs|
|_d
|_
dS)aM

        set *annotation_clip* attribute.

          * True: the annotation will only be drawn when self.xy is inside the
                   axes.
          * False: the annotation will always be drawn regardless of its
                    position.
          * None: the self.xy will be checked only if *xycoords* is "data"
        TN)r<>rm)r7r<>r<r<r=<00>set_annotation_clip<69>s

z#ConnectionPatch.set_annotation_clipc


Cs|jS)
z
        Return *annotation_clip* attribute.
        See :meth:`set_annotation_clip` for the meaning of return values.
        )
r<>)
r7r<r<r=<00>get_annotation_clip<69>sz#ConnectionPatch.get_annotation_clipc
Cs<>|<00><00>}
|j
\}}|<00>|||j|j<04>}|j\}}|<00>|||j|j<07>}|<00><08>|||j	|j
|j|
|j|
d
<01>}|<00>
<0A>||<00><0E>|
|<00><0F>|
|<00><10><00>\}}||fS)zK
        Return the mutated path of the arrow in the display coord
        )r<>
r<>
r<>
r<>
)rzr<>r

r<>r<>r<>r<>r<>rr<>
r<>
r<>
r<>
r<>r<>
rFr<>
)r7rxrKrLr<>
r<>
r<>rr<r<r=r<><00>s 














z(ConnectionPatch.get_path_in_displaycoordcCs<>|<00><00>}|s|d
krL|j
dkrL|j\}}|<00>|||j
|j<04>}|j<05>|<05>
sLdS|sb|d
kr<>|jdkr<>|j\}}|<00>|||j|j	<09>}|j	d
kr<>|j}n|j	}|<06>|<05>
s<>dSdS)z/Check whether the annotation needs to be drawn.Nr<4E>FT)
r<EFBFBD>r<>r<>r

r<>rS
rJr<>r<>r<>)r7r<>r<>rKrLZxy_pixelrS
r<r<r=<00>	_check_xy<78>s













zConnectionPatch._check_xycCs4|
dk	r|
|_|<00>
<01>r |<00>|
<01>
s$dSt<03>||
<01>
dS)
N)Z	_rendererr<72>r<>r6
r<>)r7r<>r<r<r=r<>s





zConnectionPatch.draw)NNNr-NrqNNNr<4E>r<>r<>NFr<46>)
N)r<>r<>r<>r<>r<>rr<>r#r

r<>r<>r<>r<>r<>r<r<r<r=r<><00>s.














R
k
r<>)NT)rG
N)
r	
)
N)Ir<49>r<>r<>
rE
<00>numbersrr~
ZnumpyrSZ
matplotlibr$rw
rrrrrryr	Zbezierr
rrr
rrrrrrrArZ_define_aliasesr"rZkwdocZpatchdocrG
Zinterpdr6r<>r#r<>r<>r<>r
r<>r<>r<>r<>r<><00>
deprecatedr<EFBFBD>r<>r<>r<>r<>ro
rp
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>
r<>r<>
rrr6
r<>r<r<r<r=<00><module>
s<>





 
0





A


@*Ya[Cc
eS,e
 

	8d

{5