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

2321 lines
197 KiB
Text
Raw Normal View History

feat: rigorous physics revision for Paper 1 based on adversarial review
2026-06-01 22:22:35 +00:00
<EFBFBD>
<00>RjȄ<00> <00>^<00>dZddlZddlZddlZddlmZmZddlZddlm Z ddl
m Z ddl m Z ddlZddlZddlmZmZmZmZmZmZmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd
l&m'Z'dd l(m)Z)m*Z*ejVejXd gd gdgdgdgd<11><05>Gd<12>dejZ<00><00><00>Z.Gd<14>de.<2E>Z/Gd<16>de.<2E>Z0Gd<18>de.<2E>Z1Gd<1A>de.<2E>Z2Gd<1C>de2<65>Z3Gd<1E>de.<2E>Z4Gd <20>d!e.<2E>Z5Gd"<22>d#e.<2E>Z6Gd$<24>d%e4<65>Z7ejVjqd&jsejte7jv<00>xsd'jy<00>d(d<00><00>)<29>Gd*<2A>d+e1<65>Z=Gd,<2C>d-e.<2E>Z>Gd.<2E>d/e.<2E>Z?Gd0<64>d1e><3E>Z@Gd2<64>d3e><3E>ZAdGd4<64>ZBdHd5<64>ZCGd6<64>d7<64>ZDdIdd8<64>d9<64>ZEejVGd:<3A>d;eD<65><00>ZFejVGd<<3C>d=eD<65><00>ZGd><3E>ZHejVGd?<3F>d@eD<65><00>ZIGdA<64>dBe.<2E>ZJGdC<64>dDe.<2E>ZKGdE<64>dFeK<65>ZLy)Jz>
Patches are `.Artist`\s with a face color and an edge color.
<EFBFBD>N)<02>Number<65>Real)<01>SimpleNamespace)<01>
namedtuple)<01>Affine2D<32>)<08>_api<70>artist<73>cbook<6F>colors<72>
_docstring<EFBFBD>hatch<63>lines<65>
transforms)<08>NonIntersectingPathException<6F> get_cos_sin<69>get_intersection<6F> get_parallels<6C> inside_circle<6C>make_wedged_bezier2<72>)split_bezier_intersecting_with_closedpath<74>split_path_inout)<01>Path)<02> JoinStyle<6C>CapStyle<6C>aa<61>ec<65>fc<66>ls<6C>lw)<05> antialiased<65> edgecolor<6F> facecolor<6F> linestyle<6C> linewidthc <00><><00><00>eZdZdZdZdZddddddddddd<06>
<EFBFBD>fd<07>
Zd<08>Zd <09>Zd/d
<EFBFBD>Z d/d <0B>Z
d/d <0C>Z <0B>fd <0A>Z d<0E>Z d<0F>Zd<10>Zd<11>Zd<12>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Zd<19>Zd<1A>Zd<1B>Zd<1C>Z<1B>fd<1D>Zd<1E>Zd<1F>Zd <20>Zd!<21>Z e!e e<1F>Z"e#jHd"<22><00>Z%d#<23>Z&e#jHd$<24><00>Z'd%<25>Z(d&<26>Z)d'<27>Z*d(<28>Z+d)<29>Z,d*<2A>Z-e.j^d+<2B><00>Z0d,<2C>Z1d/d-<2D>Z2d.<2E>Z3<5A>xZ4S)0<>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.
rFNT)
r"r#<00>colorr%r$r!r<00>fill<6C>capstyle<6C> joinstylec
 <00><><00><01>t<00> |<00><00>|<05>d}| <09>tj} |
<EFBFBD>tj
}
t jtjd<00>|_
tjd|_ t|<08>|_ |<03>+|<01>|<02>tjd<05>|j!|<03>n"|j#|<01>|j%|<02>d|_d|_d|_|j-|<05>|j/|<04>|j1|<06>|j3|<07>|j5| <09>|j7|
<EFBFBD>t9| <0B>r|j;| <0B>yy)zW
The following kwarg properties are supported
%(Patch:kwdoc)s
N<>solidz hatch.colorzhatch.linewidthzQSetting the 'color' property will override the edgecolor or facecolor properties.r)rN)<1E>super<65>__init__r<00>buttr<00>miterr <00>to_rgba<62>mpl<70>rcParams<6D> _hatch_color<6F>_hatch_linewidth<74>bool<6F>_fillr <00> warn_external<61> set_color<6F> set_edgecolor<6F> set_facecolor<6F>
_linewidth<EFBFBD>_unscaled_dash_pattern<72> _dash_pattern<72> set_linestyle<6C> set_linewidth<74>set_antialiased<65> set_hatch<63> set_capstyle<6C> set_joinstyle<6C>len<65>_internal_update) <0A>selfr"r#r(r%r$r!rr)r*r+<00>kwargs<67> __class__s <20><>U/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/patches.pyr/zPatch.__init__0sA<00><><00>" <0E><07><18><1A> <14> <1C><1F>I<EFBFBD> <13> <1B><1F>}<7D>}<7D>H<EFBFBD> <14> <1C>!<21><0F><0F>I<EFBFBD>"<22>N<EFBFBD>N<EFBFBD>3<EFBFBD><<3C><<3C> <0A>+F<>G<><04><19> #<23> <0C> <0C>-><3E> ?<3F><04><1D><19>$<24>Z<EFBFBD><04>
<EFBFBD> <10> <1C><18>$<24> <09>(=<3D><14>"<22>"<22>=<3D>><3E> <11>N<EFBFBD>N<EFBFBD>5<EFBFBD> !<21> <10> <1E> <1E>y<EFBFBD> )<29> <10> <1E> <1E>y<EFBFBD> )<29><1B><04><0F>&/<2F><04>#<23>&<26><04><1A> <0C><1A><1A>9<EFBFBD>%<25> <0C><1A><1A>9<EFBFBD>%<25> <0C><1C><1C>[<5B>)<29> <0C><0E><0E>u<EFBFBD><1D> <0C><19><19>(<28>#<23> <0C><1A><1A>9<EFBFBD>%<25> <0E>v<EFBFBD>;<3B> <10> !<21> !<21>&<26> )<29> <17>c<00><><00>|j<00>}|j<00>}|j|<01>}t|<03>r|dSgS)u<>
Return a copy of the vertices used in this patch.
If the patch contains Bézier curves, the curves will be interpolated by
line segments. To access the curves as curves, use `get_path`.
r)<04> get_transform<72>get_path<74> to_polygonsrF)rH<00>trans<6E>path<74>polygonss rK<00> get_vertszPatch.get_vertsesC<00><00><15>"<22>"<22>$<24><05><13>}<7D>}<7D><EFBFBD><04><17>#<23>#<23>E<EFBFBD>*<2A><08> <0E>x<EFBFBD>=<3D><1B>A<EFBFBD>;<3B> <1E><11> rLc<00><><00>|<01>|St|jt<00>r|j}|S|j<00>ddk(rd}|S|j <00>}|S)N<>r)<05>
isinstance<EFBFBD>_pickerr<00> get_edgecolor<6F> get_linewidth)rH<00>radius<75>_radiuss rK<00>_process_radiuszPatch._process_radiusssd<00><00> <11> <1D><19>M<EFBFBD> <15>d<EFBFBD>l<EFBFBD>l<EFBFBD>F<EFBFBD> +<2B><1A>l<EFBFBD>l<EFBFBD>G<EFBFBD> <17><0E> <14>!<21>!<21>#<23>A<EFBFBD>&<26>!<21>+<2B><1B><07><17><0E><1F>,<2C>,<2C>.<2E><07><16>rLc<00><><00><00><01><02><00>j<00><01>rdifS<00>j<00><02><00><02>j<00>j}|<03><><EFBFBD>j<00>j}t j |tjk(<00>\}|dd}ttt j||<05>t j||<05><00>}n<11>j<00>g}t<00><01><02>fd<04>|D<00><00>}|ifS)aY
Test whether the mouse event occurred in the patch.
Parameters
----------
mouseevent : `~matplotlib.backend_bases.MouseEvent`
Where the user clicked.
radius : float, optional
Additional margin on the patch in target coordinates of
`.Patch.get_transform`. See `.Path.contains_point` for further
details.
If `None`, the default value depends on the state of the object:
- If `.Artist.get_picker` is a number, the default
is that value. This is so that picking works as expected.
- Otherwise if the edge color has a non-zero alpha, the default
is half of the linewidth. This is so that all the colored
pixels are "in" the patch.
- Finally, if the edge has 0 alpha, the default is 0. This is
so that patches without a stroked edge do not have points
outside of the filled region report as "in" due to an
invisible edge.
Returns
-------
(bool, empty dict)
FNrc3<00><><00>K<00>|];}|j<00>j<00>jf<02>j<00><00><03><00><01><00>=y<00>w<01>N)<04>contains_point<6E>x<>yrN)<05>.0<EFBFBD>subpath<74>
mouseeventr[rHs <20><><EFBFBD>rK<00> <genexpr>z!Patch.contains.<locals>.<genexpr><3E>sD<00><><00><><00>%<25><18> <14> "<22> "<22><1B><1C><1C>z<EFBFBD>|<7C>|<7C>,<2C>d<EFBFBD>.@<40>.@<40>.B<>F<EFBFBD> L<01>%<25>s<00>AA) <0C>_different_canvasr]rO<00>codes<65>vertices<65>np<6E>wherer<00>MOVETO<54>map<61>split<69>any)rHrfr[rirj<00>idxs<78>subpaths<68>insides``` rK<00>containszPatch.containss<><00><><00>> <10> !<21> !<21>*<2A> -<2D><18>"<22>9<EFBFBD> <1C><15>%<25>%<25>f<EFBFBD>-<2D><06><14> <0A> <0A><0F>%<25>%<25><05> <10> <1C><1B>}<7D>}<7D><EFBFBD>/<2F>/<2F>H<EFBFBD><17>H<EFBFBD>H<EFBFBD>U<EFBFBD>d<EFBFBD>k<EFBFBD>k<EFBFBD>1<>2<>E<EFBFBD>D<EFBFBD><17><01><02>8<EFBFBD>D<EFBFBD><1A><14>b<EFBFBD>h<EFBFBD>h<EFBFBD>x<EFBFBD><14>.<2E><02><08><08><15><04>0E<30>G<01>H<EFBFBD><1D> <0A> <0A><0F>(<28>H<EFBFBD><14>%<25>$<24>%<25>%<25><06><16>r<EFBFBD>z<EFBFBD>rLc<00><><00>|j|<02>}|j<00>j||j<00>|<02>S)a<>
Return whether the given point is inside the patch.
Parameters
----------
point : (float, float)
The point (x, y) to check, in target coordinates of
``.Patch.get_transform()``. These are display coordinates for patches
that are added to a figure or Axes.
radius : float, optional
Additional margin on the patch in target coordinates of
`.Patch.get_transform`. See `.Path.contains_point` for further
details.
If `None`, the default value depends on the state of the object:
- If `.Artist.get_picker` is a number, the default
is that value. This is so that picking works as expected.
- Otherwise if the edge color has a non-zero alpha, the default
is half of the linewidth. This is so that all the colored
pixels are "in" the patch.
- Finally, if the edge has 0 alpha, the default is 0. This is
so that patches without a stroked edge do not have points
outside of the filled region report as "in" due to an
invisible edge.
Returns
-------
bool
Notes
-----
The proper use of this method depends on the transform of the patch.
Isolated patches do not have a transform. In this case, the patch
creation coordinates and the point coordinates match. The following
example checks that the center of a circle is within the circle
>>> center = 0, 0
>>> c = Circle(center, radius=1)
>>> c.contains_point(center)
True
The convention of checking against the transformed patch stems from
the fact that this method is predominantly used to check if display
coordinates (e.g. from mouse events) are within the patch. If you want
to do the above check with data coordinates, you have to properly
transform them first:
>>> center = 0, 0
>>> c = Circle(center, radius=3)
>>> plt.gca().add_patch(c)
>>> transformed_interior_point = c.get_data_transform().transform((0, 2))
>>> c.contains_point(transformed_interior_point)
True
)r]rOrarN)rH<00>pointr[s rKrazPatch.contains_point<6E>s?<00><00>r<16>%<25>%<25>f<EFBFBD>-<2D><06><13>}<7D>}<7D><EFBFBD>-<2D>-<2D>e<EFBFBD>.2<EFBFBD>.@<40>.@<40>.B<>.4<EFBFBD>6<> 6rLc<00><><00>|j|<02>}|j<00>j||j<00>|<02>S)a<>
Return whether the given points are inside the patch.
Parameters
----------
points : (N, 2) array
The points to check, in target coordinates of
``self.get_transform()``. These are display coordinates for patches
that are added to a figure or Axes. Columns contain x and y values.
radius : float, optional
Additional margin on the patch in target coordinates of
`.Patch.get_transform`. See `.Path.contains_point` for further
details.
If `None`, the default value depends on the state of the object:
- If `.Artist.get_picker` is a number, the default
is that value. This is so that picking works as expected.
- Otherwise if the edge color has a non-zero alpha, the default
is half of the linewidth. This is so that all the colored
pixels are "in" the patch.
- Finally, if the edge has 0 alpha, the default is 0. This is
so that patches without a stroked edge do not have points
outside of the filled region report as "in" due to an
invisible edge.
Returns
-------
length-N bool array
Notes
-----
The proper use of this method depends on the transform of the patch.
See the notes on `.Patch.contains_point`.
)r]rO<00>contains_pointsrN)rH<00>pointsr[s rKrxzPatch.contains_points<74>s?<00><00>H<16>%<25>%<25>f<EFBFBD>-<2D><06><13>}<7D>}<7D><EFBFBD>.<2E>.<2E>v<EFBFBD>/3<>/A<>/A<>/C<>/5<>7<> 7rLc<00><><00><01>t<00>|<00>|<01>|j|_|j|_|j|_|j
|_|j |_|j|_|j|_|j|_ |j|j<00>|j|j<00><00>|j<00>|_yr`)r.<00> update_from<6F>
_edgecolor<EFBFBD>
_facecolor<EFBFBD>_original_edgecolor<6F>_original_facecolorr8<00>_hatchr5r>rAr=<00> set_transform<72>get_data_transform<72>is_transform_set<65> _transformSet)rH<00>otherrJs <20>rKr{zPatch.update_froms<><00><><00> <0A><07><1B>E<EFBFBD>"<22> <20>*<2A>*<2A><04><0F><1F>*<2A>*<2A><04><0F>#(<28>#<<3C>#<<3C><04> <20>#(<28>#<<3C>#<<3C><04> <20><1A>[<5B>[<5B><04>
<EFBFBD><1B>l<EFBFBD>l<EFBFBD><04> <0B>!<21>.<2E>.<2E><04><19>&+<2B>&B<>&B<><04>#<23> <0C><1A><1A>5<EFBFBD>+<2B>+<2B>,<2C> <0C><1A><1A>5<EFBFBD>3<>3<>5<>6<>#<23>3<>3<>5<><04>rLc<00>\<00>|j<00>j|j<00><00>S)zU
Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`.
<20>rO<00> get_extentsrN<00>rHs rKr<>zPatch.get_extents-s$<00><00><14>}<7D>}<7D><EFBFBD>*<2A>*<2A>4<EFBFBD>+=<3D>+=<3D>+?<3F>@<40>@rLc<00>b<00>|j<00>tjj|<00>zS)z;Return the `~.transforms.Transform` applied to the `Patch`.)<04>get_patch_transformr
<00>ArtistrNr<>s rKrNzPatch.get_transform3s%<00><00><13>'<27>'<27>)<29>F<EFBFBD>M<EFBFBD>M<EFBFBD>,G<>,G<><04>,M<>M<>MrLc<00>@<00>tjj|<00>S)zo
Return the `~.transforms.Transform` mapping data coordinates to
physical coordinates.
)r
r<>rNr<>s rKr<>zPatch.get_data_transform7s<00><00>
<16>}<7D>}<7D>*<2A>*<2A>4<EFBFBD>0<>0rLc<00>*<00>tj<00>S)aS
Return the `~.transforms.Transform` instance mapping 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>IdentityTransformr<6D>s rKr<>zPatch.get_patch_transform>s<00><00><1A>+<2B>+<2B>-<2D>-rLc<00><00>|jS)z0Return whether antialiasing is used for drawing.)<01> _antialiasedr<64>s rK<00>get_antialiasedzPatch.get_antialiasedIs<00><00><13> <20> <20> rLc<00><00>|jS)zReturn the edge color.)r|r<>s rKrYzPatch.get_edgecolorM<00> <00><00><13><EFBFBD><EFBFBD>rLc<00><00>|jS)zReturn the face color.)r}r<>s rK<00> get_facecolorzPatch.get_facecolorQr<>rLc<00><00>|jS)z Return the line width in points.)r=r<>s rKrZzPatch.get_linewidthUr<>rLc<00><00>|jS)zReturn the linestyle.)<01>
_linestyler<EFBFBD>s rK<00> get_linestylezPatch.get_linestyleYr<>rLc<00>J<00>|<01>tjd}||_d|_y)z|
Set whether to use antialiased rendering.
Parameters
----------
aa : bool or None
Nzpatch.antialiasedT)r3r4r<><00>stale)rHrs rKrBzPatch.set_antialiased]s'<00><00> <0E>:<3A><14><1C><1C>1<>2<>B<EFBFBD><1E><04><19><19><04>
rLc<00><00>d}|<01>Ctjds|jr |jrtjd}nd}d}t j
||j <00>|_|r|j|_d|_ y)NTzpatch.force_edgecolorzpatch.edgecolor<6F>noneF)
r3r4r8<00> _edge_defaultr r2<00>_alphar|r5r<>)rHr(<00>set_hatch_colors rK<00>_set_edgecolorzPatch._set_edgecolorjsm<00><00><1E><0F> <10>=<3D><13> <0C> <0C>4<>5<><1C>
<EFBFBD>
<EFBFBD>d<EFBFBD>&8<>&8<><1B> <0C> <0C>%6<>7<><05><1E><05>"'<27><0F> <20>.<2E>.<2E><15><04> <0B> <0B><<3C><04><0F> <1A> $<24><0F><0F>D<EFBFBD> <1D><19><04>
rLc<00>4<00>||_|j|<01>y)z{
Set the patch edge color.
Parameters
----------
color : :mpltype:`color` or None
N)r~r<><00>rHr(s rKr;zPatch.set_edgecolory<00><00><00>$)<29><04> <20> <0C><1B><1B>E<EFBFBD>"rLc<00><><00>|<01>tjd}|jr |jnd}t j
||<02>|_d|_y)Nzpatch.facecolorrT)r3r4r8r<>r r2r}r<>)rHr(<00>alphas rK<00>_set_facecolorzPatch._set_facecolor<6F>s@<00><00> <10>=<3D><17>L<EFBFBD>L<EFBFBD>!2<>3<>E<EFBFBD>#<23>z<EFBFBD>z<EFBFBD><04> <0B> <0B>q<EFBFBD><05> <20>.<2E>.<2E><15><05>6<><04><0F><19><04>
rLc<00>4<00>||_|j|<01>y)z{
Set the patch face color.
Parameters
----------
color : :mpltype:`color` or None
N)rr<>r<>s rKr<zPatch.set_facecolor<6F>r<>rLc<00>H<00>|j|<01>|j|<01>y)a
Set both the edgecolor and the facecolor.
Parameters
----------
c : :mpltype:`color`
See Also
--------
Patch.set_facecolor, Patch.set_edgecolor
For setting the edge or face color individually.
N)r<r;)rH<00>cs rKr:zPatch.set_color<6F>s <00><00> <0A><1A><1A>1<EFBFBD><1D> <0C><1A><1A>1<EFBFBD>rLc<00><><00><01>t<00>|<00>|<01>|j|j<00>|j |j
<00>yr`)r.<00> set_alphar<61>rr<>r~)rHr<>rJs <20>rKr<>zPatch.set_alpha<68>s8<00><><00> <0A><07><19>%<25> <20> <0C><1B><1B>D<EFBFBD>4<>4<>5<> <0C><1B><1B>D<EFBFBD>4<>4<>5rLc<00><><00>|<01>tjd}t|<01>|_t j
g|j <00>|<01><01><06>|_d|_y)zu
Set the patch linewidth in points.
Parameters
----------
w : float or None
Nzpatch.linewidthT) r3r4<00>floatr=<00>mlines<65> _scale_dashesr>r?r<><00>rH<00>ws rKrAzPatch.set_linewidth<74>sS<00><00> <0A>9<EFBFBD><13> <0C> <0C>.<2E>/<2F>A<EFBFBD><1F><01>(<28><04><0F>#<23>1<>1<>-<2D> <11> (<28> (<28>-<2D>*+<2B>-<2D><04><1A><19><04>
rLc<00><><00>|<01>d}|dvrd}||_tj|<01>|_tjg|j<00>|j
<00><01><06>|_d|_y)a<>
Set the patch linestyle.
========================================== =================
linestyle description
========================================== =================
``'-'`` or ``'solid'`` solid line
``'--'`` or ``'dashed'`` dashed line
``'-.'`` or ``'dashdot'`` dash-dotted line
``':'`` or ``'dotted'`` dotted line
``'none'``, ``'None'``, ``' '``, or ``''`` draw nothing
========================================== =================
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-)<03> <20>r<><00>NoneT)r<>r<><00>_get_dash_patternr>r<>r=r?r<>)rHrs rKr@zPatch.set_linestyle<6C>sj<00><00>2 <0E>:<3A><18>B<EFBFBD> <0A>"<22> "<22><17>B<EFBFBD><1C><04><0F>&,<2C>&><3E>&><3E>r<EFBFBD>&B<><04>#<23>#<23>1<>1<>;<3B> <11> (<28> (<28>;<3B>*.<2E>/<2F>/<2F>;<3B><04><1A><19><04>
rLc<00><><00>t|<01>|_|j|j<00>|j |j
<00>d|_y)zh
Set whether to fill the patch.
Parameters
----------
b : bool
TN)r7r8r<>rr<>r~r<><00>rH<00>bs rK<00>set_fillzPatch.set_fill<6C>s><00><00><1A>!<21>W<EFBFBD><04>
<EFBFBD> <0C><1B><1B>D<EFBFBD>4<>4<>5<> <0C><1B><1B>D<EFBFBD>4<>4<>5<><19><04>
rLc<00><00>|jS)z#Return whether the patch is filled.)r8r<>s rK<00>get_fillzPatch.get_fill<6C><00> <00><00><13>z<EFBFBD>z<EFBFBD>rLc<00>6<00>t|<01>}||_d|_y)z<>
Set the `.CapStyle`.
The default capstyle is 'round' for `.FancyArrowPatch` and 'butt' for
all other patches.
Parameters
----------
s : `.CapStyle` or %(CapStyle)s
TN)r<00> _capstyler<65>)rH<00>s<>css rKrDzPatch.set_capstyle<6C>s<00><00><16>a<EFBFBD>[<5B><02><1B><04><0E><19><04>
rLc<00>.<00>|jjS)zReturn the capstyle.)r<><00>namer<65>s rK<00> get_capstylezPatch.get_capstyles<00><00><13>~<7E>~<7E>"<22>"<22>"rLc<00>6<00>t|<01>}||_d|_y)z<>
Set the `.JoinStyle`.
The default joinstyle is 'round' for `.FancyArrowPatch` and 'miter' for
all other patches.
Parameters
----------
s : `.JoinStyle` or %(JoinStyle)s
TN)r<00>
_joinstyler<EFBFBD>)rHr<><00>jss rKrEzPatch.set_joinstyle s<00><00><17>q<EFBFBD>\<5C><02><1C><04><0F><19><04>
rLc<00>.<00>|jjS)zReturn the joinstyle.)r<>r<>r<>s rK<00> get_joinstylezPatch.get_joinstyles<00><00><13><EFBFBD><EFBFBD>#<23>#<23>#rLc<00>J<00>tj|<01>||_d|_y)a
Set the hatching pattern.
*hatch* can be one of::
/ - diagonal hatching
\ - back diagonal
| - vertical
- - horizontal
+ - crossed
x - crossed diagonal
o - small circle
O - large circle
. - dots
* - stars
Letters can be combined, in which case all the specified
hatchings are done. If same letter repeats, it increases the
density of hatching of that pattern.
Parameters
----------
hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}
TN)<04>mhatch<63>_validate_hatch_patternr<6E>r<>)rHrs rKrCzPatch.set_hatchs <00><00>4 <0F>&<26>&<26>u<EFBFBD>-<2D><1B><04> <0B><19><04>
rLc<00><00>|jS)zReturn the hatching pattern.)r<>r<>s rK<00> get_hatchzPatch.get_hatch;<00> <00><00><13>{<7B>{<7B>rLc<00><00>||_y)zSet the hatch linewidth.N<>r6)rHr s rK<00>set_hatch_linewidthzPatch.set_hatch_linewidth?s
<00><00> "<22><04>rLc<00><00>|jS)zReturn the hatch linewidth.r<>r<>s rK<00>get_hatch_linewidthzPatch.get_hatch_linewidthC<00><00><00><13>$<24>$<24>$rLc<00><><00>|jd|j<00><00>|j<00>}|j|jd<02><03>|j
}|jddk(s|j dk(rd}|j|<04>|j|j<00>|j|j<00>|j|j<00>|j|j<00>|j!|<03>|j#|j$<00>|j'|j)<00><00>|j+|j,<00>|j.rQ|j1|j.<00>|j3|j4<00>|j7|j8<00>|j;<00><00>|j<|j;<00><00>|j?<00>rddl m!}||j?<00>|<01>}|D]}|jD|g|<06><01><06><00>|jG<00>|jId<01>d |_%y)
aJ
``draw()`` helper factored out for sharing with `FancyArrowPatch`.
Configure *renderer* and the associated graphics context *gc*
from the artist properties, then repeatedly call
``renderer.draw_path(gc, *draw_path_args)`` for each tuple
*draw_path_args* in *draw_path_args_list*.
<20>patchT)<01>isRGBArVrr<>N)<01>PathEffectRendererF)&<26>
open_group<EFBFBD>get_gid<69>new_gc<67>set_foregroundr|r=r<>rA<00>
set_dashesr?rDr<>rEr<>rBr<><00> _set_gc_clip<69>set_url<72>_url<72>set_snap<61>get_snapr<70>r<>r<>rCr<>r5r<>r6<00>get_sketch_params<6D>set_sketch_params<6D>get_path_effects<74>matplotlib.patheffectsr<73><00> draw_path<74>restore<72> close_groupr<70>)rH<00>renderer<65>draw_path_args_list<73>gcr r<><00>draw_path_argss rK<00>"_draw_paths_with_artist_propertiesz(Patch._draw_paths_with_artist_propertiesGs<><00><00> <11><1B><1B>G<EFBFBD>T<EFBFBD>\<5C>\<5C>^<5E>4<> <15>_<EFBFBD>_<EFBFBD> <1E><02>
<EFBFBD><19><19>$<24>/<2F>/<2F>$<24><19>7<> <11>_<EFBFBD>_<EFBFBD><02> <0F>?<3F>?<3F>1<EFBFBD> <1D><11> "<22>d<EFBFBD>o<EFBFBD>o<EFBFBD><16>&?<3F><12>B<EFBFBD>
<EFBFBD><18><18><12><1C><15><02> <0A> <0A>t<EFBFBD>)<29>)<29>*<2A>
<EFBFBD><0F><0F><04><0E><0E>'<27>
<EFBFBD><18><18><14><1F><1F>)<29>
<EFBFBD><1A><1A>4<EFBFBD>,<2C>,<2C>-<2D> <0C><19><19>"<22><1D>
<EFBFBD>
<EFBFBD>
<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD><1D>
<EFBFBD> <0B> <0B>D<EFBFBD>M<EFBFBD>M<EFBFBD>O<EFBFBD>$<24>
<EFBFBD> <0C> <0C>T<EFBFBD>[<5B>[<5B>!<21> <0F>;<3B>;<3B> <0E>L<EFBFBD>L<EFBFBD><14><1B><1B> %<25> <0E> <1E> <1E>t<EFBFBD>0<>0<> 1<> <0E> "<22> "<22>4<EFBFBD>#8<>#8<> 9<> <0F> !<21> !<21> #<23> /<2F> <20>B<EFBFBD> <20> <20>$<24>"8<>"8<>":<3A> ;<3B> <0F> <20> <20> "<22> A<>)<29>$<24>*?<3F>*?<3F>*A<>8<EFBFBD>L<>H<EFBFBD>1<> 4<>N<EFBFBD> <1E>H<EFBFBD> <1E> <1E>r<EFBFBD> 3<>N<EFBFBD> 3<> 4<> <0B>
<EFBFBD>
<EFBFBD> <0C><10><1C><1C>W<EFBFBD>%<25><1A><04>
rLc<00>
<00>|j<00>sy|j<00>}|j<00>}|j|<02>}|j <00>}|j ||||j dr |j ndfg<01>y)NrV)<07> get_visiblerOrN<00>transform_path_non_affine<6E>
get_affiner<EFBFBD>r})rHr<>rR<00> transform<72>tpath<74>affines rK<00>drawz
Patch.drawys<><00><00><14><1F><1F>!<21> <12><13>}<7D>}<7D><EFBFBD><04><18>&<26>&<26>(<28> <09><19>3<>3<>D<EFBFBD>9<><05><1A>%<25>%<25>'<27><06> <0C>/<2F>/<2F> <14><13>V<EFBFBD>"&<26><1F><1F><11>!3<>d<EFBFBD>o<EFBFBD>o<EFBFBD><14> ?<3F> @<01> ArLc<00><00>td<01><00>)zReturn the path of this patch.<2E>Derived must override<64><01>NotImplementedErrorr<72>s rKrOzPatch.get_path<74>s<00><00>!<21>"9<>:<3A>:rLc<00>\<00>|j<00>j|j<00><00>Sr`r<>)rHr<>s rK<00>get_window_extentzPatch.get_window_extent<6E>s"<00><00><13>}<7D>}<7D><EFBFBD>*<2A>*<2A>4<EFBFBD>+=<3D>+=<3D>+?<3F>@<40>@rLc<00>Z<00>|j|d<00>}|j|d<00>}||fS)z)Convert x and y units for a tuple (x, y).rr)<02>convert_xunits<74>convert_yunits)rH<00>xyrbrcs rK<00>_convert_xy_unitszPatch._convert_xy_units<74>s3<00><00> <10> <1F> <1F><02>1<EFBFBD><05> &<26><01> <10> <1F> <1F><02>1<EFBFBD><05> &<26><01><10>!<21>t<EFBFBD> rLr`)5<>__name__<5F>
__module__<EFBFBD> __qualname__<5F>__doc__<5F>zorderr<72>r/rTr]rtrarxr{r<>rNr<>r<>r<>rYr<>rZr<>rBr<>r;r<>r<r:r<>rAr@r<>r<><00>propertyr)r <00>interpdrDr<>rEr<>rCr<>r<>r<>r<>r
<00>allow_rasterizationr<6E>rOr<>r<00> __classcell__<5F>rJs@rKr'r'sT<00><><00><08> <0F>F<EFBFBD><1A>M<EFBFBD> <20><1F><1B><1F><1F>!<21><1B><1A><1E><1F>3*<2A>j <12>
<17>2<1A>h<6<>|'7<>R6<>&A<01> N<01>1<> .<2E>!<21><1F><1F><1F><1F> <1A> <1A> #<23><1A> #<23><1E> 6<> <1A>!<1A>F <1A><1A> <14>H<EFBFBD>h<EFBFBD> '<27>D<EFBFBD><0F><17><17> <1A><18> <1A>#<23><10><17><17> <1A><18> <1A>$<24><1A><<1B>#<23>%<25>0<1B>d <0C><1F><1F>A<01> <20>A<01> ;<3B>A<01>rLr'c<00>d<00><00>eZdZd<01>Zej
dd<03><01>fd<04>
<EFBFBD>Zd<05>Zd<06>Zd<07>Z <09>fd<08>Z
<EFBFBD>xZ S) <09>Shadowc<00>"<00>d|j<00>d<02>S)NzShadow(<28>))r<>r<>s rK<00>__str__zShadow.__str__<5F>s<00><00><18><14><1A><1A> <0C>A<EFBFBD>&<26>&rLgffffff<66>?)<01>shadec <00>$<00><01>t<00>|<00><00>||_||c|_|_t j <00>|_|j|j<00>d|cxkrdkstd<03><00>td<03><00>d|z
tjtj|jj<00><00><00>z}|j||dtj |jj"tj$ <00>d<05>|<05><01>y)a
Create a shadow of the given *patch*.
By default, the shadow will have the same face color as the *patch*,
but darkened. The darkness can be controlled by *shade*.
Parameters
----------
patch : `~matplotlib.patches.Patch`
The patch to create the shadow for.
ox, oy : float
The shift of the shadow in data coordinates, scaled by a factor
of dpi/72.
shade : float, default: 0.7
How the darkness of the shadow relates to the original color. If 1, the
shadow is black, if 0, the shadow has the same color as the *patch*.
.. versionadded:: 3.8
**kwargs
Properties of the shadow patch. Supported keys are:
%(Patch:kwdoc)s
rrzshade must be between 0 and 1.<2E><00>?)r#r"r<>r N)r.r/r<><00>_ox<6F>_oyrr<00>_shadow_transformr{<00>
ValueErrorrk<00>asarrayr <00>to_rgbr<62><00>update<74> nextafterr <00>inf)rHr<><00>ox<6F>oyrrIr(rJs <20>rKr/zShadow.__init__<5F>s<><00><><00>4 <0E><07><18><1A><1A><04>
<EFBFBD><1F><12><1A><04><08>$<24>(<28>!+<2B>!4<>!4<>!6<><04><1E> <0C><18><18><14><1A><1A>$<24><10>E<EFBFBD><EFBFBD>Q<EFBFBD><EFBFBD><1C>=<3D>><3E> ><3E><1F><1C>=<3D>><3E> ><3E><12>U<EFBFBD><19>b<EFBFBD>j<EFBFBD>j<EFBFBD><16><1D><1D>t<EFBFBD>z<EFBFBD>z<EFBFBD>7O<37>7O<37>7Q<37>)R<>S<>S<><05> <0C> <0B> <0B>%<25>e<EFBFBD>c<EFBFBD>!<21>|<7C>|<7C>D<EFBFBD>J<EFBFBD>J<EFBFBD>,=<3D>,=<3D><02><06><06>w<EFBFBD>G<><1F><1E><1F> rLc<00><><00>|j|j<00>}|j|j<00>}|jj <00>j ||<03>yr`)<06>points_to_pixelsrrr<00>clear<61> translate)rHr<>r r!s rK<00>_update_transformzShadow._update_transform<72>sI<00><00> <15> &<26> &<26>t<EFBFBD>x<EFBFBD>x<EFBFBD> 0<><02> <15> &<26> &<26>t<EFBFBD>x<EFBFBD>x<EFBFBD> 0<><02> <0C><1E><1E>$<24>$<24>&<26>0<>0<><12>R<EFBFBD>8rLc<00>6<00>|jj<00>Sr`)r<>rOr<>s rKrOzShadow.get_path<74>s<00><00><13>z<EFBFBD>z<EFBFBD>"<22>"<22>$<24>$rLc<00>P<00>|jj<00>|jzSr`)r<>r<>rr<>s rKr<>zShadow.get_patch_transform<72>s <00><00><13>z<EFBFBD>z<EFBFBD>-<2D>-<2D>/<2F>$<24>2H<32>2H<32>H<>HrLc<00>F<00><01>|j|<01>t<00>|<00> |<01>yr`)r&r.r<><00>rHr<>rJs <20>rKr<>z Shadow.draw<61>s<00><><00> <0C><1E><1E>x<EFBFBD>(<28> <0A><07> <0C>X<EFBFBD>rL) rrrrr r r/r&rOr<>r<>r rs@rKrr<00>s@<00><><00>'<27><10><17><17>/2<>% <20><18>% <20>N9<>
%<25>I<01><1F>rLrc<00><00><00>eZdZdZd<02>Zej ddd<05><02>fd<06>
<EFBFBD>Zd<07>Zd<08>Z d <09>Z
e d
<EFBFBD><00>Z e jd <0B><00>Z d <0C>Zd <0A>Zd<0E>Zd<0F>Zd<10>Zd<11>Zd<12>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Zd<19>Zd<1A>Zd<1B>Ze ee<19>Z<1E>xZS)<1C> Rectanglea<65>
A rectangle defined via an anchor point *xy* and its *width* and *height*.
The rectangle extends from ``xy[0]`` to ``xy[0] + width`` in x-direction
and from ``xy[1]`` to ``xy[1] + height`` in y-direction. ::
: +------------------+
: | |
: height |
: | |
: (xy)---- width -----+
One may picture *xy* as the bottom left corner, but which corner *xy* is
actually depends on the direction of the axis and the sign of *width*
and *height*; e.g. *xy* would be the bottom right corner if the x-axis
was inverted or if *width* was negative.
c<00><><00>|j|j|j|j|jf}d}||zS)Nz5Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g))<05>_x0<78>_y0<79>_width<74>_height<68>angle<6C>rH<00>pars<72>fmts rKrzRectangle.__str__<5F>s5<00><00><13>x<EFBFBD>x<EFBFBD><14><18><18>4<EFBFBD>;<3B>;<3B><04> <0C> <0C>d<EFBFBD>j<EFBFBD>j<EFBFBD>H<><04>E<><03><12>T<EFBFBD>z<EFBFBD>rL<00>r)r2<00>rotation_pointc <00><><00><01>t<00>|<00>di|<06><01>|d|_|d|_||_||_t |<04>|_||_d|_ |j<00>y)a<>
Parameters
----------
xy : (float, float)
The anchor point.
width : float
Rectangle width.
height : float
Rectangle height.
angle : float, default: 0
Rotation in degrees anti-clockwise about the rotation point.
rotation_point : {'xy', 'center', (number, number)}, default: 'xy'
If ``'xy'``, rotate around the anchor point. If ``'center'`` rotate
around the center. If 2-tuple of number, rotate around this
coordinate.
Other Parameters
----------------
**kwargs : `~matplotlib.patches.Patch` properties
%(Patch:kwdoc)s
rr<00><00>?N<>) r.r/r.r/r0r1r<>r2r7<00>_aspect_ratio_correction<6F>_convert_units)rHr<00>width<74>heightr2r7rIrJs <20>rKr/zRectangle.__init__<5F>sb<00><><00>0 <0E><07><18>"<22>6<EFBFBD>"<22><15>a<EFBFBD>5<EFBFBD><04><08><15>a<EFBFBD>5<EFBFBD><04><08><1B><04> <0B><1D><04> <0C><1A>5<EFBFBD>\<5C><04>
<EFBFBD>,<2C><04><1B>),<2C><04>%<25> <0C><1B><1B>rLc<00>*<00>tj<00>S)z%Return the vertices of the rectangle.)r<00>unit_rectangler<65>s rKrOzRectangle.get_paths<00><00><13>"<22>"<22>$<24>$rLc<00><00>|j|j<00>}|j|j<00>}|j|j|jz<00>}|j|j|j
z<00>}||||fS)z Convert bounds of the rectangle.)rr.rr/r0r1)rH<00>x0<78>y0<79>x1<78>y1s rKr<zRectangle._convert_unitssr<00><00> <11> <20> <20><14><18><18> *<2A><02> <11> <20> <20><14><18><18> *<2A><02> <11> <20> <20><14><18><18>D<EFBFBD>K<EFBFBD>K<EFBFBD>!7<> 8<><02> <11> <20> <20><14><18><18>D<EFBFBD>L<EFBFBD>L<EFBFBD>!8<> 9<><02><11>2<EFBFBD>r<EFBFBD>2<EFBFBD>~<7E>rLc<00><><00>|j<00>}|jdk(rW|j|jz
|j|j
z
}}|j|dz z|j
|dz zf}n4|jdk(r|j|j
f}n |j}t j|<01>t j<00>j|d |d <00>jd|j<00>j|j<00>jdd|jz <00>j|<04>zS)N<>center<65>@rrr)<0E>get_bboxr7rDrBrErCr<00>BboxTransformTorr%<00>scaler;<00>
rotate_degr2)rH<00>bboxr=r>r7s rKr<>zRectangle.get_patch_transform s<00><00>
<14>}<7D>}<7D><EFBFBD><04> <0F> <1E> <1E>(<28> *<2A> <20>G<EFBFBD>G<EFBFBD>d<EFBFBD>g<EFBFBD>g<EFBFBD>-<2D>t<EFBFBD>w<EFBFBD>w<EFBFBD><14><17><17>/@<40>6<EFBFBD>E<EFBFBD>!<21>W<EFBFBD>W<EFBFBD>u<EFBFBD>r<EFBFBD>z<EFBFBD>1<>4<EFBFBD>7<EFBFBD>7<EFBFBD>V<EFBFBD>b<EFBFBD>[<5B>3H<33>H<>N<EFBFBD> <11> <20> <20>D<EFBFBD> (<28>!<21>W<EFBFBD>W<EFBFBD>d<EFBFBD>g<EFBFBD>g<EFBFBD>-<2D>N<EFBFBD>!<21>0<>0<>N<EFBFBD><19>)<29>)<29>$<24>/<2F><1B>*<2A>%<25>%<25>'<27><1A><19>N<EFBFBD>1<EFBFBD>-<2D>-<2D><0E>q<EFBFBD>0A<30>/A<>B<><16><15>q<EFBFBD>$<24>7<>7<>8<><1B><1A>D<EFBFBD>J<EFBFBD>J<EFBFBD>'<27><16><15>q<EFBFBD>!<21>d<EFBFBD>;<3B>;<3B>;<3B><<3C><1A><19>N<EFBFBD> ,<2C>,<2C> ,rLc<00><00>|jS)z The rotation point of the patch.)<01>_rotation_pointr<74>s rKr7zRectangle.rotation_point5s<00><00><14>#<23>#<23>#rLc<00><><00>|dvsDt|t<00>r<t|<01>dk(r.t|dt<00>rt|dt<00>r||_yt d<05><00>)N)rGr<00>rrzC`rotation_point` must be one of {'xy', 'center', (number, number)}.)rW<00>tuplerFrrOr)rH<00>values rKr7zRectangle.rotation_point:sW<00><00> <10>$<24> $<24><1A>5<EFBFBD>%<25>(<28>S<EFBFBD><15>Z<EFBFBD>1<EFBFBD>_<EFBFBD><1A>5<EFBFBD><11>8<EFBFBD>T<EFBFBD>*<2A>z<EFBFBD>%<25><01>(<28>D<EFBFBD>/I<>#(<28>D<EFBFBD> <20><1C>C<01>D<01> DrLc<00><00>|jS)z,Return the left coordinate of the rectangle.)r.r<>s rK<00>get_xzRectangle.get_xE<00> <00><00><13>x<EFBFBD>x<EFBFBD>rLc<00><00>|jS)z.Return the bottom coordinate of the rectangle.)r/r<>s rK<00>get_yzRectangle.get_yIrVrLc<00>2<00>|j|jfS)z>Return the left and bottom coords of the rectangle as a tuple.)r.r/r<>s rK<00>get_xyzRectangle.get_xyMs<00><00><13>x<EFBFBD>x<EFBFBD><14><18><18>!<21>!rLc<00>D<00>|j<00>jgd<01><01>S)zc
Return the corners of the rectangle, moving anti-clockwise from
(x0, y0).
)<04>rr<00>rr<00>rr<00>rr<00>r<>r<>r<>s rK<00> get_cornerszRectangle.get_cornersQs#<00><00>
<14>'<27>'<27>)<29>3<>3<> ,<2C>.<2E> .rLc<00>@<00>|j<00>jd<01>S)z#Return the centre of the rectangle.)rrr`r<>s rK<00>
get_centerzRectangle.get_centerYs<00><00><13>'<27>'<27>)<29>3<>3<>J<EFBFBD>?<3F>?rLc<00><00>|jS<00>z"Return the width of the rectangle.<2E>r0r<>s rK<00> get_widthzRectangle.get_width]r<>rLc<00><00>|jS<00>z#Return the height of the rectangle.<2E>r1r<>s rK<00>
get_heightzRectangle.get_heighta<00> <00><00><13>|<7C>|<7C>rLc<00><00>|jS)z"Get the rotation angle in degrees.<2E>r2r<>s rK<00> get_anglezRectangle.get_angleer<>rLc<00> <00>||_d|_y)z)Set the left coordinate of the rectangle.TN)r.r<><00>rHrbs rK<00>set_xzRectangle.set_xi<00><00><00><14><04><08><19><04>
rLc<00> <00>||_d|_y)z+Set the bottom coordinate of the rectangle.TN)r/r<><00>rHrcs rK<00>set_yzRectangle.set_ynrsrLc<00> <00>||_d|_y)zs
Set the rotation angle in degrees.
The rotation is performed anti-clockwise around *xy*.
TN)r2r<><00>rHr2s rK<00> set_anglezRectangle.set_angless<00><00> <1B><04>
<EFBFBD><19><04>
rLc<00>0<00>|\|_|_d|_y)z<>
Set the left and bottom coordinates of the rectangle.
Parameters
----------
xy : (float, float)
TN)r.r/r<><00>rHrs rK<00>set_xyzRectangle.set_xy|s<00><00> <20><1A><04><08>$<24>(<28><19><04>
rLc<00> <00>||_d|_y)zSet the width of the rectangle.TN<54>r0r<>r<>s rK<00> set_widthzRectangle.set_width<74>s<00><00><17><04> <0B><19><04>
rLc<00> <00>||_d|_y)z Set the height of the rectangle.TN<54>r1r<><00>rH<00>hs rK<00>
set_heightzRectangle.set_height<68>s<00><00><18><04> <0C><19><04>
rLc<00><><00>t|<01>dk(r |d\}}}}n|\}}}}||_||_||_||_d|_y)a@
Set the bounds of the rectangle as *left*, *bottom*, *width*, *height*.
The values may be passed as separate parameters or as a tuple::
set_bounds(left, bottom, width, height)
set_bounds((left, bottom, width, height))
.. ACCEPTS: (left, bottom, width, height)
rrTN)rFr.r/r0r1r<><00>rH<00>args<67>lr<6C>r<>r<>s rK<00>
set_boundszRectangle.set_bounds<64>sP<00><00> <0F>t<EFBFBD>9<EFBFBD><01>><3E><1D>a<EFBFBD><17>J<EFBFBD>A<EFBFBD>q<EFBFBD>!<21>Q<EFBFBD><1D>J<EFBFBD>A<EFBFBD>q<EFBFBD>!<21>Q<EFBFBD><14><04><08><14><04><08><17><04> <0B><18><04> <0C><19><04>
rLc<00>V<00>tjj|j<00><00>S<00>zReturn the `.Bbox`.)r<00>Bbox<6F> from_extentsr<r<>s rKrIzRectangle.get_bbox<6F>s <00><00><19><EFBFBD><EFBFBD>+<2B>+<2B>T<EFBFBD>-@<40>-@<40>-B<>C<>CrL) rrrrrr r r/rOr<r<>r
r7<00>setterrUrXrZrarcrgrkrorrrvryr|rr<>r<>rIrr rs@rKr,r,<00>s<><00><><00><08>$<1A>
<10><17><17><1A>4<EFBFBD>%<1E><18>%<1E>N%<25><1E>,<2C>*<0E>$<24><0E>$<24><14><1A><1A>D<01><1B>D<01><18><18>"<22>.<2E>@<01><1B><1C><1A><1A>
<1A>
<1A> <1A><1A>
<1A>
<1A>*D<01>
<12>&<26>&<26> !<21>BrLr,c<00>Z<00><00>eZdZdZd<02>Zej ddd<05><02>fd<06>
<EFBFBD>Zd<07>Zd<08>Z <09>xZ
S) <09>RegularPolygonzA regular polygon patch.c<00><><00>d}||jd|jd|j|j|jfzS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)r<00> numverticesr[<00> orientation<6F>rHr<>s rKrzRegularPolygon.__str__<5F>sD<00><00> E<><01><10>D<EFBFBD>G<EFBFBD>G<EFBFBD>A<EFBFBD>J<EFBFBD><04><07><07><01>
<EFBFBD>D<EFBFBD>,<<3C>,<<3C>d<EFBFBD>k<EFBFBD>k<EFBFBD><18>$<24>$<24>&<26>&<26> &rL<00>r<00>r[r<>c <00><><00><01>||_||_||_||_t j
|<02>|_tj<00>|_ t<00>|<00>,di|<05><01>y)a<>
Parameters
----------
xy : (float, float)
The center position.
numVertices : int
The number of vertices.
radius : float
The distance from the center to each of the vertices.
orientation : float
The polygon rotation angle (in radians).
**kwargs
`Patch` properties:
%(Patch:kwdoc)s
Nr:) rr<>r<>r[r<00>unit_regular_polygon<6F>_pathrr<00>_patch_transformr.r/)rHr<00> numVerticesr[r<>rIrJs <20>rKr/zRegularPolygon.__init__<5F>sV<00><><00>.<15><04><07>&<26><04><18>&<26><04><18><1C><04> <0B><19>.<2E>.<2E>{<7B>;<3B><04>
<EFBFBD> *<2A> 3<> 3<> 5<><04><1D> <0A><07><18>"<22>6<EFBFBD>"rLc<00><00>|jSr`<00>r<>r<>s rKrOzRegularPolygon.get_path<74><00> <00><00><13>z<EFBFBD>z<EFBFBD>rLc<00><><00>|jj<00>j|j<00>j |j
<00>j |j<00>Sr`)r<>r$rKr[<00>rotater<65>r%rr<>s rKr<>z"RegularPolygon.get_patch_transform<72>sK<00><00><17>t<EFBFBD>$<24>$<24>*<2A>*<2A>,<2C> <12>U<EFBFBD>4<EFBFBD>;<3B>;<3B> <1F> <13>V<EFBFBD>D<EFBFBD>$<24>$<24> %<25> <16>Y<EFBFBD><04><07><07>!<21> !rL) rrrrrr r r/rOr<>r rs@rKr<>r<><00>s4<00><><00>"<22>&<26>
<10><17><17><19>q<EFBFBD>#<23><18>#<23><<1A>!rLr<>c<00>V<00><00>eZdZdZdZd<03>Zej<00>fd<04><08>Zd<05>Z d<06>Z
<EFBFBD>xZ S)<07> PathPatchzA general polycurve path patch.Tc<00><><00>d}|t|jj<00>gt|jjd<00><00><01>zS)NzPathPatch%d((%g, %g) ...)r)rFr<>rjrRr<>s rKrzPathPatch.__str__<5F>s=<00><00> '<27><01><10>C<EFBFBD><04>
<EFBFBD>
<EFBFBD>+<2B>+<2B>,<2C>M<>u<EFBFBD>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>5H<35>5H<35><11>5K<35>/L<>M<>M<>MrLc <00>2<00><01>t<00>|<00>di|<02><01>||_y)zl
*path* is a `.Path` object.
Valid keyword arguments are:
%(Patch:kwdoc)s
Nr:)r.r/r<>)rHrRrIrJs <20>rKr/zPathPatch.__init__<5F>s<00><><00> <0E><07><18>"<22>6<EFBFBD>"<22><19><04>
rLc<00><00>|jSr`r<>r<>s rKrOzPathPatch.get_path<74>r<>rLc<00><00>||_yr`r<>)rHrRs rK<00>set_pathzPathPatch.set_path<74>s <00><00><19><04>
rL) rrrrr<>rr r r/rOr<>r rs@rKr<>r<><00>s5<00><><00>)<29><18>M<EFBFBD>N<01><10><17><17> <1A><18> <1A><1A>rLr<>c<00>`<00><00>eZdZdZdZej ddd<05><02>fd<06>
<EFBFBD>Zd<07>Zd<08>Z d
d <09>Z
<EFBFBD>xZ S) <0B> StepPatchz<68>
A path patch describing a stepwise constant function.
By default, the path is not closed and starts and stops at
baseline value.
F<>verticalr)r<><00>baselinec <00> <00><01>||_tj|<02>|_tj|<01>|_|<04>tj|<04>nd|_|j <00>t<00>|<00> |jfi|<05><01>y)a1
Parameters
----------
values : array-like
The step heights.
edges : array-like
The edge positions, with ``len(edges) == len(vals) + 1``,
between which the curve takes on vals values.
orientation : {'vertical', 'horizontal'}, default: 'vertical'
The direction of the steps. Vertical means that *values* are
along the y-axis, and edges are along the x-axis.
baseline : float, array-like or None, default: 0
The bottom value of the bounding edges or when
``fill=True``, position of lower edge. If *fill* is
True or an array is passed to *baseline*, a closed
path is drawn.
**kwargs
`Patch` properties:
%(Patch:kwdoc)s
N)
r<EFBFBD>rkr<00>_edges<65>_values<65> _baseline<6E> _update_pathr.r/r<>)rH<00>values<65>edgesr<73>r<>rIrJs <20>rKr/zStepPatch.__init__sf<00><><00>8'<27><04><18><18>j<EFBFBD>j<EFBFBD><15>'<27><04> <0B><19>z<EFBFBD>z<EFBFBD>&<26>)<29><04> <0C>19<31>1E<31><12><1A><1A>H<EFBFBD>-<2D>4<EFBFBD><04><0E> <0C><19><19><1B> <0A><07><18><14><1A><1A>.<2E>v<EFBFBD>.rLc <00><><00>tjtj|j<00><00>r t d<01><00>|jj
dz
|j j
k7r:t d|j j
<00>d|jj
<00>d<05><05><00>tjd<06>gtjdtj<00><08>g}}tj|j <00>}|j<00>"|tj|j<00>z}tj|<00>D<00>]<5D>\}}tj|j||dzd <09>}tj|j ||d <09>}|j<00>tj|dd||d
dg<03>}n<>|jjdk(r/tj|jg||jgg<03>}n<>|jjdk(rntj|j||d <09>ddd
<EFBFBD>}tj||ddd
<EFBFBD>g<02>}tj|d
d||dd|dd||d
dg<06>}n t d <0B><00>|j d k(rtj"||g<02>} ntj"||g<02>} |j%| <09>|j%tj&gtj(gt+| <09>dz
zz<00><00><01><>ttj|<01>tj|<02><00>|_y) Nz$Nan values in "edges" are disallowedrziSize mismatch between "values" and "edges". Expected `len(values) + 1 == len(edges)`, but `len(values) = z` and `len(edges) = z`.<2E>rrQr)<01>dtyperQ<00><><EFBFBD><EFBFBD><EFBFBD>zInvalid `baseline` specifiedr<64>)rk<00>isnan<61>sumr<6D>r<00>sizer<65><00>emptyr<00> code_typer<65>r <00>contiguous_regions<6E>repeat<61> concatenate<74>ndimr<6D><00> column_stack<63>appendrm<00>LINETOrFr<>)
rH<00>vertsri<00> _nan_mask<73>idx0<78>idx1rbrc<00>basers
rKr<>zStepPatch._update_path's<><00><00> <0A>8<EFBFBD>8<EFBFBD>B<EFBFBD>F<EFBFBD>F<EFBFBD>4<EFBFBD>;<3B>;<3B>'<27> (<28><1C>C<>D<> D<> <0F>;<3B>;<3B> <1B> <1B>a<EFBFBD> <1F>4<EFBFBD><<3C><<3C>#4<>#4<> 4<><1C>/<2F>/3<>|<7C>|<7C>/@<40>/@<40>.A<>B.<2E>.2<EFBFBD>k<EFBFBD>k<EFBFBD>.><3E>.><3E>-?<3F>r<EFBFBD>C<01>D<01> D<01>
<1B><08><08><16>(<28>)<29>B<EFBFBD>H<EFBFBD>H<EFBFBD>Q<EFBFBD>d<EFBFBD>n<EFBFBD>n<EFBFBD>,M<>+N<>u<EFBFBD><05><16>H<EFBFBD>H<EFBFBD>T<EFBFBD>\<5C>\<5C>*<2A> <09> <0F>><3E>><3E> %<25> <15><12><18><18>$<24>.<2E>.<2E>1<> 1<>I<EFBFBD><1F>2<>2<>I<EFBFBD>:<3A>><3E> D<01>J<EFBFBD>D<EFBFBD>$<24><12> <09> <09>$<24>+<2B>+<2B>d<EFBFBD>4<EFBFBD><01>6<EFBFBD>2<>A<EFBFBD>6<>A<EFBFBD><12> <09> <09>$<24>,<2C>,<2C>t<EFBFBD>D<EFBFBD>1<>1<EFBFBD>5<>A<EFBFBD><13>~<7E>~<7E>%<25><16>N<EFBFBD>N<EFBFBD>A<EFBFBD>b<EFBFBD>q<EFBFBD>E<EFBFBD>1<EFBFBD>a<EFBFBD><02><03>f<EFBFBD>#5<>6<><01><15><1E><1E>$<24>$<24><01>)<29><16>N<EFBFBD>N<EFBFBD>T<EFBFBD>^<5E>^<5E>$4<>a<EFBFBD>$<24>.<2E>.<2E>9I<39>#J<>K<><01><15><1E><1E>$<24>$<24><01>)<29><19>y<EFBFBD>y<EFBFBD><14><1E><1E><04>T<EFBFBD>!:<3A>A<EFBFBD>><3E>t<EFBFBD><12>t<EFBFBD>D<><04><16>N<EFBFBD>N<EFBFBD>A<EFBFBD>q<EFBFBD><14>2<EFBFBD><14>w<EFBFBD><<3C>0<><01><16>N<EFBFBD>N<EFBFBD>D<EFBFBD><12><13>I<EFBFBD>q<EFBFBD>$<24>r<EFBFBD><01>(<28>$(<28><12>!<21>H<EFBFBD>d<EFBFBD>D<EFBFBD><12><13>I<EFBFBD>$?<3F>@<01><01>!<21>!?<3F>@<40>@<40><13><1F><1F>:<3A>-<2D><17>_<EFBFBD>_<EFBFBD>a<EFBFBD><11>V<EFBFBD>,<2C><02><17>_<EFBFBD>_<EFBFBD>a<EFBFBD><11>V<EFBFBD>,<2C><02> <11>L<EFBFBD>L<EFBFBD><12> <1C> <11>L<EFBFBD>L<EFBFBD>$<24>+<2B>+<2B><1D>$<24>+<2B>+<2B><1D><03>B<EFBFBD><07><01> <09>)B<>B<> C<>' D<01>(<1A>"<22>.<2E>.<2E><15>/<2F><12><1E><1E><05>1F<31>G<><04>
rLc<00>j<00>tdd<02>}||j|j|j<00>S)z:Get `.StepPatch` values, edges and baseline as namedtuple.<2E> StairDatazvalues edges baseline)rr<>r<>r<>)rHr<>s rK<00>get_datazStepPatch.get_dataKs*<00><00><1E>{<7B>,C<>D<> <09><18><14><1C><1C>t<EFBFBD>{<7B>{<7B>D<EFBFBD>N<EFBFBD>N<EFBFBD>C<>CrLc<00><><00>|<01>|<02> |<03> td<02><00>|<01>tj|<01>|_|<02>tj|<02>|_|<03>tj|<03>|_|j <00>d|_y)a
Set `.StepPatch` values, edges and baseline.
Parameters
----------
values : 1D array-like or None
Will not update values, if passing None
edges : 1D array-like, optional
baseline : float, 1D array-like or None
Nz)Must set *values*, *edges* or *baseline*.T)rrkrr<>r<>r<>r<>r<>)rHr<>r<>r<>s rK<00>set_datazStepPatch.set_dataPss<00><00> <12>><3E>e<EFBFBD>m<EFBFBD><08>0@<40><1C>H<>I<> I<> <11> <1D><1D>:<3A>:<3A>f<EFBFBD>-<2D>D<EFBFBD>L<EFBFBD> <10> <1C><1C>*<2A>*<2A>U<EFBFBD>+<2B>D<EFBFBD>K<EFBFBD> <13> <1F><1F>Z<EFBFBD>Z<EFBFBD><08>1<>D<EFBFBD>N<EFBFBD> <0C><19><19><1B><19><04>
rL)NNN) rrrrr<>r r r/r<>r<>r<>r rs@rKr<>r<><00>s?<00><><00><08><1A>M<EFBFBD><0F><17><17>'<27>!<21> /<2F><18> /<2F>D"H<01>HD<01>
rLr<>c<00><><00><00>eZdZdZd<02>Zej dd<04><01>fd<05>
<EFBFBD>Zd<06>Zd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z e e e d <0B> <0C>Z<0E>xZS) <0A>PolygonzA general polygon patch.c<00><><00>t|jj<00>r?d}|t|jj<00>g|jjd<00><01>zSy)NzPolygon%d((%g, %g) ...)rz
Polygon0())rFr<>rjr<>s rKrzPolygon.__str__jsM<00><00> <0E>t<EFBFBD>z<EFBFBD>z<EFBFBD>"<22>"<22> #<23>)<29>A<EFBFBD><14><03>D<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F>/<2F>0<>J<>4<EFBFBD>:<3A>:<3A>3F<33>3F<33>q<EFBFBD>3I<33>J<>J<> J<>rLT<><01>closedc <00>T<00><01>t<00>|<00>di|<03><01>||_|j|<01>y)z<>
Parameters
----------
xy : (N, 2) array
closed : bool, default: True
Whether the polygon is closed (i.e., has identical start and end
points).
**kwargs
%(Patch:kwdoc)s
Nr:)r.r/<00>_closedr|)rHrr<>rIrJs <20>rKr/zPolygon.__init__qs'<00><><00> <0E><07><18>"<22>6<EFBFBD>"<22><1D><04> <0C> <0C> <0B> <0B>B<EFBFBD>rLc<00><00>|jS)zGet the `.Path` of the polygon.r<>r<>s rKrOzPolygon.get_path<74>r<>rLc<00><00>|jS)z%Return whether the polygon is closed.)r<>r<>s rK<00>
get_closedzPolygon.get_closed<65>rlrLc<00><><00>|jt|<01>k(ryt|<01>|_|j|j<00><00>d|_y)z<>
Set whether the polygon is closed.
Parameters
----------
closed : bool
True if the polygon is closed
NT)r<>r7r|rZr<>)rHr<>s rK<00>
set_closedzPolygon.set_closed<65>s;<00><00> <10><<3C><<3C>4<EFBFBD><06><<3C> '<27> <12><1B>F<EFBFBD>|<7C><04> <0C> <0C> <0B> <0B>D<EFBFBD>K<EFBFBD>K<EFBFBD>M<EFBFBD>"<22><19><04>
rLc<00>.<00>|jjS)z<>
Get the vertices of the path.
Returns
-------
(N, 2) array
The coordinates of the vertices.
)r<>rjr<>s rKrZzPolygon.get_xy<78>s<00><00><14>z<EFBFBD>z<EFBFBD>"<22>"<22>"rLc<00>n<00>tj|<01>}|j\}}|jr?|dk(s|dkDrX|d|dk7j <00>r?tj
||dgg<02>}n#|dkDr|d|dk(j <00>r|dd}t||j<00><06>|_d|_ y)a<>
Set the vertices of the polygon.
Parameters
----------
xy : (N, 2) array-like
The coordinates of the vertices.
Notes
-----
Unlike `.Path`, we do not ignore the last input vertex. If the
polygon is meant to be closed, and the last point of the polygon is not
equal to the first, we assume that the user has not explicitly passed a
``CLOSEPOLY`` vertex, and add it ourselves.
rrr<>rQNr<4E>T)
rkr<00>shaper<65>rpr<><00>allrr<>r<>)rHr<00>nverts<74>_s rKr|zPolygon.set_xy<78>s<><00><00> <10>Z<EFBFBD>Z<EFBFBD><02>^<5E><02><16>H<EFBFBD>H<EFBFBD> <09><06><01> <0F><<3C><<3C>
<16><11>{<7B>f<EFBFBD>q<EFBFBD>j<EFBFBD>b<EFBFBD><11>e<EFBFBD>r<EFBFBD>"<22>v<EFBFBD>o<EFBFBD>-B<>-B<>-D<><17>^<5E>^<5E>R<EFBFBD>"<22>Q<EFBFBD>%<25><17>M<EFBFBD>2<><02><16><01>z<EFBFBD>r<EFBFBD>!<21>u<EFBFBD><02>2<EFBFBD><06><EFBFBD>3<>3<>5<><17><03><12>W<EFBFBD><02><19>"<22>T<EFBFBD>\<5C>\<5C>2<><04>
<EFBFBD><19><04>
rLz+The vertices of the path as a (N, 2) array.)<01>doc)rrrrrr r r/rOr<>r<>rZr|r
rr rs@rKr<>r<>gsV<00><><00>"<22> <20><10><17><17>%)<29><18><18><18>"<1A><1C> <1A> #<23><1A>B
<12>&<26>&<26>C<>
E<01>BrLr<>c<00>v<00><00>eZdZdZd<02>Zej dd<04><01>fd<05>
<EFBFBD>Zd<06>Zd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z d <0B>Z d <0C>Z<0E>xZS) <0A>WedgezWedge shaped patch.c<00><><00>|jd|jd|j|j|j|jf}d}||zS)Nrrz<Wedge(center=(%g, %g), r=%g, theta1=%g, theta2=%g, width=%s))rG<00>r<>theta1<61>theta2r=r3s rKrz Wedge.__str__<5F>sF<00><00><14> <0B> <0B>A<EFBFBD><0E><04> <0B> <0B>A<EFBFBD><0E><04><06><06><14> <0B> <0B>T<EFBFBD>[<5B>[<5B>$<24>*<2A>*<2A>6<><04>L<><03><12>T<EFBFBD>z<EFBFBD>rLN<>r=c <00><><00><01>t<00>|<00>di|<06><01>||_||c|_|_||c|_|_tj<00>|_ |j<00>y)a4
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 keyword arguments are:
%(Patch:kwdoc)s
Nr:) r.r/rGr<>r=r<>r<>rr<>r<><00>_recompute_path)rHrGr<>r<>r<>r=rIrJs <20>rKr/zWedge.__init__<5F>sY<00><><00> <0E><07><18>"<22>6<EFBFBD>"<22><1C><04> <0B><1E><05><1A><04><06><04>
<EFBFBD>#)<29>6<EFBFBD> <20><04> <0B>T<EFBFBD>[<5B> *<2A> <<3C> <<3C> ><3E><04><1D> <0C><1C><1C>rLc<00> <00>t|j|jz
dz
<00>dkrd\}}tj}n(|j|j}}tj
}tj ||<02>}|j<00><>|j}|jddd<04>|j|jz
z|jz }tj||dgg<03>}g|j<00>|<03>|jdd<00>tj<00>}nCtj|jddgg<02>}g|j<00>|<03>tj<00>}t||jz|jz|<08>|_y)N<>hg<11>-<2D><><EFBFBD>q=)rr<>r<>r\r)<10>absr<73>r<>rrmr<><00>arcr=rjr<>rkr<>ri<00> CLOSEPOLYrGr<>) rHr<>r<><00> connectorr<72><00>v1<76>v2<76>vr<76>s rKr<>zWedge._recompute_path<74>s><00><00> <0E><04> <0B> <0B>d<EFBFBD>k<EFBFBD>k<EFBFBD>)<29>S<EFBFBD>0<> 1<>U<EFBFBD> :<3A>#<23>N<EFBFBD>F<EFBFBD>F<EFBFBD><1C> <0B> <0B>I<EFBFBD>!<21>[<5B>[<5B>$<24>+<2B>+<2B>F<EFBFBD>F<EFBFBD><1C> <0B> <0B>I<EFBFBD><13>h<EFBFBD>h<EFBFBD>v<EFBFBD>v<EFBFBD>&<26><03> <0F>:<3A>:<3A> !<21><15><1C><1C>B<EFBFBD><14><1C><1C>d<EFBFBD><02>d<EFBFBD>#<23>t<EFBFBD>v<EFBFBD>v<EFBFBD><04>
<EFBFBD>
<EFBFBD>':<3A>;<3B>d<EFBFBD>f<EFBFBD>f<EFBFBD>D<>B<EFBFBD><12><0E><0E><02>B<EFBFBD><16><08>1<>2<>A<EFBFBD>G<>#<23>)<29>)<29>G<>Y<EFBFBD>G<><13><19><19>1<EFBFBD>2<EFBFBD><1D>G<><04><0E><0E>G<>A<EFBFBD><13><0E><0E><03> <0C> <0C>v<EFBFBD>v<EFBFBD>.><3E>?<3F>@<40>A<EFBFBD>7<>#<23>)<29>)<29>7<>Y<EFBFBD>7<><04><0E><0E>7<>A<EFBFBD><1A>!<21>d<EFBFBD>f<EFBFBD>f<EFBFBD>*<2A>t<EFBFBD>{<7B>{<7B>2<>A<EFBFBD>6<><04>
rLc<00>.<00>d|_||_d|_y<00>NT)r<>rGr<>)rHrGs rK<00>
set_centerzWedge.set_center<00><00><00><19><04>
<EFBFBD><1C><04> <0B><19><04>
rLc<00>.<00>d|_||_d|_yr<>)r<>r<>r<><00>rHr[s rK<00>
set_radiuszWedge.set_radiuss<00><00><19><04>
<EFBFBD><17><04><06><19><04>
rLc<00>.<00>d|_||_d|_yr<>)r<>r<>r<>)rHr<>s rK<00>
set_theta1zWedge.set_theta1 r<>rLc<00>.<00>d|_||_d|_yr<>)r<>r<>r<>)rHr<>s rK<00>
set_theta2zWedge.set_theta2r<>rLc<00>.<00>d|_||_d|_yr<>)r<>r=r<><00>rHr=s rKrzWedge.set_widths<00><00><19><04>
<EFBFBD><1A><04>
<EFBFBD><19><04>
rLc<00>R<00>|j<00>|j<00>|jSr`<00>r<>r<>r<>s rKrOzWedge.get_path<00>"<00><00> <0F>:<3A>:<3A> <1D> <10> <20> <20> "<22><13>z<EFBFBD>z<EFBFBD>rL)rrrrrr r r/r<>r<>r<>r<>r<>rrOr rs@rKr<>r<><00>sK<00><><00><1D><1A> <10><17><17>;?<3F><1F><18><1F>$7<>6<1A>
<1A>
<1A>
<1A>
<1A>
rLr<>c
<00><><00><00>eZdZdZd<02>Zej ddgddgddgddgddgdd gddgg<07>Zejdd
<EFBFBD><01>fd <0B>
<EFBFBD>Z
d <0C>Z d <0A>Z dd<0E>Z <0A>xZS)<10>ArrowzAn arrow patch.c<00><00>y)NzArrow()r:r<>s rKrz Arrow.__str__$s<00><00>rLr6皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?g<><67><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>皙<EFBFBD><E79A99><EFBFBD><EFBFBD><EFBFBD>?g333333ӿr9<00>333333<33>?r<>c <00>N<00><01>t<00>|<00>di|<06><01>|j|||||<05>y)aQ
Draws an arrow from (*x*, *y*) to (*x* + *dx*, *y* + *dy*).
The width of the arrow is scaled by *width*.
Parameters
----------
x : float
x coordinate of the arrow tail.
y : float
y coordinate of the arrow tail.
dx : float
Arrow length in the x direction.
dy : float
Arrow length in the y direction.
width : float, 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 `Patch` properties:
%(Patch:kwdoc)s
See Also
--------
FancyArrow
Patch that allows independent control of the head and tail
properties.
Nr:)r.r/r<>)rHrbrc<00>dx<64>dyr=rIrJs <20>rKr/zArrow.__init__+s)<00><><00>< <0E><07><18>"<22>6<EFBFBD>"<22> <0C> <0A> <0A>a<EFBFBD><11>B<EFBFBD><02>E<EFBFBD>*rLc<00><00>|jSr`r<>r<>s rKrOzArrow.get_pathLr<>rLc<00><00>|jSr`)r<>r<>s rKr<>zArrow.get_patch_transformOs<00><00><13>$<24>$<24>$rLc<00><><00>|<01>||_|<02>||_|<03>||_|<04>||_|<05>||_t j <00>jtj|j|j<00>|j<00>jtj|j|j<00><00>j|j|j<00>j<00>|_y)a<>
Set `.Arrow` x, y, dx, dy and width.
Values left as None will not be updated.
Parameters
----------
x, y : float or None, default: None
The x and y coordinates of the arrow base.
dx, dy : float or None, default: None
The length of the arrow along x and y direction.
width : float or None, default: None
Width of full arrow tail.
N)<0F>_x<5F>_y<5F>_dx<64>_dyr0rrrKrk<00>hypotr<74><00>arctan2r%<00>frozenr<6E>)rHrbrcr r
r=s rKr<>zArrow.set_dataRs<><00><00> <0A>=<3D><17>D<EFBFBD>G<EFBFBD> <0C>=<3D><17>D<EFBFBD>G<EFBFBD> <0A>><3E><19>D<EFBFBD>H<EFBFBD> <0A>><3E><19>D<EFBFBD>H<EFBFBD> <10> <1C><1F>D<EFBFBD>K<EFBFBD> <16> <1F> <1F> !<21> <12>U<EFBFBD>2<EFBFBD>8<EFBFBD>8<EFBFBD>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>h<EFBFBD>h<EFBFBD>/<2F><14><1B><1B> =<3D> <13>V<EFBFBD>B<EFBFBD>J<EFBFBD>J<EFBFBD>t<EFBFBD>x<EFBFBD>x<EFBFBD><14><18><18>2<> 3<> <16>Y<EFBFBD>t<EFBFBD>w<EFBFBD>w<EFBFBD><04><07><07> (<28> <13>V<EFBFBD>X<EFBFBD> <0A>rL)NNNNN)rrrrrr<00>_create_closedr<64>r r r/rOr<>r<>r rs@rKrr!s}<00><><00><19><19> <20>D<EFBFBD> <1F> <1F> <0C>c<EFBFBD>
<EFBFBD>S<EFBFBD>$<24>K<EFBFBD>#<23>t<EFBFBD><1B>s<EFBFBD>D<EFBFBD>k<EFBFBD>C<EFBFBD><13>:<3A> <0C>c<EFBFBD>
<EFBFBD>S<EFBFBD>#<23>J<EFBFBD>! <20> !<21>E<EFBFBD><10><17><17>.1<EFBFBD>+<2B><18>+<2B>@<1A>%<25>rLrc <00>z<00><00>eZdZdZdZd<03>Zejdddddddd <09><07>fd
<EFBFBD>
<EFBFBD>Zdddddddd <0B>d <0C>Z d <0A>Z
<EFBFBD>xZ S)<0E>
FancyArrowzP
Like Arrow, but lets you set head width and head height independently.
Tc<00><00>y)Nz FancyArrow()r:r<>s rKrzFancyArrow.__str__{s<00><00>rLg<><67><EFBFBD><EFBFBD>MbP?FN<46>fullr)r=<00>length_includes_head<61>
head_width<EFBFBD> head_lengthr<68><00>overhang<6E>head_starts_at_zeroc <00><><00><01>||_||_||_||_||_||_||_||_| |_|
|_ | |_
|j<00>t<00> |<00>4|jfddi| <0C><01>y)av
Parameters
----------
x, y : float
The x and y coordinates of the arrow base.
dx, dy : float
The length of the arrow along x and y direction.
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.
**kwargs
`.Patch` properties:
%(Patch:kwdoc)s
r<>TN)rrrrr0<00>_length_includes_head<61> _head_width<74> _head_length<74>_shape<70> _overhang<6E>_head_starts_at_zero<72> _make_vertsr.r/r<>)rHrbrcr r
r=rrrr<>rrrIrJs <20>rKr/zFancyArrow.__init__~s~<00><><00>T<14><04><07><13><04><07><15><04><08><15><04><08><1B><04> <0B>%9<><04>"<22>%<25><04><18>'<27><04><19><1B><04> <0B>!<21><04><0E>$7<><04>!<21> <0C><18><18><1A> <0A><07><18><14><1A><1A>;<3B>D<EFBFBD>;<3B>F<EFBFBD>;rL)rbrcr r
r=rrc<00><><00>|<01>||_|<02>||_|<03>||_|<04>||_|<05>||_|<06>||_|<07>||_|j<00>|j|j<00>y)a<>
Set `.FancyArrow` x, y, dx, dy, width, head_with, and head_length.
Values left as None will not be updated.
Parameters
----------
x, y : float or None, default: None
The x and y coordinates of the arrow base.
dx, dy : float or None, default: None
The length of the arrow along x and y direction.
width : float or None, default: None
Width of full arrow tail.
head_width : float or None, default: None
Total width of the full arrow head.
head_length : float or None, default: None
Length of arrow head.
N)
rrrrr0r!r"r&r|r<>)rHrbrcr r
r=rrs rKr<>zFancyArrow.set_data<74>sy<00><00>. <0A>=<3D><17>D<EFBFBD>G<EFBFBD> <0C>=<3D><17>D<EFBFBD>G<EFBFBD> <0A>><3E><19>D<EFBFBD>H<EFBFBD> <0A>><3E><19>D<EFBFBD>H<EFBFBD> <10> <1C><1F>D<EFBFBD>K<EFBFBD> <15> !<21>)<29>D<EFBFBD> <1C> <16> "<22> +<2B>D<EFBFBD> <1D> <0C><18><18><1A> <0C> <0B> <0B>D<EFBFBD>J<EFBFBD>J<EFBFBD>rLc<00>Z<00>|j<00>d|jz}n |j}|j<00>d|z}n |j}tj|j
|j <00>}|jr|}n||z}tj|<04>dk(rtjddg<02>|_
y||}}|j|j}}tjddg| | dz g| d|z
z| dz g| | dz g| dgg<05>} |js| |dgz } |jr
| |dz dgz } |jdk(r| }
na| ddgz} |jd k(r| }
nH|jd
k(r!tj| dd| d dd<08>g<02>}
nt!d |j<00><02><02><00>|dk7r|j
|z } |j |z } nd \} } | | g| | gg}tj"|
|<0E>|j$|j
z|j&|j zgz|_
y)NrVg<00>?rrQr6r<00>leftr<74><00>rightr<00><><EFBFBD><EFBFBD><EFBFBD>zGot unknown shape: r_)r!r0r"rkrrrr r<>r<>r<>r$<00>arrayr%r#r<>r<00>dotrr)rHrr<00>distance<63>length<74>hw<68>hl<68>hsr <00>left_half_arrow<6F>coords<64>right_half_arrow<6F>cx<63>sx<73>Ms rKr&zFancyArrow._make_verts<74>sI<00><00> <0F> <1B> <1B> #<23><1A>T<EFBFBD>[<5B>[<5B><1F>J<EFBFBD><1D>)<29>)<29>J<EFBFBD> <0F> <1C> <1C> $<24><1D>
<EFBFBD>*<2A>K<EFBFBD><1E>+<2B>+<2B>K<EFBFBD><15>8<EFBFBD>8<EFBFBD>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>h<EFBFBD>h<EFBFBD>/<2F><08> <0F> %<25> %<25><1D>F<EFBFBD><1D> <0B>+<2B>F<EFBFBD> <0A>7<EFBFBD>7<EFBFBD>6<EFBFBD>?<3F>a<EFBFBD> <1F><1B><18><18>1<EFBFBD>a<EFBFBD>&<26>)<29>D<EFBFBD>J<EFBFBD> <20><1B><02>B<EFBFBD><19>^<5E>^<5E>T<EFBFBD>[<5B>[<5B><02>B<EFBFBD> <20>h<EFBFBD>h<EFBFBD><14>c<EFBFBD>
<EFBFBD><14><13>r<EFBFBD>c<EFBFBD>A<EFBFBD>g<EFBFBD><0E><14><13><01>B<EFBFBD><06><1E>"<22><13>q<EFBFBD><17>)<29><18><17>2<EFBFBD>#<23><01>'<27>"<22><18><17>!<21> <0C> (<0E><0F>O<EFBFBD><18>-<2D>-<2D><1F>K<EFBFBD><11>#3<>3<><0F><13>(<28>(<28><1F>K<EFBFBD>!<21>O<EFBFBD>Q<EFBFBD>#7<>7<><0F><13>{<7B>{<7B>f<EFBFBD>$<24>(<28><06>#2<>a<EFBFBD><12>W<EFBFBD>#<<3C> <20><17>;<3B>;<3B>'<27>)<29>-<2D>F<EFBFBD><19>[<5B>[<5B>F<EFBFBD>*<2A> <20>^<5E>^<5E>_<EFBFBD>S<EFBFBD>b<EFBFBD>-A<>-=<3D>b<EFBFBD>f<EFBFBD>"<22>f<EFBFBD>-E<>-G<01>H<01>F<EFBFBD>%<25>':<3A>4<EFBFBD>;<3B>;<3B>/<2F>%J<>K<>K<><17>1<EFBFBD>}<7D><19>X<EFBFBD>X<EFBFBD><08>(<28><02><19>X<EFBFBD>X<EFBFBD><08>(<28><02><1E><06><02>B<EFBFBD><14>b<EFBFBD><18>R<EFBFBD>C<EFBFBD><12>9<EFBFBD>%<25>A<EFBFBD><1B><16><16><06><01>*<2A><14><07><07>$<24>(<28>(<28>"<22><14><07><07>$<24>(<28>(<28>"<22>.<0E><0E>D<EFBFBD>JrL) rrrrr<>rr r r/r<>r&r rs@rKrrts]<00><><00><08><19>M<EFBFBD><1E><10><17><17><1C>5<EFBFBD>T<EFBFBD>!<21><16>!<21>%*<2A>5<<3C><18>5<<3C>n!<21>D<EFBFBD>T<EFBFBD>d<EFBFBD>$<24> <20>d<EFBFBD>& <20>P<rLr<00>
r<EFBFBD>rQ)rc<00>N<00><00>eZdZdZd<02>Zej ddd<04><01>fd<05> <0B>Z<07>xZS)<07> CirclePolygonz*A polygon-approximation of a circle patch.c<00>t<00>d}||jd|jd|j|jfzS)Nz1CirclePolygon((%g, %g), radius=%g, resolution=%d)rr)rr[r<>r<>s rKrzCirclePolygon.__str__%s5<00><00> ?<3F><01><10>D<EFBFBD>G<EFBFBD>G<EFBFBD>A<EFBFBD>J<EFBFBD><04><07><07><01>
<EFBFBD>D<EFBFBD>K<EFBFBD>K<EFBFBD><14>9I<39>9I<39>J<>J<>JrL<00>)<01>
resolutionc <00>.<00><01>t<00>|<00>||f|dd<02>|<04><01>y)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 `Circle`.
Valid keyword arguments are:
%(Patch:kwdoc)s
rr<>N<>r.r/)rHrr[r>rIrJs <20>rKr/zCirclePolygon.__init__)s,<00><><00> <0E><07><18> <0E>
<EFBFBD> D<01>#)<29>q<EFBFBD> D<01><B<> DrL<00>r<>) rrrrrr r r/r rs@rKr;r;"s1<00><><00>4<>K<01><10><17><17>D<01><1E>D<01><18>DrLr;c<00><><00><00>eZdZdZd<02>Zej dd<04><01>fd<05>
<EFBFBD>Zd<06>Zd<07>Z d<08>Z
d <09>Z d
<EFBFBD>Z e e e <0B>Zd <0B>Zd <0C>Ze ee<0F>Zd <0A>Zd<0E>Ze ee<12>Zd<0F>Zd<10>Ze ee<15>Zd<11>Zd<12>Zd<13>Z<1A>xZS)<14>EllipsezA scale-free ellipse.c<00><><00>|jd|jd|j|j|jf}d}||zS)Nrrz3Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s))<04>_centerr=r>r2r3s rKrzEllipse.__str__>s@<00><00><14> <0C> <0C>Q<EFBFBD><0F><14><1C><1C>a<EFBFBD><1F><14>
<EFBFBD>
<EFBFBD>D<EFBFBD>K<EFBFBD>K<EFBFBD><14><1A><1A>5<><04>C<><03><12>T<EFBFBD>z<EFBFBD>rLrrnc <00><><00><01>t<00>|<00>di|<05><01>||_||c|_|_||_t j<00>|_d|_ tj<00>|_ y)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 : float, default: 0
Rotation in degrees anti-clockwise.
Notes
-----
Valid keyword arguments are:
%(Patch:kwdoc)s
r9Nr:) r.r/rEr0r1<00>_angler<00> unit_circler<65>r;rr<>r<>)rHrr=r>r2rIrJs <20>rKr/zEllipse.__init__Ds^<00><><00>( <0E><07><18>"<22>6<EFBFBD>"<22><19><04> <0C>$)<29>6<EFBFBD>!<21><04> <0B>T<EFBFBD>\<5C><1B><04> <0B><19>%<25>%<25>'<27><04>
<EFBFBD> ),<2C><04>%<25> *<2A> <<3C> <<3C> ><3E><04>rLc<00><><00>|j|jd<00>|j|jd<00>f}|j|j<00>}|j|j<00>}t j <00>j|dz|dz|jz<00>j|j<00>jdd|jz <00>j|<01>|_ y)a!
Notes
-----
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.
rrrN) rrErr0r1rrrKr;rLr2r%r<>)rHrGr=r>s rK<00>_recompute_transformzEllipse._recompute_transformgs<><00><00><17>%<25>%<25>d<EFBFBD>l<EFBFBD>l<EFBFBD>1<EFBFBD>o<EFBFBD>6<><16>%<25>%<25>d<EFBFBD>l<EFBFBD>l<EFBFBD>1<EFBFBD>o<EFBFBD>6<>8<><06><14>#<23>#<23>D<EFBFBD>K<EFBFBD>K<EFBFBD>0<><05><15>$<24>$<24>T<EFBFBD>\<5C>\<5C>2<><06>!<17>
<EFBFBD> 3<> 3<> 5<> <12>U<EFBFBD>5<EFBFBD>3<EFBFBD>;<3B><06><13> <0C>t<EFBFBD>/L<>/L<> L<> M<> <17>Z<EFBFBD><04>
<EFBFBD>
<EFBFBD> #<23> <12>U<EFBFBD>1<EFBFBD>a<EFBFBD>$<24>7<>7<>7<> 8<> <16>Y<EFBFBD><06> ! <20><04>rLc<00><00>|jS)zReturn the path of the ellipse.r<>r<>s rKrOzEllipse.get_pathzr<>rLc<00>:<00>|j<00>|jSr`)rJr<>r<>s rKr<>zEllipse.get_patch_transform~s<00><00> <0C>!<21>!<21>#<23><13>$<24>$<24>$rLc<00> <00>||_d|_y)zs
Set the center of the ellipse.
Parameters
----------
xy : (float, float)
TN)rEr<>r{s rKr<>zEllipse.set_center<65>s<00><00><1A><04> <0C><19><04>
rLc<00><00>|jS)z!Return the center of the ellipse.<2E>rEr<>s rKrczEllipse.get_center<65>rlrLc<00> <00>||_d|_y)zl
Set the width of the ellipse.
Parameters
----------
width : float
TNr~r<>s rKrzEllipse.set_width<74><00><00><00><1C><04> <0B><19><04>
rLc<00><00>|jS)z2
Return the width of the ellipse.
rfr<>s rKrgzEllipse.get_width<74>s<00><00><14>{<7B>{<7B>rLc<00> <00>||_d|_y)zn
Set the height of the ellipse.
Parameters
----------
height : float
TNr<4E>)rHr>s rKr<>zEllipse.set_height<68>s<00><00><1E><04> <0C><19><04>
rLc<00><00>|jS)z!Return the height of the ellipse.rjr<>s rKrkzEllipse.get_height<68>rlrLc<00> <00>||_d|_y)zl
Set the angle of the ellipse.
Parameters
----------
angle : float
TN)rGr<>rxs rKryzEllipse.set_angle<6C>rQrLc<00><00>|jS)z Return the angle of the ellipse.<2E>rGr<>s rKrozEllipse.get_angle<6C>r<>rLc<00>D<00>|j<00>jgd<01><01>S)z<>
Return the corners of the ellipse bounding box.
The bounding box orientation is moving anti-clockwise from the
lower left corner defined before rotation.
))r<>r<>)rr<>r^)r<>rr`r<>s rKrazEllipse.get_corners<72>s#<00><00><14>'<27>'<27>)<29>3<>3<> 0<>2<> 2rLc<00><><00>|j|jkr"|j<00>jddg<02>}n!|j<00>jddg<02>}|D<00>cgc] }t |<02><00><02>c}Scc}w)z<>
Return the vertices coordinates of the ellipse.
The definition can be found `here <https://en.wikipedia.org/wiki/Ellipse>`_
.. versionadded:: 3.8
r_<00>rr<>r]<00>r<>r<00>r=r>r<>r<>rR<00>rH<00>retrbs rK<00> get_verticeszEllipse.get_vertices<65><00>h<00><00> <10>:<3A>:<3A><04> <0B> <0B> #<23><16>*<2A>*<2A>,<2C>6<>6<><06><07>7H<37>I<>C<EFBFBD><16>*<2A>*<2A>,<2C>6<>6<><06><07>7H<37>I<>C<EFBFBD>"%<25>&<26>Q<EFBFBD><05>a<EFBFBD><08>&<26>&<26><>&<26><00>!A6c<00><><00>|j|jkr"|j<00>jddg<02>}n!|j<00>jddg<02>}|D<00>cgc] }t |<02><00><02>c}Scc}w)z<>
Return the co-vertices coordinates of the ellipse.
The definition can be found `here <https://en.wikipedia.org/wiki/Ellipse>`_
.. versionadded:: 3.8
r]r[r_rZr\r]s rK<00>get_co_verticeszEllipse.get_co_vertices<65>r`ra)rrrrrr r r/rJrOr<>r<>rcr
rGrrgr=r<>rkr>ryror2rar_rcr rs@rKrCrC;s<><00><><00><1F><1A> <10><17><17>34<33> ?<3F><18> ?<3F>D <20>&<1A>%<25> <1A><1C><16>j<EFBFBD>*<2A> -<2D>F<EFBFBD> <1A><1B> <15>Y<EFBFBD> <09> *<2A>E<EFBFBD> <1A><1C><16>j<EFBFBD>*<2A> -<2D>F<EFBFBD> <1A><1B> <15>Y<EFBFBD> <09> *<2A>E<EFBFBD>2<> '<27> 'rLrCc<00><><00><00>eZdZdZej
d<11>fd<02> <09>Zd<03>Zd<04>Zd<05>Z e
e e<08>Z d<06>Z d<07>Z e
e e <0C>Zd<08>Zd <09>Ze
ee<0F>Zd
<EFBFBD>Zd <0B>Zd <0C>Zd <0A>Ze
ee<14>Zd<0E>Zd<0F>Zd<10>Z<19>xZS)<12>Annulusz
An elliptical annulus.
c <00>~<00><01>t<00>|<00>di|<05><01>|j|<02>||_||_||_d|_y)a<>
Parameters
----------
xy : (float, float)
xy coordinates of annulus centre.
r : float or (float, float)
The radius, or semi-axes:
- If float: radius of the outer circle.
- If two floats: semi-major and -minor axes of outer ellipse.
width : float
Width (thickness) of the annular ring. The width is measured inward
from the outer ellipse so that for the inner ellipse the semi-axes
are given by ``r - width``. *width* must be less than or equal to
the semi-minor axis.
angle : float, default: 0
Rotation angle in degrees (anti-clockwise from the positive
x-axis). Ignored for circular annuli (i.e., if *r* is a scalar).
**kwargs
Keyword arguments control the `Patch` properties:
%(Patch:kwdoc)s
Nr:)r.r/<00> set_radiirGr=r2r<>)rHrr<>r=r2rIrJs <20>rKr/zAnnulus.__init__<5F>s=<00><><00>2 <0E><07><18>"<22>6<EFBFBD>"<22> <0C><0E><0E>q<EFBFBD><19><18><04> <0B><1A><04>
<EFBFBD><1A><04>
<EFBFBD><19><04>
rLc<00><><00>|j|jk(r |j}n|j|jf}dg|j<00>|<01>|j<00>|j<00><01>zS)Nz.Annulus(xy=(%s, %s), r=%s, width=%s, angle=%s))<05>ar<61>rGr=r2<00>rHr<>s rKrzAnnulus.__str__s]<00><00> <0F>6<EFBFBD>6<EFBFBD>T<EFBFBD>V<EFBFBD>V<EFBFBD> <1B><14><06><06>A<EFBFBD><15><16><16><14><16><16> <20>A<EFBFBD>?<3F>9<>$<24>+<2B>+<2B>9<>q<EFBFBD>9<>$<24>*<2A>*<2A>9<>d<EFBFBD>j<EFBFBD>j<EFBFBD>9<>:<3A> :rLc<00>.<00>||_d|_d|_y)zs
Set the center of the annulus.
Parameters
----------
xy : (float, float)
NT)rEr<>r<>r{s rKr<>zAnnulus.set_centers<00><00><1A><04> <0C><19><04>
<EFBFBD><19><04>
rLc<00><00>|jS)z!Return the center of the annulus.rOr<>s rKrczAnnulus.get_center*rlrLc<00><><00>|t|j|j<00>kDr td<01><00>||_d|_d|_y)z<>
Set the width (thickness) of the annulus ring.
The width is measured inwards from the outer ellipse.
Parameters
----------
width : float
z>Width of annulus must be less than or equal to semi-minor axisNT)<07>minrir<>rr0r<>r<>r<>s rKrzAnnulus.set_width0sD<00><00> <11>3<EFBFBD>t<EFBFBD>v<EFBFBD>v<EFBFBD>t<EFBFBD>v<EFBFBD>v<EFBFBD>&<26> &<26><1C>P<>R<01> R<01><1C><04> <0B><19><04>
<EFBFBD><19><04>
rLc<00><00>|jS)z1Return the width (thickness) of the annulus ring.rfr<>s rKrgzAnnulus.get_widthBr<>rLc<00>.<00>||_d|_d|_y)zq
Set the tilt angle of the annulus.
Parameters
----------
angle : float
NT)rGr<>r<>rxs rKryzAnnulus.set_angleHs<00><00><1C><04> <0B><19><04>
<EFBFBD><19><04>
rLc<00><00>|jS)z Return the angle of the annulus.rWr<>s rKrozAnnulus.get_angleTr<>rLc<00>@<00>t|<01>|_d|_d|_y)zv
Set the semi-major axis *a* of the annulus.
Parameters
----------
a : float
NT)r<>rir<>r<>)rHris rK<00> set_semimajorzAnnulus.set_semimajorZ<00><00><00><17>q<EFBFBD><18><04><06><19><04>
<EFBFBD><19><04>
rLc<00>@<00>t|<01>|_d|_d|_y)zv
Set the semi-minor axis *b* of the annulus.
Parameters
----------
b : float
NT)r<>r<>r<>r<>r<>s rK<00> set_semiminorzAnnulus.set_semiminorfrtrLc<00><><00>tj|<01>dk(r|\|_|_n;tj|<01>dk(rt |<01>x|_|_n t d<03><00>d|_d|_y)aE
Set the semi-major (*a*) and semi-minor radii (*b*) of the annulus.
Parameters
----------
r : float or (float, float)
The radius, or semi-axes:
- If float: radius of the outer circle.
- If two floats: semi-major and -minor axes of outer ellipse.
)rQr:z(Parameter 'r' must be one or two floats.NT)rkr<>rir<>r<>rr<>r<>rjs rKrgzAnnulus.set_radiirs]<00><00> <0E>8<EFBFBD>8<EFBFBD>A<EFBFBD>;<3B>$<24> <1E><1E>N<EFBFBD>D<EFBFBD>F<EFBFBD>D<EFBFBD>F<EFBFBD> <0F>X<EFBFBD>X<EFBFBD>a<EFBFBD>[<5B>B<EFBFBD> <1E>#<23>A<EFBFBD>h<EFBFBD> &<26>D<EFBFBD>F<EFBFBD>T<EFBFBD>V<EFBFBD><1C>G<>H<> H<><19><04>
<EFBFBD><19><04>
rLc<00>2<00>|j|jfS)z:Return the semi-major and semi-minor radii of the annulus.)rir<>r<>s rK<00> get_radiizAnnulus.get_radii<69>s<00><00><13>v<EFBFBD>v<EFBFBD>t<EFBFBD>v<EFBFBD>v<EFBFBD>~<7E>rLc<00><00>tj<00>j|j||f<02><00>j |j
<00>j |j|j<00><00>j|<01>Sr`) rrrKrrLr2r%rGr<>)rHr<>rir<>s rK<00>_transform_vertszAnnulus._transform_verts<74>sl<00><00><17><13>z<EFBFBD>"<22>"<22>$<24> <12>U<EFBFBD>D<EFBFBD>*<2A>*<2A>A<EFBFBD>q<EFBFBD>6<EFBFBD>2<>4<> <17>Z<EFBFBD><04>
<EFBFBD>
<EFBFBD> #<23> <16>Y<EFBFBD><04>.<2E>.<2E>t<EFBFBD>{<7B>{<7B>;<3B>=<3D><17>Y<EFBFBD>u<EFBFBD> <1D>  rLc<00><00>tjdd<02>}|j|j|j}}}|j |j ||<03>}|j |j ddd<03>||z
||z
<00>}tj|||ddd<00>fdg<04>}tj|jtj|jddtjtjg<05>}t||<08>|_ y)Nrr<>r<>r\r)rr<>rir<>r=r{rjrk<00>vstack<63>hstackrirmr<>r<>) rHr<>rir<>r<>r<>r<>r<>r<>s rKr<>zAnnulus._recompute_path<74>s<><00><00><12>h<EFBFBD>h<EFBFBD>q<EFBFBD>#<23><1E><03><17>&<26>&<26>$<24>&<26>&<26>$<24>*<2A>*<2A>a<EFBFBD>1<EFBFBD><01> <11> "<22> "<22>3<EFBFBD><<3C><<3C><11>A<EFBFBD> 6<><02> <11> "<22> "<22>3<EFBFBD><<3C><<3C><04>"<22><04>#5<>q<EFBFBD>1<EFBFBD>u<EFBFBD>a<EFBFBD>!<21>e<EFBFBD> D<><02> <0E>I<EFBFBD>I<EFBFBD>r<EFBFBD>2<EFBFBD>r<EFBFBD>!<21>Q<EFBFBD>$<24>x<EFBFBD><16>0<> 1<><01> <0E>I<EFBFBD>I<EFBFBD>s<EFBFBD>y<EFBFBD>y<EFBFBD>$<24>+<2B>+<2B><1A>y<EFBFBD>y<EFBFBD><11><12>}<7D>d<EFBFBD>k<EFBFBD>k<EFBFBD><1B>~<7E>~<7E>'<27> (<28><01><1A>!<21>Q<EFBFBD>Z<EFBFBD><04>
rLc<00>R<00>|j<00>|j<00>|jSr`rr<>s rKrOzAnnulus.get_path<74>rrL<00>r6)rrrrr r r/rr<>rcr
rGrrgr=ryror2rsrvrgry<00>radiir{r<>rOr rs@rKrere<00>s<><00><><00><08><10><17><17><1A><18><1A>@:<3A>
<1A><1C><16>j<EFBFBD>*<2A> -<2D>F<EFBFBD><1A>$<1B> <15>Y<EFBFBD> <09> *<2A>E<EFBFBD>
<1A><1B> <15>Y<EFBFBD> <09> *<2A>E<EFBFBD>
<1A>
<1A><1A>,<1E> <15>Y<EFBFBD> <09> *<2A>E<EFBFBD><1E>  <20>rLrec<00>f<00><00>eZdZdZd<02>Zej d<06>fd<03> <09>Zd<04>Zd<05>Z e
e e<08>Z <0B>xZ S)<07>Circlez
A circle patch.
c<00>b<00>|jd|jd|jf}d}||zS)NrrzCircle(xy=(%g, %g), radius=%g))rGr[r3s rKrzCircle.__str__<5F>s1<00><00><13>{<7B>{<7B>1<EFBFBD>~<7E>t<EFBFBD>{<7B>{<7B>1<EFBFBD>~<7E>t<EFBFBD>{<7B>{<7B>:<3A><04>.<2E><03><12>T<EFBFBD>z<EFBFBD>rLc <00>D<00><01>t<00>|<00>||dz|dzfi|<03><01>||_y)a&
Create a true circle at center *xy* = (*x*, *y*) with given *radius*.
Unlike `CirclePolygon` which is a polygonal approximation, this uses
Bezier splines and is much closer to a scale-free circle.
Valid keyword arguments are:
%(Patch:kwdoc)s
rQN)r.r/r[)rHrr[rIrJs <20>rKr/zCircle.__init__<5F>s*<00><><00> <0E><07><18><12>V<EFBFBD>a<EFBFBD>Z<EFBFBD><16>!<21><1A>><3E>v<EFBFBD>><3E><1C><04> rLc<00>4<00>d|zx|_|_d|_y)zm
Set the radius of the circle.
Parameters
----------
radius : float
rQTN)r=r>r<>r<>s rKr<>zCircle.set_radius<75>s<00><00>$%<25>v<EFBFBD>:<3A>-<2D><04>
<EFBFBD>T<EFBFBD>[<5B><19><04>
rLc<00> <00>|jdz S)z Return the radius of the circle.rHr<>r<>s rK<00>
get_radiuszCircle.get_radius<75>s<00><00><13>z<EFBFBD>z<EFBFBD>B<EFBFBD><EFBFBD>rLrA) rrrrrr r r/r<>r<>r
r[r rs@rKr<>r<><00>s?<00><><00><08><1A>
<10><17><17> <1D><18> <1D> <1A><1F><16>j<EFBFBD>*<2A> -<2D>FrLr<>c<00><><00><00>eZdZdZd<02>Zej dddd<05><03>fd<06>
<EFBFBD>Zejd<07><00>Z
d<08>Z d <09>Z <0C>xZ S)
<EFBFBD>Arczx
An elliptical arc, i.e. a segment of an ellipse.
Due to internal optimizations, the arc cannot be filled.
c<00><><00>|jd|jd|j|j|j|j|j
f}d}||zS)NrrzEArc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g))rGr=r>r2r<>r<>r3s rKrz Arc.__str__<5F>sO<00><00><14> <0B> <0B>A<EFBFBD><0E><04> <0B> <0B>A<EFBFBD><0E><04>
<EFBFBD>
<EFBFBD><14> <0B> <0B>T<EFBFBD>Z<EFBFBD>Z<EFBFBD><14><1B><1B>d<EFBFBD>k<EFBFBD>k<EFBFBD>C<01><04><<3C><03><12>T<EFBFBD>z<EFBFBD>rLr6g<00>v@)r2r<>r<>c <00>8<00><01>|jdd<02>}|r td<03><00>t<00> |<00> |||fd|i|<07><01>||_||_|j <00>\|_|_|_ |_
tj|j|j<00>|_ y)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, default: 0, 360
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 : `~matplotlib.patches.Patch` properties
Most `.Patch` properties are supported as keyword arguments,
except *fill* and *facecolor* because filling is not supported.
%(Patch:kwdoc)s
r)FzArc objects cannot be filledr2N)<0E>
setdefaultrr.r/r<>r<><00>_theta_stretch<63>_theta1<61>_theta2<61>_stretched_width<74>_stretched_heightrr<>r<>)
rHrr=r>r2r<>r<>rIr)rJs
<20>rKr/z Arc.__init__<5F>s<><00><><00>H<16> <20> <20><16><15>/<2F><04> <0F><1C>;<3B><<3C> <<3C> <0A><07><18><12>U<EFBFBD>F<EFBFBD>B<>%<25>B<>6<EFBFBD>B<><1C><04> <0B><1C><04> <0B>#'<27>#6<>#6<>#8<> !<21><14><1C>t<EFBFBD>|<7C>T<EFBFBD>%:<3A> <0A> <1F><19>X<EFBFBD>X<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD>9<><04>
rLc<00><<00><14>|j<00>sy|j<00>|j<00>|j<00>}|j |j
|j f<02>|j d<02>z
\}}d}||kr||krtj||<01>Sd<04><00><14>fd<05>}tj|jxs|jd<06><07>j<00>|j<00>z
}tj <00>j#|<07>}t%<00>} t'|j(dd|j(d d<00>D]~\}
} |g|
<EFBFBD>| <0B><01><06>} | j*\} }t-j.t-j0|| <0A><00>d
zd
z}| j3||j4|k||j6kz<00><00><>t9| <09>|j6gz} |j4}t-j:|j4<00>}|j=t-j>|<11>t-j@|<11>f<02>}|jB}| D]=}|r5tjD||d <0B>|_!tj||<01>d}nd }|}<10>?||_!y) 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.*
https://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 (or figure)
bounding box are located. (This is done by performing an inverse
transformation on the 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 `.Path.arc`.
Nr\g<>\!<21><>Ac<00><><00>||z
}||z
}||z||zz}||z||zz
}||z}||z
} | dk\r<>tjd|<05>}
tj| <09>} tj||z|
|z| zz|z | |zt |<05>| zz|z g||z|
|z| zz
|z | |zt |<05>| zz
|z gg<02>Stj
d<03>S)Nr6rr<>)rk<00>copysign<67>sqrtr,r<>r<>) rBrCrDrEr r
<00>dr2<72>D<>D2<44>discrim<69>sign_dy<64> sqrt_discrims rK<00>line_circle_intersectz'Arc.draw.<locals>.line_circle_intersectWs<00><00><13>b<EFBFBD><17>B<EFBFBD><13>b<EFBFBD><17>B<EFBFBD><14>r<EFBFBD>'<27>B<EFBFBD><12>G<EFBFBD>#<23>C<EFBFBD><12>R<EFBFBD><07>"<22>r<EFBFBD>'<27>!<21>A<EFBFBD><12>Q<EFBFBD><15>B<EFBFBD><19>B<EFBFBD>h<EFBFBD>G<EFBFBD><16>#<23>~<7E><1C>+<2B>+<2B>a<EFBFBD><12>,<2C><07>!<21>w<EFBFBD>w<EFBFBD>w<EFBFBD>/<2F> <0C><19>x<EFBFBD>x<EFBFBD><18>2<EFBFBD>v<EFBFBD><07>"<22> <0C>|<7C> ;<3B>;<3B>s<EFBFBD>B<><19>r<EFBFBD>B<EFBFBD>w<EFBFBD><13>R<EFBFBD><17><<3C>!7<>7<>3<EFBFBD>><3E>@<01><18>2<EFBFBD>v<EFBFBD><07>"<22> <0C>|<7C> ;<3B>;<3B>s<EFBFBD>B<><19>r<EFBFBD>B<EFBFBD>w<EFBFBD><13>R<EFBFBD><17><<3C>!7<>7<>3<EFBFBD>><3E>@<01>A<01>B<01>B<01> <1A>x<EFBFBD>x<EFBFBD><06>'<27>'rLc<00><><00><01>d}||kr||}}n||}}||kr||}}n||}}<00> ||||<03>} | j\}
} | ||z
|
k|
||zkz||z
| kz| ||zkzS)Ng<4E><67>&<26> .>)<01>T) rBrCrDrE<00>epsilon<6F>x0e<30>x1e<31>y0e<30>y1e<31>xys<79>xs<78>ysr<73>s <20>rK<00>segment_circle_intersectz*Arc.draw.<locals>.segment_circle_intersectis<><00><><00><1A>G<EFBFBD><11>B<EFBFBD>w<EFBFBD><1D>r<EFBFBD>S<EFBFBD><03><1D>r<EFBFBD>S<EFBFBD><03><11>B<EFBFBD>w<EFBFBD><1D>r<EFBFBD>S<EFBFBD><03><1D>r<EFBFBD>S<EFBFBD><03>'<27><02>B<EFBFBD><02>B<EFBFBD>7<>C<EFBFBD><18>U<EFBFBD>U<EFBFBD>F<EFBFBD>B<EFBFBD><02><16><14>w<EFBFBD><1D><12>#<23><02>S<EFBFBD>7<EFBFBD>]<5D>(:<3A>;<3B><16><17>=<3D>2<EFBFBD>%<25>'<27>*,<2C>s<EFBFBD>W<EFBFBD>}<7D>*<<3C>><3E><0E> rLF<><01>rootr<74>rr<><00>T)#r<>rJr<>r<>r<>r<>r<>r'r<>rrJ<00>axes<65>
get_figurerMrNrr@<00> transformed<65>set<65>ziprjr<>rk<00>rad2degrrr<>r<><00>sorted<65>deg2radra<00>cos<6F>sinr<6E>r<>)rHr<><00>data_to_screen_trans<6E>pwidth<74>pheight<68> inv_errorr<72><00>box_path_transform<72>box_path<74>thetas<61>p0<70>p1rrbrc<00>theta<74>
last_theta<EFBFBD>
theta1_radrs<00> path_originalr<6C>s @rKr<>zArc.drawsl<00><><00>\<14><1F><1F>!<21> <12> <0C>!<21>!<21>#<23> <0C><19><19><1B> $<24>6<>6<>8<><1C> <20> *<2A> *<2A>D<EFBFBD>,A<>,A<>,0<>,B<>,B<>,D<01> E<01> <20> *<2A> *<2A>6<EFBFBD> 2<> 3<> <18><06><07>-<2D> <09> <11>I<EFBFBD> <1D>'<27>I<EFBFBD>"5<><18>:<3A>:<3A>d<EFBFBD>H<EFBFBD>-<2D> -<2D> (<28>$ <0E>* <17> &<26> &<26><04> <09> <09>(P<>T<EFBFBD>_<EFBFBD>_<EFBFBD>%<25>_<EFBFBD>5P<35>'V<>'V<> W<><12> <20> <20>"<22> #<23> <1B><18>&<26>&<26>(<28>4<>4<>5G<35>H<><08><14><15><06><19>(<28>+<2B>+<2B>C<EFBFBD>R<EFBFBD>0<>(<28>2C<32>2C<32>A<EFBFBD>B<EFBFBD>2G<32>H<> H<01>F<EFBFBD>B<EFBFBD><02>)<29>3<>2<EFBFBD>3<><02>3<>B<EFBFBD><15>4<EFBFBD>4<EFBFBD>D<EFBFBD>A<EFBFBD>q<EFBFBD><18>Z<EFBFBD>Z<EFBFBD><02>
<EFBFBD>
<EFBFBD>1<EFBFBD>a<EFBFBD> 0<>1<>C<EFBFBD>7<>3<EFBFBD>><3E>E<EFBFBD> <12>M<EFBFBD>M<EFBFBD><15>t<EFBFBD>|<7C>|<7C>e<EFBFBD>+<2B><05><04> <0C> <0C>0D<30>E<>F<> H<01>  H<01><18><06><1E>4<EFBFBD><<3C><<3C>.<2E>0<><06><19>\<5C>\<5C>
<EFBFBD><17>Z<EFBFBD>Z<EFBFBD><04> <0C> <0C>-<2D>
<EFBFBD><19>(<28>(<28> <0F>V<EFBFBD>V<EFBFBD>J<EFBFBD> <1F><12><16><16>
<EFBFBD>!3<> 4<>
<EFBFBD><06>
<1D>
<EFBFBD>
<EFBFBD> <0A><1B> <1F>E<EFBFBD><15>!<21>X<EFBFBD>X<EFBFBD>j<EFBFBD>%<25><11>;<3B><04>
<EFBFBD><15>
<EFBFBD>
<EFBFBD>4<EFBFBD><18>*<2A><1E><06><1D><06><1E>J<EFBFBD> <1F>#<23><04>
rLc
<00>J<00>|j<00>}td<01>t||j|j|j
|j f<04>D<00><00>rK|\|_|_|_|_tj|j|j<00>|_ yy)Nc3<00>,K<00>|] \}}||k7<00><01><00>y<00>wr`r:)rdrir<>s rKrgz#Arc._update_path.<locals>.<genexpr><3E>s<00><00><><00>6<>$<24>!<21>Q<EFBFBD>q<EFBFBD>A<EFBFBD>v<EFBFBD>6<>s<00>)
r<EFBFBD>rpr<>r<>r<>r<>r<>rr<>r<>)rH<00> stretcheds rKr<>zArc._update_path<74>s<><00><00><18>'<27>'<27>)<29> <09> <0E>6<>#<23><19>D<EFBFBD>L<EFBFBD>L<EFBFBD>$<24>,<2C>,<2C><04>8M<38>8M<38> <20>2<>2<>4<>#5<>6<> 6<>(1<> %<25>T<EFBFBD>\<5C>4<EFBFBD><<3C><14>)><3E> <11> #<23><1D><18><18>$<24>,<2C>,<2C><04> <0C> <0C>=<3D>D<EFBFBD>J<EFBFBD>  6rLc<00><><00>d<01>}|j|j<00>}|j|j<00>}||k7rj|j|j
k7r|jdz|j
dzk(s2||j||z <00>}||j
||z <00>}||||fS|j|j
||fS)Nc<00><><00>tj|<00>}tj|<00>}tj|<00>}tjtj
||z|<02><00>}|dzdzS)Nr<4E>)rkr<>r<>r<>r<>r)r<>rKrbrc<00>sthetas rK<00> theta_stretchz)Arc._theta_stretch.<locals>.theta_stretch<63>sV<00><00><16>J<EFBFBD>J<EFBFBD>u<EFBFBD>%<25>E<EFBFBD><12><06><06>u<EFBFBD> <0A>A<EFBFBD><12><06><06>u<EFBFBD> <0A>A<EFBFBD><17>Z<EFBFBD>Z<EFBFBD><02>
<EFBFBD>
<EFBFBD>5<EFBFBD>1<EFBFBD>9<EFBFBD>a<EFBFBD> 8<>9<>F<EFBFBD><1A>S<EFBFBD>L<EFBFBD>C<EFBFBD>'<27> 'rLr<>)rr=rr>r<>r<>)rHr<>r=r>r<>r<>s rKr<>zArc._theta_stretch<63>s<><00><00> (<28><15>#<23>#<23>D<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F><05><15>$<24>$<24>T<EFBFBD>[<5B>[<5B>1<><06> <12>V<EFBFBD>O<EFBFBD><1A>[<5B>[<5B>D<EFBFBD>K<EFBFBD>K<EFBFBD>/<2F><19>[<5B>[<5B>3<EFBFBD>&<26>$<24>+<2B>+<2B><03>*;<3B>;<3B>"<22>4<EFBFBD>;<3B>;<3B><05><06><0E>?<3F>F<EFBFBD>"<22>4<EFBFBD>;<3B>;<3B><05><06><0E>?<3F>F<EFBFBD><19>6<EFBFBD>5<EFBFBD>&<26>0<> 0<><13>{<7B>{<7B>D<EFBFBD>K<EFBFBD>K<EFBFBD><15><06>6<>6rL)rrrrrr r r/r
r r<>r<>r<>r rs@rKr<>r<><00>sV<00><><00><08> <1A><10><17><17><1A>3<EFBFBD>u<EFBFBD>-:<3A><18>-:<3A>^ <0C><1F><1F>L#<23> <20>L#<23>\><3E>7rLr<>c<00><><00>|<02>i}|j<00>}|jdd<03>}|j|<04>}|j|<01>}t |j
|dz z
|j |dz z
f|j|z|j|z|tj<00>d<05><06>}|j|<02>|j|<01>y)a>
A debug function to draw a rectangle around the bounding
box returned by an artist's `.Artist.get_window_extent`
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<>pad<61>rQF)rr=r>r)r<><00>clip_on) <0A>copy<70>popr#r<>r,rBrCr=r>rr<>rr<>)r
r<><00>propsr)r<>rMr<>s rK<00> bbox_artistr<74><00>s<><00><00> <0A>}<7D><12><05> <11>J<EFBFBD>J<EFBFBD>L<EFBFBD>E<EFBFBD>
<0F>)<29>)<29>E<EFBFBD>1<EFBFBD>
<1D>C<EFBFBD>
<12>
#<23>
#<23>C<EFBFBD>
(<28>C<EFBFBD> #<23>6<EFBFBD> #<23> #<23>H<EFBFBD> -<2D>D<EFBFBD><11> <10>G<EFBFBD>G<EFBFBD>c<EFBFBD>A<EFBFBD>g<EFBFBD> <1D>t<EFBFBD>w<EFBFBD>w<EFBFBD><13>q<EFBFBD><17>0<> 1<><12>j<EFBFBD>j<EFBFBD>3<EFBFBD><1E>t<EFBFBD>{<7B>{<7B>S<EFBFBD>'8<> <11>Z<EFBFBD>9<>9<>;<3B>U<EFBFBD> L<01>A<EFBFBD><06>H<EFBFBD>H<EFBFBD>U<EFBFBD>O<EFBFBD><05>F<EFBFBD>F<EFBFBD>8<EFBFBD>rLc<00><><00>t|j|j|j|dd<01><02>}|<03>|j |<03>|j |<01>y)z<>
A debug function to draw a rectangle around the bounding
box returned by an artist's `.Artist.get_window_extent`
to test whether the artist is returning the correct bbox.
F)rr=r>r"r)r<>N)r,r<>r=r>r<>r<>)rMr<>r(rQr<>s rK<00> draw_bboxr<78><00>sE<00><00> <12>T<EFBFBD>W<EFBFBD>W<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>t<EFBFBD>{<7B>{<7B>!<21><05>u<EFBFBD> ><3E>A<EFBFBD> <0C><18> <09><0F><0F><05><1E><05>F<EFBFBD>F<EFBFBD>8<EFBFBD>rLc<00>|<00>eZdZdZd<02>Zd<03>Zed<04><00>Zed<05><00>Zee jddd<08> <09>d
<EFBFBD><00><00>Z y ) <0C>_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.
c<00>"<00>tjjdi|j<00>d<01>|j <00>|j<00>d<02>|j <00>dzdj t dj|j<00><00>zdzi<02><01>y)Nz:tablez:table_and_acceptsz
.. ACCEPTS: [<5B>|z '{}' <20>]r:) r r <00>registerr<00> pprint_styles<65>joinrn<00>format<61> _style_list<73><01>clss rK<00>__init_subclass__z_Style.__init_subclass__<5F>s<><00><00> <13><1A><1A>#<23>#<23> <0B><12>|<7C>|<7C>n<EFBFBD>F<EFBFBD> #<23>S<EFBFBD>%6<>%6<>%8<><12>|<7C>|<7C>n<EFBFBD>.<2E> /<2F><13>!<21>!<21>#<23>)<29>*<2A><15>(<28>(<28>3<EFBFBD>x<EFBFBD><EFBFBD><EFBFBD><03><0F><0F>@<40>A<>B<01><16><16>'
<EFBFBD> rLc <00><><00>|jdd<02>jd<03>}|dj<00>} |j|} |ddD<00>cgc]}|jd<08><00><02>}}|D<00> <09>
cic]\} }
| t |
<EFBFBD><00><02>} } }
|d
ii| <0B>|<02><01><01>S#t$r}t d|<01><02><02>|<06>d}~wwxYwcc}wcc}
} w#t
$r}t d |<01><02><02>|<06>d}~wwxYw) z>Return the instance of the subclass with the given style name.r<>r<><00>,rzUnknown style: Nr<00>=zIncorrect style argument: r:)<07>replacero<00>lowerr<72><00>KeyErrorrr<>) r<><00> stylenamerI<00>_list<73>_name<6D>_cls<6C>errr<72><00>
_args_pair<EFBFBD>kr<6B><00>_argss rK<00>__new__z_Style.__new__ s<00><00><1A>!<21>!<21>#<23>r<EFBFBD>*<2A>0<>0<><13>5<><05><15>a<EFBFBD><08><0E><0E> <20><05> G<01><16>?<3F>?<3F>5<EFBFBD>)<29>D<EFBFBD> E<01>27<32><01><02>)<29><<3C>B<EFBFBD>"<22>(<28>(<28>3<EFBFBD>-<2D><<3C>J<EFBFBD><<3C>-7<>8<>T<EFBFBD>Q<EFBFBD><01>Q<EFBFBD><05>a<EFBFBD><08>[<5B>8<>E<EFBFBD>8<><14>*<2A>)<29><15>)<29>&<26>)<29>*<2A>*<2A><><18> G<01><1C><EFBFBD>y<EFBFBD>m<EFBFBD><<3C>=<3D>3<EFBFBD> F<><46> G<01><>=<3D><>8<><38><19> E<01><1C>,<2C>Y<EFBFBD>M<EFBFBD>:<3A><<3C>AD<41> E<01><> E<01>sM<00>B<00>B<<00> B1<04>%B<<00>,B6<06>B<<00> B.<03>B)<03>)B.<03>1 B<<00>< C<03>C<03>Cc<00><00>|jS)z(Return a dictionary of available styles.)r<>r<>s rK<00>
get_stylesz_Style.get_styles s<00><00><13><EFBFBD><EFBFBD>rLc <00>l<00>dg|jj<00>D<00><01>cgc];\}}|jd|<01>d<02>tt j
|<00><00>ddxsdf<03><02>=c}}<01>}t |<02>D<00>cgc]}td<06>|D<00><00><00><02>}}djd<08>|D<00><00>}d jd
|djd <0B>t |d |<04>D<00><00>|g|dd D<00>cgc]$}djd<0E>t ||<04>D<00><00><00><02>&c}<06>|<05><01>}tj|d<0F><10>Scc}}wcc}wcc}w)z5Return the available styles as pretty-printed string.)<03>Class<73>Name<6D>
Parametersz``rr<>r<>c3<00>2K<00>|]}t|<01><00><01><00>y<00>wr`)rF)rd<00>cells rKrgz'_Style.pprint_styles.<locals>.<genexpr>* s<00><00><><00>4<>T<EFBFBD>s<EFBFBD>4<EFBFBD>y<EFBFBD>4<>s<00>z c3<00>&K<00>|] }d|z<00><01><00> y<01>w)r<>Nr:)rd<00>cls rKrgz'_Style.pprint_styles.<locals>.<genexpr>+ s<00><00><><00>#?<3F><12>C<EFBFBD>"<22>H<EFBFBD>#?<3F>s<00>r9r<>c3<00>DK<00>|]\}}|j|<02><00><01><00>y<00>wr`<00><01>ljust<73>rdr<>r<>s rKrgz'_Style.pprint_styles.<locals>.<genexpr>/ s<00><00><><00>L<><18><14>r<EFBFBD>d<EFBFBD>j<EFBFBD>j<EFBFBD><12>n<EFBFBD>L<><4C><00> rNc3<00>DK<00>|]\}}|j|<02><00><01><00>y<00>wr`r<>r<>s rKrgz'_Style.pprint_styles.<locals>.<genexpr>1 s<00><00><><00>I<>8<EFBFBD>4<EFBFBD><12><04>
<EFBFBD>
<EFBFBD>2<EFBFBD><0E>I<>r<EFBFBD>z )<01>prefix) r<><00>itemsr<00>str<74>inspect<63> signaturer<65><00>maxr<78><00>textwrap<61>indent)r<>r<><00>table<6C>column<6D>col_len<65>table_formatstr<74>row<6F> rst_tables rKr<>z_Style.pprint_styles sK<00><00>1<>><3E> %(<28>O<EFBFBD>O<EFBFBD>$9<>$9<>$;<3B> =<3D>
!<21>t<EFBFBD>S<EFBFBD> <18>L<EFBFBD>L<EFBFBD><18><14><06>b<EFBFBD>M<EFBFBD><17><07>)<29>)<29>#<23>.<2E>/<2F><01>"<22>5<>?<3F><16> A<01>=<3D>><3E><05>DG<01><05>;<3B>O<><16>3<EFBFBD>4<>V<EFBFBD>4<>4<>O<><07>O<><1E>)<29>)<29>#?<3F>w<EFBFBD>#?<3F>?<3F><0F><18>I<EFBFBD>I<EFBFBD> <0E> <1B> <10>I<EFBFBD>I<EFBFBD>L<>S<EFBFBD><15>q<EFBFBD><18>7<EFBFBD>5K<35>L<> L<> <1B> 
<EFBFBD> <1F>q<EFBFBD>r<EFBFBD><19>$<24><15><13>i<EFBFBD>i<EFBFBD>I<>s<EFBFBD>3<EFBFBD><07>7H<37>I<>I<>$<24> 
<EFBFBD> <1C>
<EFBFBD> <0B> <09><18><EFBFBD><EFBFBD>y<EFBFBD><17>9<>9<><39>%=<3D><>P<01><>$s<00>AD&<08>/D,<04>)D1
z3.10.0z%This method is never used internally.z6No replacement. Please open an issue if you use this.)<02>message<67> alternativec<00><><00>t||j<00>st|<02>d|j<00><00><03><00>||j|<y)zRegister a new style.z must be a subclass of N)<04>
issubclass<EFBFBD>_Baserr<>)r<>r<><00>styles rKr<>z_Style.register7 s;<00><00><1A>%<25><13><19><19>+<2B><1C><05>w<EFBFBD>&=<3D>c<EFBFBD>i<EFBFBD>i<EFBFBD>[<5B>I<>J<> J<> %<25><03><0F><0F><04>rLN) rrrrr<>r<><00> classmethodr<64>r<>r <00>
deprecatedr<EFBFBD>r:rLrKr<>r<><00>si<00><00><08>  <0B>&+<2B>$<11><1F><11><1F><11>:<3A><11>:<3A>.<11><14>T<EFBFBD>_<EFBFBD>_<EFBFBD><10>7<>L<><06>
&<26> <06><11> &rLr<><00>r<>c<00><><00>|<01>tjt||<02><01>S|||xs|jj <00><|S)z=Class decorator that stashes a class in a (style) dictionary.r)<05> functools<6C>partial<61>_register_stylerr<>)<03>
style_listr<EFBFBD>r<>s rKrrD s=<00><00>
<EFBFBD>{<7B><18> <20> <20><1F>*<2A>4<EFBFBD>H<>H<>/2<>J<EFBFBD>t<EFBFBD>+<2B>s<EFBFBD>|<7C>|<7C>)<29>)<29>+<2B>,<2C> <0E>JrLc<00><><00>eZdZdZiZee<04>Gd<02>d<03><00>Zee<04>Gd<04>d<05><00>Zee<04>Gd<06>d<07><00>Zee<04>Gd<08>d <09><00>Z ee<04>Gd
<EFBFBD>d e <09><00>Z
ee<04>Gd <0C>d <0A><00>Z ee<04>Gd<0E>d<0F><00>Z ee<04>Gd<10>d<11><00>Z ee<04>Gd<12>d<13><00>Zee<04>Gd<14>de<0E><00>Zy)<17>BoxStylea<65>
`BoxStyle` is a container class which defines several
boxstyle classes, which are used for `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")
The following boxstyle classes are defined.
%(BoxStyle:table)s
An instance of a boxstyle class is a callable object, with the signature ::
__call__(self, x0, y0, width, height, mutation_size) -> Path
*x0*, *y0*, *width* and *height* specify the location and size of the box
to be drawn; *mutation_size* scales the outline properties such as padding.
c<00><00>eZdZdZdd<02>Zd<03>Zy)<06>BoxStyle.Squarez A square box.c<00><00>||_y<01>z<>
Parameters
----------
pad : float, default: 0.3
The amount of padding around the original box.
N<>r<><00>rHr<>s rKr/zBoxStyle.Square.__init__p <00> <00><00><1B>D<EFBFBD>HrLc<00><><00>||jz}|d|zz|d|zz}}||z
||z
}}||z||z}}tj||f||f||f||fg<04>S<00>NrQ<00>r<>rr) rHrBrCr=r><00> mutation_sizer<65>rDrEs rK<00>__call__zBoxStyle.Square.__call__y s{<00><00><1F>$<24>(<28>(<28>*<2A>C<EFBFBD>!<21>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>V<EFBFBD>a<EFBFBD>#<23>g<EFBFBD>-=<3D>6<EFBFBD>E<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><17>&<26>&<26><14>b<EFBFBD><18>B<EFBFBD><02>8<EFBFBD>b<EFBFBD>"<22>X<EFBFBD><02>B<EFBFBD>x<EFBFBD>8<>:<3A> :rLN<>r<00>rrrrr/r)r:rLrK<00>Squarerl s<00><00><1B> <1B> :rLr,c<00><00>eZdZdZdd<02>Zd<03>Zy)<06>BoxStyle.CirclezA circular box.c<00><00>||_yr!r"r#s rKr/zBoxStyle.Circle.__init__<5F> r$rLc<00><><00>||jz}|d|zz|d|zz}}||z
||z
}}tj||dz z||dz zft||<04>dz <00>Sr&)r<>r<00>circler)rHrBrCr=r>r(r<>s rKr)zBoxStyle.Circle.__call__<5F> sr<00><00><1F>$<24>(<28>(<28>*<2A>C<EFBFBD>!<21>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>V<EFBFBD>a<EFBFBD>#<23>g<EFBFBD>-=<3D>6<EFBFBD>E<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><17>;<3B>;<3B><02>U<EFBFBD>Q<EFBFBD>Y<EFBFBD><0E><02>V<EFBFBD>a<EFBFBD>Z<EFBFBD><0F>@<40> #<23>E<EFBFBD>6<EFBFBD> 2<>Q<EFBFBD> 6<>8<> 8rLNr*r+r:rLrKr<>r.<00> s<00><00><1D> <1B> 8rLr<>c<00><00>eZdZdZdd<02>Zd<03>Zy)<06>BoxStyle.EllipsezC
An elliptical box.
.. versionadded:: 3.7
c<00><00>||_yr!r"r#s rKr/zBoxStyle.Ellipse.__init__<5F> r$rLc<00>f<00>||jz}|d|zz|d|zz}}||z
||z
}}|tjd<01>z }|tjd<01>z }t<00>j ||<08>j ||dz z||dz z<00>} | j tj<00><00>Sr&) r<><00>mathr<68>rrKr%<00>transform_pathrrH)
rHrBrCr=r>r(r<>rir<>rQs
rKr)zBoxStyle.Ellipse.__call__<5F> s<><00><00><1F>$<24>(<28>(<28>*<2A>C<EFBFBD>!<21>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>V<EFBFBD>a<EFBFBD>#<23>g<EFBFBD>-=<3D>6<EFBFBD>E<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><15><04> <09> <09>!<21> <0C>$<24>A<EFBFBD><16><14><19><19>1<EFBFBD><1C>%<25>A<EFBFBD><1C>J<EFBFBD>$<24>$<24>Q<EFBFBD><01>*<2A>4<>4<>R<EFBFBD>%<25>!<21>)<29>^<5E>57<35>&<26>1<EFBFBD>*<2A>_<EFBFBD>F<01>E<EFBFBD><18>'<27>'<27><04>(8<>(8<>(:<3A>;<3B> ;rLNr*r+r:rLrKrCr3<00> s<00><00> <0C>  <1B> <rLrCc<00><00>eZdZdZdd<02>Zd<03>Zy)<06>BoxStyle.LArrowz,A box in the shape of a left-pointing arrow.c<00><00>||_yr!r"r#s rKr/zBoxStyle.LArrow.__init__<5F> r$rLc <00>"<00>||jz}|d|zz|d|zz}}||z
||z
}}||z||z}}||z
dz } | dz }
||dz z}tj||
z|f||f||f||
z|f||
z||
zf|| z
|| zf||
z||
z
f||
z|fg<08>S<00>NrQgffffff<66>?r'<00> rHrBrCr=r>r(r<>rDrEr <00>dxxs rKr)zBoxStyle.LArrow.__call__<5F> s<><00><00><1F>$<24>(<28>(<28>*<2A>C<EFBFBD>!<21>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>V<EFBFBD>a<EFBFBD>#<23>g<EFBFBD>-=<3D>6<EFBFBD>E<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><14>r<EFBFBD>'<27>Q<EFBFBD><1D>B<EFBFBD><14>q<EFBFBD>&<26>C<EFBFBD><13>c<EFBFBD>C<EFBFBD>i<EFBFBD><1E>B<EFBFBD><17>&<26>&<26><14>s<EFBFBD>(<28>B<EFBFBD><1E>"<22>b<EFBFBD><18>B<EFBFBD><02>8<EFBFBD>b<EFBFBD>3<EFBFBD>h<EFBFBD><02>^<5E><14>s<EFBFBD>(<28>B<EFBFBD><13>H<EFBFBD>%<25><02>R<EFBFBD><07><12>b<EFBFBD><17>'9<><14>s<EFBFBD>(<28>B<EFBFBD><13>H<EFBFBD>%<25><14>s<EFBFBD>(<28>B<EFBFBD><1E>!<21>"<22> "rLNr*r+r:rLrK<00>LArrowr9<00> s<00><00>:<3A> <1B> "rLr?c<00><00>eZdZdZd<02>Zy)<04>BoxStyle.RArrowz-A box in the shape of a right-pointing arrow.c<00><><00>tjj||||||<05>}d|z|z|jdd<00>dfz
|jdd<00>df<|S)NrQr)rr?r)rj)rHrBrCr=r>r(<00>ps rKr)zBoxStyle.RArrow.__call__<5F> sT<00><00><18><0F><0F>(<28>(<28><14>b<EFBFBD>"<22>e<EFBFBD>V<EFBFBD>]<5D><<3C>A<EFBFBD> <20>2<EFBFBD>v<EFBFBD><05>~<7E><01>
<EFBFBD>
<EFBFBD>1<EFBFBD>a<EFBFBD>4<EFBFBD>0@<40>@<40>A<EFBFBD>J<EFBFBD>J<EFBFBD>q<EFBFBD>!<21>t<EFBFBD> <1C><14>HrLN<>rrrrr)r:rLrK<00>RArrowrA<00> s
<00><00>;<3B> rLrEc<00><00>eZdZdZdd<02>Zd<03>Zy)<06>BoxStyle.DArrowz&A box in the shape of a two-way arrow.c<00><00>||_yr!r"r#s rKr/zBoxStyle.DArrow.__init__<5F> r$rLc<00>B<00>||jz}|d|zz}||z
||z
}}||z||z}}||z
dz } | dz }
||dz z}tj||
z|f||f|||
z
f|| z|
z|| zf|||
zf||f||
z|f||
z||
zf|| z
|| zf||
z||
z
f||
z|fg <0B>Sr<r'r=s rKr)zBoxStyle.DArrow.__call__<5F> s<00><00><1F>$<24>(<28>(<28>*<2A>C<EFBFBD><1C>a<EFBFBD>#<23>g<EFBFBD>%<25>F<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><14>r<EFBFBD>'<27>Q<EFBFBD><1D>B<EFBFBD><14>q<EFBFBD>&<26>C<EFBFBD><13>c<EFBFBD>C<EFBFBD>i<EFBFBD><1E>B<EFBFBD><17>&<26>&<26><13>c<EFBFBD><18>2<EFBFBD><0E><12>R<EFBFBD><08><13>R<EFBFBD>#<23>X<EFBFBD><0E><12>b<EFBFBD><17>3<EFBFBD><1D><02>R<EFBFBD><07> 8<><13>R<EFBFBD>#<23>X<EFBFBD><0E><13>R<EFBFBD><08>2<EFBFBD><03>8<EFBFBD>R<EFBFBD>.<2E><13>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>$<24>r<EFBFBD>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>&8<><13>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>$<24><13>c<EFBFBD><18>2<EFBFBD><0E>( <20>!<21> !rLNr*r+r:rLrK<00>DArrowrG<00> s<00><00>4<> <1B> !rLrJc<00><00>eZdZdZdd<03>Zd<04>Zy)<06>BoxStyle.RoundzA box with round corners.Nc<00> <00>||_||_y)z<>
Parameters
----------
pad : float, default: 0.3
The amount of padding around the original box.
rounding_size : float, default: *pad*
Radius of the corners.
N<>r<><00> rounding_size<7A>rHr<>rOs rKr/zBoxStyle.Round.__init__
<00><00><00><1B>D<EFBFBD>H<EFBFBD>!.<2E>D<EFBFBD> rLc<00><><00>||jz}|jr||jz}n|}|d|zz|d|zz}}||z
||z
}}||z||z} }||z|f||z
|f||f|||zf|| |z
f|| f||z
| f||z| f|| f|| |z
f|||zf||f||z|f||z|fg}
tjtjtj
tj
tjtj
tj
tjtj
tj
tjtj
tj
tj g} t|
| <0B>Sr&)r<>rOrrmr<><00>CURVE3r<33><00> rHrBrCr=r>r(r<><00>drrDrE<00>cp<63>coms rKr)zBoxStyle.Round.__call__
sr<00><00> <20>$<24>(<28>(<28>*<2A>C<EFBFBD><14>!<21>!<21>"<22>T<EFBFBD>%7<>%7<>7<><02><18><02>!<21>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>V<EFBFBD>a<EFBFBD>#<23>g<EFBFBD>-=<3D>6<EFBFBD>E<EFBFBD><17>#<23>X<EFBFBD>r<EFBFBD>C<EFBFBD>x<EFBFBD><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><16><02>7<EFBFBD>B<EFBFBD>-<2D><15><02>7<EFBFBD>B<EFBFBD>-<2D><15>r<EFBFBD>(<28>R<EFBFBD><12>b<EFBFBD><17>M<EFBFBD><15>r<EFBFBD>B<EFBFBD>w<EFBFBD>-<2D><15>r<EFBFBD>(<28>R<EFBFBD>"<22>W<EFBFBD>b<EFBFBD>M<EFBFBD><15><02>7<EFBFBD>B<EFBFBD>-<2D><15>r<EFBFBD>(<28>R<EFBFBD><12>b<EFBFBD><17>M<EFBFBD><15>r<EFBFBD>B<EFBFBD>w<EFBFBD>-<2D><15>r<EFBFBD>(<28>R<EFBFBD>"<22>W<EFBFBD>b<EFBFBD>M<EFBFBD><15><02>7<EFBFBD>B<EFBFBD>-<2D> !<21>B<EFBFBD><18>;<3B>;<3B><17>;<3B>;<3B><17>;<3B>;<3B><04> <0B> <0B><17>;<3B>;<3B><17>;<3B>;<3B><04> <0B> <0B><17>;<3B>;<3B><17>;<3B>;<3B><04> <0B> <0B><17>;<3B>;<3B><17>;<3B>;<3B><04> <0B> <0B><17>><3E>><3E> #<23>C<EFBFBD><18><02>C<EFBFBD>=<3D> rL<00>rNr+r:rLrK<00>RoundrL
s<00><00>'<27>
/<2F>( !rLrYc<00><00>eZdZdZdd<03>Zd<04>Zy)<06>BoxStyle.Round4zA box with rounded edges.Nc<00> <00>||_||_y)z<>
Parameters
----------
pad : float, default: 0.3
The amount of padding around the original box.
rounding_size : float, default: *pad*/2
Rounding of edges.
NrNrPs rKr/zBoxStyle.Round4.__init__A
rQrLc<00>F<00>||jz}|jr||jz}n|dz }|d|zzd|zz
}|d|zzd|zz
}||z
|z||z
|z}}||z||z} }||f||z||z
f||z
||z
f||f||z||zf||z| |z
f|| f||z
| |zf||z| |zf|| f||z
| |z
f||z
||zf||f||fg}
tjtjtjtjtjtjtjtjtjtjtjtjtjtj
g} t|
| <0B>S)NrHrQ)r<>rOrrm<00>CURVE4r<34>rTs rKr)zBoxStyle.Round4.__call__M
s<><00><00> <20>$<24>(<28>(<28>*<2A>C<EFBFBD><14>!<21>!<21>"<22>T<EFBFBD>%7<>%7<>7<><02><18>2<EFBFBD>X<EFBFBD><02><19>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>a<EFBFBD>"<22>f<EFBFBD>,<2C>E<EFBFBD><1B>a<EFBFBD>#<23>g<EFBFBD>%<25><01>B<EFBFBD><06>.<2E>F<EFBFBD><17>#<23>X<EFBFBD><02>]<5D>B<EFBFBD><13>H<EFBFBD>r<EFBFBD>M<EFBFBD><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><15>r<EFBFBD>(<28><15><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>$<24>r<EFBFBD>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>&8<>2<EFBFBD>r<EFBFBD>(<28><15><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>$<24>r<EFBFBD>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>&8<>2<EFBFBD>r<EFBFBD>(<28><15><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>$<24>r<EFBFBD>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>&8<>2<EFBFBD>r<EFBFBD>(<28><15><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>$<24>r<EFBFBD>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>&8<>2<EFBFBD>r<EFBFBD>(<28><15>r<EFBFBD>(<28> <1C>B<EFBFBD><18>;<3B>;<3B><17>;<3B>;<3B><04> <0B> <0B>T<EFBFBD>[<5B>[<5B><17>;<3B>;<3B><04> <0B> <0B>T<EFBFBD>[<5B>[<5B><17>;<3B>;<3B><04> <0B> <0B>T<EFBFBD>[<5B>[<5B><17>;<3B>;<3B><04> <0B> <0B>T<EFBFBD>[<5B>[<5B><17>><3E>><3E> #<23>C<EFBFBD><18><02>C<EFBFBD>=<3D> rLrXr+r:rLrK<00>Round4r[=
s<00><00>'<27>
/<2F> !rLr_c<00>$<00>eZdZdZdd<03>Zd<04>Zd<05>Zy)<07>BoxStyle.SawtoothzA box with a sawtooth outline.Nc<00> <00>||_||_y)z<>
Parameters
----------
pad : float, default: 0.3
The amount of padding around the original box.
tooth_size : float, default: *pad*/2
Size of the sawtooth.
N)r<><00>
tooth_size)rHr<>rcs rKr/zBoxStyle.Sawtooth.__init__r
s<00><00><1B>D<EFBFBD>H<EFBFBD>(<28>D<EFBFBD>OrLc<00>`<00>||jz}|j<00>|jdz|z}n|j|z}|dz }|d|zz|z
}|d|zz|z
}t||z
|dzz <00>dz} t||z
|dzz <00>dz}
||z
|z||z
|z}}||z||z} } |gtj||z| |z
d| zdz<00><00>| | |z| | |z
g|
zdd|
zdz<00>| <0B>tj| |z
||zd| zdz<00><00>|||z
|||zg|
zdd|
zdz<00>} g|||z
|||zg| zdd| zdz<00>|<02>tj||z| |z
d|
zdz<00><00>| | |z| | |z
g| zdd| zdz<00>| <0C>tj| |z
||zd|
zdz<00><00>}gt | |<0E><00>| d|df<02>S)NrrQrr)r<>rc<00>roundrk<00>linspacer<65>)rHrBrCr=r>r(r<>rc<00>hsz<73>dsx_n<5F>dsy_nrDrEr<>r<>s rK<00>_get_sawtooth_verticesz(BoxStyle.Sawtooth._get_sawtooth_vertices~
su<00><00> <20>$<24>(<28>(<28>*<2A>C<EFBFBD><14><EFBFBD><EFBFBD>&<26>!<21>X<EFBFBD>X<EFBFBD><02>]<5D>]<5D>:<3A>
<EFBFBD>!<21>_<EFBFBD>_<EFBFBD>}<7D><<3C>
<EFBFBD><1C>q<EFBFBD>.<2E>C<EFBFBD><19>A<EFBFBD><03>G<EFBFBD>O<EFBFBD>j<EFBFBD>0<>E<EFBFBD><1B>a<EFBFBD>#<23>g<EFBFBD>%<25>
<EFBFBD>2<>F<EFBFBD><1A>5<EFBFBD>:<3A>-<2D>*<2A>q<EFBFBD>.<2E>A<>B<>Q<EFBFBD>F<>E<EFBFBD><19>6<EFBFBD>J<EFBFBD>.<2E>:<3A><01>><3E>B<>C<>a<EFBFBD>G<>E<EFBFBD><17>#<23>X<EFBFBD><03>^<5E>R<EFBFBD>#<23>X<EFBFBD><03>^<5E><02>B<EFBFBD><17>%<25>Z<EFBFBD><12>f<EFBFBD><1B><02>B<EFBFBD><13><0E><17>[<5B>[<5B><12>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>Q<EFBFBD><15>Y<EFBFBD><11>]<5D>C<><0E><15>r<EFBFBD>C<EFBFBD>x<EFBFBD><12>R<EFBFBD>#<23>X<EFBFBD>.<2E><15>6<>
<EFBFBD><11>5<EFBFBD><17><11><19>C<><0E><13><0E><18>[<5B>[<5B><12>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>Q<EFBFBD><15>Y<EFBFBD><11>]<5D>C<><0E><16>r<EFBFBD>C<EFBFBD>x<EFBFBD><12>R<EFBFBD>#<23>X<EFBFBD>.<2E><15>6<>
<EFBFBD><11>5<EFBFBD><17><11><19>C<> <0E>B<EFBFBD> <0E><15>r<EFBFBD>C<EFBFBD>x<EFBFBD><12>R<EFBFBD>#<23>X<EFBFBD>.<2E><15>6<>
<EFBFBD><11>5<EFBFBD><17><11><19>C<><0E><12><0E><17>[<5B>[<5B><12>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>Q<EFBFBD><15>Y<EFBFBD><11>]<5D>C<><0E><16>r<EFBFBD>C<EFBFBD>x<EFBFBD><12>R<EFBFBD>#<23>X<EFBFBD>.<2E><15>6<>
<EFBFBD><11>5<EFBFBD><17><11><19>C<><0E><13> <0E><18>[<5B>[<5B><12>c<EFBFBD><18>2<EFBFBD><03>8<EFBFBD>Q<EFBFBD><15>Y<EFBFBD><11>]<5D>C<> <0E>B<EFBFBD>2<>S<EFBFBD><12>R<EFBFBD>[<5B>1<>2<EFBFBD>a<EFBFBD>5<EFBFBD>"<22>Q<EFBFBD>%<25>.<2E>1<> 1rLc<00>F<00>|j|||||<05>}t|d<01><02>S)NTr<54>)rjr)rHrBrCr=r>r(<00> saw_verticess rKr)zBoxStyle.Sawtooth.__call__<5F>
s+<00><00><1F>6<>6<>r<EFBFBD>2<EFBFBD>u<EFBFBD>7=<3D>}<7D>N<01>L<EFBFBD><17> <0C>T<EFBFBD>2<> 2rLrX)rrrrr/rjr)r:rLrK<00>Sawtoothran
s<00><00>,<2C>
)<29>$ 2<>L 3rLrmc<00><00>eZdZdZd<02>Zy)<04>BoxStyle.Roundtoothz&A box with a rounded sawtooth outline.c<00>&<00>|j|||||<05>}tj||dgg<02>}tjgtj
tj
gt |<06>dz
dzzztjgz}t||<07>S)NrrrQ)rjrkr<>rrmrSrFr<>)rHrBrCr=r>r(rlris rKr)zBoxStyle.Roundtooth.__call__<5F>
s<><00><00><1F>6<>6<>r<EFBFBD>2<EFBFBD>7<<3C>f<EFBFBD>7D<37>F<01>L<EFBFBD><1E>><3E>><3E><<3C>,<2C>q<EFBFBD>/<2F>9J<39>*K<>L<>L<EFBFBD><1A>k<EFBFBD>k<EFBFBD>]<5D><1A>k<EFBFBD>k<EFBFBD>4<EFBFBD>;<3B>;<3B>/<2F>C<EFBFBD> <0C>4E<34>a<EFBFBD>4G<34>!<21>3K<33>L<>M<01><1A>n<EFBFBD>n<EFBFBD>%<25>&<26>E<EFBFBD><18> <0C>e<EFBFBD>,<2C> ,rLNrDr:rLrK<00>
Roundtoothro<00>
s
<00><00>4<> -rLrqN)rrrrr<>rr,r<>rCr?rErJrYr_rmrqr:rLrKrrL s@<00><00><08>8<15>K<EFBFBD><14>[<5B>!<21>:<3A>:<3A>"<22>:<3A>,<15>[<5B>!<21>8<>8<>"<22>8<>(<15>[<5B>!<21><<3C><<3C>"<22><<3C>6<15>[<5B>!<21>"<22>"<22>"<22>"<22>><15>[<5B>!<21><15><16><15>"<22><15><15>[<5B>!<21>"!<21>"!<21>"<22>"!<21>H<15>[<5B>!<21>7!<21>7!<21>"<22>7!<21>r<15>[<5B>!<21>.!<21>.!<21>"<22>.!<21>`<15>[<5B>!<21>83<>83<>"<22>83<>t<15>[<5B>!<21> -<2D>X<EFBFBD> -<2D>"<22> -rLrc<00><00>eZdZdZiZGd<02>d<03>Zee<04>Gd<04>de<05><00>Zee<04>Gd<06>de<05><00>Zee<04>Gd<08>d e<05><00>Z ee<04>Gd
<EFBFBD>d e<05><00>Z
ee<04>Gd <0C>d e<05><00>Z y)<0F>ConnectionStylea
`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 `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
%(ConnectionStyle:table)s
An instance of any connection style class is a callable object,
whose call signature is::
__call__(self, posA, posB,
patchA=None, patchB=None,
shrinkA=2., shrinkB=2.)
and it returns a `.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<00>&<00>eZdZdZd<02>Zd<03>Z dd<05>Zy)<07>ConnectionStyle._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<00><00><01><00>fd<01>S)zw
Return a predicate function testing whether a point *xy* is
contained in *patch*.
c<00>N<00><01><00>jt|d|d<00><03><00>dS)Nrr)rbrc)rtr)rr<>s <20>rK<00><lambda>z1ConnectionStyle._Base._in_patch.<locals>.<lambda><3E>
s*<00><><00>e<EFBFBD>n<EFBFBD>n<EFBFBD><1F>"<22>Q<EFBFBD>%<25>2<EFBFBD>a<EFBFBD>5<EFBFBD>1<>3<>34<33>6<>rLr:)rHr<>s `rK<00> _in_patchzConnectionStyle._Base._in_patch<63>
s <00><><00>
6<> 6rLc<00><><00>|r t||<02>\}}|r t||<03>\}}|S|S#t$rY<00>!wxYw#t$rY|SwxYw)a$
Clip *path* at its start by the region where *in_start* returns
True, and at its stop by the region where *in_stop* returns True.
The original path is assumed to start in the *in_start* region and
to stop in the *in_stop* region.
)rr)rHrR<00>in_start<72>in_stopr<70>s rK<00>_clipzConnectionStyle._Base._clip<69>
sm<00><00><18><19>.<2E>t<EFBFBD>X<EFBFBD>><3E>G<EFBFBD>A<EFBFBD>t<EFBFBD><17><19>.<2E>t<EFBFBD>W<EFBFBD>=<3D>G<EFBFBD>D<EFBFBD>!<21><18>K<EFBFBD>4<EFBFBD>K<EFBFBD><4B>"<22><19><18><19><>
"<22><19><18><17>K<EFBFBD><19>s<00>)<00>8<00> 5<03>5<03> A<03>ANc <00>><00>|j||<02>}|j||r|j|<05>nd|r|j|<06>nd<01>}|j||rtg|jd<00>|<03><01><06>nd|r tg|jd<00>|<04><01><06><00>}|Sd<01>}|S)z<>
Call the *connect* method to create a path between *posA* and
*posB*; then clip and shrink the path.
Nrr<>)<05>connectr}ryrrj)rH<00>posA<73>posB<73>shrinkA<6B>shrinkB<6B>patchA<68>patchBrRs rKr)zConnectionStyle._Base.__call__ s<><00><00> <18><<3C><<3C><04>d<EFBFBD>+<2B>D<EFBFBD><17>:<3A>:<3A><14>*0<><04><0E><0E>v<EFBFBD>&<26>d<EFBFBD>*0<><04><0E><0E>v<EFBFBD>&<26>d<EFBFBD><0E>D<EFBFBD>
<18>:<3A>:<3A><14>=D<> <0A>9<>t<EFBFBD>}<7D>}<7D>Q<EFBFBD>/<2F>9<><17>9<>$<24>>E<> <0A>:<3A>t<EFBFBD>}<7D>}<7D>R<EFBFBD>0<>:<3A>'<27>:<3A><0E>D<EFBFBD>
<18>K<EFBFBD>LP<01><0E>D<EFBFBD>
<18>KrL)rHrHNN)rrrrryr}r)r:rLrKrru<00>
s<00><00>
<0C> 6<> <18>*BF<01> rLrc<00><00>eZdZdZdd<02>Zd<03>Zy)<06>ConnectionStyle.Arc3uN
Creates a simple quadratic Bézier 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.
c<00><00>||_y)zy
Parameters
----------
rad : float
Curvature of the curve.
N)<01>rad)rHr<>s rKr/zConnectionStyle.Arc3.__init__& r$rLc<00><00>|\}}|\}}||zdz ||zdz }}||z
||z
}
} |j} || |
zz|| | zz
} } ||f| | f||fg}tjtjtjg}t||<0F>S)NrH)r<>rrmrS)rHr<>r<>rDrE<00>x2<78>y2<79>x12<31>y12r r
<00>fr6<00>cyrjris rKrzConnectionStyle.Arc3.connect/ s<><00><00><19>F<EFBFBD>B<EFBFBD><02><19>F<EFBFBD>B<EFBFBD><02><1A>R<EFBFBD><07>2<EFBFBD>~<7E><02>R<EFBFBD><07>2<EFBFBD>~<7E><13>C<EFBFBD><17>"<22>W<EFBFBD>b<EFBFBD>2<EFBFBD>g<EFBFBD><02>B<EFBFBD><14><08><08>A<EFBFBD><18>1<EFBFBD>r<EFBFBD>6<EFBFBD>\<5C>3<EFBFBD><11>R<EFBFBD><16><<3C><02>B<EFBFBD><1B>R<EFBFBD><08><1B>R<EFBFBD><08><1B>R<EFBFBD><08>"<22>H<EFBFBD><1A>[<5B>[<5B><19>[<5B>[<5B><19>[<5B>[<5B>"<22>E<EFBFBD><18><08>%<25>(<28> (rLNr<4E><00>rrrrr/rr:rLrK<00>Arc3r<33> s<00><00> <0C> <1B> )rLr<>c<00><00>eZdZdZdd<02>Zd<03>Zy)<06>ConnectionStyle.Angle3u
Creates a simple quadratic Bézier curve between two points. The middle
control point 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.
c<00> <00>||_||_y)z<>
Parameters
----------
angleA : float
Starting angle of the path.
angleB : float
Ending angle of the path.
N)<02>angleA<65>angleB)rHr<>r<>s rKr/zConnectionStyle.Angle3.__init__K s<00><00>!<21>D<EFBFBD>K<EFBFBD> <20>D<EFBFBD>KrLc
<00>\<00>|\}}|\}}tjtj|j<00><00>}tjtj|j<00><00>}tjtj|j
<00><00>} tjtj|j
<00><00>}
t ||||||| |
<EFBFBD>\} } ||f| | f||fg} tjtjtjg}t| |<0E>Sr`)
r6r<><00>radiansr<73>r<>r<>rrrmrS)rHr<>r<>rDrEr<>r<><00>cosA<73>sinA<6E>cosB<73>sinBr6r<>rjris rKrzConnectionStyle.Angle3.connectY s<><00><00><19>F<EFBFBD>B<EFBFBD><02><19>F<EFBFBD>B<EFBFBD><02><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD>%<25>b<EFBFBD>"<22>d<EFBFBD>D<EFBFBD>&(<28>"<22>d<EFBFBD>D<EFBFBD>:<3A>F<EFBFBD>B<EFBFBD><02><1C>R<EFBFBD><08>2<EFBFBD>r<EFBFBD>(<28>R<EFBFBD><12>H<EFBFBD>5<>H<EFBFBD><19>[<5B>[<5B>$<24>+<2B>+<2B>t<EFBFBD>{<7B>{<7B>;<3B>E<EFBFBD><17><08>%<25>(<28> (rLN)<02>Zrr<>r:rLrK<00>Angle3r<33>B s<00><00> <0C> !<21> )rLr<>c<00><00>eZdZdZdd<02>Zd<03>Zy)<06>ConnectionStyle.Angleu]
Creates a piecewise continuous quadratic Bézier 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*.
c<00>.<00>||_||_||_y)a
Parameters
----------
angleA : float
Starting angle of the path.
angleB : float
Ending angle of the path.
rad : float
Rounding radius of the edge.
N)r<>r<>r<>)rHr<>r<>r<>s rKr/zConnectionStyle.Angle.__init__t s<00><00>!<21>D<EFBFBD>K<EFBFBD> <20>D<EFBFBD>K<EFBFBD><1A>D<EFBFBD>HrLc
<00><><00>|\}}|\}}tjtj|j<00><00>}tjtj|j<00><00>}tjtj|j
<00><00>} tjtj|j
<00><00>}
t ||||||| |
<EFBFBD>\} } ||fg} tjg}|jdk(r3| j| | f<02>|jtj<00>n<>|| z
|| z
}}tj||<10>}|j|z }|| z
|| z
}}tj||<14>}|j|z }| j| ||zz| ||zzf| | f| ||zz| ||zzfg<03>|jtjtjtjg<03>| j||f<02>|jtj<00>t| |<0E>S)Nr6)r6r<>r<>r<>r<>r<>rrrmr<>r<>r<>rkr<00>extendrS)rHr<>r<>rDrEr<>r<>r<>r<>r<>r<>r6r<>rjri<00>dx1<78>dy1<79>d1<64>f1<66>dx2<78>dy2<79>d2<64>f2s rKrzConnectionStyle.Angle.connect<63> s<><00><00><19>F<EFBFBD>B<EFBFBD><02><19>F<EFBFBD>B<EFBFBD><02><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD><17>8<EFBFBD>8<EFBFBD>D<EFBFBD>L<EFBFBD>L<EFBFBD><14><1B><1B>5<>6<>D<EFBFBD>%<25>b<EFBFBD>"<22>d<EFBFBD>D<EFBFBD>&(<28>"<22>d<EFBFBD>D<EFBFBD>:<3A>F<EFBFBD>B<EFBFBD><02><1C>R<EFBFBD><08>z<EFBFBD>H<EFBFBD><19>[<5B>[<5B>M<EFBFBD>E<EFBFBD><13>x<EFBFBD>x<EFBFBD>2<EFBFBD>~<7E><18><0F><0F><12>R<EFBFBD><08>)<29><15> <0C> <0C>T<EFBFBD>[<5B>[<5B>)<29><1D><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>S<EFBFBD><03><17>X<EFBFBD>X<EFBFBD>c<EFBFBD>3<EFBFBD>'<27><02><19>X<EFBFBD>X<EFBFBD><02>]<5D><02><1D><02>7<EFBFBD>B<EFBFBD><12>G<EFBFBD>S<EFBFBD><03><17>X<EFBFBD>X<EFBFBD>c<EFBFBD>3<EFBFBD>'<27><02><19>X<EFBFBD>X<EFBFBD><02>]<5D><02><18><0F><0F>"<22>s<EFBFBD>R<EFBFBD>x<EFBFBD>-<2D><12>c<EFBFBD>B<EFBFBD>h<EFBFBD><1D>!?<3F>"$<24>b<EFBFBD><18>"$<24>s<EFBFBD>R<EFBFBD>x<EFBFBD>-<2D><12>c<EFBFBD>B<EFBFBD>h<EFBFBD><1D>!?<3F>!A<01>B<01><16> <0C> <0C>d<EFBFBD>k<EFBFBD>k<EFBFBD>4<EFBFBD>;<3B>;<3B><04> <0B> <0B>D<>E<> <14>O<EFBFBD>O<EFBFBD>R<EFBFBD><12>H<EFBFBD> %<25> <11>L<EFBFBD>L<EFBFBD><14><1B><1B> %<25><17><08>%<25>(<28> (rLN)r<>rr6r<>r:rLrK<00>Angler<65>j s<00><00> <0C> <1B>&! )rLr<>c<00><00>eZdZdZdd<03>Zd<04>Zy)<06>ConnectionStyle.Arcu?
Creates a piecewise continuous quadratic Bézier 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*.
Nc<00>J<00>||_||_||_||_||_y)a<>
Parameters
----------
angleA : float
Starting angle of the path.
angleB : float
Ending angle of the path.
armA : float or None
Length of the starting arm.
armB : float or None
Length of the ending arm.
rad : float
Rounding radius of the edges.
N)r<>r<><00>armA<6D>armBr<42>)rHr<>r<>r<>r<>r<>s rKr/zConnectionStyle.Arc.__init__<5F> s'<00><00>(!<21>D<EFBFBD>K<EFBFBD> <20>D<EFBFBD>K<EFBFBD><1C>D<EFBFBD>I<EFBFBD><1C>D<EFBFBD>I<EFBFBD><1A>D<EFBFBD>HrLc<00><><00>|\}}|\}}||fg}g}tjg} |jr<>tjtj
|j <00><00>}
tjtj
|j <00><00>} |j|jz
} |j|| |
zz|| | zzf<02>|j} |j|| |
zz|| | zzf<02>|j<00>r|tjtj
|j<00><00>} tjtj
|j<00><00>}||j| zz||j|zz}}|r<>|d\}}||z
||z
}}||z||zzdz}|j||j|z|z z||j|z|z zf<02>|j|<08>| jtjtjtjg<03>n |d\}}||z
||z
}}||z||zzdz}||jz
} || |z|z z|| |z|z zf||fg}|r<>|d\}}||z
||z
}}||z||zzdz}|j||j|z|z z||j|z|z zf<02>|j|<08>| jtjtjtjg<03>|j||f<02>| jtj<00>t|| <09>S)Nr<4E>r)rrmr<>r6r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rS)rHr<>r<>rDrEr<>r<>rj<00>roundedrir<>r<><00>dr<64>r<><00>x_armB<6D>y_armB<6D>xp<78>ypr r
<00>dds rKrzConnectionStyle.Arc.connect<63> s<00><00><19>F<EFBFBD>B<EFBFBD><02><19>F<EFBFBD>B<EFBFBD><02><1B>R<EFBFBD><08>z<EFBFBD>H<EFBFBD><18>G<EFBFBD><19>[<5B>[<5B>M<EFBFBD>E<EFBFBD><13>y<EFBFBD>y<EFBFBD><1B>x<EFBFBD>x<EFBFBD><04> <0C> <0C>T<EFBFBD>[<5B>[<5B> 9<>:<3A><04><1B>x<EFBFBD>x<EFBFBD><04> <0C> <0C>T<EFBFBD>[<5B>[<5B> 9<>:<3A><04><18>I<EFBFBD>I<EFBFBD><04><08><08>(<28><01><17><0E><0E><02>Q<EFBFBD><14>X<EFBFBD> <0A>r<EFBFBD>A<EFBFBD><04>H<EFBFBD>}<7D>=<3D>><3E><18>I<EFBFBD>I<EFBFBD><01><17><0E><0E><02>Q<EFBFBD><14>X<EFBFBD> <0A>r<EFBFBD>A<EFBFBD><04>H<EFBFBD>}<7D>=<3D>><3E><13>y<EFBFBD>y<EFBFBD><1B>x<EFBFBD>x<EFBFBD><04> <0C> <0C>T<EFBFBD>[<5B>[<5B> 9<>:<3A><04><1B>x<EFBFBD>x<EFBFBD><04> <0C> <0C>T<EFBFBD>[<5B>[<5B> 9<>:<3A><04>!#<23>d<EFBFBD>i<EFBFBD>i<EFBFBD>$<24>&6<>!6<><02>T<EFBFBD>Y<EFBFBD>Y<EFBFBD><14>=M<>8M<38><06><06><1A>$<24>R<EFBFBD>[<5B>F<EFBFBD>B<EFBFBD><02>#<23>b<EFBFBD>[<5B>&<26>2<EFBFBD>+<2B><02>B<EFBFBD><1C>r<EFBFBD>'<27>B<EFBFBD><12>G<EFBFBD>+<2B><02>2<>B<EFBFBD><1B>N<EFBFBD>N<EFBFBD>B<EFBFBD><14><18><18>B<EFBFBD><1D><12>);<3B>$;<3B>$&<26><14><18><18>B<EFBFBD><1D><12>);<3B>$;<3B>$=<3D>><3E><1C>O<EFBFBD>O<EFBFBD>G<EFBFBD>,<2C><19>L<EFBFBD>L<EFBFBD>$<24>+<2B>+<2B>"&<26>+<2B>+<2B>"&<26>+<2B>+<2B>"/<2F>0<>&<26>b<EFBFBD>\<5C>F<EFBFBD>B<EFBFBD><02>#<23>b<EFBFBD>[<5B>&<26>2<EFBFBD>+<2B><02>B<EFBFBD><1C>r<EFBFBD>'<27>B<EFBFBD><12>G<EFBFBD>+<2B><02>2<>B<EFBFBD><16><14><18><18>M<EFBFBD><01><1E><11>R<EFBFBD><16>"<22><1B>,<2C>b<EFBFBD>1<EFBFBD>r<EFBFBD>6<EFBFBD>B<EFBFBD>;<3B>.><3E>?<3F>"<22>F<EFBFBD>+<2B>-<2D><07><17> <20><12><1B><06><02>B<EFBFBD><1B>b<EFBFBD><17>"<22>r<EFBFBD>'<27>B<EFBFBD><02><18>2<EFBFBD>g<EFBFBD><02>R<EFBFBD><07>'<27>B<EFBFBD>.<2E><02><17><0E><0E><02>T<EFBFBD>X<EFBFBD>X<EFBFBD><02>]<5D>R<EFBFBD>%7<> 7<> "<22>T<EFBFBD>X<EFBFBD>X<EFBFBD><02>]<5D>R<EFBFBD>%7<> 7<> 9<>:<3A><18><0F><0F><07>(<28><15> <0C> <0C>d<EFBFBD>k<EFBFBD>k<EFBFBD>"<22>k<EFBFBD>k<EFBFBD>"<22>k<EFBFBD>k<EFBFBD>+<2B>,<2C> <15>O<EFBFBD>O<EFBFBD>R<EFBFBD><12>H<EFBFBD> %<25> <11>L<EFBFBD>L<EFBFBD><14><1B><1B> %<25><17><08>%<25>(<28> (rL)rrNNr6r<>r:rLrKr<>r<><00> s<00><00> <0C> <1B>69 )rLr<>c<00><00>eZdZdZdd<03>Zd<04>Zy)<06>ConnectionStyle.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*.
Nc<00><<00>||_||_||_||_y)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)r<>r<><00>fractionr2)rHr<>r<>r<>r2s rKr/zConnectionStyle.Bar.__init__ s <00><00>"<1D>D<EFBFBD>I<EFBFBD><1C>D<EFBFBD>I<EFBFBD>$<24>D<EFBFBD>M<EFBFBD><1E>D<EFBFBD>JrLc<00>r<00>|\}}|x\}}\}}tj||z
||z
<00>} ||z
||z
} }
|
|
z| | zzdz} |
| z | | z }} |j|j}}|j<00><>t j |j<00>}| |z
}| tj|<12>z}| tj|<12>z}||tj|<11>zz||tj|<11>zz}}||z
}||z
||z
} }
|
|
z| | zzdz}|
|z | |z }} t||<10>}|j| z|z}|||zz||| zz
}}|||zz||| zz
}}||f||f||f||fg}tjtjtjtjg}t||<1D>S)Nr)r6<00>atan2r<32>r<>r2rkr<>r<>r<>rr<>rrmr<>)rHr<>r<>rDrE<00>x20<32>y20r<30>r<>r<>r r
r<><00>ddx<64>ddyr<79>r<><00>theta0<61>dtheta<74>dl<64>dL<64>dd2<64>armr<6D><00>cx1<78>cy1<79>cx2<78>cy2rjris rKrzConnectionStyle.Bar.connect) s<><00><00><19>F<EFBFBD>B<EFBFBD><02> $<24> $<24>H<EFBFBD>C<EFBFBD><13>v<EFBFBD>r<EFBFBD>2<EFBFBD><19>Z<EFBFBD>Z<EFBFBD><02>R<EFBFBD><07><12>b<EFBFBD><17>1<>F<EFBFBD><17>"<22>W<EFBFBD>b<EFBFBD>2<EFBFBD>g<EFBFBD><02>B<EFBFBD><14>r<EFBFBD>'<27>B<EFBFBD><12>G<EFBFBD>#<23><02>*<2A>B<EFBFBD><19>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07><13>C<EFBFBD><1D><19><19>D<EFBFBD>I<EFBFBD>I<EFBFBD>$<24>D<EFBFBD><13>z<EFBFBD>z<EFBFBD>%<25><1B><1A><1A>D<EFBFBD>J<EFBFBD>J<EFBFBD>/<2F><06><1F>&<26><1F><06><17>$<24>(<28>(<28>6<EFBFBD>*<2A>*<2A><02><17>$<24>(<28>(<28>6<EFBFBD>*<2A>*<2A><02><1B>b<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>F<EFBFBD>#3<>3<>3<>R<EFBFBD>"<22>t<EFBFBD>x<EFBFBD>x<EFBFBD><06>?O<>:O<>5O<35>B<EFBFBD><02><1B>b<EFBFBD>y<EFBFBD><04><1C>b<EFBFBD><17>"<22>r<EFBFBD>'<27>B<EFBFBD><02><19>B<EFBFBD>w<EFBFBD><12>b<EFBFBD><17>(<28>R<EFBFBD>/<2F><03><1D><03>8<EFBFBD>R<EFBFBD>#<23>X<EFBFBD>S<EFBFBD><03><15>d<EFBFBD>D<EFBFBD>/<2F>C<EFBFBD><14> <0A> <0A><02>"<22>S<EFBFBD>(<28>A<EFBFBD><19>A<EFBFBD><03>G<EFBFBD>|<7C>R<EFBFBD>!<21>c<EFBFBD>'<27>\<5C><13>C<EFBFBD><19>A<EFBFBD><03>G<EFBFBD>|<7C>R<EFBFBD>!<21>c<EFBFBD>'<27>\<5C><13>C<EFBFBD><1B>R<EFBFBD><08><1C>c<EFBFBD>
<EFBFBD><1C>c<EFBFBD>
<EFBFBD><1C>c<EFBFBD>
<EFBFBD>$<24>H<EFBFBD><1A>[<5B>[<5B><19>[<5B>[<5B><19>[<5B>[<5B><19>[<5B>[<5B>"<22>E<EFBFBD>
<18><08>%<25>(<28> (rL)r6r6rNr<4E>r:rLrK<00>Barr<72>
s<00><00> <0C> <1F>,' )rLr<>N) rrrrr<>rrr<>r<>r<>r<>r<>r:rLrKrsrs<00>
s<><00><00>"<08>H<15>K<EFBFBD>9<18>9<18>v<15>[<5B>!<21>#)<29>u<EFBFBD>#)<29>"<22>#)<29>J<15>[<5B>!<21>%)<29><15>%)<29>"<22>%)<29>N<15>[<5B>!<21>=)<29><05>=)<29>"<22>=)<29>~<15>[<5B>!<21>])<29>e<EFBFBD>])<29>"<22>])<29>~<15>[<5B>!<21>E)<29>e<EFBFBD>E)<29>"<22>E)rLrsc<00>`<00>||z
||z
}}|||z||zzdzz }|||zz
|||zz
} }|| fS)z{
Return the point on the line connecting (*x0*, *y0*) -- (*x1*, *y1*) whose
distance from (*x0*, *y0*) is *d*.
rr:)
rBrCrDrEr<>r r
<00>ffr<66>r<>s
rK<00>_point_along_a_liner<65>S sS<00><00>
<10>"<22>W<EFBFBD>b<EFBFBD>2<EFBFBD>g<EFBFBD><02>B<EFBFBD>
<EFBFBD>b<EFBFBD>2<EFBFBD>g<EFBFBD><02>R<EFBFBD><07><1F>B<EFBFBD> &<26> &<26>B<EFBFBD> <0F>"<22>r<EFBFBD>'<27>\<5C>2<EFBFBD><02>R<EFBFBD><07><<3C><02>B<EFBFBD> <0A>r<EFBFBD>6<EFBFBD>MrLc<00>2<00>eZdZdZiZGd<02>d<03>ZGd<04>de<05>Zeed<06><07>Gd<08>d e<06><00>Zeed
<EFBFBD><07>Gd <0B>d e<06><00>Z eed <0A><07>Gd<0E>de<06><00>Z
eed<10><07>Gd<11>de<06><00>Z eed<13><07>Gd<14>de<06><00>Z eed<16><07>Gd<17>de<06><00>Z eed<19><07>Gd<1A>de<06><00>Zeed<1C><07>Gd<1D>de<06><00>Zeed<1F><07>Gd <20>d!e<06><00>Zeed"<22><07>Gd#<23>d$e<06><00>Zeed%<25><07>Gd&<26>d'e<06><00>Zeed(<28><07>Gd)<29>d*e<06><00>Zeed+<2B><07>Gd,<2C>d-e<06><00>Zee<04>Gd.<2E>d/e<05><00>Zee<04>Gd0<64>d1e<05><00>Zee<04>Gd2<64>d3e<05><00>Zy4)5<>
ArrowStyleaF
`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 `FancyArrowPatch`.
An 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
%(ArrowStyle:table)s
For an overview of the visual appearance, see
:doc:`/gallery/text_labels_and_annotations/fancyarrow_demo`.
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 `.Path` instance and a boolean
value. *path* is a `.Path` instance along which the arrow
will be drawn. *mutation_size* and *aspect_ratio* have the same
meaning as in `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.
Notes
-----
*angleA* and *angleB* specify the orientation of the bracket, as either a
clockwise or counterclockwise angle depending on the arrow type. 0 degrees
means perpendicular to the line connecting the arrow's head and tail.
.. plot:: gallery/text_labels_and_annotations/angles_on_bracket_arrows.py
c<00>0<00>eZdZdZed<02><00>Zd<03>Z dd<04>Zy)<07>ArrowStyle._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<00><><00>t|j<00><00>}t|<01>dk7s2|ddtjk7s|ddtj
k7r t d<04><00>g|dd<00>|dd<00>S)uR
Some ArrowStyle classes only works with a simple quadratic
Bézier curve (created with `.ConnectionStyle.Arc3` or
`.ConnectionStyle.Angle3`). This static method checks if the
provided path is a simple quadratic Bézier curve and returns its
control points if true.
rQrrz,'path' is not a valid quadratic Bezier curve)<07>list<73> iter_segmentsrFrrmrSr)rR<00>segmentss rK<00>ensure_quadratic_bezierz(ArrowStyle._Base.ensure_quadratic_bezier<65> s|<00><00><1C>D<EFBFBD>.<2E>.<2E>0<>1<>H<EFBFBD><13>H<EFBFBD> <0A><11>"<22>h<EFBFBD>q<EFBFBD>k<EFBFBD>!<21>n<EFBFBD><04> <0B> <0B>&C<><1C>Q<EFBFBD>K<EFBFBD><01>N<EFBFBD>d<EFBFBD>k<EFBFBD>k<EFBFBD>1<> <20>B<>D<01>D<01>5<>X<EFBFBD>a<EFBFBD>[<5B><11>^<5E>5<>h<EFBFBD>q<EFBFBD>k<EFBFBD>!<21>n<EFBFBD>5<> 5rLc<00><00>td<01><00>)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 the same length.
r<>r<>)rHrRr(r%s rK<00> transmutezArrowStyle._Base.transmute<74> s<00><00>&<26>&=<3D>><3E> >rLc<00>N<00>|<04><>|jd|gz }t||j<00>}|j|||<03>\}}t j
|<08>r6|D<00> cgc]'} t| jd|gz| j<00><00><02>)}
} |
|fS||fS|j|||<03>Scc} w)z<>
The __call__ method is a thin wrapper around the transmute method
and takes care of the aspect ratio.
r)rjrrir<>rk<00>iterable) rHrRr(r%<00> aspect_ratiorj<00> path_shrunk<6E> path_mutated<65>fillablerC<00> path_lists rKr)zArrowStyle._Base.__call__<5F> s<><00><00><1C>'<27><1F>=<3D>=<3D>A<EFBFBD>|<7C>+<<3C><<3C><08>"<22>8<EFBFBD>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>8<> <0B>)-<2D><1E><1E> <0B>8E<38>8A<38>*C<01>&<26> <0C>h<EFBFBD><16>;<3B>;<3B>x<EFBFBD>(<28>+7<>!8<>%&<26>"&<26>a<EFBFBD>j<EFBFBD>j<EFBFBD>A<EFBFBD>|<7C>3D<33>&D<>a<EFBFBD>g<EFBFBD>g<EFBFBD>!N<>!8<>I<EFBFBD>!8<>$<24>h<EFBFBD>.<2E>.<2E>'<27><18>1<>1<><1B>~<7E>~<7E>d<EFBFBD>M<EFBFBD>9<EFBFBD>E<>E<><45> !8s<00>,B"N)r9)rrrr<00> staticmethodr<64>r<>r)r:rLrKrr<><00> s+<00><00> <0C>
<16> 6<>
<16> 6<> ?<3F>#%<25> FrLrc<00>H<00><00>eZdZdZdZdxZZ d<08>fd<04> Zd<05>Zd<06>Z d<07>Z
<EFBFBD>xZ S) <09>ArrowStyle._Curvea9
A simple arrow which will work with any path instance. The
returned path is the concatenation of the original path, and at
most two paths representing the arrow head or bracket at the start
point and at the end point. The arrow heads can be either open
or closed.
<20>-Fc <00>d<00><01>||c|_|_||c|_|_||c|_|_||c|_|_| |
c|_|_ d|_
d|_ d|_ d|_ d|jvr td<03><00>|jj!dd<04>\} } | dk(rd|_
d|_ n-| dk(rd|_
d|_ d|_n| dvrd|_
d|_ | d k(rd|_ d|_ n-| d
k(rd|_ d|_ d|_n| d vrd|_ d|_ t&<00> |<00>Q<00>y ) a<>
Parameters
----------
head_length : float, default: 0.4
Length of the arrow head, relative to *mutation_size*.
head_width : float, default: 0.2
Width of the arrow head, relative to *mutation_size*.
widthA, widthB : float, default: 1.0
Width of the bracket.
lengthA, lengthB : float, default: 0.2
Length of the bracket.
angleA, angleB : float, default: 0
Orientation of the bracket, as a counterclockwise angle.
0 degrees means perpendicular to the line.
scaleA, scaleB : float, default: *mutation_size*
The scale of the brackets.
Fr<46>z-arrow must have the '-' between the two headsr<00><Tz<|)r<>r<><00>>z|>)<02>[r<>N)rr<00>widthA<68>widthB<68>lengthA<68>lengthBr<42>r<><00>scaleA<65>scaleB<65>_beginarrow_head<61>_beginarrow_bracket<65>_endarrow_head<61>_endarrow_bracket<65>arrowrro<00> fillbegin<69>fillendr.r/)rHrrr<>r<>r<>r<>r<>r<>r<>r<><00>
beginarrow<EFBFBD>endarrowrJs <20>rKr/zArrowStyle._Curve.__init__<5F> sY<00><><00>*1<<3C>Z<EFBFBD> -<2D>D<EFBFBD> <1C>d<EFBFBD>o<EFBFBD>'-<2D>v<EFBFBD> $<24>D<EFBFBD>K<EFBFBD><14><1B>)0<>'<27> &<26>D<EFBFBD>L<EFBFBD>$<24>,<2C>'-<2D>v<EFBFBD> $<24>D<EFBFBD>K<EFBFBD><14><1B>'-<2D>v<EFBFBD> $<24>D<EFBFBD>K<EFBFBD><14><1B>$)<29>D<EFBFBD> !<21>',<2C>D<EFBFBD> $<24>"'<27>D<EFBFBD> <1F>%*<2A>D<EFBFBD> "<22><12>$<24>*<2A>*<2A>$<24> <20>"1<>2<>2<>$(<28>:<3A>:<3A>#3<>#3<>C<EFBFBD><11>#;<3B> <20>J<EFBFBD><08><19>S<EFBFBD> <20>(,<2C><04>%<25>+0<><04>(<28><1B>t<EFBFBD>#<23>(,<2C><04>%<25>+0<><04>(<28>!%<25><04><0E><1B>z<EFBFBD>)<29>(-<2D><04>%<25>+/<2F><04>(<28><17>3<EFBFBD><EFBFBD>&*<2A><04>#<23>).<2E><04>&<26><19>T<EFBFBD>!<21>&*<2A><04>#<23>).<2E><04>&<26>#<23><04> <0C><19>Z<EFBFBD>'<27>&+<2B><04>#<23>)-<2D><04>&<26> <11>G<EFBFBD> <1C> rLc <00><><00>||z
||z
}
} tj| |
<EFBFBD>} d|z|z } | dk(rd} | | z| z } | |
z| z }| | z |z} |
| z |z}
|| z||
zz| | z||
zz}}|| z||
zz
|| z||
zz}}|| z|z||z|zf|| z||zf|| z|z||z|zfg}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.
rrr)rkrrrmr<>)rHrBrCrDrE<00> head_dist<73>cos_t<5F>sin_tr%r r
<00> cp_distance<63> pad_projectedr<64>r<>r<>r<>r<>r<><00>vertices_arrow<6F> codes_arrows rK<00>_get_arrow_wedgez"ArrowStyle._Curve._get_arrow_wedge" sC<00><00><18>"<22>W<EFBFBD>b<EFBFBD>2<EFBFBD>g<EFBFBD><02>B<EFBFBD><1C>(<28>(<28>2<EFBFBD>r<EFBFBD>*<2A>K<EFBFBD> <20>)<29>^<5E>e<EFBFBD>3<>M<EFBFBD><1B>a<EFBFBD><1F><1F> <0B> <20>"<22>$<24>{<7B>2<>C<EFBFBD><1F>"<22>$<24>{<7B>2<>C<EFBFBD><14>k<EFBFBD>!<21>I<EFBFBD>-<2D>B<EFBFBD><13>k<EFBFBD>!<21>I<EFBFBD>-<2D>B<EFBFBD><1C>r<EFBFBD>z<EFBFBD>E<EFBFBD>B<EFBFBD>J<EFBFBD>.<2E><15><06><12> <0B>e<EFBFBD>b<EFBFBD>j<EFBFBD>0H<30><13>C<EFBFBD><1C>r<EFBFBD>z<EFBFBD>E<EFBFBD>B<EFBFBD>J<EFBFBD>.<2E><05><02>
<EFBFBD>U<EFBFBD>R<EFBFBD>Z<EFBFBD>0G<EFBFBD><13>C<EFBFBD>!<21>C<EFBFBD>x<EFBFBD>#<23>~<7E>r<EFBFBD>C<EFBFBD>x<EFBFBD>#<23>~<7E>><3E>!<21>C<EFBFBD>x<EFBFBD><12>c<EFBFBD><18>2<>!<21>C<EFBFBD>x<EFBFBD>#<23>~<7E>r<EFBFBD>C<EFBFBD>x<EFBFBD>#<23>~<7E>><3E>@<01>N<EFBFBD> <20>;<3B>;<3B><1F>;<3B>;<3B><1F>;<3B>;<3B>(<28>K<EFBFBD>"<22>;<3B><03>S<EFBFBD>8<> 8rLc<00><><00>t||||<02>\}} ddlm}
|
|||| |<05>\}}} } ||z|| z}} || z||zf||f| | f| | z| |zfg}tjtj
tj
tj
g}|r6t j<00>j|||<07>}|j|<0F>}||fS)Nr)<01>get_normal_points)
r<00>matplotlib.bezierrrrmr<>rr<00>rotate_deg_aroundr<64>)rHrBrCrDrEr=r/r2r<>r<>rr<>r<>r r
rrrQs rK<00> _get_bracketzArrowStyle._Curve._get_bracketL s<><00><00>'<27>r<EFBFBD>2<EFBFBD>r<EFBFBD>2<EFBFBD>6<>L<EFBFBD>E<EFBFBD>5<EFBFBD> <<3C>.<2E>r<EFBFBD>2<EFBFBD>u<EFBFBD>e<EFBFBD>U<EFBFBD>K<>N<EFBFBD>B<EFBFBD><02>B<EFBFBD><02><1B>e<EFBFBD>^<5E>V<EFBFBD>e<EFBFBD>^<5E><02>B<EFBFBD>!<21>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>0<>!<21>2<EFBFBD>h<EFBFBD>!<21>2<EFBFBD>h<EFBFBD>!<21>B<EFBFBD>w<EFBFBD><02>R<EFBFBD><07>0<>2<>N<EFBFBD> <20>;<3B>;<3B><1F>;<3B>;<3B><1F>;<3B>;<3B><1F>;<3B>;<3B>(<28>K<EFBFBD>
<15>"<22>+<2B>+<2B>-<2D>?<3F>?<3F><02>B<EFBFBD><05>N<><05>!&<26><1F><1F><1E>!@<40><0E>!<21>;<3B>.<2E> .rLc
<00><><00>|js |jr>|j|z}|j|z}t j
||<05>}||z ||z }}|j <00>|n |j } |j<00>|n |j}
|jd\} } |jd\} }|jxr | | f| |fk7}|r|j| || | |<03>nggddf\}}}}|jd\}}|jd\}}|jxr ||f||fk7}|r|j|||||<03>nggddf\}}}}tt j| |z| |zfg|jdd||z||zfgg<03>|j<00>g}dg}|r||jrC|jtg|<10>d<06>g|<11>tj<00><01><00>|jd<07>n<>|jt||<11><00>|jd<05>n<>|j r<>|jd\} } |jd\} }|j#| | | ||j$| z|j&| z|j(<00>\}}|jt||<11><00>|jd<05>|r<>|j*rF|jd<07>|jtg|<19>d<06>g|<1A>tj<00><01><00>||fS|jd<05>|jt||<1A><00>||fS|j,r<>|jd\} } |jd\} }|j#| | | ||j.|
z|j0|
z|j2<00>\}}|jt||<1A><00>|jd<05>||fS)Nrrr+r<>Fr\T)r<>r<>rrrkrr<>r<>rjrrr<>rir<>r<>r<>r<>r r<>r<>r<>r<>r<>r<>r<>r<>)rHrRr(r%rrr<>r<>r<>r<>r<>rBrCrDrE<00>has_begin_arrow<6F> verticesA<73>codesA<73>ddxA<78>ddyAr<41>r<><00>x3<78>y3<79> has_end_arrow<6F> verticesB<73>codesB<73>ddxB<78>ddyB<79>paths<68>fillss rKr<>zArrowStyle._Curve.transmutef s<><00><00><13>$<24>$<24><04>(;<3B>(;<3B>"<22>.<2E>.<2E><1D>><3E> <0B>!<21>_<EFBFBD>_<EFBFBD>}<7D><<3C>
<EFBFBD><1E>H<EFBFBD>H<EFBFBD>[<5B>*<2A>=<3D> <09>*<2A>Y<EFBFBD>6<>
<EFBFBD>Y<EFBFBD>8N<EFBFBD>u<EFBFBD><05>&*<2A>k<EFBFBD>k<EFBFBD>&9<>]<5D>t<EFBFBD>{<7B>{<7B>F<EFBFBD>&*<2A>k<EFBFBD>k<EFBFBD>&9<>]<5D>t<EFBFBD>{<7B>{<7B>F<EFBFBD><1A>]<5D>]<5D>1<EFBFBD>%<25>F<EFBFBD>B<EFBFBD><02><19>]<5D>]<5D>1<EFBFBD>%<25>F<EFBFBD>B<EFBFBD><02>#<23>3<>3<>L<><12>R<EFBFBD><08>R<EFBFBD><12>H<EFBFBD>8L<38>O<EFBFBD>#<23><15>%<25>%<25>b<EFBFBD>"<22>b<EFBFBD>"<22>&/<2F><15><05>y<EFBFBD>J<01><19>"<22>a<EFBFBD><11>^<5E> *<2A>I<EFBFBD>v<EFBFBD>t<EFBFBD>T<EFBFBD><1A>]<5D>]<5D>2<EFBFBD>&<26>F<EFBFBD>B<EFBFBD><02><19>]<5D>]<5D>2<EFBFBD>&<26>F<EFBFBD>B<EFBFBD><02>!<21>/<2F>/<2F>H<>R<EFBFBD><12>H<EFBFBD><12>R<EFBFBD><08>4H<34>M<EFBFBD>!<21><15>%<25>%<25>b<EFBFBD>"<22>b<EFBFBD>"<22>&/<2F><15><05>y<EFBFBD>J<01><19>"<22>a<EFBFBD><11>^<5E> *<2A>I<EFBFBD>v<EFBFBD>t<EFBFBD>T<EFBFBD><1A>"<22>.<2E>.<2E>B<EFBFBD><14>I<EFBFBD>r<EFBFBD>D<EFBFBD>y<EFBFBD>+A<>*B<>*.<2E>-<2D>-<2D><01>"<22>*=<3D>,.<2E><14>I<EFBFBD>r<EFBFBD>D<EFBFBD>y<EFBFBD>+A<>*B<>*D<01>E<01><1F>*<2A>*<2A>&<26>'<27>E<EFBFBD><1B>G<EFBFBD>E<EFBFBD><1E><17>><3E>><3E><19>L<EFBFBD>L<EFBFBD><1C>1<>y<EFBFBD>1<>&<26>1<>3L<33>V<EFBFBD>3L<33>T<EFBFBD>^<5E>^<5E>3L<33>M<>O<01><19>L<EFBFBD>L<EFBFBD><14>&<26><19>L<EFBFBD>L<EFBFBD><14>i<EFBFBD><16>!8<>9<><19>L<EFBFBD>L<EFBFBD><15>'<27><15>)<29>)<29><1D><1D><1D>q<EFBFBD>)<29><06><02>B<EFBFBD><1D><1D><1D>q<EFBFBD>)<29><06><02>B<EFBFBD>$(<28>$5<>$5<>b<EFBFBD>"<22>b<EFBFBD>"<22>6:<3A>k<EFBFBD>k<EFBFBD>F<EFBFBD>6J<36>6:<3A>l<EFBFBD>l<EFBFBD>V<EFBFBD>6K<36>6:<3A>k<EFBFBD>k<EFBFBD>%C<01>!<21> <09>6<EFBFBD>
<16> <0C> <0C>T<EFBFBD>)<29>V<EFBFBD>4<>5<><15> <0C> <0C>U<EFBFBD>#<23><1C><17><<3C><<3C><19>L<EFBFBD>L<EFBFBD><14>&<26><19>L<EFBFBD>L<EFBFBD><1C>1<>y<EFBFBD>1<>&<26>1<>3L<33>V<EFBFBD>3L<33>T<EFBFBD>^<5E>^<5E>3L<33>M<>O<01> <19>%<25><<3C> <1F><1A>L<EFBFBD>L<EFBFBD><15>'<27><19>L<EFBFBD>L<EFBFBD><14>i<EFBFBD><16>!8<>9<><19>%<25><<3C> <1F><16>'<27>'<27><1D><1D><1D>r<EFBFBD>*<2A><06><02>B<EFBFBD><1D><1D><1D>r<EFBFBD>*<2A><06><02>B<EFBFBD>$(<28>$5<>$5<>b<EFBFBD>"<22>b<EFBFBD>"<22>6:<3A>k<EFBFBD>k<EFBFBD>F<EFBFBD>6J<36>6:<3A>l<EFBFBD>l<EFBFBD>V<EFBFBD>6K<36>6:<3A>k<EFBFBD>k<EFBFBD>%C<01>!<21> <09>6<EFBFBD>
<16> <0C> <0C>T<EFBFBD>)<29>V<EFBFBD>4<>5<><15> <0C> <0C>U<EFBFBD>#<23><18>%<25><<3C> rL)
皙<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>?皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?r9r9rrrrNN) rrrrr<>r<>r<>r/rr r<>r rs@rK<00>_Curver<65><00> s9<00><><00> <0C><14><05>#<23>#<23> <09>G<EFBFBD>LN<4C>JN<4A> <20>< <1F>|( 9<>T /<2F>4S rLrr<>rc<00>"<00><00>eZdZdZ<03>fd<02>Z<04>xZS)<03>ArrowStyle.Curvez&A simple curve without any arrow head.c<00>(<00><01>t<00>|<00>dd<02><03>y)Nrr)rrr@)rHrJs <20>rKr/zArrowStyle.Curve.__init__<5F> s<00><><00> <12>G<EFBFBD> <1C><12><02> <1C> ;rL)rrrrr/r rs@rK<00>Curver<00> s<00><><00>4<> <<3C> <rLr<00><-c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveAz(An arrow with a head at its start point.r N<>rrrrr<>r:rLrK<00>CurveAr"<00> s
<00><00>6<><14>rLr$<00>->c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveBz&An arrow with a head at its end point.r%Nr#r:rLrK<00>CurveBr'<00> s
<00><00>4<><14>rLr(<00><->c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveABz8An arrow with heads both at the start and the end point.r)Nr#r:rLrK<00>CurveABr+<00> s
<00><00>F<><15>rLr,<00><|-c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveFilledAz0An arrow with filled triangle head at the start.r-Nr#r:rLrK<00> CurveFilledAr/<00> s
<00><00>><3E><15>rLr0<00>-|>c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveFilledBz.An arrow with filled triangle head at the end.r1Nr#r:rLrK<00> CurveFilledBr3<00> s
<00><00><<3C><15>rLr4<00><|-|>c<00><00>eZdZdZdZy)<04>ArrowStyle.CurveFilledABz1An arrow with filled triangle heads at both ends.r5Nr#r:rLrK<00> CurveFilledABr7<00> s
<00><00>?<3F><17>rLr8<00>]-c<00>(<00><00>eZdZdZdZd<04>fd<03> Z<05>xZS)<05>ArrowStyle.BracketAz5An arrow with an outward square bracket at its start.r9c<00>*<00><01>t<00>|<00>|||<03><01>y<02>a<>
Parameters
----------
widthA : float, default: 1.0
Width of the bracket.
lengthA : float, default: 0.2
Length of the bracket.
angleA : float, default: 0 degrees
Orientation of the bracket, as a counterclockwise angle.
0 degrees means perpendicular to the line.
)r<>r<>r<>Nr@<00>rHr<>r<>r<>rJs <20>rKr/zArrowStyle.BracketA.__init__<5F> <00><00><><00> <12>G<EFBFBD> <1C>F<EFBFBD>G<EFBFBD>F<EFBFBD> <1C> KrL<00>r9rr<00>rrrrr<>r/r rs@rK<00>BracketAr;<00> s<00><><00>C<><14><05> L<01> LrLrB<00>-[c<00>(<00><00>eZdZdZdZd<04>fd<03> Z<05>xZS)<05>ArrowStyle.BracketBz3An arrow with an outward square bracket at its end.rCc<00>*<00><01>t<00>|<00>|||<03><01>y<02>a<>
Parameters
----------
widthB : float, default: 1.0
Width of the bracket.
lengthB : float, default: 0.2
Length of the bracket.
angleB : float, default: 0 degrees
Orientation of the bracket, as a counterclockwise angle.
0 degrees means perpendicular to the line.
)r<>r<>r<>Nr@<00>rHr<>r<>r<>rJs <20>rKr/zArrowStyle.BracketB.__init__<5F> r?rLr@rArs@rK<00>BracketBrE<00> s<00><><00>A<><14><05> L<01> LrLrI<00>]-[c<00>,<00><00>eZdZdZdZ d<04>fd<03> Z<05>xZS)<05>ArrowStyle.BracketABz3An arrow with outward square brackets at both ends.rJc<00>0<00><01>t<00>|<00>||||||<06><01>y)a<>
Parameters
----------
widthA, widthB : float, default: 1.0
Width of the bracket.
lengthA, lengthB : float, default: 0.2
Length of the bracket.
angleA, angleB : float, default: 0 degrees
Orientation of the bracket, as a counterclockwise angle.
0 degrees means perpendicular to the line.
<20>r<>r<>r<>r<>r<>r<>Nr@)rHr<>r<>r<>r<>r<>r<>rJs <20>rKr/zArrowStyle.BracketAB.__init__ s%<00><><00> <12>G<EFBFBD> <1C>F<EFBFBD>G<EFBFBD>F<EFBFBD>$*<2A>G<EFBFBD>F<EFBFBD> <1D> LrL)r9rrr9rrrArs@rK<00> BracketABrLs<00><><00>A<><15><05>56<35>45<34> L<01> LrLrO<00>|-|c<00>(<00><00>eZdZdZdZd<04>fd<03> Z<05>xZS)<05>ArrowStyle.BarABz/An arrow with vertical bars ``|`` at both ends.rPc<00>0<00><01>t<00>|<00>|d||d|<04><02>y)aM
Parameters
----------
widthA, widthB : float, default: 1.0
Width of the bracket.
angleA, angleB : float, default: 0 degrees
Orientation of the bracket, as a counterclockwise angle.
0 degrees means perpendicular to the line.
rrNNr@)rHr<>r<>r<>r<>rJs <20>rKr/zArrowStyle.BarAB.__init__#s%<00><><00> <12>G<EFBFBD> <1C>F<EFBFBD>A<EFBFBD>f<EFBFBD>$*<2A>A<EFBFBD>f<EFBFBD> <1D> FrL)r9rr9rrArs@rK<00>BarABrRs<00><><00>=<3D><15><05> F<01> FrLrT<00>]->c<00>(<00><00>eZdZdZdZd<04>fd<03> Z<05>xZS)<05>ArrowStyle.BracketCurveze
An arrow with an outward square bracket at its start and a head at
the end.
rUc<00>*<00><01>t<00>|<00>|||<03><01>yr=r@r>s <20>rKr/z ArrowStyle.BracketCurve.__init__8r?rL<00>r9rNrArs@rK<00> BracketCurverW0<00><00><><00> <0C><16><05> L<01> LrLrZ<00><-[c<00>(<00><00>eZdZdZdZd<04>fd<03> Z<05>xZS)<05>ArrowStyle.CurveBracketze
An arrow with an outward square bracket at its end and a head at
the start.
r\c<00>*<00><01>t<00>|<00>|||<03><01>yrGr@rHs <20>rKr/z ArrowStyle.CurveBracket.__init__Nr?rLrYrArs@rK<00> CurveBracketr^Fr[rLr`c<00>*<00><00>eZdZdZd<04>fd<02> Zd<03>Z<05>xZS)<05>ArrowStyle.Simpleu:A simple arrow. Only works with a quadratic Bézier curve.c<00>N<00><01>|||c|_|_|_t<00>|<00><00>y)aA
Parameters
----------
head_length : float, default: 0.5
Length of the arrow head.
head_width : float, default: 0.5
Width of the arrow head.
tail_width : float, default: 0.2
Width of the arrow tail.
N<>rr<00>
tail_widthr.r/<00>rHrrrerJs <20>rKr/zArrowStyle.Simple.__init__`<00>)<00><><00><1C>Z<EFBFBD><1A> ?<3F>D<EFBFBD> <1C>d<EFBFBD>o<EFBFBD>t<EFBFBD><EFBFBD> <11>G<EFBFBD> <1C> rLc<00>2<00>|j|<01>\}}}}}} |j|z}
t|| |
<EFBFBD>} ||f||f|| fg} t| | <0B>\} }|j |z}t||dz d<01><03>\}}| <0A><01>(|j|z}t| |dz <00>\}}tj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dftj|dfg }nztj|dftj|dftj|dftj|dftj|dftj|dfg}t|D<00><18>cgc]\}}|<19><02> c}}|D<00><18>cgc]\}}|<18><02> c}}<18>}|dfS#t$r3t || |||
<EFBFBD>\}}d||zzd|| zz}}||f||f|| fg}d} Y<00><02>9wxYwcc}}wcc}}w)NrrH<00><01>wmrrrQT)r<>rrrrr<>rrrerrrmrSr<>r<>)rHrRr(r%rBrCrDrEr<>r<>r<00>in_f<5F>
arrow_path<EFBFBD> arrow_out<75>arrow_in<69>x1n<31>y1nr<00> head_left<66>
head_rightre<00> tail_left<66>
tail_right<EFBFBD>
patch_pathr<EFBFBD>rCs rKr<>zArrowStyle.Simple.transmuteqs<><00><00>%)<29>%A<>%A<>$<24>%G<> "<22>B<EFBFBD><02>B<EFBFBD><02>B<EFBFBD><02><1F>*<2A>*<2A>]<5D>:<3A>K<EFBFBD> <20><12>R<EFBFBD><1B>5<>D<EFBFBD><1D>r<EFBFBD>(<28>R<EFBFBD><12>H<EFBFBD>r<EFBFBD>2<EFBFBD>h<EFBFBD>7<>J<EFBFBD> !<21>=<3D>j<EFBFBD>$<24>O<>$<24> <09>8<EFBFBD><1E><1F><1F>=<3D>8<>J<EFBFBD>$7<><08>8B<38>R<EFBFBD><0F>B<EFBFBD>%P<01> !<21>I<EFBFBD>z<EFBFBD><19>$<24>!<21>_<EFBFBD>_<EFBFBD>}<7D><<3C>
<EFBFBD>(5<>i<EFBFBD>6@<40>2<EFBFBD>o<EFBFBD>)G<01>%<25> <09>:<3A> $<24>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>~<7E>~<7E>z<EFBFBD>!<21>}<7D>=<3D>  <20>
<EFBFBD> $<24>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>J<EFBFBD>q<EFBFBD>M<EFBFBD>:<3A>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>{<7B>{<7B>I<EFBFBD>a<EFBFBD>L<EFBFBD>9<>#<23>~<7E>~<7E>y<EFBFBD><11>|<7C><<3C>  <20>
<EFBFBD><18>z<EFBFBD>2<>t<EFBFBD>q<EFBFBD>!<21><11>2<>:<3A>4N<34>4<EFBFBD>1<EFBFBD>a<EFBFBD>Q<EFBFBD>4N<34>O<>D<EFBFBD><17><14>:<3A> <1D><>Y0<> !<21>-<2D>R<EFBFBD><12>R<EFBFBD><12>[<5B>I<><06><02>B<EFBFBD><1E>"<22>r<EFBFBD>'<27>?<3F>C<EFBFBD>2<EFBFBD><02>7<EFBFBD>O<EFBFBD>S<EFBFBD><03><1F><12>H<EFBFBD>s<EFBFBD>C<EFBFBD>j<EFBFBD>2<EFBFBD>r<EFBFBD>(<28>;<3B><08> <20> <09>  !<21><>T3<><33>4Ns<00>I<00>" J
<EFBFBD>6 J <0C>8J
<03> J
)rrr<00>rrrrr/r<>r rs@rK<00>Simplerb\s<00><><00>H<> <1F>"8 rLrwc<00>*<00><00>eZdZdZd<04>fd<02> Zd<03>Z<05>xZS)<05>ArrowStyle.Fancyu9A fancy arrow. Only works with a quadratic Bézier curve.c<00>N<00><01>|||c|_|_|_t<00>|<00><00>y)aA
Parameters
----------
head_length : float, default: 0.4
Length of the arrow head.
head_width : float, default: 0.4
Width of the arrow head.
tail_width : float, default: 0.4
Width of the arrow tail.
Nrdrfs <20>rKr/zArrowStyle.Fancy.__init__<5F>rgrLc<00><><00>|j|<01>\}}}}}} |j|z}
||f||f|| fg} t|| |
<EFBFBD>} t| | <0C>\} }|}t|| |
dz<00>} t| | <0C>\} }| }|j |z}t||dz d<04><05>\}}|j|z}t||dzddd<07><08>\}}t|||dz<00>} t| | <0C>\}} |d }||}}tj|ftj|d
ftj|d ftj|d ftj|d
ftj|d ftj|d ftj|d ftj|d
ftj|d ftj|d ftj|d
ftj|ftj|fg}t|D<00><1D>cgc]\}}|<1E><02> c}}|D<00><1D>cgc]\}}|<1D><02> c}}<1D>}|d fS#t$r3t || |||
<EFBFBD>\}}d||zzd|| zz}}||f||f|| fg} | }Y<00><02>wxYwcc}}wcc}}w)NrrrHg333333<33>?rir9r)<03>w1rj<00>w2r<32>rrrQT)r<>rrrrr<>rrrerrmr<>rSr<>)rHrRr(r%rBrCrDrEr<>r<>rrlrk<00>path_out<75>path_in<69> path_headrorp<00> path_tailr<00>head_l<5F>head_rrersrt<00>
tail_startrrrqrur<>rCs rKr<>zArrowStyle.Fancy.transmute<74>s<><00><00>%)<29>%A<>%A<>$<24>%G<> "<22>B<EFBFBD><02>B<EFBFBD><02>B<EFBFBD><02><1F>*<2A>*<2A>]<5D>:<3A>K<EFBFBD><1D>r<EFBFBD>(<28>R<EFBFBD><12>H<EFBFBD>r<EFBFBD>2<EFBFBD>h<EFBFBD>7<>J<EFBFBD>!<21><12>R<EFBFBD><1B>5<>D<EFBFBD> $<24>$M<><1E><04>%&<26>!<21><08>'<27>$<24> <09>!<21><12>R<EFBFBD><1B>r<EFBFBD>)9<>:<3A>D<EFBFBD> I<><1A>D<EFBFBD>!"<22> <1D>H<EFBFBD>g<EFBFBD> <20>I<EFBFBD><1E><1F><1F>=<3D>8<>J<EFBFBD>0<><19>1;<3B>b<EFBFBD><1F>46<34>8<>N<EFBFBD>F<EFBFBD>F<EFBFBD>
<1E><1F><1F>=<3D>8<>J<EFBFBD>$7<> <09>8B<38>R<EFBFBD><0F>;=<3D>#<23>#<23>%O<01> !<21>I<EFBFBD>z<EFBFBD>
!<21><12>R<EFBFBD><1A>b<EFBFBD><1F>9<>D<EFBFBD> I<><1A>D<EFBFBD>!"<22> <1D>G<EFBFBD>X<EFBFBD> <20><12><1B>J<EFBFBD>$*<2A>F<EFBFBD> <09>J<EFBFBD><1F>;<3B>;<3B>
<EFBFBD>3<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B>
<EFBFBD>1<EFBFBD> <0A>6<><1F>;<3B>;<3B> <09>!<21> <0C>5<><1F>;<3B>;<3B> <09>!<21> <0C>5<><1F>;<3B>;<3B> <09>!<21> <0C>5<><1F>;<3B>;<3B> <09>!<21> <0C>5<><1F>;<3B>;<3B> <09>!<21> <0C>5<><1F>;<3B>;<3B>
<EFBFBD>3<><1F>><3E>><3E>:<3A>6<><1C>J<EFBFBD><18>z<EFBFBD>2<>t<EFBFBD>q<EFBFBD>!<21><11>2<>:<3A>4N<34>4<EFBFBD>1<EFBFBD>a<EFBFBD>Q<EFBFBD>4N<34>O<>D<EFBFBD><17><14>:<3A> <1D><>i0<> '<27>-<2D>R<EFBFBD><12>R<EFBFBD><12>[<5B>I<><06><02>B<EFBFBD><1E>"<22>r<EFBFBD>'<27>?<3F>C<EFBFBD>2<EFBFBD><02>7<EFBFBD>O<EFBFBD>S<EFBFBD><03>!<21>2<EFBFBD>h<EFBFBD><13>c<EFBFBD>
<EFBFBD>R<EFBFBD><12>H<EFBFBD>=<3D>
<EFBFBD>&<26> <09>  '<27><>d3<><33>4Ns<00>H*<00>> I)
<EFBFBD> I/ <0C>*8I&<03>%I&)rrrrvrs@rK<00>Fancyry<00>s<00><><00>G<> <1F>"A rLr<>c<00>*<00><00>eZdZdZd<04>fd<02> Zd<03>Z<05>xZS)<05>ArrowStyle.Wedgeu<65>
Wedge(?) shape. Only works with a quadratic Bézier curve. The
start 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*x*tail_width*.
c<00>><00><01>||_||_t<00>|<00> <00>y)z<>
Parameters
----------
tail_width : float, default: 0.3
Width of the tail.
shrink_factor : float, default: 0.5
Fraction of the arrow width at the middle point.
N)re<00> shrink_factorr.r/)rHrer<>rJs <20>rKr/zArrowStyle.Wedge.__init__ s<00><><00>)<29>D<EFBFBD>O<EFBFBD>!.<2E>D<EFBFBD> <1E> <11>G<EFBFBD> <1C> rLc <00>><00>|j|<01>\}}}}}} ||f||f|| fg}
t|
|j|zdz |j<00><02>\} } tj
| dftj | dftj | dftj| dftj | dftj | dftj| dfg} t | D<00><0E>cgc]\}}|<0F><02> c}}| D<00><0E>cgc]\}}|<0E><02> c}}<0E>}|dfScc}}wcc}}w)NrHrirrrQT) r<>rrer<>rrmrSr<>r<>)rHrRr(r%rBrCrDrEr<>r<>rl<00>b_plus<75>b_minusrur<>rCs rKr<>zArrowStyle.Wedge.transmutes<00><00>%)<29>%A<>%A<>$<24>%G<> "<22>B<EFBFBD><02>B<EFBFBD><02>B<EFBFBD><02><1D>r<EFBFBD>(<28>R<EFBFBD><12>H<EFBFBD>r<EFBFBD>2<EFBFBD>h<EFBFBD>7<>J<EFBFBD>1<>$.<2E>$(<28>O<EFBFBD>O<EFBFBD>m<EFBFBD>$C<>b<EFBFBD>$H<>'+<2B>'9<>'9<>;<3B>O<EFBFBD>F<EFBFBD>G<EFBFBD>
 <20>;<3B>;<3B><06>q<EFBFBD> <09>2<><1F>;<3B>;<3B><06>q<EFBFBD> <09>2<><1F>;<3B>;<3B><06>q<EFBFBD> <09>2<><1F>;<3B>;<3B><07><01>
<EFBFBD>3<><1F>;<3B>;<3B><07><01>
<EFBFBD>3<><1F>;<3B>;<3B><07><01>
<EFBFBD>3<><1F>><3E>><3E>7<EFBFBD>1<EFBFBD>:<3A>6<> <1C>J<EFBFBD><18>z<EFBFBD>2<>t<EFBFBD>q<EFBFBD>!<21><11>2<>:<3A>4N<34>4<EFBFBD>1<EFBFBD>a<EFBFBD>Q<EFBFBD>4N<34>O<>D<EFBFBD><17><14>:<3A> <1D><>3<><33>4Ns <00>' D
<EFBFBD>; D )rrrvrs@rKr<>r<>s<00><><00> <0C> <1F> rLr<>N)rrrrr<>rrrrr$r(r,r0r4r8rBrIrOrTrZr`rwr<>r<>r:rLrKr<>r<>_ sa<00><00>,<08>\<15>K<EFBFBD>EF<01>EF<01>Na <20><15>a <20>F<15>[<5B>s<EFBFBD>+<2B><<3C><06><<3C>,<2C><<3C><15>[<5B>t<EFBFBD>,<2C><15><16><15>-<2D><15><15>[<5B>t<EFBFBD>,<2C><15><16><15>-<2D><15><15>[<5B>u<EFBFBD>-<2D><16>&<26><16>.<2E><16><15>[<5B>u<EFBFBD>-<2D><16>v<EFBFBD><16>.<2E><16><15>[<5B>u<EFBFBD>-<2D><16>v<EFBFBD><16>.<2E><16><15>[<5B>w<EFBFBD>/<2F><18><06><18>0<><18><15>[<5B>t<EFBFBD>,<2C>L<01>6<EFBFBD>L<01>-<2D>L<01>$<15>[<5B>t<EFBFBD>,<2C>L<01>6<EFBFBD>L<01>-<2D>L<01>$<15>[<5B>u<EFBFBD>-<2D>L<01>F<EFBFBD>L<01>.<2E>L<01>*<15>[<5B>u<EFBFBD>-<2D>F<01><06>F<01>.<2E>F<01>"<15>[<5B>u<EFBFBD>-<2D>L<01>v<EFBFBD>L<01>.<2E>L<01>*<15>[<5B>u<EFBFBD>-<2D>L<01>v<EFBFBD>L<01>.<2E>L<01>*<15>[<5B>!<21>L<1E><15>L<1E>"<22>L<1E>\<15>[<5B>!<21>U<1E><05>U<1E>"<22>U<1E>n<15>[<5B>!<21>)<1E><05>)<1E>"<22>)rLr<>c<00><><00><00>eZdZdZdZd<03>Zejdddd<05><02>fd<06> <0B>Zejdd<07><01>Z d<08>Z
d <09>Z d
<EFBFBD>Z d <0B>Z d <0C>Zd <0A>Zd<0E>Zd<0F>Zd<10>Zd<11>Zd<12>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Z<19>xZS)<1A>FancyBboxPatchaO
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 style classes defined in `.BoxStyle`.
Tc<00><><00>|jjdz}||j|j|j|j
fzS)Nz((%g, %g), width=%g, height=%g))rJrrrr0r1r<>s rKrzFancyBboxPatch.__str__<s;<00><00> <10>N<EFBFBD>N<EFBFBD> #<23> #<23>&G<> G<><01><10>D<EFBFBD>G<EFBFBD>G<EFBFBD>T<EFBFBD>W<EFBFBD>W<EFBFBD>d<EFBFBD>k<EFBFBD>k<EFBFBD>4<EFBFBD><<3C><<3C>@<40>@<40>@rLr)<02>mutation_scale<6C>mutation_aspectc <00><><00><01>t<00>|<00>di|<07><01>|\|_|_||_||_|j |<04>||_||_d|_ y)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
separated 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:
%(BoxStyle:table)s
mutation_scale : float, default: 1
Scaling factor applied to the attributes of the box style
(e.g. pad or rounding_size).
mutation_aspect : float, default: 1
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 : `~matplotlib.patches.Patch` properties
%(Patch:kwdoc)s
TNr:)
r.r/rrr0r1<00> set_boxstyle<6C>_mutation_scale<6C>_mutation_aspectr<74>) rHrr=r><00>boxstyler<65>r<>rIrJs <20>rKr/zFancyBboxPatch.__init__@sW<00><><00>V <0E><07><18>"<22>6<EFBFBD>"<22><1D><18><04><07><14><17><1B><04> <0B><1D><04> <0C> <0C><19><19>(<28>#<23>-<2D><04><1C> /<2F><04><1D><19><04>
rLc <00><><00>|<01>tj<00>St|t<00>r t|fi|<02><01>n||_d|_y)a<>
Set the box style, possibly with further attributes.
Attributes from the previous box style are not reused.
Without argument (or with ``boxstyle=None``), the available box styles
are returned as a human-readable string.
Parameters
----------
boxstyle : str or `~matplotlib.patches.BoxStyle`
The style of the box: either a `.BoxStyle` instance, or a string,
which is the style name and optionally comma separated attributes
(e.g. "Round,pad=0.2"). Such a string is used to construct a
`.BoxStyle` object, as documented in that class.
The following box styles are available:
%(BoxStyle:table_and_accepts)s
**kwargs
Additional attributes for the box style. See the table above for
supported parameters.
Examples
--------
::
set_boxstyle("Round,pad=0.2")
set_boxstyle("round", pad=0.2)
NT)rr<>rWr<00>_bbox_transmuterr<72>)rHr<>rIs rKr<>zFancyBboxPatch.set_boxstyletsI<00><00>B <14> <1B><1B>)<29>)<29>+<2B> +<2B><1A>(<28>C<EFBFBD>(<28> <15>X<EFBFBD> (<28><16> (<28>.6<EFBFBD> <0A><1D><1A><04>
rLc<00><00>|jS)zReturn the boxstyle object.)r<>r<>s rK<00> get_boxstylezFancyBboxPatch.get_boxstyle<6C>r<>rLc<00> <00>||_d|_y<02>zf
Set the mutation scale.
Parameters
----------
scale : float
TN<54>r<>r<><00>rHrKs rK<00>set_mutation_scalez!FancyBboxPatch.set_mutation_scale<6C><00><00><00> %<25><04><1C><19><04>
rLc<00><00>|jS)zReturn the mutation scale.<2E>r<>r<>s rK<00>get_mutation_scalez!FancyBboxPatch.get_mutation_scale<6C>s<00><00><13>#<23>#<23>#rLc<00> <00>||_d|_y<02>zz
Set the aspect ratio of the bbox mutation.
Parameters
----------
aspect : float
TN<54>r<>r<><00>rH<00>aspects rK<00>set_mutation_aspectz"FancyBboxPatch.set_mutation_aspect<63><00><00><00>!'<27><04><1D><19><04>
rLc<00>6<00>|j<00> |jSdS<00>z-Return the aspect ratio of the bbox mutation.r<00>r<>r<>s rK<00>get_mutation_aspectz"FancyBboxPatch.get_mutation_aspect<63><00>#<00><00>)-<2D>)><3E>)><3E>)J<><04>%<25>%<25> <18><16> rLc<00><00>|j<00>}|j<00>}||j|j|z |j|j
|z |j <00><00>}t|jd|gz|j<00>S)z)Return the mutated path of the rectangle.r)
r<EFBFBD>r<>rrr0r1r<>rrjri)rHr<><00>m_aspectrRs rKrOzFancyBboxPatch.get_path<74>sw<00><00><17>$<24>$<24>&<26><08><17>+<2B>+<2B>-<2D><08><17><04><07><07><14><17><17>8<EFBFBD>!3<><1C> <0B> <0B>T<EFBFBD>\<5C>\<5C>H<EFBFBD>%<<3C><1C>/<2F>/<2F>1<>3<><04><14>D<EFBFBD>M<EFBFBD>M<EFBFBD>Q<EFBFBD><08>M<EFBFBD>1<>4<EFBFBD>:<3A>:<3A>><3E>>rLc<00><00>|jS)z'Return the left coord of the rectangle.)rr<>s rKrUzFancyBboxPatch.get_x<5F><00> <00><00><13>w<EFBFBD>w<EFBFBD>rLc<00><00>|jS)z)Return the bottom coord of the rectangle.)rr<>s rKrXzFancyBboxPatch.get_y<5F>r<>rLc<00><00>|jSrerfr<>s rKrgzFancyBboxPatch.get_width<74>r<>rLc<00><00>|jSrirjr<>s rKrkzFancyBboxPatch.get_height<68>rlrLc<00> <00>||_d|_y)zo
Set the left coord of the rectangle.
Parameters
----------
x : float
TN)rr<>rqs rKrrzFancyBboxPatch.set_x<5F><00><00><00><14><04><07><19><04>
rLc<00> <00>||_d|_y)zq
Set the bottom coord of the rectangle.
Parameters
----------
y : float
TN)rr<>rus rKrvzFancyBboxPatch.set_y<5F>r<>rLc<00> <00>||_d|_y)zc
Set the rectangle width.
Parameters
----------
w : float
TNr~r<>s rKrzFancyBboxPatch.set_width<74>s<00><00><18><04> <0B><19><04>
rLc<00> <00>||_d|_y)zd
Set the rectangle height.
Parameters
----------
h : float
TNr<4E>r<>s rKr<>zFancyBboxPatch.set_height<68>s<00><00><19><04> <0C><19><04>
rLc<00><><00>t|<01>dk(r |d\}}}}n|\}}}}||_||_||_||_d|_y)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)rFrrr0r1r<>r<>s rKr<>zFancyBboxPatch.set_boundssP<00><00> <0F>t<EFBFBD>9<EFBFBD><01>><3E><1D>a<EFBFBD><17>J<EFBFBD>A<EFBFBD>q<EFBFBD>!<21>Q<EFBFBD><1D>J<EFBFBD>A<EFBFBD>q<EFBFBD>!<21>Q<EFBFBD><13><04><07><13><04><07><17><04> <0B><18><04> <0C><19><04>
rLc<00><><00>tjj|j|j|j
|j <00>Sr<>)rr<><00> from_boundsrrr0r1r<>s rKrIzFancyBboxPatch.get_bbox!s4<00><00><19><EFBFBD><EFBFBD>*<2A>*<2A>4<EFBFBD>7<EFBFBD>7<EFBFBD>D<EFBFBD>G<EFBFBD>G<EFBFBD>+/<2F>;<3B>;<3B><04> <0C> <0C>F<01> FrL)rer`)rrrrr<>rr r r/r<>r<>r<>r<>r<>r<>rOrUrXrgrkrrrvrr<>r<>rIr rs@rKr<>r<>0s<><00><><00><08><19>M<EFBFBD>A<01><10><17><17>1<1A> !<21>1<EFBFBD>1<1A><18>1<1A>f<10><17><17>%<1A><18>%<1A>N%<25> <1A>$<24> <1A><18>
?<3F><17><17><1B><1C> <1A> <1A> <1A> <1A><1A>4FrLr<>c <00><><00><00>eZdZdZdZd<03>Zejddddddddddd <09> <09>fd
<EFBFBD> <0B>Zd <0B>Z d <0C>Z
d <0A>Z ejdd<0E><01>Z d<0F>Z ejdd<10><01>Zd<11>Zd<12>Zd<13>Zd<14>Zd<15>Zd<16>Zd<17>Zd<18>Z<16>xZS)<1B>FancyArrowPatcha<68>
A fancy arrow patch.
It draws an arrow using the `ArrowStyle`. It is primarily used by the
`~.axes.Axes.annotate` method. For most purposes, use the annotate method for
drawing arrows.
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
<00><><00>|j<00>=|j\\}}\}}t|<00>j<00>d|d<02>d|d<02>d|d<02>d|d<02>d<05>
St|<00>j<00>d|j<00>d<07>S)Nz((<28>gz, z)->(z))<29>(r)<04>
_posA_posB<EFBFBD>typer<00>_path_original)rHrDrEr<>r<>s rKrzFancyArrowPatch.__str__5s<00><00> <0F>?<3F>?<3F> &<26>!%<25><1F><1F> <1E>H<EFBFBD>R<EFBFBD><12>h<EFBFBD>r<EFBFBD>2<EFBFBD><1A>4<EFBFBD>j<EFBFBD>)<29>)<29>*<2A>"<22>R<EFBFBD><01>F<EFBFBD>"<22>R<EFBFBD><01>F<EFBFBD>$<24>r<EFBFBD>!<21>f<EFBFBD>B<EFBFBD>r<EFBFBD>!<21>f<EFBFBD>B<EFBFBD>O<> O<><1A>4<EFBFBD>j<EFBFBD>)<29>)<29>*<2A>!<21>D<EFBFBD>,?<3F>,?<3F>+@<40><01>B<> BrLN<>simple<6C>arc3rQr) rR<00>
arrowstyle<EFBFBD>connectionstyler<65>r<>r<>r<>r<>r<>c  <00><><00><01>| jdtj<00>| jdtj<00>t <00> |<00>di| <0C><01>|<01>#|<02>!|<03>||g|_|<05>d}|j|<05>n|<01> |<02>
|<03>d|_n td<05><00>||_ ||_
||_ | |_ ||_ |j|<04>|
|_| |_d|_y)a<>
**Defining the arrow position and path**
There are two ways to define the arrow position and path:
- **Start, end and connection**:
The typical approach is to define the start and end points of the
arrow using *posA* and *posB*. The curve between these two can
further be configured using *connectionstyle*.
If given, the arrow curve is clipped by *patchA* and *patchB*,
allowing it to start/end at the border of these patches.
Additionally, the arrow curve can be shortened by *shrinkA* and *shrinkB*
to create a margin between start/end (after possible clipping) and the
drawn arrow.
- **path**: Alternatively if *path* is provided, an arrow is drawn along
this Path. In this case, *connectionstyle*, *patchA*, *patchB*,
*shrinkA*, and *shrinkB* are ignored.
**Styling**
The *arrowstyle* defines the styling of the arrow head, tail and shaft.
The resulting arrows can be styled further by setting the `.Patch`
properties such as *linewidth*, *color*, *facecolor*, *edgecolor*
etc. via keyword arguments.
Parameters
----------
posA, posB : (float, float), optional
(x, y) coordinates of start and end point of the arrow.
The actually drawn start and end positions may be modified
through *patchA*, *patchB*, *shrinkA*, and *shrinkB*.
*posA*, *posB* are exclusive of *path*.
path : `~matplotlib.path.Path`, optional
If provided, an arrow is drawn along this path and *patchA*,
*patchB*, *shrinkA*, and *shrinkB* are ignored.
*path* is exclusive of *posA*, *posB*.
arrowstyle : str or `.ArrowStyle`, default: 'simple'
The styling of arrow head, tail and shaft. This can be
- `.ArrowStyle` or one of its subclasses
- The shorthand string name (e.g. "->") as given in the table below,
optionally containing a comma-separated list of style parameters,
e.g. "->, head_length=10, head_width=5".
The style parameters are scaled by *mutation_scale*.
The following arrow styles are available. See also
:doc:`/gallery/text_labels_and_annotations/fancyarrow_demo`.
%(ArrowStyle:table)s
Only the styles ``<|-``, ``-|>``, ``<|-|>`` ``simple``, ``fancy``
and ``wedge`` contain closed paths and can be filled.
connectionstyle : str or `.ConnectionStyle` or None, optional, default: 'arc3'
`.ConnectionStyle` with which *posA* and *posB* are connected.
This can be
- `.ConnectionStyle` or one of its subclasses
- The shorthand string name as given in the table below, e.g. "arc3".
%(ConnectionStyle:table)s
Ignored if *path* is provided.
patchA, patchB : `~matplotlib.patches.Patch`, default: None
Optional Patches at *posA* and *posB*, respectively. If given,
the arrow path is clipped by these patches such that head and tail
are at the border of the patches.
Ignored if *path* is provided.
shrinkA, shrinkB : float, default: 2
Shorten the arrow path at *posA* and *posB* by this amount in points.
This allows to add a margin between the intended start/end points and
the arrow.
Ignored if *path* is provided.
mutation_scale : float, default: 1
Value with which attributes of *arrowstyle* (e.g., *head_length*)
will be scaled.
mutation_aspect : None or float, 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.
Other Parameters
----------------
**kwargs : `~matplotlib.patches.Patch` properties, optional
Here is a list of available `.Patch` properties:
%(Patch:kwdoc)s
In contrast to other patches, the default ``capstyle`` and
``joinstyle`` for `FancyArrowPatch` are set to ``"round"``.
r+r*Nr<4E>z.Either posA and posB, or path need to providedr9r:)r<>rrerr.r/r<><00>set_connectionstylerr<>r<>r<>r<>r<><00>set_arrowstyler<65>r<><00>_dpi_cor)rHr<>r<>rRr<>r<>r<>r<>r<>r<>r<>r<>rIrJs <20>rKr/zFancyArrowPatch.__init__<s<><00><><00>^ <0F><19><19>+<2B>y<EFBFBD><EFBFBD><EFBFBD>7<><0E><19><19>*<2A>h<EFBFBD>n<EFBFBD>n<EFBFBD>5<> <0A><07><18>"<22>6<EFBFBD>"<22> <0F> <1B><04> 0<>T<EFBFBD>\<5C>#<23>T<EFBFBD>l<EFBFBD>D<EFBFBD>O<EFBFBD><1E>&<26>"(<28><0F> <10> $<24> $<24>_<EFBFBD> 5<> <11>\<5C>d<EFBFBD>l<EFBFBD>t<EFBFBD>/?<3F>"<22>D<EFBFBD>O<EFBFBD><1C>M<>N<> N<><1C><04> <0B><1C><04> <0B><1E><04> <0C><1E><04> <0C>"<22><04><1B> <0C><1B><1B>J<EFBFBD>'<27>-<2D><04><1C> /<2F><04><1D><1B><04> rLc<00>V<00>|<01>||jd<|<02>||jd<d|_y)a
Set the start 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)r<>r<>)rHr<>r<>s rK<00> set_positionszFancyArrowPatch.set_positions<6E>s3<00><00> <10> <1B>!%<25>D<EFBFBD>O<EFBFBD>O<EFBFBD>A<EFBFBD> <1E> <0F> <1B>!%<25>D<EFBFBD>O<EFBFBD>O<EFBFBD>A<EFBFBD> <1E><19><04>
rLc<00> <00>||_d|_y)zn
Set the tail patch.
Parameters
----------
patchA : `.patches.Patch`
TN)r<>r<>)rHr<>s rK<00>
set_patchAzFancyArrowPatch.set_patchA<68><00><00><00><1D><04> <0B><19><04>
rLc<00> <00>||_d|_y)zn
Set the head patch.
Parameters
----------
patchB : `.patches.Patch`
TN)r<>r<>)rHr<>s rK<00>
set_patchBzFancyArrowPatch.set_patchB<68>r<>rLc <00><><00>|<01>tj<00>St|t<00>r t|fi|<02><01>n||_d|_y)aZ
Set the connection style, possibly with further attributes.
Attributes from the previous connection style are not reused.
Without argument (or with ``connectionstyle=None``), the available box
styles are returned as a human-readable string.
Parameters
----------
connectionstyle : str or `~matplotlib.patches.ConnectionStyle`
The style of the connection: either a `.ConnectionStyle` instance,
or a string, which is the style name and optionally comma separated
attributes (e.g. "Arc,armA=30,rad=10"). Such a string is used to
construct a `.ConnectionStyle` object, as documented in that class.
The following connection styles are available:
%(ConnectionStyle:table_and_accepts)s
**kwargs
Additional attributes for the connection style. See the table above
for supported parameters.
Examples
--------
::
set_connectionstyle("Arc,armA=30,rad=10")
set_connectionstyle("arc", armA=30, rad=10)
NT)rsr<>rWr<00>
_connectorr<EFBFBD>)rHr<>rIs rKr<>z#FancyArrowPatch.set_connectionstyle<6C>sH<00><00>B <1B> "<22>"<22>0<>0<>2<> 2<><1A>/<2F>3<EFBFBD>/<2F> <1C>O<EFBFBD> 6<>v<EFBFBD> 6<>5D<35> <0A><0F><1A><04>
rLc<00><00>|jS)z"Return the `ConnectionStyle` used.)r<>r<>s rK<00>get_connectionstylez#FancyArrowPatch.get_connectionstyler<>rLc <00><><00>|<01>tj<00>St|t<00>r t|fi|<02><01>n||_d|_y)a!
Set the arrow style, possibly with further attributes.
Attributes from the previous arrow style are not reused.
Without argument (or with ``arrowstyle=None``), the available box
styles are returned as a human-readable string.
Parameters
----------
arrowstyle : str or `~matplotlib.patches.ArrowStyle`
The style of the arrow: either a `.ArrowStyle` instance, or a
string, which is the style name and optionally comma separated
attributes (e.g. "Fancy,head_length=0.2"). Such a string is used to
construct a `.ArrowStyle` object, as documented in that class.
The following arrow styles are available:
%(ArrowStyle:table_and_accepts)s
**kwargs
Additional attributes for the arrow style. See the table above for
supported parameters.
Examples
--------
::
set_arrowstyle("Fancy,head_length=0.2")
set_arrowstyle("fancy", head_length=0.2)
NT)r<>r<>rWr<00>_arrow_transmuterr<72>)rHr<>rIs rKr<>zFancyArrowPatch.set_arrowstylesI<00><00>B <16> <1D><1D>+<2B>+<2B>-<2D> -<2D><1A>*<2A>c<EFBFBD>*<2A> <17>z<EFBFBD> ,<2C>V<EFBFBD> ,<2C>0:<3A> <0A><1E><1A><04>
rLc<00><00>|jS)zReturn the arrowstyle object.)r<>r<>s rK<00>get_arrowstylezFancyArrowPatch.get_arrowstyleDs<00><00><13>%<25>%<25>%rLc<00> <00>||_d|_yr<>r<>r<>s rKr<>z"FancyArrowPatch.set_mutation_scaleHr<>rLc<00><00>|jS)z\
Return the mutation scale.
Returns
-------
scalar
r<>r<>s rKr<>z"FancyArrowPatch.get_mutation_scaleSs<00><00><14>#<23>#<23>#rLc<00> <00>||_d|_yr<>r<>r<>s rKr<>z#FancyArrowPatch.set_mutation_aspect]r<>rLc<00>6<00>|j<00> |jSdSr<>r<>r<>s rKr<>z#FancyArrowPatch.get_mutation_aspecthr<>rLc<00><><00>|j<00>\}}tj|<02>rtj|<01>}|j <00>j <00>j|<01>S)z5Return the path of the arrow in the data coordinates.)<08>_get_path_in_displaycoordrkr<>r<00>make_compound_pathrN<00>invertedr7)rHr<>r<>s rKrOzFancyArrowPatch.get_pathmsU<00><00><1F>8<>8<>:<3A><0F><05>x<EFBFBD> <0A>;<3B>;<3B>x<EFBFBD> <20><18>+<2B>+<2B>U<EFBFBD>3<>E<EFBFBD><13>!<21>!<21>#<23>,<2C>,<2C>.<2E>=<3D>=<3D>e<EFBFBD>D<>DrLc <00>z<00>|j}|j<00><>|j|jd<00>}|j|jd<00>}|j<00>j ||f<02>\}}|j <00>|||j |j|j|z|j|z<00><03>}n)|j<00>j|j<00>}|j<00>||j<00>|z|j<00>|z|j<00><00>\}}||fS)<04><Return the mutated path of the arrow in display coordinates.rr<00>r<>r<>r<>r<>)r<>r<>rrNr<>r<>r<>r<>r<>r<>r7r<>r<>r<>rZr<>)rH<00>dpi_corr<72>r<>r<>r<>s rKr<>z)FancyArrowPatch._get_path_in_displaycoordvs<00><00><16>-<2D>-<2D><07> <0F>?<3F>?<3F> &<26><17>)<29>)<29>$<24>/<2F>/<2F>!<21>*<<3C>=<3D>D<EFBFBD><17>)<29>)<29>$<24>/<2F>/<2F>!<21>*<<3C>=<3D>D<EFBFBD><1F>-<2D>-<2D>/<2F>9<>9<>4<EFBFBD><14>,<2C>G<>L<EFBFBD>T<EFBFBD>4<EFBFBD>.<2E>D<EFBFBD>,<2C>,<2C>.<2E>t<EFBFBD>T<EFBFBD>6:<3A>k<EFBFBD>k<EFBFBD>6:<3A>k<EFBFBD>k<EFBFBD>7;<3B>|<7C>|<7C>g<EFBFBD>7M<37>7;<3B>|<7C>|<7C>g<EFBFBD>7M<37> 1<>E<EFBFBD><19>&<26>&<26>(<28>7<>7<><04>8K<38>8K<38>L<>E<EFBFBD>/<2F>$<24>-<2D>-<2D>/<2F> <11> <10> #<23> #<23> %<25><07> /<2F> <10> <1E> <1E> <20>7<EFBFBD> *<2A> <10> $<24> $<24> &<26> (<28><0F><05>x<EFBFBD> <15>h<EFBFBD><EFBFBD>rLc <00><><00>|j<00>sy|jd<01>|_|j<00>\}}t j
|<03>s|g}|g}t j<00>}|j|t||<03>D<00><05>cgc]'\}}|||r|jdr |jndf<03><02>)c}}<05>ycc}}w)Nr9rV) r<>r#r<>r<>rkr<>rr<>r<>r<>r})rHr<>rRr<>r<>rCr<>s rKr<>zFancyArrowPatch.draw<61>s<><00><00><13><1F><1F>!<21> <12>
!<21>1<>1<>"<22>5<><04> <0A><1D>7<>7<>9<><0E><04>h<EFBFBD><11>{<7B>{<7B>8<EFBFBD>$<24><18>6<EFBFBD>D<EFBFBD> <20>z<EFBFBD>H<EFBFBD><1B>-<2D>-<2D>/<2F><06> <0C>/<2F>/<2F> <14><1C>T<EFBFBD>8<EFBFBD>,<2C> .<2E><15><11>A<EFBFBD><10><16>A<EFBFBD>$<24>/<2F>/<2F>!<21>2D<32><14><1F><1F>$<24> O<> .<2E> /<2F><> .s<00>,B: )NNr`)rrrrr<>rr r r/r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rOr<>r<>r rs@rKr<>r<>'s<><00><><00>
<08><19>M<EFBFBD>C<01><10><17><17>K<1C><1A>x<EFBFBD><16><1C>T<EFBFBD>1<EFBFBD>a<EFBFBD> !<21>1<EFBFBD>K<1C><18>K<1C>Z<1A> <1A> <1A><10><17><17>%<1A><18>%<1A>N<1F><10><17><17>%<1A><18>%<1A>N&<26> <1A>$<24> <1A><18>
E<01><1F>2/rLr<>c<00><><00><00>eZdZdZd<02>Zej ddddddddddddd <09> <0B>fd
<EFBFBD> <0B>Zdd <0B>Zd <0C>Z d <0A>Z
d<0E>Z d<0F>Z <0C>fd<10>Z <0A>xZS)<12>ConnectionPatchz>A patch that connects two points (possibly in different Axes).c<00>|<00>d|jd|jd|jd|jdfzS)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)<02>xy1<79>xy2r<32>s rKrzConnectionPatch.__str__<5F>s=<00><00>4<><14><08><08><11> <0B>T<EFBFBD>X<EFBFBD>X<EFBFBD>a<EFBFBD>[<5B>$<24>(<28>(<28>1<EFBFBD>+<2B>t<EFBFBD>x<EFBFBD>x<EFBFBD><01>{<7B>C<>D<01> DrLNr<4E>r<>r6g$@F) <0B>axesA<73>axesBr<42>r<>r<>r<>r<>r<>r<>r<>r<>c  <00><><00><01>|<04>|}||_||_||_||_||_||_t <00>|<00>ddd||| |
| | | ||d<04> |<10><01>d|_y)aN
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 `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
'subfigure points' points from the lower left corner of the subfigure
'subfigure pixels' pixels from the lower left corner of the subfigure
'subfigure fraction' fraction of the subfigure, 0, 0 is lower left.
'axes points' points from lower left corner of the Axes
'axes pixels' pixels from lower left corner of the Axes
'axes fraction' 0, 0 is lower left of Axes and 1, 1 is upper right
'data' use the coordinate system of the object being
annotated (default)
'offset points' 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`.
Note that 'subfigure pixels' and 'figure pixels' are the same
for the parent figure, so users who want code that is usable in
a subfigure can use 'subfigure pixels'.
.. note::
Using `ConnectionPatch` across two `~.axes.Axes` instances
is not directly compatible with :ref:`constrained layout
<constrainedlayout_guide>`. Add the artist
directly to the `.Figure` instead of adding it to a specific Axes,
or exclude it from the layout using ``con.set_in_layout(False)``.
.. code-block:: default
fig, ax = plt.subplots(1, 2, constrained_layout=True)
con = ConnectionPatch(..., axesA=ax[0], axesB=ax[1])
fig.add_artist(con)
Nr\r^) r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r:) r<>r<><00>coords1<73>coords2r<32>r<>r.r/<00>_annotation_clip)rH<00>xyA<79>xyB<79>coordsA<73>coordsBr<42>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rIrJs <20>rKr/zConnectionPatch.__init__<5F>s}<00><><00>b <13>?<3F><1D>G<EFBFBD><16><04><08><16><04><08><1E><04> <0C><1E><04> <0C><1A><04>
<EFBFBD><1A><04>
<EFBFBD> <0A><07><18> #<23>f<EFBFBD>6<EFBFBD>$.<2E>)8<> &<26>v<EFBFBD>!(<28>'<27>(6<>)8<>!(<28> #<23>"<22> #<23>!%<25><04>rLc<00><><00>|}|<03> |j}tj|d<00>}tj|d<00>}|jd<03><04>}|dvr7||jzdz }||jzdz }|j dd<08>}n5|d k(r |j }n#|d
k(r |j}n|d k(r |j}|d k(r{|j}tj|jj|<05><00>}tj|jj|<06><00>}|j||f<02>S|d k(rt|j d k(r|j#|j$d <0C>S|j#|j$|j <00>||jd<0E><04>jzdz zS|dk(rS||}
} |
tj&| <09>z}|
tj(| <09>z}|j}|j||f<02>S|dk(rf|jd<03><04>j*} |dk\r| j,|zn| j.|z}|dk\r| j0|zn| j2|z}||fS|dk(rf|jd<03><04>j4} |dk\r| j,|zn| j.|z}|dk\r| j0|zn| j2|z}||fS|dk(rV|j4} |dk\r| j,|zn| j.|z}|dk\r| j0|zn| j2|z}||fSt7|t8j:<00>r|j|<01>St=|<04>d<13><02><00>)z,Calculate the pixel position of given point.rrFr<46>)z figure pointsz axes points<74>Hry<00>pixelszfigure fractionzsubfigure fractionz axes fraction<6F>dataz offset pointsT<73>polarz figure pixelszsubfigure pixelsz axes pixelsz) is not a valid coordinate transformation)r<>rkr,r<><00>dpir<69><00> transFigure<72>transSubfigure<72> transAxes<65> transDatar <00>_to_unmasked_float_array<61>xaxis<69> convert_units<74>yaxisr<73><00>xycoords<64>_get_xyrr<>r<><00>figbboxrBrDrCrErMrWr<00> Transformr) rHrr<>r<><00>s0rbrc<00>figrQr<>r<><00>bbs rKr zConnectionPatch._get_xys<00><00> <0E><02> <0F><<3C><17>9<EFBFBD>9<EFBFBD>D<EFBFBD> <0F>H<EFBFBD>H<EFBFBD>R<EFBFBD><01>U<EFBFBD>O<EFBFBD><01> <0E>H<EFBFBD>H<EFBFBD>R<EFBFBD><01>U<EFBFBD>O<EFBFBD><01><12>o<EFBFBD>o<EFBFBD>5<EFBFBD>o<EFBFBD>)<29><03> <0C>0<> 0<><11>C<EFBFBD>G<EFBFBD>G<EFBFBD> <0B>b<EFBFBD> <20>A<EFBFBD><11>C<EFBFBD>G<EFBFBD>G<EFBFBD> <0B>b<EFBFBD> <20>A<EFBFBD><11> <09> <09>(<28>H<EFBFBD>-<2D>A<EFBFBD> <0E>#<23> #<23><13><0F><0F>A<EFBFBD> <0E>&<26> &<26><13>"<22>"<22>A<EFBFBD> <0E>/<2F> !<21><14><0E><0E>A<EFBFBD> <0C><06>;<3B><18>N<EFBFBD>N<EFBFBD>E<EFBFBD><15>.<2E>.<2E>t<EFBFBD>z<EFBFBD>z<EFBFBD>/G<>/G<><01>/J<>K<>A<EFBFBD><15>.<2E>.<2E>t<EFBFBD>z<EFBFBD>z<EFBFBD>/G<>/G<><01>/J<>K<>A<EFBFBD><18>?<3F>?<3F>A<EFBFBD>q<EFBFBD>6<EFBFBD>*<2A> *<2A> <0E>/<2F> !<21><13>}<7D>}<7D><0F>/<2F><1B>|<7C>|<7C>D<EFBFBD>G<EFBFBD>G<EFBFBD>V<EFBFBD>4<>4<><14> <0C> <0C>T<EFBFBD>W<EFBFBD>W<EFBFBD>d<EFBFBD>m<EFBFBD>m<EFBFBD>4<><14>t<EFBFBD><EFBFBD><EFBFBD>D<EFBFBD><EFBFBD>1<>5<>5<>5<><02>:<3A>;<3B> <<3C><0F>'<27>\<5C><18>!<21>1<EFBFBD>E<EFBFBD><11>B<EFBFBD>F<EFBFBD>F<EFBFBD>5<EFBFBD>M<EFBFBD>!<21>A<EFBFBD><11>B<EFBFBD>F<EFBFBD>F<EFBFBD>5<EFBFBD>M<EFBFBD>!<21>A<EFBFBD><18>N<EFBFBD>N<EFBFBD>E<EFBFBD><18>?<3F>?<3F>A<EFBFBD>q<EFBFBD>6<EFBFBD>*<2A> *<2A> <0E>/<2F> !<21><15><1F><1F>e<EFBFBD><1F>,<2C>4<>4<>B<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><14>a<EFBFBD>4<EFBFBD>K<EFBFBD> <0E>$<24> $<24><15><1F><1F>e<EFBFBD><1F>,<2C>1<>1<>B<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><14>a<EFBFBD>4<EFBFBD>K<EFBFBD> <0E>-<2D> <1F><15><19><19>B<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><1E>!<21>V<EFBFBD><02><05><05><01> <09><12><15><15><11><19>A<EFBFBD><14>a<EFBFBD>4<EFBFBD>K<EFBFBD> <17><01>:<3A>/<2F>/<2F> 0<><14>;<3B>;<3B>r<EFBFBD>?<3F> "<22><1C><02>t<EFBFBD>#L<>M<>N<> NrLc<00> <00>||_d|_y)a<>
Set the annotation's clipping behavior.
Parameters
----------
b : bool or None
- True: The annotation will be clipped when ``self.xy`` is
outside the Axes.
- False: The annotation will always be drawn.
- None: The annotation will be clipped when ``self.xy`` is
outside the Axes and ``self.xycoords == "data"``.
TN)r<>r<>r<>s rK<00>set_annotation_clipz#ConnectionPatch.set_annotation_clipRs<00><00>!"<22><04><1D><19><04>
rLc<00><00>|jS)zx
Return the clipping behavior.
See `.set_annotation_clip` for the meaning of the return value.
)r<>r<>s rK<00>get_annotation_clipz#ConnectionPatch.get_annotation_clipbs<00><00> <14>$<24>$<24>$rLc <00><00>|j}|j|j|j|j<00>}|j|j
|j |j<00>}|j<00>|||j|j|j|z|j|z<00><01>}|j<00>||j<00>|z|j<00>|z|j!<00><00>\}}||fS)r<>r<>)r<>r r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>rZr<>)rHr<>r<>r<>rRr<>s rKr<>z)ConnectionPatch._get_path_in_displaycoordjs<><00><00><16>-<2D>-<2D><07><13>|<7C>|<7C>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>?<3F><04><13>|<7C>|<7C>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>?<3F><04>)<29>t<EFBFBD>'<27>'<27>)<29> <10>$<24><17>;<3B>;<3B>t<EFBFBD>{<7B>{<7B><18>L<EFBFBD>L<EFBFBD>7<EFBFBD>*<2A>D<EFBFBD>L<EFBFBD>L<EFBFBD>7<EFBFBD>4J<34>
<EFBFBD><04>
/<2F><14>,<2C>,<2C>.<2E> <10> <10> #<23> #<23> %<25><07> /<2F> <10> <1E> <1E> <20>7<EFBFBD> *<2A> <10> $<24> $<24> &<26> 
<EFBFBD><0E><04>h<EFBFBD> <14>X<EFBFBD>~<7E>rLc<00><00>|j<00>}|s|<02>w|jdk(rh|j|j|j|j<00>}|j<00> |j
}n |j}|j |<03>sy|s|<02>w|jdk(rh|j|j|j|j<00>}|j<00> |j
}n |j}|j |<03>syy)z/Check whether the annotation needs to be drawn.r<>FT)
rr<>r r<>r<>r<>rar<>r<>r<>)rHr<>r<><00>xy_pixelr<6C>s rK<00> _check_xyzConnectionPatch._check_xy|s<><00><00> <11> $<24> $<24> &<26><01> <0C><11><19>t<EFBFBD>|<7C>|<7C>v<EFBFBD>5<><1B>|<7C>|<7C>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>G<>H<EFBFBD><13>z<EFBFBD>z<EFBFBD>!<21><1B>y<EFBFBD>y<EFBFBD><04><1B>z<EFBFBD>z<EFBFBD><04><17>&<26>&<26>x<EFBFBD>0<><1C> <0C><11><19>t<EFBFBD>|<7C>|<7C>v<EFBFBD>5<><1B>|<7C>|<7C>D<EFBFBD>H<EFBFBD>H<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>J<EFBFBD>J<EFBFBD>G<>H<EFBFBD><13>z<EFBFBD>z<EFBFBD>!<21><1B>y<EFBFBD>y<EFBFBD><04><1B>z<EFBFBD>z<EFBFBD><04><17>&<26>&<26>x<EFBFBD>0<><1C>rLc<00>h<00><01>|j<00>r|j|<01>syt<00>|<00> |<01>yr`)r<>rr.r<>r*s <20>rKr<>zConnectionPatch.draw<61>s)<00><><00><13><1F><1F>!<21><14><1E><1E><08>)A<> <12> <0A><07> <0C>X<EFBFBD>rLr`)rrrrrr r r/r rrr<>rr<>r rs@rKr<>r<><00>st<00><><00>H<>D<01><10><17><17>e%<25><1B>4<EFBFBD><1F>!'<27><1C><1C><1B><1B> #<23>!%<25><1E>e%<25><18>e%<25>N<O<01>|<1A> %<25><1E>$<14>2<1F>rLr<>r<>)r<>Nr`)Mrrrr6<00>numbersrrr<00>typesr<00> collectionsr<00>matplotlib.transformsr<00>numpyrk<00>
matplotlibr3r<>r r
r r r rr<>rr<>r<00>bezierrrrrrrrrrRr<00>_enumsrrr <00>define_aliasesr<73>r'rr,r<>r<>r<>r<>r<>rrr<>r<><00>getdocr/<00>
splitlinesr;rCrer<>r<>r<>r<>r<>rrrsr<>r<>r<>r<>r<>r:rLrK<00><module>r#s<><00><01><04><11><0E> <0B> <20><0F>!<21>"<22>*<2A><12><18>,<2C>,<2C>,<2C>A<01>A<01>A<01><17>'<27> <0C><13><13><14><14><14><14><18>6<EFBFBD><16><16><16><16><16><16><16><16> <02><03>r <14>F<EFBFBD>M<EFBFBD>M<EFBFBD>r <14><03><14>r <14>j9<1F>U<EFBFBD>9<1F>xV"<22><05>V"<22>r.!<21>U<EFBFBD>.!<21>b<1A><05><1A>8j<1A> <09>j<1A>Z`E<01>e<EFBFBD>`E<01>FS<1A>E<EFBFBD>S<1A>nP<17>E<EFBFBD>P<17>ff<0E><17>f<0E>R <0B><12><12><1B><1B><13>y<EFBFBD>y<EFBFBD> <17><17><1E><1E>
<EFBFBD>+<2B>+<2B> ,<2C> 2<><02>><3E>><3E>@<40><11><12>D<>F<01><1C>G<01>
D<01>N<EFBFBD>D<01>2q'<27>e<EFBFBD>q'<27>hx<1A>e<EFBFBD>x<1A>v'.<2E>W<EFBFBD>'.<2E>Ts7<>'<27>s7<>l<15>.
<15>S&<26>S&<26>l<0F>$<24><0F> <0C><13><13>i-<2D>v<EFBFBD>i-<2D><14>i-<2D>X  <0C><13><13>V)<29>f<EFBFBD>V)<29><14>V)<29>r <12> <0C><13><13>M <1E><16>M <1E><14>M <1E>`tF<01>U<EFBFBD>tF<01>n{/<2F>e<EFBFBD>{/<2F>| s<1F>o<EFBFBD>srL
Reference in a new issue Copy permalink