B ]”t\úMã@sâddlZddlZddlmZddlZddlZddlZddlZ ddl m Z m Z m Z mZmZmZddlmZmZmZmZmZmZmZmZmZmZddlmZe  dgdgd gd gd gd œ¡Gd d„de j ƒƒZ!e  "e!¡Z#xdD]Z$ej% &e$e#i¡qÚWe 'e!j(¡Gdd„de!ƒZ)Gdd„de!ƒZ*Gdd„de!ƒZ+Gdd„de!ƒZ,Gdd„de!ƒZ-Gdd„de!ƒZ.Gdd„de!ƒZ/Gdd„de-ƒZ0ej% &de0j(j1i¡e j2d d!d"Gd#d$„d$e!ƒƒZ3Gd%d&„d&e+ƒZ4Gd'd(„d(e!ƒZ5Gd)d*„d*e5ƒZ6Gd+d,„d,e5ƒZ7dNd.d/„Z8dOd1d2„Z9dPd4d5„Z:d6d7„Z;d8d9„ZdQdd<œd=d>„Z?Gd?d@„d@e>ƒZ@ej%j&e;e@jAƒeƒZCdFdG„ZDGdHdI„dIe>ƒZEej%j&e;eEjAƒe;eCjAƒdJGdKd!„d!e!ƒZFGdLdM„dMeFƒZGdS)RéN)ÚNumberé)ÚartistÚcbookÚcolorsÚ docstringÚlinesÚ transforms) ÚNonIntersectingPathExceptionÚconcatenate_pathsÚ get_cos_sinÚget_intersectionÚ get_parallelsÚ inside_circleÚmake_path_regularÚmake_wedged_bezier2Ú)split_bezier_intersecting_with_closedpathÚsplit_path_inout)ÚPathÚaaZecZfcÚlwÚls)Ú antialiasedÚ edgecolorÚ facecolorÚ linewidthÚ linestylec @sZeZdZdZdZdZdZdZdPdd „Zd d „Z d d „Z dQdd„Z dRdd„Z dSdd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Z d:d;„Z!dd?„Z%d@dA„Z&dBdC„Z'dDdE„Z(dFdG„Z)dHdI„Z*e+j,dJdK„ƒZ-dLdM„Z.dTdNdO„Z/dS)UÚPatchzÅ A patch is a 2D artist with a face color and an edge color. If any of *edgecolor*, *facecolor*, *linewidth*, or *antialiased* are *None*, they default to their rc params setting. r)ÚbuttÚroundZ projecting)ÚmiterrZbevelFNTc Ks"tj |¡|dkrtjd}|dkr*d}| dkr6d} | dkrBd} |dkrTtjd}t tjd¡|_d|_|dk rš|dk s„|dk rŽt   d ¡|  |¡n|  |¡|  |¡d|_d |_| |¡| |¡| |¡| |¡| |¡| | ¡| | ¡t ¡|_t| ƒr| | ¡dS) zQ The following kwarg properties are supported %(Patch)s Nzpatch.linewidthÚsolidrr zpatch.antialiasedz hatch.colorTzPSetting the 'color' property will overridethe edgecolor or facecolor properties.r)rÚArtistÚ__init__ÚmplÚrcParamsrÚto_rgbaÚ _hatch_colorÚ_fillÚwarningsÚwarnÚ set_colorÚ set_edgecolorÚ set_facecolorÚ _us_dashesÚ _linewidthÚset_fillÚ set_linestyleÚ set_linewidthÚset_antialiasedÚ set_hatchÚ set_capstyleÚ set_joinstyler ÚIdentityTransformZ_combined_transformÚlenÚupdate) ÚselfrrÚcolorrrrÚhatchÚfillZcapstyleZ joinstyleÚkwargs©r?ú1lib/python3.7/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 :meth:`get_path`. r)Ú get_transformÚget_pathZ to_polygonsr8)r:ÚtransÚpathZpolygonsr?r?r@Ú get_vertsas  zPatch.get_vertscCsB|dk r |St|jtƒr |j}n| ¡ddkr6d}n| ¡}|S)Nér)Ú isinstanceZ_pickerrÚ get_edgecolorÚ get_linewidth)r:ÚradiusÚ_radiusr?r?r@Ú_process_radiusps zPatch._process_radiuscCsFt|jƒr| ||¡S| |¡}| ¡ |j|jf| ¡|¡}|ifS)zUTest whether the mouse event occurred in the patch. Returns T/F, {} )ÚcallableZ _containsrLrBÚcontains_pointÚxÚyrA)r:Z mouseeventrJÚinsider?r?r@Úcontains|s    zPatch.containscCs | |¡}| ¡ || ¡|¡S)zÇ Returns ``True`` if the given *point* is inside the path (transformed with its transform attribute). *radius* allows the path to be made slightly larger or smaller. )rLrBrNrA)r:ZpointrJr?r?r@rNˆs  zPatch.contains_pointcCs | |¡}| ¡ || ¡|¡S)a Returns a bool array which is ``True`` if the (closed) path contains the corresponding point. (transformed with its transform attribute). *points* must be Nx2 array. *radius* allows the path to be made slightly larger or smaller. )rLrBÚcontains_pointsrA)r:ZpointsrJr?r?r@rS”s  zPatch.contains_pointscCsvtj ||¡|j|_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |  |j ¡|  | ¡¡| ¡|_dS)zM Updates this :class:`Patch` from the properties of *other*. N)rr"Ú update_fromÚ _edgecolorÚ _facecolorÚ_original_edgecolorÚ_original_facecolorr(Ú_hatchr'r.r2r/Ú set_transformÚget_data_transformZis_transform_setZ _transformSet)r:Úotherr?r?r@rT¢s zPatch.update_fromcCs| ¡ | ¡¡S)z‡ Return a :class:`~matplotlib.transforms.Bbox` object defining the axis-aligned extents of the :class:`Patch`. )rBÚ get_extentsrA)r:r?r?r@r]¸szPatch.get_extentscCs| ¡tj |¡S)zm Return the :class:`~matplotlib.transforms.Transform` applied to the :class:`Patch`. )Úget_patch_transformrr"rA)r:r?r?r@rA¿szPatch.get_transformcCs tj |¡S)zŒ Return the :class:`~matplotlib.transforms.Transform` instance which maps data coordinates to physical coordinates. )rr"rA)r:r?r?r@r[ÆszPatch.get_data_transformcCst ¡S)ah Return the :class:`~matplotlib.transforms.Transform` instance which takes patch coordinates to data coordinates. For example, one may define a patch of a circle which represents a radius of 5 by providing coordinates for a unit circle, and a transform which scales the coordinates (the patch coordinate) by 5. )r r7)r:r?r?r@r^Ís zPatch.get_patch_transformcCs|jS)zV Returns True if the :class:`Patch` is to be drawn with antialiasing. )Ú _antialiased)r:r?r?r@Úget_antialiasedØszPatch.get_antialiasedcCs|jS)z> Return the edge color of the :class:`Patch`. )rU)r:r?r?r@rHÞszPatch.get_edgecolorcCs|jS)z> Return the face color of the :class:`Patch`. )rV)r:r?r?r@Ú get_facecoloräszPatch.get_facecolorcCs|jS)z2 Return the line width in points. )r/)r:r?r?r@rIêszPatch.get_linewidthcCs|jS)z' Return the linestyle. )Ú _linestyle)r:r?r?r@Ú get_linestyleðszPatch.get_linestylecCs"|dkrtjd}||_d|_dS)z{ Set whether to use antialiased rendering. Parameters ---------- b : bool or None Nzpatch.antialiasedT)r$r%r_Ústale)r:rr?r?r@r3ös zPatch.set_antialiasedcCs\d}|dkr6tjds"|jr"|jr.tjd}nd}d}t ||j¡|_|rR|j|_d|_ dS)NTzpatch.force_edgecolorzpatch.edgecolorZnoneF) r$r%r(Ú _edge_defaultrr&Ú_alpharUr'rd)r:r;Úset_hatch_colorr?r?r@Ú_set_edgecolors   zPatch._set_edgecolorcCs||_| |¡dS)zz Set the patch edge color. Parameters ---------- color : color or None or 'auto' N)rWrh)r:r;r?r?r@r,szPatch.set_edgecolorcCs:|dkrtjd}|jr|jnd}t ||¡|_d|_dS)Nzpatch.facecolorrT)r$r%r(rfrr&rVrd)r:r;Úalphar?r?r@Ú_set_facecolors  zPatch._set_facecolorcCs||_| |¡dS)zp Set the patch face color. Parameters ---------- color : color or None N)rXrj)r:r;r?r?r@r-$szPatch.set_facecolorcCs| |¡| |¡dS)a Set both the edgecolor and the facecolor. .. seealso:: :meth:`set_facecolor`, :meth:`set_edgecolor` For setting the edge or face color individually. Parameters ---------- c : color N)r-r,)r:Úcr?r?r@r+/s zPatch.set_colorcCs\|dk r2y t|ƒWntk r0tdƒ‚YnXtj ||¡| |j¡| |j¡dS)z Set the alpha transparency of the patch. Parameters ---------- alpha : float or None Nzalpha must be a float or None) ÚfloatÚ TypeErrorrr"Ú set_alpharjrXrhrW)r:rir?r?r@rn?s  zPatch.set_alphacCsZ|dkr$tjd}|dkr$tjd}t|ƒ|_|j\}}t |||j¡\|_|_d|_ dS)z_ Set the patch linewidth in points ACCEPTS: float or None for default Nzpatch.linewidthzaxes.linewidthT) r$r%rlr/r.ÚmlinesÚ _scale_dashesÚ _dashoffsetÚ_dashesrd)r:ÚwÚoffsetrr?r?r@r2Qs    zPatch.set_linewidthcCsH|dkr d}||_t |¡\}}|_t |||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. Nr!T) rbroZ_get_dash_patternr.rpr/rqrrrd)r:rrtr?r?r@r1cszPatch.set_linestylecCs,t|ƒ|_| |j¡| |j¡d|_dS)zh Set whether to fill the patch. Parameters ---------- b : bool TN)Úboolr(rjrXrhrWrd)r:Úbr?r?r@r0…s   zPatch.set_fillcCs|jS)zreturn whether fill is set)r()r:r?r?r@Úget_fill’szPatch.get_fillcCs<| ¡}||jkr,td|fd|jfƒ‚||_d|_dS)z{ Set the patch capstyle Parameters ---------- s : {'butt', 'round', 'projecting'} zset_capstyle passed "%s"; zvalid capstyles are %sTN)ÚlowerÚvalidCapÚ ValueErrorÚ _capstylerd)r:Úsr?r?r@r5›s   zPatch.set_capstylecCs|jS)zReturn the current capstyle)r{)r:r?r?r@Ú get_capstyleªszPatch.get_capstylecCs<| ¡}||jkr,td|fd|jfƒ‚||_d|_dS)zx Set the patch joinstyle Parameters ---------- s : {'miter', 'round', 'bevel'} zset_joinstyle passed "%s"; zvalid joinstyles are %sTN)rxÚ validJoinrzÚ _joinstylerd)r:r|r?r?r@r6®s   zPatch.set_joinstylecCs|jS)zReturn the current joinstyle)r)r:r?r?r@Ú get_joinstyle½szPatch.get_joinstylecCs||_d|_dS)aØ Set the hatching pattern *hatch* can be one of:: / - diagonal hatching \ - back diagonal | - vertical - - horizontal + - crossed x - crossed diagonal o - small circle O - large circle . - dots * - stars Letters can be combined, in which case all the specified hatchings are done. If same letter repeats, it increases the density of hatching of that pattern. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. Parameters ---------- hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'} TN)rYrd)r:r<r?r?r@r4ÁszPatch.set_hatchcCs|jS)z#Return the current hatching pattern)rY)r:r?r?r@Ú get_hatchàszPatch.get_hatchc Cs¢| ¡s dS| d| ¡¡| ¡}|j|jdd|j}|jddkrLd}| |¡| d|j ¡|  |j ¡|  |j ¡| |j¡| |¡| |j¡| | ¡¡|j}|ddkrÂd}| |j¡|jr| |j¡y| |j¡Wn tk rt d¡YnX| ¡dk r0|j | ¡Ž| !¡}| "¡}| #|¡}| $¡}| %¡rvddl&m'} | | %¡|ƒ}| (||||¡| )¡| *d¡d |_+dS) z0Draw the :class:`Patch` to the given *renderer*.NÚpatchT)ÚisRGBArFrz6Your backend does not support setting the hatch color.)ÚPathEffectRendererF),Ú get_visibleÚ open_groupÚget_gidÚnew_gcÚset_foregroundrUr/r2Ú set_dashesrrr5r{r6rr3r_Ú _set_gc_clipZset_urlZ_urlÚset_snapÚget_snaprVrnrfrYr4rgr'ÚAttributeErrorr)r*Úget_sketch_paramsÚset_sketch_paramsrBrAZtransform_path_non_affineZ get_affineÚget_path_effectsÚmatplotlib.patheffectsr„Ú draw_pathÚrestoreÚ close_grouprd) r:ÚrendererÚgcrÚrgbFacerDZ transformZtpathÚaffiner„r?r?r@ÚdrawäsP              z Patch.drawcCs tdƒ‚dS)z/ Return the path of this patch zDerived must overrideN)ÚNotImplementedError)r:r?r?r@rBszPatch.get_pathcCs| ¡ | ¡¡S)N)rBr]rA)r:r–r?r?r@Úget_window_extent#szPatch.get_window_extent) NNNNNNNTNN)N)N)N)N)0Ú__name__Ú __module__Ú __qualname__Ú__doc__Úzorderryr~rer#rErLrRrNrSrTr]rAr[r^r`rHrarIrcr3rhr,rjr-r+rnr2r1r0rwÚpropertyr=r5r}r6r€r4rrÚallow_rasterizationršrBrœr?r?r?r@rsf  .     "  9r) Ú RectangleÚCircleÚRegularPolygonÚPolygonÚWedgeÚArrowÚ FancyArrowÚYAArrowÚ CirclePolygonÚEllipseÚArcÚFancyBboxPatchrc@sleZdZdd„Zejddd„ƒZdd„Zdd „Zd d „Z d d „Z dd„Z dd„Z dd„Z dd„Zdd„ZdS)ÚShadowcCsdt|jƒS)Nz Shadow(%s))Ústrr‚)r:r?r?r@Ú__str__2szShadow.__str__NcKs:t |¡||_||_|||_|_t ¡|_|  ¡dS)a Create a shadow of the given *patch* offset by *ox*, *oy*. *props*, if not *None*, is a patch property update dictionary. If *None*, the shadow will have have the same color as the face, but darkened. kwargs are %(Patch)s N) rr#r‚ÚpropsÚ_oxÚ_oyr ÚAffine2DÚ_shadow_transformÚ_update)r:r‚ÚoxÚoyr³r>r?r?r@r#5s  zShadow.__init__cCsz| |j¡| t |jjtj ¡¡|jdk r>| |j¡n8dt  t   |j  ¡¡¡}|  |¡| |¡| d¡dS)Ng333333Ó?gà?)rTr‚Z set_zorderÚnpZ nextafterr¡Úinfr³r9ÚasarrayrZto_rgbrar-r,rn)r:r;r?r?r@r¸Gs    zShadow._updatecCs.| |j¡}| |j¡}|j ¡ ||¡dS)N)Úpoints_to_pixelsr´rµr·ÚclearÚ translate)r:r–r¹rºr?r?r@Ú_update_transformUs  zShadow._update_transformcCs|jS)N)r´)r:r?r?r@Ú_get_oxZszShadow._get_oxcCs ||_dS)N)r´)r:r¹r?r?r@Ú_set_ox]szShadow._set_oxcCs|jS)N)rµ)r:r?r?r@Ú_get_oy`szShadow._get_oycCs ||_dS)N)rµ)r:rºr?r?r@Ú_set_oycszShadow._set_oycCs |j ¡S)N)r‚rB)r:r?r?r@rBfszShadow.get_pathcCs|j ¡|jS)N)r‚r^r·)r:r?r?r@r^iszShadow.get_patch_transformcCs| |¡t ||¡dS)N)rÁrrš)r:r–r?r?r@ršls z Shadow.draw)N)rržrŸr²rÚdedent_interpdr#r¸rÁrÂrÃrÄrÅrBr^ršr?r?r?r@r°1s r°c@sÂeZdZdZdd„Zejd,dd„ƒZdd„Zd d „Z d d „Z d d„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„ZeeeƒZd+S)-r¤zz Draw a rectangle with lower left at *xy* = (*x*, *y*) with specified *width*, *height* and rotation *angle*. cCs$|j|j|j|j|jf}d}||S)Nz5Rectangle(xy=(%g, %g), width=%g, height=%g, angle=%g))Ú_x0Ú_y0Ú_widthÚ_heightÚangle)r:ÚparsÚfmtr?r?r@r²wszRectangle.__str__çcKsbtj|f|Ž|d|_|d|_||_||_|j|j|_|j|j|_t|ƒ|_ t   ¡|_ dS)a÷ Parameters ---------- xy : (float, float) The bottom and left rectangle coordinates width : float Rectangle width height : float Rectangle height angle : float, optional rotation in degrees anti-clockwise about *xy* (default is 0.0) fill : bool, optional Whether to fill the rectangle (default is ``True``) Notes ----- Valid kwargs are: %(Patch)s rrN) rr#rÇrÈrÉrÊÚ_x1Ú_y1rlrËr r7Ú_rect_transform)r:ÚxyÚwidthÚheightrËr>r?r?r@r#|s   zRectangle.__init__cCst ¡S)z7 Return the vertices of the rectangle. )rÚunit_rectangle)r:r?r?r@rB¡szRectangle.get_pathcCsX| ¡\}}}}tj ||||¡}t ¡}| |||j¡t |¡|_|j|7_dS)aNOTE: This cannot be called until after this has been added to an Axes, otherwise unit conversion will fail. This makes it very important to call the accessor method and not directly access the transformation member variable. N) Ú_convert_unitsr ÚBboxÚ from_extentsr¶Zrotate_deg_aroundrËÚBboxTransformTorÑ)r:Úx0Úy0Úx1Úy1ÚbboxZ rot_transr?r?r@Ú_update_patch_transform§s  z!Rectangle._update_patch_transformcCs|j|j|_dS)N)rÇrÉrÏ)r:r?r?r@Ú _update_x1´szRectangle._update_x1cCs|j|j|_dS)N)rÈrÊrÐ)r:r?r?r@Ú _update_y1·szRectangle._update_y1cCs<| |j¡}| |j¡}| |j¡}| |j¡}||||fS)z2 Convert bounds of the rectangle. )Úconvert_xunitsrÇÚconvert_yunitsrÈrÏrÐ)r:rÚrÛrÜrÝr?r?r@rÖºs     zRectangle._convert_unitscCs| ¡|jS)N)rßrÑ)r:r?r?r@r^ÄszRectangle.get_patch_transformcCs|jS)z'Return the left coord of the rectangle.)rÇ)r:r?r?r@Úget_xÈszRectangle.get_xcCs|jS)z)Return the bottom coord of the rectangle.)rÈ)r:r?r?r@Úget_yÌszRectangle.get_ycCs |j|jfS)z3Return the left and bottom coords of the rectangle.)rÇrÈ)r:r?r?r@Úget_xyÐszRectangle.get_xycCs|jS)z"Return the width of the rectangle.)rÉ)r:r?r?r@Ú get_widthÔszRectangle.get_widthcCs|jS)z#Return the height of the rectangle.)rÊ)r:r?r?r@Ú get_heightØszRectangle.get_heightcCs||_| ¡d|_dS)z$Set the left coord of the rectangle.TN)rÇràrd)r:rOr?r?r@Úset_xÜszRectangle.set_xcCs||_| ¡d|_dS)z&Set the bottom coord of the rectangle.TN)rÈrárd)r:rPr?r?r@Úset_yâszRectangle.set_ycCs&|\|_|_| ¡| ¡d|_dS)z… Set the left and bottom coords of the rectangle. Parameters ---------- xy : (float, float) TN)rÇrÈràrárd)r:rÒr?r?r@Úset_xyès zRectangle.set_xycCs||_| ¡d|_dS)zSet the width of the rectangle.TN)rÉràrd)r:rsr?r?r@Ú set_widthõszRectangle.set_widthcCs||_| ¡d|_dS)z Set the height of the rectangle.TN)rÊrárd)r:Úhr?r?r@Ú set_heightûszRectangle.set_heightcGs\t|ƒdkr|d\}}}}n |\}}}}||_||_||_||_| ¡| ¡d|_dS)zj Set the bounds of the rectangle: l,b,w,h ACCEPTS: (left, bottom, width, height) rrTN)r8rÇrÈrÉrÊràrárd)r:ÚargsÚlrvrsrír?r?r@Ú set_boundss  zRectangle.set_boundscCs"| ¡\}}}}tj ||||¡S)N)rÖr r×rØ)r:rÚrÛrÜrÝr?r?r@Úget_bboxszRectangle.get_bboxN)rÎ)rržrŸr r²rrÆr#rBrßràrárÖr^rärårærçrèrérêrërìrîrñròr¢rÒr?r?r?r@r¤qs. $   r¤c@s¨eZdZdZdd„Zejddd„ƒZdd „Zd d „Z d d „Z e e e ƒZ dd„Z dd„Ze e eƒZdd„Zdd„Ze eeƒZdd„Zdd„Ze eeƒZdd„Zdd„ZdS) r¦z" A regular polygon patch. cCs(d}||jd|jd|j|j|jfS)Nz7RegularPolygon((%g, %g), %d, radius=%g, orientation=%g)rr)Ú_xyÚ _numVerticesrKÚ _orientation)r:r|r?r?r@r²szRegularPolygon.__str__ércKsH||_||_||_||_t |¡|_t ¡|_ |  ¡t j |f|ŽdS)af Constructor arguments: *xy* A length 2 tuple (*x*, *y*) of the center. *numVertices* the number of vertices. *radius* The distance from the center to each of the vertices. *orientation* rotates the polygon (in radians). Valid kwargs are: %(Patch)s N) rórôrõrKrZunit_regular_polygonÚ_pathr r¶Ú_poly_transformrÁrr#)r:rÒÚ numVerticesrJÚ orientationr>r?r?r@r##s  zRegularPolygon.__init__cCs&|j ¡ |j¡ |j¡j|jŽdS)N)rør¿ÚscalerJÚrotaterúrÀrÒ)r:r?r?r@rÁBs z RegularPolygon._update_transformcCs|jS)N)ró)r:r?r?r@Ú_get_xyHszRegularPolygon._get_xycCs||_| ¡dS)N)rórÁ)r:rÒr?r?r@Ú_set_xyKszRegularPolygon._set_xycCs|jS)N)rõ)r:r?r?r@Ú_get_orientationPszRegularPolygon._get_orientationcCs||_| ¡dS)N)rõrÁ)r:rúr?r?r@Ú_set_orientationSszRegularPolygon._set_orientationcCs|jS)N)rK)r:r?r?r@Ú _get_radiusXszRegularPolygon._get_radiuscCs||_| ¡dS)N)rKrÁ)r:rJr?r?r@Ú _set_radius[szRegularPolygon._set_radiuscCs|jS)N)rô)r:r?r?r@Ú_get_numvertices`szRegularPolygon._get_numverticescCs ||_dS)N)rô)r:rùr?r?r@Ú_set_numverticescszRegularPolygon._set_numverticescCs|jS)N)r÷)r:r?r?r@rBhszRegularPolygon.get_pathcCs| ¡|jS)N)rÁrø)r:r?r?r@r^ksz"RegularPolygon.get_patch_transformN)rör)rržrŸr r²rrÆr#rÁrýrþr¢rÒrÿrrúrrrJrrZ numverticesrBr^r?r?r?r@r¦s&     r¦c@s2eZdZdZdZdd„Zejdd„ƒZdd„Z d S) Ú PathPatchz) A general polycurve path patch. TcCs&d}|t|jjƒft|jjdƒ˜S)NzPathPatch%d((%g, %g) ...)r)r8r÷ÚverticesÚtuple)r:r|r?r?r@r²vszPathPatch.__str__cKstj|f|Ž||_dS)zÉ *path* is a :class:`matplotlib.path.Path` object. Valid kwargs are: %(Patch)s .. seealso:: :class:`Patch` For additional kwargs N)rr#r÷)r:rDr>r?r?r@r#zszPathPatch.__init__cCs|jS)N)r÷)r:r?r?r@rB‹szPathPatch.get_pathN) rržrŸr rer²rrÆr#rBr?r?r?r@rps rc@sfeZdZdZdd„Zejddd„ƒZdd„Zd d „Z d d „Z d d„Z dd„Z e Z e Zee e ddZdS)r§z" A general polygon patch. cCs&d}|t|jjƒft|jjdƒ˜S)NzPolygon%d((%g, %g) ...)r)r8r÷rr)r:r|r?r?r@r²“szPolygon.__str__TcKs"tj|f|Ž||_| |¡dS)a0 *xy* is a numpy array with shape Nx2. If *closed* is *True*, the polygon will be closed so the starting and ending points are the same. Valid kwargs are: %(Patch)s .. seealso:: :class:`Patch` For additional kwargs N)rr#Ú_closedrë)r:rÒÚclosedr>r?r?r@r#—szPolygon.__init__cCs|jS)z² Get the path of the polygon Returns ------- path : Path The :class:`~matplotlib.path.Path` object for the polygon )r÷)r:r?r?r@rB¬s zPolygon.get_pathcCs|jS)z‹ Returns if the polygon is closed Returns ------- closed : bool If the path is closed )r)r:r?r?r@Ú get_closed¸s zPolygon.get_closedcCs4|jt|ƒkrdSt|ƒ|_| | ¡¡d|_dS)z” Set if the polygon is closed Parameters ---------- closed : bool True if the polygon is closed NT)rrurërærd)r:r r?r?r@Ú set_closedÃs  zPolygon.set_closedcCs|jjS)z£ Get the vertices of the path. Returns ------- vertices : (N, 2) numpy array The coordinates of the vertices. )r÷r)r:r?r?r@ræÒs zPolygon.get_xycCsˆt |¡}|jrBt|ƒrn|d|dk ¡rnt ||dgg¡}n,t|ƒdkrn|d|dk ¡rn|dd…}t||jd|_d|_ dS)z¥ Set the vertices of the polygon. Parameters ---------- xy : (N, 2) array-like The coordinates of the vertices. réÿÿÿÿéN)r T) r»r½rr8ÚanyÚ concatenateÚallrr÷rd)r:rÒr?r?r@rëÝs   zPolygon.set_xyz/The vertices of the path as (N, 2) numpy array.)ÚdocN)T)rržrŸr r²rrÆr#rBr r rærërýrþr¢rÒr?r?r?r@r§s    r§c@s`eZdZdZdd„Zejddd„ƒZdd„Zd d „Z d d „Z d d„Z dd„Z dd„Z dd„ZdS)r¨z Wedge shaped patch. cCs0|jd|jd|j|j|j|jf}d}||S)Nrrzr?r?r@r#s  zWedge.__init__c Cs&t|j|jdƒdkr(d\}}tj}n|j|j}}tj}t ||¡}|jdk rÀ|j}|jddd…|j |j|j }t   |||ddd…fdg¡}t   |j |j |tjg¡}||t|j ƒ<nÚLÚcxÚsxZtrans1Ztrans2Ztrans3rCr?r?r@r#^s   zArrow.__init__cCs|jS)N)r÷)r:r?r?r@rBszArrow.get_pathcCs|jS)N)r)r:r?r?r@r^szArrow.get_patch_transformN)r$) rržrŸr r²rr÷rrÆr#rBr^r?r?r?r@r©Qs   .r©cs4eZdZdZdZdd„Zejd ‡fd d „ ƒZ‡Z S) rªzP Like Arrow, but lets you set head width and head height independently. TcCsdS)Nz FancyArrow()r?)r:r?r?r@r²›szFancyArrow.__str__çü©ñÒMbP?FNÚfullrc  sš|dkrd|}|dkr d|}t ||¡} |r6| }n| |}|sJg}n4||| |f\}}}}t ddg| | dg| d|| dg| | dg| dgg¡}|s¸||dg7}| rÌ||ddg7}| dkrÚ|}nR|dd g}| d krô|}n8| d kr t |dd …|d dd …g¡}n td | ƒ‚| dkrH|| }|| }nd\}}||g| |gg}t ||¡||||f}tƒj|fddi| —ŽdS)aê Constructor arguments *width*: float (default: 0.001) width of full arrow tail *length_includes_head*: bool (default: False) True if head is to be counted in calculating the length. *head_width*: float or None (default: 3*width) total width of the full arrow head *head_length*: float or None (default: 1.5 * head_width) length of arrow head *shape*: ['full', 'left', 'right'] (default: 'full') draw the left-half, right-half, or full arrow *overhang*: float (default: 0) fraction that the arrow is swept back (0 overhang means triangular shape). Can be negative or greater than one. *head_starts_at_zero*: bool (default: False) if True, the head starts being drawn at coordinate 0 instead of ending at coordinate 0. Other valid kwargs (inherited from :class:`Patch`) are: %(Patch)s NrFgø?gr rrÚleftr Úrightr-éþÿÿÿzGot unknown shape: %s)rrr T)r»r%ÚarrayrrzÚdotÚsuperr#)r:rOrPr'r(rÓZlength_includes_headÚ head_widthÚ head_lengthÚshapeZoverhangZhead_starts_at_zeror>ZdistanceÚlengthZvertsZhwZhlZhsrZleft_half_arrowZcoordsZright_half_arrowr*r+ÚM)Ú __class__r?r@r#žsJ!       zFancyArrow.__init__)r,FNNr-rF) rržrŸr rer²rrÆr#Ú __classcell__r?r?)r9r@rª”srªz3.0ÚFancyArrowPatch)Z alternativec@s@eZdZdZdd„Zejddd„ƒZd d „Zd d „Z d d„Z dS)r«z“ Yet another arrow class. This is an arrow that is defined in display space and has a tip at *x1*, *y1* and a base at *x2*, *y2*. cCsdS)Nz YAArrow()r?)r:r?r?r@r²szYAArrow.__str__éçš™™™™™¹?é cKs6||_||_||_||_||_tj|f|Ž||_dS)a  Constructor arguments: *xytip* (*x*, *y*) location of arrow tip *xybase* (*x*, *y*) location the arrow base mid point *figure* The `Figure` instance (used to get the dpi setting). *width* The width of the arrow in points *frac* The fraction of the arrow length occupied by the head *headwidth* The width of the base of the arrow head in points Valid kwargs are: %(Patch)s N)ÚxytipÚxybaserÓÚfracÚ headwidthrr#Úfigure)r:rCr?r@rÓrArBr>r?r?r@r#szYAArrow.__init__c Cs:|j\}}|j\}}|j|jjdd}|j|jjdd}| |||||¡\}}} } t ||||¡} t  ||d||d¡} ||j | t  | ¡} ||j | t  | ¡}| ||| ||¡\}}}}| ||| ||¡\}}}}|  || ||||||g¡}| || ||||||g¡}tt ||g¡ddS)NgR@g@T)r )r?r@rÓrCÚdpirBÚ getpointsÚmathÚatan2ÚsqrtrAÚcosÚsinrârãrr»Z column_stack)r:rÜrÝÚx2Úy2Zk1Zk2Zxb1Zyb1Zxb2Zyb2ÚthetarZxmZymZxc1Zyc1Zxc2Zyc2Zxd1Zyd1Zxd2Zyd2ZxsZysr?r?r@rB+s  zYAArrow.get_pathcCst ¡S)N)r r7)r:r?r?r@r^CszYAArrow.get_patch_transformcCs"tt|||||fƒ\}}}}}||dkr>||||||fS||dkr^||||||fS||||}d|}d}d|} |d|d|dd|d} | t | dd|| ¡d|} | |||} | t | dd|| ¡d|} | |||}| | || fS) a For line segment defined by (*x1*, *y1*) and (*x2*, *y2*) return the points on the line that is perpendicular to the line and intersects (*x2*, *y2*) and the distance from (*x2*, *y2*) of the returned points is *k*. rgð¿rr0g@gð?r r<)ÚmaprlrFrH)r:rÜrÝrKrLÚkÚmZpmÚarvrkZy3aZx3aZy3bZx3br?r?r@rEFs  $((zYAArrow.getpointsN)r<r=r>) rržrŸr r²rrÆr#rBr^rEr?r?r?r@r«ús $r«c@s(eZdZdZdd„Zejd dd„ƒZdS) r¬z4 A polygon-approximation of a circle patch. cCs$d}||jd|jd|j|jfS)Nz1CirclePolygon((%g, %g), radius=%g, resolution=%d)rr)rórKrô)r:r|r?r?r@r²fszCirclePolygon.__str__röécKs tj||||fddi|—ŽdS)a/ Create a circle at *xy* = (*x*, *y*) with given *radius*. This circle is approximated by a regular polygon with *resolution* sides. For a smoother circle drawn with splines, see :class:`~matplotlib.patches.Circle`. Valid kwargs are: %(Patch)s rúrN)r¦r#)r:rÒrJZ resolutionr>r?r?r@r#js zCirclePolygon.__init__N)rörR)rržrŸr r²rrÆr#r?r?r?r@r¬bs r¬c@sZeZdZdZdd„Zejddd„ƒZdd„Zd d „Z d d „Z d d„Z dd„Z e e e ƒZdS)r­z A scale-free ellipse. cCs,|jd|jd|j|j|jf}d}||S)Nrrz3Ellipse(xy=(%s, %s), width=%s, height=%s, angle=%s))Ú_centerrÓrÔrË)r:rÌrÍr?r?r@r²ƒszEllipse.__str__rcKs@tj|f|Ž||_|||_|_||_t ¡|_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 : scalar, optional Rotation in degrees anti-clockwise. Notes ----- Valid keyword arguments are %(Patch)s N) rr#rSrÓrÔrËrZ unit_circler÷r r7r)r:rÒrÓrÔrËr>r?r?r@r#‰s  zEllipse.__init__cCsd| |jd¡| |jd¡f}| |j¡}| |j¡}t ¡ |d|d¡ |j ¡j |Ž|_ dS)aNOTE: This cannot be called until after this has been added to an Axes, otherwise unit conversion will fail. This makes it very important to call the accessor method and not directly access the transformation member variable. rrgà?N) rârSrãrÓrÔr r¶rûZ rotate_degrËrÀr)r:rrÓrÔr?r?r@Ú_recompute_transform¥s  zEllipse._recompute_transformcCs|jS)z6 Return the vertices of the rectangle )r÷)r:r?r?r@rB´szEllipse.get_pathcCs| ¡|jS)N)rTr)r:r?r?r@r^ºszEllipse.get_patch_transformcCs||_d|_dS)zs Set the center of the ellipse. Parameters ---------- xy : (float, float) TN)rSrd)r:rÒr?r?r@r ¾szEllipse.set_centercCs|jS)z2 Return the center of the ellipse )rS)r:r?r?r@Ú get_centerÉszEllipse.get_centerN)r)rržrŸr r²rrÆr#rTrBr^r rUr¢rr?r?r?r@r­s  r­c@sBeZdZdZdd„Zejd dd„ƒZdd„Zd d „Z e e eƒZ d S) r¥z A circle patch. cCs$|jd|jd|jf}d}||S)NrrzCircle(xy=(%g, %g), radius=%g))rrJ)r:rÌrÍr?r?r@r²ÖszCircle.__str__röcKs&tj|||d|df|Ž||_dS)a6 Create true circle at center *xy* = (*x*, *y*) with given *radius*. Unlike :class:`~matplotlib.patches.CirclePolygon` which is a polygonal approximation, this uses Bezier splines and is much closer to a scale-free circle. Valid kwargs are: %(Patch)s r N)r­r#rJ)r:rÒrJr>r?r?r@r#Ûs zCircle.__init__cCsd||_|_d|_dS)zl Set the radius of the circle Parameters ---------- radius : float r TN)rÓrÔrd)r:rJr?r?r@r!êszCircle.set_radiuscCs |jdS)z1 Return the radius of the circle g@)rÓ)r:r?r?r@Ú get_radiusõszCircle.get_radiusN)rö) rržrŸr r²rrÆr#r!rVr¢rJr?r?r?r@r¥Òs  r¥c@s6eZdZdZdd„Zejd dd„ƒZej dd „ƒZ d S) r®a˜ An elliptical arc, i.e. a segment of an ellipse. Due to internal optimizations, there are certain restrictions on using Arc: - The arc cannot be filled. - The arc must be used in an :class:`~.axes.Axes` instance---it can not be added directly to a `.Figure`---because it is optimized to only render the segments that are inside the axes bounding box with high resolution. cCs4|jd|jd|j|j|j|j|jf}d}||S)NrrzEArc(xy=(%g, %g), width=%g, height=%g, angle=%g, theta1=%g, theta2=%g))rrÓrÔrËrr)r:rÌrÍr?r?r@r² sz Arc.__str__çç€v@c Ks>| dd¡}|rtdƒ‚tj|||||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 (anti-clockwise). theta1, theta2 : float, optional Starting and ending angles of the arc in degrees. These values are relative to *angle*, .e.g. if *angle* = 45 and *theta1* = 90 the absolute starting angle is 135. Default *theta1* = 0, *theta2* = 360, i.e. a complete ellipse. Other Parameters ---------------- **kwargs : `.Patch` properties Most `.Patch` properties are supported as keyword arguments, with the exception of *fill* and *facecolor* because filling is not supported. %(Patch)s r=FzArc objects can not be filledN)Ú setdefaultrzr­r#rr) r:rÒrÓrÔrËrrr>r=r?r?r@r#s " z Arc.__init__cst|dƒstdƒ‚| ¡| |j¡}| |j¡}dd„}||j||ƒ}||j||ƒ}|  ¡  ||f¡\}}d}||krž||kržt   ||¡|_ t ||¡Sdd„‰‡fdd „}t  ¡} t |jj¡|  ¡ ¡} |  | ¡} tƒ} x¬t| jd d …| jd d …ƒD]Š\} } | \}}| \}}xn|||||ƒD]\\}}t |¡}|d krVdtj|}t |¡}||krx|kr,nn |  |¡q,WqWt| ƒ|g} |}t  |¡}|  !t "|¡t #|¡f¡}|j }x>| D]6}|rt   ||d¡|_ t ||¡d}nd}|}qÔW||_ d S)a  Draw the arc to the given *renderer*. Notes ----- Ellipses are normally drawn using an approximation that uses eight cubic Bezier splines. The error of this approximation is 1.89818e-6, according to this unverified source: Lancaster, Don. *Approximating a Circle or an Ellipse Using Four Bezier Cubic Splines.* http://www.tinaja.com/glib/ellipse4.pdf There is a use case where very large ellipses must be drawn with very high accuracy, and it is too expensive to render the entire ellipse with enough segments (either splines or line segments). Therefore, in the case where either radius of the ellipse is large enough that the error of the spline approximation will be visible (greater than one pixel offset from the ideal), a different technique is used. In that case, only the visible parts of the ellipse are drawn, with each visible arc using a fixed number of spline segments (8). The algorithm proceeds as follows: 1. The points where the ellipse intersects the axes bounding box are located. (This is done be performing an inverse transformation on the axes bbox such that it is relative to the unit circle -- this makes the intersection calculation much easier than doing rotated ellipse intersection directly). This uses the "line intersecting a circle" algorithm from: Vince, John. *Geometry for Computer Graphics: Formulae, Examples & Proofs.* London: Springer-Verlag, 2005. 2. The angles of each of the intersection points are calculated. 3. Proceeding counterclockwise starting in the positive x-direction, each of the visible arc-segments between the pairs of vertices are drawn using the Bezier arc approximation technique implemented in :meth:`matplotlib.path.Path.arc`. Úaxesz'Arcs can only be used in Axes instancescSs4t |¡}t |¡}t |¡}t t |||¡¡S)N)r»Údeg2radrIrJÚrad2degZarctan2)rMrûrOrPr?r?r@Ú theta_stretchxs   zArc.draw..theta_stretchgø\!ÛÈAcssê||}||}||||}||||}||}||} | dkrn|||} | ||} | | fVnx| dkræ|dkr„d} nd} t | ¡} xRdD]J}|||| || |} | ||t |¡| |} | | fVq˜WdS)Nggð¿gð?)gð?gð¿)r»rHr)rÚrÛrÜrÝr'r(Zdr2ÚDZD2ZdiscrimrOrPZsign_dyZ sqrt_discrimZsignr?r?r@Úiter_circle_intersect_on_line‡s&     z/Arc.draw..iter_circle_intersect_on_linec 3sºd}||kr||}}n ||}}||kr6||}}n ||}}||8}||8}||7}||7}xTˆ||||ƒD]B\} } || krŒ|krpnqp|| kr¤|krpnqp| | fVqpWdS)Ng•Ö&è .>r?) rÚrÛrÜrÝÚepsilonZx0eZx1eZy0eZy1erOrP)r_r?r@Ú!iter_circle_intersect_on_line_seg¡s    0z3Arc.draw..iter_circle_intersect_on_line_segNr rrr éFT)$ÚhasattrÚ RuntimeErrorrTrârÓrãrÔrrrAÚtransform_pointrrr÷rršrÕr rÙrZrÞÚinvertedZ transformedÚsetÚziprr»ZarccosZpir\ÚaddÚsortedr[rNrIrJ)r:r–rÓrÔr]rrZ inv_errorraZbox_pathZbox_path_transformZthetasZp0Zp1rÚrÛrÜrÝrOrPrMZ last_thetaZ theta1_radrQZ path_originalr?)r_r@rš<sX2       (        zArc.drawN)rWrWrX) rržrŸr r²rrÆr#rr£ršr?r?r?r@r®þs   )r®Tc Cs®|dkr i}| ¡}| dd¡}| |¡}| |¡}|j\}}}} ||d8}||d8}||7}| |7} t||f|| |d} |  t ¡¡|   d¡|   |¡|   |¡dS)ad This is a debug function to draw a rectangle around the bounding box returned by :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist, to test whether the artist is returning the correct bbox. *props* is a dict of rectangle props with the additional property 'pad' that sets the padding around the bbox in points. NÚpadr<g@)rÒrÓrÔr=F) ÚcopyÚpopr¾rœÚboundsr¤rZr r7Ú set_clip_onr9rš) rr–r³r=rkrÞrðrvrsrírr?r?r@Ú bbox_artistÞs&        rprOc CsN|j\}}}}t||f|||dd}|dk r6| |¡| d¡| |¡dS)zâ This is a debug function to draw a rectangle around the bounding box returned by :meth:`~matplotlib.artist.Artist.get_window_extent` of an artist, to test whether the artist is returning the correct bbox. F)rÒrÓrÔrr=N)rnr¤rZrorš) rÞr–r;rCrðrvrsrírr?r?r@Ú draw_bboxþs  rqr cs‚dd„t|ŽDƒ‰d dd„ˆDƒ¡}d|d dd„t|dˆƒDƒ¡|f‡fd d„|d d …Dƒ|df•}t d  |¡d |¡S)zR Given the list of list of strings, return a string of REST table format. cSsg|]}tdd„|Dƒƒ‘qS)css|]}t|ƒVqdS)N)r8)Ú.0Úcellr?r?r@ú sz+_pprint_table...)Úmax)rrÚcolumnr?r?r@ú sz!_pprint_table..z css|]}d|VqdS)ú=Nr?)rrÚclr?r?r@rtsz _pprint_table..Úcss|]\}}| |¡VqdS)N)Úljust)rrrsryr?r?r@rtsrcs&g|]}d dd„t|ˆƒDƒ¡‘qS)z css|]\}}| |¡VqdS)N)r{)rrrsryr?r?r@rtsz+_pprint_table...)Újoinrh)rrÚrow)Úcol_lenr?r@rwsrNÚ ú )rhr|ÚtextwrapÚindent)ÚtableZ leadingspaceZtable_formatstrrr?)r~r@Ú _pprint_tables r„cCsŒddl}dddgg}xnt| ¡ƒD]^\}}| |j¡}|jrfd tdj|j t |jƒ d…|jƒ¡}nd}|  |j d ||g¡q"Wt |ƒS) z¿ A helper function for the _Style class. Given the dictionary of {stylename: styleclass}, return a formatted string listing all the styles. Used to update the documentation. rNZClassÚNameZAttrsz, z{}={}ÚNonez``%s``)ÚinspectrjÚitemsZgetfullargspecr#Údefaultsr|rNÚformatrïr8Úappendrr„)Ú_stylesr‡Z_tableÚnameÚclsÚspecZargstrr?r?r@Ú_pprint_styles&s  $rcCsd d tdjt|ƒƒ¡¡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 '{}' )rŠr|rNrj)rŒr?r?r@Ú_simpleprint_styles>sr’c@s<eZdZdZdd„Zedd„ƒZedd„ƒZedd „ƒ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. cKs¬| dd¡ d¡}|d ¡}y|j|}Wn tk rLtd|ƒ‚YnXy(dd„|dd …Dƒ}d d „|Dƒ}Wn tk r–td |ƒ‚YnX| |¡|f|ŽS) zP return the instance of the subclass with the given style name. r€rzú,rzUnknown style : %scSsg|]}| d¡‘qS)rx)Úsplit)rrZcsr?r?r@rw]sz"_Style.__new__..rNcSsi|]\}}t|ƒ|“qSr?)rl)rrrOrr?r?r@ú ^sz"_Style.__new__..zIncorrect style argument : %s)Úreplacer•rxÚ _style_listÚKeyErrorrzr9)rŽZ stylenameÚkwZ_listÚ_nameÚ_clsZ _args_pairZ_argsr?r?r@Ú__new__Ms  z_Style.__new__cCs|jS)zP A class method which returns a dictionary of available styles. )r˜)rŽr?r?r@Ú get_stylesesz_Style.get_stylescCs t|jƒS)zP A class method which returns a string of the available styles. )rr˜)rŽr?r?r@Ú pprint_styleslsz_Style.pprint_stylescCs,t||jƒstd||jfƒ‚||j|<dS)z' Register a new style. z%s must be a subclass of %sN)Ú issubclassÚ_Baserzr˜)rŽrZstyler?r?r@Úregisterss  z_Style.registerN) rržrŸr rÚ classmethodržrŸr¢r?r?r?r@r“Gs   r“)rcCs.|dkrtjt||dS|||p(|j ¡<|S)z=Class decorator that stashes a class in a (style) dictionary.N)r)Ú functoolsÚpartialÚ_register_stylerrx)Z style_listrŽrr?r?r@r¦sr¦c@seZdZdZiZGdd„deƒZeeƒGdd„deƒƒZeeƒGdd„deƒƒZ eeƒGdd „d eƒƒZ eeƒGd d „d e ƒƒZ eeƒGd d „d eƒƒZ eeƒGdd„deƒƒZ eeƒGdd„deƒƒZeeƒGdd„deƒƒZeeƒGdd„deƒƒZere e¡deeƒiZdS)ÚBoxStylea„ :class:`BoxStyle` is a container class which defines several boxstyle classes, which are used for :class:`FancyBboxPatch`. A style object can be created as:: BoxStyle.Round(pad=0.2) or:: BoxStyle("Round", pad=0.2) or:: BoxStyle("Round, pad=0.2") Following boxstyle classes are defined. %(AvailableBoxstyles)s An instance of any boxstyle class is an callable object, whose call signature is:: __call__(self, x0, y0, width, height, mutation_size, aspect_ratio=1.) and returns a :class:`Path` instance. *x0*, *y0*, *width* and *height* specify the location and size of the box to be drawn. *mutation_scale* determines the overall size of the mutation (by which I mean the transformation of the rectangle to the fancy box). *mutation_aspect* determines the aspect-ratio of the mutation. c@s"eZdZdZdd„Zddd„ZdS) zBoxStyle._Basea_ :class:`BBoxTransmuterBase` and its derivatives are used to make a fancy box around a given rectangle. The :meth:`__call__` method returns the :class:`~matplotlib.path.Path` of the fancy box. This class is not an artist and actual drawing of the fancy box is done by the :class:`FancyBboxPatch` class. cCs tdƒ‚dS)aƒ The transmute method is a very core of the :class:`BboxTransmuter` class and must be overridden in the subclasses. It receives the location and size of the rectangle, and the mutation_size, with which the amount of padding and etc. will be scaled. It returns a :class:`~matplotlib.path.Path` instance. zDerived must overrideN)r›)r:rÚrÛrÓrÔÚ mutation_sizer?r?r@Ú transmute¸s zBoxStyle._Base.transmuteçð?c Csz|dk rd||||}}| |||||¡}|j|j}} |dd…df||dd…df<t|| ƒS| |||||¡SdS)aH Given the location and size of the box, return the path of the box around it. - *x0*, *y0*, *width*, *height* : location and size of the box - *mutation_size* : a reference scale for the mutation. - *aspect_ratio* : aspect-ration for the mutation. Nr)r©rrr) r:rÚrÛrÓrÔr¨Ú aspect_ratiorDrrr?r?r@Ú__call__Ãs   zBoxStyle._Base.__call__N)rª)rržrŸr r©r¬r?r?r?r@r¡«s r¡cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zBoxStyle.Squarez& A simple square box. ç333333Ó?cs||_tƒ ¡dS)zB *pad* amount of padding N)rkr3r#)r:rk)r9r?r@r#âszBoxStyle.Square.__init__c Cs||j}|d||d|}}||||}}||||}}||f||f||f||f||fg} tjgtjgdtjg} t| | ƒS)Nr rF)rkrrrr) r:rÚrÛrÓrÔr¨rkrÜrÝrrr?r?r@r©ës "zBoxStyle.Square.transmute)r­)rržrŸr r#r©r:r?r?)r9r@ÚSquareÜs r®cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zBoxStyle.CirclezA simple circle box.ç333333Ó?cs||_tƒ ¡dS)z’ Parameters ---------- pad : float The amount of padding around the original box. N)rkr3r#)r:rk)r9r?r@r#üszBoxStyle.Circle.__init__cCs`||j}|d||d|}}||||}}t ||d||dft||ƒd¡S)Nr )rkrZcircleru)r:rÚrÛrÓrÔr¨rkr?r?r@r©s  zBoxStyle.Circle.transmute)r¯)rržrŸr r#r©r:r?r?)r9r@r¥ùs r¥cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zBoxStyle.LArrowz" (left) Arrow Box ç333333Ó?cs||_tƒ ¡dS)N)rkr3r#)r:rk)r9r?r@r#szBoxStyle.LArrow.__init__c Cs||j}|d||d|}}||||}}||||}}||d} | d} ||d}|| |f||f||f|| |f|| || f|| || f|| || f|| |f|| |fg } tjtjtjtjtjtjtjtjtjg } t| | ƒ} | S)Ng@gà?gffffffö?)rkrrrr)r:rÚrÛrÓrÔr¨rkrÜrÝr'ÚdxxÚcpÚcomrDr?r?r@r©s        zBoxStyle.LArrow.transmute)r°)rržrŸr r#r©r:r?r?)r9r@ÚLArrowsr´cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zBoxStyle.RArrowz# (right) Arrow Box ç333333Ó?cstƒ |¡dS)N)r3r#)r:rk)r9r?r@r#;szBoxStyle.RArrow.__init__cCsFtj ||||||¡}d|||jdd…df|jdd…df<|S)Nr r)r§r´r©r)r:rÚrÛrÓrÔr¨Úpr?r?r@r©>s  ,zBoxStyle.RArrow.transmute)rµ)rržrŸr r#r©r:r?r?)r9r@ÚRArrow5sr·cs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zBoxStyle.DArrowz$ (Double) Arrow Box ç333333Ó?cs||_tƒ ¡dS)N)rkr3r#)r:rk)r9r?r@r#LszBoxStyle.DArrow.__init__c Cs$||j}|d|}||||}}||||}}||d} | d} ||d}|| |f||f||| f|| | || f||| f||f|| |f|| || f|| || f|| || f|| |f|| |fg } tjtjtjtjtjtjtjtjtjtjtjtjg } t| | ƒ} | S)Ng@r gà?gffffffö?)rkrrrr)r:rÚrÛrÓrÔr¨rkrÜrÝr'r±r²r³rDr?r?r@r©Ps.       zBoxStyle.DArrow.transmute)r¸)rržrŸr r#r©r:r?r?)r9r@ÚDArrowDsr¹cs*eZdZdZd‡fdd„ Zdd„Z‡ZS) zBoxStyle.Roundz+ A box with round corners. ç333333Ó?Ncs||_||_tƒ ¡dS)z” *pad* amount of padding *rounding_size* rounding radius of corners. *pad* if None N)rkÚ rounding_sizer3r#)r:rkr»)r9r?r@r#|szBoxStyle.Round.__init__c Cs(||j}|jr||j}n|}|d||d|}}||||}}||||}} |||f|||f||f|||f|| |f|| f||| f||| f|| f|| |f|||f||f|||f|||fg} tjtjtjtjtjtjtjtjtjtjtjtjtjtjg} t| | ƒ} | S)Ng@)rkr»rrrÚCURVE3r) r:rÚrÛrÓrÔr¨rkÚdrrÜrÝr²r³rDr?r?r@r©ˆs:        zBoxStyle.Round.transmute)rºN)rržrŸr r#r©r:r?r?)r9r@ÚRoundvs r¾cs*eZdZdZd‡fdd„ Zdd„Z‡ZS) zBoxStyle.Round4z/ Another box with round edges. ç333333Ó?Ncs||_||_tƒ ¡dS)z *pad* amount of padding *rounding_size* rounding size of edges. *pad* if None N)rkr»r3r#)r:rkr»)r9r?r@r#ºszBoxStyle.Round4.__init__c Cs\||j}|jr||j}n|d}|d|d||d|d|}}||||||}}||||}} ||f||||f||||f||f||||f||| |f|| f||| |f||| |f|| f||| |f||||f||f||fg} tjtjtjtjtjtjtjtjtjtjtjtjtjtjg} t| | ƒ} | S)Ng@r )rkr»rrZCURVE4r) r:rÚrÛrÓrÔr¨rkr½rÜrÝr²r³rDr?r?r@r©Æs,  """"      zBoxStyle.Round4.transmute)r¿N)rržrŸr r#r©r:r?r?)r9r@ÚRound4´s rÀcs2eZdZdZd ‡fdd„ Zdd„Zdd „Z‡ZS) zBoxStyle.Sawtoothz! A sawtooth box. ç333333Ó?Ncs||_||_tƒ ¡dS)zŠ *pad* amount of padding *tooth_size* size of the sawtooth. pad* if None N)rkÚ tooth_sizer3r#)r:rkrÂ)r9r?r@r#ïszBoxStyle.Sawtooth.__init__cCsX||j}|jdkr$|jd|}n |j|}|d}|d|||d||}}tt |||d¡ƒd} ||| } tt |||d¡ƒd} ||| } ||||||}}||||} }|f||| dt | d¡| |f•}|f||||||g| ||f•}| f| || | || g| | |f•}|f||| dt | d¡||f•}| f| || dt | d¡||f•}|f||||||g| ||f•}|f||||||g| ||f•}|f||| dt | d¡||f•}t||ƒt||ƒt||ƒt||ƒ|d|dff•}|S)Ngà?g@r r)rkrÂÚintr»rZarangerh)r:rÚrÛrÓrÔr¨rkrÂZ tooth_size2Zdsx_nZdsxZdsy_nZdsyrÜrÝZ bottom_saw_xZ bottom_saw_yZ right_saw_xZ right_saw_yZ top_saw_xZ top_saw_yZ left_saw_xZ left_saw_yÚ saw_verticesr?r?r@Ú_get_sawtooth_verticesûsV             z(BoxStyle.Sawtooth._get_sawtooth_verticescCs"| |||||¡}t|dd}|S)NT)r )rÅr)r:rÚrÛrÓrÔr¨rÄrDr?r?r@r©E s  zBoxStyle.Sawtooth.transmute)rÁN)rržrŸr r#rÅr©r:r?r?)r9r@ÚSawtoothés JrÆcs*eZdZdZd‡fdd„ Zdd„Z‡ZS) zBoxStyle.RoundtoothzA rounded tooth box.ç333333Ó?Ncstƒ ||¡dS)zŠ *pad* amount of padding *tooth_size* size of the sawtooth. pad* if None N)r3r#)r:rkrÂ)r9r?r@r#N szBoxStyle.Roundtooth.__init__cCsf| |||||¡}tjt |¡|dggdd}tjgtjtjgt|ƒddtjg}t||ƒS)Nr)Zaxisrr ) rÅr»rr1rrr¼r8r)r:rÚrÛrÓrÔr¨rÄrr?r?r@r©X s " zBoxStyle.Roundtooth.transmute)rÇN)rržrŸr r#r©r:r?r?)r9r@Ú RoundtoothK s rÈÚAvailableBoxstylesN)rržrŸr r˜Úobjectr¡r¦r®r¥r´r·r¹r¾rÀrÆrÈrÚdedentrr?r?r?r@r§‡s0 1%1=4ar§)rÉZ ListBoxstylesc@s¼eZdZdZdZdd„Zejd,dd „ƒZejd-d d „ƒZ d d „Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„ZdS).r¯a} Draw a fancy box around a rectangle with lower left at *xy*=(*x*, *y*) with specified width and height. :class:`FancyBboxPatch` class is similar to :class:`Rectangle` class, but it draws a fancy box around the rectangle. The transformation of the rectangle box to the fancy box is delegated to the :class:`BoxTransmuterBase` and its derived classes. TcCs$|jjd}||j|j|j|jfS)Nz((%g, %g), width=%g, height=%g))r9rÚ_xÚ_yrÉrÊ)r:r|r?r?r@r²{ s zFancyBboxPatch.__str__rNçð?c Ksntj|f|Ž|d|_|d|_||_||_|dkrN|dkrFtdƒ‚||_n | |¡||_ ||_ d|_ dS)aº *xy* = lower left corner *width*, *height* *boxstyle* determines what kind of fancy box will be drawn. It can be a string of the style name with a comma separated attribute, or an instance of :class:`BoxStyle`. Following box styles are available. %(AvailableBoxstyles)s *mutation_scale* : a value with which attributes of boxstyle (e.g., pad) will be scaled. default=1. *mutation_aspect* : 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. default=None. Valid kwargs are: %(Patch)s rrZcustomNz7bbox_transmuter argument is needed with custom boxstyleT) rr#rÌrÍrÉrÊrzÚ_bbox_transmuterÚ set_boxstyleÚ_mutation_scaleÚ_mutation_aspectrd) r:rÒrÓrÔÚboxstyleZbbox_transmuterÚmutation_scaleÚmutation_aspectr>r?r?r@r# s   zFancyBboxPatch.__init__cKsD|dkrt ¡St|tjƒs$t|ƒr,||_nt|f|Ž|_d|_dS)a Set the box style. *boxstyle* can be a string with boxstyle name with optional comma-separated attributes. Alternatively, the attrs can be provided as keywords:: set_boxstyle("round,pad=0.2") set_boxstyle("round", pad=0.2) Old attrs simply are forgotten. Without argument (or with *boxstyle* = None), it returns available box styles. The following boxstyles are available: %(AvailableBoxstyles)s ACCEPTS: %(ListBoxstyles)s NT)r§rŸrGr¡rMrÏrd)r:rÓršr?r?r@rб s zFancyBboxPatch.set_boxstylecCs||_d|_dS)zf Set the mutation scale. Parameters ---------- scale : float TN)rÑrd)r:rûr?r?r@Úset_mutation_scaleÑ sz!FancyBboxPatch.set_mutation_scalecCs|jS)z, Return the mutation scale. )rÑ)r:r?r?r@Úget_mutation_scaleÜ sz!FancyBboxPatch.get_mutation_scalecCs||_d|_dS)zz Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : float TN)rÒrd)r:Úaspectr?r?r@Úset_mutation_aspectâ sz"FancyBboxPatch.set_mutation_aspectcCs|jS)z? Return the aspect ratio of the bbox mutation. )rÒ)r:r?r?r@Úget_mutation_aspectí sz"FancyBboxPatch.get_mutation_aspectcCs|jS)zReturn the boxstyle object)rÏ)r:r?r?r@Ú get_boxstyleó szFancyBboxPatch.get_boxstylecCs*| ¡|j|j|j|j| ¡| ¡ƒ}|S)z: Return the mutated path of the rectangle )rÛrÌrÍrÉrÊr×rÚ)r:r÷r?r?r@rB÷ s  zFancyBboxPatch.get_pathcCs|jS)z&Return the left coord of the rectangle)rÌ)r:r?r?r@rä szFancyBboxPatch.get_xcCs|jS)z(Return the bottom coord of the rectangle)rÍ)r:r?r?r@rå szFancyBboxPatch.get_ycCs|jS)z!Return the width of the rectangle)rÉ)r:r?r?r@rç szFancyBboxPatch.get_widthcCs|jS)z"Return the height of the rectangle)rÊ)r:r?r?r@rè szFancyBboxPatch.get_heightcCs||_d|_dS)zo Set the left coord of the rectangle. Parameters ---------- x : float TN)rÌrd)r:rOr?r?r@ré szFancyBboxPatch.set_xcCs||_d|_dS)zq Set the bottom coord of the rectangle. Parameters ---------- y : float TN)rÍrd)r:rPr?r?r@rê szFancyBboxPatch.set_ycCs||_d|_dS)zc Set the rectangle width. Parameters ---------- w : float TN)rÉrd)r:rsr?r?r@rì* szFancyBboxPatch.set_widthcCs||_d|_dS)zd Set the rectangle height. Parameters ---------- h : float TN)rÊrd)r:rír?r?r@rî5 szFancyBboxPatch.set_heightcGsLt|ƒdkr|d\}}}}n |\}}}}||_||_||_||_d|_dS)zj Set the bounds of the rectangle: l,b,w,h ACCEPTS: (left, bottom, width, height) rrTN)r8rÌrÍrÉrÊrd)r:rïrðrvrsrír?r?r@rñ@ s  zFancyBboxPatch.set_boundscCstj |j|j|j|j¡S)N)r r×Z from_boundsrÌrÍrÉrÊ)r:r?r?r@ròP szFancyBboxPatch.get_bbox)rNrÎN)N)rržrŸr rer²rrÆr#rÐrÖr×rÙrÚrÛrBrärårçrèrérêrìrîrñròr?r?r?r@r¯m s4  -        r¯c@s¶eZdZdZiZGdd„deƒZeeƒGdd„deƒƒZeeƒGdd„deƒƒZ eeƒGdd „d eƒƒZ eeƒGd d „d eƒƒZ eeƒGd d „d eƒƒZ er²e  e¡deeƒiZdS)ÚConnectionStylea0 :class:`ConnectionStyle` is a container class which defines several connectionstyle classes, which is used to create a path between two points. These are mainly used with :class:`FancyArrowPatch`. A connectionstyle object can be either created as:: ConnectionStyle.Arc3(rad=0.2) or:: ConnectionStyle("Arc3", rad=0.2) or:: ConnectionStyle("Arc3, rad=0.2") The following classes are defined %(AvailableConnectorstyles)s An instance of any connection style class is an callable object, whose call signature is:: __call__(self, posA, posB, patchA=None, patchB=None, shrinkA=2., shrinkB=2.) and it returns a :class:`Path` instance. *posA* and *posB* are tuples of x,y coordinates of the two points to be connected. *patchA* (or *patchB*) is given, the returned path is clipped so that it start (or end) from the boundary of the patch. The path is further shrunk by *shrinkA* (or *shrinkB*) which is given in points. c@s8eZdZdZGdd„dƒZdd„Zdd„Zd 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@seZdZdd„ZdS)z!ConnectionStyle._Base.SimpleEventcCs|\|_|_dS)N)rOrP)r:rÒr?r?r@r# sz*ConnectionStyle._Base.SimpleEvent.__init__N)rržrŸr#r?r?r?r@Ú SimpleEventŒ srÝcs„ˆr@‡fdd„}yt||ƒ\}}Wntk r:|}YnX|}ˆr€‡fdd„}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. cstj |¡}ˆ |¡dS)Nr)rÜr¡rÝrR)Ú xy_displayÚxy_event)ÚpatchAr?r@ÚinsideAš s z,ConnectionStyle._Base._clip..insideAcstj |¡}ˆ |¡dS)Nr)rÜr¡rÝrR)rÞrß)ÚpatchBr?r@ÚinsideB¦ s z,ConnectionStyle._Base._clip..insideB)rrz)r:rDràrârár.r/rãr?)ràrâr@Ú_clip s     zConnectionStyle._Base._clipc Cs˜|rJ|jd\}}t|||ƒ}yt||ƒ\}}|}Wntk rHYnX|r”|jd\}}t|||ƒ} yt|| ƒ\}}|}Wntk r’YnX|S)z\ Shrink the path by fixed size (in points) with shrinkA and shrinkB rr )rrrrz) r:rDÚshrinkAÚshrinkBrOrPrár.r/rãr?r?r@Ú_shrink³ s"  zConnectionStyle._Base._shrinkç@Nc Cs,| ||¡}| |||¡}| |||¡} | S)z Calls the *connect* method to create a path between *posA* and *posB*. The path is clipped and shrunken. )Úconnecträrç) r:ÚposAÚposBråræràrârDZ clipped_pathZ shrunk_pathr?r?r@r¬Í s zConnectionStyle._Base.__call__)rèrèNN)rržrŸr rÝrärçr¬r?r?r?r@r¡ s  #r¡c@s"eZdZdZddd„Zdd„ZdS) zConnectionStyle.Arc3aM Creates a simple quadratic Bezier curve between two points. The curve is created so that the middle control point (C1) is located at the same distance from the start (C0) and end points(C2) and the distance of the C1 to the line connecting C0-C2 is *rad* times the distance of C0-C2. çcCs ||_dS)zE *rad* curvature of the curve. N)Úrad)r:rír?r?r@r#å szConnectionStyle.Arc3.__init__cCsŒ|\}}|\}}||d||d}}||||} } |j} || | || | } } ||f| | f||fg}tjtjtjg}t||ƒS)Ng@)rírrr¼)r:rêrërÜrÝrKrLZx12Zy12r'r(Úfr*Úcyrrr?r?r@réì s zConnectionStyle.Arc3.connectN)rì)rržrŸr r#rér?r?r?r@ÚArc3Û s rðc@s"eZdZdZd dd„Zdd„ZdS) zConnectionStyle.Angle3a  Creates a simple quadratic Bezier curve between two points. The middle control points is placed at the intersecting point of two lines which cross the start and end point, and have a slope of angleA and angleB, respectively. éZrcCs||_||_dS)zˆ *angleA* starting angle of the path *angleB* ending angle of the path N)ÚangleAÚangleB)r:ròrór?r?r@r# s zConnectionStyle.Angle3.__init__c Cs¢|\}}|\}}t t |j¡¡}t t |j¡¡}t t |j¡¡} t t |j¡¡} t||||||| | ƒ\} } ||f| | f||fg} tjtj tj g}t| |ƒS)N) rFrIÚradiansròrJrór rrr¼)r:rêrërÜrÝrKrLÚcosAÚsinAÚcosBÚsinBr*rïrrr?r?r@ré s zConnectionStyle.Angle3.connectN)rñr)rržrŸr r#rér?r?r?r@ÚAngle3ÿ s rùc@s"eZdZdZd dd„Zdd„Zd S) zConnectionStyle.AngleaX Creates a piecewise continuous quadratic Bezier path between two points. The path has a one passing-through point placed at the intersecting point of two lines which cross the start and end point, and have a slope of angleA and angleB, respectively. The connecting edges are rounded with *rad*. rñrçcCs||_||_||_dS)zÅ *angleA* starting angle of the path *angleB* ending angle of the path *rad* rounding radius of the edge N)ròrórí)r:ròrórír?r?r@r#/ s zConnectionStyle.Angle.__init__c Cs€|\}}|\}}t t |j¡¡}t t |j¡¡}t t |j¡¡} t t |j¡¡} t||||||| | ƒ\} } ||fg} tjg}|j dkrª|   | | f¡|  tj ¡n²|| || }}|d|dd}|j |}|| || }}|d|dd}|j |}|   | ||| ||f| | f| ||| ||fg¡|  tj tj tj g¡|   ||f¡|  tj ¡t| |ƒS)Ngr gà?)rFrIrôròrJrór rrrír‹rÚextendr¼)r:rêrërÜrÝrKrLrõrör÷rør*rïrrÚdx1Údy1Zd1Úf1Údx2Údy2Zd2Úf2r?r?r@ré@ s4      zConnectionStyle.Angle.connectN)rñrrú)rržrŸr r#rér?r?r?r@ÚAngle% s rc@s"eZdZdZd dd„Zdd„ZdS) zConnectionStyle.Arca: Creates a piecewise continuous quadratic Bezier path between two points. The path can have two passing-through points, a point placed at the distance of armA and angle of angleA from point A, another point with respect to point B. The edges are rounded with *rad*. rNçcCs"||_||_||_||_||_dS)aH *angleA* : starting angle of the path *angleB* : ending angle of the path *armA* : length of the starting arm *armB* : length of the ending arm *rad* : rounding radius of the edges N)ròróÚarmAÚarmBrí)r:ròrórrrír?r?r@r#m s zConnectionStyle.Arc.__init__cCsv|\}}|\}}||fg}g}tjg} |jržt t |j¡¡} t t |j¡¡} |j|j} |  || | || | f¡|j} |  || | || | f¡|j rÐt t |j ¡¡} t t |j ¡¡}||j | ||j |}}|rl|d\}}||||}}||||d}|  ||j||||j||f¡|  |¡|   tj tjtjg¡n2|d\}}||||}}||||d}||j} || |||| ||f||fg}|rR|d\}}||||}}||||d}|  ||j||||j||f¡|  |¡|   tj tjtjg¡|  ||f¡|   tj ¡t|| ƒS)Nr gà?)rrrrFrIrôròrJrír‹rrórûrr¼)r:rêrërÜrÝrKrLrZroundedrrõröÚdr÷røZx_armBZy_armBZxpZypr'r(Úddr?r?r@ré† sZ            zConnectionStyle.Arc.connect)rrNNr)rržrŸr r#rér?r?r?r@r®c s r®c@s"eZdZdZd dd„Zdd„ZdS) zConnectionStyle.Bara A line with *angle* between A and B with *armA* and *armB*. One of the arms is extended so that they are connected in a right angle. The length of armA is determined by (*armA* + *fraction* x AB distance). Same for armB. çç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)rrÚfractionrË)r:rrr rËr?r?r@r#Ê szConnectionStyle.Bar.__init__cCs |\}}|\}}\}}t ||||¡} ||||} } | | | | d} | | | | } }|j|j}}|jdk rt |j¡}| |}| t |¡}| t |¡}||t |¡||t |¡}}||}||||} } | | | | d}| || |} }nd}t ||ƒ}|j | |}|||||| }}|||||| }}||f||f||f||fg}t j t j t j t j g}t ||ƒS)Ngà?g)rFrGrrrËr»r[rJrIrur rrr)r:rêrërÜrÝZx20Zy20rKrLrr'r(rÚddxÚddyrrZtheta0ZdthetaZdlZdLZdd2ZarmrîZcx1Zcy1Zcx2Zcy2rrr?r?r@réá s>  &  zConnectionStyle.Bar.connect)rrr N)rržrŸr r#rér?r?r?r@ÚBarÁ s r ÚAvailableConnectorstylesN)rržrŸr r˜rÊr¡r¦rðrùrr®r rrËrr?r?r?r@rÜU s &\#%=]KrÜc CsL||||}}|||||d}||||||}} || fS)zj find a point along a line connecting (x0, y0) -- (x1, y1) whose distance from (x0, y0) is d. gà?r?) rÚrÛrÜrÝrr'r(ZffrKrLr?r?r@Ú_point_along_a_line src@sÜeZdZdZiZGdd„deƒZGdd„deƒZeeddGdd „d eƒƒZ eed dGd d „d eƒƒZ eed dGdd„deƒƒZ eeddGdd„deƒƒZ eeddGdd„deƒƒZ eeddGdd„deƒƒZeeddGdd„deƒƒZGdd„deƒZeeddGdd „d eƒƒZeed!dGd"d#„d#eƒƒZeed$dGd%d&„d&eƒƒZeed'dGd(d)„d)eƒƒZeeƒGd*d+„d+eƒƒZeeƒGd,d-„d-eƒƒZeeƒGd.d/„d/eƒƒZerØe e¡d0eeƒiZd1S)2Ú ArrowStylea« :class:`ArrowStyle` is a container class which defines several arrowstyle classes, which is used to create an arrow path along a given path. These are mainly used with :class:`FancyArrowPatch`. A arrowstyle object can be either created as:: ArrowStyle.Fancy(head_length=.4, head_width=.4, tail_width=.4) or:: ArrowStyle("Fancy", head_length=.4, head_width=.4, tail_width=.4) or:: ArrowStyle("Fancy, head_length=.4, head_width=.4, tail_width=.4") The following classes are defined %(AvailableArrowstyles)s An instance of any arrow style class is a callable object, whose call signature is:: __call__(self, path, mutation_size, linewidth, aspect_ratio=1.) and it returns a tuple of a :class:`Path` instance and a boolean value. *path* is a :class:`Path` instance along which the arrow will be drawn. *mutation_size* and *aspect_ratio* have the same meaning as in :class:`BoxStyle`. *linewidth* is a line width to be stroked. This is meant to be used to correct the location of the head so that it does not overshoot the destination point, but not all classes support it. c@s.eZdZdZedd„ƒZdd„Zd dd„Zd 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<|ddtjkrDtdƒ‚|dd|dd•S)a3 Some ArrowStyle class only works with a simple quadratic Bezier curve (created with Arc3Connetion or Angle3Connector). This static method is to check if the provided path is a simple quadratic Bezier curve and returns its control points if true. r rrz,'path' is not a valid quadratic Bezier curve)ÚlistZ iter_segmentsr8rrr¼rz)rDZsegmentsr?r?r@Úensure_quadratic_bezierV s  z(ArrowStyle._Base.ensure_quadratic_beziercCs tdƒ‚dS)a’ The transmute method is the very core of the ArrowStyle class and must be overridden in the subclasses. It receives the path object along which the arrow will be drawn, and the mutation_size, with which the arrow head etc. will be scaled. The linewidth may be used to adjust the path so that it does not pass beyond the given points. It returns a tuple of a Path instance and a boolean. The boolean value indicate whether the path can be filled or not. The return value can also be a list of paths and list of booleans of a same length. zDerived must overrideN)r›)r:rDr¨rr?r?r@r©e s zArrowStyle._Base.transmuteçð?cCsìt|ƒ}|dk rÚ|jdd…|jdd…}}|dd…df||dd…df<t||ƒ}| |||¡\}} t | ¡rÐg} xNt|ƒD]B} | j| j} } | dd…df|| dd…df<|  t| | ƒ¡q‚W| | fS|| fSn| |||¡SdS)z‹ The __call__ method is a thin wrapper around the transmute method and takes care of the aspect ratio. Nr) rrrrr©rÚiterablerhr‹)r:rDr¨rr«rrZ path_shrunkZ path_mutatedÚfillableÚ path_listr¶rrkr?r?r@r¬s s"      zArrowStyle._Base.__call__N)r)rržrŸr Ú staticmethodrr©r¬r?r?r?r@r¡E s  r¡cs2eZdZdZd ‡fdd„ Zdd „Zd d „Z‡ZS) zArrowStyle._Curvea* A simple arrow which will work with any path instance. The returned path is simply concatenation of the original path + at most two paths representing the arrow head at the begin point and the at the end point. The arrow heads can be either open or closed. NFçš™™™™™É?çš™™™™™¹?cs8|||_|_|||_|_|||_|_tƒ ¡dS)a> The arrows are drawn if *beginarrow* and/or *endarrow* are true. *head_length* and *head_width* determines the size of the arrow relative to the *mutation scale*. The arrowhead at the begin (or end) is closed if fillbegin (or fillend) is True. N)Ú beginarrowÚendarrowr5r4Ú fillbeginÚfillendr3r#)r:rrrrr5r4)r9r?r@r#œ s 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. gà?rr)r»r%rrr)r:rÚrÛrÜrÝÚ head_distÚcos_tÚsin_trr'r(Z cp_distanceZ pad_projectedr r rürýrÿrÚvertices_arrowÚ codes_arrowr?r?r@Ú_get_arrow_wedge« s$       $"z"ArrowStyle._Curve._get_arrow_wedgec CsL|j|}|j|}t |d|d¡}||||}}|jd\} } |jd\} } |jon| | kol| | k } | r–| | | | | ||||¡\}}}}ngg}}d\}}|jd\}}|jd\}}|joÚ||koØ||k }|r| ||||||||¡\}}}}ngg}}d\}}tt   | || |fg|jdd…||||fgg¡|j ƒg}dg}| rÐ|j r¶t   ||d|dgg¡}t   |tj tjgg¡}| t||ƒ¡| d¡n| t||ƒ¡| d¡|rD|jr*| d¡t   ||d|dgg¡}t   |tj tjgg¡}| t||ƒ¡n| d¡| t||ƒ¡||fS) Nr rr)ggr0r FT)r5r4rFrHrrr#rrr»rrrrrr‹r)r:rDr¨rr5r4rrr rÚrÛrÜrÝZhas_begin_arrowÚ verticesAÚcodesAZddxAZddyArKrLZx3Zy3Z has_end_arrowÚ verticesBÚcodesBZddxBZddyBr÷Z _fillabler¶rkr?r?r@r©Ö s\              zArrowStyle._Curve.transmute)NNFFrr)rržrŸr r#r#r©r:r?r?)r9r@Ú_Curve” s  +r(ú-)rcs eZdZdZ‡fdd„Z‡ZS)zArrowStyle.Curvez8 A simple curve without any arrow head. cstƒjddddS)NF)rr)r3r#)r:)r9r?r@r#! szArrowStyle.Curve.__init__)rržrŸr r#r:r?r?)r9r@ÚCurve sr*z<-cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveAz: An arrow with a head at its begin point. çš™™™™™Ù?çš™™™™™É?cstƒjdd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head TF)rrr5r4N)r3r#)r:r5r4)r9r?r@r#* s zArrowStyle.CurveA.__init__)r+r,)rržrŸr r#r:r?r?)r9r@ÚCurveA$ sr-z->cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveBz8 An arrow with a head at its end point. çš™™™™™Ù?çš™™™™™É?cstƒjdd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head FT)rrr5r4N)r3r#)r:r5r4)r9r?r@r#= s zArrowStyle.CurveB.__init__)r.r/)rržrŸr r#r:r?r?)r9r@ÚCurveB7 sr0z<->cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveABzJ An arrow with heads both at the begin and the end point. çš™™™™™Ù?çš™™™™™É?cstƒjdd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head T)rrr5r4N)r3r#)r:r5r4)r9r?r@r#P s zArrowStyle.CurveAB.__init__)r1r2)rržrŸr r#r:r?r?)r9r@ÚCurveABJ sr3z<|-cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveFilledAzB An arrow with filled triangle head at the begin. çš™™™™™Ù?çš™™™™™É?cstƒjdddd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head TF)rrrrr5r4N)r3r#)r:r5r4)r9r?r@r#c s z ArrowStyle.CurveFilledA.__init__)r4r5)rržrŸr r#r:r?r?)r9r@Ú CurveFilledA] sr6z-|>cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveFilledBz@ An arrow with filled triangle head at the end. çš™™™™™Ù?çš™™™™™É?cstƒjdddd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head FT)rrrrr5r4N)r3r#)r:r5r4)r9r?r@r#w s z ArrowStyle.CurveFilledB.__init__)r7r8)rržrŸr r#r:r?r?)r9r@Ú CurveFilledBq sr9z<|-|>cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.CurveFilledABzC An arrow with filled triangle heads at both ends. çš™™™™™Ù?çš™™™™™É?cstƒjdddd||ddS)zþ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.2 Width of the arrow head T)rrrrr5r4N)r3r#)r:r5r4)r9r?r@r#‹ s z!ArrowStyle.CurveFilledAB.__init__)r:r;)rržrŸr r#r:r?r?)r9r@Ú CurveFilledAB… sr<c @s&eZdZd dd„Zdd„Zdd „ZdS) zArrowStyle._BracketNçð?çš™™™™™É?c CsJ|||_|_|||_|_|||_|_|||_|_| | |_|_ dS)N) ÚbracketAÚbracketBÚwidthAÚwidthBÚlengthAÚlengthBròróÚscaleAÚscaleB) r:r?r@rArBrCrDròrórErFr?r?r@r#› s zArrowStyle._Bracket.__init__cCs~ddlm}||||||ƒ\}} } } ||||} } || | | f|| f| | f| | | | fg}tjtjtjtjg}||fS)Nr)Úget_normal_points)Zmatplotlib.bezierrGrrr)r:rÚrÛrr rÓr7rGrÜrÝrKrLr'r(r!r"r?r?r@Ú _get_bracket¦ s z ArrowStyle._Bracket._get_bracketc CsN|jdkr|}n|j}|jdkr&|}n|j}gg}}|jr¢|jd\}} |jd\} } t| | || ƒ\} } | || | | |j||j|¡\}}| |¡| |¡| |j¡| |j ¡|j r(|jd\}} |jd\} } t| | || ƒ\} } | || | | |j ||j |¡\}}| |¡| |¡t  |¡}t  |¡}t||ƒ}|dfS)Nrrr r0F)rErFr?rr rHrArCr‹rr@rBrDr»rr)r:rDr¨rrErFZ vertices_listZ codes_listrÚrÛrÜrÝrr r$r%r&r'rrr¶r?r?r@r©º s>              zArrowStyle._Bracket.transmute) NNr=r=r>r>NNNN)rržrŸr#rHr©r?r?r?r@Ú_Bracket™ s rIz]-[cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.BracketABz: An arrow with a bracket(]) at both ends. çð?çš™™™™™É?Nc s tƒjdd||||||ddS)a€ Parameters ---------- widthA : float, optional, default : 1.0 Width of the bracket lengthA : float, optional, default : 0.2 Length of the bracket angleA : float, optional, default : None Angle between the bracket and the line widthB : float, optional, default : 1.0 Width of the bracket lengthB : float, optional, default : 0.2 Length of the bracket angleB : float, optional, default : None Angle between the bracket and the line T)rArCròrBrDróN)r3r#)r:rArCròrBrDró)r9r?r@r#ì s zArrowStyle.BracketAB.__init__)rJrKNrJrKN)rržrŸr r#r:r?r?)r9r@Ú BracketABæ srLz]-cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.BracketAz9 An arrow with a bracket(]) at its end. çð?çš™™™™™É?Ncstƒjdd|||ddS)a] Parameters ---------- widthA : float, optional, default : 1.0 Width of the bracket lengthA : float, optional, default : 0.2 Length of the bracket angleA : float, optional, default : None Angle between the bracket and the line TN)rArCrò)r3r#)r:rArCrò)r9r?r@r#s zArrowStyle.BracketA.__init__)rMrNN)rržrŸr r#r:r?r?)r9r@ÚBracketAsrOz-[cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.BracketBz9 An arrow with a bracket([) at its end. çð?çš™™™™™É?Ncstƒjdd|||ddS)a] Parameters ---------- widthB : float, optional, default : 1.0 Width of the bracket lengthB : float, optional, default : 0.2 Length of the bracket angleB : float, optional, default : None Angle between the bracket and the line NT)rBrDró)r3r#)r:rBrDró)r9r?r@r#$s zArrowStyle.BracketB.__init__)rPrQN)rržrŸr r#r:r?r?)r9r@ÚBracketBsrRz|-|cs"eZdZdZd‡fdd„ Z‡ZS)zArrowStyle.BarABz6 An arrow with a bar(|) at both ends. çð?Nc s tƒjdd|d||d|ddS)aÈ Parameters ---------- widthA : float, optional, default : 1.0 Width of the bracket angleA : float, optional, default : None Angle between the bracket and the line widthB : float, optional, default : 1.0 Width of the bracket angleB : float, optional, default : None Angle between the bracket and the line Tr)rArCròrBrDróN)r3r#)r:rAròrBró)r9r?r@r#:s zArrowStyle.BarAB.__init__)rSNrSN)rržrŸr r#r:r?r?)r9r@ÚBarAB4srTcs*eZdZdZd‡fdd„ Zdd„Z‡ZS) zArrowStyle.SimplezK A simple arrow. Only works with a quadratic Bezier curve. çà?çš™™™™™É?cs$||||_|_|_tƒ ¡dS)a_ Parameters ---------- head_length : float, optional, default : 0.5 Length of the arrow head head_width : float, optional, default : 0.5 Width of the arrow head tail_width : float, optional, default : 0.2 Width of the arrow tail N)r5r4Ú tail_widthr3r#)r:r5r4rW)r9r?r@r#VszArrowStyle.Simple.__init__cCs| |¡\}}}}}} |j|} t|| | ƒ} ||f||f|| fg} yt| | dd\} }Wn\tk r´t|| ||| ƒ\}}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 „|Dƒd d „|Dƒƒ}|d fS) Ng{®Gáz„?)Ú tolerencegà?g@)Úwmrrr cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rwŸsz/ArrowStyle.Simple.transmute..cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rwŸsT)rr5rrr rr4rrWrrrr¼rr)r:rDr¨rrÚrÛrÜrÝrKrLr5Úin_fÚ arrow_pathZ arrow_outZarrow_inÚx1nÚy1nr4Ú head_leftÚ head_rightrWÚ tail_leftÚ tail_rightÚ patch_pathr?r?r@r©gsR                       zArrowStyle.Simple.transmute)rUrUrV)rržrŸr r#r©r:r?r?)r9r@ÚSimplePsrccs*eZdZdZd‡fdd„ Zdd„Z‡ZS)zArrowStyle.FancyzJ A fancy arrow. Only works with a quadratic Bezier curve. çš™™™™™Ù?cs$||||_|_|_tƒ ¡dS)a_ Parameters ---------- head_length : float, optional, default : 0.4 Length of the arrow head head_width : float, optional, default : 0.4 Width of the arrow head tail_width : float, optional, default : 0.4 Width of the arrow tail N)r5r4rWr3r#)r:r5r4rW)r9r?r@r#©szArrowStyle.Fancy.__init__cCs| |¡\}}}}}} |j|} ||f||f|| fg} t|| | ƒ} yt| | dd\} }Wn\tk r´t|| ||| ƒ\}}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 |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„|Dƒdd„|Dƒƒ}|dfS)Ng{®Gáz„?)rXgà?gš™™™™™é?g@g333333ã?)rYgð?g333333Ó?)Zw1rYZw2r rrr cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rwsz.ArrowStyle.Fancy.transmute..cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rwsT)rr5rrr rr4rrWrrrr¼r)r:rDr¨rrÚrÛrÜrÝrKrLr5r[rZZpath_outZpath_inr\r]Z path_headZ path_tailr4Zhead_lZhead_rrWr`raZ tail_startr_r^rbr?r?r@r©ºsh                     zArrowStyle.Fancy.transmute)rdrdrd)rržrŸr r#r©r:r?r?)r9r@ÚFancy£srecs*eZdZdZd‡fdd„ Zdd„Z‡ZS) 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||_||_tƒ ¡dS)a Parameters ---------- tail_width : float, optional, default : 0.3 Width of the tail shrink_factor : float, optional, default : 0.5 Fraction of the arrow width at the middle point N)rWÚ shrink_factorr3r#)r:rWrh)r9r?r@r#s zArrowStyle.Wedge.__init__c CsÈ| |¡\}}}}}} ||f||f|| fg} t| |j|d|jd\} } tj| dftj| dftj| dftj| dftj| dftj| dftj| dfg} tdd„| Dƒdd„| Dƒƒ}|d fS) Ng@)rYrrr cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rw.sz.ArrowStyle.Wedge.transmute..cSsg|] \}}|‘qSr?r?)rrrkr¶r?r?r@rw.sT) rrrWrhrrr¼rr)r:rDr¨rrÚrÛrÜrÝrKrLr[Zb_plusZb_minusrbr?r?r@r©s       zArrowStyle.Wedge.transmute)rfrg)rržrŸr r#r©r:r?r?)r9r@r¨sr¨ÚAvailableArrowstylesN)rržrŸr r˜rÊr¡r(r¦r*r-r0r3r6r9r<rIrLrOrRrTrcrer¨rrËrr?r?r?r@r sJ#OM!Rb+r)rirc@s®eZdZdZdZdd„Zejd,d d „ƒZd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zd-dd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„ZdS).r;a% A fancy arrow patch. It draws an arrow using the :class:`ArrowStyle`. The head and tail positions are fixed at the specified start and end points of the arrow, but the size and shape (in display coordinates) of the arrow does not change when the axis is moved or zoomed. TcCsP|jdk r4|j\\}}\}}|jjd||||fS|jjdt|jƒfSdS)Nz((%g, %g)->(%g, %g))z(%s))Ú _posA_posBr9rr±Ú_path_original)r:rÜrÝrKrLr?r?r@r²Gs  zFancyArrowPatch.__str__NÚsimpleÚarc3r rcKsì|dk rtjddddd|dk r4tjdddddtj|f|Ž|dk r||dk r||dkr|||g|_|dkrpd }| |¡n.|dkr¢|dkr¢|dk r¢d|_d|_ntd ƒ‚||_| |_ | |_ | |_ ||_ |  |¡| |_| |_| |¡dS) a If *posA* and *posB* are given, a path connecting two points is created according to *connectionstyle*. The path will be clipped with *patchA* and *patchB* and further shrunken by *shrinkA* and *shrinkB*. An arrow is drawn along this resulting path using the *arrowstyle* parameter. Alternatively if *path* is provided, an arrow is drawn along this path and *patchA*, *patchB*, *shrinkA*, and *shrinkB* are ignored. Parameters ---------- posA, posB : None, tuple, optional (default: None) (x,y) coordinates of arrow tail and arrow head respectively. path : None, Path (default: None) :class:`matplotlib.path.Path` instance. If provided, an arrow is drawn along this path and *patchA*, *patchB*, *shrinkA*, and *shrinkB* are ignored. arrowstyle : str or ArrowStyle, optional (default: 'simple') Describes how the fancy arrow will be drawn. It can be string of the available arrowstyle names, with optional comma-separated attributes, or an :class:`ArrowStyle` instance. The optional attributes are meant to be scaled with the *mutation_scale*. The following arrow styles are available: %(AvailableArrowstyles)s arrow_transmuter : Ignored connectionstyle : str, ConnectionStyle, or None, optional (default: 'arc3') Describes how *posA* and *posB* are connected. It can be an instance of the :class:`ConnectionStyle` class or a string of the connectionstyle name, with optional comma-separated attributes. The following connection styles are available: %(AvailableConnectorstyles)s connector : Ignored patchA, patchB : None, Patch, optional (default: None) Head and tail patch respectively. :class:`matplotlib.patch.Patch` instance. shrinkA, shrinkB : scalar, optional (default: 2) Shrinking factor of the tail and head of the arrow respectively mutation_scale : scalar, optional (default: 1) Value with which attributes of *arrowstyle* (e.g., *head_length*) will be scaled. mutation_aspect : None, scalar, optional (default: None) The height of the rectangle will be squeezed by this value before the mutation and the mutated box will be stretched by the inverse of it. dpi_cor : scalar, optional (default: 1) dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Notes ----- Valid kwargs are: %(Patch)s Ng@zZThe "arrow_transmuter" keyword argument is not used, and will be removed in Matplotlib 3.1Úarrow_transmuterzkeyword argument)ÚmessagerZobj_typezSThe "connector" keyword argument is not used, and will be removed in Matplotlib 3.1rrmz.either posA and posB, or path need to provided)rZwarn_deprecatedrr#rjÚset_connectionstyleZ _connetorsrzràrârårærkÚset_arrowstylerÑrÒÚ set_dpi_cor)r:rêrërDÚ arrowstylernÚconnectionstylerràrârårærÔrÕÚdpi_corr>r?r?r@r#Qs>V   zFancyArrowPatch.__init__cCs||_d|_dS)zÇ dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Parameters ---------- dpi_cor : scalar TN)Ú_dpi_corrd)r:rur?r?r@rrÒs zFancyArrowPatch.set_dpi_corcCs|jS)zÁ dpi_cor is currently used for linewidth-related things and shrink factor. Mutation scale is affected by this. Returns ------- dpi_cor : scalar )rv)r:r?r?r@Ú get_dpi_corÞs 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)rjrd)r:rêrër?r?r@Ú set_positionsés   zFancyArrowPatch.set_positionscCs||_d|_dS)z™ Set the tail patch. Parameters ---------- patchA : Patch :class:`matplotlib.patch.Patch` instance. TN)ràrd)r:ràr?r?r@Ú set_patchAùs zFancyArrowPatch.set_patchAcCs||_d|_dS)z™ Set the head patch. Parameters ---------- patchB : Patch :class:`matplotlib.patch.Patch` instance. TN)rârd)r:râr?r?r@Ú set_patchBs zFancyArrowPatch.set_patchBcKsD|dkrt ¡St|tjƒs$t|ƒr,||_nt|f|Ž|_d|_dS)a€ Set the connection style. Old attributes are forgotten. Parameters ---------- connectionstyle : None, ConnectionStyle instance, or string Can be a string with connectionstyle name with optional comma-separated attributes, e.g.:: set_connectionstyle("arc,angleA=0,armA=30,rad=10") Alternatively, the attributes can be provided as keywords, e.g.:: set_connectionstyle("arc", angleA=0,armA=30,rad=10) Without any arguments (or with ``connectionstyle=None``), return available styles as a list of strings. NT)rÜrŸrGr¡rMÚ _connectorrd)r:rtršr?r?r@rps z#FancyArrowPatch.set_connectionstylecCs|jS)z? Return the :class:`ConnectionStyle` instance. )r{)r:r?r?r@Úget_connectionstyle/sz#FancyArrowPatch.get_connectionstylecKs<|dkrt ¡St|tjƒr$||_nt|f|Ž|_d|_dS)aO Set the arrow style. Old attributes are forgotten. Without arguments (or with ``arrowstyle=None``) returns available box styles as a list of strings. Parameters ---------- arrowstyle : None, ArrowStyle, str, optional (default: None) Can be a string with arrowstyle name with optional comma-separated attributes, e.g.:: set_arrowstyle("Fancy,head_length=0.2") Alternatively attributes can be provided as keywords, e.g.:: set_arrowstyle("fancy", head_length=0.2) NT)rrŸrGr¡Ú_arrow_transmuterrd)r:rsršr?r?r@rq5s  zFancyArrowPatch.set_arrowstylecCs|jS)z/ Return the arrowstyle object. )r})r:r?r?r@Úget_arrowstyleRszFancyArrowPatch.get_arrowstylecCs||_d|_dS)zg Set the mutation scale. Parameters ---------- scale : scalar TN)rÑrd)r:rûr?r?r@rÖXsz"FancyArrowPatch.set_mutation_scalecCs|jS)zd Return the mutation scale. Returns ------- scale : scalar )rÑ)r:r?r?r@r×csz"FancyArrowPatch.get_mutation_scalecCs||_d|_dS)z{ Set the aspect ratio of the bbox mutation. Parameters ---------- aspect : scalar TN)rÒrd)r:rØr?r?r@rÙmsz#FancyArrowPatch.set_mutation_aspectcCs|jS)z? Return the aspect ratio of the bbox mutation. )rÒ)r:r?r?r@rÚxsz#FancyArrowPatch.get_mutation_aspectcCs0| ¡\}}t |¡rt|ƒ}| ¡ ¡ |¡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_displaycoordrrr rArfÚtransform_path)r:r÷rr?r?r@rB~s  zFancyArrowPatch.get_pathcCs¦| ¡}|jdk rd| ¡ |jd¡}| ¡ |jd¡}| ¡|||j|j|j||j|d}n| ¡  |j ¡}|  ¡||  ¡||  ¡|| ¡ƒ\}}||fS)zN Return the mutated path of the arrow in display coordinates. Nrr)ràrâråræ)rwrjrArer|ràrârårær€rkr~r×rIrÚ)r:rurêrër÷rr?r?r@r‹s     z(FancyArrowPatch.get_path_in_displaycoordc Csâ| ¡s dS| d| ¡¡| ¡}|j|jdd|j}|jddkrLd}| |¡| |j |j ¡|  |j ¡|  |¡| d¡| | ¡¡|j}|ddkrªd}| |j¡|jr| |j¡|jdk ry| |j¡Wn tk rt d¡YnX| ¡dk r$|j| ¡Ž| | d¡¡| ¡\}}t  !|¡sX|g}|g}t" #¡}| $¡r„dd l%m&}|| $¡|ƒ}x@t'||ƒD]2\} } | r°| (|| ||¡n| (|| |d¡qW| )¡| *d¡d |_+dS) Nr‚T)rƒrFrrz6Your backend does not support setting the hatch color.gð?)r„F),r…r†r‡rˆr‰rUr/r2rŠrqrrr3r_r‹r5rŒrrVrnrfrYr4r'rgrŽr)r*rrrrr¾rrrr r7r‘r’r„rhr“r”r•rd) r:r–r—rr˜rDrr™r„r¶rîr?r?r@rš©sV             zFancyArrowPatch.draw)NNNrlNrmNNNr r rNr)N)rržrŸr rer²rrÆr#rrrwrxryrzrpr|rqr~rÖr×rÙrÚrBrršr?r?r?r@r;=sB  t         c@sZeZdZdZdd„Zejdd d „ƒZdd d„Zdd„Z dd„Z dd„Z dd„Z dd„Z dS)ÚConnectionPatchz A :class:`~matplotlib.patches.ConnectionPatch` class is to make connecting lines between two points (possibly in different axes). cCs(d|jd|jd|jd|jdfS)Nz#ConnectionPatch((%g, %g), (%g, %g))rr)Úxy1Úxy2)r:r?r?r@r²ñszConnectionPatch.__str__Nr)rmçç$@Fçð?cKsj|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 :class:`matplotlib.patches.PathPatch` =============== ====================================================== *coordsA* and *coordsB* are strings that indicate the coordinates of *xyA* and *xyB*. ================= =================================================== Property Description ================= =================================================== 'figure points' points from the lower left corner of the figure 'figure pixels' pixels from the lower left corner of the figure 'figure fraction' 0,0 is lower left of figure and 1,1 is upper, right 'axes points' points from lower left corner of axes 'axes pixels' pixels from lower left corner of axes 'axes fraction' 0,1 is lower left of axes and 1,1 is upper right 'data' use the coordinate system of the object being annotated (default) 'offset points' Specify an offset (in points) from the *xy* value 'polar' you can specify *theta*, *r* for the annotation, even in cartesian plots. Note that if you are using a polar axes, you do not need to specify polar for the coordinate system since that is the native "data" coordinate system. ================= =================================================== N)rr)rr)rêrërsrnrtrràrârårærÔrÕÚclip_onru) r‚rƒÚcoords1Úcoords2ÚaxesAÚaxesBr;r#Ú_annotation_clip)r:ZxyAZxyBZcoordsAZcoordsBrŠr‹rsrnrtrràrârårærÔrÕr‡rur>r?r?r@r#õs0@zConnectionPatch.__init__cCs|dkr|j}|dkrF|j}t| |¡ƒ}t| |¡ƒ}| ||f¡S|dkr¾|j\}}|jdkrp| ||d¡S| |||j¡\}}|j   ¡}||d9}||d9}||7}||7}||fS|dkr||} } | t   | ¡}| t   | ¡}|j}| ||f¡S|dkrz|j j}|j jj\} } } }| | } | |}||d9}||d9}|dkr`| |}|dkrr||}||fS|dkrÒ|j jj\} } } }| | } | |}|dkr¸| |}|dkrÊ||}||fS|d krò|j j}| ||f¡S|d kr„|j j}|jj\} } } }| | } | |}|dkr@| ||d}n| ||d}|dkrl|||d}n| ||d}||fS|d krî|jj\} } } }| | } | |}|dkrÂ| |}n| |}|dkrÞ||}n| |}||fS|d kr |j}| ||f¡SdS) z= calculate the pixel position of given point NÚdataz offset pointsgR@Zpolarz figure pointsrz figure pixelszfigure fractionz axes pointsz axes pixelsz axes fraction)rZZ transDatarlrârãrerÒZxycoordsrýrCZget_dpir»rIrJrDrÞrnZ transFigureZ transAxes)r:rOrPr|rZrCr'r(rDrMrrðrvrsríÚtr?r?r@rýSs”                         zConnectionPatch._get_xycCs||_d|_dS)aM set *annotation_clip* attribute. * True: the annotation will only be drawn when self.xy is inside the axes. * False: the annotation will always be drawn regardless of its position. * None: the self.xy will be checked only if *xycoords* is "data" TN)rŒrd)r:rvr?r?r@Úset_annotation_clip¹s z#ConnectionPatch.set_annotation_clipcCs|jS)z Return *annotation_clip* attribute. See :meth:`set_annotation_clip` for the meaning of return values. )rŒ)r:r?r?r@Úget_annotation_clipÆsz#ConnectionPatch.get_annotation_clipcCsž| ¡}|j\}}| |||j|j¡}|j\}}| |||j|j¡}| ¡|||j |j |j ||j |d}|  ¡|| ¡|| ¡|| ¡ƒ\}}||fS)zK Return the mutated path of the arrow in the display coord )ràrâråræ)rwr‚rýrˆrŠrƒr‰r‹r|ràrârårær~r×rIrÚ)r:rurOrPrêrër÷rr?r?r@rÍs      z(ConnectionPatch.get_path_in_displaycoordcCsª| ¡}|s|dkrL|jdkrL|j\}}| |||j|j¡}|j |¡sLdS|sb|dkr¦|jdkr¦|j\}}| |||j|j ¡}|j dkr’|j}n|j }| |¡s¦dSdS)z/Check whether the annotation needs to be drawn.NrFT) rrˆr‚rýrŠrZrNr‰rƒr‹)r:r–rvrOrPZxy_pixelrZr?r?r@Ú _check_xyês     zConnectionPatch._check_xycCs4|dk r||_| ¡r | |¡s$dSt ||¡dS)N)Z _rendererr…r‘r;rš)r:r–r?r?r@ršs zConnectionPatch.draw)NNNr)NrmNNNr„r„r…NFr†)N)rržrŸr r²rrÆr#rýrrrr‘ršr?r?r?r@rìs. P f r)NT)rON)r )N)Hr¤rFZnumbersrrr)Znumpyr»Z matplotlibr$rzrrrrrror Zbezierr r r r rrrrrrrDrZ_define_aliasesr"rZkwdocZpatchdocrOZinterpdr9rÆr#r°r¤r¦rr§r¨r©rªr Z deprecatedr«r¬r­r¥r®rprqr„rr’rÊr“r¦r§r˜r¯rÜrrr;rr?r?r?r@Úsš  0     @*Vg[CcgS,a   8di@ 2