3 ƽhE @sddlZddlZddlZddlZddlmZddlZddlZddl Z ddl m Z m Z mZmZmZmZddlmZmZmZmZmZmZmZmZddlmZe jdgdgd gd gd gd Gd dde jZ e j!e Z"xdFD]Z#ej$j%e#e"iqWej&e j'Gddde Z(Gddde Z)Gddde Z*Gddde Z+Gd dde Z,Gd!dde Z-Gd"dde Z.Gd#dde,Z/ej$j%d$j0ej1e/j'j2d%dd&Gd'dde*Z3Gd(dde Z4Gd)dde4Z5Gd*dde4Z6dGd,d-Z7dHd/d0Z8d1d2Z9Gd3d4d4Z:dIdd5d6d7Z;Gd8d9d9e:ZGd>d?d?e:Z?ej$j%ed?Z(d@dAZ)dBdCZ*dDdEZ+dFdGZ,e-j.dHdIZ/e0j1dJdKZ2dLdMZ3dVdNdOZ4dPdQZ5Z6S)WPatchz 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. rFNTc Kstjj||dkrtjd}|dkr*d}| dkr6d} | dkrBd} |dkrTtjd}tjtjd|_d|_|dk r|dk s|dk rt j d |j |n|j ||j |d|_d |_|j||j||j||j||j||j| |j| t| r|j| dS) zQ The following kwarg properties are supported %(Patch)s Nzpatch.linewidthsolidZbuttZmiterzpatch.antialiasedz hatch.colorTzQSetting the 'color' property will override the edgecolor or facecolor properties.r)rArtist__init__mplrcParamsrto_rgba _hatch_color_fillrZ_warn_external set_color set_edgecolor set_facecolor _us_dashes _linewidthset_fill set_linestyle set_linewidthset_antialiased set_hatch set_capstyle set_joinstylelenupdate) selfrrcolorrrrhatchfillcapstyle joinstylekwargsr98/tmp/pip-build-7iwl8md4/matplotlib/matplotlib/patches.pyr)s>              zPatch.__init__cCs.|j}|j}|j|}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_pathZ to_polygonsr0)r2transpathZpolygonsr9r9r: get_vertsas  zPatch.get_vertscCsB|dk r |St|jtr |j}n|jddkr6d}n|j}|S)Nr) isinstanceZ_pickerr get_edgecolor get_linewidth)r2radius_radiusr9r9r:_process_radiusos zPatch._process_radiusc sj\}}|dk r||fSjjj}|dk rjj}tj|tjk\}|dd}t ttj ||tj ||}n jg}t fdd|D}|ifS)z Test whether the mouse event occurred in the patch. Returns ------- (bool, empty dict) Nrc3s(|] }|jjjfjVqdS)N)contains_pointxyr;).0subpath) mouseeventrDr2r9r: sz!Patch.contains..) Z_default_containsrFr<codesverticesnpwhererMOVETOmapsplitany) r2rLrDinsideinforNrOZidxsZsubpathsr9)rLrDr2r:contains{s       zPatch.containscCs |j|}|jj||j|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 )rFr<rGr;)r2ZpointrDr9r9r:rGs-  zPatch.contains_pointcCs |j|}|jj||j|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`. )rFr<contains_pointsr;)r2pointsrDr9r9r:rYs  zPatch.contains_pointscCsvtjj|||j|_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |j |j |j|j|_dS)N)rr update_from _edgecolor _facecolor_original_edgecolor_original_facecolorr#_hatchr"r'r+r( set_transformget_data_transformZis_transform_setZ _transformSet)r2otherr9r9r:r[s zPatch.update_fromcCs|jj|jS)zU Return the `Patch`'s axis-aligned extents as a `~.transforms.Bbox`. )r< get_extentsr;)r2r9r9r:rdszPatch.get_extentscCs|jtjj|S)z;Return the `~.transforms.Transform` applied to the `Patch`.)get_patch_transformrrr;)r2r9r9r:r;szPatch.get_transformcCs tjj|S)zo Return the `~.transforms.Transform` mapping data coordinates to physical coordinates. )rrr;)r2r9r9r:rbszPatch.get_data_transformcCstjS)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 IdentityTransform)r2r9r9r:re s zPatch.get_patch_transformcCs|jS)z0Return whether antialiasing is used for drawing.) _antialiased)r2r9r9r:get_antialiasedszPatch.get_antialiasedcCs|jS)zReturn the edge color.)r\)r2r9r9r:rBszPatch.get_edgecolorcCs|jS)zReturn the face color.)r])r2r9r9r: get_facecolor szPatch.get_facecolorcCs|jS)z Return the line width in points.)r()r2r9r9r:rC$szPatch.get_linewidthcCs|jS)zReturn the linestyle.) _linestyle)r2r9r9r: get_linestyle(szPatch.get_linestylecCs"|dkrtjd}||_d|_dS)z{ Set whether to use antialiased rendering. Parameters ---------- b : bool or None Nzpatch.antialiasedT)rr rgstale)r2rr9r9r:r,,s zPatch.set_antialiasedcCs^d}|dkr8tjds$|j s$|jr0tjd}nd}d}tj||j|_|rT|j|_d|_ dS)NTzpatch.force_edgecolorzpatch.edgecolornoneF) rr r# _edge_defaultrr!_alphar\r"rl)r2r3set_hatch_colorr9r9r:_set_edgecolor9s  zPatch._set_edgecolorcCs||_|j|dS)zz Set the patch edge color. Parameters ---------- color : color or None or 'auto' N)r^rq)r2r3r9r9r:r%HszPatch.set_edgecolorcCs:|dkrtjd}|jr|jnd}tj|||_d|_dS)Nzpatch.facecolorrT)rr r#rorr!r]rl)r2r3alphar9r9r:_set_facecolorSs  zPatch._set_facecolorcCs||_|j|dS)zp Set the patch face color. Parameters ---------- color : color or None N)r_rs)r2r3r9r9r:r&ZszPatch.set_facecolorcCs|j||j|dS)a Set both the edgecolor and the facecolor. Parameters ---------- c : color See Also -------- Patch.set_facecolor, Patch.set_edgecolor For setting the edge or face color individually. N)r&r%)r2cr9r9r:r$es zPatch.set_colorcs(tj||j|j|j|jdS)N)super set_alpharsr_rqr^)r2rr) __class__r9r:rvus  zPatch.set_alphacCsZ|dkr$tjd}|dkr$tjd}t||_|j\}}tj|||j\|_|_d|_ dS)zu Set the patch linewidth in points. Parameters ---------- w : float or None Nzpatch.linewidthzaxes.linewidthT) rr floatr(r'mlines _scale_dashes _dashoffset_dashesrl)r2woffsetrr9r9r:r+|s    zPatch.set_linewidthcCsH|dkr d}||_tj|\}}|_tj|||j\|_|_d|_dS)a Set the patch linestyle. =========================== ================= linestyle description =========================== ================= ``'-'`` or ``'solid'`` solid line ``'--'`` or ``'dashed'`` dashed line ``'-.'`` or ``'dashdot'`` dash-dotted line ``':'`` or ``'dotted'`` dotted line =========================== ================= Alternatively a dash tuple of the following form can be provided:: (offset, onoffseq) where ``onoffseq`` is an even length tuple of on and off ink in points. Parameters ---------- ls : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...} The line style. NrT) rjryZ_get_dash_patternr'rzr(r{r|rl)r2rr~r9r9r:r*szPatch.set_linestylecCs,t||_|j|j|j|jd|_dS)zh Set whether to fill the patch. Parameters ---------- b : bool TN)boolr#rsr_rqr^rl)r2br9r9r:r)s   zPatch.set_fillcCs|jS)z#Return whether the patch is filled.)r#)r2r9r9r:get_fillszPatch.get_fillcCstjj|||_d|_dS)zv Set the capstyle. Parameters ---------- s : {'butt', 'round', 'projecting'} TN)rrcsetupZvalidate_capstyle _capstylerl)r2sr9r9r:r.s zPatch.set_capstylecCs|jS)zReturn the capstyle.)r)r2r9r9r: get_capstyleszPatch.get_capstylecCstjj|||_d|_dS)zs Set the joinstyle. Parameters ---------- s : {'miter', 'round', 'bevel'} TN)rrZvalidate_joinstyle _joinstylerl)r2rr9r9r:r/s zPatch.set_joinstylecCs|jS)zReturn the joinstyle.)r)r2r9r9r: get_joinstyleszPatch.get_joinstylecCs||_d|_dS)a Set the hatching pattern. *hatch* can be one of:: / - diagonal hatching \ - back diagonal | - vertical - - horizontal + - crossed x - crossed diagonal o - small circle O - large circle . - dots * - stars Letters can be combined, in which case all the specified hatchings are done. If same letter repeats, it increases the density of hatching of that pattern. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. Parameters ---------- hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'} TN)r`rl)r2r4r9r9r:r-szPatch.set_hatchcCs|jS)zReturn the hatching pattern.)r`)r2r9r9r: get_hatchszPatch.get_hatchccs6|jd|j|j}|j|jdd|j}|jddkr@d}|j||j|j|j |j |j |j |j |j|j|j||j|j|j|j|j|j|jr|j|j|j|j|jdk r|j|j|jr ddlm}||j|}t j!|j"|V|j#|j$dd|_%dS) ac ``draw()`` helper factored out for sharing with `FancyArrowPatch`. Yields a callable ``dp`` such that calling ``dp(*args, **kwargs)`` is equivalent to calling ``renderer1.draw_path(gc, *args, **kwargs)`` where ``renderer1`` and ``gc`` have been suitably set from ``renderer`` and the artist's properties. patchT)ZisRGBAr@rN)PathEffectRendererF)&Z open_groupZget_gidZnew_gcZset_foregroundr\r(r+Z set_dashesr{r|r.rr/rr,rgZ _set_gc_clipZset_urlZ_urlZset_snapZget_snaprvror`r-rpr"Zget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsr functoolspartial draw_pathZrestoreZ close_grouprl)r2renderergcrrr9r9r:_bind_draw_path_function s6              zPatch._bind_draw_path_functioncCs~|js dStj|ddZ|j|D}|j}|j}|j|}|j}||||jdr`|jndWdQRXWdQRXdS)Nr)r{r@) get_visiblerZ _setattr_cmrr<r;Ztransform_path_non_affineZ get_affiner])r2rrr> transformZtpathaffiner9r9r:draw?s  z Patch.drawcCs tddS)zReturn the path of this patch.zDerived must overrideN)NotImplementedError)r2r9r9r:r<QszPatch.get_pathcCs|jj|jS)N)r<rdr;)r2rr9r9r:get_window_extentUszPatch.get_window_extentcCs$|j|d}|j|d}||fS)z)Convert x and y units for a tuple (x, y).rr)convert_xunitsconvert_yunits)r2xyrHrIr9r9r:_convert_xy_unitsXszPatch._convert_xy_units) NNNNNNNTNN)N)N)N)N)7__name__ __module__ __qualname____doc__zorderryZLine2DZvalidCapZ validJoinrnrr?rFrXrGrYr[rdr;rbrerhrBrirCrkr,rqr%rsr&r$rvr+r*r)rpropertyr5r.rr/rr-r contextlibcontextmanagerrrallow_rasterizationrr<rr __classcell__r9r9)rwr:rsj  .  2      "    4 r RectangleCircleRegularPolygonPolygonWedgeArrow FancyArrow CirclePolygonEllipseArcFancyBboxPatchc@seZdZddZejddejdddZej dZ dd Z d d Z d d Z ddZddZddZddZddZddZdS)ShadowcCsdt|jS)Nz Shadow(%s))strr)r2r9r9r:__str__jszShadow.__str__z3.3propsNcKsltj|||_|dkr>dtjtj|jj}||dd}|||_|||_ |_ t j |_ |jdS)aP 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. props : dict *deprecated (use kwargs instead)* Properties of the shadow patch. **kwargs Properties of the shadow patch. Supported keys are: %(Patch)s Ng333333?g?)rrrr)rrrrPasarrayrZto_rgbri_props_ox_oyr Affine2D_shadow_transform_update)r2roxoyrr8r3r9r9r:rms   zShadow.__init__cCs6|j|j|jtj|jjtj |j|jdS)N) r[rZ set_zorderrPZ nextafterrinfr1r)r2r9r9r:rs zShadow._updatecCs.|j|j}|j|j}|jjj||dS)N)points_to_pixelsrrrclear translate)r2rrrr9r9r:_update_transforms  zShadow._update_transformcCs|jS)N)r)r2r9r9r:_get_oxszShadow._get_oxcCs ||_dS)N)r)r2rr9r9r:_set_oxszShadow._set_oxcCs|jS)N)r)r2r9r9r:_get_oyszShadow._get_oycCs ||_dS)N)r)r2rr9r9r:_set_oyszShadow._set_oycCs |jjS)N)rr<)r2r9r9r:r<szShadow.get_pathcCs|jj|jS)N)rrer)r2r9r9r:reszShadow.get_patch_transformcCs|j|tj||dS)N)rrr)r2rr9r9r:rs z Shadow.draw)N)rrrrrZ_delete_parameterrdedent_interpdrZ_deprecate_privatize_attributerrrrrrrr<rerr9r9r9r:ris % rc@seZdZdZddZejd,ddZddZd d Z d d Z d dZ ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*ZeeeZd+S)-ra 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 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_heightangle)r2parsfmtr9r9r:rszRectangle.__str__cKsbtj|f||d|_|d|_||_||_|j|j|_|j|j|_t||_ t j |_ 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 *xy*. Other Parameters ---------------- **kwargs : `.Patch` properties %(Patch)s rrN) rrrrrr_x1_y1rxrr rf_rect_transform)r2rwidthheightrr8r9r9r:rs   zRectangle.__init__cCstjS)z%Return the vertices of the rectangle.)runit_rectangle)r2r9r9r:r<szRectangle.get_pathcCsX|j\}}}}tjj||||}tj}|j|||jtj||_|j|7_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. N) _convert_unitsr Bbox from_extentsrZrotate_deg_aroundrBboxTransformTor)r2x0y0x1y1bboxZ rot_transr9r9r:_update_patch_transforms  z!Rectangle._update_patch_transformcCs|j|j|_dS)N)rrr)r2r9r9r: _update_x1 szRectangle._update_x1cCs|j|j|_dS)N)rrr)r2r9r9r: _update_y1 szRectangle._update_y1cCs<|j|j}|j|j}|j|j}|j|j}||||fS)z Convert bounds of the rectangle.)rrrrrr)r2rrrrr9r9r:rs     zRectangle._convert_unitscCs|j|jS)N)rr)r2r9r9r:reszRectangle.get_patch_transformcCs|jS)z,Return the left coordinate of the rectangle.)r)r2r9r9r:get_xszRectangle.get_xcCs|jS)z.Return the bottom coordinate of the rectangle.)r)r2r9r9r:get_yszRectangle.get_ycCs |j|jfS)z>Return the left and bottom coords of the rectangle as a tuple.)rr)r2r9r9r:get_xy#szRectangle.get_xycCs|jS)z"Return the width of the rectangle.)r)r2r9r9r: get_width'szRectangle.get_widthcCs|jS)z#Return the height of the rectangle.)r)r2r9r9r: get_height+szRectangle.get_heightcCs||_|jd|_dS)z)Set the left coordinate of the rectangle.TN)rrrl)r2rHr9r9r:set_x/szRectangle.set_xcCs||_|jd|_dS)z+Set the bottom coordinate of the rectangle.TN)rrrl)r2rIr9r9r:set_y5szRectangle.set_ycCs&|\|_|_|j|jd|_dS)z Set the left and bottom coordinates of the rectangle. Parameters ---------- xy : (float, float) TN)rrrrrl)r2rr9r9r:set_xy;s zRectangle.set_xycCs||_|jd|_dS)zSet the width of the rectangle.TN)rrrl)r2r}r9r9r: set_widthHszRectangle.set_widthcCs||_|jd|_dS)z Set the height of the rectangle.TN)rrrl)r2hr9r9r: set_heightNszRectangle.set_heightcGs\t|dkr|d\}}}}n |\}}}}||_||_||_||_|j|jd|_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)r0rrrrrrrl)r2argslrr}rr9r9r: set_boundsTs  zRectangle.set_boundscCs"|j\}}}}tjj||||S)zReturn the `.Bbox`.)rr rr)r2rrrrr9r9r:get_bboxkszRectangle.get_bboxN)r)rrrrrrrrr<rrrrrerrrrrrrrrrrrrrr9r9r9r:rs. " c@seZdZdZddZejdddZdd Ze d d Z e j d d Z e d dZ e j ddZ e ddZ e j ddZ e ddZej ddZddZddZdS)rzA regular polygon patch.cCs(d}||jd|jd|j|j|jfS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)_xy _numVerticesrE _orientation)r2rr9r9r:rvszRegularPolygon.__str__rcKsH||_||_||_||_tj||_tj|_ |j t j |f|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)s N) rrrrErZunit_regular_polygon_pathr r_poly_transformrrr)r2r numVerticesrD orientationr8r9r9r:r{s  zRegularPolygon.__init__cCs&|jjj|jj|jj|jdS)N)rrscalerDrotaterrr)r2r9r9r:rs z RegularPolygon._update_transformcCs|jS)N)r)r2r9r9r:rszRegularPolygon.xycCs||_|jdS)N)rr)r2rr9r9r:rscCs|jS)N)r)r2r9r9r:rszRegularPolygon.orientationcCs||_|jdS)N)rr)r2rr9r9r:rscCs|jS)N)rE)r2r9r9r:rDszRegularPolygon.radiuscCs||_|jdS)N)rEr)r2rDr9r9r:rDscCs|jS)N)r)r2r9r9r: numverticesszRegularPolygon.numverticescCs ||_dS)N)r)r2rr9r9r:rscCs|jS)N)r)r2r9r9r:r<szRegularPolygon.get_pathcCs|j|jS)N)rr)r2r9r9r:resz"RegularPolygon.get_patch_transformN)rr)rrrrrrrrrrrsetterrrDrr<rer9r9r9r:rss     c@s:eZdZdZdZddZejddZddZ d d Z d S) PathPatchzA general polycurve path patch.TcCs&d}|t|jjft|jjdS)NzPathPatch%d((%g, %g) ...)r)r0rrOtuple)r2rr9r9r:rszPathPatch.__str__cKstj|f|||_dS)zl *path* is a `~.path.Path` object. Valid keyword arguments are: %(Patch)s N)rrr)r2r>r8r9r9r:rs zPathPatch.__init__cCs|jS)N)r)r2r9r9r:r<szPathPatch.get_pathcCs ||_dS)N)r)r2r>r9r9r:set_pathszPathPatch.set_pathN) rrrrrnrrrrr<rr9r9r9r:rs  rc@s^eZdZdZddZejdddZddZd d Z d d Z d dZ ddZ e e e ddZdS)rzA general polygon patch.cCs&d}|t|jjft|jjdS)NzPolygon%d((%g, %g) ...)r)r0rrOr)r2rr9r9r:rszPolygon.__str__TcKs"tj|f|||_|j|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)s N)rr_closedr)r2rclosedr8r9r9r:rs zPolygon.__init__cCs|jS)zGet the `.Path` of the polygon.)r)r2r9r9r:r<szPolygon.get_pathcCs|jS)z%Return whether the polygon is closed.)r)r2r9r9r: get_closedszPolygon.get_closedcCs4|jt|krdSt||_|j|jd|_dS)z Set whether the polygon is closed. Parameters ---------- closed : bool True if the polygon is closed NT)rrrrrl)r2rr9r9r: set_closeds  zPolygon.set_closedcCs|jjS)z Get the vertices of the path. Returns ------- (N, 2) numpy array The coordinates of the vertices. )rrO)r2r9r9r:rs zPolygon.get_xycCstj|}|j\}}|jrT|dks>|dkr||d|dkjr|tj||dgg}n(|dkr||d|dkjr||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. rrN)rTrr) rPrshaperrU concatenateallrrrl)r2rZnverts_r9r9r:r"s  $ zPolygon.set_xyz/The vertices of the path as (N, 2) numpy array.)docN)T)rrrrrrrrr<rrrrrrr9r9r9r:rs  !c@s`eZdZdZddZejdddZddZd d Z d d Z d dZ ddZ ddZ ddZdS)rzWedge shaped patch.cCs0|jd|jd|j|j|j|jf}d}||S)Nrrz|jdd}|rtdtj|||||f|||_||_dS)a Parameters ---------- xy : (float, float) The center of the ellipse. width : float The length of the horizontal axis. height : float The length of the vertical axis. angle : float Rotation of the ellipse in degrees (counterclockwise). theta1, theta2 : float, 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 : `.Patch` properties Most `.Patch` properties are supported as keyword arguments, with the exception of *fill* and *facecolor* because filling is not supported. %(Patch)s r5FzArc objects can not be filledN) setdefaultr'rrr r ) r2rrrrr r r8r5r9r9r:r"s % z Arc.__init__cs&t|dstd|jsdS|j|j|j}|j|j}dd}|j}|j }||kr||kop|d|dk r||j||}||j ||}|j }|j ||f|j d\}} d} || kr| | krt j |||_tj||Sd d fd d} tj|jj|jj} t jj| } t}xvt| jdd| jddD]T\}}| ||}|j\}}tjtj||dd}|j |||k||k@qHWt!||g}|}tj"|}| j#tj$|tj%|f}|j}x>|D]6}|rt j ||d|_tj||d}nd}|}qW||_dS)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 bounding box are located. (This is done be performing an inverse transformation on the axes bbox such that it is relative to the unit circle -- this makes the intersection calculation much easier than doing rotated ellipse intersection directly). This uses the "line intersecting a circle" algorithm from: Vince, John. *Geometry for Computer Graphics: Formulae, Examples & Proofs.* London: Springer-Verlag, 2005. 2. The angles of each of the intersection points are calculated. 3. Proceeding counterclockwise starting in the positive x-direction, each of the visible arc-segments between the pairs of vertices are drawn using the Bezier arc approximation technique implemented in `.Path.arc`. axesz'Arcs can only be used in Axes instancesNcSs@tj|}tj|}tj|}tjtj|||}|ddS)Nih)rPdeg2radcossinrad2degr)thetarrHrIZsthetar9r9r: theta_stretchs    zArc.draw..theta_stretchihrg?gJؿ>g?c Ss||}||}||||}||||}||}||} | dkrtjd|} tj| } tj||| || || |t|| |g||| || || |t|| |ggStjdSdS)Ngrrr)rr)rPcopysignsqrtr&rr%) rrrrrrZdr2DZD2ZdiscrimZsign_dyZ sqrt_discrimr9r9r:line_circle_intersects   z'Arc.draw..line_circle_intersectc sd}||kr||}}n ||}}||kr6||}}n ||}}||||} | j\} } | ||| k| ||k@||| k@| ||k@S)Ng& .>)T) rrrrepsilonZx0eZx1eZy0eZy1eZxysxsZys)rEr9r:segment_circle_intersects     z*Arc.draw..segment_circle_intersectrFT)rrg\! Ag\!Ar)&hasattr RuntimeErrorrr3rrrrr r rbrrrrrrr rr;rr;invertedrZ transformedsetziprOrFrPr?rr1sortedr<rGr=r>)r2rrrrAr r Zdata_to_screen_transZpwidthZpheightZ inv_errorrIZbox_path_transformZbox_pathZthetasZp0p1rrHrIr@Z last_thetaZ theta1_radrVZ path_originalr9)rEr:rPs\/        (       zArc.drawN)r8r8r9) rrrrrrrrrrrr9r9r9r:rs   ,TcCs|dkr i}|j}|jdd}|j|}|j|}t|j|d|j|df|j||j||t j dd}|j ||j |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. NpadrF)rrrr5rclip_on) copypoprrrrrrrr rfr1r)rrrr5rRrr r9r9r: bbox_artists     rWkcCs@t|j|jf|j|j|ddd}|dk r2|j||j|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)rrrrr5rTN)rrrrrrar)rrr3r=r r9r9r: draw_bboxs   rYcCsdjdjtdjt|S)z A helper function for the _Style class. Given the dictionary of {stylename: styleclass}, return a string rep of the list of keys. Used to update the documentation. z[{}]|z '{}' )formatjoinrSrP)Z_stylesr9r9r:_simpleprint_styles sr]c@s<eZdZdZddZeddZeddZedd Zd 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 Ks|jddjd}|dj}y|j|}Wn0tk r\}ztd||WYdd}~XnXy(dd|d dD}d d |D}Wn0tk r}ztd ||WYdd}~XnX|j||f|S) z>Return the instance of the subclass with the given style name. ,rzUnknown style : %sNcSsg|]}|jdqS)=)rT)rJcsr9r9r: =sz"_Style.__new__..rcSsi|]\}}t||qSr9)rx)rJrXrr9r9r: >sz"_Style.__new__..zIncorrect style argument : %s)replacerTlower _style_listKeyErrorr'r1) clsZ stylenamekwZ_list_name_clserrZ _args_pair_argsr9r9r:__new__/s   z_Style.__new__cCs|jS)z(Return a dictionary of available styles.)rh)rjr9r9r: get_stylesFsz_Style.get_stylescsdddt|jjD}ddt|Ddjdd D}d jd |djd d t|d D|ffdd|ddD|d f}tj|ddS)z5Return the available styles as pretty-printed string.ClassNameAttrscSs:g|]2\}}|jd|dttj|ddp2dfqS)z``rNoner)rrinspect signature)rJnamerjr9r9r:rdOsz(_Style.pprint_styles..cSsg|]}tdd|DqS)css|]}t|VqdS)N)r0)rJcellr9r9r:rMVsz2_Style.pprint_styles...)max)rJcolumnr9r9r:rdVsz css|]}d|VqdS)rbNr9)rJclr9r9r:rMWsz'_Style.pprint_styles..r.r`css|]\}}|j|VqdS)N)ljust)rJryr|r9r9r:rM[srcs&g|]}djddt|DqS)z css|]\}}|j|VqdS)N)r})rJryr|r9r9r:rM]sz2_Style.pprint_styles...)r\rO)rJrow)col_lenr9r:rd]srNr_r)prefixrrrsrt)rz )rPrhitemsrOr\textwrapindent)rjtableZtable_formatstrZ rst_tabler9)rr: pprint_stylesKs  z_Style.pprint_stylescCs,t||jstd||jf||j|<dS)zRegister a new style.z%s must be a subclass of %sN) issubclass_Baser'rh)rjrxstyler9r9r:registerds  z_Style.registerN) rrrrrp classmethodrqrrr9r9r9r:r^)s   r^)rxcCs.|dkrtjt||dS|||p(|jj<|S)z=Class decorator that stashes a class in a (style) dictionary.N)rx)rr_register_stylerrg)Z style_listrjrxr9r9r:rmsrc@seZdZdZiZGdddZeeGdddeZeeGdddeZeeGdd d eZ eeGd d d e Z eeGd d d eZ eeGdddeZ eeGdddeZ eeGdddeZeeGdddeZdS)BoxStyleat `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. %(AvailableBoxstyles)s An instance of any boxstyle class is an callable object, whose call signature is:: __call__(self, x0, y0, width, height, mutation_size, aspect_ratio=1.) and returns a `.Path` instance. *x0*, *y0*, *width* and *height* specify the location and size of the box to be drawn. *mutation_scale* determines the overall size of the mutation (by which I mean the transformation of the rectangle to the fancy box). *mutation_aspect* determines the aspect-ratio of the mutation. c@s"eZdZdZddZdddZdS) zBoxStyle._Basea Abstract base class for styling of `.FancyBboxPatch`. This class is not an artist itself. The `__call__` method returns the `~matplotlib.path.Path` for outlining the fancy box. The actual drawing is handled in `.FancyBboxPatch`. Subclasses may only use parameters with default values in their ``__init__`` method because they must be able to be initialized without arguments. Subclasses must implement the `transmute` method. It receives the enclosing rectangle *x0, y0, width, height* as well as the *mutation_size*, which scales the outline properties such as padding. It returns the outline of the fancy box as `.path.Path`. cCs tddS)z7Return the `~.path.Path` outlining the given rectangle.zDerived must overrideN)r)r2rrrr mutation_sizer9r9r: transmuteszBoxStyle._Base.transmute?c Csz|dk rd||||}}|j|||||}|j|j}} |dddf||dddf<t|| S|j|||||SdS)a Given the location and size of the box, return the path of the box around it. Parameters ---------- x0, y0, width, height : float Location and size of the box. mutation_size : float A reference scale for the mutation. aspect_ratio : float, default: 1 Aspect-ratio for the mutation. Returns ------- `~matplotlib.path.Path` Nr)rrOrNr) r2rrrrr aspect_ratior>rOrNr9r9r:__call__s  zBoxStyle._Base.__call__N)r)rrrrrrr9r9r9r:rsrcs*eZdZdZdfdd ZddZZS)zBoxStyle.Squarez A square box. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. 333333?cs||_tjdS)N)rRrur)r2rR)rwr9r:rszBoxStyle.Square.__init__c Csr||j}|d||d|}}||||}}||||}}t||f||f||f||f||fgddS)NrT)r)rRr) r2rrrrrrRrrr9r9r:rs  "zBoxStyle.Square.transmute)r)rrrrrrrr9r9)rwr:Squares rcs*eZdZdZdfdd ZddZZS)zBoxStyle.Circlez A circular box. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. 333333?cs||_tjdS)N)rRrur)r2rR)rwr9r:rszBoxStyle.Circle.__init__cCs`||j}|d||d|}}||||}}tj||d||dft||dS)Nr)rRrZcirclerz)r2rrrrrrRr9r9r:rs  zBoxStyle.Circle.transmute)r)rrrrrrrr9r9)rwr:rs rcs*eZdZdZdfdd ZddZZS)zBoxStyle.LArrowz A box in the shape of a left-pointing arrow. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. 333333?cs||_tjdS)N)rRrur)r2rR)rwr9r:r szBoxStyle.LArrow.__init__c Cs||j}|d||d|}}||||}}||||}}||d} | d} ||d}t|| |f||f||f|| |f|| || f|| || f|| || f|| |f|| |fg ddS)Nrgffffff?T)r)rRr) r2rrrrrrRrrrdxxr9r9r:r s   "zBoxStyle.LArrow.transmute)r)rrrrrrrr9r9)rwr:LArrows rcs*eZdZdZdfdd ZddZZS)zBoxStyle.RArrowz A box in the shape of a right-pointing arrow. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. 333333?cstj|dS)N)rur)r2rR)rwr9r:r*szBoxStyle.RArrow.__init__cCsFtjj||||||}d|||jdddf|jdddf<|S)Nrr)rrrrO)r2rrrrrpr9r9r:r-s  ,zBoxStyle.RArrow.transmute)r)rrrrrrrr9r9)rwr:RArrow s rcs*eZdZdZdfdd ZddZZS)zBoxStyle.DArrowz A box in the shape of a two-way arrow. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. 333333?cs||_tjdS)N)rRrur)r2rR)rwr9r:r@szBoxStyle.DArrow.__init__c Cs||j}|d|}||||}}||||}}||d} | d} ||d}t|| |f||f||| f|| | || f||| f||f|| |f|| || f|| || f|| || f|| |f|| |fg ddS)Nrgffffff?T)r)rRr) r2rrrrrrRrrrrr9r9r:rDs     zBoxStyle.DArrow.transmute)r)rrrrrrrr9r9)rwr:DArrow3s rcs*eZdZdZdfdd ZddZZS) zBoxStyle.Rounda A box with round corners. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. rounding_size : float, default: *pad* Radius of the corners. 333333?Ncs||_||_tjdS)N)rR rounding_sizerur)r2rRr)rwr9r:rgszBoxStyle.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| | } | S)Nr)rRrrrRrCURVE3r) r2rrrrrrRdrrrcpcomr>r9r9r:rls:        zBoxStyle.Round.transmute)rN)rrrrrrrr9r9)rwr:Round[s rcs*eZdZdZdfdd ZddZZS) zBoxStyle.Round4z A box with rounded edges. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. rounding_size : float, default: *pad*/2 Rounding of edges. 333333?Ncs||_||_tjdS)N)rRrrur)r2rRr)rwr9r:rszBoxStyle.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)Ng@r)rRrrrRZCURVE4r) r2rrrrrrRrrrrrr>r9r9r:rs,  """"      zBoxStyle.Round4.transmute)rN)rrrrrrrr9r9)rwr:Round4s rcs2eZdZdZd fdd ZddZdd ZZS) zBoxStyle.Sawtootha A box with a sawtooth outline. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. tooth_size : float, default: *pad*/2 Size of the sawtooth. 333333?Ncs||_||_tjdS)N)rR tooth_sizerur)r2rRr)rwr9r:rszBoxStyle.Sawtooth.__init__cCsR||j}|jdkr$|jd|}n |j|}|d}|d||}|d||}tt|||dd} ||| } tt|||dd} ||| } ||||||}}||||} }|f||| dtj| d| |f}|f||||||g| ||f}| f| || | || g| | |f}|f||| dtj| d||f}| f| || dtj| d||f}|f||||||g| ||f}|f||||||g| ||f}|f||| dtj| d||f}t||t||t||t|||d|dff}|S)Ng?rr)rRrintroundrPZarangerO)r2rrrrrrRrZ 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_verticesr9r9r:_get_sawtooth_verticessV             z(BoxStyle.Sawtooth._get_sawtooth_verticescCs"|j|||||}t|dd}|S)NT)r)rr)r2rrrrrrr>r9r9r:r' s  zBoxStyle.Sawtooth.transmute)rN)rrrrrrrrr9r9)rwr:Sawtooths Jrcs*eZdZdZdfdd ZddZZS) zBoxStyle.Roundtootha  A box with a rounded sawtooth outline. Parameters ---------- pad : float, default: 0.3 The amount of padding around the original box. tooth_size : float, default: *pad*/2 Size of the sawtooth. 333333?Ncstj||dS)N)rur)r2rRr)rwr9r:r9 szBoxStyle.Roundtooth.__init__cCs\|j|||||}tj||dgg}tjgtjtjgt|ddtjg}t||S)Nrrr)rrPrrrRrr0r)r2rrrrrrrNr9r9r:r< s" zBoxStyle.Roundtooth.transmute)rN)rrrrrrrr9r9)rwr: Roundtooth- s rN)rrrrrhrrrrrrrrrrrr9r9r9r:rus* 8 '<3`rc@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 %(AvailableConnectorstyles)s An instance of any connection style class is an callable object, whose call signature is:: __call__(self, posA, posB, patchA=None, patchB=None, shrinkA=2., shrinkB=2.) and it returns a `.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|\|_|_dS)N)rHrI)r2rr9r9r:r} sz*ConnectionStyle._Base.SimpleEvent.__init__N)rrrrr9r9r9r: SimpleEvent| srcsr@fdd}yt||\}}Wntk r:|}YnX|}rfdd}yt||\}}Wntk rz|}YnX|}|S)aI Clip the path to the boundary of the patchA and patchB. The starting point of the path needed to be inside of the patchA and the end point inside the patch B. The *contains* methods of each patch object is utilized to test if the point is inside the path. cstjj|}j|dS)Nr)rrrrX) xy_displayxy_event)patchAr9r:insideA s z,ConnectionStyle._Base._clip..insideAcstjj|}j|dS)Nr)rrrrX)rr)patchBr9r:insideB s z,ConnectionStyle._Base._clip..insideB)rr')r2r>rrrr"r#rr9)rrr:_clip s     zConnectionStyle._Base._clipcCs|r@t|jd|f}yt||\}}Wntk r>YnX|rt|jd|f}yt||\}}Wntk r~YnX|S)z] Shrink the path by fixed size (in points) with shrinkA and shrinkB. rrr)rrOrr')r2r>shrinkAshrinkBrr"rr#r9r9r:_shrink szConnectionStyle._Base._shrink@Nc Cs,|j||}|j|||}|j|||} | S)z Call the *connect* method to create a path between *posA* and *posB*; then clip and shrink the path. )connectrr) r2posAposBrrrrr>Z clipped_pathZ shrunk_pathr9r9r:r s zConnectionStyle._Base.__call__)rrNN)rrrrrrrrr9r9r9r:ro s  #rc@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. cCs ||_dS)zE *rad* curvature of the curve. N)rad)r2rr9r9r:r szConnectionStyle.Arc3.__init__cCs|\}}|\}}||d||d}}||||} } |j} || | || | } } ||f| | f||fg}tjtjtjg}t||S)Ng@)rrrRr)r2rrrrx2y2Zx12Zy12rrfr,cyrOrNr9r9r:r s zConnectionStyle.Arc3.connectN)r)rrrrrrr9r9r9r:Arc3 s rc@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)r2rrr9r9r:r s zConnectionStyle.Angle3.__init__c Cs|\}}|\}}tjtj|j}tjtj|j}tjtj|j} tjtj|j} t||||||| | \} } ||f| | f||fg} tjtj tj g}t| |S)N) mathr=radiansrr>rr rrRr)r2rrrrrrcosAsinAcosBsinBr,rrOrNr9r9r:r s zConnectionStyle.Angle3.connectN)rr)rrrrrrr9r9r9r:Angle3 s rc@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*. rrcCs||_||_||_dS)z *angleA* starting angle of the path *angleB* ending angle of the path *rad* rounding radius of the edge N)rrr)r2rrrr9r9r:r s zConnectionStyle.Angle.__init__c Csp|\}}|\}}tjtj|j}tjtj|j}tjtj|j} tjtj|j} t||||||| | \} } ||fg} tjg}|j dkr| j | | f|j tj n|| || }}t j ||}|j |}|| || }}t j ||}|j |}| j| ||| ||f| | f| ||| ||fg|jtj tjtjg| j ||f|j tj t| |S)Ng)rr=rrr>rr rrRrappendrrPrextendr)r2rrrrrrrrrrr,rrOrNdx1dy1Zd1f1dx2dy2Zd2f2r9r9r:r% s4        zConnectionStyle.Angle.connectN)rrr)rrrrrrr9r9r9r:Angle s rc@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*. rNcCs"||_||_||_||_||_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)rrarmAarmBr)r2rrrrrr9r9r:rR s zConnectionStyle.Arc.__init__cCsv|\}}|\}}||fg}g}tjg} |jrtjtj|j} tjtj|j} |j|j} |j || | || | f|j} |j || | || | f|j rtjtj|j } tjtj|j }||j | ||j |}}|rl|d\}}||||}}||||d}|j ||j||||j||f|j || j tj tjtjgn2|d\}}||||}}||||d}||j} || |||| ||f||fg}|rR|d\}}||||}}||||d}|j ||j||||j||f|j || j tj tjtjg|j ||f| j tj t|| S)Nrg?rrr)rrRrrr=rrr>rrrrrrr)r2rrrrrrrOZroundedrNrrdrrZx_armBZy_armBZxpZyprrddr9r9r:rk sZ            zConnectionStyle.Arc.connect)rrNNr)rrrrrrr9r9r9r:rH 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. 333333?NcCs||_||_||_||_dS)a Parameters ---------- armA : float minimum length of armA armB : float minimum length of armB fraction : float a fraction of the distance between two points that will be added to armA and armB. angle : float or None angle of the connecting line (if None, parallel to A and B) N)rrfractionr)r2rrrrr9r9r:r szConnectionStyle.Bar.__init__cCs|\}}|\}}\}}tj||||} ||||} } | | | | d} | | | | } }|j|j}}|jdk rtj|j}| |}| tj|}| tj|}||tj|||tj|}}||}||||} } | | | | d}| || |} }t ||}|j | |}|||||| }}|||||| }}||f||f||f||fg}t j t j t j t j g}t ||S)Ng?)ratan2rrrrPr<r>r=rzrrrRr)r2rrrrZx20Zy20rrr rrrddxddyrrZtheta0ZdthetadlZdLZdd2armrZcx1Zcy1Zcx2Zcy2rOrNr9r9r:r s<  &  zConnectionStyle.Bar.connect)rrrN)rrrrrrr9r9r9r:Bar s rN) rrrrrhrrrrrrrr9r9r9r:rH s#Q#%=]rc CsL||||}}|||||d}||||||}} || fS)z{ Return the point on the line connecting (*x0*, *y0*) -- (*x1*, *y1*) whose distance from (*x0*, *y0*) is *d*. g?r9) rrrrrrrffrrr9r9r:_point_along_a_line src@seZdZdZiZGdddZGdddeZeeddGdd d eZeed dGd d d eZ eed dGdddeZ eeddGdddeZ eeddGdddeZ eeddGdddeZ eeddGdddeZGdddeZeeddGdd d eZeed!dGd"d#d#eZeed$dGd%d&d&eZeed'dGd(d)d)eZeeGd*d+d+eZeeGd,d-d-eZeeGd.d/d/eZd0S)1 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 %(AvailableArrowstyles)s An instance of any arrow style class is a callable object, whose call signature is:: __call__(self, path, mutation_size, linewidth, aspect_ratio=1.) and it returns a tuple of a `.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|j}t|dks<|ddtjks<|ddtjkrDtd|dd|ddS)a4 Some ArrowStyle class only works with a simple quadratic Bezier curve (created with Arc3Connection or Angle3Connector). This static method is to check if the provided path is a simple quadratic Bezier curve and returns its control points if true. rrrz,'path' is not a valid quadratic Bezier curve)listZ iter_segmentsr0rrRrr')r>segmentsr9r9r:ensure_quadratic_bezier3 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. zDerived must overrideN)r)r2r>rrr9r9r:rB s zArrowStyle._Base.transmute?c Cs|dk r|jd|g}t||j}|j|||\}}tj|rxg} x,t|D] } | jt| jd|g| jqLW| |fS||fSn|j|||SdS)z The __call__ method is a thin wrapper around the transmute method and takes care of the aspect ratio. Nr)rOrrNrrPiterablerOr) r2r>rrrrOZ path_shrunkZ path_mutatedfillable path_listrr9r9r:rP s    zArrowStyle._Base.__call__N)r)rrrr staticmethodrrrr9r9r9r:r" s  rcs2eZdZdZd fdd Zdd Zd d ZZS) zArrowStyle._Curvea* A simple arrow which will work with any path instance. The returned path is simply concatenation of the original path + at most two paths representing the arrow head at the begin point and the at the end point. The arrow heads can be either open or closed. NF皙?皙?cs8|||_|_|||_|_|||_|_tjdS)a> The arrows are drawn if *beginarrow* and/or *endarrow* are true. *head_length* and *head_width* determines the size of the arrow relative to the *mutation scale*. The arrowhead at the begin (or end) is closed if fillbegin (or fillend) is True. N) beginarrowendarrowr*r) fillbeginfillendrur)r2rrrrr*r))rwr9r:rs s zArrowStyle._Curve.__init__c Cs||||} } tj| | } d||} | dkr6d} | | | } | | | }| | |} | | |} || || | | || }}|| || || || }}|| ||||f|| ||f|| ||||fg}tjtjtjg}||| |fS)a Return the paths for arrow heads. Since arrow lines are drawn with capstyle=projected, The arrow goes beyond the desired point. This method also returns the amount of the path to be shrunken so that it does not overshoot. g?rr)rPrrrRr)r2rrrr head_distcos_tsin_trrrZ cp_distanceZ pad_projectedrrrrrrvertices_arrow codes_arrowr9r9r:_get_arrow_wedge s$       $"z"ArrowStyle._Curve._get_arrow_wedgec Cs,|j|}|j|}tj||}||||}}|jd\} } |jd\} } |job| | f| | fk} | r|j| | | | ||||n ggddf\}}}}|jd\}}|jd\}}|jo||f||fk}|r|j||||||||n ggddf\}}}}ttj | || |fg|jdd||||fgg|j g}dg}| r|j rtj ||d|dgg}tj |tj tj gg}|jt|||jdn|jt|||jd|r$|jr |jdtj ||d|dgg}tj |tj tj gg}|jt||n|jd|jt||||fS) NrrrFTr$rr)r*r)rPrrOrrrrrrNrrrrr)r2r>rrr*r)rrrrrrrZhas_begin_arrow verticesAcodesAZddxAZddyArrZx3Zy3Z has_end_arrow verticesBcodesBZddxBZddyBrZ _fillablerrtr9r9r:r sL           zArrowStyle._Curve.transmute)NNFFrr)rrrrrrrrr9r9)rwr:_Curvek s  *r-)rxcs eZdZdZfddZZS)zArrowStyle.Curvez&A simple curve without any arrow head.cstjddddS)NF)rr)rur)r2)rwr9r:r szArrowStyle.Curve.__init__)rrrrrrr9r9)rwr:Curve srz<-cs"eZdZdZdfdd ZZS)zArrowStyle.CurveAz(An arrow with a head at its begin point.皙?皙?cstjdd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. TF)rrr*r)N)rur)r2r*r))rwr9r:r s zArrowStyle.CurveA.__init__)rr)rrrrrrr9r9)rwr:CurveA sr z->cs"eZdZdZdfdd ZZS)zArrowStyle.CurveBz&An arrow with a head at its end point.皙?皙?cstjdd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. FT)rrr*r)N)rur)r2r*r))rwr9r:r s zArrowStyle.CurveB.__init__)r r )rrrrrrr9r9)rwr:CurveB sr z<->cs"eZdZdZdfdd ZZS)zArrowStyle.CurveABz8An arrow with heads both at the begin and the end point.皙?皙?cstjdd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. T)rrr*r)N)rur)r2r*r))rwr9r:r s zArrowStyle.CurveAB.__init__)r r)rrrrrrr9r9)rwr:CurveAB srz<|-cs"eZdZdZdfdd ZZS)zArrowStyle.CurveFilledAz0An arrow with filled triangle head at the begin.皙?皙?cstjdddd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. TF)rrrrr*r)N)rur)r2r*r))rwr9r:r+ s z ArrowStyle.CurveFilledA.__init__)rr)rrrrrrr9r9)rwr: CurveFilledA' srz-|>cs"eZdZdZdfdd ZZS)zArrowStyle.CurveFilledBz.An arrow with filled triangle head at the end.皙?皙?cstjdddd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. FT)rrrrr*r)N)rur)r2r*r))rwr9r:r= s z ArrowStyle.CurveFilledB.__init__)rr)rrrrrrr9r9)rwr: CurveFilledB9 srz<|-|>cs"eZdZdZdfdd ZZS)zArrowStyle.CurveFilledABz1An arrow with filled triangle heads at both ends.皙?皙?cstjdddd||ddS)z Parameters ---------- head_length : float, default: 0.4 Length of the arrow head. head_width : float, default: 0.2 Width of the arrow head. T)rrrrr*r)N)rur)r2r*r))rwr9r:rO s z!ArrowStyle.CurveFilledAB.__init__)rr)rrrrrrr9r9)rwr: CurveFilledABK src @s&eZdZd ddZddZdd ZdS) zArrowStyle._BracketN?皙?c CsJ|||_|_|||_|_|||_|_|||_|_| | |_|_ dS)N) bracketAbracketBwidthAwidthBlengthAlengthBrrscaleAscaleB) r2rrrrrr rrr!r"r9r9r:r_ s zArrowStyle._Bracket.__init__cCs~ddlm}||||||\}} } } ||||} } || | | f|| f| | f| | | | fg}tjtjtjtjg}||fS)Nr)get_normal_points)Zmatplotlib.bezierr#rrRr)r2rrrrrr+r#rrrrrrrrr9r9r: _get_bracketj s z ArrowStyle._Bracket._get_bracketcCsN|jdkr|}n|j}|jdkr&|}n|j}gg}}|jr|jd\}} |jd\} } t| | || \} } |j|| | | |j||j|\}}|j||j||j|j|j|j |j r(|jd\}} |jd\} } t| | || \} } |j|| | | |j ||j |\}}|j||j|t j|}t j|}t||}|dfS)NrrrFrr$)r!r"rrOr r$rrrrNrrr rPrr)r2r>rrr!r"Z vertices_listZ codes_listrrrrrrrrrrrOrNrr9r9r:r~ s>              zArrowStyle._Bracket.transmute) NNrrrrNNNN)rrrrr$rr9r9r9r:_Bracket] s r%z]-[cs"eZdZdZdfdd ZZS)zArrowStyle.BracketABz3An arrow with outward square brackets at both ends.?皙?Nc s tjdd||||||ddS)aD Parameters ---------- widthA : float, default: 1.0 Width of the bracket. lengthA : float, default: 0.2 Length of the bracket. angleA : float, default: None Angle between the bracket and the line. widthB : float, default: 1.0 Width of the bracket. lengthB : float, default: 0.2 Length of the bracket. angleB : float, default: None Angle between the bracket and the line. T)rrrrr rN)rur)r2rrrrr r)rwr9r:r s zArrowStyle.BracketAB.__init__)r&r'Nr&r'N)rrrrrrr9r9)rwr: BracketAB sr(z]-cs"eZdZdZdfdd ZZS)zArrowStyle.BracketAz5An arrow with an outward square bracket at its start.?皙?Ncstjdd|||ddS)a? Parameters ---------- widthA : float, default: 1.0 Width of the bracket. lengthA : float, default: 0.2 Length of the bracket. angleA : float, default: None Angle between the bracket and the line. TN)rrr)rur)r2rrr)rwr9r:r s zArrowStyle.BracketA.__init__)r)r*N)rrrrrrr9r9)rwr:BracketA sr+z-[cs"eZdZdZdfdd ZZS)zArrowStyle.BracketBz3An arrow with an outward square bracket at its end.?皙?Ncstjdd|||ddS)a? Parameters ---------- widthB : float, default: 1.0 Width of the bracket. lengthB : float, default: 0.2 Length of the bracket. angleB : float, default: None Angle between the bracket and the line. NT)rr r)rur)r2rr r)rwr9r:r s zArrowStyle.BracketB.__init__)r,r-N)rrrrrrr9r9)rwr:BracketB sr.z|-|cs"eZdZdZdfdd ZZS)zArrowStyle.BarABz/An arrow with vertical bars ``|`` at both ends.?Nc s tjdd|d||d|ddS)a Parameters ---------- widthA : float, default: 1.0 Width of the bracket. angleA : float, default: None Angle between the bracket and the line. widthB : float, default: 1.0 Width of the bracket. angleB : float, default: None Angle between the bracket and the line. Tr)rrrrr rN)rur)r2rrrr)rwr9r:r s zArrowStyle.BarAB.__init__)r/Nr/N)rrrrrrr9r9)rwr:BarAB sr0cs*eZdZdZdfdd ZddZZS) zArrowStyle.Simplez9A simple arrow. Only works with a quadratic Bezier curve.?皙?cs$||||_|_|_tjdS)aA Parameters ---------- head_length : float, default: 0.5 Length of the arrow head. head_width : float, default: 0.5 Width of the arrow head. tail_width : float, default: 0.2 Width of the arrow tail. N)r*r) tail_widthrur)r2r*r)r3)rwr9r:r szArrowStyle.Simple.__init__cCs|j|\}}}}}} |j|} t|| | } ||f||f|| fg} yt| | dd\} }Wn\tk rt|| ||| \}}d||d|| }}||f||f|| fg}d} YnX|j|}t||ddd\}}| dk r|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) Ng{Gz?) toleranceg?g@)wmrrrcSsg|] \}}|qSr9r9)rJrtrr9r9r:rdX sz/ArrowStyle.Simple.transmute..cSsg|] \}}|qSr9r9)rJrtrr9r9r:rdX sT)rr*rrr rr)rr3r rrRrrr)r2r>rrrrrrrrr*in_f arrow_pathZ arrow_outZarrow_inx1ny1nr) head_left head_rightr3 tail_left tail_right patch_pathr9r9r:r! sP                       zArrowStyle.Simple.transmute)r1r1r2)rrrrrrrr9r9)rwr:Simple sr?cs*eZdZdZdfdd ZddZZS)zArrowStyle.Fancyz8A fancy arrow. Only works with a quadratic Bezier curve.皙?cs$||||_|_|_tjdS)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. N)r*r)r3rur)r2r*r)r3)rwr9r:r` szArrowStyle.Fancy.__init__cCs|j|\}}}}}} |j|} ||f||f|| fg} t|| | } yt| | dd\} }Wn\tk rt|| ||| \}}d||d|| }}||f||f|| fg} | }YnX|}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 |d ft j |d ft j |d ft j |d ft j |d ft j |d ft j |d ft j |d ft j |d ft j |ft j |fg}t dd|Ddd|D}|dfS)Ng{Gz?)r4g?g?g@g333333?)r5g?g333333?)Zw1r5Zw2rrrcSsg|] \}}|qSr9r9)rJrtrr9r9r:rd sz.ArrowStyle.Fancy.transmute..cSsg|] \}}|qSr9r9)rJrtrr9r9r:rd sTr)rr*rrr rr)rr3rrRrrr)r2r>rrrrrrrrr*r7r6Zpath_outZpath_inr8r9Z path_headZ path_tailr)Zhead_lZhead_rr3r<r=Z tail_startr;r:r>r9r9r:rq s\                   zArrowStyle.Fancy.transmute)r@r@r@)rrrrrrrr9r9)rwr:Fancy\ srAcs*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. 333333??cs||_||_tjdS)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)r3 shrink_factorrur)r2r3rD)rwr9r:r s zArrowStyle.Wedge.__init__c Cs|j|\}}}}}} ||f||f|| fg} t| |j|d|jd\} } tj| dftj| dftj| dftj| dftj| dftj| dftj| dfg} tdd| Ddd| D}|d fS) Ng@)r5rrrcSsg|] \}}|qSr9r9)rJrtrr9r9r:rd sz.ArrowStyle.Wedge.transmute..cSsg|] \}}|qSr9r9)rJrtrr9r9r:rd sT) rrr3rDrrRrrr)r2r>rrrrrrrrr7Zb_plusZb_minusr>r9r9r:r s       zArrowStyle.Wedge.transmute)rBrC)rrrrrrrr9r9)rwr:r srN)rrrrrhrrrrr r rrrrr%r(r+r.r0r?rArr9r9r9r:r sD"IMOWr)ZAvailableBoxstylesZ ListBoxstylesZAvailableArrowstylesZAvailableConnectorstylesc@seZdZdZdZddZejd,dd Zejd-d d Z d d Z ddZ ddZ ddZ ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+ZdS).raO 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))rwr_x_yrr)r2rr9r9r:r s zFancyBboxPatch.__str__rN?c Ksntj|f||d|_|d|_||_||_|dkrN|dkrFtd||_n |j|||_ ||_ d|_ dS)a Parameters ---------- xy : float, float The lower left corner of the box. width : float The width of the box. height : float The height of the box. boxstyle : str or `matplotlib.patches.BoxStyle` The style of the fancy box. This can either be a `.BoxStyle` instance or a string of the style name and optionally comma seprarated attributes (e.g. "Round, pad=0.2"). This string is passed to `.BoxStyle` to construct a `.BoxStyle` object. See there for a full documentation. The following box styles are available: %(AvailableBoxstyles)s mutation_scale : float, default: 1 Scaling factor applied to the attributes of the box style (e.g. pad or rounding_size). mutation_aspect : float, optional The height of the rectangle will be squeezed by this value before the mutation and the mutated box will be stretched by the inverse of it. For example, this allows different horizontal and vertical padding. Other Parameters ---------------- **kwargs : `.Patch` properties %(Patch)s rrZcustomNz7bbox_transmuter argument is needed with custom boxstyleT) rrrErFrrr'_bbox_transmuter set_boxstyle_mutation_scale_mutation_aspectrl) r2rrrboxstyleZbbox_transmutermutation_scalemutation_aspectr8r9r9r:r s/   zFancyBboxPatch.__init__cKsD|dkrtjSt|tjs$t|r,||_nt|f||_d|_dS)a Set the box style. Most box styles can be further configured using 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 The name of the box style. Optionally, followed by a comma and a comma-separated list of attributes. The attributes may alternatively be passed separately as keyword arguments. The following box styles are available: %(AvailableBoxstyles)s .. ACCEPTS: %(ListBoxstyles)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)rrrArcallablerHrl)r2rLr8r9r9r:rI?s $zFancyBboxPatch.set_boxstylecCs||_d|_dS)zf Set the mutation scale. Parameters ---------- scale : float TN)rJrl)r2rr9r9r:set_mutation_scalelsz!FancyBboxPatch.set_mutation_scalecCs|jS)zReturn the mutation scale.)rJ)r2r9r9r:get_mutation_scalewsz!FancyBboxPatch.get_mutation_scalecCs||_d|_dS)zz Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : float TN)rKrl)r2aspectr9r9r:set_mutation_aspect{sz"FancyBboxPatch.set_mutation_aspectcCs|jS)z-Return the aspect ratio of the bbox mutation.)rK)r2r9r9r:get_mutation_aspectsz"FancyBboxPatch.get_mutation_aspectcCs|jS)zReturn the boxstyle object.)rH)r2r9r9r: get_boxstyleszFancyBboxPatch.get_boxstylecCs*|j|j|j|j|j|j|j}|S)z)Return the mutated path of the rectangle.)rUrErFrrrQrT)r2rr9r9r:r<s  zFancyBboxPatch.get_pathcCs|jS)z'Return the left coord of the rectangle.)rE)r2r9r9r:rszFancyBboxPatch.get_xcCs|jS)z)Return the bottom coord of the rectangle.)rF)r2r9r9r:rszFancyBboxPatch.get_ycCs|jS)z"Return the width of the rectangle.)r)r2r9r9r:rszFancyBboxPatch.get_widthcCs|jS)z#Return the height of the rectangle.)r)r2r9r9r:rszFancyBboxPatch.get_heightcCs||_d|_dS)zo Set the left coord of the rectangle. Parameters ---------- x : float TN)rErl)r2rHr9r9r:rszFancyBboxPatch.set_xcCs||_d|_dS)zq Set the bottom coord of the rectangle. Parameters ---------- y : float TN)rFrl)r2rIr9r9r:rszFancyBboxPatch.set_ycCs||_d|_dS)zc Set the rectangle width. Parameters ---------- w : float TN)rrl)r2r}r9r9r:rszFancyBboxPatch.set_widthcCs||_d|_dS)zd Set the rectangle height. Parameters ---------- h : float TN)rrl)r2rr9r9r:rszFancyBboxPatch.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)r0rErFrrrl)r2rrrr}rr9r9r:rs  zFancyBboxPatch.set_boundscCstjj|j|j|j|jS)zReturn the `.Bbox`.)r rZ from_boundsrErFrr)r2r9r9r:rszFancyBboxPatch.get_bbox)rNrGN)N)rrrrrnrrrrrIrPrQrSrTrUr<rrrrrrrrrrr9r9r9r:r s4 > ,       c @seZdZdZdZddZejd,d d Zd d Z ddZ ddZ ddZ ddZ ddZddZd-ddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+ZdS).FancyArrowPatcha 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|jdk rL|j\\}}\}}t|jd|dd|dd|dd|dd St|jd|jdSdS)Nz((gz, z)->(z))()) _posA_posBtyper_path_original)r2rrrrr9r9r:rs 0zFancyArrowPatch.__str__Nsimplearc3rrc Ks| jdd| jddtj|f| |dk r`|dk r`|dkr`||g|_|dkrTd}|j|n(|dkr|dkr|dk rd|_ntd||_||_||_| |_ ||_ |j || |_ | |_ |j| dS)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: %(AvailableArrowstyles)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: %(AvailableConnectorstyles)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. dpi_cor : float, default: 1 dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Other Parameters ---------------- **kwargs : `.Patch` properties, optional Here is a list of available `.Patch` properties: %(Patch)s In contrast to other patches, the default ``capstyle`` and ``joinstyle`` for `FancyArrowPatch` are set to ``"round"``. r7rr6Nr^z.Either posA and posB, or path need to provided)r:rrrZset_connectionstyler'rrrrr\set_arrowstylerJrK set_dpi_cor)r2rrr> arrowstyleconnectionstylerrrrrMrNdpi_corr8r9r9r:rs(R     zFancyArrowPatch.__init__cCs||_d|_dS)z dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Parameters ---------- dpi_cor : float TN)_dpi_corrl)r2rdr9r9r:ravs zFancyArrowPatch.set_dpi_corcCs|jS)z dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Returns ------- scalar )re)r2r9r9r: get_dpi_cors zFancyArrowPatch.get_dpi_corcCs.|dk r||jd<|dk r$||jd<d|_dS)a Set the begin and end positions of the connecting path. Parameters ---------- posA, posB : None, tuple (x, y) coordinates of arrow tail and arrow head respectively. If `None` use current value. NrrT)rZrl)r2rrr9r9r: set_positionss   zFancyArrowPatch.set_positionscCs||_d|_dS)zn Set the tail patch. Parameters ---------- patchA : `.patches.Patch` TN)rrl)r2rr9r9r: set_patchAszFancyArrowPatch.set_patchAcCs||_d|_dS)zn Set the head patch. Parameters ---------- patchB : `.patches.Patch` TN)rrl)r2rr9r9r: set_patchBszFancyArrowPatch.set_patchBcKsD|dkrtjSt|tjs$t|r,||_nt|f||_d|_dS)a Set the connection style. Old attributes are forgotten. Parameters ---------- connectionstyle : str or `.ConnectionStyle` or None, optional Can be a string with connectionstyle name with optional comma-separated attributes, e.g.:: set_connectionstyle("arc,angleA=0,armA=30,rad=10") Alternatively, the attributes can be provided as keywords, e.g.:: set_connectionstyle("arc", angleA=0,armA=30,rad=10) Without any arguments (or with ``connectionstyle=None``), return available styles as a list of strings. NT)rrrArrO _connectorrl)r2rcrkr9r9r:r_s z#FancyArrowPatch.set_connectionstylecCs|jS)z"Return the `ConnectionStyle` used.)rj)r2r9r9r:get_connectionstylesz#FancyArrowPatch.get_connectionstylecKs<|dkrtjSt|tjr$||_nt|f||_d|_dS)aH Set the arrow style. Old attributes are forgotten. Without arguments (or with ``arrowstyle=None``) returns available box styles as a list of strings. Parameters ---------- arrowstyle : None or ArrowStyle or str, default: None Can be a string with arrowstyle name with optional comma-separated attributes, e.g.:: set_arrowstyle("Fancy,head_length=0.2") Alternatively attributes can be provided as keywords, e.g.:: set_arrowstyle("fancy", head_length=0.2) NT)rrrAr_arrow_transmuterrl)r2rbrkr9r9r:r`s  zFancyArrowPatch.set_arrowstylecCs|jS)zReturn the arrowstyle object.)rl)r2r9r9r:get_arrowstyleszFancyArrowPatch.get_arrowstylecCs||_d|_dS)zf Set the mutation scale. Parameters ---------- scale : float TN)rJrl)r2rr9r9r:rPsz"FancyArrowPatch.set_mutation_scalecCs|jS)z\ Return the mutation scale. Returns ------- scalar )rJ)r2r9r9r:rQsz"FancyArrowPatch.get_mutation_scalecCs||_d|_dS)zz Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : float TN)rKrl)r2rRr9r9r:rS sz#FancyArrowPatch.set_mutation_aspectcCs|jS)z-Return the aspect ratio of the bbox mutation.)rK)r2r9r9r:rTsz#FancyArrowPatch.get_mutation_aspectcCs2|j\}}tj|r tj|}|jjj|S)z Return the path of the arrow in the data coordinates. Use get_path_in_displaycoord() method to retrieve the arrow path in display coordinates. )get_path_in_displaycoordrPrrZmake_compound_pathr;rMtransform_path)r2rrr9r9r:r<s   zFancyArrowPatch.get_pathcCs|j}|jdk rr|j|jd}|j|jd}|jj||f\}}|j|||j|j|j||j |d}n|jj |j }|j ||j ||j||j\}}||fS)zrrrrr9r9r:rAs   zFancyArrowPatch.draw) NNNr]r^NNrrrNr)N)rrrrrnrrrrrarfrgrhrir_rkr`rmrPrQrSrTr<rnrr9r9r9r:rVs> f         rVc@sZeZdZdZddZejdd d Zdd dZddZ ddZ ddZ ddZ ddZ dS)ConnectionPatchz>A patch that connects two points (possibly in different axes).cCs(d|jd|jd|jd|jdfS)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)xy1xy2)r2r9r9r:r[szConnectionPatch.__str__Nrr^$@F?cKsf|dkr |}||_||_||_||_||_||_tj|fdd||| | | | | |||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 '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:: 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. .. 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) rrrbrcrrrrrMrNrTrd)rr)rr) rqrrcoords1coords2axesAaxesBrVr_annotation_clip)r2ZxyAZxyBZcoordsAZcoordsBrxryrbrcrrrrrMrNrTrdr8r9r9r:r_s,IzConnectionPatch.__init__c Cs|}|dkr|j}tj|}|dkrB||jjd9}|jdd}n |dkrT|jj}n|dkrb|j}|\}}|d kr|j}t |j |}t |j |}|j ||fS|d kr|j d kr|j|jd S|j|j|j ||jjdS|d kr&||}} | tj|}| tj|}|j}|j ||fS|d kr||jj} |d krL| j|n| j|}|d krj| j|n| j|}||fS|dkr|j} |d kr| j|n| j|}|d kr| j|n| j|}||fSt|tjr|j |St|ddS)z,Calculate the pixel position of given point.N figure points axes pointsHrZZpixelszfigure fractionz axes fractiondataz offset pointsZpolarz figure pixelsrz axes pixelsz) is not a valid coordinate transformation)r{r|)r;rPr&figureZdpirfZ transFigureZ transAxesZ transDatarxrrrZxycoords_get_xyrr=r>rrrrrrAr Z Transformr') r2rrr;s0rHrIr=r@r Zbbr9r9r:rsR        zConnectionPatch._get_xycCs||_d|_dS)a Set the clipping behavior. Parameters ---------- b : bool or None - *False*: The annotation will always be drawn regardless of its position. - *True*: The annotation will only be drawn if ``self.xy`` is inside the axes. - *None*: The annotation will only be drawn if ``self.xy`` is inside the axes and ``self.xycoords == "data"``. TN)rzrl)r2rr9r9r:set_annotation_clipsz#ConnectionPatch.set_annotation_clipcCs|jS)zx Return the clipping behavior. See `.set_annotation_clip` for the meaning of the return value. )rz)r2r9r9r:get_annotation_clipsz#ConnectionPatch.get_annotation_clipcCs|j}|j|j|j|j}|j|j|j|j}|j|||j |j |j ||j |d}|j ||j||j||j\}}||fS)zrr9r9r:rns  z(ConnectionPatch.get_path_in_displaycoordcCs|j}|s|dkrX|jdkrX|j|j|j|j}|jdkrD|j}n|j}|j|sXdS|sn|dkr|jdkr|j|j|j|j }|j dkr|j}n|j }|j|sdSdS)z/Check whether the annotation needs to be drawn.Nr~FT) rrvrrqrxr;rGrwrrry)r2rrZxy_pixelr;r9r9r: _check_xy!s     zConnectionPatch._check_xycCs8|dk r||_|j s$|j| r(dStj||dS)N)Z _rendererrrrVr)r2rr9r9r:r:s zConnectionPatch.draw) NNNrr^NNrsrsrtNFru)N)rrrrrrrrrrrrnrrr9r9r9r:rpXs* Y 1rp) rrrrrrrrrrrr)NT)rXN)N)ErrrvrnumbersrrnumpyrPZ matplotlibrr`rrrrrryr Zbezierr r r r rrrrr>rZ_define_aliasesrrZkwdocZpatchdocrXZinterpdr1rrrrrrrrrrr\getdoc splitlinesrrrrrWrYr]r^rrrrrrrhrrVrpr9r9r9r:s  (  I  Q:Z^Z9e")n   DV+ j     f