h~ jSrSSKrSSKrSSKrSSKJrJr SSKrSSKJ r SSK J r SSK J r SSKrSSKrSSKJrJrJrJrJrJrJrJr SS KJrJrJ r J!r!J"r"J#r#J$r$J%r% SS K&J'r' SS K(J)r)J*r* \RV\RX"S /S /S/S/S/S.5"SS\RZ555r."SS\.5r/"SS\.5r0"SS\.5r1"SS\.5r2"SS\25r3"SS\.5r4"S S!\.5r5"S"S#\.5r6"S$S%\45r7\RVRqS&Rs\Rt"\7Rv5=(d S'Ry5S(S5S)9 "S*S+\15r="S,S-\.5r>"S.S/\.5r?"S0S1\>5r@"S2S3\>5rASGS4jrBSHS5jrC"S6S75rDSISS8.S9jjrE\RV"S:S;\D55rF\RV"S<S=\D55rGS>rH\RV"S?S@\D55rI"SASB\.5rJ"SCSD\.5rK"SESF\K5rLg)Jz> Patches are `.Artist`\s with a face color and an edge color. N)NumberReal)SimpleNamespace) namedtuple)Affine2D)_apiartistcbookcolors _docstringhatchlines transforms)NonIntersectingPathException get_cos_singet_intersection get_parallels inside_circlemake_wedged_bezier2)split_bezier_intersecting_with_closedpathsplit_path_inout)Path) JoinStyleCapStyleaaecfclslw) antialiased edgecolor facecolor linestyle linewidthc ^\rSrSrSrSrSrSSSSSSSSSSS. U4SjjrS rS r S1S jr S1S jr S1S jr U4Sjr SrSrSrSrSrSrSrSrSrSrSrSrSrSrSrU4SjrSrS rS!r S"r!\""\!\ 5r#\$RJS#5r&S$r'\$RJS%5r(S&r)S'r*S(r+S)r,S*r-S+r.\/R`S,5r1S-r2S1S.jr3S/r4S0r5U=r6$)2Patchz 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#colorr%r$r!rfillcapstyle joinstylec  >[T U]5 UcSnU c[Rn U c[R n [ R"[RS5Ul [RSUl [U5Ul Ub.UcUb[R"S5 UR!U5 O"UR#U5 UR%U5 SUlSUlSUlUR-U5 UR/U5 UR1U5 UR3U5 UR5U 5 UR7U 5 [9U 5(aUR;U 5 gg)z? The following kwarg properties are supported %(Patch:kwdoc)s Nsolidz hatch.colorzhatch.linewidthzQSetting the 'color' property will override the edgecolor or facecolor properties.r)rN)super__init__rbuttrmiterr to_rgbamplrcParams _hatch_color_hatch_linewidthbool_fillr warn_external set_color set_edgecolor set_facecolor _linewidth_unscaled_dash_pattern _dash_pattern set_linestyle set_linewidthset_antialiased set_hatch set_capstyle set_joinstylelen_internal_update) selfr"r#r)r%r$r!rr*r+r,kwargs __class__s D/var/www/html/env/lib/python3.13/site-packages/matplotlib/patches.pyr0Patch.__init__0sC"   I  }}H  !I"NN3<< +FG # -> ?$Z  $ (=""=> NN5 !   y )   y )&/#& 9% 9% [) u (# 9% v;;  ! !& ) cUR5nUR5nURU5n[U5(aUS$/$)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) get_transformget_path to_polygonsrG)rItranspathpolygonss rL get_vertsPatch.get_vertsesE""$}}##E* x==A;  rNcUbU$[UR[5(aURnU$UR5SS:XaSnU$UR 5nU$)Nr) isinstance_pickerr get_edgecolor get_linewidth)rIradius_radiuss rL_process_radiusPatch._process_radiusssg  M dllF + +llG  !!#A&!+,,.rNc^^^TRT5(aS04$TRT5mTR5RnUbTR5Rn[ R "U[R:H5unUSSn[[[ R"XE5[ R"X555nOTR5/n[UUU4SjU55nU04$)a 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># UH<nURTRTR4TR5T5v M> g7fN)contains_pointxyrP).0subpath mouseeventr^rIs rL !Patch.contains..sI%$  " "z||,d.@.@.BF L L#sAA) _different_canvasr`rQcodesverticesnpwhererMOVETOmapsplitany)rIrjr^rnroidxssubpathsinsides``` rLcontainsPatch.containss>  ! !* - -"9 %%f- %%  }}//HHHUdkk12ED8Dbhhx.0EGH (H%$%%rzrNcURU5nUR5RUUR5U5$)ah 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`rQrerP)rIpointr^s rLrePatch.contains_points?r%%f-}}--e.2.@.@.B.46 6rNcURU5nUR5RUUR5U5$)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`rQcontains_pointsrP)rIpointsr^s rLrPatch.contains_pointss?H%%f-}}..v/3/A/A/C/57 7rNc>[TU]U5 URUlURUlURUlUR UlUR UlURUlURUlURUl URUR5 URUR55 UR5Ulgrd)r/ update_from _edgecolor _facecolor_original_edgecolor_original_facecolorr9_hatchr6r?rBr> set_transformget_data_transformis_transform_set _transformSet)rIotherrKs rLrPatch.update_froms E" ****#(#<#< #(#<#< [[ ll !..&+&B&B# 5++, 53356#335rNc\UR5RUR55$)zE Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`. rQ get_extentsrPrIs rLrPatch.get_extents-s$}}**4+=+=+?@@rNcbUR5[RRU5-$)z;Return the `~.transforms.Transform` applied to the `Patch`.)get_patch_transformr ArtistrPrs rLrPPatch.get_transform3s%'')FMM,G,G,MMMrNc@[RRU5$)zW Return the `~.transforms.Transform` mapping data coordinates to physical coordinates. )r rrPrs rLrPatch.get_data_transform7s }}**400rNc,[R"5$)a# 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. )rIdentityTransformrs rLrPatch.get_patch_transform>s++--rNcUR$)z0Return whether antialiasing is used for drawing.) _antialiasedrs rLget_antialiasedPatch.get_antialiasedIs   rNcUR$)zReturn the edge color.)rrs rLr\Patch.get_edgecolorM rNcUR$)zReturn the face color.)rrs rL get_facecolorPatch.get_facecolorQrrNcUR$)z Return the line width in points.)r>rs rLr]Patch.get_linewidthUrrNcUR$)zReturn the linestyle.) _linestylers rL get_linestylePatch.get_linestyleYrrNcJUc[RSnXlSUlg)zT Set whether to use antialiased rendering. Parameters ---------- aa : bool or None Nzpatch.antialiasedT)r4r5rstale)rIrs rLrCPatch.set_antialiased]s% :12B rNc:SnUcR[RS(d"UR(aUR(a[RSnOSnSn[R "XR 5UlU(aURUlSUl g)NTzpatch.force_edgecolorzpatch.edgecolornoneF) r4r5r9 _edge_defaultr r3_alpharr6r)rIr)set_hatch_colors rL_set_edgecolorPatch._set_edgecolorjsk = 45 d&8&8 %67"' .. <  $D  rNc2XlURU5 g)zS Set the patch edge color. Parameters ---------- color : :mpltype:`color` or None N)rrrIr)s rLr<Patch.set_edgecolory$)  E"rNcUc[RSnUR(a UROSn[R "X5UlSUlg)Nzpatch.facecolorrT)r4r5r9rr r3rr)rIr)alphas rL_set_facecolorPatch._set_facecolors> =LL!23E#zz q ..6 rNc2XlURU5 g)zS Set the patch face color. Parameters ---------- color : :mpltype:`color` or None N)rrrs rLr=Patch.set_facecolorrrNcHURU5 URU5 g)z 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<)rIcs rLr;Patch.set_colors  1 1rNc>[TU]U5 URUR5 UR UR 5 grd)r/ set_alpharrrr)rIrrKs rLrPatch.set_alphas8 %  D445 D445rNcUc[RSn[U5Ul[R "/UR QUP76UlSUlg)zM Set the patch linewidth in points. Parameters ---------- w : float or None Nzpatch.linewidthT) r4r5floatr>mlines _scale_dashesr?r@rrIws rLrBPatch.set_linewidthsS 9 ./A(#11-  ( (-*+- rNcUcSnUS;aSnXl[R"U5Ul[R"/URQUR P76UlSUlg)a5 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.) rNoneT)rr_get_dash_patternr?rr>r@r)rIrs rLrAPatch.set_linestylesh2 :B " "B&,&>&>r&B##11;  ( (;*.//; rNc[U5UlURUR5 UR UR 5 SUlg)z@ Set whether to fill the patch. Parameters ---------- b : bool TN)r8r9rrrrrrIbs rLset_fillPatch.set_fills>!W  D445 D445 rNcUR$)z#Return whether the patch is filled.)r9rs rLget_fillPatch.get_fill zzrNc4[U5nX lSUlg)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 _capstyler)rIscss rLrEPatch.set_capstylesa[ rNc.URR$)zReturn the capstyle.)rnamers rL get_capstylePatch.get_capstyles~~"""rNc4[U5nX lSUlg)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 _joinstyler)rIrjss rLrFPatch.set_joinstyle sq\ rNc.URR$)zReturn the joinstyle.)rrrs rL get_joinstylePatch.get_joinstyles###rNcJ[R"U5 XlSUlg)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)mhatch_validate_hatch_patternrr)rIrs rLrDPatch.set_hatchs4 &&u-  rNcUR$)zReturn the hatching pattern.)rrs rL get_hatchPatch.get_hatch; {{rNcXlg)zSet the hatch linewidth.Nr7)rIr s rLset_hatch_linewidthPatch.set_hatch_linewidth?s "rNcUR$)zReturn the hatch linewidth.rrs rLget_hatch_linewidthPatch.get_hatch_linewidthC$$$rNcURSUR55 UR5nURURSS9 UR nURSS:XdUR S:XaSnURU5 UR"UR6 URUR5 URUR5 URUR5 UR!U5 UR#UR$5 UR'UR)55 UR+UR,5 UR.(aQUR1UR.5 UR3UR45 UR7UR85 UR;5bUR<"UR;56 UR?5(aSSK J!n U"UR?5U5nUHnURD"U/UQ76 M URG5 URIS5 S Ul%g) a ``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*. patchT)isRGBArYrrN)PathEffectRendererF)& open_groupget_gidnew_gcset_foregroundrr>rrB set_dashesr@rErrFrrCr _set_gc_clipset_url_urlset_snapget_snaprrrrDrr6rr7get_sketch_paramsset_sketch_paramsget_path_effectsmatplotlib.patheffectsr draw_pathrestore close_groupr)rIrendererdraw_path_args_listgcr rdraw_path_argss rL"_draw_paths_with_artist_properties(Patch._draw_paths_with_artist_propertiesGs GT\\^4 __  $//$7 __ ??1  "doo&?B  t))* ' ) 4,,- " 499 DMMO$ T[[! ;; LL %   t00 1  " "4#8#8 9  ! ! # /  $"8"8": ;  " " A)$*?*?*A8LH1N   r 3N 32 W% rNcUR5(dgUR5nUR5nURU5nUR 5nUR UXEUR S(a UR OS4/5 g)NrY) get_visiblerQrPtransform_path_non_affine get_affinerr)rIrrT transformtpathaffines rLdraw Patch.drawys!! }}&&( 33D9%%' // "&!3doo ? @ ArNc[S5e)zReturn the path of this patch.Derived must overrideNotImplementedErrorrs rLrQPatch.get_paths!"9::rNc\UR5RUR55$rdr)rIrs rLget_window_extentPatch.get_window_extents"}}**4+=+=+?@@rNcXURUS5nURUS5nX#4$)z)Convert x and y units for a tuple (x, y).rr)convert_xunitsconvert_yunits)rIxyrfrgs rL_convert_xy_unitsPatch._convert_xy_unitss1   1 &   1 &t rN)rrr@rrr9rr6r7rrr>rrrr?rrd)7__name__ __module__ __qualname____firstlineno____doc__zorderrr0rVr`ryrerrrrPrrrr\rr]rrCrr<rr=r;rrBrArrpropertyr*r interpdrErrFrrDrrrrr allow_rasterizationrrQr'r-__static_attributes__ __classcell__rKs@rLr'r's^ FM !3*3*j  2h<6|'7R6&A N1 .!   # # 6 !F  Hh 'D  #  $<#%0d A A ;ArNr'cr^\rSrSrSr\R SS.U4Sjj5rSrSr Sr U4S jr S r U=r $) Shadowic"SURS3$)NzShadow())rrs rL__str__Shadow.__str__s A&&rNgffffff?)shadec >[TU]5 XlX#sUlUl[ R "5UlURUR5 SUs=::aS::d O [S5eSU- [R"[R"URR555-nURXfS[R "URR"[R$*5S.UE5 g)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.?)r#r"rr4N)r/r0r_ox_oyrr_shadow_transformr ValueErrorrpasarrayr to_rgbrupdate nextafterr4inf)rIroxoyrArJr)rKs rLr0Shadow.__init__s4  $(!+!4!4!6 $EQ=> >Ubjjtzz7O7O7Q)RSS %c!||DJJ,=,=wG rNcURUR5nURUR5nURR 5R X#5 grd)points_to_pixelsrDrErFclear translate)rIrrMrNs rL_update_transformShadow._update_transformsG  & &txx 0  & &txx 0 $$&008rNc6URR5$rd)rrQrs rLrQShadow.get_pathszz""$$rNcPURR5UR-$rd)rrrFrs rLrShadow.get_patch_transforms zz--/$2H2HHHrNcF>URU5 [TU] U5 grd)rTr/rrIrrKs rLr Shadow.draws x(  XrN)rDrErFr)r/r0r1r2r?r r6r0rTrQrrr8r9r:s@rLr<r<s@'/2% % N9 %IrNr<c^\rSrSrSrSr\RSSS.U4Sjj5rSr S r S r \ S 5r \ RS 5r S rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr\ "\\5rSr U=r!$) Rectangleia 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. cURURURURUR4nSnX!-$)Nz5Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g))_x0_y0_width_heightanglerIparsfmts rLr?Rectangle.__str__s3xx4;; djjHEzrNr,)rdrotation_pointc >[TU]"S0UD6 USUlUSUlX lX0l[ U5UlXPlSUl UR5 g)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?N) r/r0r`rarbrcrrdrj_aspect_ratio_correction_convert_units)rIr,widthheightrdrjrJrKs rLr0Rectangle.__init__s\0 "6"a5a5  5\ ,),% rNc,[R"5$)z%Return the vertices of the rectangle.)runit_rectanglers rLrQRectangle.get_paths""$$rNcURUR5nURUR5nURURUR-5nURURUR -5nXX44$)z Convert bounds of the rectangle.)r*r`r+rarbrc)rIx0y0x1y1s rLroRectangle._convert_unitssn   *   *  DKK!7 8  DLL!8 9r~rNcUR5nURS:XaVURUR- URUR - p2URUS- -UR US- -4nO5URS:XaURUR 4nO URn[ R"U5[ R"5RUS*US*5RSUR5RUR5RSSUR- 5R"U6-$)Ncenter@r,rr)get_bboxrjryrwrzrxrBboxTransformTorrSscalern rotate_degrd)rIbboxrprqrjs rLrRectangle.get_patch_transform s }}   ( * GGdgg-tww/@6!WWurz1477Vb[3HHN  D (!WWdgg-N!00N))$/%%'N1--q0A/ABq$778DJJ'q!d;;;<  + ,, ,rNcUR$)z The rotation point of the patch.)_rotation_pointrs rLrjRectangle.rotation_point5s###rNcUS;dT[U[5(aF[U5S:Xa7[US[5(a[US[5(aXlg[ S5e)N)r}r,rrzC`rotation_point` must be one of {'xy', 'center', (number, number)}.)rZtuplerGrrrG)rIvalues rLrjr:s^ $ $5%((SZ1_58T**z%(D/I/I#( CD DrNcUR$)z,Return the left coordinate of the rectangle.)r`rs rLget_xRectangle.get_xE xxrNcUR$)z.Return the bottom coordinate of the rectangle.)rars rLget_yRectangle.get_yIrrNc2URUR4$)z>Return the left and bottom coords of the rectangle as a tuple.)r`rars rLget_xyRectangle.get_xyMsxx!!rNcDUR5R/SQ5$)zK Return the corners of the rectangle, moving anti-clockwise from (x0, y0). )rrrrrrrrrrrs rL get_cornersRectangle.get_cornersQs# '')33 ,. .rNc@UR5RS5$)z#Return the centre of the rectangle.)rCrCrrs rL get_centerRectangle.get_centerYs'')33J??rNcUR$z"Return the width of the rectangle.rbrs rL get_widthRectangle.get_width]rrNcUR$z#Return the height of the rectangle.rcrs rL get_heightRectangle.get_heighta ||rNcUR$)z"Get the rotation angle in degrees.rdrs rL get_angleRectangle.get_angleerrNcXlSUlg)z)Set the left coordinate of the rectangle.TN)r`rrIrfs rLset_xRectangle.set_xi rNcXlSUlg)z+Set the bottom coordinate of the rectangle.TN)rarrIrgs rLset_yRectangle.set_ynrrNcXlSUlg)z[ Set the rotation angle in degrees. The rotation is performed anti-clockwise around *xy*. TN)rdrrIrds rL set_angleRectangle.set_angless   rNc0UuUlUlSUlg)zb Set the left and bottom coordinates of the rectangle. Parameters ---------- xy : (float, float) TN)r`rarrIr,s rLset_xyRectangle.set_xy|s $( rNcXlSUlg)zSet the width of the rectangle.TNrbrrs rL set_widthRectangle.set_widths  rNcXlSUlg)z Set the height of the rectangle.TNrcrrIhs rL set_heightRectangle.set_heights  rNc|[U5S:Xa USup#pEOUup#pEX lX0lX@lXPlSUlg)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)rGr`rarbrcrrIargslrrrs rL set_boundsRectangle.set_boundssB t9>aJA!QJA!   rNcX[RR"UR56$zReturn the `.Bbox`.)rBbox from_extentsrors rLrRectangle.get_bboxs ++T-@-@-BCCrN) rnrcrrbr`rardrjr)"r/r0r1r2r3r?r r6r0rQrorr5rjsetterrrrrrrrrrrrrrrrrr,r8r9r:s@rLr^r^s$ 4%%N%,*$$DD".@     *D && !BrNr^cf^\rSrSrSrSr\RSSS.U4Sjj5rSr S r S r U=r $) RegularPolygonizA regular polygon patch.cSnXRSURSURURUR4-$)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)r, numverticesr^ orientationrIrs rLr?RegularPolygon.__str__sB EGGAJ D,<,XlX lX@lX0l[R "U5Ul[R"5Ul [TU],"S0UD6 g)a6 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 Nrm) r,rrr^runit_regular_polygon_pathrr_patch_transformr/r0)rIr, numVerticesr^rrJrKs rLr0RegularPolygon.__init__sN.&& ..{; * 3 3 5 "6"rNcUR$rdrrs rLrQRegularPolygon.get_path zzrNcURR5RUR5R UR 5R "UR6$rd)rrRrr^rotaterrSr,rs rLr"RegularPolygon.get_patch_transformsO$$**, U4;;  VD$$ % Y! !rN)rrrrr^r,) r/r0r1r2r3r?r r6r0rQrr8r9r:s@rLrrs9"& q##<!!rNrc`^\rSrSrSrSrSr\RU4Sj5r Sr Sr Sr U=r $) PathPatchizA general polycurve path patch.TcSnU[URR5/[URRS5Q7-$)NzPathPatch%d((%g, %g) ...)r)rGrrorrs rLr?PathPatch.__str__s= 'C ++,MuTZZ5H5H5K/LMMMrNc 2>[TU]"S0UD6 Xlg)zL *path* is a `.Path` object. Valid keyword arguments are: %(Patch:kwdoc)s Nrm)r/r0r)rIrTrJrKs rLr0PathPatch.__init__s "6" rNcUR$rdrrs rLrQPathPatch.get_pathrrNcXlgrdr)rIrTs rLset_pathPathPatch.set_paths rNr)r/r0r1r2r3rr?r r6r0rQrr8r9r:s@rLrrs:)MN  rNrcn^\rSrSrSrSr\RSSS.U4Sjj5rSr S r S S jr S r U=r $) StepPatchiz A path patch describing a stepwise constant function. By default, the path is not closed and starts and stops at baseline value. Fverticalr)rbaselinec >X0l[R"U5Ul[R"U5UlUb[R"U5OSUlUR 5 [TU] "UR40UD6 g)a 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) rrprH_edges_values _baseline _update_pathr/r0r)rIvaluesedgesrrrJrKs rLr0StepPatch.__init__sd8'jj' zz&) 191EH-4  .v.rNc [R"[R"UR55(a [ S5eURR S- UR R :wa:[ SUR R SURR S35e[R"S5/[R"S[RS9/p![R"UR 5nURb#U[R"UR5-n[R"U)5GHupE[R"URXES-S 5n[R"UR XES 5nURc[R"USSXwS S/5nOURRS:Xa/[R"UR/XpR//5nOURRS:Xam[R"URXES 5SSS 2n[R"XfSSS 2/5n[R"US SXxSSUSSXS S/5nO [ S 5eUR S :Xa[R""Xg/5n O[R""Xv/5n UR%U 5 UR%[R&/[R(/[+U 5S- --5 GM [[R"U5[R"U55Ulg) 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`.rrr)dtyperzInvalid `baseline` specifiedr)rpisnansumrrGsizeremptyr code_typerr contiguous_regionsrepeat concatenatendimr column_stackappendrrLINETOrGr) rIvertsrn _nan_maskidx0idx1rfrgbaser,s rLrStepPatch._update_path's 88BFF4;;' ( (CD D ;;  a 4<<#4#4 4//3||/@/@.AB..2kk.>.>-?rCD D ()BHHQdnn,M+NuHHT\\* >> % $..1 1I22I:>JD $++d62A6A $,,t115A~~%NNAbqE1f#56$$)NNT^^$4a..9I#JK$$)yy!:A>ttDNNA2w<0NNDIqr($(!HdI$?@!!?@@:-__aV,__aV, LL  LL$++$++B )BB C'?("../1FG rNcj[SS5nU"URURUR5$)z:Get `.StepPatch` values, edges and baseline as namedtuple. StairDatazvalues edges baseline)rrrr)rIrs rLget_dataStepPatch.get_dataKs*{,CD t{{DNNCCrNcUcUcUc [S5eUb[R"U5UlUb[R"U5UlUb[R"U5UlUR 5 SUlg)z 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)rGrprHrrrrr)rIrrrs rLset_dataStepPatch.set_dataPss >em0@HI I  ::f-DL  **U+DK  ZZ1DN  rN)rrrrrr)NNN)r/r0r1r2r3rr r6r0rrrr8r9r:s@rLrrsDM'! / /D"HHD rNrc^\rSrSrSrSr\RSS.U4Sjj5rSr Sr S r S r S r \"\ \ S S 9rSrU=r$)PolygonigzA general polygon patch.c[URR5(a?SnU[URR5/URRSQ7-$g)NzPolygon%d((%g, %g) ...)rz Polygon0())rGrrors rLr?Polygon.__str__jsP tzz"" # #)ADJJ//0J4::3F3Fq3IJJ JrNTclosedc T>[TU]"S0UD6 X lURU5 g)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 Nrm)r/r0_closedr)rIr,r&rJrKs rLr0Polygon.__init__qs% "6"  BrNcUR$)zGet the `.Path` of the polygon.rrs rLrQPolygon.get_pathrrNcUR$)z%Return whether the polygon is closed.)r(rs rL get_closedPolygon.get_closedrrNcUR[U5:Xag[U5UlURUR55 SUlg)zk Set whether the polygon is closed. Parameters ---------- closed : bool True if the polygon is closed NT)r(r8rrr)rIr&s rL set_closedPolygon.set_closeds; <<4< ' F|  DKKM" rNc.URR$)zb Get the vertices of the path. Returns ------- (N, 2) array The coordinates of the vertices. )rrors rLrPolygon.get_xyszz"""rNc[R"U5nURup#UR(aFUS:Xd$US:a9USUS:gR 5(a "XS//5nO)US:a#USUS:HR 5(aUSSn[XRS9UlSUl g)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. rrrrNr%T) rprHshaper(rurallrrr)rIr,nverts_s rLrPolygon.set_xys ZZ^HH  << {fqjber"vo-B-B-D-D^^RQ%M2zr!u23355W"\\2  rNz+The vertices of the path as a (N, 2) array.)doc)r(rr)r/r0r1r2r3r?r r6r0rQr-r0rrr5r,r8r9r:s@rLr"r"gsV" %)"  #B &&C EBrNr"c^\rSrSrSrSr\RSS.U4Sjj5rSr Sr S r S r S r S rS rSrU=r$)WedgeizWedge shaped patch.cURSURSURURURUR4nSnX!-$)Nrrz[TU]"S0UD6 XlX%sUlUlX4sUlUl[R"5Ul UR5 g)z 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 Nrm) r/r0r}r>rpr?r@rrr_recompute_path)rIr}r>r?r@rprJrKs rLr0Wedge.__init__sS "6"  #)  T[ * < < > rNc [URUR- S- 5S::aSup[RnO'URURp![R n[R "X5nURbURnURSSS2URUR- -UR- n[R"XVS//5n/URQUPURSSQ[RPnOD[R"URSS//5n/URQUP[RPn[XpR-UR-U5Ulg)Nhg-q=)rrGrrr)absr@r?rrrrarcrpror>rprrn CLOSEPOLYr}r) rIr?r@ connectorrIv1v2vrs rLrDWedge._recompute_paths4  dkk)S0 1U :#NF I![[$++F Ihhv& :: !Bdd#tvv ':;dffDB12AG#))GYG12GGA vv.>?@A7#))7Y77A!ff*t{{2A6 rNc,SUlXlSUlgNT)rr}r)rIr}s rL set_centerWedge.set_center   rNc,SUlXlSUlgrQ)rr>rrIr^s rL set_radiusWedge.set_radiuss  rNc,SUlXlSUlgrQ)rr?r)rIr?s rL set_theta1Wedge.set_theta1 rTrNc,SUlXlSUlgrQ)rr@r)rIr@s rL set_theta2Wedge.set_theta2rTrNc,SUlXlSUlgrQ)rrprrIrps rLrWedge.set_widths   rNcTURcUR5 UR$rdrrDrs rLrQWedge.get_path" ::   "zzrN)rrr}r>rr?r@rp)r/r0r1r2r3r?r r6r0rDrRrWrZr]rrQr8r9r:s@rLr<r<sP ;?$76     rNr<c ^\rSrSrSrSr\R"SS/SS/SS/SS/S S/SS /SS//5r\ RS S .U4S jj5r S r Sr SSjrSrU=r$)Arrowi!zAn arrow patch.cg)NzArrow()rmrs rLr? Arrow.__str__$srNri皙?g皙?g333333ӿrl333333?rBc L>[TU]"S0UD6 URXX4U5 g)a 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. Nrm)r/r0r)rIrfrgdxdyrprJrKs rLr0Arrow.__init__+s%< "6" aBE*rNcUR$rdrrs rLrQArrow.get_pathLrrNcUR$rd)rrs rLrArrow.get_patch_transformOs$$$rNcUbXlUbX lUbX0lUbX@lUbXPl[ R "5R[R"URUR5UR5R[R"URUR55RURUR5R5Ulg)aY 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)_x_y_dx_dyrbrrrrphypotrarctan2rSfrozenr)rIrfrgrnrorps rLrArrow.set_dataRs =G =G >H >H  K    ! U288DHHdhh/ = VBJJtxx2 3 Ytww ( VX rN)rxryrrbrvrw)NNNNN)r/r0r1r2r3r?r_create_closedrr r6r0rQrrr8r9r:s@rLrgrg!s    c S$K#tsDkC: c S#J!  !E.1++@%rNrgc ^\rSrSrSrSrSr\RSSSSSS SS .U4S jj5r SSSSSSSS .S jr Sr Sr U=r $) FancyArrowitzH Like Arrow, but lets you set head width and head height independently. Tcg)Nz FancyArrow()rmrs rLr?FancyArrow.__str__{srNgMbP?FNfullr)rplength_includes_head head_width head_lengthr5overhanghead_starts_at_zeroc >XlX lX0lX@lXPlX`lXplXlXlXl Xl UR5 [T U]4"UR4SS0U D6 g)a 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)rvrwrxryrb_length_includes_head _head_width _head_length_shape _overhang_head_starts_at_zero _make_vertsr/r0r)rIrfrgrnrorprrrr5rrrJrKs rLr0FancyArrow.__init__~shT %9"%' !$7!  ;D;F;rN)rfrgrnrorprrcUbXlUbX lUbX0lUbX@lUbXPlUbX`lUbXplUR5 URUR5 g)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) rvrwrxryrbrrrrr)rIrfrgrnrorprrs rLrFancyArrow.set_datask. =G =G >H >H  K  !)   " +   DJJrNc\URcSUR-nO URnURcSU-nO URn[R"UR UR 5nUR(aUnOX2-nU(d[R"SS/5Ul gXpeURURp[R"SS/U*U*S- /U*SU- -U*S- /U*U*S- /U*S//5n UR(dXS/- n UR(a XS- S/- n URS:XaU n OeU SS/-n URS :XaU n OKURS :Xa"[R"U SSU S SS2/5n O[S UR<35eUS:waUR U- n UR U- n OS upX/U *U //n[R "X5UR"UR -UR$UR -/-Ul g)NrYg?rrrirleftrrightrzGot unknown shape: r)rrbrrprzrxryrr rrarrayrrrrGdotrvrw)rIrrdistancelengthhwhlhsr left_half_arrowcoordsright_half_arrowcxsxMs rLrFancyArrow._make_vertss*    #T[[J))J    $ *K++K88DHHdhh/  % %F+F1a&)DJ ^^T[[ hhc rcAgB"q)2#'"! (O--#33((!OQ#77{{f$(#2aW#< ;;')-F[[F* ^^_Sb-A-=bf"f-E-GHF%':4;;/%JKK1}XX(XX(RC9%A*$(("$((".DJrN) rxryrrrrrrrbrvrwr)r/r0r1r2r3rr?r r6r0rrr8r9r:s@rLrrtsbM5T!!%*5<5[TU]"X4USS.UD6 g)z 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 rrNr/r0)rIr,r^rrJrKs rLr0CirclePolygon.__init__)s*   D#)q Ds> Qa DKK5CzrNrrc >[TU]"S0UD6 XlX#sUlUlX@l[ R"5UlSUl [R"5Ul g)aI 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 rlNrm) r/r0rrbrc_angler unit_circlerrnrrr)rIr,rprqrdrJrKs rLr0Ellipse.__init__DsX( "6" $)! T\ %%' ),% * < < >rNcURURS5URURS54nURUR5nURUR5n[ R "5RUS-US-UR-5RUR5RSSUR- 5R"U6Ul g)z 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. rrrCN) r*rr+rbrcrrrrnrrdrSr)rIr}rprqs rL_recompute_transformEllipse._recompute_transformgs%%dll1o6%%dll1o68##DKK0$$T\\2 * 3 3 5 U53; t/L/L L M Z # U1a$777 8 Y ! ! rNcUR$)zReturn the path of the ellipse.rrs rLrQEllipse.get_pathzrrNc:UR5 UR$rd)rrrs rLrEllipse.get_patch_transform~s !!#$$$rNcXlSUlg)zK Set the center of the ellipse. Parameters ---------- xy : (float, float) TN)rrrs rLrREllipse.set_centers  rNcUR$)z!Return the center of the ellipse.rrs rLrEllipse.get_centerrrNcXlSUlg)zD Set the width of the ellipse. Parameters ---------- width : float TNrr`s rLrEllipse.set_width  rNcUR$)z" Return the width of the ellipse. rrs rLrEllipse.get_widths{{rNcXlSUlg)zF Set the height of the ellipse. Parameters ---------- height : float TNr)rIrqs rLrEllipse.set_heights  rNcUR$)z!Return the height of the ellipse.rrs rLrEllipse.get_heightrrNcXlSUlg)zD Set the angle of the ellipse. Parameters ---------- angle : float TN)rrrs rLrEllipse.set_anglerrNcUR$)z Return the angle of the ellipse.rrs rLrEllipse.get_anglerrNcDUR5R/SQ5$)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. ))rr)rrr)rrrrs rLrEllipse.get_cornerss#'')33 02 2rNcURUR:a"UR5RSS/5nO!UR5RSS/5nUVs/sHn[ U5PM sn$s snf)z Return the vertices coordinates of the ellipse. The definition can be found `here `_ .. versionadded:: 3.8 rrrrrrrprqrrrrIretrfs rL get_verticesEllipse.get_verticesl :: #**,667HIC**,667HIC"%&#Qa#&&&"A:cURUR:a"UR5RSS/5nO!UR5RSS/5nUVs/sHn[ U5PM sn$s snf)z Return the co-vertices coordinates of the ellipse. The definition can be found `here `_ .. versionadded:: 3.8 rrrrrrs rLget_co_verticesEllipse.get_co_verticesrr)rrnrrcrrrbr)r/r0r1r2r3r?r r6r0rrQrrRrr5r}rrrprrrqrrrdrrrr8r9r:s@rLrr;s 34 ? ?D &% j* -F  Y *E j* -F  Y *E2 ' ' 'rNrc^\rSrSrSr\R SU4Sjj5rSrSr Sr \ "\ \ 5r Sr Sr\ "\\ 5rS rS r\ "\\5rS rS rS rSr\ "\\5rSrSrSrSrU=r$)Annulusiz An elliptical annulus. c z>[TU]"S0UD6 URU5 XlX0lX@lSUlg)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 Nrm)r/r0 set_radiir}rprdr)rIr,r>rprdrJrKs rLr0Annulus.__init__s72 "6" q    rNcURUR:Xa URnOURUR4nS/URQUPURPURP7-$)Nz.Annulus(xy=(%s, %s), r=%s, width=%s, angle=%s))arr}rprdrIr>s rLr?Annulus.__str__s] 66TVV A A?9$++9q9$**9djj9: :rNc,XlSUlSUlg)zK Set the center of the annulus. Parameters ---------- xy : (float, float) NT)rrrrs rLrRAnnulus.set_centers   rNcUR$)z!Return the center of the annulus.rrs rLrAnnulus.get_center*rrNcU[URUR5:a [S5eXlSUlSUlg)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)minrrrGrbrrr`s rLrAnnulus.set_width0sB 3tvvtvv& &PR R   rNcUR$)z1Return the width (thickness) of the annulus ring.rrs rLrAnnulus.get_widthBrrNc,XlSUlSUlg)zI Set the tilt angle of the annulus. Parameters ---------- angle : float NT)rrrrs rLrAnnulus.set_angleHs   rNcUR$)z Return the angle of the annulus.rrs rLrAnnulus.get_angleTrrNc@[U5UlSUlSUlg)zN Set the semi-major axis *a* of the annulus. Parameters ---------- a : float NT)rrrr)rIrs rL set_semimajorAnnulus.set_semimajorZq  rNc@[U5UlSUlSUlg)zN Set the semi-minor axis *b* of the annulus. Parameters ---------- b : float NT)rrrrrs rL set_semiminorAnnulus.set_semiminorfrrNc[R"U5S:XaUuUlUlO=[R"U5S:Xa[ U5=UlUlO [ S5eSUlSUlg)a 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. )rrmz(Parameter 'r' must be one or two floats.NT)rpr5rrrrGrrrs rLrAnnulus.set_radiirs] 88A;$ NDFDF XXa[B #Ah &DFTVGH H  rNc2URUR4$)z:Return the semi-major and semi-minor radii of the annulus.)rrrs rL get_radiiAnnulus.get_radiisvvtvv~rNc[R"5R"URX#456R UR 5R "URUR56RU5$rd) rrrr-rrdrSr}r)rIrrrs rL_transform_vertsAnnulus._transform_vertsso""$ U**A624 Z # Y..t{{;=Yu   rNc[R"SS5nURURURpCnUR UR X#5nUR UR SSS2X$- X4- 5n[R"XVUSSS24S/5n[R"UR[RURSS[R[R/5n[Xx5Ul g)NrrGrrr)rrIrrrprrorpvstackhstackrnrrrJr) rIrIrrrrLrMrNrs rLrDAnnulus._recompute_pathshhq#&&$&&$**a  " "3<< 6  " "3<<"#5quae D IIrr!Q$x0 1 IIsyy$++yy}dkk~~' (!Z rNcTURcUR5 UR$rdrcrs rLrQAnnulus.get_pathrerN) rrrrbrrdrr}rrpri)r/r0r1r2r3r r6r0r?rRrr5r}rrrprrrdrrrrradiirrDrQr8r9r:s@rLrrs@: j* -F$ Y *E  Y *E  , Y *E  rNrcr^\rSrSrSrSr\RSU4Sjj5rSr Sr \ "\ \ 5r Sr U=r$) Circleiz A circle patch. c`URSURSUR4nSnX!-$)NrrzCircle(xy=(%g, %g), radius=%g))r}r^res rLr?Circle.__str__s/{{1~t{{1~t{{:.zrNc B>[TU]"XS-US-40UD6 X lg)z 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 rN)r/r0r^)rIr,r^rJrKs rLr0Circle.__init__s& aZ!>v> rNc4SU-=UlUlSUlg)zE Set the radius of the circle. Parameters ---------- radius : float rTN)rprqrrVs rLrWCircle.set_radiuss$%v:- T[ rNc URS- $)z Return the radius of the circle.r~rBrs rL get_radiusCircle.get_radiusszzBrN)rqr^rrpr)r/r0r1r2r3r?r r6r0rWrr5r^r8r9r:s@rLrrs?    j* -FrNrc^\rSrSrSrSr\RSSSS.U4Sjj5r\ RS5r S r S r S rU=r$) Arcizl An elliptical arc, i.e. a segment of an ellipse. Due to internal optimizations, the arc cannot be filled. cURSURSURURURURUR 4nSnX!-$)NrrzEArc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g))r}rprqrdr?r@res rLr? Arc.__str__sM A A  TZZdkkC<zrNrigv@)rdr?r@c @>URSS5nU(a [S5e[T U] "XU4SU0UD6 XPlX`lUR 5uUlUlUl Ul [R"URUR5Ul g)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 filledrdN) setdefaultrGr/r0r?r@_theta_stretch_theta1_theta2_stretched_width_stretched_heightrrIr) rIr,rprqrdr?r@rJr*rKs rLr0 Arc.__init__sH  / ;< < FB%B6B  #'#6#6#8 !t|T%: XXdllDLL9 rNc^^UR5(dgUR5 UR5 UR5nUR UR UR 45UR S5- up4SnX5:aXE:a[RX5$SmU4Sjn[R"UR=(d URSS9R5UR5- n[R "5R#U5n[%5n ['UR(SSUR(S S5H|upU"/U QU Q76n U R*up[,R."[,R0"X55S -S -nU R3XR4U:XR6:-5 M~ [9U 5UR6/-n UR4n[,R:"UR45nUR=[,R>"U5[,R@"U545nURBnU HCnU(a5[RD"UUS 5Ul![RX5 SnOS nUnME UUl!g) 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`. Nrg\!AcX - nX1- nXD-XU--nX-X!-- nXw-nXh- n U S:a[R"SU5n [R"U 5n [R"Xu-X-U --U- U*U-[ U5U --U- /Xu-X-U -- U- U*U-[ U5U -- U- //5$[R "S5$)Nrirr)rpcopysignsqrtrrHr ) rwrxryrzrnrodr2DD2discrimsign_dy sqrt_discrims rLline_circle_intersect'Arc.draw..line_circle_intersectWsBB'BG#C"'!ABhG#~++a,!www/ xxv | ;;sBrBwR@v | ;;sBrBwR@ABB xx''rNc>SnX :aX peOXpeX1:aX1pOXpT "XX#5n U RupU XT- U :XU-:-Xt- U :-XU-:-$)Ng& .>)T) rwrxryrzepsilonx0ex1ey0ey1exysxsysr1s rLsegment_circle_intersect*Arc.draw..segment_circle_intersectis~GwSSwSS'7CUUFB#7](:;=2%'*,W}*<> rNFrootrrrGT)#rrrrrr$r%r'rrraxes get_figurerrPrrt transformedsetzipror4rprad2degr{rJr"r#sorteddeg2radrecossinrrI)rIrdata_to_screen_transpwidthpheight inv_errorr=box_path_transformbox_paththetasp0p1r,rfrgtheta last_theta theta1_radrx path_originalr1s @rLrArc.drawsP\!!  !!#  $668 * *D,A,A,0,B,B,D E * *6 2 3 -  '"5::d- - ($ *  & & (PT__%_5P'V'V W  " # &&(445GH(++CR0(2C2CAB2GHFB)3233B44DAZZ 1 01C73>E MM||e+ 0DEF H I4<<.0\\ ZZ - (( VVJ  !3 4   E!XXj%;  4*J# rNc TUR5n[S[XRURUR UR 4555(aLUuUlUlUlUl[R"URUR5Ul gg)Nc3.# UH upX:gv M g7frdrm)rhrrs rLrk#Arc._update_path..s6#5$!qv#5s) r!rurFr"r#r$r%rrIr)rI stretcheds rLrArc._update_paths'') 6#LL$,,8M8M 224#56 6 6(1 %T\4<)>  #$,, =DJ  6rNcSnURUR5nURUR5nX#:wahURUR :wa URS-UR S-:Xd.U"URX#- 5nU"UR X#- 5nXEX#4$URUR X#4$)Nc[R"U5n[R"U5n[R"U5n[R"[R "X-U55nUS-S-$)NrG)rprIrJrKrGr{)rUrrfrgsthetas rL theta_stretch)Arc._theta_stretch..theta_stretchsTJJu%Eu Au AZZ 59a 89FSLC' 'rNrG)r*rpr+rqr?r@)rIrbrprqr?r@s rLr!Arc._theta_stretchs (##DJJ/$$T[[1 O[[DKK/[[3&$++*;;"4;;?F"4;;?F50 0{{DKK66rN)rr%r$r"r#r?r@)r/r0r1r2r3r?r r6r0r r7rrr!r8r9r:s@rLrrs[ 3u-:-:^ L# L#\>77rNrc Uc0nUR5nURSS5nURU5nUR"U5n[ UR US- - UR US- - 4URU-URU-U[R"5SS9nURU5 URU5 g)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. NpadrF)r,rprqr*rclip_on) copypoprQr'r^rwrxrprqrrrJr)r rpropsr*rfrr>s rL bbox_artistrls } JJLE ))E1 C  # #C (C  # #H -D GGcAg twwq0 1jj3t{{S'8 Z99;U LAHHUOFF8rNc [URURURUSSS9nUbUR U5 UR U5 g)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)r,rprqr"r*rhN)r^rSrprqrr)rrr)rSr>s rL draw_bboxrnsE TWWDJJt{{!u >A  FF8rNc~\rSrSrSrSrSr\S5r\S5r \\ R"SSS S 9S 55r S r g )_Styleiz 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$[RR"S0URS3UR 5URS3UR 5S-SR [ SRUR55-S-0D6 g)Nz:tablez:table_and_acceptsz .. ACCEPTS: [|z '{}' ]rm) r r6registerr/ pprint_stylesjoinrsformat _style_listclss rL__init_subclass___Style.__init_subclass__s ## ||nF #S%6%6%8||n. /!!#)*((3x@AB'  rNc URSS5RS5nUSR5nURUnUSSVs/sHowRS5PM nnUV V s0sHupU [ U 5_M n n n U"S 00U EUED6$![an[ SU<35UeSnAff=fs snfs sn n f![ an[ S U<35UeSnAff=f) z>Return the instance of the subclass with the given style name.rr,rzUnknown style: Nr=zIncorrect style argument: rm)replacertlowerrxKeyErrorrGr) rz stylenamerJ_list_name_clserrr _args_pairkrN_argss rL__new___Style.__new__ s!!#r*005a  G??5)D E27)<)B((3-)J<-78ZTQQa[ZE8*))&)** Gym<=3 F G=8 E,YM:.* s4VTs4yyVsz c3,# UH nSU-v M g7f)rNrm)rhcls rLrkr+ s#?wC"Hwsrrc3H# UHupURU5v M g7frdljustrhrrs rLrkr/ sL5Kdjjnn5K "rNc3H# UHupURU5v M g7frdrrs rLrkr1 sI7H84 27Hrz )prefix) rxitemsr/strinspect signaturerFmaxrvtextwrapindent)rzrtablecolumncol_lentable_formatstrrow rst_tables rLru_Style.pprint_styles sT,> %(OO$9$9$; = %DG;O;34V44;O))#?w#??II   IILSq75KL L   qr$"#iiIs37HII"$     y99%=P$sAD17D7'+D< z3.10.0z%This method is never used internally.z6No replacement. Please open an issue if you use this.)message alternativec[X R5(d[USUR35eX RU'g)zRegister a new style.z must be a subclass of N) issubclass_BaserGrx)rzrstyles rLrt_Style.register7 s:%++w&=cii[IJ J %rNrmN)r/r0r1r2r3r{r classmethodrrur deprecatedrtr8rmrNrLrprpsg  &+$::. __7L &  &rNrprcUc[R"[XS9$XU=(d URR 5'U$)z=Class decorator that stashes a class in a (style) dictionary.r) functoolspartial_register_styler/r) style_listrzrs rLrrD s9 {  *HH/2t+s||))+, JrNc\rSrSrSr0r\"\5"SS55r\"\5"SS55r\"\5"SS55r \"\5"S S 55r \"\5"S S \ 55r \"\5"S S55r \"\5"SS55r \"\5"SS55r\"\5"SS55r\"\5"SS\55rSrg)BoxStyleiL aj `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(\rSrSrSrSSjrSrSrg)BoxStyle.Squareil z A square box.cXlgzd Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. NrfrIrfs rLr0BoxStyle.Square.__init__p HrNcXPR-nUSU--USU--pCX- X&- p!X-X$-p[R"X4Xr4Xx4X4/5$Nrrfrr~) rIrwrxrprq mutation_sizerfryrzs rL__call__BoxStyle.Square.__call__y sc((*C!AGOVa#g-=6XrxZ&&B8bXx8: :rNrNrlr/r0r1r2r3r0rr8rmrNrLSquarerl s  :rNrc(\rSrSrSrSSjrSrSrg)BoxStyle.Circlei zA circular box.cXlgrrrs rLr0BoxStyle.Circle.__init__ rrNcXPR-nUSU--USU--pCX- X&- p![R"XS- -X$S- -4[X45S- 5$r)rfrcircler)rIrwrxrprqrrfs rLrBoxStyle.Circle.__call__ sb((*C!AGOVa#g-=6Xrx;;QYaZ@ #E 2Q 68 8rNrNrrrmrNrLrr s  8rNrc(\rSrSrSrSSjrSrSrg)BoxStyle.Ellipsei z+ An elliptical box. .. versionadded:: 3.7 cXlgrrrs rLr0BoxStyle.Ellipse.__init__ rrNc\XPR-nUSU--USU--pCX- X&- p!U[R"S5- nU[R"S5- n[5R Xx5R XS- -X$S- -5n U R [R"55$r) rfmathr*rrrStransform_pathrr) rIrwrxrprqrrfrrrSs rLrBoxStyle.Ellipse.__call__ s((*C!AGOVa#g-=6Xrx ! $A1%AJ$$Q*44R!)^571*_FE''(8(8(:; ;rNrNrrrmrNrLrr s   > #C= rNrrlNrrmrNrLRoundr s' /( !rNrc(\rSrSrSrSSjrSrSrg)BoxStyle.Round4i= zA box with rounded edges.NcXlX lg)z Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. rounding_size : float, default: *pad*/2 Rounding of edges. Nrrs rLr0BoxStyle.Round4.__init__A rrNcXPR-nUR(aXPR-nOUS- nUSU--SU-- nUSU--SU-- nX- U-X&- U-p!X-X$-pX4X-X'- 4X- X'- 4X4X-X'-4X-X- 4X4X- X-4X-X-4X4X- X- 4X- X'-4X4X4/n [R[R[R[R[R[R[R[R[R[R[R[R[R[R /n [X5$)Nr~r)rfrrrrCURVE4rJrs rLrBoxStyle.Round4.__call__M si ((*C!!"%7%772XAGOa"f,Ea#g%B.FX]BHrMZ(7BG$rw&82(7BG$rw&82(7BG$rw&82(7BG$rw&82(( B;;;; T[[;; T[[;; T[[;; T[[>> #C= rNrrrrmrNrLRound4r = s' / !rNrc.\rSrSrSrSSjrSrSrSrg) BoxStyle.Sawtoothin zA box with a sawtooth outline.NcXlX lg)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. Nrf tooth_size)rIrfrs rLr0BoxStyle.Sawtooth.__init__r sH(OrNc6XPR-nURcURS-U-nOURU-nUS- nUSU--U- nUSU--U- n[X7- US-- 5S-n [XG- US-- 5S-n X- U-X&- U-p!X-X$-pU/[R"X-X- SU -S-5QXU-XU- /U -SSU -S-QU P[R"X- X-SU -S-5QXU- XU-/U -SSU -S-Qn /X"U- X"U-/U -SSU -S-QUP[R"X(-X- SU -S-5QXU-XU- /U -SSU -S-QU P[R"X- X(-SU -S-5Qn/[ X5QU SUS4P$)NrCrrr)rfrroundrplinspacerF)rIrwrxrprqrrfrhszdsx_ndsy_nryrzr;r<s rL_get_sawtooth_vertices(BoxStyle.Sawtooth._get_sawtooth_vertices~ sA ((*C&!XX]]: !__}< q.CAGOj0Ea#g% 2F5-*q.ABQFE6.:>BCaGEX^RX^Z[[28QY]CCx#X.6 5C[[28QY]CCx#X.6 5C B Cx#X.6 5C[[28QY]CCx#X.6 5C [[28QY]C B2S[12a5"Q%.1 1rNc<URXUXE5n[USS9$)NTr%)rr)rIrwrxrprqr saw_verticess rLrBoxStyle.Sawtooth.__call__ s'66ru7=NL T2 2rNrr) r/r0r1r2r3r0rrr8rmrNrLSawtoothrn s, )$ 2L 3rNr!c\rSrSrSrSrSrg)BoxStyle.Roundtoothi z&A box with a rounded sawtooth outline.c URXX4U5n[R"XfS//5n[R/[R [R /[ U5S- S---[R/-n[Xg5$)Nrrr)rrprrrrrrGrJ)rIrwrxrprqrrrns rLrBoxStyle.Roundtooth.__call__ s66r7<7DFL>>[!"[!"!"!""!H[!7!7!"7!r[!.!.!".!`[!8383"83t[! -X -" -rNrc \rSrSrSr0r"SS5r\"\5"SS\55r\"\5"SS\55r \"\5"S S \55r \"\5"S S \55r \"\5"S S\55r Sr g)ConnectionStylei a `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. c0\rSrSrSrSrSrSSjrSrg) ConnectionStyle._Basei aS 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^U4Sj$)zS Return a predicate function testing whether a point *xy* is contained in *patch*. cH>TR[USUSS95S$)Nrr)rfrg)ryr)r,rs rL1ConnectionStyle._Base._in_patch.. s(enn"Q%2a513346rNrm)rIrs `rL _in_patchConnectionStyle._Base._in_patch s 6 6rNcU(a[X5upAU(a[X5upU$U$![a N%f=f![a U$f=f)z 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. )rrG)rIrTin_startin_stopr8s rL_clipConnectionStyle._Base._clip se.t>GA.t=GDK4K" "Ks / ? << A  A Nc dURX5nURUU(aURU5OSU(aURU5OS5nURUU(a[/URSQUP76OSU(a [/URSQUP765nU$S5nU$)zf Call the *connect* method to create a path between *posA* and *posB*; then clip and shrink the path. Nrr)connectr4r/rro)rIposAposBshrinkAshrinkBpatchApatchBrTs rLrConnectionStyle._Base.__call__ s <<+D::*0v&d*0v&dD ::=D 9t}}Q/99$>E :t}}R0:':D KLPD KrNrm)r~r~NN) r/r0r1r2r3r/r4rr8rmrNrLrr* s  6 *BF rNrc(\rSrSrSrSSjrSrSrg)ConnectionStyle.Arc3i u 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. cXlg)z= Parameters ---------- rad : float Curvature of the curve. Nrad)rIrCs rLr0ConnectionStyle.Arc3.__init__& rrNcUup4UupVX5-S- XF-S- pXS- Xd- pURn X{U --XU -- pX44X4XV4/n[R[R[R/n[X5$)Nr~)rCrrrr)rIr8r9ryrzx2y2x12y12rnrofrcyrorns rLr7ConnectionStyle.Arc3.connect/ sFBFB2~2~WbgAr6\3R<"H[[[[[["E( (rNrBNrr/r0r1r2r3r0r7r8rmrNrLArc3r@ s   )rNrNc(\rSrSrSrSSjrSrSrg)ConnectionStyle.Angle3iB u 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. cXlX lg)zp Parameters ---------- angleA : float Starting angle of the path. angleB : float Ending angle of the path. NangleAangleB)rIrSrTs rLr0ConnectionStyle.Angle3.__init__K s!K KrNc VUup4UupV[R"[R"UR55n[R"[R"UR55n[R"[R"UR 55n [R"[R"UR 55n [ X4XxXVX5upX44X4XV4/n [R[R[R/n[X5$rd) rrJradiansrSrKrTrrrrr)rIr8r9ryrzrFrGcosAsinAcosBsinBrrKrorns rLr7ConnectionStyle.Angle3.connectY sFBFB88DLL56D88DLL56D88DLL56D88DLL56D%bd&(d:FB2(RH5H[[$++t{{;E( (rNrRN)ZrrMrmrNrLAngle3rPB s  ! )rNr^c(\rSrSrSrSSjrSrSrg)ConnectionStyle.Angleij u- 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(XlX lX0lg)z Parameters ---------- angleA : float Starting angle of the path. angleB : float Ending angle of the path. rad : float Rounding radius of the edge. NrSrTrC)rIrSrTrCs rLr0ConnectionStyle.Angle.__init__t s!K KHrNc Uup4UupV[R"[R"UR55n[R"[R"UR55n[R"[R"UR 55n [R"[R"UR 55n [ X4XxXVX5upX44/n [R/nURS:Xa2U RX45 UR[R5 OX;- XL- nn[R"UU5nURU- nX[- Xl- nn[R"UU5nURU- nU RXU--U UU--4X4U UU--U UU--4/5 UR[R[R[R/5 U RXV45 UR[R5 [X5$)Nri)rrJrWrSrKrTrrrrrCrrrprzextendr)rIr8r9ryrzrFrGrXrYrZr[rrKrorndx1dy1d1f1dx2dy2d2f2s rLr7ConnectionStyle.Angle.connect sFBFB88DLL56D88DLL56D88DLL56D88DLL56D%bd&(d:FBzH[[MExx2~) T[[)7BGSXXc3'XX]7BGSXXc3'XX]"Rx-cBh!?"$"$sRx-cBh!?!AB dkk4;; DE OORH % LL %( (rNrbN)r]rrirMrmrNrLAngler`j s  &! )rNroc(\rSrSrSrSSjrSrSrg)ConnectionStyle.Arci u 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@XlX lX0lX@lXPlg)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. NrSrTarmAarmBrC)rIrSrTrtrurCs rLr0ConnectionStyle.Arc.__init__ s(!K KIIHrNcUup4UupVX44/n/n[R/n UR(a[R"[R "UR 55n [R"[R "UR 55n URUR- n URXIIX rH}=>yyyxx T[[ 9:xx T[[ 9:!#ii$&6!6YY=M8M$R[FB#b[&2+Br'BG+2BNNBB);$;$&B);$;$=>OOG,LL$++"&++"&++"/0&b\FB#b[&2+Br'BG+2BMR",b1r6B;.>?"F+- Bb"r'B2gR'B.TXX]R%7 7 "TXX]R%7 7 9:( dkk"kk"kk+, OORH % LL %( (rNrs)rrNNrirMrmrNrLrrq s  69 )rNrc(\rSrSrSrSSjrSrSrg)ConnectionStyle.Bari z 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*. Nc4XlX lX0lX@lg)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)rtrufractionrd)rIrtrurrds rLr0ConnectionStyle.Bar.__init__ s"II$MJrNcTUup4U=upVupx[R"X- Xs- 5n Xs- X- pX-X--S-n X- X- pURURnnURb[ R "UR5nU U- nU [R"U5-nU [R"U5-nUU[R"U5--UU[R"U5--pUU- nXs- X- pX-X--S-nU U- U U- p[UU5nURU -U-nUUU--UUU -- nnUUU--UUU -- nnX44UU4UU4XV4/n[R[R[R[R/n[UU5$)NrC)ratan2rtrurdrprIrKrJrrrrrr)rIr8r9ryrzx20y20rFrGr?rnror~ddxddyrtrutheta0dthetadldLdd2armrJcx1cy1cx2cy2rorns rLr7ConnectionStyle.Bar.connect) sFB $ $HCvrZZ1FWbg'BG#*BwDII$Dzz%DJJ/&$((6**$((6**b488F#333R"txx?O:O5OBby"'Bw(R/8R#XSdD/C "S(AAG|R!c'\CAG|R!c'\Cc c  $H[[[[[[[["E %( (rN)rdrtrur)ririrlNrMrmrNrLBarr s  ,' )rNrrmN)r/r0r1r2r3rxrrrNr^rorrr8rmrNrLr(r( s"HK99v[!#)u#)"#)J[!%)%)"%)N[!=)=)"=)~[!])e])"])~[!E)eE)"E)rNr(cNX- X- peXEU-Xf--S-- nXU-- XU-- pX4$)zo Return the point on the line connecting (*x0*, *y0*) -- (*x1*, *y1*) whose distance from (*x0*, *y0*) is *d*. rCrm) rwrxryrzryrnroffrFrGs rL_point_along_a_linerS sA Wbg 2gB & &B r'\2R< 6MrNc\rSrSrSr0r"SS5r"SS\5r\"\SS9"S S \55r \"\S S9"S S \55r \"\SS9"SS\55r \"\SS9"SS\55r \"\SS9"SS\55r \"\SS9"SS\55r\"\SS9"SS\55r\"\SS9"SS\55r\"\S S9"S!S"\55r\"\S#S9"S$S%\55r\"\S&S9"S'S(\55r\"\S)S9"S*S+\55r\"\S,S9"S-S.\55r\"\5"S/S0\55r\"\5"S1S2\55r\"\5"S3S4\55rS5rg6)7 ArrowStylei_ a `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:\rSrSrSr\S5rSrSSjrSr g) ArrowStyle._Basei a 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[UR55n[U5S:wd4USS[R:wdUSS[R :wa [ S5e/USSQUSSQ$)u  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. rrrz,'path' is not a valid quadratic Bezier curve)list iter_segmentsrGrrrrrG)rTsegmentss rLensure_quadratic_bezier(ArrowStyle._Base.ensure_quadratic_bezier s|D..01HH "hqk!n &CQKNdkk1 BDD5Xa[^5hqk!n5 5rNc[S5e)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#)rIrTrr%s rL transmuteArrowStyle._Base.transmute s&&=> >rNcXUbURSU/- n[XQR5nURUUU5upx[R "U5(a8UV s/sH(n [U RSU/-U R5PM* n n X4$Xx4$URXU5$s sn f)zg The __call__ method is a thin wrapper around the transmute method and takes care of the aspect ratio. r)rorrnrrpiterable) rIrTrr% aspect_ratioro path_shrunk path_mutatedfillabler path_lists rLrArrowStyle._Base.__call__ s'==A|+<<"8ZZ8 )- 8E8A*C& ;;x((+7!8*6Q"&ajjA|3D&Dagg!N*6!8$..'11~~d9EE !8s/B'rmN)rl) r/r0r1r2r3 staticmethodrrrr8rmrNrLrr s+   6  6 ?#% FrNrcT^\rSrSrSrSrS=rrS U4SjjrSr Sr Sr S r U=r $) ArrowStyle._Curvei a  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. -Fc l>XsUlUlX4sUlUlXVsUlUlXxsUlUlXsUlUl SUl SUl SUl SUl SUR;a [S5eURR!SS5upU S:XaSUl SUl O0U S:XaSUl SUl SUlOU S;aSUl SUl U S :XaSUl SUl O0U S :XaSUl SUl SUlOU S ;aSUl SUl [&T U]Q5 g ) 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. Frz-arrow must have the '-' between the two headsrz|>)[rrN)rrwidthAwidthBlengthAlengthBrSrTscaleAscaleB_beginarrow_head_beginarrow_bracket_endarrow_head_endarrow_bracketarrowrGrt fillbeginfillendr/r0)rIrrrrrrrSrTrr beginarrowendarrowrKs rLr0ArrowStyle._Curve.__init__ sM*1< -D do'- $DK)0 &DL$,'- $DK'- $DK$)D !',D $"'D %*D "$**$ "122$(::#3#3C#; JS (,%+0(t#(,%+0(!%z)(-%+/(3&*#).&T!&*#).&# Z'&+#)-& G  rNc X- X$- p[R"X5n SU-U- n U S:XaSn X-U - n X-U - nX- U-n X- U-n Xi-Xz--U*U -Xj--nnXi-Xz-- Xy-Xj--nnX=-U-XN-U-4X=-XN-4X=-U-XN-U-4/n[R[R[R/nUUX4$)z 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. rCrr)rprzrrrr)rIrwrxryrz head_distcos_tsin_tr%rnro cp_distance pad_projectedrrrfrgrjrkvertices_arrow codes_arrows rL_get_arrow_wedge"ArrowStyle._Curve._get_arrow_wedge" sWbg((2*K )^e3Ma  ${2C${2C!I-B!I-BzEJ. ej0HCzEJ. UZ0GC!x#~rx#~>!x2!x#~rx#~>@N ;;;;;;(K";8 8rNcx[X4X5upSSKJn U "XXU5up4pXh-Xi-pX=-XN-4X44X4X-X-4/n[R[R [R [R /nU(a6[ R"5RXU5nURU5nUU4$)Nr)get_normal_points) rmatplotlib.bezierrrrrrrrrotate_deg_aroundr)rIrwrxryrzrprrdrrrrFrGrnrorrrSs rL _get_bracketArrowStyle._Curve._get_bracketL s'rr6LE <.ruUKNBB^V^!w0!h!h!w02N ;;;;;;;;(K "++-??N!&!@!;. .rNc UR(dUR(a;URU-nURU-n[R "XE5nXF- XV- pUR cUO UR n URcUO URn URSupURSupUR=(a X4X4:gnU(aURXXWWWU5O//SS4unnnnURSunnURSunnUR=(a UU4UU4:gnU(aURUUUUWWWU5O//SS4unnnn[[R"U U-U U-4/URSSUU-UU-4//5UR5/nS/nU(aUR(aCUR[/UQSP/UQ[RP55 URS5 OUR[UU55 URS5 OUR (aURSupURSupUR#XXUR$U -UR&U -UR(5unnUR[UU55 URS5 U(aUR*(aFURS5 UR[/UQSP/UQ[RP55 UU4$URS5 UR[UU55 UU4$UR,(aURSupURSupUR#XXUR.U -UR0U -UR25unnUR[UU55 URS5 UU4$)NrrrrFrT)rrrrrprzrrrorrrrnrrrJrrrrrSrrrrrT)rIrTrr%rrrrrrrrwrxryrzhas_begin_arrow verticesAcodesAddxAddyArFrGx3y3 has_end_arrow verticesBcodesBddxBddyBpathsfillss rLrArrowStyle._Curve.transmutef s$$(;(;"..> !__}< HH[= *6 8Nu&*kk&9]t{{F&*kk&9]t{{F]]1%FB]]1%FB#33LRH8LO#%%bb&/yJ"a^ *IvtT]]2&FB]]2&FB!//HRHR4HM!%%b"b"&/yJ"a^ *IvtT"..BIrDy+A*B*.--"*=,.IrDy+A*B*DE**&'EGE>>LL1y1&13LV3LT^^3LMOLL&LLi!89LL'))q)q)$($5$5bb6:kkF6J6:llV6K6:kk%C! 6  T)V45 U#<<LL&LL1y1&13LV3LT^^3LMO %< LL'LLi!89%< ''r*r*$($5$5bb6:kkF6J6:llV6K6:kk%C! 6  T)V45 U#%< rN)rrrrrSrTrrrrrrrrrr) 皙?皙?rlrlrrrrNN)r/r0r1r2r3rrrr0rrrr8r9r:s@rL_Curver s? ## GLNJN < |( 9T /4S S rNrrrc,^\rSrSrSrU4SjrSrU=r$)ArrowStyle.Curvei z&A simple curve without any arrow head.c">[TU]SSS9 g)Nrrj)rrr)rIrKs rLr0ArrowStyle.Curve.__init__ s G   ;rNrm)r/r0r1r2r3r0r8r9r:s@rLCurver s4 < c\rSrSrSrSrSrg)ArrowStyle.CurveBi z&An arrow with a head at its end point.rrmNrrmrNrLCurveBr s 4rNr<->c\rSrSrSrSrSrg)ArrowStyle.CurveABi z8An arrow with heads both at the start and the end point.rrmNrrmrNrLCurveABr s FrNr<|-c\rSrSrSrSrSrg)ArrowStyle.CurveFilledAi z0An arrow with filled triangle head at the start.rrmNrrmrNrL CurveFilledAr s >rNr-|>c\rSrSrSrSrSrg)ArrowStyle.CurveFilledBi z.An arrow with filled triangle head at the end.rrmNrrmrNrL CurveFilledBr s <rNr<|-|>c\rSrSrSrSrSrg)ArrowStyle.CurveFilledABi z1An arrow with filled triangle heads at both ends.rrmNrrmrNrL CurveFilledABr s ?rNr]-c4^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.BracketAi z5An arrow with an outward square bracket at its start.rc">[TU]XUS9 ga 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. )rrrSNrrIrrrSrKs rLr0ArrowStyle.BracketA.__init__  G FF  KrNrmrlrr r/r0r1r2r3rr0r8r9r:s@rLBracketAr  sC L LrNr-[c4^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.BracketBi z3An arrow with an outward square bracket at its end.rc">[TU]XUS9 ga 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. )rrrTNrrIrrrTrKs rLr0ArrowStyle.BracketB.__init__ rrNrmrrr:s@rLBracketBr sA L LrNr]-[c8^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.BracketABiz3An arrow with outward square brackets at both ends.rc &>[TU]XUXEUS9 g)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. rrrSrrrTNr)rIrrrSrrrTrKs rLr0ArrowStyle.BracketAB.__init__ s! G FF$*F  LrNrm)rlrrrlrrrr:s@rL BracketABrsA5645 L LrNr!|-|c4^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.BarABiz/An arrow with vertical bars ``|`` at both ends.r"c *>[TU]USUUSUS9 g)z 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. rrNr)rIrrSrrTrKs rLr0ArrowStyle.BarAB.__init__#s% G FAf$*Af  FrNrm)rlrrlrrr:s@rLBarABr$s= F FrNr']->c4^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.BracketCurvei0zM An arrow with an outward square bracket at its start and a head at the end. r(c">[TU]XUS9 gr rr s rLr0 ArrowStyle.BracketCurve.__init__8rrNrmrlrNrr:s@rL BracketCurver*0  L LrNr.<-[c4^\rSrSrSrSrSU4SjjrSrU=r$)ArrowStyle.CurveBracketiFzM An arrow with an outward square bracket at its end and a head at the start. r0c">[TU]XUS9 grrrs rLr0 ArrowStyle.CurveBracket.__init__NrrNrmr-rr:s@rL CurveBracketr2Fr/rNr5c6^\rSrSrSrSU4SjjrSrSrU=r$)ArrowStyle.Simplei\u:A simple arrow. Only works with a quadratic Bézier curve.cL>XUsUlUlUl[TU]5 g)z 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. Nrr tail_widthr/r0rIrrr:rKs rLr0ArrowStyle.Simple.__init__`' ?D dot G  rNcURU5upEpgpURU-n [XU 5n XE4Xg4X4/n [X5upUR U-n[UUS- SS9unnU Gb(URU-n[U US- 5unn[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4/ nOz[RUS4[RUS4[RUS4[RUS4[RUS4[RUS4/n[UVVs/sHunnUPM snnUVVs/sHunnUPM snn5nUS4$![a, [ XXgU 5upESXH--SXY--nnXE4UU4X4/nSn GN7f=fs snnfs snnf)NrCr~wmrrrT)rrrrrrrrr:rrrrrrrJ)rIrTrr%rwrxryrzrFrGrin_f arrow_path arrow_outarrow_inx1ny1nr head_left head_rightr: tail_left tail_right patch_pathrrs rLrArrowStyle.Simple.transmuteqs%)%A%A$%G "BBB**]:K 5D(RHrh7J !=jO$ =8J$78BRB%P !Iz$!__}< (5i6@2o)G% : ${{JqM:#{{JqM:#{{JqM:#{{JqM:#{{JqM:#{{JqM:#{{IaL9#{{IaL9#{{IaL9#{{IaL9#{{IaL9#{{JqM:#~~z!}=   ${{JqM:#{{JqM:#{{JqM:#{{IaL9#{{IaL9#~~y|<  z2ztq!z2:4N:41aQ:4NOD: Y0 !-RR[I"'?C27OSHsCj2(;  !T34Ns I J .J 2I?>I?rrr:)rCrCr r/r0r1r2r3r0rr8r9r:s@rLSimpler7\sH "8 8 rNrOc6^\rSrSrSrSU4SjjrSrSrU=r$)ArrowStyle.Fancyiu9A fancy arrow. Only works with a quadratic Bézier curve.cL>XUsUlUlUl[TU]5 g)z 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. Nr9r;s rLr0ArrowStyle.Fancy.__init__r=rNcURU5upEpgpURU-n XE4Xg4X4/n [XU 5n [X5upUn[XU S-5n [X5upU nUR U-n[UUS- SS9unnURU-n[UUS-SSSS9unn[XEUS-5n [X5upUS nUUnn[RU4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RUS 4[RU4[RU4/n[UVVs/sHunnUPM snnUVVs/sHunnUPM snn5nUS 4$![a, [ XXgU 5upESXH--SXY--nnXE4UU4X4/n U nGNf=fs snnfs snnf)NrCrkr~g333333?r?rlrl)w1r@w2rrrrT)rrrrrrrrr:rrrrrrJ)rIrTrr%rwrxryrzrFrGrrBrApath_outpath_in path_headrErF path_tailrhead_lhead_rr:rIrJ tail_startrHrGrKrrs rLrArrowStyle.Fancy.transmutes%)%A%A$%G "BBB**]:K(RHrh7J!5D $$M%&!$ !r)9:D I!" H I=8J01;b468NFF =8J$7 8BR;=##%O !Iz !b9D I!" G J$*F J;; 3;; 1 6;; 1 6;; 1 6;; 1 6;; 1 6;; 1 6;; ! 5;; ! 5;; ! 5;; ! 5;; ! 5;; 3>>:6Jz2ztq!z2:4N:41aQ:4NOD: i0 '-RR[I"'?C27OS!hc RH= &  'd34Ns H)I I 2IIrM)rrrrNr:s@rLFancyrQsG "A A rNr_c6^\rSrSrSrSU4SjjrSrSrU=r$)ArrowStyle.Wedgeiu 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:>XlX l[TU] 5 g)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)r: shrink_factorr/r0)rIr:rcrKs rLr0ArrowStyle.Wedge.__init__ s)O!.  G  rNc 2URU5upEpgpXE4Xg4X4/n [U URU-S- URS9up[R U S4[R U S4[R U S4[RU S4[R U S4[R U S4[RU S4/n [ U VVs/sHupUPM snnU VVs/sHupUPM snn5nUS4$s snnfs snnf)Nr~r?rrrT) rrr:rcrrrrrrJ)rIrTrr%rwrxryrzrFrGrBb_plusb_minusrKrrs rLrArrowStyle.Wedge.transmutes%)%A%A$%G "BBB(RHrh7J1$.$(OOm$Cb$H'+'9'9;OF  ;;q 2;;q 2;;q 2;; 3;; 3;; 3>>71:6 Jz2ztqz2:4N:41Q:4NOD: 34Ns D 3D )rcr:)rlrCrNr:s@rLr<ras   rNr<rmN)r/r0r1r2r3rxrrrrrrrrrrrrr!r'r.r5rOr_r<r8rmrNrLrr_ sa,\KEFEFNa a F[s+<<,<[t,-[t,-[u-&.[u-v.[u-v.[w/0[t,L6L-L$[t,L6L-L$[u-LFL.L*[u-FF.F"[u-LvL.L*[u-LvL.L*[!LL"L\[!UU"Un[!))")rNrc^\rSrSrSrSrSr\RSSSS.U4Sjjj5r \RSSj5r S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrU=r$)FancyBboxPatchi0a7 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`. TcURRS-nXRURURUR 4-$)Nz((%g, %g), width=%g, height=%g))rKr/rvrwrbrcrs rLr?FancyBboxPatch.__str__<s9 NN # #&G GGGTWWdkk4<<@@@rNr)mutation_scalemutation_aspectc >[TU]"S0UD6 UuUlUlX lX0lUR U5 XPlX`lSUl g)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 TNrm) r/r0rvrwrbrc set_boxstyle_mutation_scale_mutation_aspectr) rIr,rprqboxstylermrnrJrKs rLr0FancyBboxPatch.__init__@sOV "6"   (#- / rNc Uc[R5$[U[5(a [U40UD6OUUlSUlg)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)rrurZr_bbox_transmuterr)rIrsrJs rLrpFancyBboxPatch.set_boxstyletsLB  ))+ +(C(( X ( (.6  rNcUR$)zReturn the boxstyle object.)rvrs rL get_boxstyleFancyBboxPatch.get_boxstylerrNcXlSUlgz> Set the mutation scale. Parameters ---------- scale : float TNrqrrIrs rLset_mutation_scale!FancyBboxPatch.set_mutation_scale % rNcUR$)zReturn the mutation scale.rqrs rLget_mutation_scale!FancyBboxPatch.get_mutation_scales###rNcXlSUlgzR Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : float TNrrrrIaspects rLset_mutation_aspect"FancyBboxPatch.set_mutation_aspect!' rNc8URb UR$S$z-Return the aspect ratio of the bbox mutation.rrrrs rLget_mutation_aspect"FancyBboxPatch.get_mutation_aspect#)-)>)>)J%%  rNcUR5nUR5nU"URURU- URUR U- UR 55n[URSU/-UR5$)z)Return the mutated path of the rectangle.r) ryrrvrwrbrcrrrorn)rIrsm_aspectrTs rLrQFancyBboxPatch.get_pathsw$$&++-8!3 T\\H%<//13DMMQM14::>>rNcUR$)z'Return the left coord of the rectangle.)rvrs rLrFancyBboxPatch.get_x wwrNcUR$)z)Return the bottom coord of the rectangle.)rwrs rLrFancyBboxPatch.get_yrrNcUR$rrrs rLrFancyBboxPatch.get_widthrrNcUR$rrrs rLrFancyBboxPatch.get_heightrrNcXlSUlg)zG Set the left coord of the rectangle. Parameters ---------- x : float TN)rvrrs rLrFancyBboxPatch.set_x rNcXlSUlg)zI Set the bottom coord of the rectangle. Parameters ---------- y : float TN)rwrrs rLrFancyBboxPatch.set_yrrNcXlSUlg)z; Set the rectangle width. Parameters ---------- w : float TNrrs rLrFancyBboxPatch.set_widths  rNcXlSUlg)z< Set the rectangle height. Parameters ---------- h : float TNrrs rLrFancyBboxPatch.set_heights  rNc|[U5S:Xa USup#pEOUup#pEX lX0lX@lXPlSUlg)a9 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)rGrvrwrbrcrrs rLrFancyBboxPatch.set_boundssB t9>aJA!QJA!   rNc[RRURURUR UR 5$r)rr from_boundsrvrwrbrcrs rLrFancyBboxPatch.get_bbox!s4**477DGG+/;; F FrN)rvrcrrrqrbrvrwr)rrd)r/r0r1r2r3rr?r r6r0rpryrrrrrQrrrrrrrrrrr8r9r:s@rLrjrj0sMA1 !1111f%%N% $  ?    4FFrNrjc ^\rSrSrSrSrSr\RSSSSSSSSS S S . U4S jjj5r S r S r Sr \RSSj5r Sr\RSSj5rSrSrSrSrSrSrSrSrSrU=r$)FancyArrowPatchi'a 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 URb;URuupup4[U5RSUSSUSSUSSUSS3 $[U5RSURS3$)Nz((gz, z)->(z))(r>) _posA_posBtyper/_path_original)rIryrzrFrGs rLr?FancyArrowPatch.__str__5s{ ?? &!% HRhr4j))*"RF"RF$r!fBr!fBO O4j))*!D,?,?+@B BrNNsimplearc3rr) rT arrowstyleconnectionstyler<r=r:r;rmrnc  >U RS[R5 U RS[R5 [T U]"S0U D6 Ub%Ub"UcX/UlUcSnURU5 OUcUc UbSUlO [S5eX`l Xpl Xl Xl X0l URU5 XlXlSUlg)a& There are two ways for defining an arrow: - If *posA* and *posB* are given, a path connecting two points is created according to *connectionstyle*. The path will be clipped with *patchA* and *patchB* and further shrunken by *shrinkA* and *shrinkB*. An arrow is drawn along this resulting path using the *arrowstyle* parameter. - Alternatively if *path* is provided, an arrow is drawn along this path and *patchA*, *patchB*, *shrinkA*, and *shrinkB* are ignored. Parameters ---------- posA, posB : (float, float), default: None (x, y) coordinates of arrow tail and arrow head respectively. path : `~matplotlib.path.Path`, default: None If provided, an arrow is drawn along this path and *patchA*, *patchB*, *shrinkA*, and *shrinkB* are ignored. arrowstyle : str or `.ArrowStyle`, default: 'simple' The `.ArrowStyle` with which the fancy arrow is drawn. If a string, it should be one of the available arrowstyle names, with optional comma-separated attributes. The optional attributes are meant to be scaled with the *mutation_scale*. The following arrow styles are available: %(ArrowStyle:table)s connectionstyle : str or `.ConnectionStyle` or None, optional, default: 'arc3' The `.ConnectionStyle` with which *posA* and *posB* are connected. If a string, it should be one of the available connectionstyle names, with optional comma-separated attributes. The following connection styles are available: %(ConnectionStyle:table)s patchA, patchB : `~matplotlib.patches.Patch`, default: None Head and tail patches, respectively. shrinkA, shrinkB : float, default: 2 Shrink amount, in points, of the tail and head of the arrow respectively. 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+Nrz.Either posA and posB, or path need to providedrlrm)r rrrr/r0rset_connectionstylerGr<r=r:r;rset_arrowstylerqrr_dpi_cor)rIr8r9rTrrr<r=r:r;rmrnrJrKs rLr0FancyArrowPatch.__init__<sL +y7*hnn5 "6"   0T\#lDO&"(  $ $_ 5 \dlt/?"DOMN N    " J'- / rNcVUbXRS'UbX RS'SUlg)z 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)rr)rIr8r9s rL set_positionsFancyArrowPatch.set_positionss/  !%OOA   !%OOA  rNcXlSUlg)zF Set the tail patch. Parameters ---------- patchA : `.patches.Patch` TN)r<r)rIr<s rL set_patchAFancyArrowPatch.set_patchA  rNcXlSUlg)zF Set the head patch. Parameters ---------- patchB : `.patches.Patch` TN)r=r)rIr=s rL set_patchBFancyArrowPatch.set_patchBrrNc Uc[R5$[U[5(a [U40UD6OUUlSUlg)a 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)r(rurZr _connectorr)rIrrJs rLr#FancyArrowPatch.set_connectionstylesKB  ""002 2/3// O 6v 65D  rNcUR$)z"Return the `ConnectionStyle` used.)rrs rLget_connectionstyle#FancyArrowPatch.get_connectionstylerrNc Uc[R5$[U[5(a [U40UD6OUUlSUlg)aq 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)rrurZr_arrow_transmuterr)rIrrJs rLrFancyArrowPatch.set_arrowstylesLB  ++- -*c** z ,V ,0:  rNcUR$)zReturn the arrowstyle object.)rrs rLget_arrowstyleFancyArrowPatch.get_arrowstyles%%%rNcXlSUlgr|r}r~s rLr"FancyArrowPatch.set_mutation_scalerrNcUR$)z4 Return the mutation scale. Returns ------- scalar rrs rLr"FancyArrowPatch.get_mutation_scale*s###rNcXlSUlgrrrs rLr#FancyArrowPatch.set_mutation_aspect4rrNc8URb UR$S$rrrs rLr#FancyArrowPatch.get_mutation_aspect?rrNcUR5up[R"U5(a[R"U6nUR 5R 5RU5$)z5Return the path of the arrow in the data coordinates.)_get_path_in_displaycoordrprrmake_compound_pathrPinvertedr)rIrrs rLrQFancyArrowPatch.get_pathDsV88: ;;x ++U3E!!#,,.==eDDrNc lURnURbURURS5nURURS5nUR5R X#45up#UR 5"X#UR URURU-URU-S9nO)UR5RUR5nUR5"UUR5U-UR5U-UR55upEXE4$)A patch that connects two points (possibly in different Axes).c|SURSURSURSURS4-$)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)xy1xy2rs rLr?ConnectionPatch.__str__s=4 TXXa[$((1+txx{CD DrNNrrrig$@F) axesAaxesBrrr<r=r:r;rmrnrhc  >UcUnXlX lX0lX@lXPlX`l[ TU]"SSSUUXXU UUS. UD6 SUlg)a Connect point *xyA* in *coordsA* with point *xyB* in *coordsB*. Valid keys are =============== ====================================================== Key Description =============== ====================================================== arrowstyle the arrow style connectionstyle the connection style relpos default is (0.5, 0.5) patchA default is bounding box of the text patchB default is None shrinkA default is 2 points shrinkB default is 2 points mutation_scale default is text size (in points) mutation_aspect default is 1. ? any key for `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 `. 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) Nrr) r8r9rrr<r=r:r;rmrnrhrm) rrcoords1coords2rrr/r0_annotation_clip)rIxyAxyBcoordsAcoordsBrrrrr<r=r:r;rmrnrhrJrKs rLr0ConnectionPatch.__init__smb ?G      #f6$.)8 &!((6)8!( #" #!%rNc UnUc URn[R"US5n[R"US5nURSS9nUS;a5XWR-S- nXgR-S- nUR SS5nO8US :Xa UR nO%US :Xa URnOUS :Xa URnUS :Xa|URn[R"URRU55n[R"URRU55nURXV45$US :XaqUR S :XaUR#UR$S 5$UR#UR$UR 5XRSS9R-S- -$US:XaRXVpU [R&"U 5-nU [R("U 5-nURnURXV45$US:XadURSS9R*n US:aU R,U-OU R.U-nUS:aU R0U-OU R2U-nXV4$US:XadURSS9R4n US:aU R,U-OU R.U-nUS:aU R0U-OU R2U-nXV4$US:XaWUR4n US:aU R,U-OU R.U-nUS:aU R0U-OU R2U-nXV4$[7U[8R:5(aURU5$[=US35e)z,Calculate the pixel position of given point.rrFr?)z figure pointsz axes pointsHrpixelszfigure fractionzsubfigure fractionz axes fractiondataz offset pointsTpolarz figure pixelszsubfigure pixelsz axes pixelsz) is not a valid coordinate transformation)rBrprrCdpir transFiguretransSubfigure transAxes transDatar _to_unmasked_float_arrayxaxis convert_unitsyaxisrxycoords_get_xyr,rJrKfigbboxrwryrxrzrrZr TransformrG) rIr,rrBs0rfrgfigrSrUr>bbs rLr ConnectionPatch._get_xys  <99D HHRUO HHRUOoo5o) 0 0GG b AGG b A (H-A # #A & &""A / !A ;NNE..tzz/G/G/JKA..tzz/G/G/JKA??A6* * / !}}/||DGGV44 TWWdmm4D1555:; <'\1BFF5M!ABFF5M!ANNE??A6* * / !e,44B!V A!V A4K $ $e,11B!V A!V A4K - B!V A!V A4K :// 0 0;;r? "t#LMN NrNcXlSUlg)aQ 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)rrrs rLset_annotation_clip#ConnectionPatch.set_annotation_clip)s!" rNcUR$)z` Return the clipping behavior. See `.set_annotation_clip` for the meaning of the return value. )rrs rLget_annotation_clip#ConnectionPatch.get_annotation_clip9s $$$rNc URnURURURUR5nURUR UR UR5nUR5"X#URURURU-URU-S9nUR5"UUR5U-UR5U-UR!55upEXE4$)rr)rr rrrrrrrr<r=r:r;rrr]r)rIrr8r9rTrs rLr)ConnectionPatch._get_path_in_displaycoordAs--||DHHdllDJJ?||DHHdllDJJ?'') ;;t{{LL7*DLL74J  ,,.   # # % /    7 *  $ $ &   ~rNcDUR5nU(dUc~URS:XanURURURUR5nURc UR nO URnUR U5(dgU(dUc~URS:XanURURURUR5nURc UR nO URnUR U5(dgg)z/Check whether the annotation needs to be drawn.rFT) rrr rrrBrerrr)rIrrxy_pixelrBs rL _check_xyConnectionPatch._check_xySs  $ $ & t||v5||DHHdllDJJGHzz!yyzz&&x00 t||v5||DHHdllDJJGHzz!yyzz&&x00rNc|>UR5(aURU5(dg[TU] U5 grd)rrr/rr[s rLrConnectionPatch.drawls/!!)A)A   XrN)rrrrrrrrrd)r/r0r1r2r3r?r r6r0r rrrrrr8r9r:s@rLrr|szHDe%4!' #!%e%e%e%N<O| %$2rNrrQ)rNrd)Mr3rrrnumbersrrrtypesr collectionsrmatplotlib.transformsrnumpyrp matplotlibr4rr r r r r rrrrrbezierrrrrrrrrrTr_enumsrrr6define_aliasesrr'r<r^rrrr"r<rgrrtrvgetdocr0 splitlinesrrrrrrlrnrprrr(rrrjrrrmrNrLr*s !"*,,,AAA' 6 r FMMr r j9U9xV"V"r.!U.!b8j jZ`Ee`EFSESnPEPfffR yy  ++ , 2>>@DFG DND2q'eq'hxexv'.W'.Ts7's7l. S&S&l$ i-vi-i-X  V)fV)V)r  M M M `tFUtFnR/eR/j sosrN