o îÇ hmyã @sÎdZddlZddlZddlZddlmZmZddlZddlZ ddl Z ddl m Z mZmZmZmZmZmZmZmZmZmZddlmZmZe   ddgd d gd d ggd ¢ddgdgdœ¡Gdd„dej!ƒƒZ"Gdd„de"ƒZ#Gdd„de#ƒZ$Gdd„de#ƒZ%Gdd„de%ƒZ&Gdd„de#ƒZ'Gdd„de'ƒZ(Gd d!„d!e'ƒZ)Gd"d#„d#e"ƒZ*Gd$d%„d%e*ƒZ+Gd&d'„d'e#ƒZ,Gd(d)„d)e"ƒZ-Gd*d+„d+e"ƒZ.Gd,d-„d-e"ƒZ/Gd.d/„d/ƒZ0Gd0d1„d1e0e"ƒZ1Gd2d3„d3e0e%ƒZ2dS)4ay Classes for the efficient drawing of large collections of objects that share most properties, e.g., a large number of line segments or polygons. The classes are not meant to be as flexible as their single element counterparts (e.g., you may not be able to select all line styles) but they are meant to be fast for common use cases (e.g., a large set of solid line segments). éN)ÚNumberÚRealé) Ú_apiÚ_pathÚartistÚcbookÚ colorizerÚcolorsÚ _docstringÚhatchÚlinesÚpathÚ transforms)Ú JoinStyleÚCapStyleÚ antialiasedsÚaaÚ edgecolorsÚecÚ facecolorsÚfc)Ú linestylesÚdashesÚlsÚ linewidthsÚlwÚ transOffset)Ú antialiasedÚ edgecolorÚ facecolorÚ linestyleÚ linewidthÚoffset_transformcseZdZdZe d¡ZdZej dddddddddddddddddœ‡fd d „ ƒZ d d „Z d d„Z dd„Z dd„Zdd„Zdd„Zdidd„Zdd„Zejdd„ƒZdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Z d3d4„Z!d5d6„Z"d7d8„Z#ej d9d:„ƒZ$ej d;d<„ƒZ%ej d=d>„ƒZ&ej d?d@„ƒZ'e(dAdB„ƒZ)dCdD„Z*dEdF„Z+dGdH„Z,dIdJ„Z-dKdL„Z.dMdN„Z/dOdP„Z0dQdR„Z1dSdT„Z2dUdV„Z3dWdX„Z4dYdZ„Z5d[d\„Z6ej7j8je6_d]d^„Z9d_d`„Z:dadb„Z;dcdd„Z‡Z?S)jÚ CollectionaÅ Base class for Collections. Must be subclassed to be usable. A Collection represents a sequence of `.Patch`\es that can be drawn more efficiently together than individually. For example, when a single path is being drawn repeatedly at different offsets, the renderer can typically execute a ``draw_marker()`` call much more efficiently than a series of repeated calls to ``draw_path()`` with the offsets put in one-by-one. Most properties of a collection can be configured per-element. Therefore, Collections have "plural" versions of many of the properties of a `.Patch` (e.g. `.Collection.get_paths` instead of `.Patch.get_path`). Exceptions are the *zorder*, *hatch*, *pickradius*, *capstyle* and *joinstyle* properties, which can only be set globally for the whole collection. Besides these exceptions, all properties can be specified as single values (applying to all elements) or sequences of values. The property of the ``i``\th element of the collection is:: prop[i % len(prop)] Each Collection can optionally be used as its own `.ScalarMappable` by passing the *norm* and *cmap* parameters to its constructor. If the Collection's `.ScalarMappable` matrix ``_A`` has been set (via a call to `.Collection.set_array`), then at draw time this internal scalar mappable will be used to set the ``facecolors`` and ``edgecolors``, ignoring those that were manually passed in. ©rér&FNÚsolidg@r)rrrrÚcapstyleÚ joinstylerÚoffsetsr#ÚnormÚcmapr Ú pickradiusr ÚurlsÚzorderc sFtƒ | | | | ¡¡dg|_dg|_dg|_dg|_d|_d|_d|_ d|_ t   t jd¡|_t jd|_| |¡| |¡| |¡| |¡| |¡| | ¡| |¡| |¡| |¡|rk| |¡nd|_|rv| |¡nd|_|durt |t ¡}|j!dkr|ddd…f}||_"| |_#d|_$| %|¡d|_&dS)aË Parameters ---------- edgecolors : :mpltype:`color` or list of colors, default: :rc:`patch.edgecolor` Edge color for each patch making up the collection. The special value 'face' can be passed to make the edgecolor match the facecolor. facecolors : :mpltype:`color` or list of colors, default: :rc:`patch.facecolor` Face color for each patch making up the collection. linewidths : float or list of floats, default: :rc:`patch.linewidth` Line width for each patch making up the collection. linestyles : str or tuple or list thereof, default: 'solid' Valid strings are ['solid', 'dashed', 'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples should be of the form:: (offset, onoffseq), where *onoffseq* is an even length tuple of on and off ink lengths in points. For examples, see :doc:`/gallery/lines_bars_and_markers/linestyles`. capstyle : `.CapStyle`-like, default: 'butt' Style to use for capping lines for all paths in the collection. Allowed values are %(CapStyle)s. joinstyle : `.JoinStyle`-like, default: 'round' Style to use for joining lines for all paths in the collection. Allowed values are %(JoinStyle)s. antialiaseds : bool or list of bool, default: :rc:`patch.antialiased` Whether each patch in the collection should be drawn with antialiasing. offsets : (float, float) or list thereof, default: (0, 0) A vector by which to translate each patch after rendering (default is no translation). The translation is performed in screen (pixel) coordinates (i.e. after the Artist's transform is applied). offset_transform : `~.Transform`, default: `.IdentityTransform` A single transform which will be applied to each *offsets* vector before it is used. cmap, norm Data normalization and colormapping parameters. See `.ScalarMappable` for a detailed description. hatch : str, optional Hatching pattern to use in filled paths, if any. Valid strings are ['/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*']. See :doc:`/gallery/shapes_and_collections/hatch_style_reference` for the meaning of each hatch type. pickradius : float, default: 5.0 If ``pickradius <= 0``, then `.Collection.contains` will return ``True`` whenever the test point is inside of one of the polygons formed by the control points of a Path in the Collection. On the other hand, if it is greater than 0, then we instead check if the test point is contained in a stroke of width ``2*pickradius`` following any of the Paths in the Collection. urls : list of str, default: None A URL for each patch to link to once drawn. Currently only works for the SVG backend. See :doc:`/gallery/misc/hyperlinks_sgskip` for examples. zorder : float, default: 1 The drawing order, shared by all Patches in the Collection. See :doc:`/gallery/misc/zorder_demo` for all defaults and examples. **kwargs Remaining keyword arguments will be used to set properties as ``Collection.set_{key}(val)`` for each key-value pair in *kwargs*. ©rNrNz hatch.colorzhatch.linewidth©é)'ÚsuperÚ__init__Ú_get_colorizerÚ_us_linestylesÚ _linestylesÚ_us_lwÚ _linewidthsÚ _gapcolorÚ_face_is_mappedÚ_edge_is_mappedÚ_mapped_colorsÚmcolorsÚto_rgbaÚmplÚrcParamsÚ _hatch_colorÚ_hatch_linewidthÚ set_facecolorÚ set_edgecolorÚ set_linewidthÚ set_linestyleÚset_antialiasedÚset_pickradiusÚset_urlsÚ set_hatchÚ set_zorderÚ set_capstyleÚ _capstyleÚ set_joinstyleÚ _joinstyleÚnpÚ asanyarrayÚfloatÚshapeÚ_offsetsÚ_offset_transformÚ _path_effectsÚ_internal_updateÚ_paths)Úselfrrrrr(r)rr*r#r+r,r r-r r.r/Úkwargs©Ú __class__©új/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/matplotlib/collections.pyr4NsFS                zCollection.__init__cCó|jS©N©rY©rZr^r^r_Ú get_pathsÔózCollection.get_pathscCs||_d|_dS©NT©rYÚstale)rZÚpathsr^r^r_Ú set_paths×s zCollection.set_pathscCr`ra)Ú _transformsrcr^r^r_Úget_transformsÛrezCollection.get_transformscCsJ|jdur t ¡|_|jSt|jtjƒs"t|jdƒr"|j |j¡|_|jS)zóz*Collection.get_datalim..)Ú get_transformrsrorrnÚcontains_branchÚBboxÚnullrdÚlenÚ is_affineÚ get_offsetsÚanyÚcontains_branch_seperatelyrQÚmaÚ MaskedArrayÚfilledÚnanÚmpathÚget_path_collection_extentsÚ get_affinerlÚtransform_non_affineÚfrozenrUr}Úmasked_invalidÚmaskÚallÚupdate_from_data_xy)rZÚ transDataÚ offset_trfrir*Úbboxr^r|r_Ú get_datalimòs: ÿ     ü      zCollection.get_datalimcCs| t ¡¡Sra)r™rrn©rZÚrendererr^r^r_Úget_window_extent7szCollection.get_window_extentc s.| ¡‰| ¡}| ¡}| ¡}| ¡rhg}| ¡D]/}|j}|dd…df|dd…df}}| |¡}| |¡}| t   t   ||g¡|j ¡¡q| |dd…df¡}| |dd…df¡}t j  ||g¡}ˆjsx‡fdd„|Dƒ}ˆ ¡‰|js„| |¡}| ¡}t|t jjƒr‘| t j¡}ˆ|||fS)Nrrcrvr^rw)rzrr|r^r_r~Qsÿz.Collection._prepare_points..)r€rsr†rdÚ have_unitsÚverticesÚconvert_xunitsÚconvert_yunitsÚappendrÚPathrQÚ column_stackÚcodesr‰r…rrrorŠr‹rŒ)rZr—r*rirržÚxsÚysr^r|r_Ú_prepare_points<s4 "    ÿ   zCollection._prepare_pointscCs| ¡sdS| |jj| ¡¡| ¡| ¡\}}}}| ¡}| |¡|  |  ¡¡|j rA|  |j ¡|  |j¡| |j¡| ¡durN|j| ¡Ž| ¡r_ddlm}|| ¡|ƒ}| ¡}| ¡} | ¡} d} t|ƒdkrÙt|ƒdkrÙt| ƒdkrÙt| ƒdkrÙt|jƒdkrÙtdd„|jDƒƒrÙt|jƒdkrÙt|jƒdkrÙ| ¡durÙt|ƒr¸t  !|d¡|} n|} |d "| ¡} | j#|j$ddj%j#krÙ| j&|j$ddj%j&krÙd} |j'râ| (|j'¡|j)rë| *|j)¡| r-| +t,| dƒ¡| -|jd¡|j.|jdŽ| /|jd¡| 0|jd¡| 1||d|  2¡t3 4|¡|t,| dƒ¡nF|j5durV| 6¡\}}| 7|| 2¡|| ¡||t8 9d ¡g|j5|j||j|jd ¡ | 7|| 2¡|| ¡||| ¡| ¡|j|j|j|jd ¡ | :¡| ;|jj¡d|_‡ó€z"Collection.draw..T©ÚrootÚnoneÚscreen)=Ú get_visibleÚ open_groupr]Ú__name__Úget_gidÚupdate_scalarmappabler§Únew_gcÚ _set_gc_clipÚset_snapÚget_snapÚ_hatchrKÚset_hatch_colorrBÚset_hatch_linewidthrCÚget_sketch_paramsÚset_sketch_paramsÚget_path_effectsÚmatplotlib.patheffectsr¨rlÚ get_facecolorÚ get_edgecolorr„r9r”r7Ú _antialiasedsÚ_urlsÚ get_hatchrÚAffine2DÚ get_extentsÚwidthÚ get_figurer˜ÚheightrPrOrNrMÚset_foregroundÚtuplerFÚ set_dashesrHÚset_urlÚ draw_markersr‘rr¢r:Ú_get_inverse_paths_linestylesÚdraw_path_collectionr>r?ÚrestoreÚ close_grouprh)rZr›r}r—r*riÚgcr¨ÚtransrrÚdo_single_path_optimizationÚcombined_transformÚextentsÚipathsÚ ilinestylesr^r^r_Údraw`sŒ      ÿ   þ    ú   ú zCollection.drawcCs"t|tƒs td|›ƒ‚||_dS)z§ Set the pick radius used for containment tests. Parameters ---------- pickradius : float Pick radius, in points. z-pickradius must be a real-valued number, not N)rorÚ ValueErrorÚ _pickradius)rZr-r^r^r_rIºs ÿ zCollection.set_pickradiuscCr`ra)rÛrcr^r^r_Úget_pickradiusÈrezCollection.get_pickradiusc Cs | |¡s | ¡s difSt|jtƒr|jdurt|jƒn|j}|jr(|j ¡|  ¡\}}}}t   |j |j || ¡|| ¡|||dk¡ }t|ƒdkt|dfS)z² Test whether the mouse event occurred in the collection. Returns ``bool, dict(ind=itemlist)``, where every item in itemlist contains the event. FTr)Úind)Ú_different_canvasr¯roÚ_pickerrrSrÛrrÚ_unstale_viewLimr§rÚpoint_in_path_collectionÚxÚyr‘rlr„Údict)rZÚ mouseeventr-r}r—r*rirÝr^r^r_ÚcontainsËs" ÿ  þü   ýzCollection.containscCs|dur|ndg|_d|_dS)zß Parameters ---------- urls : list of str or None Notes ----- URLs are currently only implemented by the SVG backend. They are ignored by all other backends. NT)rÂrh)rZr.r^r^r_rJçs zCollection.set_urlscCr`)zÑ Return a list of URLs, one for each element of the collection. The list contains *None* for elements without a URL. See :doc:`/gallery/misc/hyperlinks_sgskip` for an example. )rÂrcr^r^r_Úget_urlsõszCollection.get_urlscCst |¡||_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. Unlike other properties such as linewidth and colors, hatching can only be specified for the collection as a whole, not separately for each member. Parameters ---------- hatch : {'/', '\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'} TN)ÚmhatchÚ_validate_hatch_patternr¸rh)rZr r^r^r_rKþs  zCollection.set_hatchcCr`)z$Return the current hatching pattern.)r¸rcr^r^r_rà ózCollection.get_hatchcCrt)zSet the hatch linewidth.N©rC©rZrr^r^r_rº$ó zCollection.set_hatch_linewidthcCr`)zReturn the hatch linewidth.rërcr^r^r_Úget_hatch_linewidth(rêzCollection.get_hatch_linewidthc CsŒt |¡}|jdkr|ddd…f}t|tjjƒrtjjntj}|t | |dd…df¡t¡t |  |dd…df¡t¡fƒ|_ d|_ dS)zˆ Set the offsets for the collection. Parameters ---------- offsets : (N, 2) or (2,) array-like r1NrrT) rQrRrTror‰rŠr£rŸrSr rUrh)rZr*Úcstackr^r^r_Ú set_offsets,s  ÿÿÿ zCollection.set_offsetscCs|jdur t d¡S|jS)z&Return the offsets for the collection.N©rr2)rUrQÚzerosrcr^r^r_r†>szCollection.get_offsetscCó tjdS)Nzpatch.linewidth©r@rArcr^r^r_Ú_get_default_linewidthCríz!Collection._get_default_linewidthcCs>|dur| ¡}t |¡|_| |j|j¡\|_|_d|_dS)zû Set the linewidth(s) for the collection. *lw* can be a scalar or a sequence; if it is a sequence the patches will cycle through the sequence Parameters ---------- lw : float or list of floats NT) rõrQÚ atleast_1dr8Ú _bcast_lwlsr6r9r7rhrìr^r^r_rFGs   ÿ zCollection.set_linewidthc Csˆzt |¡g}Wn*ty2z dd„|Dƒ}Wnty/}z d|›d}t|ƒ|‚d}~wwYnw||_| |j|j¡\|_|_dS)a­ Set the linestyle(s) for the collection. =========================== ================= 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 : str or tuple or list thereof Valid values for individual linestyles include {'-', '--', '-.', ':', '', (offset, on-off-seq)}. See `.Line2D.set_linestyle` for a complete description. cSóg|]}t |¡‘qSr^)ÚmlinesÚ_get_dash_pattern©rzrâr^r^r_r~yrz,Collection.set_linestyle..zDo not know how to convert z to dashesN)rùrúrÚr6r÷r8r9r7)rZrrÚerrÚemsgr^r^r_rG[s    €þÿþÿzCollection.set_linestylecCót|ƒ|_dS)z  Set the `.CapStyle` for the collection (for all its elements). Parameters ---------- cs : `.CapStyle` or %(CapStyle)s N)rrN)rZÚcsr^r^r_rM…ó zCollection.set_capstylecCó|jr|jjSdS)z Return the cap style for the collection (for all its elements). Returns ------- %(CapStyle)s or None N)rNÚnamercr^r^r_Ú get_capstyleó zCollection.get_capstylecCrþ)z£ Set the `.JoinStyle` for the collection (for all its elements). Parameters ---------- js : `.JoinStyle` or %(JoinStyle)s N)rrP)rZÚjsr^r^r_rO›rzCollection.set_joinstylecCr)z‘ Return the join style for the collection (for all its elements). Returns ------- %(JoinStyle)s or None N)rPrrcr^r^r_Ú get_joinstyle¦rzCollection.get_joinstylecCsztjdr ||fSt|ƒt|ƒkr/t|ƒ}t|ƒ}t ||¡}t|ƒ||}t|ƒ||}dd„t||ƒDƒ}||fS)aÈ Internal helper function to broadcast + scale ls/lw In the collection drawing code, the linewidth and linestyle are cycled through as circular buffers (via ``v[i % len(v)]``). Thus, if we are going to scale the dash pattern at set time (not draw time) we need to do the broadcasting now and expand both lists to be the same length. Parameters ---------- linewidths : list line widths of collection dashes : list dash specification (offset, (dash pattern tuple)) Returns ------- linewidths, dashes : list Will be the same length, dashes are scaled by paired linewidth z_internal.classic_modecSs"g|] \\}}}t |||¡‘qSr^)rùÚ _scale_dashes)rzÚoÚdrr^r^r_r~Òs ÿz*Collection._bcast_lwls..)r@rAr„ÚmathÚgcdÚlistÚzip)rrÚl_dashesÚl_lwr r^r^r_r÷±s  ÿzCollection._bcast_lwlscCr`)zs Get the antialiasing state for rendering. Returns ------- array of bools )rÁrcr^r^r_Úget_antialiased×ózCollection.get_antialiasedcCs.|dur| ¡}t t |t¡¡|_d|_dS)z… Set the antialiasing state for rendering. Parameters ---------- aa : bool or list of bools NT)Ú_get_default_antialiasedrQröÚasarrayÚboolrÁrh)rZrr^r^r_rHás zCollection.set_antialiasedcCró)Nzpatch.antialiasedrôrcr^r^r_rîríz#Collection._get_default_antialiasedcCs| |¡| |¡dS)a1 Set both the edgecolor and the facecolor. Parameters ---------- c : :mpltype:`color` or list of RGBA tuples See Also -------- Collection.set_facecolor, Collection.set_edgecolor For setting the edge or face color individually. N)rDrE©rZÚcr^r^r_Ú set_coloròs zCollection.set_colorcCró)Nzpatch.facecolorrôrcr^r^r_Ú_get_default_facecolorríz!Collection._get_default_facecolorcCs*|dur| ¡}t ||j¡|_d|_dSrf)rr>Ú to_rgba_arrayÚ_alphaÚ _facecolorsrhrr^r^r_Ú_set_facecolors zCollection._set_facecolorcCó2t|tƒr| ¡dvr| ¡}||_| |¡dS)an Set the facecolor(s) of the collection. *c* can be a color (all patches have same color), or a sequence of colors; if it is a sequence the patches will cycle through the sequence. If *c* is 'none', the patch will not be filled. Parameters ---------- c : :mpltype:`color` or list of :mpltype:`color` ©r­ÚfaceN)roÚstrÚlowerÚ_original_facecolorrrr^r^r_rD s zCollection.set_facecolorcCr`ra)rrcr^r^r_r¿rezCollection.get_facecolorcCst |jd¡r | ¡S|jS)Nr)rÚ _str_equalÚ _edgecolorsr¿rcr^r^r_rÀ!szCollection.get_edgecolorcCró)Nzpatch.edgecolorrôrcr^r^r_Ú_get_default_edgecolor'ríz!Collection._get_default_edgecolorcCsd}|durtjds|jst |jd¡r| ¡}nd}d}t |d¡r,d|_d|_ dSt   ||j ¡|_|rCt |jƒrCt|jdƒ|_d|_ dS)NTzpatch.force_edgecolorr­Frr)r@rAÚ _edge_defaultrr#r"r%Ú_str_lower_equalr$rhr>rrr„rÊrB)rZrr¹r^r^r_Ú_set_edgecolor+s$ ÿ þ   zCollection._set_edgecolorcCr)a' Set the edgecolor(s) of the collection. Parameters ---------- c : :mpltype:`color` or list of :mpltype:`color` or 'face' The collection edgecolor(s). If a sequence, the patches cycle through it. If 'face', match the facecolor. rN)ror r!Ú_original_edgecolorr(rr^r^r_rE>s zCollection.set_edgecolorcCs*tj ||¡| |j¡| |j¡dS)a„ Set the transparency of the collection. Parameters ---------- alpha : float or array of float or None If not None, *alpha* values must be between 0 and 1, inclusive. If an array is provided, its length must match the number of elements in the collection. Masked values and nans are not supported. N)rÚArtistÚ_set_alpha_for_arrayrr"r(r)©rZÚalphar^r^r_Ú set_alphaPs zCollection.set_alphacCr`ra)r9rcr^r^r_Ú get_linewidthbrezCollection.get_linewidthcCr`ra)r7rcr^r^r_Ú get_linestyleerezCollection.get_linestylecCs”|j}|j}d|_d|_|jdur.t |jd¡s&d|_t |jd¡r%d|_n|jdur.d|_|jp3|j}|dupE|dupE|j|kpE|j|k}|pI|S)aF Determine whether edges and/or faces are color-mapped. This is a helper for update_scalarmappable. It sets Boolean flags '_edge_is_mapped' and '_face_is_mapped'. Returns ------- mapping_change : bool True if either flag is True, or if a flag has changed. FNr­Tr)r<r;Ú_Arr#r"r))rZÚedge0Úface0ÚmappedÚchangedr^r^r_Ú_set_mappable_flagshs& €  ÿþzCollection._set_mappable_flagscCsÔ| ¡sdS|jdurI|jjdkrt|tƒstdƒ‚t |j¡r@|jj |jj kr7td|jj ›d|jj ›dƒ‚|j  |jj ¡|_|  |j|j¡|_ |jrQ|j |_n| |j¡|jr_|j |_n| |j¡d|_dS)z Update colors from the scalar mappable array, if any. Assign colors to edges and faces based on the array and/or colors that were directly set, as appropriate. Nrz&Collections can only map rank 1 arrayszData array shape, z) is incompatible with alpha array shape, z†. This can occur with the deprecated behavior of the "flat" shading option, in which a row and/or column of the data array is dropped.T)r6r1ÚndimroÚ _MeshDatarÚrQÚiterablerÚsizerTÚreshaper?r=r;rrr"r<r$r(r)rhrcr^r^r_r³Šs*   þÿ      z Collection.update_scalarmappablecCst |jd¡ S)zReturn whether face is colored.r­)rr'r"rcr^r^r_Úget_fill°szCollection.get_fillcCs˜tj ||¡|j|_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_|j|_|j|_|j|_|j|_d|_dS)z#Copy properties from other to self.TN)rr*Ú update_fromrÁr=r<r)r$r;r"rr9r7r6rÛr¸r1r+r,rh)rZÚotherr^r^r_r=´s$ zCollection.update_fromra)@r±Ú __module__Ú __qualname__Ú__doc__rQÚemptyrkr&r Úinterpdr4rdrjrlrsrur™rœr§rÚallow_rasterizationrÙrIrÜrærJrçrKrÃrºrîrðr†rõrFrGrMrrOrÚ staticmethodr÷rrHrrrrrDr¿rÀr%r(rEr.r*r+r/r0r6r³r<r=Ú __classcell__r^r^r\r_r$sš #ð  E$ Y "*     %   "&r$cs<eZdZdZdZdd„Zd dd„Zej‡fdd „ƒZ ‡Z S) Ú_CollectionWithSizeszA Base class for collections that have an array of sizes. çð?cCr`)z¦ Return the sizes ('areas') of the elements in the collection. Returns ------- array The 'area' of each element. )Ú_sizesrcr^r^r_Ú get_sizesÓs z_CollectionWithSizes.get_sizesçR@cCs¦|durt g¡|_t d¡|_n=t |¡|_t t|jƒddf¡|_t |j¡|d|j }||jdd…ddf<||jdd…ddf<d|jdd…ddf<d |_ dS) aI Set the sizes of each member of the collection. Parameters ---------- sizes : `numpy.ndarray` or None The size to set for each element of the collection. The value is the 'area' of the element. dpi : float, default: 72 The dpi of the canvas. Nr%r&rKrrrHr2T) rQÚarrayrIrBrkrròr„ÚsqrtÚ_factorrh)rZÚsizesÚdpiÚscaler^r^r_Ú set_sizesÞs   z_CollectionWithSizes.set_sizescs(| |j|jddj¡tƒ |¡dS)NTr«)rRrIrÇrPr3rÙršr\r^r_rÙösz_CollectionWithSizes.draw)rK) r±r?r@rArNrJrRrrDrÙrFr^r^r\r_rGÍs rGcs@eZdZdZd ‡fdd„ Zdd„Zdddd d „fd d „Z‡ZS)ÚPathCollectionzO A collection of `~.path.Path`\s, as created by e.g. `~.Axes.scatter`. Nc s0tƒjdi|¤Ž| |¡| |¡d|_dS)a› Parameters ---------- paths : list of `.path.Path` The paths that will make up the `.Collection`. sizes : array-like The factor by which to scale each drawn `~.path.Path`. One unit squared in the Path's data space is scaled to be ``sizes**2`` points when rendered. **kwargs Forwarded to `.Collection`. TNr^)r3r4rjrRrh)rZrirOr[r\r^r_r4s   zPathCollection.__init__cCr`rarbrcr^r^r_rdrezPathCollection.get_pathsr ÚautocCs|Srar^)râr^r^r_ÚszPathCollection.cKsîg}g}| ¡du}|durtjjddd}n t|tƒr"tj |¡}| ¡|dkrF|s5t  d¡||fSt   | ¡¡} |  dtj d¡} n|d krXt   | ¡¡} |  d d ¡} ntd |›d ƒ‚|| ƒ} |j |  ¡|  ¡¡|j |  ¡|  ¡¡|dkrˆd}t| ƒ|krˆd}|dur“| } || ƒ}ny|dkrœ| ¡}n|d kr¤| ¡}t|tjjƒr®|}nt  |¡rºtj |¡}nt|ƒ}tjj||dgd¢d}| ||ƒ ¡||ƒ ¡¡}|||ƒ ¡k|||ƒ ¡k@}||}t  | ¡| ¡d¡}||ƒ}t  |¡}t  |||||¡} | ¡d|  ¡dœ|¥}t!| |ƒD]T\}}|dkr0| "| #|¡¡} n|d krCt  $|¡} t  %| d¡rCqt&j'dgdgfd| | | (¡ddœ|¤Ž}| )|¡t*|dƒrh| +|¡||ƒ}| )|¡q||fS)a Create legend handles and labels for a PathCollection. Each legend handle is a `.Line2D` representing the Path that was drawn, and each label is a string that represents the Path. This is useful for obtaining a legend for a `~.Axes.scatter` plot; e.g.:: scatter = plt.scatter([1, 2, 3], [4, 5, 6], c=[7, 2, 3], num=None) plt.legend(*scatter.legend_elements()) creates three legend elements, one for each color with the numerical values passed to *c* as the labels. Also see the :ref:`automatedlegendcreation` example. Parameters ---------- prop : {"colors", "sizes"}, default: "colors" If "colors", the legend handles will show the different colors of the collection. If "sizes", the legend will show the different sizes. To set both, use *kwargs* to directly edit the `.Line2D` properties. num : int, None, "auto" (default), array-like, or `~.ticker.Locator` Target number of elements to create. If None, use all unique elements of the mappable array. If an integer, target to use *num* elements in the normed range. If *"auto"*, try to determine which option better suits the nature of the data. The number of created elements may slightly deviate from *num* due to a `~.ticker.Locator` being used to find useful locations. If a list or array, use exactly those elements for the legend. Finally, a `~.ticker.Locator` can be provided. fmt : str, `~matplotlib.ticker.Formatter`, or None (default) The format or formatter to use for the labels. If a string must be a valid input for a `.StrMethodFormatter`. If None (the default), use a `.ScalarFormatter`. func : function, default: ``lambda x: x`` Function to calculate the labels. Often the size (or color) argument to `~.Axes.scatter` will have been pre-processed by the user using a function ``s = f(x)`` to make the markers visible; e.g. ``size = np.log10(x)``. Providing the inverse of this function here allows that pre-processing to be inverted, so that the legend labels have the correct values; e.g. ``func = lambda x: 10**x``. **kwargs Allowed keyword arguments are *color* and *size*. E.g. it may be useful to set the color of the markers if *prop="sizes"* is used; similarly to set the size of the markers if *prop="colors"* is used. Any further parameters are passed onto the `.Line2D` instance. This may be useful to e.g. specify a different *markeredgecolor* or *alpha* for the legend handles. Returns ------- handles : list of `.Line2D` Visual representation of each element of the legend. labels : list of str The string labels for elements of the legend. NFT)Ú useOffsetÚ useMathTextr zfCollection without array used. Make sure to specify the values to be colormapped via the `c` argument.r:zlines.markersizerOÚcolorÚkz?Valid values for `prop` are 'colors' or 'sizes'. You supplied 'z ' instead.rTé r)rr2g@r&éééé )ÚnbinsÚ min_n_ticksÚstepsér)Úmarkeredgewidthr-gÚ)rrXÚmsÚmarkerÚset_locs),Ú get_arrayr@ÚtickerÚScalarFormatterror ÚStrMethodFormatterÚcreate_dummy_axisÚwarningsÚwarnrQÚuniqueÚpoprArJrÚÚaxisÚset_view_intervalÚminÚmaxÚset_data_intervalr„ÚLocatorr9Ú FixedLocatorÚintÚ MaxNLocatorÚ tick_valuesÚlinspaceÚargsortÚinterpÚget_linewidthsÚ get_alphar r,r+rMÚiscloserùÚLine2Drdr¡rqrg)rZÚpropÚnumÚfmtÚfuncr[ÚhandlesÚlabelsÚhasarrayÚur:rXÚfuÚvaluesÚ label_valuesÚarrÚlocÚcondÚyarrÚxarrÚixÚkwÚvalÚlabÚhÚlr^r^r_Úlegend_elementss”?     ÿ    ÿÿ  ÿþ    ÿÿ   zPathCollection.legend_elementsra)r±r?r@rAr4rdr˜rFr^r^r\r_rSüsÿrScs:eZdZd ddœ‡fdd„ Zd dd„ZeZdd „Z‡ZS) ÚPolyCollectionNT)Úclosedc s2tƒjdi|¤Ž| |¡| ||¡d|_dS)aA Parameters ---------- verts : list of array-like The sequence of polygons [*verts0*, *verts1*, ...] where each element *verts_i* defines the vertices of polygon *i* as a 2D array-like of shape (M, 2). sizes : array-like, default: None Squared scaling factors for the polygons. The coordinates of each polygon *verts_i* are multiplied by the square-root of the corresponding entry in *sizes* (i.e., *sizes* specify the scaling of areas). The scaling is applied before the Artist master transform. closed : bool, default: True Whether the polygon should be closed by adding a CLOSEPOLY connection at the end. **kwargs Forwarded to `.Collection`. TNr^)r3r4rRÚ set_vertsrh)rZÚvertsrOršr[r\r^r_r4¦s   zPolyCollection.__init__csd|_t|tjjƒr| t¡ tj¡}|sdd„|Dƒ|_ dSt|tj ƒrit |j ƒdkritj ||dd…dd…ffdd}tj|j dtjjd‰tjjˆdd…<tjjˆd <tjjˆd <‡fd d„|Dƒ|_ dSg|_ |D]}t |ƒr|j  tj |¡¡qn|j  t |¡¡qndS) aÈ Set the vertices of the polygons. Parameters ---------- verts : list of array-like The sequence of polygons [*verts0*, *verts1*, ...] where each element *verts_i* defines the vertices of polygon *i* as a 2D array-like of shape (M, 2). closed : bool, default: True Whether the polygon should be closed by adding a CLOSEPOLY connection at the end. TcSrør^©rr¢©rzÚxyr^r^r_r~Órz,PolyCollection.set_verts..Nr&r©rq©Údtyperéÿÿÿÿcsg|]}t |ˆ¡‘qSr^rrž©r¤r^r_r~ßó)rhrorQr‰rŠÚastyperSr‹rŒrYÚndarrayr„rTÚ concatenaterBrr¢Ú code_typeÚLINETOÚMOVETOÚ CLOSEPOLYr¡Ú_create_closed)rZrœršÚ verts_padrŸr^r¤r_r›¿s("  üzPolyCollection.set_vertscCs8t|ƒt|ƒkr tdƒ‚dd„t||ƒDƒ|_d|_dS)z$Initialize vertices with path codes.zB'codes' must be a 1D list or array with the same length of 'verts'cSs.g|]\}}t|ƒrt ||¡nt |¡‘qSr^)r„rr¢)rzrŸÚcdsr^r^r_r~ðs"ÿz6PolyCollection.set_verts_and_codes..TN)r„rÚr rYrh)rZrœr¤r^r^r_Úset_verts_and_codesës ÿ z"PolyCollection.set_verts_and_codesra)T)r±r?r@r4r›rjr°rFr^r^r\r_r™¤s  *r™csœeZdZdZddddœ‡fdd„ Zedd„ƒZed d „ƒZdd œd d „Z dd„Z dd„Z dd„Z edd„ƒZ dd„Zedd„ƒZedd„ƒZdd„Z‡ZS)ÚFillBetweenPolyCollectionzK `.PolyCollection` that fills the area between two x- or y-curves. NF)ÚwhereÚ interpolateÚstepc  s:||_||_||_| ||||¡} tƒj| fi|¤ŽdS)aY Parameters ---------- t_direction : {{'x', 'y'}} The axes on which the variable lies. - 'x': the curves are ``(t, f1)`` and ``(t, f2)``. - 'y': the curves are ``(f1, t)`` and ``(f2, t)``. t : array-like The ``t_direction`` coordinates of the nodes defining the curves. f1 : array-like or float The other coordinates of the nodes defining the first curve. f2 : array-like or float The other coordinates of the nodes defining the second curve. where : array-like of bool, optional Define *where* to exclude some {dir} regions from being filled. The filled regions are defined by the coordinates ``t[where]``. More precisely, fill between ``t[i]`` and ``t[i+1]`` if ``where[i] and where[i+1]``. Note that this definition implies that an isolated *True* value between two *False* values in *where* will not result in filling. Both sides of the *True* position remain unfilled due to the adjacent *False* values. interpolate : bool, default: False This option is only relevant if *where* is used and the two curves are crossing each other. Semantically, *where* is often used for *f1* > *f2* or similar. By default, the nodes of the polygon defining the filled region will only be placed at the positions in the *t* array. Such a polygon cannot describe the above semantics close to the intersection. The t-sections containing the intersection are simply clipped. Setting *interpolate* to *True* will calculate the actual intersection point and extend the filled region up to this point. step : {{'pre', 'post', 'mid'}}, optional Define *step* if the filling should be a step function, i.e. constant in between *t*. The value determines where the step will occur: - 'pre': The f value is continued constantly to the left from every *t* position, i.e. the interval ``(t[i-1], t[i]]`` has the value ``f[i]``. - 'post': The y value is continued constantly to the right from every *x* position, i.e. the interval ``[t[i], t[i+1])`` has the value ``f[i]``. - 'mid': Steps occur half-way between the *t* positions. **kwargs Forwarded to `.PolyCollection`. See Also -------- .Axes.fill_between, .Axes.fill_betweenx N)Ú t_directionÚ _interpolateÚ_stepÚ _make_vertsr3r4) rZrµÚtÚf1Úf2r²r³r´r[rœr\r^r_r4ùs @z"FillBetweenPolyCollection.__init__cCs*|dkrdS|dkr dSd|›}t|ƒ‚)z/The direction that is other than `t_direction`.rârãz$t_direction must be 'x' or 'y', got )rÚ)rµÚmsgr^r^r_Ú _f_dir_from_t?s  z'FillBetweenPolyCollection._f_dir_from_tcCs | |j¡S)z4The direction that is other than `self.t_direction`.)r½rµrcr^r^r_Ú _f_directionJs z&FillBetweenPolyCollection._f_direction)r²cCs<|j |j|j|||¡\}}}| ||||¡}| |¡dS)a- Set new values for the two bounding curves. Parameters ---------- t : array-like The ``self.t_direction`` coordinates of the nodes defining the curves. f1 : array-like or float The other coordinates of the nodes defining the first curve. f2 : array-like or float The other coordinates of the nodes defining the second curve. where : array-like of bool, optional Define *where* to exclude some {dir} regions from being filled. The filled regions are defined by the coordinates ``t[where]``. More precisely, fill between ``t[i]`` and ``t[i+1]`` if ``where[i] and where[i+1]``. Note that this definition implies that an isolated *True* value between two *False* values in *where* will not result in filling. Both sides of the *True* position remain unfilled due to the adjacent *False* values. See Also -------- .PolyCollection.set_verts, .Line2D.set_data N)rrÚ_fill_between_process_unitsrµr¾r¸r›)rZr¹rºr»r²rœr^r^r_Úset_dataOs  ÿz"FillBetweenPolyCollection.set_datacCs8tj ¡}| | ¡| t |j|jj gg¡¡¡|S)z7Calculate the data limits and return them as a `.Bbox`.) rr‚rƒr•r€r}rQr¨Ú_bboxÚminpos)rZr–Údatalimr^r^r_r™qs ÿz%FillBetweenPolyCollection.get_datalimc sšˆ ˆjˆjˆˆˆ¡ˆ ˆˆˆˆ¡‰tjt ˆ¡ˆˆdd\‰‰‰tj  ¡ˆ_ ˆj   ˆ  t  ‡‡fdd„ˆˆfDƒ¡¡¡‡‡‡‡fdd„t ˆ¡DƒS)zH Make verts that can be forwarded to `.PolyCollection`. T)Úsubokcs&g|]}tjˆˆ|ˆfdd‘qS)r£r )rQÚstack)rzÚf)r¹r²r^r_r~‚sÿz9FillBetweenPolyCollection._make_verts..c s"g|] \}}ˆ ˆˆˆ||¡‘qSr^)Ú_make_verts_for_region)rzÚidx0Úidx1)rºr»rZr¹r^r_r~…sÿÿ)Ú_validate_shapesrµr¾Ú_get_data_maskrQÚbroadcast_arraysrörr‚rƒrÁr•Ú_fix_pts_xy_orderr¨rÚcontiguous_regions)rZr¹rºr»r²r^)rºr»rZr¹r²r_r¸xs  ÿþz%FillBetweenPolyCollection._make_vertsc Csh|durd}ntj|td}|j|jkr"d |j|j|j¡}t|ƒ‚|t tj t tj j |||gƒ¡@S)zõ Return a bool array, with True at all points that should eventually be rendered. The array is True at a point if none of the data inputs *t*, *f1*, *f2* is masked and if the input *where* is true at that point. NTr¡z-where size ({}) does not match {!r} size ({})) rQrrr:ÚformatrµrÚÚ functoolsÚreduceÚ logical_orÚmapr‰Ú getmaskarray)rZr¹rºr»r²r¼r^r^r_rËŠs  ÿÿz(FillBetweenPolyCollection._get_data_maskc CsŒdd„t|||fdƒDƒ}t||||gƒD].\}}|jdkr%t|›dƒ‚|jdkrC|jdkrC|j|jkrCd ||j||j¡}t|ƒ‚qdS)zFValidate that t, f1 and f2 are 1-dimensional and have the same length.css|] \}}||VqdSrar^)rzr Úsr^r^r_r©Ÿrªz=FillBetweenPolyCollection._validate_shapes..)rdÚ1Ú2rz is not 1-dimensionalz4{!r} has size {}, but {!r} has an unequal size of {}N)r r7rÚr:rÏ) Út_dirÚf_dirr¹rºr»ÚnamesrrLr¼r^r^r_rÊœs   ÿ€úz*FillBetweenPolyCollection._validate_shapesc Csê|||…}|||…}|||…}|jdur(tjd|j} | |||ƒ\}}}|jr<| ||||¡} | ||||¡} n|d|df} |d|df} t t | g¡tj||fddt | g¡tj||fddddd…f¡} |  | ¡S)z‘ Make ``verts`` for a contiguous region between ``idx0`` and ``idx1``, taking into account ``step`` and ``interpolate``. Nzsteps-rr£r ) r·rÚSTEP_LOOKUP_MAPr¶Ú_get_interpolating_pointsrQr¨rrÅrÍ) rZr¹rºr»rÈrÉÚt_sliceÚf1_sliceÚf2_sliceÚ step_funcÚstartÚendÚptsr^r^r_rǨs$      ü z0FillBetweenPolyCollection._make_verts_for_regionc Cs¾t|ddƒ}|||d…}|||d…|||d…}|||d…}t|ƒdkrMtj |d¡r=||||fStj |d¡rM||||fS| d||¡} | | ||¡} | | fS)zCalculate interpolating points.rrr2)rtr„rQr‰Ú is_maskedÚ_get_diff_root) Úclsr¹rºr»ÚidxÚim1Út_valuesÚ diff_valuesÚ f1_valuesÚ diff_root_tÚ diff_root_fr^r^r_rÜÅs  z3FillBetweenPolyCollection._get_interpolating_pointscCs| ¡}t |||||¡S)zCalculate diff root.)r|rQr})râÚxpÚfpÚorderr^r^r_rå×sz(FillBetweenPolyCollection._get_diff_rootcCs$|jdkr|dd…ddd…fS|S)zÐ Fix pts calculation results with `self.t_direction`. In the workflow, it is assumed that `self.t_direction` is 'x'. If this is not true, we need to exchange the coordinates. rãNr£)rµ)rZrãr^r^r_rÍÝs$z+FillBetweenPolyCollection._fix_pts_xy_order)r±r?r@rAr4rEr½Úpropertyr¾rÀr™r¸rËrÊrÇÚ classmethodrÜrårÍrFr^r^r\r_r±õs(þF  "    r±csXeZdZdZejjZej dZ dddœ‡fdd„ Z dd „Z d d „Z ejd d „ƒZ‡ZS)ÚRegularPolyCollectionz)A collection of n-sided regular polygons.çà¿r)r)ÚrotationrOc sHtƒjdi|¤Ž| |¡||_| |¡g|_||_| t  ¡¡dS)aš Parameters ---------- numsides : int The number of sides of the polygon. rotation : float The rotation of the polygon in radians. sizes : tuple of float The area of the circle circumscribing the polygon in points^2. **kwargs Forwarded to `.Collection`. Examples -------- See :doc:`/gallery/event_handling/lasso_demo` for a complete example:: offsets = np.random.rand(20, 2) facecolors = [cm.jet(x) for x in np.random.rand(20)] collection = RegularPolyCollection( numsides=5, # a pentagon rotation=0, sizes=(50,), facecolors=facecolors, edgecolors=("black",), linewidths=(1,), offsets=offsets, offset_transform=ax.transData, ) Nr^) r3r4rRÚ _numsidesÚ_path_generatorrYÚ _rotationÚ set_transformrrn)rZÚnumsidesrõrOr[r\r^r_r4ís # zRegularPolyCollection.__init__cCr`ra)rörcr^r^r_Ú get_numsidesrez"RegularPolyCollection.get_numsidescCr`ra)rørcr^r^r_Ú get_rotationrez"RegularPolyCollection.get_rotationcs>ˆ ˆjˆjddj¡‡fdd„ˆjDƒˆ_t ˆ|¡dS)NTr«cs$g|]}t |¡ ˆj ¡ ¡‘qSr^)rrÄÚrotaterøÚ get_matrixrûrcr^r_r~ sÿÿz.RegularPolyCollection.draw..)rRrIrÇrPrkr$rÙršr^rcr_rÙs  þzRegularPolyCollection.draw)r±r?r@rArr¢Úunit_regular_polygonr÷rQÚpirNr4rûrürrDrÙrFr^r^r\r_róçs ü*róc@óeZdZdZejjZdS)ÚStarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)r±r?r@rArr¢Úunit_regular_starr÷r^r^r^r_r)ó rc@r)ÚAsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)r±r?r@rArr¢Úunit_regular_asteriskr÷r^r^r^r_r.rrcs¦eZdZdZdZddœ‡fdd„ Zdd„ZeZeZd d „Z d d „Z d d„Z dd„Z dd„Z ‡fdd„Zdd„ZeZdd„ZeZdd„Zdd„Zdd„Zdd „Z‡ZS)!ÚLineCollectiona­ Represents a sequence of `.Line2D`\s that should be drawn together. This class extends `.Collection` to represent a sequence of `.Line2D`\s instead of just a sequence of `.Patch`\s. Just as in `.Collection`, each property of a *LineCollection* may be either a single value or a list of values. This list is then used cyclically for each element of the LineCollection, so the property of the ``i``\th element of the collection is:: prop[i % len(prop)] The properties of each member of a *LineCollection* default to their values in :rc:`lines.*` instead of :rc:`patch.*`, and the property *colors* is added in place of *edgecolors*. Tr2)r/c s0| dd¡tƒjdd|i|¤Ž| |¡dS)a½ Parameters ---------- segments : list of (N, 2) array-like A sequence ``[line0, line1, ...]`` where each line is a (N, 2)-shape array-like containing points:: line0 = [(x0, y0), (x1, y1), ...] Each line can contain a different number of points. linewidths : float or list of float, default: :rc:`lines.linewidth` The width of each line in points. colors : :mpltype:`color` or list of color, default: :rc:`lines.color` A sequence of RGBA tuples (e.g., arbitrary color strings, etc, not allowed). antialiaseds : bool or list of bool, default: :rc:`lines.antialiased` Whether to use antialiasing for each line. zorder : float, default: 2 zorder of the lines once drawn. facecolors : :mpltype:`color` or list of :mpltype:`color`, default: 'none' When setting *facecolors*, each line is interpreted as a boundary for an area, implicitly closing the path from the last point to the first point. The enclosed area is filled with *facecolor*. In order to manually specify what should count as the "interior" of each line, please use `.PathCollection` instead, where the "interior" can be specified by appropriate usage of `~.path.Path.CLOSEPOLY`. **kwargs Forwarded to `.Collection`. rr­r/Nr^)Ú setdefaultr3r4Ú set_segments)rZÚsegmentsr/r[r\r^r_r4Gs & ÿþzLineCollection.__init__cCs&|durdSdd„|Dƒ|_d|_dS)NcSs6g|]}t|tjjƒrt |¡nt t |t¡¡‘qSr^)rorQr‰rŠrr¢rrS)rzÚsegr^r^r_r~ws þÿz/LineCollection.set_segments..Trg)rZr r^r^r_r ss þ zLineCollection.set_segmentscCs>g}|jD]}dd„|jddDƒ}t |¡}| |¡q|S)z¤ Returns ------- list List of segments in the LineCollection. Each list item contains an array of vertices. cSsg|]\}}|‘qSr^r^)rzÚvertexÚ_r^r^r_r~Šsÿÿz/LineCollection.get_segments..F)Úsimplify)rYÚ iter_segmentsrQrr¡)rZr rržr^r^r_Ú get_segmentss  ú  zLineCollection.get_segmentscCró)Nzlines.linewidthrôrcr^r^r_rõ—ó z%LineCollection._get_default_linewidthcCró)Nzlines.antialiasedrôrcr^r^r_ršrz'LineCollection._get_default_antialiasedcCró)Nz lines.colorrôrcr^r^r_r%rz%LineCollection._get_default_edgecolorcCsdS)Nr­r^rcr^r^r_r sz%LineCollection._get_default_facecolorcs*tƒ |¡|jdur| |j¡dSdSra)r3r.r:Ú set_gapcolorÚ_original_gapcolorr,r\r^r_r.£s  ÿzLineCollection.set_alphacCs| |¡dS)aH Set the edgecolor(s) of the LineCollection. Parameters ---------- c : :mpltype:`color` or list of :mpltype:`color` Single color (all lines have same color), or a sequence of RGBA tuples; if it is a sequence the lines will cycle through the sequence. N)rErr^r^r_r©s zLineCollection.set_colorcCr`ra)r$rcr^r^r_Ú get_color¸rezLineCollection.get_colorcCs||_| |¡dS)a1 Set a color to fill the gaps in the dashed line style. .. note:: Striped lines are created by drawing two interleaved dashed lines. There can be overlaps between those two, which may result in artifacts when using transparency. This functionality is experimental and may change. Parameters ---------- gapcolor : :mpltype:`color` or list of :mpltype:`color` or None The color with which to fill the gaps. If None, the gaps are unfilled. N)rÚ _set_gapcolor©rZÚgapcolorr^r^r_r½szLineCollection.set_gapcolorcCs&|dur t ||j¡}||_d|_dSrf)r>rrr:rhrr^r^r_rÒs zLineCollection._set_gapcolorcCr`ra)r:rcr^r^r_Ú get_gapcolorØrezLineCollection.get_gapcolorcCs&dd„t|jt |j¡ƒDƒ}t|ŽS)a% Returns the path and pattern for the gaps in the non-solid lines. This path and pattern is the inverse of the path and pattern used to construct the non-solid lines. For solid lines, we set the inverse path to nans to prevent drawing an inverse line. cSs>g|]\}}|dkrt t dtj¡¡|fn|tj|Žf‘qS)r0rñ)rr¢rQÚfullrŒrùÚ_get_inverse_dash_pattern)rzrrr^r^r_r~ãs þÿ ýz@LineCollection._get_inverse_paths_linestyles..)r rYÚ itertoolsÚcycler7)rZÚ path_patternsr^r^r_rÎÛsûz,LineCollection._get_inverse_paths_linestyles)r±r?r@rAr&r4r r›rjrrõrr%rr.rÚ set_colorsrÚ get_colorsrrrrÎrFr^r^r\r_r3s,þ,   rcs¸eZdZdZdZ d'dddddddœ‡fd d „ Zd d „Zd d„Zdd„ZeZ Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd „Z‡fd!d"„Z‡fd#d$„Zd%d&„Z‡ZS)(ÚEventCollectionzÐ A collection of locations along a single axis at which an "event" occurred. The events are given by a 1-dimensional array. They do not have an amplitude and are displayed as parallel lines. TÚ horizontalrrNr')Ú lineoffsetÚ linelengthr"rXr!rc  sHtƒjgf||||dœ| ¤Žd|_||_||_| |¡| |¡dS)aY Parameters ---------- positions : 1D array-like Each value is an event. orientation : {'horizontal', 'vertical'}, default: 'horizontal' The sequence of events is plotted along this direction. The marker lines of the single events are along the orthogonal direction. lineoffset : float, default: 0 The offset of the center of the markers from the origin, in the direction orthogonal to *orientation*. linelength : float, default: 1 The total height of the marker (i.e. the marker stretches from ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``). linewidth : float or list thereof, default: :rc:`lines.linewidth` The line width of the event lines, in points. color : :mpltype:`color` or list of :mpltype:`color`, default: :rc:`lines.color` The color of the event lines. linestyle : str or tuple or list thereof, default: 'solid' Valid strings are ['solid', 'dashed', 'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples should be of the form:: (offset, onoffseq), where *onoffseq* is an even length tuple of on and off ink in points. antialiased : bool or list thereof, default: :rc:`lines.antialiased` Whether to use antialiasing for drawing the lines. **kwargs Forwarded to `.LineCollection`. Examples -------- .. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py )rrr rTN)r3r4Ú_is_horizontalÚ _linelengthÚ _lineoffsetÚset_orientationÚ set_positions) rZÚ positionsÚ orientationr"r#r"rXr!rr[r\r^r_r4÷s 0þý zEventCollection.__init__cs&| ¡rdnd‰‡fdd„| ¡DƒS)zX Return an array containing the floating-point values of the positions. rrcsg|]}|dˆf‘qS)rr^)rzÚsegment©Úposr^r_r~6r¥z1EventCollection.get_positions..)Ú is_horizontalrrcr^r,r_Ú get_positions1szEventCollection.get_positionscCsÈ|durg}t |¡dkrtdƒ‚| ¡}| ¡}| ¡rdnd}t t|ƒddf¡}t |¡dd…df|dd…dd…|f<||d|dd…dd|f<||d|dd…dd|f<|  |¡dS)z Set the positions of the events.Nrz!positions must be one-dimensionalrr2) rQr7rÚÚget_lineoffsetÚget_linelengthr.rBr„Úsortr )rZr)r"r#Úpos_idxr r^r^r_r(8s(zEventCollection.set_positionscCsL|dust|dƒrt|ƒdkrdS| ¡}t |t |¡g¡}| |¡dS)z2Add one or more events at the specified positions.Nr„r)rqr„r/rQÚhstackrRr()rZÚpositionr)r^r^r_Ú add_positionsGs  zEventCollection.add_positionscCr`)z=True if the eventcollection is horizontal, False if vertical.)r$rcr^r^r_r.QrêzEventCollection.is_horizontalcCs| ¡rdSdS)zX Return the orientation of the event line ('horizontal' or 'vertical'). r!Úvertical)r.rcr^r^r_Úget_orientationUszEventCollection.get_orientationcCsH| ¡}t|ƒD] \}}t |¡||<q| |¡| ¡ |_d|_dS)zv Switch the orientation of the event line, either from vertical to horizontal or vice versus. TN)rÚ enumeraterQÚfliplrr r.r$rh)rZr Úir+r^r^r_Úswitch_orientation[s    z"EventCollection.switch_orientationcCs0tjdddœ|d}|| ¡krdS| ¡dS)z Set the orientation of the event line. Parameters ---------- orientation : {'horizontal', 'vertical'} TF)r!r7)r*N)rÚ check_getitemr.r<)rZr*r.r^r^r_r'gsþ  zEventCollection.set_orientationcCr`)z7Return the length of the lines used to mark each event.)r%rcr^r^r_r1vrêzEventCollection.get_linelengthcCsv|| ¡krdS| ¡}| ¡}| ¡rdnd}|D]}||d|d|f<||d|d|f<q| |¡||_dS)z4Set the length of the lines used to mark each event.Nrrç@)r1r0rr.r r%)rZr#r"r r-r+r^r^r_Úset_linelengthzó   zEventCollection.set_linelengthcCr`)z7Return the offset of the lines used to mark each event.)r&rcr^r^r_r0‡rêzEventCollection.get_lineoffsetcCsv|| ¡krdS| ¡}| ¡}| ¡rdnd}|D]}||d|d|f<||d|d|f<q| |¡||_dS)z4Set the offset of the lines used to mark each event.Nrrr>)r0r1rr.r r&)rZr"r#r r-r+r^r^r_Úset_lineoffset‹r@zEventCollection.set_lineoffsetcstƒ ¡dS)z3Get the width of the lines used to mark each event.r©r3r/rcr\r^r_r/˜szEventCollection.get_linewidthcs tƒ ¡SrarBrcr\r^r_r~œrzEventCollection.get_linewidthscCs | ¡dS)z6Return the color of the lines used to mark each event.r)rrcr^r^r_rŸó zEventCollection.get_color)r!)r±r?r@rAr&r4r/r(r6Úextend_positionsÚappend_positionsr.r8r<r'r1r?r0rAr/r~rrFr^r^r\r_r ís6þ÷:   r cs*eZdZdZejdZ‡fdd„Z‡ZS)ÚCircleCollectionz-A collection of circles, drawn using splines.rôc s<tƒjdi|¤Ž| |¡| t ¡¡tj ¡g|_ dS)z½ Parameters ---------- sizes : float or array-like The area of each circle in points^2. **kwargs Forwarded to `.Collection`. Nr^) r3r4rRrùrrnrr¢Ú unit_circlerY)rZrOr[r\r^r_r4©s zCircleCollection.__init__) r±r?r@rArQrrNr4rFr^r^r\r_rF¤s rFcspeZdZdZddœ‡fdd„ Zdd„Zdd „Zd d „Zd d „Zdd„Z dd„Z dd„Z e j ‡fdd„ƒZ‡ZS)ÚEllipseCollectionz.A collection of ellipses, drawn using splines.Úpoints)Úunitsc sbtƒjdi|¤Ž| |¡| |¡| |¡||_| t ¡¡t   d¡|_ t j  ¡g|_dS)a° Parameters ---------- widths : array-like The lengths of the first axes (e.g., major axis lengths). heights : array-like The lengths of second axes. angles : array-like The angles of the first axes, degrees CCW from the x-axis. units : {'points', 'inches', 'dots', 'width', 'height', 'x', 'y', 'xy'} The units in which majors and minors are given; 'width' and 'height' refer to the dimensions of the axes, while 'x' and 'y' refer to the *offsets* data units. 'xy' differs from all others in that the angle as plotted varies with the aspect ratio, and equals the specified angle only when the aspect ratio is unity. Hence it behaves the same as the `~.patches.Ellipse` with ``axes.transData`` as its transform. **kwargs Forwarded to `Collection`. r%Nr^)r3r4Ú set_widthsÚ set_heightsÚ set_anglesÚ_unitsrùrrnrQrBrkrr¢rGrY)rZÚwidthsÚheightsÚanglesrJr[r\r^r_r4»s    zEllipseCollection.__init__c CsÐ|j}|jdd}|jdkrd}nT|jdkr|jj|jj}nF|jdkr-|jj|jj}n8|jdkr6|j}n/|jdkrA|jd }n$|jd krK|jj}n|jd krU|jj}n|jd kr]d }ntd|j›ƒ‚t   t |j ƒddf¡|_ |j |}|j|}t  |j¡}t  |j¡}|||j dd…ddf<|| |j dd…ddf<|||j dd…ddf<|||j dd…ddf<d |j dd…ddf<tj}|jdkræ|j ¡ ¡ ¡} d| dd…dd…f<| || ƒ¡dSdS)z0Calculate transforms immediately before drawing.Fr«rŸrrârãÚinchesrIrKrÆrÈÚdotsrHzUnrecognized units: r&Nrr2)rrrÇrNr˜rÆÚviewLimrÈrPrÚrQròr„Ú_widthsrkÚ_heightsÚsinÚ_anglesÚcosrrÄr–rrþÚcopyrù) rZÚaxÚfigÚscrOrPÚ sin_angleÚ cos_angleÚ_affineÚmr^r^r_Ú_set_transformsÙsF                 ýz!EllipseCollection._set_transformscCódt |¡ ¡|_d|_dS)z5Set the lengths of the first axes (e.g., major axis).çà?TN)rQrÚravelrUrh)rZrOr^r^r_rKó zEllipseCollection.set_widthscCrc)ú2Set the lengths of second axes (e.g., minor axes).rdTN)rQrrerVrh)rZrPr^r^r_rLrfzEllipseCollection.set_heightscCst |¡ ¡|_d|_dS)z>Set the angles of the first axes, degrees CCW from the x-axis.TN)rQÚdeg2radrerXrh)rZrQr^r^r_rM s zEllipseCollection.set_anglescCó |jdS)z5Get the lengths of the first axes (e.g., major axis).r2)rUrcr^r^r_Ú get_widthsrízEllipseCollection.get_widthscCri)rgr2)rVrcr^r^r_Ú get_heightsrízEllipseCollection.get_heightscCs t |j¡S)z>Get the angles of the first axes, degrees CCW from the x-axis.)rQÚrad2degrXrcr^r^r_Ú get_anglesrCzEllipseCollection.get_anglescs| ¡tƒ |¡dSra)rbr3rÙršr\r^r_rÙszEllipseCollection.draw)r±r?r@rAr4rbrKrLrMrjrkrmrrDrÙrFr^r^r\r_rH¸s*rHcs.eZdZdZddœ‡fdd„ Zdd„Z‡ZS)ÚPatchCollectionzá A generic collection of patches. PatchCollection draws faster than a large number of equivalent individual Patches. It also makes it easier to assign a colormap to a heterogeneous collection of patches. F)Úmatch_originalc sŠ|r5dd„‰‡fdd„|Dƒ|d<dd„|Dƒ|d<dd„|Dƒ|d <d d„|Dƒ|d <d d„|Dƒ|d <tƒjdi|¤Ž| |¡dS)a? Parameters ---------- patches : list of `.Patch` A sequence of Patch objects. This list may include a heterogeneous assortment of different patch types. match_original : bool, default: False If True, use the colors and linewidths of the original patches. If False, new colors may be assigned by providing the standard collection arguments, facecolor, edgecolor, linewidths, norm or cmap. **kwargs All other parameters are forwarded to `.Collection`. If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their `.rcParams` patch setting, in sequence form. Notes ----- The use of `~matplotlib.cm.ScalarMappable` functionality is optional. If the `~matplotlib.cm.ScalarMappable` matrix ``_A`` has been set (via a call to `~.ScalarMappable.set_array`), at draw time a call to scalar mappable will be made to set the face colors. cSs| ¡r| ¡Sgd¢S)N)rrrr)r<r¿)Úpatchr^r^r_Údetermine_facecolorKsz5PatchCollection.__init__..determine_facecolorcsg|]}ˆ|ƒ‘qSr^r^ry©rqr^r_r~Póz,PatchCollection.__init__..rcSóg|]}| ¡‘qSr^)rÀryr^r^r_r~QrsrcSrtr^)r/ryr^r^r_r~RrsrcSrtr^)r0ryr^r^r_r~SrsrcSrtr^)rryr^r^r_r~TrsrNr^)r3r4rj)rZÚpatchesror[r\rrr_r4-szPatchCollection.__init__cCsdd„|Dƒ}||_dS)NcSsg|] }| ¡ | ¡¡‘qSr^)r€Útransform_pathÚget_pathryr^r^r_r~[sÿz-PatchCollection.set_paths..rb)rZrurir^r^r_rjZsÿ zPatchCollection.set_paths)r±r?r@rAr4rjrFr^r^r\r_rn$s-rncsJeZdZdZ‡fdd„Zdd„Zdd„Zedd „ƒZe j d d „ƒZ ‡Z S) ÚTriMeshz™ Class for the efficient drawing of a triangular mesh using Gouraud shading. A triangular mesh is a `~matplotlib.tri.Triangulation` object. c s\tƒjdi|¤Ž||_d|_tj ¡|_t  |j   dd¡|j   dd¡f¡}|j  |¡dS)NÚgouraudr£rr^)r3r4Ú_triangulationÚ_shadingrr‚ÚunitrÁrQr4râr;rãr•)rZÚ triangulationr[rŸr\r^r_r4fs  ÿzTriMesh.__init__cCó|jdur | ¡|jSra©rYrjrcr^r^r_rdsó zTriMesh.get_pathscCs| |j¡|_dSra)Úconvert_mesh_to_pathsrzrYrcr^r^r_rjxszTriMesh.set_pathscCs4| ¡}tj|j||j|fdd}dd„|DƒS)z¾ Convert a given mesh into a sequence of `.Path` objects. This function is primarily of use to implementers of backends that do not directly support meshes. r£r cSrør^rrûr^r^r_r~…rz1TriMesh.convert_mesh_to_paths..)Úget_masked_trianglesrQrÅrârã)ÚtriÚ trianglesrœr^r^r_r{szTriMesh.convert_mesh_to_pathscCsº| ¡sdS|j|jj| ¡d| ¡}|j}| ¡}tj |j ||j |fdd}|  ¡|j |}| ¡}| |¡| | ¡d¡| |||| ¡¡| ¡| |jj¡dS)N)Úgidr£r r)r¯r°r]r±r²r€rzr‚rQrÅrârãr³rr´rµrFr/Údraw_gouraud_trianglesr‘rÐrÑ)rZr›r}rƒr„rœr rÒr^r^r_rÙ‡s  z TriMesh.draw) r±r?r@rAr4rdrjrErrrDrÙrFr^r^r\r_rx`s    rxcsbeZdZdZddœdd„Z‡fdd„Zdd „Z‡fd d „Z‡fd d „Ze dd„ƒZ dd„Z ‡Z S)r8aš Class for managing the two dimensional coordinates of Quadrilateral meshes and the associated data with them. This class is a mixin and is intended to be used with another collection that will implement the draw separately. A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is defined by the vertices :: (m+1, n) ----------- (m+1, n+1) / / / / / / (m, n) -------- (m, n+1) The mesh need not be regular and the polygons need not be convex. Parameters ---------- coordinates : (M+1, N+1, 2) array-like The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates of vertex (m, n). shading : {'flat', 'gouraud'}, default: 'flat' Úflat)ÚshadingcCstjd|d||_||_dS)N)NNr2©Ú coordinates)rÚ check_shapeÚ _coordinatesr{)rZrŠrˆr^r^r_r4¹s z_MeshData.__init__c sº|jjdd…\}}|jdkr|d|d}}n||}}||df||df||f||fg}|durWt |¡}||vrWtd|›d |›d |j›d d  tt|ƒ¡›d |j› ƒ‚tƒ  |¡S)au Set the data values. Parameters ---------- A : array-like The mesh data. Supported array shapes are: - (M, N) or (M*N,): a mesh with scalar data. The values are mapped to colors using normalization and a colormap. See parameters *norm*, *cmap*, *vmin*, *vmax*. - (M, N, 3): an image with RGB values (0-1 float or 0-255 int). - (M, N, 4): an image with RGBA values (0-1 float or 0-255 int), i.e. including transparency. If the values are provided as a 2D grid, the shape must match the coordinates grid. If the values are 1D, they are reshaped to 2D. M, N follow from the coordinates grid, where the coordinates grid shape is (M, N) for 'gouraud' *shading* and (M+1, N+1) for 'flat' shading. rr£r‡rr&éNzFor X (z ) and Y (z) with z shading, A should have shape z or z, not ) rŒrTr{rQrÚÚjoinrÓr r3Ú set_array)rZÚArÈrÆr–ÚwÚ ok_shapesrTr\r^r_r¾s   " þþÿ z_MeshData.set_arraycCr`)a Return the vertices of the mesh as an (M+1, N+1, 2) array. M, N are the number of quadrilaterals in the rows / columns of the mesh, corresponding to (M+1, N+1) vertices. The last dimension specifies the components (x, y). )rŒrcr^r^r_Úget_coordinatesãrz_MeshData.get_coordinatescótƒ ¡ dd¡S©Nr£r)r3rÀr;rcr\r^r_rÀíóz_MeshData.get_edgecolorcr”r•)r3r¿r;rcr\r^r_r¿ór–z_MeshData.get_facecolorc Cs–t|tjjƒr |j}n|}tj|dd…dd…f|dd…dd…f|dd…dd…f|dd…dd…f|dd…dd…fgdd d¡}dd„|DƒS) z Convert a given mesh into a sequence of `.Path` objects. This function is primarily of use to implementers of backends that do not directly support quadmeshes. Nr£rr2r )r£r[r2cSrør^rrûr^r^r_r~ rz4_MeshData._convert_mesh_to_paths..)rorQr‰rŠÚdatar¨r;)rŠrrIr^r^r_Ú_convert_mesh_to_pathsùsûúúz _MeshData._convert_mesh_to_pathsc Cs²t|tjjƒr |j}n|}|dd…dd…f}|dd…dd…f}|dd…dd…f}|dd…dd…f}||||d}tj||||||||||||g dd d¡}| ¡ g|jdd…¢d‘R¡} |  ¡} tj  | ¡rs| j nd} | dur€tj | | d f<| dd…dd…f} | dd…dd…f} | dd…dd…f}| dd…dd…f}| | ||d}tj| | || ||||||| |g dd d ¡}t  |d ¡}||||fS) zË Convert a given mesh into a sequence of triangles, each point with its own color. The result can be used to construct a call to `~.RendererBase.draw_gouraud_triangles`. Nr£rg@r2r )r£r&r2rr&)r£r&r).r2r&)rorQr‰rŠr—r¨r;r¿rTrhrär“rŒÚisnan)rZrŠr{Úp_aÚp_bÚp_cÚp_dÚp_centerr„rÚzr“Úc_aÚc_bÚc_cÚc_dÚc_centerr Útmaskr^r^r_Ú_convert_mesh_to_triangles sPüûû"üûûz$_MeshData._convert_mesh_to_triangles) r±r?r@rAr4rr“rÀr¿rEr˜r¦rFr^r^r\r_r8Ÿs %  r8csVeZdZdZdddœ‡fdd„ Zdd„Zd d „Zd d „Zej d d„ƒZ dd„Z ‡Z S)ÚQuadMeshaá Class for the efficient drawing of a quadrilateral mesh. A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is defined by the vertices :: (m+1, n) ----------- (m+1, n+1) / / / / / / (m, n) -------- (m, n+1) The mesh need not be regular and the polygons need not be convex. Parameters ---------- coordinates : (M+1, N+1, 2) array-like The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates of vertex (m, n). antialiased : bool, default: True shading : {'flat', 'gouraud'}, default: 'flat' Notes ----- Unlike other `.Collection`\s, the default *pickradius* of `.QuadMesh` is 0, i.e. `~.Artist.contains` checks whether the test point is within any of the mesh quadrilaterals. Tr‡)rrˆc sd| dd¡tƒj||dtj|fi|¤Ž||_tj ¡|_|j  |j   dd¡¡|  d¡dS)Nr-r)rŠrˆr£r2F) rr3r4r$Ú _antialiasedrr‚r|rÁr•rŒr;Ú set_mouseover)rZrŠrrˆr[r\r^r_r4[ s  zQuadMesh.__init__cCr~rarrcr^r^r_rdf r€zQuadMesh.get_pathscCs| |j¡|_d|_dSrf)r˜rŒrYrhrcr^r^r_rjk s zQuadMesh.set_pathscCs| ¡| |j¡Sra)r€Útransform_bboxrÁ)rZr–r^r^r_r™o szQuadMesh.get_datalimc Csž| ¡sdS| |jj| ¡¡| ¡}| ¡}| ¡}| ¡r=|  |dd…df¡}|  |dd…df¡}t   ||g¡}|  ¡|js[|j d¡}| |¡}| |jj¡}t ¡}n|j}|jsj| |¡}| ¡}| ¡}| | ¡¡| |¡| | ¡d¡|jdkrš| |¡\} } | || | |  ¡¡n%| !||  ¡|jdd|jdd|||| "¡ d¡|j#| $¡ d¡¡ | %¡| &|jj¡d|_'dS)Nrr)r£r2ry)r£rF)(r¯r°r]r±r²r€rsr†rrŸr rQr£r³r…rŒr;r}rTrrnrrr´r¶r·rµrFr/r{r¦r†r‘Údraw_quad_meshr¿r¨Úget_edgecolorsrÐrÑrh) rZr›r}r—r*r¥r¦rŠrÒr„r r^r^r_rÙr sN       ÿ ú z QuadMesh.drawcCs6| |¡\}}|r| ¡dur| ¡ ¡|dSdS)NrÝ)rærhre)rZÚeventÚ containedÚinfor^r^r_Úget_cursor_data£ szQuadMesh.get_cursor_data) r±r?r@rAr4rdrjr™rrDrÙr°rFr^r^r\r_r§9 s!  0r§csTeZdZdZ‡fdd„Zdd„Zdd„Z‡fdd „Z‡fd d „Z‡fd d „Z ‡Z S)Ú PolyQuadMeshas Class for drawing a quadrilateral mesh as individual Polygons. A quadrilateral mesh is a grid of M by N adjacent quadrilaterals that are defined via a (M+1, N+1) grid of vertices. The quadrilateral (m, n) is defined by the vertices :: (m+1, n) ----------- (m+1, n+1) / / / / / / (m, n) -------- (m, n+1) The mesh need not be regular and the polygons need not be convex. Parameters ---------- coordinates : (M+1, N+1, 2) array-like The vertices. ``coordinates[m, n]`` specifies the (x, y) coordinates of vertex (m, n). Notes ----- Unlike `.QuadMesh`, this class will draw each cell as an individual Polygon. This is significantly slower, but allows for more flexibility when wanting to add additional properties to the cells, such as hatching. Another difference from `.QuadMesh` is that if any of the vertices or data of a cell are masked, that Polygon will **not** be drawn and it won't be in the list of paths returned. c s0tƒj|dtj|fdgi|¤Ž| ¡dS)Nr‰rœ)r3r4r™Ú_set_unmasked_verts)rZrŠr[r\r^r_r4Ë s zPolyQuadMesh.__init__cCsôtjtj |j¡dd}|dd…dd…f|dd…dd…fB|dd…dd…fB|dd…dd…fB}| ¡}|durwtj |¡}|jdkrS|tj|ddO}|S|jdkr_||O}|S|| |jdd…dd…dd…fjdd…¡O}|S)z8Get the unmasked regions using the coordinates and arrayr£r rrNr&r2) rQr‡r‰rÔrŒrhr7r;rT)rZr“rr^r^r_Ú_get_unmasked_polysÓ sP   ü0ÿz PolyQuadMesh._get_unmasked_polysc Csf|jd}|jd}| ¡}tj |dd…dd…f¡|}tj |dd…dd…f¡|}tj |dd…dd…f¡|}tj |dd…dd…f¡|}tj |dd…dd…f¡|}tj |dd…dd…f¡|} tj |dd…dd…f¡|} tj |dd…dd…f¡|} t|ƒ} tjj|||||| | | ||g dd} |  | ddf¡}| |¡dS)N).r).rr£rr r[r2) rŒr³rQr‰r‹r„rÅr;r›)rZÚXÚYÚunmaskÚX1ÚY1ÚX2ÚY2ÚX3ÚY3ÚX4ÚY4ÚnpolyrŸrœr^r^r_r²æ s          $z PolyQuadMesh._set_unmasked_vertscó:tƒ ¡}| ¡ ¡}t|ƒt|ƒkr|S||dd…fSra)r3rÀr³rer„)rZrÚunmasked_polysr\r^r_rÀù ó  zPolyQuadMesh.get_edgecolorcrÀra)r3r¿r³rer„)rZrrÁr\r^r_r¿ rÂzPolyQuadMesh.get_facecolorcs4| ¡}tƒ |¡t || ¡¡s| ¡dSdSra)r³r3rrQÚ array_equalr²)rZrÚ prev_unmaskr\r^r_r s   ÿzPolyQuadMesh.set_array) r±r?r@rAr4r³r²rÀr¿rrFr^r^r\r_r±ª s    r±)3rArrÐr ÚnumbersrrrmÚnumpyrQÚ matplotlibr@rdrrrrr Ú mcolorizerr r>r r rèr rùrrrÚ_enumsrrÚdefine_aliasesÚColorizingArtistr$rGrSr™r±rórrrr rFrHrnrxr8r§r±r^r^r^r_Ús^ 4ú0/)QsB;8l<?q