a Sic&| @sdZddlZddlZddlZddlmZddlZddlmZddl Z ddl Z ddl mZmZmZmZmZmZmZmZddlmZmZmZmZmZmZmZm Z ddl!m"Z"dd l#m$Z$m%Z%ej&e'd gd gd gd gdgdGdddej(Z)Gddde)Z*Gddde)Z+Gddde)Z,Gddde)Z-Gddde-Z.Gddde)Z/Gddde)Z0Gd d!d!e)Z1Gd"d#d#e/Z2ej&j3d$4e5e2j6pd%7d&dd'Gd(d)d)e,Z8Gd*d+d+e)Z9Gd,d-d-e)Z:Gd.d/d/e9Z;Gd0d1d1e9ZGd8d9d9Z?dMdd:d;d<Z@ejAGd=d>d>e?ZBejAGd?d@d@e?ZCdAdBZDejAGdCdDdDe?ZEGdEdFdFe)ZFGdGdHdHe)ZGGdIdJdJeGZHdS)Nz> Patches are `.Artist`\s with a face color and an edge color. N)Number) namedtuple)_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 seZdZdZdZdZejddddUfd d Zd d Z d dZ dVddZ dWddZ dXddZ fddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zfd5d6Zd7d8Zd9d:Z d;d<Z!d=d>Z"e#e"e!Z$e%j&d?d@Z'dAdBZ(e%j&dCdDZ)dEdFZ*dGdHZ+dIdJZ,dKdLZ-e.j/dMdNZ0dOdPZ1dYdQdRZ2dSdTZ3Z4S)ZPatchz 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. rF3.6rnameNTc  st|durd}| dur$tj} | dur2tj} ttj d|_ d|_ |durx|dusb|durlt d||n||||d|_d|_d|_|||||||||||| || t| r|| dS)zW The following kwarg properties are supported %(Patch:kwdoc)s Nsolidz hatch.colorTzQSetting the 'color' property will override the edgecolor or facecolor properties.r)rN)super__init__rbuttrmiterrto_rgbamplrcParams _hatch_color_fillr warn_external set_color set_edgecolor set_facecolor _linewidth_unscaled_dash_pattern _dash_patternset_fill set_linestyle set_linewidthset_antialiased set_hatch set_capstyle set_joinstylelen_internal_update) selfrrcolorr!r rr fillcapstyle joinstylekwargs __class__N/var/www/html/django/DPS/env/lib/python3.9/site-packages/matplotlib/patches.pyr(.s:           zPatch.__init__cCs.|}|}||}t|r*|dSgS)z Return a copy of the vertices used in this patch. If the patch contains Bezier curves, the curves will be interpolated by line segments. To access the curves as curves, use `get_path`. r) get_transformget_path to_polygonsr>)r@transpathZpolygonsrHrHrI get_vertsds  zPatch.get_vertscCsB|dur |St|jtr |j}n|ddkr6d}n|}|S)Nr) isinstance_pickerr get_edgecolor get_linewidth)r@radiusZ_radiusrHrHrI_process_radiusrs zPatch._process_radiusc s\}}|dur||fSj}|durj}t|tjk\}|dd}t tt ||t ||}n g}t fdd|D}|ifS)z Test whether the mouse event occurred in the patch. Returns ------- (bool, empty dict) Nrc3s(|] }|jjfVqdSN)contains_pointxyrJ).0subpath mouseeventrUr@rHrI sz!Patch.contains..) _default_containsrVrKcodesverticesnpwhererMOVETOmapsplitany) r@r^rUinsideinforarbidxsZsubpathsrHr]rIcontains~s"     zPatch.containscCs ||}||||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 ``self.get_transform()``. These are display coordinates for patches that are added to a figure or axes. radius : float, optional Add an additional margin on the patch in target coordinates of ``self.get_transform()``. See `.Path.contains_point` for further details. 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=1) >>> plt.gca().add_patch(c) >>> transformed_center = c.get_transform().transform(center) >>> c.contains_point(transformed_center) True )rVrKrXrJ)r@pointrUrHrHrIrXs -  zPatch.contains_pointcCs ||}||||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 Add an additional margin on the patch in target coordinates of ``self.get_transform()``. See `.Path.contains_point` for further details. 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`. )rVrKcontains_pointsrJ)r@pointsrUrHrHrIrns   zPatch.contains_pointscstt||j|_|j|_|j|_|j|_|j|_|j|_|j|_|j |_ | |j | | ||_dSrW)r' update_from _edgecolor _facecolor_original_edgecolor_original_facecolorr/_hatchr.r5r9r4 set_transformget_data_transformis_transform_set _transformSet)r@otherrFrHrIrps  zPatch.update_fromcCs||S)zU Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`. rK get_extentsrJr@rHrHrIr|szPatch.get_extentscCs|tj|S)z;Return the `~.transforms.Transform` applied to the `Patch`.)get_patch_transformrArtistrJr}rHrHrIrJszPatch.get_transformcCs tj|S)zo Return the `~.transforms.Transform` mapping data coordinates to physical coordinates. )rrrJr}rHrHrIrwszPatch.get_data_transformcCstS)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 IdentityTransformr}rHrHrIr~s zPatch.get_patch_transformcCs|jS)z0Return whether antialiasing is used for drawing.) _antialiasedr}rHrHrIget_antialiasedszPatch.get_antialiasedcCs|jS)zReturn the edge color.)rqr}rHrHrIrSszPatch.get_edgecolorcCs|jS)zReturn the face color.rrr}rHrHrI get_facecolor"szPatch.get_facecolorcCs|jS)z Return the line width in points.)r4r}rHrHrIrT&szPatch.get_linewidthcCs|jS)zReturn the linestyle.) _linestyler}rHrHrI get_linestyle*szPatch.get_linestylecCs"|durtjd}||_d|_dS)z| Set whether to use antialiased rendering. Parameters ---------- aa : bool or None Nzpatch.antialiasedT)r,r-rstale)r@rrHrHrIr:.s zPatch.set_antialiasedcCs\d}|dur6tjds"|jr"|jr.tjd}nd}d}t||j|_|rR|j|_d|_ dS)NTzpatch.force_edgecolorzpatch.edgecolornoneF) r,r-r/ _edge_defaultrr+_alpharqr.r)r@rAset_hatch_colorrHrHrI_set_edgecolor;s  zPatch._set_edgecolorcCs||_||dS)zp Set the patch edge color. Parameters ---------- color : color or None N)rsrr@rArHrHrIr2JszPatch.set_edgecolorcCs:|durtjd}|jr|jnd}t|||_d|_dS)Nzpatch.facecolorrT)r,r-r/rrr+rrr)r@rAalpharHrHrI_set_facecolorUs  zPatch._set_facecolorcCs||_||dS)zp Set the patch face color. Parameters ---------- color : color or None N)rtrrrHrHrIr3\szPatch.set_facecolorcCs||||dS)a Set both the edgecolor and the facecolor. Parameters ---------- c : color See Also -------- Patch.set_facecolor, Patch.set_edgecolor For setting the edge or face color individually. N)r3r2)r@crHrHrIr1gs zPatch.set_colorcs(t|||j||jdSrW)r' set_alpharrtrrs)r@rrFrHrIrws  zPatch.set_alphacCs>|durtjd}t||_tjg|j|R|_d|_dS)zu Set the patch linewidth in points. Parameters ---------- w : float or None Nzpatch.linewidthT) r,r-floatr4mlines _scale_dashesr5r6rr@wrHrHrIr9~s   zPatch.set_linewidthcCsN|dur d}|dvrd}||_t||_tjg|j|jR|_d|_dS)a Set the patch linestyle. ========================================== ================= linestyle description ========================================== ================= ``'-'`` or ``'solid'`` solid line ``'--'`` or ``'dashed'`` dashed line ``'-.'`` or ``'dashdot'`` dash-dotted line ``':'`` or ``'dotted'`` dotted line ``'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_patternr5rr4r6r)r@rrHrHrIr8s  zPatch.set_linestylecCs,t||_||j||jd|_dS)zh Set whether to fill the patch. Parameters ---------- b : bool TN)boolr/rrtrrsrr@brHrHrIr7s   zPatch.set_fillcCs|jS)z#Return whether the patch is filled.)r/r}rHrHrIget_fillszPatch.get_fillcCst|}||_d|_dS)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)r@scsrHrHrIr<s zPatch.set_capstylecCs|jjS)zReturn the capstyle.)rr%r}rHrHrI get_capstyleszPatch.get_capstylecCst|}||_d|_dS)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)r@rjsrHrHrIr=s zPatch.set_joinstylecCs|jjS)zReturn the joinstyle.)rr%r}rHrHrI get_joinstyleszPatch.get_joinstylecCst|||_d|_dS)a Set the hatching pattern. *hatch* can be one of:: / - diagonal hatching \ - back diagonal | - vertical - - horizontal + - crossed x - crossed diagonal o - small circle O - large circle . - dots * - stars Letters can be combined, in which case all the specified hatchings are done. If same letter repeats, it increases the density of hatching of that pattern. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. Parameters ---------- hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'} TN)mhatch_validate_hatch_patternrur)r@r rHrHrIr;s zPatch.set_hatchcCs|jS)zReturn the hatching pattern.)rur}rHrHrI get_hatchszPatch.get_hatchcCsJ|d||}|j|jdd|j}|jddksF|jdkrJd}|||j|j | |j | |j ||j||||j||||j|jr||j||j|dur|j||rddlm}|||}|D]}|j |g|Rq|!|"dd |_#dS) 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*. patchT)isRGBArPrrN)PathEffectRendererF)$ open_groupget_gidnew_gcset_foregroundrqr4rr9 set_dashesr6r<rr=rr:r _set_gc_clipset_url_urlset_snapget_snaprrrur;rr.get_sketch_paramsset_sketch_paramsget_path_effectsmatplotlib.patheffectsr draw_pathrestore close_groupr)r@rendererZdraw_path_args_listgcrrZdraw_path_argsrHrHrI"_draw_paths_with_artist_propertiess8               z(Patch._draw_paths_with_artist_propertiescCsV|s dS|}|}||}|}|||||jdrH|jndfgdS)NrP) get_visiblerKrJtransform_path_non_affine get_affinerrr)r@rrN transformtpathaffinerHrHrIdrawDs z Patch.drawcCs tddS)zReturn the path of this patch.Derived must overrideNNotImplementedErrorr}rHrHrIrKUszPatch.get_pathcCs||SrWr{r@rrHrHrIget_window_extentYszPatch.get_window_extentcCs$||d}||d}||fS)z)Convert x and y units for a tuple (x, y).rr)convert_xunitsconvert_yunits)r@xyrYrZrHrHrI_convert_xy_units\szPatch._convert_xy_units) NNNNNNNTNN)N)N)N)N)5__name__ __module__ __qualname____doc__zorderrrmake_keyword_onlyr(rOrVrlrXrnrpr|rJrwr~rrSrrTrr:rr2rr3r1rr9r8r7rpropertyrBr interpdr<rr=rr;rrrallow_rasterizationrrKrr __classcell__rHrHrFrIr"sp  5  2       #    !1  r"csNeZdZddZejfddZddZddZd d Z fd d Z Z S) ShadowcCsdt|jS)Nz Shadow(%s))strrr}rHrHrI__str__dszShadow.__str__c szt||_|||_|_t|_||jdt t |j }|||dt |jjt j d|dS)a Create a shadow of the given *patch*. By default, the shadow will have the same face color as the *patch*, but darkened. Parameters ---------- patch : `.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. **kwargs Properties of the shadow patch. Supported keys are: %(Patch:kwdoc)s 333333??)rrrrN)r'r(r_ox_oyr Affine2D_shadow_transformrprcasarrayrto_rgbrupdate nextafterrinf)r@roxoyrErArFrHrIr(gs    zShadow.__init__cCs.||j}||j}|j||dSrW)points_to_pixelsrrrclear translate)r@rrrrHrHrI_update_transforms  zShadow._update_transformcCs |jSrW)rrKr}rHrHrIrKszShadow.get_pathcCs|j|jSrW)rr~rr}rHrHrIr~szShadow.get_patch_transformcs||t|dSrW)rr'rrrFrHrIrs z Shadow.draw) rrrrr dedent_interpdr(rrKr~rrrHrHrFrIrcsrcseZdZdZddZejejdddd5dd fd d Z d d Z ddZ ddZ e ddZejddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Ze eeZ Z!S)6 Rectanglea 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. cCs$|j|j|j|j|jf}d}||S)Nz5Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g))_x0_y0_width_heightangler@ZparsfmtrHrHrIrszRectangle.__str__r#rr$r)rotation_pointc sTtjfi||d|_|d|_||_||_t||_||_d|_ | dS)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 : `.Patch` properties %(Patch:kwdoc)s rr?N) r'r(rrrrrrr_aspect_ratio_correction_convert_units)r@rwidthheightrrrErFrHrIr(s   zRectangle.__init__cCstS)z%Return the vertices of the rectangle.)runit_rectangler}rHrHrIrKszRectangle.get_pathcCsH||j}||j}||j|j}||j|j}||||fS)z Convert bounds of the rectangle.)rrrrrrr@x0y0x1y1rHrHrIrs   zRectangle._convert_unitscCs|}|jdkrJ|j|j|j|j}}|j|d|j|df}n|jdkrb|j|jf}n|j}t|t |d |d  d|j  |j  dd|j j |S)Ncenter@rrr)get_bboxrrrrrr BboxTransformTorrscaler rotate_degr)r@bboxrrrrHrHrIr~s(   zRectangle.get_patch_transformcCs|jS)z The rotation point of the patch.)_rotation_pointr}rHrHrIrszRectangle.rotation_pointcCsN|dvs:t|trBt|dkrBt|dtrBt|dtrB||_ntddS)N)rrrrzC`rotation_point` must be one of {'xy', 'center', (number, number)}.)rQtupler>rr  ValueError)r@valuerHrHrIrs   cCs|jS)z,Return the left coordinate of the rectangle.)rr}rHrHrIget_x szRectangle.get_xcCs|jS)z.Return the bottom coordinate of the rectangle.)rr}rHrHrIget_y szRectangle.get_ycCs |j|jfS)z>Return the left and bottom coords of the rectangle as a tuple.)rrr}rHrHrIget_xyszRectangle.get_xycCs|gdS)zc Return the corners of the rectangle, moving anti-clockwise from (x0, y0). )rr)rrrrrrr~rr}rHrHrI get_cornersszRectangle.get_cornerscCs|dS)z#Return the centre of the rectangle.)rrrr}rHrHrI get_centerszRectangle.get_centercCs|jSz"Return the width of the rectangle.rr}rHrHrI get_width!szRectangle.get_widthcCs|jSz#Return the height of the rectangle.rr}rHrHrI get_height%szRectangle.get_heightcCs|jS)z"Get the rotation angle in degrees.)rr}rHrHrI get_angle)szRectangle.get_anglecCs||_d|_dS)z)Set the left coordinate of the rectangle.TN)rrr@rYrHrHrIset_x-szRectangle.set_xcCs||_d|_dS)z+Set the bottom coordinate of the rectangle.TN)rrr@rZrHrHrIset_y2szRectangle.set_ycCs||_d|_dS)zs Set the rotation angle in degrees. The rotation is performed anti-clockwise around *xy*. TN)rrr@rrHrHrI set_angle7szRectangle.set_anglecCs|\|_|_d|_dS)z Set the left and bottom coordinates of the rectangle. Parameters ---------- xy : (float, float) TN)rrrr@rrHrHrIset_xy@s zRectangle.set_xycCs||_d|_dS)zSet the width of the rectangle.TNrrrrHrHrI set_widthKszRectangle.set_widthcCs||_d|_dS)z Set the height of the rectangle.TNrrr@hrHrHrI set_heightPszRectangle.set_heightcGsLt|dkr|d\}}}}n |\}}}}||_||_||_||_d|_dS)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)r>rrrrrr@argslrrr,rHrHrI set_boundsUs  zRectangle.set_boundscCs"|\}}}}tj||||SzReturn the `.Bbox`.)rr Bbox from_extentsrrHrHrIrjszRectangle.get_bbox)r)"rrrrrr rrrr(rKrr~rrsetterrrrrrrrrr!r#r%r'r)r-r1rrrrHrHrFrIrs> '    rcsNeZdZdZddZejejddddfd d Z d d Z d dZ Z S)RegularPolygonzA regular polygon patch.cCs(d}||jd|jd|j|j|jfS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)r numverticesrU orientationr@rrHrHrIruszRegularPolygon.__str__r#rUr$rc sD||_||_||_||_t||_t|_ t j fi|dS)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 N) rr7r8rUrunit_regular_polygon_pathr r_patch_transformr'r()r@r numVerticesrUr8rErFrHrIr(zs  zRegularPolygon.__init__cCs|jSrWr<r}rHrHrIrKszRegularPolygon.get_pathcCs"|j|j|jj|jSrW)r=rrrUrotater8rrr}rHrHrIr~s z"RegularPolygon.get_patch_transform)r:r) rrrrrr rrrr(rKr~rrHrHrFrIr6rs r6csBeZdZdZdZddZejfddZddZ d d Z Z S) PathPatchzA general polycurve path patch.TcCs(d}|t|jjgt|jjdRS)NzPathPatch%d((%g, %g) ...)r)r>r<rbr r9rHrHrIrszPathPatch.__str__c stjfi|||_dS)zr *path* is a `~.path.Path` object. Valid keyword arguments are: %(Patch:kwdoc)s N)r'r(r<)r@rNrErFrHrIr(s zPathPatch.__init__cCs|jSrWr?r}rHrHrIrKszPathPatch.get_pathcCs ||_dSrWr?)r@rNrHrHrIset_pathszPathPatch.set_path) rrrrrrr rr(rKrBrrHrHrFrIrAs rAcsLeZdZdZdZejdddfdd Zdd Zd d Z dd dZ Z S) StepPatchz A path patch describing a stepwise constant function. By default the path is not closed and starts and stops at baseline value. Fverticalr)r8baselinec sX||_t||_t||_|dur0t|nd|_|tj|j fi|dS)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. Other valid keyword arguments are: %(Patch:kwdoc)s N) r8rcr_edges_values _baseline _update_pathr'r(r<)r@valuesedgesr8rErErFrHrIr(s   zStepPatch.__init__c Cs(tt|jrtd|jjd|jjkrLtd|jjd|jjdtdgtjdtj dg}}t|j}|j dur|t|j O}t |D]j\}}t |j||dd }t |j||d }|j durt|dd||d dg}n|j jdkr.t|j g||j gg}n|j jdkrt |j ||d ddd }t||ddd g}t|d d||dd|dd||d dg}ntd |jd krt||g} nt||g} || |tjgtjgt| dqtt|t||_dS) 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`.rr r)dtyper zInvalid `baseline` specifiedrD)rcisnansumrFrsizerGemptyr code_typerHrcontiguous_regionsrepeat concatenatendimr8 column_stackappendreLINETOr>r<) r@vertsra _nan_maskidx0idx1rYrZbaserrHrHrIrIs@     "   $zStepPatch._update_pathcCstdd}||j|j|jS)z:Get `.StepPatch` values, edges and baseline as namedtuple. StairDatazvalues edges baseline)rrGrFrH)r@r`rHrHrIget_datas zStepPatch.get_dataNcCsn|dur |dur |dur td|dur4t||_|durHt||_|dur\t||_|d|_dS)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)rrcrrGrFrHrIr)r@rJrKrErHrHrIset_datas    zStepPatch.set_data)NNN) rrrrrr rr(rIrarbrrHrHrFrIrCs!$rCcsteZdZdZddZejejddddfdd Z d d Z d d Z ddZ ddZ ddZee eddZZS)PolygonzA general polygon patch.cCs8t|jjr0d}|t|jjg|jjdRSdSdS)NzPolygon%d((%g, %g) ...)rz Polygon0())r>r<rbr9rHrHrIr/s  zPolygon.__str__r#closedr$Tc s&tjfi|||_||dS)z *xy* is a numpy array with shape Nx2. If *closed* is *True*, the polygon will be closed so the starting and ending points are the same. Valid keyword arguments are: %(Patch:kwdoc)s N)r'r(_closedr')r@rrdrErFrHrIr(6s zPolygon.__init__cCs|jS)zGet the `.Path` of the polygon.r?r}rHrHrIrKGszPolygon.get_pathcCs|jS)z%Return whether the polygon is closed.)rer}rHrHrI get_closedKszPolygon.get_closedcCs4|jt|krdSt||_||d|_dS)z Set whether the polygon is closed. Parameters ---------- closed : bool True if the polygon is closed NT)rerr'rr)r@rdrHrHrI set_closedOs  zPolygon.set_closedcCs|jjS)z Get the vertices of the path. Returns ------- (N, 2) numpy array The coordinates of the vertices. )r<rbr}rHrHrIr^s zPolygon.get_xycCst|}|j\}}|jrT|dks>|dkr||d|dkr|t||dgg}n(|dkr||d|dkr||dd}t||jd|_d|_ dS)a Set the vertices of the polygon. Parameters ---------- xy : (N, 2) array-like The coordinates of the vertices. Notes ----- Unlike `~.path.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. rrrNr NrdT) rcrshapererhrVallrr<r)r@rnverts_rHrHrIr'is  $ zPolygon.set_xyz/The vertices of the path as (N, 2) numpy array.)doc)T)rrrrrr rrrr(rKrfrgrr'rrrrHrHrFrIrc,s  !rccsveZdZdZddZejejddddfdd Z d d Z d d Z ddZ ddZ ddZddZddZZS)WedgezWedge shaped patch.cCs0|jd|jd|j|j|j|jf}d}||S)Nrrzrrr<) r@rprq connectorruv1v2vrrHrHrIrrs.  "  zWedge._recompute_pathcCsd|_||_d|_dSNT)r<rr)r@rrHrHrI set_centerszWedge.set_centercCsd|_||_d|_dSr{)r<rorr@rUrHrHrI set_radiusszWedge.set_radiuscCsd|_||_d|_dSr{)r<rpr)r@rprHrHrI set_theta1szWedge.set_theta1cCsd|_||_d|_dSr{)r<rqr)r@rqrHrHrI set_theta2szWedge.set_theta2cCsd|_||_d|_dSr{)r<rrr@rrHrHrIr)szWedge.set_widthcCs|jdur||jSrWr<rrr}rHrHrIrKs zWedge.get_path)N)rrrrrr rrrr(rrr|r~rrr)rKrrHrHrFrIrns !rnc seZdZdZddZeddgddgddgddgd dgdd gddggZej e j d d d dfdd Z ddZ ddZZS)ArrowzAn arrow patch.cCsdS)NzArrow()rHr}rHrHrIrsz Arrow.__str__r皙?g皙?g333333ӿrrr#rr$c sJtjfi|tt|||t|| || |_ dS)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. N) r'r(r rrrchypotr@arctan2rfrozenr=)r@rYrZdxdyrrErFrHrIr(s  zArrow.__init__cCs|jSrWr?r}rHrHrIrKszArrow.get_pathcCs|jSrW)r=r}rHrHrIr~ szArrow.get_patch_transform)r)rrrrrr_create_closedr<r rrrr(rKr~rrHrHrFrIrs  %rc sdeZdZdZdZddZejej ddddfd d Z d d d d d d d dddZ ddZ Z S) FancyArrowzP Like Arrow, but lets you set head width and head height independently. TcCsdS)Nz FancyArrow()rHr}rHrHrIr+szFancyArrow.__str__r#rr$MbP?FNfullrc  sh||_||_||_||_||_||_||_||_| |_| |_ | |_ | t j |jfddi| dS)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 rdTN)_x_y_dx_dyr_length_includes_head _head_width _head_length_shape _overhang_head_starts_at_zero _make_vertsr'r(r[) r@rYrZrrrZlength_includes_head head_width head_lengthriZoverhangZhead_starts_at_zerorErFrHrIr(.s*zFancyArrow.__init__)rYrZrrrrrcCsz|dur||_|dur||_|dur*||_|dur8||_|durF||_|durT||_|durb||_|||j dS)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) rrrrrrrrr'r[)r@rYrZrrrrrrHrHrIrbfs zFancyArrow.set_datacCs|jdurd|j}n|j}|jdur0d|}n|j}t|j|j}|jrR|}n||}|srtddg|_ nZ||}}|j |j}}t ddg| | dg| d|| dg| | dg| dgg} |js| |dg7} |j r| |ddg7} |j dkr| } n\| ddg} |j d kr.| } n>|j d kr\t| dd| d ddg} ntd |j |dkr|j|} |j|} nd \} } | | g| | gg}t| ||j|j|j|jg|_ dS)NrPg?rr rrleftrNrightrzGot unknown shape: r)rrrrcrrrrrRr[rarrayrrrVrdotrr)r@rrdistancelengthhwZhlhsrZleft_half_arrowcoordsZright_half_arrowcxsxMrHrHrIrsX                 zFancyArrow._make_verts)rFNNrrF)rrrrrrr rrrr(rbrrrHrHrFrIr$s 6  (r rr )rcs>eZdZdZddZejejdddd fd d Z Z S) CirclePolygonz*A polygon-approximation of a circle patch.cCs$d}||jd|jd|j|jfS)Nz1CirclePolygon((%g, %g), radius=%g, resolution=%d)rr)rrUr7r9rHrHrIrszCirclePolygon.__str__r# resolutionr$r:c s tj||f|dd|dS)a Create a circle at *xy* = (*x*, *y*) with given *radius*. This circle is approximated by a regular polygon with *resolution* sides. For a smoother circle drawn with splines, see `Circle`. Valid keyword arguments are: %(Patch:kwdoc)s r)rUr8Nr'r()r@rrUrrErFrHrIr(szCirclePolygon.__init__)r:r) rrrrrr rrrr(rrHrHrFrIrs rcseZdZdZddZejejdddd"fdd Z d d Z d d Z ddZ ddZ ddZeee ZddZddZeeeZddZddZeeeZddZddZeeeZd d!ZZS)#EllipsezA scale-free ellipse.cCs,|jd|jd|j|j|jf}d}||S)Nrrz3Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s))_centerrrrrrHrHrIrs  zEllipse.__str__r#rr$rc sJtjfi|||_|||_|_||_t|_d|_ t |_ dS)a Parameters ---------- xy : (float, float) xy coordinates of ellipse centre. width : float Total length (diameter) of horizontal axis. height : float Total length (diameter) of vertical axis. angle : float, default: 0 Rotation in degrees anti-clockwise. Notes ----- Valid keyword arguments are: %(Patch:kwdoc)s rN) r'r(rrr_angler unit_circler<rr rr=)r@rrrrrErFrHrIr(s zEllipse.__init__cCsx||jd||jdf}||j}||j}t|d|d|j |j dd|jj ||_ dS)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) rrrrrr rrrr rrr=)r@rrrrHrHrI_recompute_transforms    zEllipse._recompute_transformcCs|jS)zReturn the path of the ellipse.r?r}rHrHrIrK,szEllipse.get_pathcCs||jSrW)rr=r}rHrHrIr~0szEllipse.get_patch_transformcCs||_d|_dS)zs Set the center of the ellipse. Parameters ---------- xy : (float, float) TN)rrr&rHrHrIr|4szEllipse.set_centercCs|jS)z!Return the center of the ellipse.rr}rHrHrIr?szEllipse.get_centercCs||_d|_dS)zl Set the width of the ellipse. Parameters ---------- width : float TNr(rrHrHrIr)EszEllipse.set_widthcCs|jS)z2 Return the width of the ellipse. rr}rHrHrIrPszEllipse.get_widthcCs||_d|_dS)zn Set the height of the ellipse. Parameters ---------- height : float TNr*)r@rrHrHrIr-XszEllipse.set_heightcCs|jS)z!Return the height of the ellipse.rr}rHrHrIrcszEllipse.get_heightcCs||_d|_dS)zl Set the angle of the ellipse. Parameters ---------- angle : float TN)rrr$rHrHrIr%iszEllipse.set_anglecCs|jS)z Return the angle of the ellipse.rr}rHrHrIrtszEllipse.get_anglecCs|gdS)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. ))rNrN)rrNr)rNrrr}rHrHrIrzszEllipse.get_corners)r)rrrrrr rrrr(rrKr~r|rrrr)rrr-rrr%rrrrrHrHrFrIrs* "        rcseZdZdZejd!fdd ZddZddZd d Z e e eZ d d Z d dZ e e e ZddZddZe eeZddZddZddZddZe eeZddZddZdd ZZS)"Annulusz An elliptical annulus. rc s8tjfi|||||_||_||_d|_dS)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 N)r'r( set_radiirrrr<)r@rrorrrErFrHrIr(s  zAnnulus.__init__cCs@|j|jkr|j}n |j|jf}dg|j||j|jRS)Nz.Annulus(xy=(%s, %s), r=%s, width=%s, angle=%s))arrrrr@rorHrHrIrs   zAnnulus.__str__cCs||_d|_d|_dS)zs Set the center of the annulus. Parameters ---------- xy : (float, float) NT)rr<rr&rHrHrIr|szAnnulus.set_centercCs|jS)z!Return the center of the annulus.rr}rHrHrIrszAnnulus.get_centercCs0t|j|j|krtd||_d|_d|_dS)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 semi-minor axisNT)minrrrrr<rrrHrHrIr)s zAnnulus.set_widthcCs|jS)z1Return the width (thickness) of the annulus ring.rr}rHrHrIrszAnnulus.get_widthcCs||_d|_d|_dS)zq Set the tilt angle of the annulus. Parameters ---------- angle : float NT)rr<rr$rHrHrIr%szAnnulus.set_anglecCs|jS)z Return the angle of the annulus.rr}rHrHrIrszAnnulus.get_anglecCst||_d|_d|_dS)zv Set the semi-major axis *a* of the annulus. Parameters ---------- a : float NT)rrr<r)r@rrHrHrI set_semimajors zAnnulus.set_semimajorcCst||_d|_d|_dS)zv Set the semi-minor axis *b* of the annulus. Parameters ---------- b : float NT)rrr<rrrHrHrI set_semiminors zAnnulus.set_semiminorcCsTt|dkr|\|_|_n(t|dkr.line_circle_intersectc sd}||kr||}}n ||}}||kr6||}}n ||}}||||} | j\} } | ||| k| ||k@||| k@| ||k@S)Ng& .>)T) rrrrepsilonZx0eZx1eZy0eZy1exysxsysrrHrIsegment_circle_intersects        z*Arc.draw..segment_circle_intersectrNrrsFT)#rrrIrwrrrr"rr raxesfigurer rJrr transformedsetziprbrrcrad2degrrrrsorteddeg2radrXcossinr<ru)r@rZdata_to_screen_transZpwidthZpheightZ inv_errorrZbox_path_transformZbox_pathZthetasp0p1rrYrZthetaZ last_thetaZ theta1_radriZ path_originalrHrrIrsX.  &   zArc.drawcCsZ|}tddt||j|j|j|jfDrV|\|_|_|_|_t|j|j|_ dS)Ncss|]\}}||kVqdSrWrH)r[rrrHrHrIr_<z#Arc._update_path..) rrhrrrrrrrur<)r@Z stretchedrHrHrIrI9s  zArc._update_pathcCsdd}||j}||j}||krt|j|jkrH|jd|jdkst||j||}||j||}||||fS|j|j||fS)NcSs@t|}t|}t|}tt|||}|ddS)Nrs)rcrrrrr)rrrYrZZsthetarHrHrI theta_stretchFs    z)Arc._theta_stretch..theta_stretchrs)rrrrrprq)r@rrrrprqrHrHrIrCs      zArc._theta_stretch)rrr)rrrrrr rrrr(rrrrIrrrHrHrFrIrjs 0  rTcCs|dur i}|}|dd}||}||}t|j|d|j|df|j||j||t dd}| || |dS)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. Npadr F)rrrrBrclip_on) copypoprrrrrrrr rrr)rrpropsrBrr rorHrHrI bbox_artistbs      rkcCs:t|j|j|j|ddd}|dur,||||dS)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)rrrrrBrN)rrrrrvr)r rrArMrorHrHrI draw_bboxys  rc@sDeZdZdZddZddZeddZedd Zed d Z d S) _Stylez 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 CsLtj|jd||jd|ddtdj|jdidS)Nz:tablez:table_and_acceptsz .. ACCEPTS: [|z '{}' ]) r rrr pprint_stylesjoinrfformat _style_listclsrHrHrI__init_subclass__s  z_Style.__init_subclass__c Ks|ddd}|d}z|j|}Wn4ty`}ztd||WYd}~n d}~00z(dd|d dD}d d |D}Wn4ty}ztd ||WYd}~n d}~00|fii||S) z>Return the instance of the subclass with the given style name.rr,rzUnknown style: NcSsg|]}|dqS)=)rg)r[rrHrHrI rz"_Style.__new__..rcSsi|]\}}|t|qSrH)r)r[rrzrHrHrI rz"_Style.__new__..zIncorrect style argument: )replacerglowerrKeyErrorr) r stylenamerE_list_name_clserrZ _args_pair_argsrHrHrI__new__s  &z_Style.__new__cCs|jS)z(Return a dictionary of available styles.)rrrHrHrI get_stylessz_Style.get_stylesc sdgdd|jD}ddt|DdddD}dd |dd dt|d D|gfd d|d dD|}tj|ddS)z5Return the available styles as pretty-printed string.)ClassNameAttrscSs:g|]2\}}|jd|dtt|ddp2dfqS)z``rrNr)rrinspect signature)r[r%rrHrHrIrs  z(_Style.pprint_styles..cSsg|]}tdd|DqS)css|]}t|VqdSrW)r>)r[cellrHrHrIr_r2_Style.pprint_styles...)max)r[columnrHrHrIrr css|]}d|VqdS)rNrH)r[clrHrHrIr_rz'_Style.pprint_styles..rrcss|]\}}||VqdSrWljustr[r rrHrHrIr_rrcs&g|]}dddt|DqS)rcss|]\}}||VqdSrWrrrHrHrIr_rr)rr)r[rowcol_lenrHrIrsrNz )prefix)ritemsrrtextwrapindent)rtabletable_formatstrZ rst_tablerHrrIrs(   z_Style.pprint_stylescCs,t||jstd||jf||j|<dS)zRegister a new style.z%s must be a subclass of %sN) issubclass_Baserr)rr%stylerHrHrIregisters  z_Style.registerN) rrrrrr classmethodrrr"rHrHrHrIrs  rr$cCs.|durtjt||dS|||p(|j<|S)z=Class decorator that stashes a class in a (style) dictionary.Nr$) functoolspartial_register_stylerr)Z style_listrr%rHrHrIr&sr&c@seZdZdZiZeeGdddZeeGdddZeeGdddZeeGdd d eZ eeGd d d Z eeGd d d Z eeGdddZ eeGdddZ eeGddde ZdS)BoxStylea `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@s"eZdZdZdddZddZdS) zBoxStyle.Squarez A square box.rcCs ||_dSz Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. Nrr@rrHrHrIr( szBoxStyle.Square.__init__c Csj||j}|d||d|}}||||}}||||}}t||f||f||f||fgSNr rrr) r@rrrr mutation_sizerrrrHrHrI__call__ s zBoxStyle.Square.__call__N)rrrrrr(r.rHrHrHrISquare s r0c@s"eZdZdZdddZddZdS) zBoxStyle.CirclezA circular box.rcCs ||_dSr(r)r*rHrHrIr( szBoxStyle.Circle.__init__cCs`||j}|d||d|}}||||}}t||d||dft||dSr+)rrcircler)r@rrrrr-rrHrHrIr.$ s   zBoxStyle.Circle.__call__N)rr/rHrHrHrIr s rc@s"eZdZdZdddZddZdS) zBoxStyle.LArrowz,A box in the shape of a left-pointing arrow.rcCs ||_dSr(r)r*rHrHrIr(0 szBoxStyle.LArrow.__init__c Cs||j}|d||d|}}||||}}||||}}||d} | d} ||d}t|| |f||f||f|| |f|| || f|| || f|| || f|| |fgSNr gffffff?r, r@rrrrr-rrrrZdxxrHrHrIr.9 s     zBoxStyle.LArrow.__call__N)rr/rHrHrHrILArrow, s r4c@seZdZdZddZdS)zBoxStyle.RArrowz-A box in the shape of a right-pointing arrow.cCsFtj||||||}d|||jdddf|jdddf<|S)Nr r)r'r4r.rb)r@rrrrr-prHrHrIr.P s  ,zBoxStyle.RArrow.__call__Nrrrrr.rHrHrHrIRArrowL sr7c@s"eZdZdZdddZddZdS) zBoxStyle.DArrowz&A box in the shape of a two-way arrow.rcCs ||_dSr(r)r*rHrHrIr([ szBoxStyle.DArrow.__init__c Cs||j}|d|}||||}}||||}}||d} | d} ||d}t|| |f||f||| f|| | || f||| f||f|| |f|| || f|| || f|| || f|| |fg Sr2r,r3rHrHrIr.d s       zBoxStyle.DArrow.__call__N)rr/rHrHrHrIDArrowV s r8c@s"eZdZdZdddZddZdS) zBoxStyle.RoundzA box with round corners.rNcCs||_||_dS)z Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. rounding_size : float, default: *pad* Radius of the corners. Nr rounding_sizer@rr:rHrHrIr( s zBoxStyle.Round.__init__c Cs(||j}|jr||j}n|}|d||d|}}||||}}||||}} |||f|||f||f|||f|| |f|| f||| f||| f|| f|| |f|||f||f|||f|||fg} tjtjtjtjtjtjtjtjtjtjtjtjtjtjg} t| | } | Sr+)rr:rrerZCURVE3rv r@rrrrr-rdrrrcpcomrNrHrHrIr. s>          zBoxStyle.Round.__call__)rNr/rHrHrHrIRound{ s rAc@s"eZdZdZdddZddZdS) zBoxStyle.Round4zA box with rounded edges.rNcCs||_||_dS)z Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. rounding_size : float, default: *pad*/2 Rounding of edges. Nr9r;rHrHrIr( s zBoxStyle.Round4.__init__c CsZ||j}|jr||j}n|d}|d|d|}|d|d|}||||||}}||||}} ||f||||f||||f||f||||f||| |f|| f||| |f||| |f|| f||| |f||||f||f||fg} tjtjtjtjtjtjtjtjtjtjtjtjtjtjg} t| | } | S)Nrr )rr:rreCURVE4rvr=rHrHrIr. s0  """"     zBoxStyle.Round4.__call__)rNr/rHrHrHrIRound4 s rCc@s*eZdZdZd ddZddZdd ZdS) zBoxStyle.SawtoothzA box with a sawtooth outline.rNcCs||_||_dS)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 tooth_size)r@rrDrHrHrIr( s zBoxStyle.Sawtooth.__init__cCsZ||j}|jdur$|jd|}n |j|}|d}|d||}|d||}tt|||dd} ||| } tt|||dd} ||| } ||||||}}||||} }|g||| dt| d| |}|g||||||g| ||}| g| || | || g| | |}|g||| dt| d||}| g| || dt| d||}|g||||||g| ||}|g||||||g| ||}|g||| dt| d||}gt||t||t||t|||d|df}|S)Nrr r)rrDintroundrcaranger)r@rrrrr-rrDZ tooth_size2Zdsx_nZdsxZdsy_nZdsyrrZ bottom_saw_xZ bottom_saw_yZ right_saw_xZ right_saw_yZ top_saw_xZ top_saw_yZ left_saw_xZ left_saw_y saw_verticesrHrHrI_get_sawtooth_vertices s      z(BoxStyle.Sawtooth._get_sawtooth_verticescCs"||||||}t|dd}|S)NTrh)rIr)r@rrrrr-rHrNrHrHrIr.D s   zBoxStyle.Sawtooth.__call__)rN)rrrrr(rIr.rHrHrHrISawtooth s JrJc@seZdZdZddZdS)zBoxStyle.Roundtoothz&A box with a rounded sawtooth outline.cCs\||||||}t||dgg}tjgtjtjgt|ddtjg}t||S)Nrrr )rIrcrVrrer<r>rv)r@rrrrr-rHrarHrHrIr.N szBoxStyle.Roundtooth.__call__Nr6rHrHrHrI RoundtoothJ srKN)rrrrrr&r0rr4r7r8rArCrJrKrHrHrHrIr's( $;2_r'c@seZdZdZiZGdddZeeGdddeZeeGdddeZeeGdd d eZ eeGd d d eZ eeGd d d eZ dS)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 an 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@s8eZdZdZGdddZddZddZd d d Zd S) zConnectionStyle._Basea 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@seZdZddZdS)z!ConnectionStyle._Base.SimpleEventcCs|\|_|_dSrW)rYrZr&rHrHrIr( sz*ConnectionStyle._Base.SimpleEvent.__init__N)rrrr(rHrHrHrI SimpleEvent srMcsr>fdd}zt||\}}Wnty8|}Yn0|}r|fdd}zt||\}}Wntyv|}Yn0|}|S)aI Clip the path to the boundary of the patchA and patchB. The starting point of the path needed to be inside of the patchA and the end point inside the patch B. The *contains* methods of each patch object is utilized to test if the point is inside the path. cstj|}|dSNrrLr rMrlZ xy_displayZxy_event)patchArHrIinsideA s z,ConnectionStyle._Base._clip..insideAcstj|}|dSrNrOrP)patchBrHrIinsideB s z,ConnectionStyle._Base._clip..insideB)rr)r@rNrQrSrRrrrTrH)rQrSrI_clip s       zConnectionStyle._Base._clipcCs|rBtg|jd|R}zt||\}}Wnty@Yn0|rtg|jd|R}zt||\}}WntyYn0|S)z] Shrink the path by fixed size (in points) with shrinkA and shrinkB. rrN)rrbrr)r@rNshrinkAshrinkBrRrrTrrHrHrI_shrink s  zConnectionStyle._Base._shrinkrNc Cs,|||}||||}||||} | S)z Call the *connect* method to create a path between *posA* and *posB*; then clip and shrink the path. )connectrUrX) r@posAposBrVrWrQrSrNZ clipped_pathZ shrunk_pathrHrHrIr. s zConnectionStyle._Base.__call__)rrNN)rrrrrMrUrXr.rHrHrHrIr  s  #r c@s"eZdZdZdddZddZdS) zConnectionStyle.Arc3aM Creates a simple quadratic Bezier curve between two points. The curve is created so that the middle control point (C1) is located at the same distance from the start (C0) and end points(C2) and the distance of the C1 to the line connecting C0-C2 is *rad* times the distance of C0-C2. rcCs ||_dS)zE *rad* curvature of the curve. N)rad)r@r\rHrHrIr( szConnectionStyle.Arc3.__init__cCs|\}}|\}}||d||d}}||||} } |j} || | || | } } ||f| | f||fg}tjtjtjg}t||S)Nr)r\rrer<)r@rZr[rrx2y2Zx12Zy12rrfrcyrbrarHrHrIrY szConnectionStyle.Arc3.connectN)rrrrrr(rYrHrHrHrIArc3 s rbc@s"eZdZdZd ddZddZdS) zConnectionStyle.Angle3a  Creates a simple quadratic Bezier curve between two points. The middle control points is placed at the intersecting point of two lines which cross the start and end point, and have a slope of angleA and angleB, respectively. ZrcCs||_||_dS)z *angleA* starting angle of the path *angleB* ending angle of the path N)angleAangleB)r@rdrerHrHrIr( s zConnectionStyle.Angle3.__init__c Cs|\}}|\}}tt|j}tt|j}tt|j} tt|j} t||||||| | \} } ||f| | f||fg} tjtj tj g}t| |SrW) mathrradiansrdrrerrrer<)r@rZr[rrr]r^cosAsinAcosBsinBrr`rbrarHrHrIrY s zConnectionStyle.Angle3.connectN)rcrrarHrHrHrIAngle3 s rlc@s"eZdZdZd ddZddZd S) zConnectionStyle.AngleaX Creates a piecewise continuous quadratic Bezier path between two points. The path has a one passing-through point placed at the intersecting point of two lines which cross the start and end point, and have a slope of angleA and angleB, respectively. The connecting edges are rounded with *rad*. rcrrcCs||_||_||_dS)z *angleA* starting angle of the path *angleB* ending angle of the path *rad* rounding radius of the edge N)rdrer\)r@rdrer\rHrHrIr(' s zConnectionStyle.Angle.__init__c Csp|\}}|\}}tt|j}tt|j}tt|j} tt|j} t||||||| | \} } ||fg} tjg}|j dkr| | | f| tj n|| || }}t ||}|j |}|| || }}t ||}|j |}| | ||| ||f| | f| ||| ||fg|tj tjtjg| ||f| tj t| |S)Nr)rfrrgrdrrerrrer\rYrZrcrextendr<)r@rZr[rrr]r^rhrirjrkrr`rbradx1dy1d1f1dx2dy2d2f2rHrHrIrY8 s8        zConnectionStyle.Angle.connectN)rcrrrarHrHrHrIAngle s rvc@s"eZdZdZd ddZddZdS) zConnectionStyle.Arca: Creates a piecewise continuous quadratic Bezier path between two points. The path can have two passing-through points, a point placed at the distance of armA and angle of angleA from point A, another point with respect to point B. The edges are rounded with *rad*. rNrcCs"||_||_||_||_||_dS)aH *angleA* : starting angle of the path *angleB* : ending angle of the path *armA* : length of the starting arm *armB* : length of the ending arm *rad* : rounding radius of the edges N)rdrearmAarmBr\)r@rdrerwrxr\rHrHrIr(e s zConnectionStyle.Arc.__init__cCsv|\}}|\}}||fg}g}tjg} |jrtt|j} tt|j} |j|j} | || | || | f|j} | || | || | f|j rtt|j } tt|j }||j | ||j |}}|rl|d\}}||||}}||||d}| ||j||||j||f| || tj tjtjgn2|d\}}||||}}||||d}||j} || |||| ||f||fg}|rR|d\}}||||}}||||d}| ||j||||j||f| || tj tjtjg| ||f| tj t|| S)NrNr)rrerwrfrrgrdrr\rYrxrermrZr<)r@rZr[rrr]r^rbroundedrarhridrjrkZx_armBZy_armBxpyprrddrHrHrIrY~ sd         zConnectionStyle.Arc.connect)rrNNrrarHrHrHrIr[ s rc@s"eZdZdZd ddZddZdS) zConnectionStyle.Bara A line with *angle* between A and B with *armA* and *armB*. One of the arms is extended so that they are connected in a right angle. The length of armA is determined by (*armA* + *fraction* x AB distance). Same for armB. rrNcCs||_||_||_||_dS)a Parameters ---------- armA : float minimum length of armA armB : float minimum length of armB fraction : float a fraction of the distance between two points that will be added to armA and armB. angle : float or None angle of the connecting line (if None, parallel to A and B) N)rwrxfractionr)r@rwrxr~rrHrHrIr( szConnectionStyle.Bar.__init__cCs|\}}|\}}\}}t||||} ||||} } | | | | d} | | | | } }|j|j}}|jdurt|j}| |}| t|}| t|}||t|||t|}}||}||||} } | | | | d}| || |} }t ||}|j | |}|||||| }}|||||| }}||f||f||f||fg}t j t j t j t j g}t ||S)Nr)rfatan2rwrxrrcrrrrr~rrerZ)r@rZr[rrZx20Zy20r]r^rprrr}ddxddyrwrxZtheta0dthetadlZdLZdd2armr_cx1cy1cx2cy2rbrarHrHrIrY s@  & zConnectionStyle.Bar.connect)rrrNrarHrHrHrIBar s rN) rrrrrr r&rbrlrvrrrHrHrHrIrLZ s$Q#%=]rLc CsL||||}}|||||d}||||||}} || fS)z{ Return the point on the line connecting (*x0*, *y0*) -- (*x1*, *y1*) whose distance from (*x0*, *y0*) is *d*. rrH) rrrrrzrrffr]r^rHrHrI_point_along_a_line src@seZdZdZiZGdddZGdddeZeeddGdd d eZeed dGd d d eZ eed dGdddeZ eeddGdddeZ eeddGdddeZ eeddGdddeZ eeddGdddeZeeddGdddeZeeddGd d!d!eZeed"dGd#d$d$eZeed%dGd&d'd'eZeed(dGd)d*d*eZeed+dGd,d-d-eZeeGd.d/d/eZeeGd0d1d1eZeeGd2d3d3eZd4S)5 ArrowStylea `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`. A arrowstyle object can be either created as:: ArrowStyle.Fancy(head_length=.4, head_width=.4, tail_width=.4) or:: ArrowStyle("Fancy", head_length=.4, head_width=.4, tail_width=.4) or:: ArrowStyle("Fancy, head_length=.4, head_width=.4, tail_width=.4") The following classes are defined %(ArrowStyle:table)s An instance of any arrow style class is a callable object, whose call signature is:: __call__(self, path, mutation_size, linewidth, aspect_ratio=1.) and it returns a tuple of a `.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. c@s.eZdZdZeddZddZd ddZd S) zArrowStyle._Basea Arrow Transmuter Base class ArrowTransmuterBase and its derivatives are used to make a fancy arrow around a given path. The __call__ method returns a path (which will be used to create a PathPatch instance) and a boolean value indicating the path is open therefore is not fillable. This class is not an artist and actual drawing of the fancy arrow is done by the FancyArrowPatch class. cCs`t|}t|dks<|ddtjks<|ddtjkrDtdg|dd|ddS)aP Some ArrowStyle classes only works with a simple quadratic Bezier curve (created with `.ConnectionStyle.Arc3` or `.ConnectionStyle.Angle3`). This static method checks if the provided path is a simple quadratic Bezier curve and returns its control points if true. r rrz,'path' is not a valid quadratic Bezier curve)list iter_segmentsr>rrer<r)rNsegmentsrHrHrIensure_quadratic_bezierF s z(ArrowStyle._Base.ensure_quadratic_beziercCs tddS)a The transmute method is the very core of the ArrowStyle class and must be overridden in the subclasses. It receives the path object along which the arrow will be drawn, and the mutation_size, with which the arrow head etc. will be scaled. The linewidth may be used to adjust the path so that it does not pass beyond the given points. It returns a tuple of a Path instance and a boolean. The boolean value indicate whether the path can be filled or not. The return value can also be a list of paths and list of booleans of a same length. rNr)r@rNr-r!rHrHrI transmuteV s zArrowStyle._Base.transmuterc stdurb|jdg}t||j}||||\}}t|rXfdd|D} | |fS||fSn||||SdS)z The __call__ method is a thin wrapper around the transmute method and takes care of the aspect ratio. Nrcs"g|]}t|jdg|jqS)r)rrbra)r[r5 aspect_ratiorHrIru sz-ArrowStyle._Base.__call__..)rbrrarrciterable) r@rNr-r!rrbZ path_shrunkZ path_mutatedfillable path_listrHrrIr.d s    zArrowStyle._Base.__call__N)r)rrrr staticmethodrrr.rHrHrHrIr 6 s  r c sNeZdZdZdZZdZdZZdfd d Z d d Z d dZ ddZ Z S)zArrowStyle._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 begin point and at the end point. The arrow heads can be either open or closed. N-F皙?皙?rrc s|||_|_|||_|_|||_|_|||_|_| | |_|_ d|_ d|_ d|_ d|_ d|jvrptd|jdd\} } | dkrd|_ d|_ n| dkrd|_ d|_ d|_nf| dvrd|_ d|_ nP|jdurd|_ d|_ tjd d d d n(|jdurd|_ d|_ tjd d d d | d kr2d|_ d|_ n| dkrPd|_ d|_ d|_nj| dvrhd|_ d|_ nR|jdurd|_ d|_ tjd dd d n(|jdurd|_ d|_ tjd dd d tdS)a= Parameters ---------- head_length : float, default: 0.4 Length of the arrow head, relative to *mutation_scale*. head_width : float, default: 0.2 Width of the arrow head, relative to *mutation_scale*. widthA : float, default: 1.0 Width of the bracket at the beginning of the arrow widthB : float, default: 1.0 Width of the bracket at the end of the arrow lengthA : float, default: 0.2 Length of the bracket at the beginning of the arrow lengthB : float, default: 0.2 Length of the bracket at the end of the arrow angleA : float, default 0 Orientation of the bracket at the beginning, as a counterclockwise angle. 0 degrees means perpendicular to the line. angleB : float, default 0 Orientation of the bracket at the beginning, as a counterclockwise angle. 0 degrees means perpendicular to the line. scaleA : float, default *mutation_size* The mutation_size for the beginning bracket scaleB : float, default *mutation_size* The mutation_size for the end bracket Frz-arrow must have the '-' between the two headsrz|>)[rendarrowN)rrwidthAwidthBlengthAlengthBrdrescaleAscaleB_beginarrow_head_beginarrow_bracket_endarrow_head_endarrow_bracketrrrg fillbeginrrwarn_deprecatedfillendrr'r() r@rrrrrrrdrerrrrrFrHrIr( sr         zArrowStyle._Curve.__init__c Cs||||} } t| | } d||} | dkr6d} | | | } | | | }| | |} | | |} || || | | || }}|| || || || }}|| ||||f|| ||f|| ||||fg}tjtjtjg}||| |fS)a Return the paths for arrow heads. Since arrow lines are drawn with capstyle=projected, The arrow goes beyond the desired point. This method also returns the amount of the path to be shrunken so that it does not overshoot. rrr)rcrrrerZ)r@rrrr head_distcos_tsin_tr!rrZ cp_distanceZ pad_projectedrrrnrorrrsvertices_arrow codes_arrowrHrHrI_get_arrow_wedge s(       $"z"ArrowStyle._Curve._get_arrow_wedgecCst||||\}} ddlm} | |||| |\}}} } |||| } }|| ||f||f| | f| | | |fg}tjtjtjtjg}|rt|||}| |}||fS)Nr)get_normal_points) rZmatplotlib.bezierrrrerZr rrotate_deg_aroundr)r@rrrrrrrrrrr]r^rrrrrMrHrHrI _get_bracket s$  zArrowStyle._Curve._get_bracketc! Cs2|js |jr>|j|}|j|}t||}||||}}|jdurL|n|j} |jdur`|n|j} |jd\} } |jd\} }|jo| | f| |fk}|r| | || | ||||n ggddf\}}}}|jd\}}|jd\}}|jo||f||fk}|r| ||||||||n ggddf\}}}}t t | || |fg|jdd||||fgg|j g}dg}|r|j rt ||d|dgg}t |t jt jgg} |t || |dn|t |||dnf|jrN|jd\} } |jd\} }|| | | ||j| |j| |j\}}|t |||d|r|jr|dt ||d|dgg}t |t jt jgg} |t || n|d|t ||nf|jr*|jd\} } |jd\} }|| | | ||j| |j| |j\}}|t |||d||fS)NrrrrNFT)rrrrrcrrrrbrrrVrarrZrvrYrrrrrdrrrrre)!r@rNr-r!rrrrrrrrrrrZhas_begin_arrowZ verticesAZcodesAZddxAZddyAr]r^x3Zy3Z has_end_arrowZ verticesBZcodesBZddxBZddyBr<Z _fillabler5rrHrHrIr/ s                 zArrowStyle._Curve.transmute) rrrrrrrrNN)rrrrrrrrrr(rrrrrHrHrFrI_Curve} sa*rrr$cs eZdZdZfddZZS)zArrowStyle.Curvez&A simple curve without any arrow head.cstjddddS)Nrr)rrrr}rFrHrIr( szArrowStyle.Curve.__init__)rrrrr(rrHrHrFrICurve sr<-c@seZdZdZdZdS)zArrowStyle.CurveAz(An arrow with a head at its begin point.rNrrrrrrHrHrHrICurveA sr->c@seZdZdZdZdS)zArrowStyle.CurveBz&An arrow with a head at its end point.rNrrHrHrHrICurveB sr<->c@seZdZdZdZdS)zArrowStyle.CurveABz8An arrow with heads both at the begin and the end point.rNrrHrHrHrICurveAB sr<|-c@seZdZdZdZdS)zArrowStyle.CurveFilledAz0An arrow with filled triangle head at the begin.rNrrHrHrHrI CurveFilledA sr-|>c@seZdZdZdZdS)zArrowStyle.CurveFilledBz.An arrow with filled triangle head at the end.rNrrHrHrHrI CurveFilledB sr<|-|>c@seZdZdZdZdS)zArrowStyle.CurveFilledABz1An arrow with filled triangle heads at both ends.rNrrHrHrHrI CurveFilledAB sr]-cs&eZdZdZdZdfdd ZZS) zArrowStyle.BracketAz5An arrow with an outward square bracket at its start.rrrrcstj|||ddSa 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. )rrrdNrr@rrrdrFrHrIr( s zArrowStyle.BracketA.__init__)rrrrrrrrr(rrHrHrFrIBracketA sr-[cs&eZdZdZdZdfdd ZZS) zArrowStyle.BracketBz3An arrow with an outward square bracket at its end.rrrrcstj|||ddSa 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. )rrreNrr@rrrerFrHrIr( s zArrowStyle.BracketB.__init__)rrrrrHrHrFrIBracketB sr]-[cs&eZdZdZdZdfdd ZZS) zArrowStyle.BracketABz3An arrow with outward square brackets at both ends.rrrrcstj||||||ddS)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. rrrdrrreNr)r@rrrdrrrerFrHrIr( s zArrowStyle.BracketAB.__init__)rrrrrrrrHrHrFrI BracketAB s r|-|cs&eZdZdZdZdfdd ZZS)zArrowStyle.BarABz/An arrow with vertical bars ``|`` at both ends.rrrcstj|d||d|ddS)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. rrNr)r@rrdrrerFrHrIr( s zArrowStyle.BarAB.__init__)rrrrrrHrHrFrIBarAB sr]->cs&eZdZdZdZdfdd ZZS) zArrowStyle.BracketCurveze An arrow with an outward square bracket at its start and a head at the end. rrrNcstj|||ddSrrrrFrHrIr(s z ArrowStyle.BracketCurve.__init__)rrNrrHrHrFrI BracketCurve sr<-[cs&eZdZdZdZdfdd ZZS) zArrowStyle.CurveBracketze An arrow with an outward square bracket at its end and a head at the start. rrrNcstj|||ddSrrrrFrHrIr(s z ArrowStyle.CurveBracket.__init__)rrNrrHrHrFrI CurveBracketsrcs*eZdZdZdfdd ZddZZS) zArrowStyle.Simplez9A simple arrow. Only works with a quadratic Bezier curve.rrcs$||||_|_|_tdS)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. Nrr tail_widthr'r(r@rrrrFrHrIr(-szArrowStyle.Simple.__init__cCs||\}}}}}} |j|} t|| | } ||f||f|| fg} zt| | dd\} }WnZtyt|| ||| \}}d||d|| }}||f||f|| fg}d} Yn0|j|}t||ddd\}}| dur|j|}t | |d\}}t j |dft j |dft j |dft j |dft j |dft j |dft j |dft j |dft j |dft j |dft j |dft j |dft j|dfg }nLt j |dft j |dft j |dft j |dft j |dft j|dfg}t d d |Dd d |D}|d fS) N{Gz? tolerancerrwmrrr cSsg|] \}}|qSrHrHr[rr5rHrHrIrurz/ArrowStyle.Simple.transmute..cSsg|] \}}|qSrHrHrrHrHrIrurT)rrrrr rrrrrrrer<rZrv)r@rNr-r!rrrrr]r^rin_f arrow_pathZ arrow_outZarrow_inx1ny1nr head_left head_rightr tail_left tail_right patch_pathrHrHrIr>s\                            zArrowStyle.Simple.transmute)rrrrrrrr(rrrHrHrFrISimple)srcs*eZdZdZdfdd ZddZZS)zArrowStyle.Fancyz8A fancy arrow. Only works with a quadratic Bezier curve.rcs$||||_|_|_tdS)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. NrrrFrHrIr(}szArrowStyle.Fancy.__init__cCs||\}}}}}} |j|} ||f||f|| fg} t|| | } zt| | dd\} }WnZtyt|| ||| \}}d||d|| }}||f||f|| fg} | }Yn0|}t|| | d} t| | dd\} }| }|j|}t||ddd\}}|j|}t||dddd d \}}t|||d } t| | dd\}} |d }||}}t j |ft j |d ft j |d ft j |dft j |d ft j |d ft j |dft j |d ft j |d ft j |dft j |d ft j |d ft j |ft j |fg}t dd|Ddd|D}|dfS)Nrrrrrg333333?rrr)w1rw2rNrrr cSsg|] \}}|qSrHrHrrHrHrIrrz.ArrowStyle.Fancy.transmute..cSsg|] \}}|qSrHrHrrHrHrIrrT)rrrrr rrrrrrerZr<rv)r@rNr-r!rrrrr]r^rrrpath_outpath_inrr path_headZ path_tailrZhead_lZhead_rrrrZ tail_startrrrrHrHrIrsh                      zArrowStyle.Fancy.transmute)rrrrrHrHrFrIFancyysrcs*eZdZdZdfdd ZddZZS) zArrowStyle.Wedgez Wedge(?) shape. Only works with a quadratic Bezier curve. The begin point has a width of the tail_width and the end point has a width of 0. At the middle, the width is shrink_factor*tail_width. rrcs||_||_tdS)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'r()r@rrrFrHrIr(s zArrowStyle.Wedge.__init__c Cs||\}}}}}} ||f||f|| fg} t| |j|d|jd\} } tj| dftj| dftj| dftj| dftj| dftj| dftj| dfg} tdd| Ddd| D}|d fS) Nrrrrr cSsg|] \}}|qSrHrHrrHrHrIrrz.ArrowStyle.Wedge.transmute..cSsg|] \}}|qSrHrHrrHrHrIrrT) rrrrrrer<rZrv)r@rNr-r!rrrrr]r^rZb_plusZb_minusrrHrHrIrs"         zArrowStyle.Wedge.transmute)rrrrHrHrFrIrnsrnN)rrrrrr rr&rrrrrrrrrrrrrrrrnrHrHrHrIr sL#G             OWrcseZdZdZdZddZejej dddej dd d d d3fdd Z ejd4ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2ZZS)5FancyBboxPatchaO 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`. TcCs$|jjd}||j|j|j|jfS)Nz((%g, %g), width=%g, height=%g))rGrrrrrr9rHrHrIr s zFancyBboxPatch.__str__r#mutation_scaler$3.4bbox_transmuterboxstylerrFNrc  stjfi||d|_|d|_||_||_|dkr`tjddd|durXtd||_ n | |||_ ||_ d |_ dS) a Parameters ---------- xy : float, float The lower left corner of the box. width : float The width of the box. height : float The height of the box. boxstyle : str or `matplotlib.patches.BoxStyle` The style of the fancy box. This can either be a `.BoxStyle` instance or a string of the style name and optionally comma 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 : `.Patch` properties %(Patch:kwdoc)s rrcustomrzSupport for boxstyle='custom' is deprecated since %(since)s and will be removed %(removal)s; directly pass a boxstyle instance as the boxstyle parameter instead.messageNz7bbox_transmuter argument is needed with custom boxstyleT)r'r(rrrrrrr_bbox_transmuter set_boxstyle_mutation_scale_mutation_aspectr) r@rrrrrrmutation_aspectrErFrHrIr(s /   zFancyBboxPatch.__init__cKs:|durtSt|tr*t|fi|n||_d|_dS)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)r'rrQrrr)r@rrErHrHrIrUs!zFancyBboxPatch.set_boxstylecCs|jS)zReturn the boxstyle object.)rr}rHrHrI get_boxstyle}szFancyBboxPatch.get_boxstylecCs||_d|_dSzf Set the mutation scale. Parameters ---------- scale : float TNrrr@rrHrHrIset_mutation_scalesz!FancyBboxPatch.set_mutation_scalecCs|jS)zReturn the mutation scale.rr}rHrHrIget_mutation_scalesz!FancyBboxPatch.get_mutation_scalecCs||_d|_dSzz Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : float TNrrr@aspectrHrHrIset_mutation_aspectsz"FancyBboxPatch.set_mutation_aspectcCs|jdur|jSdSz-Return the aspect ratio of the bbox mutation.Nrrr}rHrHrIget_mutation_aspectsz"FancyBboxPatch.get_mutation_aspectc Cs|}|j}|j}|j}|j}|}|}||||}}zt| |||||Wn2t y||||||d}t j dddYn0||||||}|j |j} } | dddf|| dddf<t| | S)z)Return the mutated path of the rectangle.rrzboxstyles must be callable without the 'mutation_aspect' parameter since %(since)s; support for the old call signature will be removed %(removal)s.rN)rrrrrr rr r bind TypeErrorrrrbrar) r@rrYrZrrZm_scaleZm_aspectrNrbrarHrHrIrKs&   zFancyBboxPatch.get_pathcCs|jS)z'Return the left coord of the rectangle.)rr}rHrHrIrszFancyBboxPatch.get_xcCs|jS)z)Return the bottom coord of the rectangle.)rr}rHrHrIrszFancyBboxPatch.get_ycCs|jSrrr}rHrHrIrszFancyBboxPatch.get_widthcCs|jSrrr}rHrHrIrszFancyBboxPatch.get_heightcCs||_d|_dS)zo Set the left coord of the rectangle. Parameters ---------- x : float TN)rrr rHrHrIr!szFancyBboxPatch.set_xcCs||_d|_dS)zq Set the bottom coord of the rectangle. Parameters ---------- y : float TN)rrr"rHrHrIr#szFancyBboxPatch.set_ycCs||_d|_dS)zc Set the rectangle width. Parameters ---------- w : float TNr(rrHrHrIr)szFancyBboxPatch.set_widthcCs||_d|_dS)zd Set the rectangle height. Parameters ---------- h : float TNr*r+rHrHrIr-szFancyBboxPatch.set_heightcGsLt|dkr|d\}}}}n |\}}}}||_||_||_||_d|_dS)a Set the bounds of the rectangle. Call signatures:: set_bounds(left, bottom, width, height) set_bounds((left, bottom, width, height)) Parameters ---------- left, bottom : float The coordinates of the bottom left corner of the rectangle. width, height : float The width/height of the rectangle. rrTN)r>rrrrrr.rHrHrIr1s  zFancyBboxPatch.set_boundscCstj|j|j|j|jSr2)r r3 from_boundsrrrrr}rHrHrIrszFancyBboxPatch.get_bbox)rFNrr)N)rrrrrrr rrrdelete_parameterr(rrrr rrrKrrrrr!r#r)r-r1rrrHrHrFrIrs6  D '      rc seZdZdZdZddZejej dddd.fd d Z ddZ ddZ ddZ ejd/ddZddZd0ddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zejd)d*d+Zd,d-ZZS)1FancyArrowPatcha A fancy arrow patch. It draws an arrow using the `ArrowStyle`. The head and tail positions are fixed at the specified start and end points of the arrow, but the size and shape (in display coordinates) of the arrow does not change when the axis is moved or zoomed. Tc Csh|jdurL|j\\}}\}}t|jd|dd|dd|dd|dd St|jd|jdSdS)Nz((gz, z)->(z))()) _posA_posBtyper_path_original)r@rrr]r^rHrHrIr$s 0zFancyArrowPatch.__str__r#rNr$Nsimplearc3r rc  s| dtj| dtjtjfi| |durh|durh|durh||g|_|dur\d}||n(|dur|dur|durd|_ntd||_ ||_ ||_ | |_ ||_ ||| |_| |_d|_dS)ao 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 : `.Patch`, default: None Head and tail patches, respectively. shrinkA, shrinkB : float, default: 2 Shrinking factor 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 : `.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"``. rDrCNrz.Either posA and posB, or path need to providedr)rrrFrr'r(rset_connectionstylerrQrSrVrWrset_arrowstylerr_dpi_cor) r@rZr[rN arrowstyleconnectionstylerQrSrVrWrrrErFrHrIr(+s(I   zFancyArrowPatch.__init__cCs.|dur||jd<|dur$||jd<d|_dS)a Set the begin and end positions of the connecting path. Parameters ---------- posA, posB : None, tuple (x, y) coordinates of arrow tail and arrow head respectively. If `None` use current value. NrrT)rr)r@rZr[rHrHrI set_positionss   zFancyArrowPatch.set_positionscCs||_d|_dS)zn Set the tail patch. Parameters ---------- patchA : `.patches.Patch` TN)rQr)r@rQrHrHrI set_patchAszFancyArrowPatch.set_patchAcCs||_d|_dS)zn Set the head patch. Parameters ---------- patchB : `.patches.Patch` TN)rSr)r@rSrHrHrI set_patchBszFancyArrowPatch.set_patchBcKs:|durtSt|tr*t|fi|n||_d|_dS)aY 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)rLrrQr _connectorr)r@r$rErHrHrIr s!z#FancyArrowPatch.set_connectionstylecCs|jS)z"Return the `ConnectionStyle` used.)r(r}rHrHrIget_connectionstylesz#FancyArrowPatch.get_connectionstylecKs:|durtSt|tr*t|fi|n||_d|_dS)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)rrrQr_arrow_transmuterr)r@r#rErHrHrIr!s zFancyArrowPatch.set_arrowstylecCs|jS)zReturn the arrowstyle object.)r*r}rHrHrIget_arrowstyle szFancyArrowPatch.get_arrowstylecCs||_d|_dSrrrrHrHrIrsz"FancyArrowPatch.set_mutation_scalecCs|jS)z\ Return the mutation scale. Returns ------- scalar r r}rHrHrIr sz"FancyArrowPatch.get_mutation_scalecCs||_d|_dSr r r rHrHrIr%sz#FancyArrowPatch.set_mutation_aspectcCs|jdur|jSdSrrr}rHrHrIr0sz#FancyArrowPatch.get_mutation_aspectcCs2|\}}t|r tj|}||S)z5Return the path of the arrow in the data coordinates.)_get_path_in_displaycoordrcrrmake_compound_pathrJinvertedtransform_path)r@r<rrHrHrIrK5s   zFancyArrowPatch.get_pathcCs|j}|jdurp||jd}||jd}|||f\}}||||j|j|j||j |d}n| |j }| || ||||\}}||fS)s&    z)FancyArrowPatch._get_path_in_displaycoordrz4self.get_transform().transform_path(self.get_path())rcshs dS|d_\}}t|s:|g}|g}t|fddt ||DdS)Nrcs.g|]&\}}||r$jdr$jndfqS)rPNr)r[r5r_rr@rHrIrmsz(FancyArrowPatch.draw..) rrr"r,rcrr rrr)r@rrNrrHr3rIr[s    zFancyArrowPatch.draw) NNNrrNNr r rr)N)N)rrrrrrr rrrr(r%r&r'r r)r!r+rr rrrKr,deprecate_privatize_attributeZget_path_in_displaycoordrrrHrHrFrIrs< f   ' '    rcsteZdZdZddZejejddddfd d Z dddZ ddZ ddZ ddZ ddZfddZZS)ConnectionPatchz>A patch that connects two points (possibly in different axes).cCs(d|jd|jd|jd|jdfS)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)xy1xy2r}rHrHrIrts"zConnectionPatch.__str__r#axesAr$Nrrr$@Fc sd|dur |}||_||_||_||_||_||_tjfdd||| | | | | ||d |d|_dS)a^ Connect point *xyA* in *coordsA* with point *xyB* in *coordsB*. Valid keys are =============== ====================================================== Key Description =============== ====================================================== arrowstyle the arrow style connectionstyle the connection style relpos default is (0.5, 0.5) patchA default is bounding box of the text patchB default is None shrinkA default is 2 points shrinkB default is 2 points mutation_scale default is text size (in points) mutation_aspect default is 1. ? any key for `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 axes 'axes pixels' pixels from lower left corner of 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 :doc:`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) rZr[r#r$rQrSrVrWrrr) r6r7coords1coords2r8axesBr'r(_annotation_clip)r@ZxyAZxyBZcoordsAZcoordsBr8r<r#r$rQrSrVrWrrrrErFrHrIr(xs(R  zConnectionPatch.__init__c Csb|}|dur|j}t|}|dvrB||jjd9}|dd}n2|dkrT|jj}n |dkrf|jj}n|dkrt|j}|\}}|d kr|j }t | |}t | |}| ||fS|d kr|jd kr||jd S||j|j||jjdS|d kr8||}} | t|}| t|}|j }| ||fS|d kr|jj} |d kr^| j|n| j|}|d kr|| j|n| j|}||fS|dkr|jj} |d kr| j|n| j|}|d kr| j|n| j|}||fS|dkr8|j} |d kr| j|n| j|}|d kr&| j|n| j|}||fSt|tjrP| |St|ddS)z,Calculate the pixel position of given point.N)z figure pointsz axes pointsHropixelszfigure fractionzsubfigure fractionz axes fractiondataz offset pointspolarz figure pixelsrzsubfigure pixelsz axes pixelsz) is not a valid coordinate transformation)rrcrrdpir transFigureZtransSubfigure transAxes transDatarrrrxycoords_get_xyrrrZfigbboxrrrrr rQr Transformr) r@rrrs0rYrZrMrrobbrHrHrIrGsd          zConnectionPatch._get_xycCs||_d|_dS)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=rrrHrHrIset_annotation_clips z#ConnectionPatch.set_annotation_clipcCs|jS)zx Return the clipping behavior. See `.set_annotation_clip` for the meaning of the return value. )r=r}rHrHrIget_annotation_clip*sz#ConnectionPatch.get_annotation_clipcCs|j}||j|j|j}||j|j|j}||||j |j |j ||j |d}| ||||||\}}||fS)r0r1)r"rGr6r:r8r7r;r<r)rQrSrVrWr+r rTr)r@r2rZr[rNrrHrHrIr,2s  z)ConnectionPatch._get_path_in_displaycoordcCs|}|s|durX|jdkrX||j|j|j}|jdurD|j}n|j}||sXdS|sn|dur|jdkr||j|j|j }|j dur|j}n|j }||sdSdS)z/Check whether the annotation needs to be drawn.Nr@FT) rLr:rGr6r8rrXr;r7r<)r@rrZxy_pixelrrHrHrI _check_xyDs     zConnectionPatch._check_xycs4|dur||_|r ||s$dSt|dSrW)Z _rendererrrMr'rrrFrHrIr]s zConnectionPatch.draw) NNNrrNNrrr9NF)N)rrrrrr rrrr(rGrKrLr,rMrrrHrHrFrIr5qs, g 9r5)NT)rN)N)Irr$r rfnumbersrr collectionsrnumpyrc matplotlibr,rrrrrr r rr rr bezierr rrrrrrrrNr_enumsrrrdefine_aliasesrr"rrr6rArCrcrnrrrrgetdocr( splitlinesrrrrrrrrr&rr'rLrrrrr5rHrHrHrIs  (( F4\2lb^8*<*y  R{+ sY