B ]”t\#ã@sÖdZddlZddlmZddlZddlZddlZddl m Z m Z m Z m Z mZmZmZmZmZde ej¡Ze  dgdgd gd d gd d gdœ¡Gdd„de je jƒƒZejjddGdd„deƒZGdd„deƒZ Gdd„deƒZ!Gdd„de!ƒZ"Gdd„deƒZ#Gdd„de#ƒZ$Gdd „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,e  -e¡Z.xd/D]Z/ej e/e.i¡q¤Wejje  -e&¡d0dS)1ax 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 segemnts) éN)ÚNumberé) Ú_pathÚartistÚcbookÚcmÚcolorsÚ docstringÚlinesÚpathÚ transformsgð?Ú antialiasedsÚ edgecolorsÚ facecolorsÚ linestylesÚdashesÚ linewidthsÚlw)Ú antialiasedZ edgecolorZ facecolorÚ linestyleÚ linewidthc@s„eZdZdZe d¡Ze ¡Z e  d¡Z dZ d\d d „Z d d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zejdd„ƒZdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Z d.d/„Z!d0d1„Z"d2d3„Z#d4d5„Z$d6d7„Z%d8d9„Z&d:d;„Z'dd?„ƒZ*d@dA„Z+dBdC„Z,dDdE„Z-dFdG„Z.dHdI„Z/dJdK„Z0dLdM„Z1dNdO„Z2dPdQ„Z3dRdS„Z4dTdU„Z5dVdW„Z6dXdY„Z7dZd[„Z8dS)]Ú Collectiona Base class for Collections. Must be subclassed to be usable. All properties in a collection must be sequences or scalars; if scalars, they will be converted to sequences. The property of the ith element of the collection is:: prop[i % len(props)] Exceptions are *capstyle* and *joinstyle* properties, these can only be set globally for the whole collection. Keyword arguments and default values: * *edgecolors*: None * *facecolors*: None * *linewidths*: None * *capstyle*: None * *joinstyle*: None * *antialiaseds*: None * *offsets*: None * *transOffset*: transforms.IdentityTransform() * *offset_position*: 'screen' (default) or 'data' * *norm*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *cmap*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *hatch*: None * *zorder*: 1 *offsets* and *transOffset* are used to translate the patch after rendering (default no offsets). If offset_position is 'screen' (default) the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not None (i.e., a call to set_array has been made), at draw time a call to scalar mappable will be made to set the face colors. )ré)rérFNÚsolidç@ÚscreenrcKs`tj |¡tj || | ¡dg|_dg|_dg|_dg|_d|_ t   t j d¡|_| |¡| |¡| |¡| |¡| |¡| | ¡| |¡| | ¡| |¡| |¡|rÈ| |¡nd|_|rÞ| |¡nd|_t d¡|_d|_ |dk rFt !|t"¡}|j#dkr(|ddd…f}| dk r@||_| |_$n||_ d|_%| &|¡d|_'dS)z= Create a Collection %(Collection)s )NNrTz hatch.colorN)rr)r)(rÚArtistÚ__init__rÚScalarMappableÚ_us_linestylesÚ _linestylesÚ_us_lwÚ _linewidthsÚ _is_filledÚmcolorsÚto_rgbaÚmplÚrcParamsÚ _hatch_colorÚ set_facecolorÚ set_edgecolorÚ set_linewidthÚ set_linestyleÚset_antialiasedÚset_pickradiusÚset_urlsÚ set_hatchÚset_offset_positionZ set_zorderÚ set_capstyleÚ _capstyleÚ set_joinstyleÚ _joinstyleÚnpÚzerosÚ_offsetsÚ_uniform_offsetsÚ asanyarrayÚfloatÚshapeÚ _transOffsetZ _path_effectsÚupdateÚ_paths)ÚselfrrrrZcapstyleZ joinstyler ÚoffsetsÚ transOffsetÚnormÚcmapÚ pickradiusÚhatchÚurlsÚoffset_positionÚzorderÚkwargs©rLú5lib/python3.7/site-packages/matplotlib/collections.pyr^sJ                   zCollection.__init__cCs|jS)N)r@)rArLrLrMÚ get_paths©szCollection.get_pathscCst‚dS)N)ÚNotImplementedError)rArLrLrMÚ set_paths¬szCollection.set_pathscCs|jS)N)Ú _transforms)rArLrLrMÚget_transforms¯szCollection.get_transformscCs,|j}t|tjƒs(t|dƒr(| |j¡}|S)NÚ_as_mpl_transform)r>Ú isinstancer Z TransformÚhasattrrSÚaxes)rAÚtrLrLrMÚget_offset_transform²s    zCollection.get_offset_transformcs¸| ¡‰| ¡}|j}| ¡}ˆjs>‡fdd„|Dƒ}ˆ ¡‰|jsV| |¡}| ¡}t|tj j ƒrp|  tj ¡}t |ƒrªt |ƒrªt ˆ ¡|| ¡|| ¡¡}| |¡}n tj ¡}|S)Ncsg|]}ˆ |¡‘qSrL)Útransform_path_non_affine)Ú.0Úp)Ú transformrLrMú Àsz*Collection.get_datalim..)Ú get_transformrXr9rNÚ is_affineÚ get_affineÚtransform_non_affinerTr7ÚmaÚ MaskedArrayÚfilledÚnanÚlenÚmpathZget_path_collection_extentsÚfrozenrRZinverse_transformedr ÚBboxZnull)rAÚ transDatarCrBÚpathsÚresultrL)r\rMÚ get_datalim¹s&     zCollection.get_datalimcCs| t ¡¡S)N)rmr ÚIdentityTransform)rAÚrendererrLrLrMÚget_window_extentÓszCollection.get_window_extentc s<| ¡‰| ¡}|j}| ¡}| ¡rÚg}xj| ¡D]^}|j}|dd…df|dd…df}}| |¡}| |¡}| t   t   ||g¡|j ¡¡q4W|jdkrÚ| |dd…df¡}| |dd…df¡}t   ||g¡}ˆjsú‡fdd„|Dƒ}ˆ ¡‰|js| |¡}| ¡}t|t jjƒr0| t j¡}ˆ|||fS)z&Point prep for drawing and hit testingNrrcsg|]}ˆ |¡‘qSrL)rY)rZr )r\rLrMr]ïsz.Collection._prepare_points..)r^rXr9rNÚ have_unitsÚverticesÚconvert_xunitsÚconvert_yunitsÚappendrgÚPathr7Ú column_stackÚcodesÚsizer_r`rarTrbrcrdre)rArCrBrkr rrÚxsÚysrL)r\rMÚ_prepare_pointsØs4"  "    zCollection._prepare_pointscCsÖ| ¡s dS| |jj| ¡¡| ¡| ¡\}}}}| ¡}| |¡|  |  ¡¡|j rš|  |j ¡y|  |j¡Wntk r˜t d¡YnX| ¡dk r´|j| ¡Ž| ¡rÖddlm}|| ¡|ƒ}| ¡}| ¡} | ¡} d} t|ƒdkrÎt|ƒdkrÎt| ƒdkrÎt| ƒdkrÎt|jƒdkrÎ|jdgkrÎt|jƒdkrÎt|jƒdkrÎ| ¡dkrÎt|ƒr”t  !|d¡|} n|} |d "| ¡} | #¡\}}| j$|krÎ| j%|krÎd} |j&râ| '|j&¡|j(rö| )|j(¡| rz| *t+| dƒ¡| ,|jd¡|j-|jdŽ| .|jd¡| /|jd¡| 0||d|  1¡t2 3|¡|t+| dƒ¡n<| 4|| 1¡|| ¡||| ¡| ¡|j|j|j|j|j5¡ | 6¡| 7|jj¡d|_8dS)Nz6Your backend does not support setting the hatch color.r)ÚPathEffectRendererFr)NNT)9Ú get_visibleÚ open_groupÚ __class__Ú__name__Úget_gidÚupdate_scalarmappabler|Únew_gcÚ _set_gc_clipZset_snapZget_snapÚ_hatchr1Úset_hatch_colorr)ÚAttributeErrorÚwarningsÚwarnZget_sketch_paramsZset_sketch_paramsZget_path_effectsZmatplotlib.patheffectsr}rRÚ get_facecolorÚ get_edgecolorrfr#r!Ú _antialiasedsÚ_urlsÚ get_hatchr ÚAffine2DZ get_extentsZget_canvas_width_heightÚwidthÚheightr6r5r4r3Zset_foregroundÚtupler,Z set_dashesr.Zset_urlZ draw_markersrhrgrvZdraw_path_collectionÚ_offset_positionÚrestoreÚ close_groupÚstale)rAror\rCrBrkÚgcr}ZtransrrZdo_single_path_optimizationZcombined_transformZextentsr‘r’rLrLrMÚdrawþsx             zCollection.drawcCs ||_dS)z•Set the pick radius used for containment tests. Parameters ---------- d : float Pick radius, in points. N)Ú _pickradius)rAZprrLrLrMr/RszCollection.set_pickradiuscCs|jS)N)rš)rArLrLrMÚget_pickradius\szCollection.get_pickradiusc Cs¢t|jƒr| ||¡S| ¡s&difSt|jtƒrF|jdk rFt|jƒn|j}| ¡\}}}}t   |j |j ||  ¡|| ¡|||dk| ¡¡ }t|ƒdkt|dfS)zº Test whether the mouse event occurred in the collection. Returns True | False, ``dict(ind=itemlist)``, where every item in itemlist contains the event. FTr)Úind)ÚcallableZ _containsr~rTZ_pickerrr<ršr|rZpoint_in_path_collectionÚxÚyrhrRÚget_offset_positionrfÚdict)rAZ mouseeventrFr\rCrBrkrœrLrLrMÚcontains_s      zCollection.containscCs|dk r |ndg|_d|_dS)zP Parameters ---------- urls : List[str] or None NT)rŽr—)rArHrLrLrMr0|szCollection.set_urlscCs|jS)N)rŽ)rArLrLrMÚget_urls…szCollection.get_urlscCs||_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)r†r—)rArGrLrLrMr1ˆs zCollection.set_hatchcCs|jS)z$Return the current hatching pattern.)r†)rArLrLrMr«szCollection.get_hatchcCsHt |t¡}|jdkr&|ddd…f}|jdkr8||_n||_d|_dS)z¼ Set the offsets for the collection. *offsets* can be a scalar or a sequence. Parameters ---------- offsets : float or sequence of floats )rNT)r7r;r<r=r:r9r—)rArBrLrLrMÚ set_offsets¯s   zCollection.set_offsetscCs|jdkr|jS|jSdS)z&Return the offsets for the collection.N)r:r9)rArLrLrMÚ get_offsetsÂs zCollection.get_offsetscCs |dkrtdƒ‚||_d|_dS)a½ Set how offsets are applied. If *offset_position* is 'screen' (default) the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. Parameters ---------- offset_position : {'screen', 'data'} )rÚdataz*offset_position must be 'screen' or 'data'TN)Ú ValueErrorr”r—)rArIrLrLrMr2Ês zCollection.set_offset_positioncCs|jS)a€ Returns how offsets are applied for the collection. If *offset_position* is 'screen', the offset is applied after the master transform has been applied, that is, the offsets are in screen coordinates. If offset_position is 'data', the offset is applied before the master transform, i.e., the offsets are in data coordinates. )r”)rArLrLrMr Ûs zCollection.get_offset_positioncCsX|dkr$tjd}|dkr$tjd}t 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 sequence of floats Nzpatch.linewidthzlines.linewidthT) r'r(r7Ú atleast_1dÚasarrayr"Ú _bcast_lwlsr r#r!r—)rArrLrLrMr,æs   zCollection.set_linewidthcCs¤y^t|tƒr(tj ||¡}t |¡g}n4yt |¡g}Wn"tk rZdd„|Dƒ}YnXWn"tk r€td |¡ƒ‚YnX||_ |  |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 : {'-', '--', '-.', ':', '', (offset, on-off-seq), ...} The line style. cSsg|]}t |¡‘qSrL)ÚmlinesÚ_get_dash_pattern)rZržrLrLrMr]sz,Collection.set_linestyle..z)Do not know how to convert {!r} to dashesN)rTÚstrrZ ls_mapperÚgetr«r¬r§Úformatr rªr"r#r!)rAZlsrrLrLrMr-üs zCollection.set_linestylecCs |dkr||_n td|ƒ‚dS)zô Set the capstyle for the collection. The capstyle can only be set globally for all elements in the collection Parameters ---------- cs : {'butt', 'round', 'projecting'} The capstyle )ZbuttÚroundZ projectingz!Unrecognized cap style. Found %sN)r4r§)rAZcsrLrLrMr3)s zCollection.set_capstylecCs|jS)N)r4)rArLrLrMÚ get_capstyle8szCollection.get_capstylecCs |dkr||_n td|ƒ‚dS)zô Set the joinstyle for the collection. The joinstyle can only be set globally for all elements in the collection. Parameters ---------- js : {'miter', 'round', 'bevel'} The joinstyle )Zmiterr°Zbevelz"Unrecognized join style. Found %sN)r6r§)rAZjsrLrLrMr5;s zCollection.set_joinstylecCs|jS)N)r6)rArLrLrMÚ get_joinstyleJszCollection.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 |||¡‘qSrL)r«Z _scale_dashes)rZÚoÚdrrLrLrMr]psz*Collection._bcast_lwls..)r'r(rfÚmathÚgcdÚlistÚzip)rrZl_dashesZl_lwr¶rLrLrMrªMs  zCollection._bcast_lwlscCs0|dkrtjd}t t |t¡¡|_d|_dS)z‰ Set the antialiasing state for rendering. Parameters ---------- aa : bool or sequence of bools Nzpatch.antialiasedT)r'r(r7r¨r©Úboolrr—)rAZaarLrLrMr.us zCollection.set_antialiasedcCs| |¡| |¡dS)a. Set both the edgecolor and the facecolor. .. seealso:: :meth:`set_facecolor`, :meth:`set_edgecolor` For setting the edge or face color individually. Parameters ---------- c : matplotlib color arg or sequence of rgba tuples N)r*r+)rAÚcrLrLrMÚ set_color‚s zCollection.set_colorcCs^|dkrtjd}d|_y| ¡dkr,d|_Wntk rBYnXt ||j¡|_d|_ dS)Nzpatch.facecolorTÚnoneF) r'r(r$Úlowerrˆr%Ú to_rgba_arrayÚ_alphaÚ _facecolorsr—)rArºrLrLrMÚ_set_facecolor’s   zCollection._set_facecolorcCs||_| |¡dS)au Set the facecolor(s) of the collection. *c* can be a matplotlib color spec (all patches have same color), or a sequence of specs; 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 sequence of colors N)Ú_original_facecolorrÁ)rArºrLrLrMr*Ÿs zCollection.set_facecolorcCs|jS)N)rÀ)rArLrLrMr‹¯szCollection.get_facecolorcCs t |jd¡r| ¡S|jSdS)NÚface)rZ _str_equalÚ _edgecolorsZget_facecolors)rArLrLrMrŒ²szCollection.get_edgecolorcCsÐd}|dkr6tjds"|jr"|jr.tjd}nd}d}d|_y| ¡dkrPd|_Wntk rfYnXy| ¡dkr€d|_dSWntk r–YnXt  ||j ¡|_|rÆt |jƒrÆt |jdƒ|_ d|_dS)NTzpatch.force_edgecolorzpatch.edgecolorr¼FrÃr)r'r(r$Ú _edge_defaultÚ _is_strokedr½rˆrÄr%r¾r¿rfr“r)r—)rArºr‡rLrLrMÚ_set_edgecolor¸s.      zCollection._set_edgecolorcCs||_| |¡dS)aØ Set the edgecolor(s) of the collection. *c* can be a matplotlib color spec (all patches have same color), or a sequence of specs; if it is a sequence the patches will cycle through the sequence. If *c* is 'face', the edge color will always be the same as the face color. If it is 'none', the patch boundary will not be drawn. Parameters ---------- c : color or sequence of colors N)Ú_original_edgecolorrÇ)rArºrLrLrMr+ÔszCollection.set_edgecolorcCsf|dk r2y t|ƒWntk r0tdƒ‚YnXd|jd<tj ||¡| |j¡| |j ¡dS)z± Set the alpha tranparencies of the collection. *alpha* must be a float or *None*. Parameters ---------- alpha : float or None Nzalpha must be a float or NoneTÚarray) r<Ú TypeErrorZ update_dictrrÚ set_alpharÁrÂrÇrÈ)rAZalpharLrLrMrËæs    zCollection.set_alphacCs|jS)N)r#)rArLrLrMÚ get_linewidthùszCollection.get_linewidthcCs|jS)N)r!)rArLrLrMÚ get_linestyleüszCollection.get_linestylecCsl|jdkrdS|jjdkr"tdƒ‚| d¡s0dS|jrJ| |j|j¡|_n|jrb| |j|j¡|_ d|_ dS)zb If the scalar mappable array is not none, update colors from scalar data Nrz&Collections can only map rank 1 arraysrÉT) Ú_AÚndimr§Z check_updater$r&r¿rÀrÆrÄr—)rArLrLrMrƒÿs   z Collection.update_scalarmappablecCs|jS)zreturn whether fill is set)r$)rArLrLrMÚget_fillszCollection.get_fillcCs€tj ||¡|j|_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_|j|_d|_dS)z"copy properties from other to selfTN)rrÚ update_fromrrÈrÄrÂrÀr#r!r ršr†rÎrDrEr—)rAÚotherrLrLrMrÑszCollection.update_from)NNNrNNNNNNNrNNrr)9rÚ __module__Ú __qualname__Ú__doc__r7r8r9r rnr>ÚemptyrQrÅrrNrPrRrXrmrpr|rÚallow_rasterizationr™r/r›r¢r0r£r1rr¤r¥r2r r,r-r3r±r5r²Ú staticmethodrªr.r»rÁr*r‹rŒrÇr+rËrÌrÍrƒrÐrÑrLrLrLrMrsz6   ;&T  # - (  ra´ Valid Collection keyword arguments: * *edgecolors*: None * *facecolors*: None * *linewidths*: None * *antialiaseds*: None * *offsets*: None * *transOffset*: transforms.IdentityTransform() * *norm*: None (optional for :class:`matplotlib.cm.ScalarMappable`) * *cmap*: None (optional for :class:`matplotlib.cm.ScalarMappable`) *offsets* and *transOffset* are used to translate the patch after rendering (default no offsets) If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. )rc@s4eZdZdZdZdd„Zd dd„Zejdd „ƒZ d S) Ú_CollectionWithSizeszA Base class for collections that have an array of sizes. gð?cCs|jS)zÞ Returns the sizes of the elements in the collection. The value represents the 'area' of the element. Returns ------- sizes : array The 'area' of each element. )Ú_sizes)rArLrLrMÚ get_sizesKs z_CollectionWithSizes.get_sizesçR@cCs¦|dkr"t g¡|_t d¡|_nzt |¡|_t t|jƒddf¡|_t |j¡|d|j }||jdd…ddf<||jdd…ddf<d|jdd…ddf<d |_ dS) aG 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 The dpi of the canvas. Defaults to 72.0. N)rrrrgR@rrgð?rT) r7rÉrÚrÖrQr©r8rfÚsqrtÚ_factorr—)rAÚsizesÚdpiZscalerLrLrMÚ set_sizesWs   z_CollectionWithSizes.set_sizescCs"| |j|jj¡t ||¡dS)N)rárÚÚfigureràrr™)rArorLrLrMr™psz_CollectionWithSizes.drawN)rÜ) rrÓrÔrÕrÞrÛrárr×r™rLrLrLrMrÙEs  rÙc@s0eZdZdZejd dd„ƒZdd„Zdd„ZdS) ÚPathCollectionz> This is the most basic :class:`Collection` subclass. NcKs,tj|f|Ž| |¡| |¡d|_dS)zs *paths* is a sequence of :class:`matplotlib.path.Path` instances. %(Collection)s TN)rrrPrár—)rArkrßrKrLrLrMrzs   zPathCollection.__init__cCs||_d|_dS)NT)r@r—)rArkrLrLrMrPˆszPathCollection.set_pathscCs|jS)N)r@)rArLrLrMrNŒszPathCollection.get_paths)N) rrÓrÔrÕr Údedent_interpdrrPrNrLrLrLrMrãvs  rãc@s2eZdZejd dd„ƒZd dd„ZeZdd„ZdS) ÚPolyCollectionNTcKs.tj|f|Ž| |¡| ||¡d|_dS)aû *verts* is a sequence of ( *verts0*, *verts1*, ...) where *verts_i* is a sequence of *xy* tuples of vertices, or an equivalent :mod:`numpy` array of shape (*nv*, 2). *sizes* is *None* (default) or a sequence of floats that scale the corresponding *verts_i*. The scaling is applied before the Artist master transform; if the latter is an identity transform, then the overall scaling is such that if *verts_i* specify a unit square, then *sizes_i* is the area of that square in points^2. If len(*sizes*) < *nv*, the additional values will be taken cyclically from the array. *closed*, when *True*, will explicitly close the polygon. %(Collection)s TN)rrráÚ set_vertsr—)rAÚvertsrßÚclosedrKrLrLrMr‘s  zPolyCollection.__init__cCs t|tjjƒr | t¡ tj¡}|ròg|_xÖ|D]¼}t |ƒrÚt|tjjƒrdtj  ||dd…g¡}n t  |¡}t  ||dd…g¡}tj |j dtjjd}tjj|dd…<tjj|d<tjj|d<|j t ||¡¡q0|j t |¡¡q0Wndd„|Dƒ|_d|_dS) z8This allows one to delay initialization of the vertices.rr)ZdtypeNéÿÿÿÿcSsg|]}t |¡‘qSrL)rgrv)rZÚxyrLrLrMr]Àsz,PolyCollection.set_verts..T)rTr7rbrcZastyper<rdrer@rfÚ concatenater©rÖr=rgrvZ code_typeZLINETOZMOVETOZ CLOSEPOLYrur—)rArçrèrêrxrLrLrMræªs$    zPolyCollection.set_vertscCspt|ƒt|ƒkrtdƒ‚g|_xFt||ƒD]8\}}t|ƒrP|j t ||¡¡q*|j t |¡¡q*Wd|_dS)z7This allows one to initialize vertices with path codes.zB'codes' must be a 1D list or array with the same length of 'verts'TN)rfr§r@r¸rurgrvr—)rArçrxrêZcdsrLrLrMÚset_verts_and_codesÅsz"PolyCollection.set_verts_and_codes)NT)T) rrÓrÔr rärrærPrìrLrLrLrMrås   råc@s*eZdZdZejdd„ƒZedd„ƒZdS)ÚBrokenBarHCollectionz] A collection of horizontal bars spanning *yrange* with a sequence of *xranges*. c s8|\‰}ˆ|‰‡‡fdd„|Dƒ}tj||f|ŽdS)z *xranges* sequence of (*xmin*, *xwidth*) *yrange* *ymin*, *ywidth* %(Collection)s cs:g|]2\}}|ˆf|ˆf||ˆf||ˆf|ˆfg‘qSrLrL)rZZxminZxwidth)ÚymaxÚyminrLrMr]åsz1BrokenBarHCollection.__init__..N)rår)rAÚxrangesZyrangerKZywidthrçrL)rîrïrMrØs  zBrokenBarHCollection.__init__c Ksjg}xJt |¡D]<\}}|||…}t|ƒs.q| |d|d|df¡qWt||||gf|Ž} | S)a( Create a BrokenBarHCollection to plot horizontal bars from over the regions in *x* where *where* is True. The bars range on the y-axis from *ymin* to *ymax* A :class:`BrokenBarHCollection` is returned. *kwargs* are passed on to the collection. rré)rZcontiguous_regionsrfrurí) ržrïrîÚwhererKrðZind0Zind1ZxsliceZ collectionrLrLrMÚ span_whereìs  "zBrokenBarHCollection.span_whereN) rrÓrÔrÕr rärrØròrLrLrLrMríÓsríc@sJeZdZdZejjZeZ e j d dd„ƒZ dd„Z dd „Zejd d „ƒZd S)ÚRegularPolyCollectionz6Draw a collection of regular polygons with *numsides*.r©rcKsDtj|f|Ž| |¡||_| |¡g|_||_| t  ¡¡dS)aX *numsides* the number of sides of the polygon *rotation* the rotation of the polygon in radians *sizes* gives the area of the circle circumscribing the regular polygon in points^2 %(Collection)s Example: 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)] black = (0,0,0,1) collection = RegularPolyCollection( numsides=5, # a pentagon rotation=0, sizes=(50,), facecolors=facecolors, edgecolors=(black,), linewidths=(1,), offsets=offsets, transOffset=ax.transData, ) N) rrráÚ _numsidesÚ_path_generatorr@Ú _rotationÚ set_transformr rn)rAZnumsidesZrotationrßrKrLrLrMrs $ zRegularPolyCollection.__init__cCs|jS)N)rõ)rArLrLrMÚ get_numsides3sz"RegularPolyCollection.get_numsidescCs|jS)N)r÷)rArLrLrMÚ get_rotation6sz"RegularPolyCollection.get_rotationcs8ˆ ˆjˆjj¡‡fdd„ˆjDƒˆ_t ˆ|¡dS)Ncs$g|]}t |¡ ˆj ¡ ¡‘qSrL)r rÚrotater÷Ú get_matrix)rZrž)rArLrMr]=sz.RegularPolyCollection.draw..)rárÚrâràrQrr™)rArorL)rArMr™9s  zRegularPolyCollection.drawN)rrô)rrÓrÔrÕrgrvZunit_regular_polygonröÚCIRCLE_AREA_FACTORrÞr rärrùrúrr×r™rLrLrLrMrós 'róc@seZdZdZejjZdS)ÚStarPolygonCollectionz? Draw a collection of regular stars with *numsides* points.N)rrÓrÔrÕrgrvZunit_regular_starrörLrLrLrMrþCsrþc@seZdZdZejjZdS)ÚAsteriskPolygonCollectionzC Draw a collection of regular asterisks with *numsides* points.N)rrÓrÔrÕrgrvZunit_regular_asteriskrörLrLrLrMrÿJsrÿc @sReZdZdZdZddd „Zd d „ZeZeZd d „Z dd„Z dd„Z dd„Z e Z dS)ÚLineCollectiona All parameters must be sequences or scalars; if scalars, they will be converted to sequences. The property of the ith line segment is:: prop[i % len(props)] i.e., the properties cycle if the ``len`` of props is less than the number of segments. TNrérr¼c Ks||dkrtjd}|dkr&tjdf}|dkr:tjdf}t |¡}tj|f|| ||||||| | | dœ | —Ž| |¡dS)aë Parameters ---------- segments : 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 be a different length. colors : sequence, optional A sequence of RGBA tuples (e.g., arbitrary color strings, etc, not allowed). antialiaseds : sequence, optional A sequence of ones or zeros. linestyles : string, tuple, optional Either one of [ 'solid' | 'dashed' | 'dashdot' | 'dotted' ], or a dash tuple. The dash tuple is:: (offset, onoffseq) where ``onoffseq`` is an even length tuple of on and off ink in points. norm : Normalize, optional `~.colors.Normalize` instance. cmap : string or Colormap, optional Colormap name or `~.colors.Colormap` instance. pickradius : float, optional The tolerance in points for mouse clicks picking a line. Default is 5 pt. zorder : int, optional zorder of the LineCollection. Default is 2. facecolors : optional The facecolors of the LineCollection. Default is 'none'. Setting to a value other than 'none' will lead to a filled polygon being drawn between points on each line. Notes ----- If *linewidths*, *colors*, or *antialiaseds* is None, they default to their rcParams setting, in sequence form. If *offsets* and *transOffset* are not None, then *offsets* are transformed by *transOffset* and applied after the segments have been transformed to display coordinates. If *offsets* is not None but *transOffset* is None, then the *offsets* are added to the segments before any transformation. In this case, a single offset can be specified as:: offsets=(xo,yo) and this value will be added cumulatively to each successive segment, so as to produce a set of successively offset curves. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` array :attr:`~matplotlib.cm.ScalarMappable._A` is not None (i.e., a call to :meth:`~matplotlib.cm.ScalarMappable.set_array` has been made), at draw time a call to scalar mappable will be made to set the colors. Nz lines.colorzlines.linewidthzlines.antialiased) rrrrr rBrCrDrErFrJ)r'r(r%r¾rrÚ set_segments)rAÚsegmentsrrr rrBrCrDrErFrJrrKrLrLrMr_s,S    zLineCollection.__init__cCsp|dkr dSg}x0|D](}t|tjjƒs4t |t¡}| |¡qW|jdk rV| |¡}dd„|Dƒ|_ d|_ dS)NcSsg|]}t |¡‘qSrL)rgrv)rZZ_segrLrLrMr]Ùsz/LineCollection.set_segments..T) rTr7rbrcr©r<rur:Ú _add_offsetsr@r—)rArZ _segmentsZsegrLrLrMrÌs    zLineCollection.set_segmentscCs>g}x4|jD]*}dd„| ¡Dƒ}t |¡}| |¡q W|S)z¯ Returns ------- segments : list List of segments in the LineCollection. Each list item contains an array of vertices. cSsg|] \}}|‘qSrLrL)rZZvertexÚ_rLrLrMr]êsz/LineCollection.get_segments..)r@Z iter_segmentsr7r©ru)rArr rrrLrLrMÚ get_segmentsßs   zLineCollection.get_segmentscCs‚|j}t|ƒ}|jd}|dkrHx\t|ƒD]}||||||<q*Wn6x4t|ƒD](}||}|||||d…||<qRW|S)Nrr)r:rfr=Úrange)rAZsegsrBZNsegsZNoffsÚiÚiorLrLrMrðs  zLineCollection._add_offsetscCs| |¡d|_dS)a( Set the color(s) of the LineCollection. Parameters ---------- c : Matplotlib color argument (all patches have same color), or a sequence or rgba tuples; if it is a sequence the patches will cycle through the sequence. TN)r+r—)rArºrLrLrMr»ýs zLineCollection.set_colorcCs|jS)N)rÄ)rArLrLrMÚ get_color szLineCollection.get_color) NNNrNNNNrrr¼)rrÓrÔrÕrÅrrrærPrrr»r Ú get_colorsrLrLrLrMrQs*  b rcs¤eZdZdZdZd%dd„Zd d „Zd d „Zd d„ZeZ Z dd„Z dd„Z dd„Z d&dd„Zdd„Zdd„Zdd„Zdd„Z‡fdd „Z‡fd!d"„Zd#d$„Z‡ZS)'ÚEventCollectiona  A collection of discrete events. The events are given by a 1-dimensional array, usually the position of something along an axis, such as time or length. They do not have an amplitude and are displayed as vertical or horizontal parallel bars. TNrrrc  sö||d||df‰|dks,t|ƒdkr2g} n–t|dƒrP|jdkrPtdƒ‚nx|dksp| ¡dksp| ¡dkr’| ¡‡fd d „|Dƒ} d |_n6| ¡d krÀ| ¡‡fd d „|Dƒ} d|_ntdƒ‚tj|| f||||dœ| —Ž||_ ||_ dS)a  Parameters ---------- positions : 1D array-like object Each value is an event. orientation : {None, 'horizontal', 'vertical'}, optional The orientation of the **collection** (the event bars are along the orthogonal direction). Defaults to 'horizontal' if not specified or None. lineoffset : scalar, optional, default: 0 The offset of the center of the markers from the origin, in the direction orthogonal to *orientation*. linelength : scalar, optional, default: 1 The total height of the marker (i.e. the marker stretches from ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``). linewidth : scalar or None, optional, default: None If it is None, defaults to its rcParams setting, in sequence form. color : color, sequence of colors or None, optional, default: None If it is None, defaults to its rcParams setting, in sequence form. linestyle : str or tuple, optional, 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 : {None, 1, 2}, optional If it is None, defaults to its rcParams setting, in sequence form. **kwargs : optional Other keyword arguments are line collection properties. See :class:`~matplotlib.collections.LineCollection` for a list of the valid properties. Examples -------- .. plot:: gallery/lines_bars_and_markers/eventcollection_demo.py g@NrrÏrz:positions cannot be an array with more than one dimension.r¼Ú horizontalcsg|]‰‡fdd„ˆDƒ‘qS)csg|] }ˆ|f‘qSrLrL)rZÚcoord2)Úcoord1rLrMr]asz7EventCollection.__init__...rL)rZ)Úsegment)rrMr]asz,EventCollection.__init__..TÚverticalcsg|]‰‡fdd„ˆDƒ‘qS)csg|] }|ˆf‘qSrLrL)rZr)rrLrMr]fsz7EventCollection.__init__...rL)rZ)r)rrMr]fsFz.orientation must be 'horizontal' or 'vertical')rrr r) rfrUrÏr§r½ÚsortÚ_is_horizontalrrÚ _linelengthÚ _lineoffset) rAÚ positionsÚ orientationÚ lineoffsetÚ linelengthrZcolorrrrKrrL)rrMrs6;      zEventCollection.__init__cCs@| ¡}| ¡rdnd}g}x|D]}| |d|f¡q"W|S)zW return an array containing the floating-point values of the positions rr)rÚ is_horizontalru)rArÚposrrrLrLrMÚ get_positionsws  zEventCollection.get_positionscs¢|dkst|dƒr,t|ƒdkr,| g¡dS| ¡}| ¡}||d||df‰t |¡}| ¡| ¡r‚‡fdd„|Dƒ}n‡fdd„|Dƒ}| |¡dS)zH set the positions of the events to the specified value Nrfrg@csg|]‰‡fdd„ˆDƒ‘qS)csg|] }ˆ|f‘qSrLrL)rZr)rrLrMr]’sz..rL)rZ)r)rrMr]’sz1EventCollection.set_positions..csg|]‰‡fdd„ˆDƒ‘qS)csg|] }|ˆf‘qSrLrL)rZr)rrLrMr]•sz..rL)rZ)r)rrMr]•s) rUrfrÚget_lineoffsetÚget_linelengthr7r;rr)rArrrrrL)rrMÚ set_positions‚s        zEventCollection.set_positionscCsL|dkst|dƒr"t|ƒdkr"dS| ¡}t |t |¡g¡}| |¡dS)zC add one or more events at the specified positions Nrfr)rUrfrr7Úhstackr;r)rAZpositionrrLrLrMÚ add_positions™s  zEventCollection.add_positionscCs|jS)zN True if the eventcollection is horizontal, False if vertical )r)rArLrLrMr¥szEventCollection.is_horizontalcCs| ¡r dSdS)zf get the orientation of the event line, may be: [ 'horizontal' | 'vertical' ] r r)r)rArLrLrMÚget_orientation«szEventCollection.get_orientationcCsL| ¡}x"t|ƒD]\}}t |¡||<qW| |¡| ¡ |_d|_dS)zu switch the orientation of the event line, either from vertical to horizontal or vice versus TN)rÚ enumerater7Zfliplrrrrr—)rArrrrLrLrMÚswitch_orientation²s   z"EventCollection.switch_orientationcCs\|dks | ¡dks | ¡dkr&d}n| ¡dkr8d}ntdƒ‚|| ¡krPdS| ¡dS)zž set the orientation of the event line [ 'horizontal' | 'vertical' | None ] defaults to 'horizontal' if not specified or None Nr¼r TrFz.orientation must be 'horizontal' or 'vertical')r½r§rr$)rArrrLrLrMÚset_orientation¾s   zEventCollection.set_orientationcCs|jS)zE get the length of the lines used to mark each event )r)rArLrLrMrÐszEventCollection.get_linelengthcCsz|| ¡krdS| ¡}| ¡}| ¡r,dnd}x4|D],}||d|d|f<||d|d|f<q6W| |¡||_dS)zE set the length of the lines used to mark each event Nrrg@)rrrrrr)rArrrrrrLrLrMÚset_linelengthÖs   zEventCollection.set_linelengthcCs|jS)zE get the offset of the lines used to mark each event )r)rArLrLrMråszEventCollection.get_lineoffsetcCsz|| ¡krdS| ¡}| ¡}| ¡r,dnd}x4|D],}||d|d|f<||d|d|f<q6W| |¡||_dS)zE set the offset of the lines used to mark each event Nrrg@)rrrrrr)rArrrrrrLrLrMÚset_lineoffsetës   zEventCollection.set_lineoffsetcstt|ƒ ¡dS)z3Get the width of the lines used to mark each event.r)Úsuperr rÌ)rA)r€rLrMrÌúszEventCollection.get_linewidthcstt|ƒ ¡S)N)r(r rÌ)rA)r€rLrMÚget_linewidthsþszEventCollection.get_linewidthscCs | ¡dS)zD get the color of the lines used to mark each event r)r )rArLrLrMr szEventCollection.get_color)NrrNNrN)N)rrÓrÔrÕrÅrrrr!Zextend_positionsZappend_positionsrr"r$r%rr&rr'rÌr)r Ú __classcell__rLrL)r€rMr s0 S     r c@s"eZdZdZeZejdd„ƒZdS)ÚCircleCollectionz7 A collection of circles, drawn using splines. cKs8tj|f|Ž| |¡| t ¡¡tj ¡g|_ dS)zf *sizes* Gives the area of the circle in points^2 %(Collection)s N) rrrárør rnrgrvÚ unit_circler@)rArßrKrLrLrMrs zCircleCollection.__init__N) rrÓrÔrÕrýrÞr rärrLrLrLrMr+sr+c@s6eZdZdZejd dd„ƒZdd„Zej dd„ƒZ d S) ÚEllipseCollectionz8 A collection of ellipses, drawn using splines. ÚpointscKsxtj|f|Ždt |¡ ¡|_dt |¡ ¡|_t |¡ ¡|_||_ |  t   ¡¡t  d¡|_tj ¡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 :class:`~matplotlib.patches.Ellipse` with ``axes.transData`` as its transform. Other Parameters ---------------- **kwargs Additional kwargs inherited from the base :class:`Collection`. %(Collection)s gà?)rrrN)rrr7r©ZravelÚ_widthsÚ_heightsZdeg2radÚ_anglesÚ_unitsrør rnrÖrQrgrvr,r@)rAÚwidthsÚheightsZanglesZunitsrKrLrLrMr s  zEllipseCollection.__init__c CsÆ|j}|j}|jdkrd}n¦|jdkr8|jj|jj}nŠ|jdkrT|jj|jj}nn|jdkrf|j}n\|jdkr||jd}nF|jdkr|jj}n2|jd kr¤|jj}n|jd kr´d }ntd |jƒ‚t   t |j ƒd d f¡|_ |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<| || ƒ¡dS)zB Calculate transforms immediately before drawing. rêrržrŸZinchesr.gR@r‘r’Zdotsgð?zunrecognized units: %srNrr)rVrâr2Zbboxr‘ZviewLimr’ràr§r7r8rfr/rQr0Zsinr1Zcosr rrjr`rüÚcopyrø) rAZaxZfigZscr3r4Z sin_angleZ cos_angleZ_affineÚmrLrLrMÚ_set_transformsIsD                z!EllipseCollection._set_transformscCs| ¡t ||¡dS)N)r7rr™)rArorLrLrMr™tszEllipseCollection.drawN)r.) rrÓrÔrÕr rärr7rr×r™rLrLrLrMr-s  (+r-c@s"eZdZdZddd„Zdd„ZdS) ÚPatchCollectionzþ A generic collection of patches. This makes it easier to assign a color map to a heterogeneous collection of patches. This also may improve plotting speed, since PatchCollection will draw faster than a large number of patches. Fc s†|rjdd„‰‡fdd„|Dƒ|d<dd„|Dƒ|d<dd„|Dƒ|d <d d„|Dƒ|d <d d„|Dƒ|d <tj|f|Ž| |¡dS)a€ *patches* a sequence of Patch objects. This list may include a heterogeneous assortment of different patch types. *match_original* 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. If any of *edgecolors*, *facecolors*, *linewidths*, *antialiaseds* are None, they default to their :data:`matplotlib.rcParams` patch setting, in sequence form. The use of :class:`~matplotlib.cm.ScalarMappable` is optional. If the :class:`~matplotlib.cm.ScalarMappable` matrix _A is not None (i.e., a call to set_array has been made), at draw time a call to scalar mappable will be made to set the face colors. cSs| ¡r| ¡SddddgS)Nr)rÐr‹)ZpatchrLrLrMÚdetermine_facecolorœsz5PatchCollection.__init__..determine_facecolorcsg|] }ˆ|ƒ‘qSrLrL)rZr[)r9rLrMr]¡sz,PatchCollection.__init__..rcSsg|] }| ¡‘qSrL)rŒ)rZr[rLrLrMr]¢srcSsg|] }| ¡‘qSrL)rÌ)rZr[rLrLrMr]£srcSsg|] }| ¡‘qSrL)rÍ)rZr[rLrLrMr]¤srcSsg|] }| ¡‘qSrL)Zget_antialiased)rZr[rLrLrMr]¥sr N)rrrP)rAÚpatchesZmatch_originalrKrL)r9rMr…szPatchCollection.__init__cCsdd„|Dƒ}||_dS)NcSsg|]}| ¡ | ¡¡‘qSrL)r^Ztransform_pathZget_path)rZr[rLrLrMr]¬sz-PatchCollection.set_paths..)r@)rAr:rkrLrLrMrP«szPatchCollection.set_pathsN)F)rrÓrÔrÕrrPrLrLrLrMr8zs  &r8c@sBeZdZdZdd„Zdd„Zdd„Zedd „ƒZe j d d „ƒZ d S) ÚTriMeshz¨ Class for the efficient drawing of a triangular mesh using Gouraud shading. A triangular mesh is a :class:`~matplotlib.tri.Triangulation` object. cKs^tj|f|Ž||_d|_d|_tj ¡|_t   |j   dd¡|j   dd¡f¡}|j |¡dS)NÚgouraudTrér)rrÚ_triangulationÚ_shadingr$r riÚunitÚ_bboxr7r ržÚreshaperŸÚupdate_from_data_xy)rAZ triangulationrKrêrLrLrMr¹s zTriMesh.__init__cCs|jdkr| ¡|jS)N)r@rP)rArLrLrMrNÇs zTriMesh.get_pathscCs| |j¡|_dS)N)Úconvert_mesh_to_pathsr=r@)rArLrLrMrPÌszTriMesh.set_pathscCs4| ¡}tj|j||j|fdd}dd„|DƒS)zú Converts a given mesh into a sequence of :class:`matplotlib.path.Path` objects for easier rendering by backends that do not directly support meshes. This function is primarily of use to backend implementers. ré)ÚaxiscSsg|]}t |¡‘qSrL)rgrv)rZržrLrLrMr]Úsz1TriMesh.convert_mesh_to_paths..)Úget_masked_trianglesr7ÚstackržrŸ)ÚtriÚ trianglesrçrLrLrMrCÏs zTriMesh.convert_mesh_to_pathscCs²| ¡s dS| |jj¡| ¡}|j}| ¡}tj|j ||j |fdd}|  ¡|j |}|  ¡}| |¡| | ¡d¡| |||| ¡¡| ¡| |jj¡dS)Nré)rDr)r~rr€rr^r=rEr7rFržrŸrƒrÀr„r…r,rÌÚdraw_gouraud_trianglesrhr•r–)rAror\rGrHrçrr˜rLrLrMr™Üs  z TriMesh.drawN) rrÓrÔrÕrrNrPrØrCrr×r™rLrLrLrMr;±s  r;c@sTeZdZdZddd„Zdd„Zdd „Zd d „Zed d „ƒZ dd„Z e j dd„ƒZ dS)ÚQuadMeshaÄ Class for the efficient drawing of a quadrilateral mesh. 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. *shading* may be 'flat', or 'gouraud' TÚflatcKsztj|f|Ž||_||_t |t¡ |d|ddf¡|_||_ ||_ t j   ¡|_|j | |d|ddf¡¡dS)Nrr)rrÚ _meshWidthÚ _meshHeightr7r©r<rAÚ _coordinatesÚ _antialiasedr>r rir?r@rB)rAÚ meshWidthÚ meshHeightÚ coordinatesrZshadingrKrLrLrMrs   zQuadMesh.__init__cCs|jdkr| ¡|jS)N)r@rP)rArLrLrMrN"s zQuadMesh.get_pathscCs | |j|j|j¡|_d|_dS)NT)rCrLrMrNr@r—)rArLrLrMrP'szQuadMesh.set_pathscCs| ¡| |j¡S)N)r^Ztransform_bboxr@)rArjrLrLrMrm,szQuadMesh.get_datalimc Cs¤t|tjjƒr|j}n|}tj|dd…dd…f|dd…dd…f|dd…dd…f|dd…dd…f|dd…dd…ffdd}| ||ddf¡}dd„|DƒS) zþ Converts a given mesh into a sequence of :class:`matplotlib.path.Path` objects for easier rendering by backends that do not directly support quadmeshes. This function is primarily of use to backend implementers. Nrérr)rDrcSsg|]}t |¡‘qSrL)rgrv)rZržrLrLrMr]Dsz2QuadMesh.convert_mesh_to_paths..)rTr7rbrcr¦rërA)rPrQrRrºr.rLrLrMrC/s zQuadMesh.convert_mesh_to_pathsc Cs‚t|tjjƒr|j}n|}|dd…dd…f}|dd…dd…f}|dd…dd…f}|dd…dd…f}||||d} tj||| ||| ||| ||| f dd} |  ||dddf¡} | ¡ |d|ddf¡} | dd…dd…f} | dd…dd…f} | dd…dd…f}| dd…dd…f}| | ||d}tj| | || ||||||| |f dd}| ||dddf¡}| |fS) z³ Converts a given mesh into a sequence of triangles, each point with its own color. This is useful for experiments using `draw_qouraud_triangle`. Nrérg@r)rDér)rTr7rbrcr¦rërAr‹)rArPrQrRr[Zp_aZp_bZp_cZp_dZp_centerrHrºZc_aZc_bZc_cZc_dZc_centerrrLrLrMÚconvert_mesh_to_trianglesFs:z"QuadMesh.convert_mesh_to_trianglesc CsŠ| ¡s dS| |jj| ¡¡| ¡}| ¡}|j}| ¡r†t |jƒr†|  |jdd…df¡}|  |jdd…df¡}t   ||g¡}| ¡|jsÂ|j d¡}| |¡}| |jj¡}t ¡}n|j}|jsà| |¡}| ¡}| ¡}| |¡| | ¡d¡|jdkr<| |j|j|¡\} } |  || | | !¡¡n.| "|| !¡|j|j|||| #¡|j$| %¡¡ | &¡| '|jj¡d|_(dS)Nrr)rérr<F))r~rr€rr‚r^rXr9rqrfrsrtr7rwrƒr_rNrAr\r=r rnrar`r„r…r,rÌr>rTrLrMrIrhZdraw_quad_meshr‹rOZget_edgecolorsr•r–r—) rAror\rCrBrzr{rRr˜rHrrLrLrMr™psH        z QuadMesh.drawN)TrK)rrÓrÔrÕrrNrPrmrØrCrTrr×r™rLrLrLrMrJôs  *rJ) rJr;rårírórãrþr8r+r)r)0rÕrµZnumbersrr‰Znumpyr7Z matplotlibr'Úrrrrrr%r r r«r rgr rÝZpirýZ_define_aliasesrrrZinterpdr?rÙrãrårírórþrÿrr r+r-r8r;rJZkwdocZpatchstrÚkrLrLrLrMÚ sV ,1C/AAx^7C-