a Sicf@ @sdZddlZddlZddlmZddlZddlZddlZ ddl m Z m Z m Z mZmZmZmZmZmZmZmZddlmZmZe ddgd d gd d ggd ddgdgdGddde jejZ Gddde Z!Gddde!Z"Gddde!Z#Gddde#Z$Gddde!Z%Gddde%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/e Z.dS)0ay 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) _api_pathartistcbookcmcolors _docstringhatchlinespath transforms) JoinStyleCapStyle antialiasedsaa edgecolorsec facecolorsfc) linestylesdashesls linewidthslw transOffset) antialiased edgecolor facecolor linestyle linewidthoffset_transformc@seZdZdZedZdZej e j ddddjd d d d Z ddZ ddZddZddZe dddddZddZdkddZddZejd d!Ze dd"d#d$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Z d4d5Z!d6d7Z"d8d9Z#d:d;Z$ej dd?Z&ej d@dAZ'dBdCZ(e)dDdEZ*dFdGZ+dHdIZ,dJdKZ-dLdMZ.dNdOZ/dPdQZ0dRdSZ1dTdUZ2dVdWZ3dXdYZ4dZd[Z5d\d]Z6ej7j8je6_d^d_Z9d`daZ:dbdcZ;dddeZdS)l 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. rr%F3.6rnameNsolid@rzordercKs>tj|tj|| | dg|_dg|_dg|_dg|_d|_ d|_ d|_ t tjd|_|||||||||||| |||| |||r||nd|_|r||nd|_|durt|t }|j!dkr|dddf}||_"| |_#d|_$|%|d|_&dS)a' Parameters ---------- edgecolors : 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 : 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: :rc:`patch.capstyle` Style to use for capping lines for all paths in the collection. Allowed values are %(CapStyle)s. joinstyle : `.JoinStyle`-like, default: :rc:`patch.joinstyle` 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. )rNrNz hatch.color)'rArtist__init__rScalarMappable_us_linestyles _linestyles_us_lw _linewidths_face_is_mapped_edge_is_mapped_mapped_colorsmcolorsto_rgbamplrcParams _hatch_color set_facecolor set_edgecolor set_linewidth set_linestyleset_antialiasedset_pickradiusset_urls set_hatchZ set_zorder set_capstyle _capstyle set_joinstyle _joinstylenp asanyarrayfloatshape_offsets_offset_transformZ _path_effects_internal_update_paths)selfrrrrcapstyle joinstyleroffsetsr"normcmap pickradiusr urlsr,kwargsr[R/var/www/html/django/DPS/env/lib/python3.9/site-packages/matplotlib/collections.pyr0MsDP                zCollection.__init__cCs|jSNrQrRr[r[r\ get_pathsszCollection.get_pathscCstdSr])NotImplementedErrorrRpathsr[r[r\ set_pathsszCollection.set_pathscCs|jSr]) _transformsr_r[r[r\get_transformsszCollection.get_transformscCsF|jdurt|_n*t|jtjs@t|jdr@|j|j|_|jS)z z*Collection.get_datalim..) get_transformrmrirrhcontains_branchBboxnull get_offsetsr`len is_affineanycontains_branch_seperatelyrJma MaskedArrayfillednanmpathget_path_collection_extents get_affinerftransform_non_affinefrozenrNrumasked_invalidmaskallupdate_from_data_xy)rR transData offset_trfrUrcbboxr[rtr\ get_datalims:           zCollection.get_datalimcCs|tSr])rrrhrRrendererr[r[r\get_window_extent/szCollection.get_window_extentc s0||}|}|}|rg}|D]^}|j}|dddf|dddf}}||}||}|t t ||g|j q4||dddf}||dddf}t ||g}jsfdd|D}|js||}|}t|t jjr$|t j}|||fS)Nrrcsg|]}|qSr[ro)rrr rtr[r\rvIsz.Collection._prepare_points..)rxrmr|r` have_unitsverticesconvert_xunitsconvert_yunitsappendrPathrJ column_stackcodesr~rrrirrrr)rRrrUrcr rxsysr[rtr\_prepare_points4s4 "      zCollection._prepare_pointscCs|s dS||jj|||\}}}}|}||| | |j rv| |j | |j|dur|j||rddlm}|||}|}|} |} d} t|dkrt|dkrt| dkrt| dkrt|jdkrtdd|jDrt|jdkrt|jdkr|durt|rxt|d|} n|} |d | } | j!|j"j#j!kr| j$|j"j#j$krd} |j%r|&|j%|j'r|(|j'| r^|)t*| d|+|jd|j,|jd|-|jd|.|jd|/||d| 0t12||t*| dn:|3||0|||||||j|j|j|jd |4|5|jjd|_6dS) Nr)PathEffectRendererFrcss|]}|dduVqdS)rNr[)rrrr[r[r\ ~rwz"Collection.draw..Tscreen)7 get_visible open_group __class____name__get_gidupdate_scalarmappablernew_gc _set_gc_clipset_snapget_snap_hatchrEset_hatch_colorr=Zget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsrrf get_facecolor get_edgecolorr}r5rr3 _antialiaseds_urls get_hatchrAffine2D get_extentswidthfigurerheightrIrHrGrFZset_foregroundtupler@Z set_dashesrBZset_urlZ draw_markersrrrZdraw_path_collectionrestore close_groupstale)rRrrurrUrcgcrtransrrZdo_single_path_optimizationZcombined_transformextentsr[r[r\drawXs                 zCollection.drawprrXcCs ||_dS)z Set the pick radius used for containment tests. Parameters ---------- pickradius : float Pick radius, in points. N _pickradius)rRrXr[r[r\rCs zCollection.set_pickradiuscCs|jSr]rr_r[r[r\get_pickradiusszCollection.get_pickradiusc Cs||\}}|dur||fS|s.difSt|jtrN|jdurNt|jn|j}|jrd|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. NFTr)ind)Z_default_containsrriZ_pickerrrLrrlZ_unstale_viewLimrrpoint_in_path_collectionxyrrfr}dict) rRZ mouseeventinsideinforXrurrUrcrr[r[r\containss(     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)rr)rRrYr[r[r\rDs zCollection.set_urlscCs|jS)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. )rr_r[r[r\get_urlsszCollection.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. Hatching is supported in the PostScript, PDF, SVG and Agg backends only. 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)mhatchZ_validate_hatch_patternrr)rRr r[r[r\rEs! zCollection.set_hatchcCs|jS)z$Return the current hatching pattern.)rr_r[r[r\rszCollection.get_hatchc Csrt|}|jdkr$|dddf}tt||dddfdt||dddfdf|_d|_dS)z Set the offsets for the collection. Parameters ---------- offsets : (N, 2) or (2,) array-like r-NrrLrT) rJrKrMrasarrayrrrNr)rRrUr[r[r\ set_offsetss  zCollection.set_offsetscCs|jdurtdS|jS)z&Return the offsets for the collection.N)rr.)rNrJzerosr_r[r[r\r|*szCollection.get_offsetscCs tjdS)Nzpatch.linewidthr;r<r_r[r[r\_get_default_linewidth/sz!Collection._get_default_linewidthcCsD|dur|}tt||_||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) rrJ atleast_1drr4 _bcast_lwlsr2r5r3r)rRrr[r[r\r@3s  zCollection.set_linewidthc Csz\t|tr(tj||}t|g}n2zt|g}Wn tyXdd|D}Yn0Wn4ty}ztd||WYd}~n d}~00||_ | |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. cSsg|]}t|qSr[)mlines_get_dash_patternrrrr[r[r\rvirwz,Collection.set_linestyle..z)Do not know how to convert {!r} to dashesN)ristrr ls_mappergetrr ValueErrorformatr2rr4r5r3)rRrrerrr[r[r\rAGs$  zCollection.set_linestylecCst||_dS)z Set the `.CapStyle` for the collection (for all its elements). Parameters ---------- cs : `.CapStyle` or %(CapStyle)s N)rrG)rRcsr[r[r\rFvs zCollection.set_capstylecCs|jjSr])rGr(r_r[r[r\ get_capstyleszCollection.get_capstylecCst||_dS)z Set the `.JoinStyle` for the collection (for all its elements). Parameters ---------- js : `.JoinStyle` or %(JoinStyle)s N)rrI)rRjsr[r[r\rHs zCollection.set_joinstylecCs|jjSr])rIr(r_r[r[r\ get_joinstyleszCollection.get_joinstylecCsztjdr||fSt|t|kr^t|}t|}t||}t|||}t|||}ddt||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[)rZ _scale_dashes)rrodrr[r[r\rvs z*Collection._bcast_lwls..)r;r<r}mathgcdlistzip)rrZl_dashesZl_lwrr[r[r\rs  zCollection._bcast_lwlscCs.|dur|}tt|t|_d|_dS)z Set the antialiasing state for rendering. Parameters ---------- aa : bool or list of bools NT)_get_default_antialiasedrJrrboolrr)rRrr[r[r\rBszCollection.set_antialiasedcCs tjdS)Nzpatch.antialiasedrr_r[r[r\rsz#Collection._get_default_antialiasedcCs||||dS)a& Set both the edgecolor and the facecolor. Parameters ---------- c : color or list of rgba tuples See Also -------- Collection.set_facecolor, Collection.set_edgecolor For setting the edge or face color individually. N)r>r?rRcr[r[r\ set_colors zCollection.set_colorcCs tjdS)Nzpatch.facecolorrr_r[r[r\_get_default_facecolorsz!Collection._get_default_facecolorcCs*|dur|}t||j|_d|_dSNT)rr9 to_rgba_array_alpha _facecolorsrrr[r[r\_set_facecolorszCollection._set_facecolorcCs2t|tr|dvr|}||_||dS)aY 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 : color or list of colors nonefaceN)rirlower_original_facecolorrrr[r[r\r>s zCollection.set_facecolorcCs|jSr])rr_r[r[r\rszCollection.get_facecolorcCs t|jdr|S|jSdS)Nr)r _str_equal _edgecolorsrr_r[r[r\rszCollection.get_edgecolorcCs tjdS)Nzpatch.edgecolorrr_r[r[r\_get_default_edgecolorsz!Collection._get_default_edgecolorcCsd}|durrrrrr?rr/rrrrrrrr[r[r[r\r#s #  ~  D $ M  % %/   %  "&r#cs<eZdZdZdZddZd ddZejfdd Z Z S) _CollectionWithSizeszA Base class for collections that have an array of sizes. ?cCs|jS)z Return the sizes ('areas') of the elements in the collection. Returns ------- array The 'area' of each element. )_sizesr_r[r[r\ get_sizess z_CollectionWithSizes.get_sizesR@cCs|dur"tg|_td|_nzt||_tt|jddf|_t|j|d|j }||jddddf<||jddddf<d|jddddf<d |_ dS) aA Set the sizes of each member of the collection. Parameters ---------- sizes : 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%rrrrr.T) rJarrayrrrerrr}sqrt_factorr)rRsizesdpiscaler[r[r\ set_sizess   z_CollectionWithSizes.set_sizescs"||j|jjt|dSr])r%rrr#superrrrr[r\rsz_CollectionWithSizes.draw)r) rrrrr!rr%rrr __classcell__r[r[r'r\rs  rcsHeZdZdZdfdd ZddZddZd d dd d fd dZZS)PathCollectionzO A collection of `~.path.Path`\s, as created by e.g. `~.Axes.scatter`. Nc s0tjfi|||||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`. TN)r&r0rdr%r)rRrcr"rZr'r[r\r0s  zPathCollection.__init__cCs||_d|_dSrrQrrbr[r[r\rdszPathCollection.set_pathscCs|jSr]r^r_r[r[r\r`szPathCollection.get_pathsr autocCs|Sr]r[)rr[r[r\rwzPathCollection.cKsg}g}|du}|dur.tjjddd}nt|trDtj|}||dkr|sjt d||fSt |} | dtj d} n4|d krt |} | d d } ntd |d || } |j| | |j| | |dkrd}t| |krd}|dur,| } || }n|dkr@|}n|d krR|}t|tjjrh|}n)rRpropnumfmtfuncrZhandleslabelsZhasarrayur r/Zfuvalues label_valuesarrloccondZyarrxarrixkwvallabhlr[r[r\legend_elementss?                     zPathCollection.legend_elements)N) rrrrr0rdr`rlr(r[r[r'r\r)sr)csBeZdZejdddd fdd Zd dd ZeZd d ZZ S)PolyCollectionr&closedr'NTc s2tjfi||||||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`. TN)r&r0r% set_vertsr)rRvertsr"rnrZr'r[r\r0s  zPolyCollection.__init__csd|_t|tjjr&|ttj}|s>dd|D|_ dSt|tj rt |j dkrtj ||ddddffdd}tj|j dtjjdtjjdd<tjjd <tjjd <fd d|D|_ dSg|_ |D]4}t |r|j tj|q|j t|qdS) 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. TcSsg|]}t|qSr[rrrrxyr[r[r\rvrwz,PolyCollection.set_verts..Nr%rrH)dtypercsg|]}t|qSr[rqrrrr[r\rvrw)rrirJrrastyperLrrrQndarrayr}rM concatenaterrr code_typeLINETOMOVETO CLOSEPOLYr_create_closed)rRrprnZ verts_padrsr[rwr\ros&"  zPolyCollection.set_vertscCs8t|t|krtdddt||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|r t||nt|qSr[)r}rr)rrrsZcdsr[r[r\rvsz6PolyCollection.set_verts_and_codes..TN)r}rrrQr)rRrprr[r[r\set_verts_and_codess z"PolyCollection.set_verts_and_codes)NT)T) rrrrrr0rordrr(r[r[r'r\rms   *rmcs,eZdZdZfddZeddZZS)BrokenBarHCollectionz] A collection of horizontal bars spanning *yrange* with a sequence of *xranges*. c s<|\}|fdd|D}tj|fi|dS)a6 Parameters ---------- xranges : list of (float, float) The sequence of (left-edge-position, width) pairs for each bar. yrange : (float, float) The (lower-edge, height) common to all bars. **kwargs Forwarded to `.Collection`. cs:g|]2\}}|f|f||f||f|fgqSr[r[)rrxminZxwidthymaxyminr[r\rvs  z1BrokenBarHCollection.__init__..N)r&r0)rRxrangesyrangerZZywidthrpr'rr\r0s  zBrokenBarHCollection.__init__c Ksfg}t|D]<\}}|||} t| s,q|| d| d| dfq|||||gfi|S)z Return a `.BrokenBarHCollection` that plots horizontal bars from over the regions in *x* where *where* is True. The bars range on the y-axis from *ymin* to *ymax* *kwargs* are passed on to the collection. rrv)rcontiguous_regionsr}r) clsrrrwhererZrind0ind1xslicer[r[r\ span_wheres   zBrokenBarHCollection.span_where)rrrrr0 classmethodrr(r[r[r'r\rs rcs`eZdZdZejjZej dZ e j ddddfdd Z d d Zd d ZejddZZS)RegularPolyCollectionz)A collection of n-sided regular polygons.r&rotationr'rrc sHtjfi|||||_||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, ) N) r&r0r% _numsides_path_generatorrQ _rotation set_transformrrh)rRnumsidesrr"rZr'r[r\r0s # zRegularPolyCollection.__init__cCs|jSr])rr_r[r[r\ get_numsides,sz"RegularPolyCollection.get_numsidescCs|jSr])rr_r[r[r\ get_rotation/sz"RegularPolyCollection.get_rotationcs8jjjfddjD_t|dS)Ncs$g|]}t|j qSr[)rrrotater get_matrixrr_r[r\rv5sz.RegularPolyCollection.draw..)r%rrr#rer#rrr[r_r\r2s  zRegularPolyCollection.draw)rr)rrrrrrunit_regular_polygonrrJpir!rrr0rrrrrr(r[r[r'r\rs  )rc@seZdZdZejjZdS)StarPolygonCollectionz:Draw a collection of regular stars with *numsides* points.N)rrrrrrunit_regular_starrr[r[r[r\r>src@seZdZdZejjZdS)AsteriskPolygonCollectionz>Draw a collection of regular asterisks with *numsides* points.N)rrrrrrunit_regular_asteriskrr[r[r[r\rCsrcszeZdZdZdZddfdd ZddZeZeZd d Z d d Z d dZ ddZ ddZ ddZeZddZeZZS)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*. Tr.r+c s0|ddtjfd|i|||dS)a Parameters ---------- segments : list of array-like A sequence of (*line0*, *line1*, *line2*), where:: linen = (x0, y0), (x1, y1), ... (xm, ym) or the equivalent numpy array with two columns. Each line can have a different number of segments. linewidths : float or list of float, default: :rc:`lines.linewidth` The width of each line in points. colors : 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 : int, default: 2 zorder of the lines once drawn. facecolors : color or list of 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`. rrr,N) setdefaultr&r0 set_segments)rRsegmentsr,rZr'r[r\r0\s&  zLineCollection.__init__cCs&|dur dSdd|D|_d|_dS)NcSs6g|].}t|tjjr t|ntt|tqSr[)rirJrrrrrrL)rrsegr[r[r\rvsz/LineCollection.set_segments..Tr*)rRrr[r[r\rs 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[)rrZvertex_r[r[r\rvsz/LineCollection.get_segments..F)simplify)rQ iter_segmentsrJrr)rRrr rr[r[r\ get_segmentss    zLineCollection.get_segmentscCs tjdS)Nzlines.linewidthrr_r[r[r\rsz%LineCollection._get_default_linewidthcCs tjdS)Nzlines.antialiasedrr_r[r[r\rsz'LineCollection._get_default_antialiasedcCs tjdS)Nz lines.colorrr_r[r[r\rsz%LineCollection._get_default_edgecolorcCsdS)Nrr[r_r[r[r\rsz%LineCollection._get_default_facecolorcCs||dS)a3 Set the edgecolor(s) of the LineCollection. Parameters ---------- c : color or list of colors 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)r?rr[r[r\rs zLineCollection.set_colorcCs|jSr])rr_r[r[r\ get_colorszLineCollection.get_color)rrrrrr0rrordrrrrrrZ set_colorsr get_colorsr(r[r[r'r\rHs ,  rcseZdZdZdZejdddd)fd d Zd dZddZ ddZ e Z Z ddZ ddZddZddZddZddZdd Zd!d"Zfd#d$Zfd%d&Zd'd(ZZS)*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. Tr& lineoffsetr' horizontalrrNr)c  sHtjgf||||d| d|_||_||_||||dS)aD 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 : color or list of colors, 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)r&r0_is_horizontal _linelength _lineoffsetset_orientation set_positions) rR positions orientationr linelengthr!r/r rrZr'r[r\r0s0  zEventCollection.__init__cs&|r dndfdd|DS)zX Return an array containing the floating-point values of the positions. rrcsg|]}|dfqS)rr[)rrsegmentposr[r\rvrwz1EventCollection.get_positions..) is_horizontalrr_r[rr\ get_positionsszEventCollection.get_positionscCs|dur g}t|dkr"td|}|}|r>dnd}tt|ddf}t|dddf|dddd|f<||d|dddd|f<||d|dddd|f<| |dS)z Set the positions of the events.Nrz!positions must be one-dimensionalrr.) rJr rget_lineoffsetget_linelengthrrr}sortr)rRrrrZpos_idxrr[r[r\rs(zEventCollection.set_positionscCsL|dust|dr"t|dkr"dS|}t|t|g}||dS)z2Add one or more events at the specified positions.Nr}r)rkr}rrJhstackrKr)rRpositionrr[r[r\ add_positions's zEventCollection.add_positionscCs|jS)z=True if the eventcollection is horizontal, False if vertical.)rr_r[r[r\r1szEventCollection.is_horizontalcCs|r dSdS)zX Return the orientation of the event line ('horizontal' or 'vertical'). rvertical)rr_r[r[r\get_orientation5szEventCollection.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 enumeraterJfliplrrrrr)rRrirr[r[r\switch_orientation;s   z"EventCollection.switch_orientationcCs0tjddd|d}||kr$dS|dS)z Set the orientation of the event line. Parameters ---------- orientation : {'horizontal', 'vertical'} TF)rr)rN)r check_getitemrr)rRrrr[r[r\rGs zEventCollection.set_orientationcCs|jS)z7Return the length of the lines used to mark each event.)rr_r[r[r\rVszEventCollection.get_linelengthcCsv||krdS|}|}|r,dnd}|D],}||d|d|f<||d|d|f<q4||||_dS)z4Set the length of the lines used to mark each event.Nrr@)rrrrrr)rRrrrrrr[r[r\set_linelengthZs  zEventCollection.set_linelengthcCs|jS)z7Return the offset of the lines used to mark each event.)rr_r[r[r\rgszEventCollection.get_lineoffsetcCsv||krdS|}|}|r,dnd}|D],}||d|d|f<||d|d|f<q4||||_dS)z4Set the offset of the lines used to mark each event.Nrrr)rrrrrr)rRrrrrrr[r[r\set_lineoffsetks  zEventCollection.set_lineoffsetcstdS)z3Get the width of the lines used to mark each event.rr&rr_r'r[r\rxszEventCollection.get_linewidthcs tSr]rr_r'r[r\rU|szEventCollection.get_linewidthscCs |dS)z6Return the color of the lines used to mark each event.r)rr_r[r[r\rszEventCollection.get_color)rrrNNr)N)rrrrrrrr0rrrZextend_positionsZappend_positionsrrrrrrrrrrUrr(r[r[r'r\rs4 9    rcs*eZdZdZejdZfddZZS)CircleCollectionz-A collection of circles, drawn using splines.rc s<tjfi||||ttjg|_ dS)z Parameters ---------- sizes : float or array-like The area of each circle in points^2. **kwargs Forwarded to `.Collection`. N) r&r0r%rrrhrr unit_circlerQ)rRr"rZr'r[r\r0s  zCircleCollection.__init__) rrrrrJrr!r0r(r[r[r'r\rs rcsJeZdZdZejdddd fdd Zdd Zej fd d Z Z S) EllipseCollectionz.A collection of ellipses, drawn using splines.r&unitsr'pointsc s|tjfi|dt||_dt||_t||_||_ | t t d|_tjg|_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`. g?r$N)r&r0rJrravel_widths_heightsdeg2rad_angles_unitsrrrhrrerrrrQ)rRwidthsheightsanglesrrZr'r[r\r0s zEllipseCollection.__init__c Cs|j}|j}|jdkrd}n|jdkr8|jj|jj}n|jdkrT|jj|jj}np|jdkrf|j}n^|jdkr||jd}nH|jdkr|jj}n4|jd kr|jj}n |jd krd }ntd |jt t |j d d f|_ |j |}|j|}t |j}t |j}|||j ddddf<|| |j ddddf<|||j ddddf<|||j ddddf<d |j ddddf<tj}|jdkr|j} d| ddddf<||| dS)z0Calculate transforms immediately before drawing.rsrrrinchesrrrrdotsrzUnrecognized units: r%Nrr.)rlrrrrviewLimrr#rrJrr}rrersinrcosrrrrrcopyr) rRaxfigscrrZ sin_angleZ cos_angle_affinemr[r[r\_set_transformssD                z!EllipseCollection._set_transformscs|t|dSr])rr&rrr'r[r\rszEllipseCollection.draw)r) rrrrrrr0rrrrr(r[r[r'r\rs  *rcs8eZdZdZejdddd fdd Zdd ZZS) 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. r&match_originalr'Fc s|rjddfdd|D|d<dd|D|d<dd|D|d <d d|D|d <d d|D|d <tjfi|||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|SgdS)N)rrrr)rr)patchr[r[r\determine_facecolorsz5PatchCollection.__init__..determine_facecolorcsg|] }|qSr[r[rqrr[r\rvrwz,PatchCollection.__init__..rcSsg|] }|qSr[)rrqr[r[r\rvrwrcSsg|] }|qSr[)rrqr[r[r\rvrwrcSsg|] }|qSr[)rrqr[r[r\rvrwrcSsg|] }|qSr[)Zget_antialiasedrqr[r[r\rvrwrN)r&r0rd)rRpatchesrrZr'rr\r0szPatchCollection.__init__cCsdd|D}||_dS)NcSsg|]}||qSr[)rxtransform_pathget_pathrqr[r[r\rv"sz-PatchCollection.set_paths..r^)rRrrcr[r[r\rd!szPatchCollection.set_paths)F) rrrrrrr0rdr(r[r[r'r\rs -rcsJeZdZdZfddZddZddZedd 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\tjfi|||_d|_tj|_t |j dd|j ddf}|j |dS)Ngouraudrvr)r&r0_triangulation_shadingrrzunit_bboxrJrrr rr)rRZ triangulationrZrsr'r[r\r0-s  zTriMesh.__init__cCs|jdur||jSr]rQrdr_r[r[r\r`:s zTriMesh.get_pathscCs||j|_dSr])convert_mesh_to_pathsrrQr_r[r[r\rd?szTriMesh.set_pathscCs4|}tj|j||j|fdd}dd|DS)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. rvrtcSsg|]}t|qSr[rqrr[r[r\rvLrwz1TriMesh.convert_mesh_to_paths..)get_masked_trianglesrJstackrr)tri trianglesrpr[r[r\rBszTriMesh.convert_mesh_to_pathscCs|s dS|j|jj|d|}|j}|}tj |j ||j |fdd}| |j |}|}||||d||||||||jjdS)N)gidrvrtr)rrrrrrxrrrJrrrrrrrr@rdraw_gouraud_trianglesrrr)rRrrurrrpr rr[r[r\rNs  z TriMesh.draw) rrrrr0r`rdrrrrrr(r[r[r'r\r's  rcseZdZdZfddZedddddd e_d d Zd d Z fddZ ddZ ddZ e ejdddddZe ddZedddZddZejdd Zd!d"ZZS)#r a? 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. There exists a deprecated API version ``QuadMesh(M, N, coords)``, where the dimensions are given explicitly and ``coords`` is a (M*N, 2) array-like. This has been deprecated in Matplotlib 3.5. The following describes the semantics of this deprecated API. A quadrilateral mesh consists of a grid of vertices. The dimensions of this array are (*meshWidth* + 1, *meshHeight* + 1). Each vertex in the mesh has a different set of "mesh coordinates" representing its position in the topology of the mesh. For any values (*m*, *n*) such that 0 <= *m* <= *meshWidth* and 0 <= *n* <= *meshHeight*, the vertices at mesh coordinates (*m*, *n*), (*m*, *n* + 1), (*m* + 1, *n* + 1), and (*m* + 1, *n*) form one of the quadrilaterals in the mesh. There are thus (*meshWidth* * *meshHeight*) quadrilaterals in the mesh. The mesh need not be regular and the polygons need not be convex. A quadrilateral mesh is represented by a (2 x ((*meshWidth* + 1) * (*meshHeight* + 1))) numpy array *coordinates*, where each row is the *x* and *y* coordinates of one of the vertices. To define the function that maps from a data point to its corresponding color, use the :meth:`set_cmap` method. Each of these arrays is indexed in row-major order by the mesh coordinates of the vertex (or the mesh coordinates of the lower left vertex, in the case of the colors). For example, the first entry in *coordinates* is the coordinates of the vertex at mesh coordinates (0, 0), then the one at (0, 1), then at (0, 2) .. (0, meshWidth), (1, 0), (1, 1), and so on. c stjddddddgg|Ri|}|^}}}}}|rxtjddd|\}} t|tj| d |d d f}|d d tj d |d||_ ||_ ||_ t j|_|j|j dd tjfi||ddS)NTflatc[stSr]locals) meshWidth meshHeight coordinatesrshadingrZr[r[r\r,sz#QuadMesh.__init__..c[stSr]r)rrrrZr[r[r\r,s3.5zThis usage of Quadmesh is deprecated: Parameters meshWidth and meshHeights will be removed; coordinates must be 2D; all parameters except coordinates will be keyword-only.messagerr.rXr)NNr.)rrvF)Tr)Tr)rselect_matching_signaturer`warn_deprecatedrJrfloat64r r check_shape _coordinates _antialiasedrrrzrrrr&r0Z set_mouseover) rRargsrZparamsZold_w_hcoordsrrwrjr'r[r\r0s8 "  zQuadMesh.__init__Trr)rrrXcKsdSr]r[)rRrrrrXrZr[r[r\r,szQuadMesh.cCs|jdur||jSr]rr_r[r[r\r`s zQuadMesh.get_pathscCs||j|_d|_dSr)_convert_mesh_to_pathsr rQrr_r[r[r\rdszQuadMesh.set_pathsc s|jjdd\}}d}d}|jdkr:|d|d}}n ||}}|durt|}t|dkrz|d||krd}n(|||fkrt|||krd}nd}|rtjdd |d |d |jd |d |d|jd d|rtd|jd|d|dt |S)a Set the data values. Parameters ---------- A : (M, N) array-like or M*N array-like 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. rrvFrrNTrzFor X (z ) and Y (z) with z& shading, the expected shape of A is (z, z). Passing A (zE) is deprecated since %(since)s and will become an error %(removal)s.rzDimensions of A z are incompatible with X (z ) and/or Y ()) r rMrrJr}prodrr  TypeErrorr& set_array) rRArrZmisshapen_dataZ faulty_datarjrrMr'r[r\rsH        zQuadMesh.set_arraycCs|||jSr])rxtransform_bboxr)rRrr[r[r\rszQuadMesh.get_datalimcCs|jS)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 r_r[r[r\get_coordinatesszQuadMesh.get_coordinatesrz8`QuadMesh(coordinates).get_paths()<.QuadMesh.get_paths>`) alternativecCs t|Sr])r r)rrrr[r[r\rszQuadMesh.convert_mesh_to_pathsc Cst|tjjr|j}n|}tj|ddddf|ddddf|ddddf|ddddf|ddddfgddd}dd|DS) 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. Nrvrr.rt)rvr2r.cSsg|]}t|qSr[rqrr[r[r\rv*rwz3QuadMesh._convert_mesh_to_paths..)rirJrrdatarzr )rrrr[r[r\rszQuadMesh._convert_mesh_to_pathscCs ||Sr])_convert_mesh_to_triangles)rRrrrr[r[r\convert_mesh_to_triangles,sz"QuadMesh.convert_mesh_to_trianglesc Csdt|tjjr|j}n|}|ddddf}|ddddf}|ddddf}|ddddf}||||d}tj||||||||||||g ddd}|g|jdddR} | ddddf} | ddddf} | ddddf} | ddddf} | | | | d}tj| | || | || | || | |g ddd }||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_triangle`. Nrvrg@r.rt)rvr%r.)rvr%r) rirJrrrrzr rrM)rRrrsZp_aZp_bZp_cZp_dZp_centerrrZc_aZc_bc_cc_dZc_centerr r[r[r\r0sF"z#QuadMesh._convert_mesh_to_trianglesc Cs|s dS||jj||}|}|}|rz| |dddf}| |dddf}t ||g}| |js|jd}||}||jj}t}n|j}|js||}|}|}||||||d|jdkr6||\} } ||| | | nJ|!|| |jdd|jdd||||"d|j#|$d |%|&|jjd|_'dS)Nrr)rvr.r)rvrF)(rrrrrrxrmr|rrrrJrrr~r r rurMrrhrrrrrrr@rrrrrZdraw_quad_meshrrZget_edgecolorsrrr) rRrrurrUrrrrrr r[r[r\rVsN        z QuadMesh.drawcCs6||\}}|r2|dur2||dSdS)Nr)rr?r)rRevent containedrr[r[r\get_cursor_dataszQuadMesh.get_cursor_data)rrrrr0inspect signature __signature__r`rdrrrrr deprecatedrrrrrrrr$r(r[r[r'r\r fs,< %  /     & 0r )/rr%rnumbersrrDnumpyrJ matplotlibr;r;rrrrrr r9r r rr rr rr_enumsrrdefine_aliasesr/r1r#rr)rmrrrrrrrrrrr r[r[r[r\sR  4/-R+B8R=?