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

2095 lines
128 KiB
Plaintext
Raw Normal View History

2019-11-17 12:44:16 +01:00
B
U<>]<5D>Q<00>@s<>ddlZddlZddlZddlZddlmZddlZddlZddl Z
ddl m Z m Z mZmZmZmZddlmZmZmZmZmZmZmZmZmZmZddlmZe <0A> dgdgd gd
gd gd <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?dQdd<<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>ZHdS)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
@speZdZdZdZdZdZdZdTdd <09>Zd
d <0B>Z d d <0A>Z
dUdd<0F>Z dVdd<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 Kstj<01>|<00>|dkrtjd}|dkr*d}| dkr6d} |
dkrBd}
|dkrTtjd}t<05>tjd<00>|_d|_|dk r<>|dk s<>|dk 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>dS) zQ
The following kwarg properties are supported
%(Patch)s
Nzpatch.linewidth<74>solidrr zpatch.antialiasedz hatch.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__cCs.|<00><00>}|<00><01>}|<02>|<01>}t|<03>r*|dSgS)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_pathZ to_polygonsr5)r7<00>trans<6E>pathZpolygonsr<r<r=<00> get_vertsbs 
zPatch.get_vertscCsB|dk r |St|jt<02>r |j}n|<00><03>ddkr6d}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>jdk r<16><02><00><02><00>S<00><02><01><01><01><01><02><02>j}|dk 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)
Nrc3s(|] }|<01><00>j<01>jf<02><02><03><00><01>VqdS)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>|_dS)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_fromcCs|<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_extentscCs|<00><00>tj<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_transformcCs 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_transformcCst<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_transformcCs|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_antialiasedcCs|jS)z>
Return the edge color of the :class:`Patch`.
)r])r7r<r<r=rE<00>szPatch.get_edgecolorcCs|jS)z>
Return the face color of the :class:`Patch`.
)r^)r7r<r<r=<00> get_facecolor<6F>szPatch.get_facecolorcCs|jS)z2
Return the line width in points.
)r-)r7r<r<r=rF<00>szPatch.get_linewidthcCs|jS)z'
Return the linestyle.
)<01>
_linestyle)r7r<r<r=<00> get_linestyleszPatch.get_linestylecCs"|dkrtjd}||_d|_dS)z{
Set whether to use antialiased rendering.
Parameters
----------
b : bool or None
Nzpatch.antialiasedT)r$r%rh<00>stale)r7rr<r<r=r1s
zPatch.set_antialiasedcCs\d}|dkr6tjds"|jr"|jr.tjd}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_edgecolors
  zPatch._set_edgecolorcCs||_|<00>|<01>dS)zz
Set the patch edge color.
Parameters
----------
color : color or None or 'auto'
N)r_rr)r7r8r<r<r=r*$szPatch.set_edgecolorcCs:|dkrtjd}|jr|jnd}t<04>||<02>|_d|_dS)Nzpatch.facecolorrT)r$r%r(rprr&r^rm)r7r8<00>alphar<r<r=<00>_set_facecolor/s

zPatch._set_facecolorcCs||_|<00>|<01>dS)zp
Set the patch face color.
Parameters
----------
color : color or None
N)r`rt)r7r8r<r<r=r+6szPatch.set_facecolorcCs|<00>|<01>|<00>|<01>dS)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)As
zPatch.set_colorcCs\|dk r2y t|<01>Wntk
r0td<02><01>YnXtj<03>||<01>|<00>|j<06>|<00>|j<08>dS)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=rxQs  zPatch.set_alphacCsZ|dkr$tjd}|dkr$tjd}t|<01>|_|j\}}t<05>|||j<03>\|_|_d|_ dS)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=r0cs



zPatch.set_linewidthcCsH|dkr d}||_t<01>|<01>\}}|_t<01>|||j<05>\|_|_d|_dS)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/wszPatch.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_fillcCs|jS)zreturn whether fill is set)r()r7r<r<r=<00>get_fill<6C>szPatch.get_fillcCs<|<01><00>}||jkr,td|fd|jf<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_capstylecCs|jS)zReturn the current capstyle)r<>)r7r<r<r=<00> get_capstyle<6C>szPatch.get_capstylecCs<|<01><00>}||jkr,td|fd|jf<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_joinstylecCs|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>szPatch.set_hatchcCs|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)ZisRGBArCrz3.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_pathZrestoreZ close_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 dStj|dd<03><02>Z|<00>|<01><01>D}|<00><04>}|<00><05>}|<04>|<03>}|<04><07>}||||jdr`|jnd<01>WdQRXWdQRXdS)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.drawcCs 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_extentLszPatch.get_window_extentcCs$|<00>|d<00>}|<00>|d<00>}||fS)z:
Convert x and y units for a tuple (x, y)
rr)<02>convert_xunits<74>convert_yunits)r7<00>xyrKrLr<r<r=<00>_convert_xy_unitsOszPatch._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@sleZdZdd<02>Zejddd<05><01>Zdd<07>Zdd <09>Zd
d <0B>Z d d <0A>Z
dd<0F>Z dd<11>Z dd<13>Z dd<15>Zdd<17>ZdS)<19>ShadowcCsdt|j<01>S)Nz
Shadow(%s))<02>strr<72>)r7r<r<r=<00>__str__cszShadow.__str__NcKs:t<00>|<00>||_||_|||_|_t<06><07>|_|<00> <09>dS)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__cCsz|<00>|j<01>|<00>t<03>|jjtj <00><02>|jdk r>|<00>|j<07>n8dt<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_transformcCs|jS)N)r<>)r7r<r<r=<00>_get_ox<6F>szShadow._get_oxcCs
||_dS)N)r<>)r7r<>r<r<r=<00>_set_ox<6F>szShadow._set_oxcCs|jS)N)r<>)r7r<r<r=<00>_get_oy<6F>szShadow._get_oycCs
||_dS)N)r<>)r7r<>r<r<r=<00>_set_oy<6F>szShadow._set_oycCs
|j<00><01>S)N)r<>r?)r7r<r<r=r?<00>szShadow.get_pathcCs|j<00><01>|jS)N)r<>rfr<>)r7r<r<r=rf<00>szShadow.get_patch_transformcCs|<00>|<01>t<01>||<01>dS)N)r<>rr<>)r7r<>r<r<r=r<><00>s
z Shadow.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<>eZdZdZdd<03>Zejd,dd<06><01>Zdd<08>Zd d
<EFBFBD>Z d d <0C>Z
d d<0E>Z dd<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*.
cCs$|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>szRectangle.__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
rrN) 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__cCst<00><01>S)z7
Return the vertices of the rectangle.
)r<00>unit_rectangle)r7r<r<r=r?<00>szRectangle.get_pathcCsX|<00><00>\}}}}tj<02>||||<04>}t<01><04>}|<06>|||j<06>t<01>|<05>|_|j|7_dS)aNOTE: 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_transformcCs|j|j|_dS)N)r<>r<>r<>)r7r<r<r=<00>
_update_x1<EFBFBD>szRectangle._update_x1cCs|j|j|_dS)N)r<>r<>r<>)r7r<r<r=<00>
_update_y1<EFBFBD>szRectangle._update_y1cCs<|<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_unitscCs|<00><00>|jS)N)r<>r<>)r7r<r<r=rf<00>szRectangle.get_patch_transformcCs|jS)z'Return the left coord of the rectangle.)r<>)r7r<r<r=<00>get_x<5F>szRectangle.get_xcCs|jS)z)Return the bottom coord of the rectangle.)r<>)r7r<r<r=<00>get_y<5F>szRectangle.get_ycCs |j|jfS)z3Return the left and bottom coords of the rectangle.)r<>r<>)r7r<r<r=<00>get_xyszRectangle.get_xycCs|jS)z"Return the width of the rectangle.)r<>)r7r<r<r=<00> get_widthszRectangle.get_widthcCs|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 szRectangle.set_xcCs||_|<00><01>d|_dS)z&Set the bottom coord of the rectangle.TN)r<>r<>rm)r7rLr<r<r=<00>set_yszRectangle.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&szRectangle.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,szRectangle.set_heightcGs\t|<01>dkr|d\}}}}n |\}}}}||_||_||_||_|<00><05>|<00><06>d|_dS)zj
Set the bounds of the rectangle: l,b,w,h
ACCEPTS: (left, bottom, width, height)
rrTN)r5r<>r<>r<>r<>r<>r<>rm)r7<00>args<67>lr<6C>r}r<>r<r<r=<00>
set_bounds2s  zRectangle.set_boundscCs"|<00><00>\}}}}tj<02>||||<04>S)N)r<>r r<>r<>)r7r<>r<>r<>r<>r<r<r=<00>get_bboxDszRectangle.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<>eZdZdZdd<03>Zejddd<07><01>Zdd <09>Ze d
d <0B><00>Z
e
j d d <0B><00>Z
e d d<0E><00>Z e j dd<0E><00>Z e dd<11><00>Z e j dd<11><00>Z e dd<14><00>Zej dd<14><00>Zdd<17>Zdd<19>ZdS)r<>z"
A regular polygon patch.
cCs(d}||jd|jd|j|j|jfS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)<04>_xy<78> _numVerticesrH<00> _orientation)r7r<>r<r<r=r<>OszRegularPolygon.__str__<5F>rcKsH||_||_||_||_t<04>|<02>|_t<07><08>|_ |<00>
<EFBFBD>t j |f|<05>dS)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__cCs&|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_transformcCs|jS)N)r<>)r7r<r<r=r<>yszRegularPolygon.xycCs||_|<00><01>dS)N)r<>r<>)r7r<>r<r<r=r<>}scCs|jS)N)r<>)r7r<r<r=r<><00>szRegularPolygon.orientationcCs||_|<00><01>dS)N)r<>r<>)r7r<>r<r<r=r<><00>scCs|jS)N)rH)r7r<r<r=rG<00>szRegularPolygon.radiuscCs||_|<00><01>dS)N)rHr<>)r7rGr<r<r=rG<00>scCs|jS)N)r<>)r7r<r<r=<00> numvertices<65>szRegularPolygon.numverticescCs
||_dS)N)r<>)r7r<>r<r<r=r<00>scCs|jS)N)r<>)r7r<r<r=r?<00>szRegularPolygon.get_pathcCs|<00><00>|jS)N)r<>r<>)r7r<r<r=rf<00>sz"RegularPolygon.get_patch_transformN)r<>r)r<>r<>r<>r<>r<>rr<>r#r<>r<>r<><00>setterr<72>rGrr?rfr<r<r<r=r<>Ks     r<>c@s2eZdZdZdZdd<04>Zejdd<06><00>Zdd<08>Z d S)
<EFBFBD> PathPatchz)
A general polycurve path patch.
TcCs&d}|t|jj<02>ft|jjd<00><01>S)NzPathPatch%d((%g, %g) ...)r)r5r<>rR<00>tuple)r7r<>r<r<r=r<><00>szPathPatch.__str__cKstj|f|<02>||_dS)zp
*path* is a :class:`matplotlib.path.Path` object.
Valid kwargs are:
%(Patch)s
N)rr#r<>)r7rAr;r<r<r=r#<00>szPathPatch.__init__cCs|jS)N)r<>)r7r<r<r=r?<00>szPathPatch.get_pathN)
r<EFBFBD>r<>r<>r<>ror<>rr<>r#r?r<r<r<r=r<00>s
 rc@sfeZdZdZdd<03>Zejddd<06><01>Zdd<08>Zd d
<EFBFBD>Z d d <0C>Z
d d<0E>Z dd<10>Z e Z e Zee e dd<12>ZdS)r<>z"
A general polygon patch.
cCs&d}|t|jj<02>ft|jjd<00><01>S)NzPolygon%d((%g, %g) ...)r)r5r<>rRr)r7r<>r<r<r=r<><00>szPolygon.__str__TcKs"tj|f|<03>||_|<00>|<01>dS)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__cCs|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_pathcCs|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>krdSt|<01>|_|<00>|<00><03><00>d|_dS)z<>
Set if the polygon is closed
Parameters
----------
closed : bool
True if the polygon is closed
NT)rrr<>r<>rm)r7rr<r<r=<00>
set_closed<EFBFBD>s

zPolygon.set_closedcCs|jjS)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>||dgg<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)rT)
rSr<>rr5rX<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?rrr<>r<><00>_get_xyZ_set_xyr<79>r<>r<r<r<r=r<><00>s    r<>c@s`eZdZdZdd<03>Zejddd<06><01>Zdd<08>Zd d
<EFBFBD>Z d d <0C>Z
d d<0E>Z dd<10>Z dd<12>Z dd<14>ZdS)r<>z
Wedge shaped patch.
cCs0|jd|jd|j|j|j|jf}d}||S)Nrrz<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<>"sz Wedge.__str__NcKsFtj|f|<06>||_|||_|_|||_|_t<07><08>|_ |<00>
<EFBFBD>dS)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#rrr<>rrr rg<00>_patch_transform<72>_recompute_path)r7rrrrr<>r;r<r<r=r#(s 
zWedge.__init__c Cs&t|j|jd<00>dkr(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)Nihg<11>-<2D><><EFBFBD>q=)rihrr)rr)<13>absrrrrU<00>LINETO<54>arcr<63>rRrrSZvstackZhstackrQ<00> CLOSEPOLYr5r<>rr<>) r7rr<00> connectorrZv1Zv2<76>vrur<r<r=r;s" 
"$
zWedge._recompute_pathcCsd|_||_d|_dS)NT)r<>rrm)r7rr<r<r=<00>
set_centerYszWedge.set_centercCsd|_||_d|_dS)NT)r<>rrm)r7rGr<r<r=<00>
set_radius^szWedge.set_radiuscCsd|_||_d|_dS)NT)r<>rrm)r7rr<r<r=<00>
set_theta1cszWedge.set_theta1cCsd|_||_d|_dS)NT)r<>rrm)r7rr<r<r=<00>
set_theta2hszWedge.set_theta2cCsd|_||_d|_dS)NT)r<>r<>rm)r7r<>r<r<r=r<>mszWedge.set_widthcCs|jdkr|<00><01>|jS)N)r<>r)r7r<r<r=r?rs
zWedge.get_path)N)r<>r<>r<>r<>r<>rr<>r#rrrrrr<>r?r<r<r<r=r<>s r<>c
@steZdZdZdd<03>Zeddgddgddgddgd dgdd
gddgddggd d <0C>Zejdd d<0E><01>Z dd<10>Z
dd<12>Z dS)r<>z
An arrow patch.
cCsdS)NzArrow()r<)r7r<r<r=r<>}sz 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)rcKs<>tj|f|<06>t<02>||<04>}|dkr4||}||} 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)rrgN) rr#rS<00>hypotr r<>r<>Z from_valuesr<73><00>frozenr)r7rKrL<00>dx<64>dyr<79>r;<00>L<>cx<63>sxZtrans1Ztrans2Ztrans3r@r<r<r=r#<00>s 
 zArrow.__init__cCs|jS)N)r<>)r7r<r<r=r?<00>szArrow.get_pathcCs|jS)N)r)r7r<r<r=rf<00>szArrow.get_patch_transformN)r) r<>r<>r<>r<>r<>rr<>rr<>r#r?rfr<r<r<r=r<>ys   .r<>cs4eZdZdZdZdd<04>Zejd <0C>fd
d <0B> <09>Z<08>Z S) r<>zP
Like Arrow, but lets you set head width and head height independently.
TcCsdS)Nz FancyArrow()r<)r7r<r<r=r<><00>szFancyArrow.__str__<5F><5F><EFBFBD><EFBFBD><EFBFBD>MbP?FN<46>fullrc  s<>|dkrd|}|dkr 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| d k<02>r*t<00>|dd <09>|d dd <09>g<02>}n td | <00><01>| dk<03>rR|| }|| }nd\}}||g| |gg}t<00>||<19>||||f}t<07>j|fddi| <0C><02>dS)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>?rr gr<00>leftr<00>rightr'<00><><EFBFBD><EFBFBD><EFBFBD>zGot unknown shape: %s)rrrT) 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'rF)
r<EFBFBD>r<>r<>r<>ror<>rr<>r#<00> __classcell__r<r<)r4r=r<><00>sr<>z3.0<EFBFBD>FancyArrowPatch)<01> alternativec@s@eZdZdZdd<03>Zejddd<08><01>Zd d
<EFBFBD>Zd d <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*.
cCsdS)Nz YAArrow()r<)r7r<r<r=r<>*szYAArrow.__str__<5F><><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F> cKs6||_||_||_||_||_tj|f|<07>||_dS)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#-szYAArrow.__init__c
Cs<>|j\}}|j\}}|j|jjdd}|j|jjdd}|<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_pathcCst<00><01>S)N)r rg)r7r<r<r=rfiszYAArrow.get_patch_transformcCs"tt|||||f<05>\}}}}}||dkr>||||||fS||dkr^||||||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*.
rg<00><>rr*g@g<00>?r r8)rVrv<00>math<74>sqrt)r7r<>r<>rBrC<00>k<>mZpm<70>ar<61>ruZy3aZx3aZy3bZx3br<r<r=rAls  $((zYAArrow.getpointsN)r8r9r:) r<>r<>r<>r<>r<>rr<>r#r?rfrAr<r<r<r=r<>"s $r<>c@s(eZdZdZdd<03>Zejd dd<07><01>ZdS)
r<EFBFBD>z4
A polygon-approximation of a circle patch.
cCs$d}||jd|jd|j|jfS)Nz1CirclePolygon((%g, %g), radius=%g, resolution=%d)rr)r<>rHr<>)r7r<>r<r<r=r<><00>szCirclePolygon.__str__r<5F><00>cKs tj||||fddi|<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<>rN)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@sZeZdZdZdd<03>Zejddd<06><01>Zdd<08>Zd d
<EFBFBD>Z d d <0C>Z
d d<0E>Z dd<10>Z e e e <0B>ZdS)r<>z
A scale-free ellipse.
cCs,|jd|jd|j|j|jf}d}||S)Nrrz3Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s))<04>_centerr<72>r<>r<>)r7r<>r<>r<r<r=r<><00>szEllipse.__str__rcKs@tj|f|<05>||_|||_|_||_t<06><07>|_t <09>
<EFBFBD>|_ dS)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#rLr<>r<>r<>rZ unit_circler<65>r rgr)r7r<>r<>r<>r<>r;r<r<r=r#<00>s 
zEllipse.__init__cCsd|<00>|jd<00>|<00>|jd<00>f}|<00>|j<03>}|<00>|j<04>}t<05><06><00>|d|d<00><02>|j <09>j
|<01>|_ dS)aNOTE: 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.
rrg<00>?N) r<>rLr<>r<>r<>r r<>r<>Z
rotate_degr<EFBFBD>r<>r)r7rr<>r<>r<r<r=<00>_recompute_transform<72>s  zEllipse._recompute_transformcCs|jS)z6
Return the vertices of the rectangle
)r<>)r7r<r<r=r?<00>szEllipse.get_pathcCs|<00><00>|jS)N)rMr)r7r<r<r=rf<00>szEllipse.get_patch_transformcCs||_d|_dS)zs
Set the center of the ellipse.
Parameters
----------
xy : (float, float)
TN)rLrm)r7r<>r<r<r=r<00>szEllipse.set_centercCs|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#rMr?rfrrNr<>rr<r<r<r=r<><00>s  r<>c@sBeZdZdZdd<03>Zejd dd<06><01>Zdd<08>Zd d
<EFBFBD>Z e
e e<08>Z d S) r<>z
A circle patch.
cCs$|jd|jd|jf}d}||S)NrrzCircle(xy=(%g, %g), radius=%g))rrG)r7r<>r<>r<r<r=r<><00>szCircle.__str__r<5F>cKs&tj|||d|df|<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=rszCircle.set_radiuscCs
|jdS)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#rrOr<>rGr<r<r<r=r<><00>s  r<>c@s6eZdZdZdd<03>Zejd dd<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.
cCs4|jd|jd|j|j|j|j|jf}d}||S)NrrzEArc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g))rr<>r<>r<>rr)r7r<>r<>r<r<r=r<>0sz Arc.__str__<5F><00><00>v@c Ks>|<07>dd<02>}|rtd<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#rr) r7r<>r<>r<>r<>rrr;r:r<r<r=r#7s & z Arc.__init__cst|d<01>std<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>fdd <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,nn
| <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<>||}||}||||}||||}||}||} | dkrn|||}
| ||} |
| fVnx| dkr<>|dkr<>d} nd} t<00>| <09>} xRdD]J}|||| || |}
| ||t<00>|<05>| |} |
| fVq<>WdS)Ngg<00><>g<00>?)g<00>?g<00><>)rSrFr)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_linec 3s<>d}||kr||}}n
||}}||kr6||}}n
||}}||8}||8}||7}||7}xT<78>||||<03>D]B\} }
|| kr<>|krpnqp||
kr<>|krpnqp| |
fVqpWdS)Ng<4E><67>&<26> .>r<) r<>r<>r<>r<><00>epsilonZx0eZx1eZy0eZy1erKrL)r\r<r=<00>!iter_circle_intersect_on_line_seg<65>s 
 
0z3Arc.draw.<locals>.iter_circle_intersect_on_line_segNrrrr <00>FT)$<24>hasattr<74> RuntimeErrorrMr<>r<>r<>r<>rrr><00>transform_pointrrr<>rr<>r<>r r<>rSr<><00>invertedZ transformed<65>set<65>ziprRrSZarccos<6F>pirW<00>add<64>sortedrTrJrUrV)r7r<>r<>r<>rYrrZ inv_errorr^Zbox_pathZbox_path_transformZthetasZp0<70>p1r<31>r<>r<>r<>rKrLrXZ
last_thetaZ
theta1_radrYZ path_originalr<)r\r=r<>fsX2
     
(



 
 
zArc.drawN)rPrPrQ) r<>r<>r<>r<>r<>rr<>r#rr<>r<>r<r<r<r=r<>$s   -r<>Tc Cs<>|dkr 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>dS)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<>padr8g@)r<>r<>r<>r:F) <0C>copy<70>popr<70>r<><00>boundsr<73>rbr rg<00> set_clip_onr6r<>) rr<>r<>r:rjr<>r<>r<>r}r<>rr<r<r=<00> bbox_artists&
 

  

rorGc CsN|j\}}}}t||f|||dd<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)rmr<>rbrnr<>) r<>r<>r8r@r<>r<>r}r<>rr<r<r=<00> draw_bbox(s

rpr cs<>dd<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>fd 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.
cSsg|]}tdd<01>|D<00><01><01>qS)css|]}t|<01>VqdS)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 css|]}d|VqdS)<02>=Nr<)rM<00>clr<r<r=rPBsz _pprint_table.<locals>.<genexpr><3E>css|]\}}|<01>|<02>VqdS)N)<01>ljust)rMrqrvr<r<r=rPFsrcs&g|]}d<00>dd<02>t|<01><00>D<00><01><01>qS)z css|]\}}|<01>|<02>VqdS)N)rx)rMrqrvr<r<r=rPHsz+_pprint_table.<locals>.<listcomp>.<genexpr>)<02>joinre)rM<00>row)<01>col_lenr<r=rtHsrN<>
<EFBFBD> )rery<00>textwrap<61>indent)<04>tableZ leadingspaceZtable_formatstrrr<)r{r=<00> _pprint_table=s
r<>cCs<>ddl}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.
rNZClass<73>NameZAttrsz, z{}={}<7D>Nonez``%s``)<0E>inspectrh<00>items<6D>getfullargspecr#<00>defaultsryrV<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<>cCsd<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<>ryrVrh)r<>r<r<r=<00>_simpleprint_styleshsr<>c@s<eZdZdZdd<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>dd<02><02>d<03>}|d<00><02>}y|j|}Wn tk
rLtd|<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>,rzUnknown style : %scSsg|]}|<01>d<00><01>qS)ru)rW)rM<00>csr<r<r=rt<00>sz"_Style.__new__.<locals>.<listcomp>rNcSsi|]\}}t|<02>|<01>qSr<)rv)rMrGrr<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__cCs|jS)zP
A class method which returns a dictionary of available styles.
)r<>)r<>r<r<r=<00>
get_styles<EFBFBD>sz_Style.get_stylescCs
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||jf<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<>cCs.|dkrtjt||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>sr<>c@seZdZdZiZGdd<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>d e
<EFBFBD><03>Z ee<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>iZdS)<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"eZdZdZdd<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|dk rd||||}}|<00>|||||<05>}|j|j}} |dd<01>df||dd<01>df<t|| <09>S|<00>|||||<05>SdS)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*eZdZdZd<07>fdd<04> Zdd<06>Z<05>ZS)zBoxStyle.Squarez&
A simple square box.
<20>333333<33>?cs||_t<01><00><02>dS)zB
*pad*
amount of padding
N)rjr.r#)r7rj)r4r<r=r# szBoxStyle.Square.__init__c Cs<>||j}|d||d|}}||||}}||||}}||f||f||f||f||fg} tjgtjgdtjg}
t| |
<EFBFBD>S)Nr rC)rjrrUrr) r7r<>r<>r<>r<>r<>rjr<>r<>rRrQr<r<r=r<>s
"zBoxStyle.Square.transmute)r<>)r<>r<>r<>r<>r#r<>r5r<r<)r4r=<00>Squares r<>cs*eZdZdZd<07>fdd<04> Zdd<06>Z<05>ZS)zBoxStyle.CirclezA simple circle box.<2E>333333<33>?cs||_t<01><00><02>dS)z<>
Parameters
----------
pad : float
The amount of padding around the original box.
N)rjr.r#)r7rj)r4r<r=r#&szBoxStyle.Circle.__init__cCs`||j}|d||d|}}||||}}t<01>||d||dft||<04>d<00>S)Nr )rjrZcirclerr)r7r<>r<>r<>r<>r<>rjr<r<r=r<>0s

zBoxStyle.Circle.transmute)r<>)r<>r<>r<>r<>r#r<>r5r<r<)r4r=r<>#s
r<EFBFBD>cs*eZdZdZd<07>fdd<04> Zdd<06>Z<05>ZS)zBoxStyle.LArrowz"
(left) Arrow Box
<20>333333<33>?cs||_t<01><00><02>dS)N)rjr.r#)r7rj)r4r<r=r#>szBoxStyle.LArrow.__init__c
Cs||j}|d||d|}}||||}}||||}}||d} | d}
||d}||
|f||f||f||
|f||
||
f|| || f||
||
f||
|f||
|fg } tjtjtjtjtjtjtjtjtjg } t| | <0C>} | S)Ng@g<00>?gffffff<66>?)rjrrUrr)r7r<>r<>r<>r<>r<>rjr<>r<>r!<00>dxx<78>cp<63>comrAr<r<r=r<>Bs 
     
zBoxStyle.LArrow.transmute)r<>)r<>r<>r<>r<>r#r<>r5r<r<)r4r=<00>LArrow9sr<>cs*eZdZdZd<07>fdd<04> Zdd<06>Z<05>ZS)zBoxStyle.RArrowz#
(right) Arrow Box
<20>333333<33>?cst<00><00>|<01>dS)N)r.r#)r7rj)r4r<r=r#eszBoxStyle.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<>r5r<r<)r4r=<00>RArrow_sr<>cs*eZdZdZd<07>fdd<04> Zdd<06>Z<05>ZS)zBoxStyle.DArrowz$
(Double) Arrow Box
<20>333333<33>?cs||_t<01><00><02>dS)N)rjr.r#)r7rj)r4r<r=r#vszBoxStyle.DArrow.__init__c Cs$||j}|d|}||||}}||||}}||d} | d}
||d}||
|f||f|||
f|| |
|| f|||
f||f||
|f||
||
f|| || f||
||
f||
|f||
|fg } tjtjtjtjtjtjtjtjtjtjtjtjg } t| | <0C>} | S)Ng@r g<00>?gffffff<66>?)rjrrUrr)r7r<>r<>r<>r<>r<>rjr<>r<>r!r<>r<>r<>rAr<r<r=r<>zs.
   
 
zBoxStyle.DArrow.transmute)r<>)r<>r<>r<>r<>r#r<>r5r<r<)r4r=<00>DArrownsr<>cs*eZdZdZd<08>fdd<05> Zdd<07>Z<05>ZS) zBoxStyle.Roundz+
A box with round corners.
<20>333333<33>?Ncs||_||_t<02><00><03>dS)z<>
*pad*
amount of padding
*rounding_size*
rounding radius of corners. *pad* if None
N)rj<00> rounding_sizer.r#)r7rjr<>)r4r<r=r#<00>szBoxStyle.Round.__init__c Cs(||j}|jr||j}n|}|d||d|}}||||}}||||}} |||f|||f||f|||f|| |f|| f||| f||| f|| f|| |f|||f||f|||f|||fg}
tjtjtjtjtjtjtjtjtjtjtjtjtjtjg} t|
| <0B>} | S)Ng@)rjr<>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<>r5r<r<)r4r=<00>Round<6E>s r<>cs*eZdZdZd<08>fdd<05> Zdd<07>Z<05>ZS) zBoxStyle.Round4z/
Another box with round edges.
<20>333333<33>?Ncs||_||_t<02><00><03>dS)z<>
*pad*
amount of padding
*rounding_size*
rounding size of edges. *pad* if None
N)rjr<>r.r#)r7rjr<>)r4r<r=r#<00>szBoxStyle.Round4.__init__c Cs\||j}|jr||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 )rjr<>rrUZCURVE4r) r7r<>r<>r<>r<>r<>rjr<>r<>r<>r<>r<>rAr<r<r=r<><00>s,
 """"
    
zBoxStyle.Round4.transmute)r<>N)r<>r<>r<>r<>r#r<>r5r<r<)r4r=<00>Round4<64>s r<>cs2eZdZdZd
<EFBFBD>fdd<05> Zdd<07>Zdd <09>Z<06>ZS) zBoxStyle.Sawtoothz!
A sawtooth box.
<20>333333<33>?Ncs||_||_t<02><00><03>dS)z<>
*pad*
amount of padding
*tooth_size*
size of the sawtooth. pad* if None
N)rj<00>
tooth_sizer.r#)r7rjr<>)r4r<r=r# szBoxStyle.Sawtooth.__init__cCsX||j}|jdkr$|jd|}n
|j|}|d}|d|||d||}}tt<03>|||d<00><01>d} ||| }
tt<03>|||d<00><01>d} ||| } ||||||}}||||} }|f|||
dt<03>| d<00>| |f<01>}|f||||||g| ||f<01>}| f| || | || g| | |f<01>}|f||| dt<03>| d<00>||f<01>}| f| ||
dt<03>| d<00>||f<01>}|f||||||g| ||f<01>}|f||||||g| ||f<01>}|f||| dt<03>| d<00>||f<01>}t||<10>t||<12>t||<14>t||<16>|d|dff<01>}|S)Ng<00>?g@r r)rjr<><00>intrSrZarangere)r7r<>r<>r<>r<>r<>rjr<>Z tooth_size2Zdsx_nZdsxZdsy_nZdsyr<79>r<>Z bottom_saw_xZ bottom_saw_yZ right_saw_xZ right_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|dd<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<>r5r<r<)r4r=<00>Sawtooth s Jr<4A>cs*eZdZdZd<08>fdd<05> Zdd<07>Z<05>ZS) zBoxStyle.RoundtoothzA rounded tooth box.<2E>333333<33>?Ncst<00><00>||<02>dS)z<>
*pad*
amount of padding
*tooth_size*
size of the sawtooth. pad* if None
N)r.r#)r7rjr<>)r4r<r=r#x szBoxStyle.Roundtooth.__init__cCsf|<00>|||||<05>}tjt<01>|<06>|dggdd<02>}tjgtjtjgt|<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<>r5r<r<)r4r=<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=4ar<>)r<>Z ListBoxstylesc@s<>eZdZdZdZdd<04>Zejd,dd <09><01>Zejd-d
d <0B><01>Z d d <0A>Z
dd<0F>Z dd<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.
TcCs$|jjd}||j|j|j|jfS)Nz((%g, %g), width=%g, height=%g))r4r<><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
rrZcustomNz7bbox_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|dkrt<00><01>St|tj<03>s$t|<01>r,||_nt|f|<02>|_d|_dS)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
sz!FancyBboxPatch.set_mutation_scalecCs|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
sz"FancyBboxPatch.set_mutation_aspectcCs|jS)z-Return the aspect ratio of the bbox mutation.)r<>)r7r<r<r=<00>get_mutation_aspect#
sz"FancyBboxPatch.get_mutation_aspectcCs|jS)zReturn the boxstyle object.)r<>)r7r<r<r=<00> get_boxstyle'
szFancyBboxPatch.get_boxstylecCs*|<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_pathcCs|jS)z'Return the left coord of the rectangle.)r<>)r7r<r<r=r<>5
szFancyBboxPatch.get_xcCs|jS)z)Return the bottom coord of the rectangle.)r<>)r7r<r<r=r<>9
szFancyBboxPatch.get_ycCs|jS)z"Return the width of the rectangle.)r<>)r7r<r<r=r<>=
szFancyBboxPatch.get_widthcCs|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
szFancyBboxPatch.set_xcCs||_d|_dS)zq
Set the bottom coord of the rectangle.
Parameters
----------
y : float
TN)r<>rm)r7rLr<r<r=r<>P
szFancyBboxPatch.set_ycCs||_d|_dS)zc
Set the rectangle width.
Parameters
----------
w : float
TN)r<>rm)r7r}r<r<r=r<>[
szFancyBboxPatch.set_widthcCs||_d|_dS)zd
Set the rectangle height.
Parameters
----------
h : float
TN)r<>rm)r7r<>r<r<r=r<>f
szFancyBboxPatch.set_heightcGsLt|<01>dkr|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.
rrTN)r5r<>r<>r<>r<>rm)r7r<>r<>r<>r}r<>r<r<r=r<>q
s  zFancyBboxPatch.set_boundscCstj<01>|j|j|j|j<06>S)z$Return the `.Bbox` of the rectangle.)r r<>Z from_boundsr<73>r<>r<>r<>)r7r<r<r=r<><00>
szFancyBboxPatch.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<>eZdZdZiZGdd<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>d e<06><03>Z ee<04>Gd d <0A>d e<06><03>Z er<>e <0A>e<03>dee<04>iZdS)<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@s8eZdZdZGdd<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@seZdZdd<02>ZdS)z!ConnectionStyle._Base.SimpleEventcCs|\|_|_dS)N)rKrL)r7r<>r<r<r=r#<00>
sz*ConnectionStyle._Base.SimpleEvent.__init__N)r<>r<>r<>r#r<r<r<r=<00> SimpleEvent<6E>
sr<>cs<><00>r@<40>fdd<02>}yt||<04>\}}Wntk
r:|}YnX|}<01>r<><72>fdd<04>}yt||<07>\}}Wntk
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.
cstj<01>|<00>}<01><00>|<01>dS)Nr)r<>r<>r<>rZ)<02>
xy_display<EFBFBD>xy_event)<01>patchAr<r=<00>insideA<65>
s z,ConnectionStyle._Base._clip.<locals>.insideAcstj<01>|<00>}<01><00>|<01>dS)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|jd|f<01><02>}yt||<04>\}}Wntk
r>YnX|r<>t|jd|f<01><02>}yt||<06>\}}Wntk
r~YnX|S)z]
Shrink the path by fixed size (in points) with shrinkA and shrinkB.
rr)rrRrr<>)r7rA<00>shrinkA<6B>shrinkBr<42>r(r<>r)r<r<r=<00>_shrink<6E>
szConnectionStyle._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_pathZ shrunk_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"eZdZdZddd<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
||_dS)zE
*rad*
curvature of the curve.
N)<01>rad)r7r<>r<r<r=r# szConnectionStyle.Arc3.__init__cCs<>|\}}|\}}||d||d}}||||} }
|j} || |
|| | } } ||f| | f||fg}tjtjtjg}t||<0F>S)Ng@)r<>rrUr<>)r7r<>r<>r<>r<>rBrCZx12Zy12r!r"<00>fr$<00>cyrRrQr<r<r=r<> s
zConnectionStyle.Arc3.connectN)r<>)r<>r<>r<>r<>r#r<>r<r<r<r=<00>Arc3 s
r<>c@s"eZdZdZd 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>ZrcCs||_||_dS)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)
rErU<00>radiansr<73>rVr<>r rrUr<>)r7r<>r<>r<>r<>rBrC<00>cosA<73>sinA<6E>cosB<73>sinBr$r<>rRrQr<r<r=r<>H s
zConnectionStyle.Angle3.connectN)r<>r)r<>r<>r<>r<>r#r<>r<r<r<r=<00>Angle33 s
r<>c@s"eZdZdZd
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||_||_||_dS)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#c s 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 dkr<>| <0A>
| | f<02>|<0E>
tj <0B>n<>|| || }}t <0C> ||<10>}|j |}|| || }}t <0C> ||<14>}|j |}| <0A>| ||| ||f| | f| ||| ||fg<03>|<0E>tj tjtjg<03>| <0A>
||f<02>|<0E>
tj <0B>t| |<0E>S)Ng)rErUr<>r<>rVr<>r rrUr<>r<>rrSr<00>extendr<64>)r7r<>r<>r<>r<>rBrCr<>r<>r<>r<>r$r<>rRrQ<00>dx1<78>dy1Zd1<64>f1<66>dx2<78>dy2<79>d2<64>f2r<r<r=r<>t s4


 
 
 zConnectionStyle.Angle.connectN)r<>rr<>)r<>r<>r<>r<>r#r<>r<r<r<r=<00>AngleY s
rc@s"eZdZdZd 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*.
rN<>cCs"||_||_||_||_||_dS)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}tjg} |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)Nrg<00>?)rrUrrErUr<>r<>rVr<>r<>rr<>r<>rr<>)r7r<>r<>r<>r<>rBrCrRZroundedrQr<>r<><00>dr<64>r<>Zx_armBZy_armBZxpZypr!r"<00>ddr<r<r=r<><00> sZ
  
  

 

 zConnectionStyle.Arc.connect)rrNNr)r<>r<>r<>r<>r#r<>r<r<r<r=r<><00> s
r<>c@s"eZdZdZd 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||_||_||_||_dS)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> szConnectionStyle.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}t j t j t j t j g}t ||<1D>S)Ng<00>?)rE<00>atan2rrr<>rSrTrVrUrrr
rrUr)r7r<>r<>r<>r<>Zx20Zy20rBrCrr!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#%=]Hr<>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>ffrBrCr<r<r=<00>_point_along_a_lineC src@s<>eZdZdZiZGdd<03>de<05>ZGdd<05>de<06>Zeedd<07>Gdd <09>d e<07><03>Z eed
d<07>Gd d <0C>d e<07><03>Z
eed d<07>Gdd<0F>de<07><03>Z eedd<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>iZd1S)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.eZdZdZedd<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.
cCs\t|<00><01><00>}t|<01>dks<|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 rrz,'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>}|dk r<>|jdd<01>|jdd<01>}}|dd<01>df||dd<01>df<t||<06>}|<00>|||<02>\}} t<05>| <09>r<>g}
xNt|<08>D]B} | j| j} } | dd<01>df|| dd<01>df<|
<EFBFBD>t| | <0A><02>q<>W|
| fS|| fSn|<00>|||<03>SdS)z<>
The __call__ method is a thin wrapper around the transmute method
and takes care of the aspect ratio.
Nr) rrRrQrr<>rS<00>iterablerer<>)r7rAr<>rr<>rRrQZ path_shrunkZ path_mutated<65>fillable<6C> path_listr<74>rrur<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<>cs2eZdZdZd <0C>fdd<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>dS)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>endarrowr0r/<00> fillbegin<69>fillendr.r#)r7rrr r!r0r/)r4r<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>?rr)rSrrrUr)r7r<>r<>r<>r<><00> head_dist<73>cos_t<5F>sin_trr!r"Z cp_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
ggddf\}}}}|jd\}}|jd\}}|jo<>||f||fk}|r<>|<00>||||||||<03>n
ggddf\}}}}tt<02> | ||
|fg|jdd<04>||||fgg<03>|j
<EFBFBD>g}dg}| <0A>r<>|j <0B>r<>t<02> ||d|dgg<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|dgg<02>}t<02> |tj tj gg<02>}|<1B>t||<1E><02>n|<1C>d<05>|<1B>t||<18><02>||fS)Nrrr*rFT)r0r/rSrrRrr'rrr
rQr rrr<>r!)r7rAr<>rr0r/r"r#r$r<>r<>r<>r<>Zhas_begin_arrow<6F> verticesA<73>codesAZddxAZddyArBrCZx3Zy3Z 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<>r5r<r<)r4r=<00>_Curve<76> s  +r,<00>-)r<>cs eZdZdZ<03>fdd<03>Z<04>ZS)zArrowStyle.Curvez8
A simple curve without any arrow head.
cst<00>jddd<02>dS)NF)rr)r.r#)r7)r4r<r=r#N szArrowStyle.Curve.__init__)r<>r<>r<>r<>r#r5r<r<)r4r=<00>CurveH sr.z<-cs"eZdZdZd<06>fdd<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>jdd||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)rrr0r/N)r.r#)r7r0r/)r4r<r=r#W s
zArrowStyle.CurveA.__init__)r/r0)r<>r<>r<>r<>r#r5r<r<)r4r=<00>CurveAQ sr1z->cs"eZdZdZd<06>fdd<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>jdd||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)rrr0r/N)r.r#)r7r0r/)r4r<r=r#j s
zArrowStyle.CurveB.__init__)r2r3)r<>r<>r<>r<>r#r5r<r<)r4r=<00>CurveBd sr4z<->cs"eZdZdZd<06>fdd<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>jdd||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)rrr0r/N)r.r#)r7r0r/)r4r<r=r#} s
zArrowStyle.CurveAB.__init__)r5r6)r<>r<>r<>r<>r#r5r<r<)r4r=<00>CurveABw sr7z<|-cs"eZdZdZd<06>fdd<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>jdddd||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!r0r/N)r.r#)r7r0r/)r4r<r=r#<00> s
z ArrowStyle.CurveFilledA.__init__)r8r9)r<>r<>r<>r<>r#r5r<r<)r4r=<00> CurveFilledA<64> sr:z-|>cs"eZdZdZd<06>fdd<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>jdddd||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!r0r/N)r.r#)r7r0r/)r4r<r=r#<00> s
z ArrowStyle.CurveFilledB.__init__)r;r<)r<>r<>r<>r<>r#r5r<r<)r4r=<00> CurveFilledB<64> sr=z<|-|>cs"eZdZdZd<06>fdd<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>jdddd||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!r0r/N)r.r#)r7r0r/)r4r<r=r#<00> s
z!ArrowStyle.CurveFilledAB.__init__)r>r?)r<>r<>r<>r<>r#r5r<r<)r4r=<00> CurveFilledAB<41> sr@c
@s&eZdZd
dd<05>Zdd<07>Zdd <09>ZdS) zArrowStyle._BracketN<74><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?c CsJ|||_|_|||_|_|||_|_|||_|_| |
|_|_ 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~ddlm}||||||<05>\}} }
} ||||} } || | | f|| f|
| f|
| | | fg}tjtjtjtjg}||fS)Nr)<01>get_normal_points)Zmatplotlib.bezierrKrrUr)r7r<>r<>r#r$r<>r2rKr<>r<>rBrCr!r"r%r&r<r<r=<00> _get_bracket<65> s z ArrowStyle._Bracket._get_bracketc CsN|jdkr|}n|j}|jdkr&|}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)Nrrrr*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"eZdZdZd<07>fdd<06> Z<04>ZS)zArrowStyle.BracketABz:
An arrow with a bracket(]) at both ends.
<20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Nc
s t<00>jdd||||||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<>)r4r<r=r#s
zArrowStyle.BracketAB.__init__)rNrONrNrON)r<>r<>r<>r<>r#r5r<r<)r4r=<00> BracketABsrPz]-cs"eZdZdZd<07>fdd<06> Z<04>ZS)zArrowStyle.BracketAz9
An arrow with a bracket(]) at its end.
<20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Ncst<00>jdd|||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<>)r4r<r=r#;s
zArrowStyle.BracketA.__init__)rQrRN)r<>r<>r<>r<>r#r5r<r<)r4r=<00>BracketA5srSz-[cs"eZdZdZd<07>fdd<06> Z<04>ZS)zArrowStyle.BracketBz9
An arrow with a bracket([) at its end.
<20><00>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?Ncst<00>jdd|||d<03>dS)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<>)r4r<r=r#Qs
zArrowStyle.BracketB.__init__)rTrUN)r<>r<>r<>r<>r#r5r<r<)r4r=<00>BracketBKsrVz|-|cs"eZdZdZd<06>fdd<05> Z<04>ZS)zArrowStyle.BarABz6
An arrow with a bar(|) at both ends.
<20><00>?Nc
s t<00>jdd|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<>)r4r<r=r#gs
zArrowStyle.BarAB.__init__)rWNrWN)r<>r<>r<>r<>r#r5r<r<)r4r=<00>BarABasrXcs*eZdZdZd<08>fdd<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>dS)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)r0r/<00>
tail_widthr.r#)r7r0r/r[)r4r<r=r#<00>szArrowStyle.Simple.__init__cCs|<00>|<01>\}}}}}} |j|}
t|| |
<EFBFBD>} ||f||f|| fg} yt| | dd<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>d d
<EFBFBD>|D<00><01>}|d fS) Ng{<14>G<EFBFBD>z<EFBFBD>?)<01> toleranceg<00>?g@)<01>wmrrr cSsg|] \}}|<02>qSr<r<)rMrur<>r<r<r=rt<00>sz/ArrowStyle.Simple.transmute.<locals>.<listcomp>cSsg|] \}}|<01>qSr<r<)rMrur<>r<r<r=rt<00>sT)rr0rrr
rr/rr[rrrUr<>rr)r7rAr<>rr<>r<>r<>r<>rBrCr0<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<>r5r<r<)r4r=<00>Simple}srgcs*eZdZdZd<07>fdd<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>dS)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)r0r/r[r.r#)r7r0r/r[)r4r<r=r#<00>szArrowStyle.Fancy.__init__cCs|<00>|<01>\}}}}}} |j|}
||f||f|| fg} t|| |
<EFBFBD>} yt| | dd<02>\} }Wn\tk
r<EFBFBD>t|| |||
<EFBFBD>\}}d||d|| }}||f||f|| fg} | }YnX|}t|| |
d<00>} t| | dd<02>\} }| }|j|}t||ddd<07>\}}|j|}t||dddd d
<EFBFBD>\}}t|||d <00>} t| | dd<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]Zw2rrrr cSsg|] \}}|<02>qSr<r<)rMrur<>r<r<r=rt%sz.ArrowStyle.Fancy.transmute.<locals>.<listcomp>cSsg|] \}}|<01>qSr<r<)rMrur<>r<r<r=rt%sT)rr0rrr
rr/rr[rrUrr<>r)r7rAr<>rr<>r<>r<>r<>rBrCr0r_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<>r5r<r<)r4r=<00>Fancy<63>srics*eZdZdZd<08>fdd<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>dS)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)r4r<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]rrr cSsg|] \}}|<02>qSr<r<)rMrur<>r<r<r=rtQsz.ArrowStyle.Wedge.transmute.<locals>.<listcomp>cSsg|] \}}|<01>qSr<r<)rMrur<>r<r<r=rtQsT) rrr[rlrrUr<>rr)r7rAr<>rr<>r<>r<>r<>rBrCr_Zb_plusZb_minusrfr<r<r=r<>?s       zArrowStyle.Wedge.transmute)rjrk)r<>r<>r<>r<>r#r<>r5r<r<)r4r=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#OM!QY+r)rmrc@s<>eZdZdZdZdd<04>Zejd,d
d <0B><01>Zd d <0A>Z dd<0F>Z
dd<11>Z dd<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).r6a%
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.
TcCsP|jdk r4|j\\}}\}}|jjd||||fS|jjdt|j<04>fSdS)Nz((%g, %g)->(%g, %g))z(%s))<05>
_posA_posBr4r<>r<><00>_path_original)r7r<>r<>rBrCr<r<r=r<>js 
zFancyArrowPatch.__str__N<5F>simple<6C>arc3r rcKs<>|dk rtjddddd<06>|dk r4tjddddd<06>tj|f|<0F>|dk r||dk r||dkr|||g|_|dkrpd }|<00>|<06>n(|dkr<>|dkr<>|dk r<>d|_ntd
<EFBFBD><01>||_| |_|
|_ | |_
||_ |<00> |<04>| |_ | |_|<00>|<0E>dS) 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.1rrqz.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>connectionstylerr<>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_corcCs|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.|dk r||jd<|dk r$||jd<d|_dS)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.
NrrT)rnrm)r7r<>r<>r<r<r=<00> set_positions s


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|dkrt<00><01>St|tj<03>s$t|<01>r,||_nt|f|<02>|_d|_dS)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_connectionstylecCs|jS)z?
Return the :class:`ConnectionStyle` instance.
)r~)r7r<r<r=<00>get_connectionstyleQsz#FancyArrowPatch.get_connectionstylecKs<|dkrt<00><01>St|tj<03>r$||_nt|f|<02>|_d|_dS)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_arrowstylecCs|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<>zsz"FancyArrowPatch.set_mutation_scalecCs|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>sz#FancyArrowPatch.set_mutation_aspectcCs|jS)z?
Return the aspect ratio of the bbox mutation.
)r<>)r7r<r<r=r<><00>sz#FancyArrowPatch.get_mutation_aspectcCs0|<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_displaycoordrSrr r>rc<00>transform_path)r7r<>rr<r<r=r?<00>s 
zFancyArrowPatch.get_pathcCs<>|<00><00>}|jdk rx|<00>|jd<00>}|<00>|jd<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.
Nrr)r<>r<>r<>r<>)rzrnr<>r>rbrr<>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 dStj|ddd<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 rgrer^)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@sZeZdZdZdd<03>Zejdd d <0C><01>Zdd d<0E>Zdd<10>Z dd<12>Z
dd<14>Z dd<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).
cCs(d|jd|jd|jd|jdfS)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)<02>xy1<79>xy2)r7r<r<r=r<><00>szConnectionPatch.__str__Nr-rq<00><00>$@F<><00>?cKsj|dkr |}||_||_||_||_||_||_tj|fdd||| |
| | | |||||d<04>|<13><02>d|_dS)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)rr)rr)r<>r<>rvrrrwrr<>r<>r<>r<>r<>r<><00>clip_onrx) r<>r<><00>coords1<73>coords2<73>axesA<73>axesBr6r#<00>_annotation_clip)r7ZxyAZxyBZcoordsAZcoordsBr<42>r<>rvrrrwrr<>r<>r<>r<>r<>r<>r<>rxr;r<r<r=r#<00>s0BzConnectionPatch.__init__cCs:|dkr|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|d k<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>dS)z=
calculate the pixel position of given point
N<>dataz offset pointsgR@Zpolarz figure pointsrz figure pixelszfigure fractionz axes pointsz axes pixelsz axes fractionz,{} is not a valid coordinate transformation.)rSZ transDatarvr<>r<>rbr<>Zxycoordsr r?Zget_dpirSrUrVr@r<>rmZ transFigureZ transAxesrDr Z Transformr<6D>r<>)r7rKrLr<>rSr@r!r"r@rXrr<>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_clipcCs|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_clipcCs<>|<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|dkrL|jdkrL|j\}}|<00>|||j|j<04>}|j<05>|<05>sLdS|sb|dkr<>|jdkr<>|j\}}|<00>|||j|j <09>}|j dkr<>|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<>rSrJr<>r<>r<>)r7r<>r<>rKrLZxy_pixelrSr<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<>r6r<>)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)rGN)r )N)Ir<49>r<>r<>rE<00>numbersrr~ZnumpyrSZ
matplotlibr$rwrrrrrryr Zbezierr
r r r rrrrrrrArZ_define_aliasesr"rZkwdocZpatchdocrGZinterpdr6r<>r#r<>r<>r<>rr<>r<>r<>r<>r<><00>
deprecatedr<EFBFBD>r<>r<>r<>r<>rorpr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rrr6r<>r<r<r<r=<00><module>s<>  0 
A

 @*Ya[CceS,e

 8d{5