B Jd^@sdZddlZddlmZmZddlZddlZddlZddlZddl Z ddl m Z ddl Z ddl mZddlmZddlZddlZddlmZmZmZdd lmZmZmZmZGd d d eZiZe ee d d e!De ee ee dd e!De eeeZdZ"ddZ#ddZ$ddZ%ddZ&ddZ'ddZ(d\ddZ)d]ddZ*d^d d!Z+d"d#Z,d_d%d&Z-eZ.e /d'Z0e-Z1e,Z2Gd(d)d)Z3e3Z4d`d+d,Z5d-d.Z6Gd/d0d0Z7Gd1d2d2e7Z8Gd3d4d4e7Z9Gd5d6d6Z:Gd7d8d8e:Z;Gd9d:d:e:Zdbd>d?d;Gd@dAdAe:Z?e=ej@ejAdBdCGdDdEdEe:ZBe=ejCdcdFdGdHd?d;GdIdJdJe:ZDGdKdLdLe:ZEGdMdNdNe:ZFGdOdPdPe:ZGdQdRZHdSdTZIdUdVZJGdWdXdXZKdddZd[ZLdS)ea3 A module for converting numbers or color arguments to *RGB* or *RGBA*. *RGB* and *RGBA* are sequences of, respectively, 3 or 4 floats in the range 0-1. This module includes functions and classes for color specification conversions, and for mapping numbers to colors in a 1-D array of colors called a colormap. Mapping data onto colors using a colormap typically involves two steps: a data array is first mapped onto the range 0-1 using a subclass of `Normalize`, then this number is mapped to a color using a subclass of `Colormap`. Two subclasses of `Colormap` provided here: `LinearSegmentedColormap`, which uses piecewise-linear interpolation to define colormaps, and `ListedColormap`, which makes a colormap from a list of colors. .. seealso:: :doc:`/tutorials/colors/colormap-manipulation` for examples of how to make colormaps and :doc:`/tutorials/colors/colormaps` for a list of built-in colormaps. :doc:`/tutorials/colors/colormapnorms` for more details about data normalization More colormaps are available at palettable_. The module also provides functions for checking whether an object can be interpreted as a color (`is_color_like`), for converting such an object to an RGBA tuple (`to_rgba`) or to an HTML-like hex string in the "#rrggbb" format (`to_hex`), and a sequence of colors to an (n, 4) RGBA array (`to_rgba_array`). Caching is used for efficiency. Colors that Matplotlib recognizes are listed at :doc:`/tutorials/colors/colors`. .. _palettable: https://jiffyclub.github.io/palettable/ .. _xkcd color survey: https://xkcd.com/color/rgb/ N)SizedSequence)Number)Image)PngInfo)_apicbookscale) BASE_COLORSTABLEAU_COLORS CSS4_COLORS XKCD_COLORScs4eZdZfddZfddZfddZZS) _ColorMappingcst|i|_dS)N)super__init__cache)selfmapping) __class__C/var/www/html/venv/lib/python3.7/site-packages/matplotlib/colors.pyr=s z_ColorMapping.__init__cst|||jdS)N)r __setitem__rclear)rkeyvalue)rrrrAsz_ColorMapping.__setitem__cst||jdS)N)r __delitem__rr)rr)rrrrEs z_ColorMapping.__delitem__)__name__ __module__ __qualname__rrr __classcell__rr)rrr<s  rcCs&i|]\}}d|kr||ddqS)greygray)replace).0kvrrr Msr'cCs&i|]\}}d|kr||ddqS)r"r!)r#)r$r%r&rrrr'Rs)i@cCstS)z3Return the global mapping of names to named colors.)_colors_full_maprrrrget_named_colors_mapping[sr*cCs:|dkr |Sy |}Wntk r4t|}YnX|S)N)itemAttributeErrorfloat)exretrrr_sanitize_extrema`s r0cCst|totd|S)zDReturn whether *c* can be interpreted as an item in the color cycle.z \AC[0-9]+\Z) isinstancestrrematch)crrr _is_nth_colorjsr6cCs6t|r dSy t|Wntk r,dSXdSdS)z9Return whether *c* can be interpreted as an RGB(A) color.TFN)r6to_rgba ValueError)r5rrr is_color_likeos r9cKs4x.|D]"\}}t|s t|d|q WdS)zS For each *key, value* pair in *kwargs*, check that *value* is color-like. z is not a valid value for N)itemsr9r8)kwargsr%r&rrr_check_color_like|sr<cCsXt|}t|}t|jdd}t|jdd}||kr@td|j|jkoV||kS)z Return whether the colors *c1* and *c2* are the same. *c1*, *c2* can be single colors or lists/arrays of colors. rr z$Different number of elements passed.) to_rgba_arraymaxshaper8all)c1c2Zn1Zn2rrr same_colorsrCc Cst|rJddlm}|d}|ddg}|t|ddt|}ytj||f}Wnt t fk rxd}YnX|dkrt ||}y|tj||f<Wnt k rYnX|S)a Convert *c* to an RGBA color. Parameters ---------- c : Matplotlib color or ``np.ma.masked`` alpha : float, optional If *alpha* is given, force the alpha value of the returned RGBA tuple to *alpha*. If None, the alpha value from *c* is used. If *c* does not have an alpha channel, then alpha defaults to 1. *alpha* is ignored for the color value ``"none"`` (case-insensitive), which always maps to ``(0, 0, 0, 0)``. Returns ------- tuple Tuple of floats ``(r, g, b, a)``, where each channel (red, green, blue, alpha) can assume values between 0 and 1. r)rcParamszaxes.prop_cyclecolorr%r N) r6 matplotlibrDby_keygetintlenr)rKeyError TypeError_to_rgba_no_colorcycle)r5alpharDZ prop_cyclercolorsrgbarrrr7s    r7c Cs\|}|tjjkrdSt|tr|dkr.dSy t|}WnFtk rt|dkr|yt|}Wntk rzYnXYnXt|trpt d|}|rt dd|dd|dd|dd gD|d k r|nd fSt d |}|r6t d d|dd|dd|ddgD|d k r.|nd fSt d|}|rdd|dd|dd|dd |d dgD}|d k r||d<t |St d|}|rdd|dd|dd|dd|ddgD}|d k r||d<t |Sy t |}Wnt k rYnFXd|kr6dksHnt d|d||||d k r\|nd fSt d|t|tjr|jdkr|jddkr|d}t|st d|t|dkrt dtdd|Dst d|t tt |}t|dkr |d kr d}|d k r<|d d|f}tdd|DrXt d|S) a Convert *c* to an RGBA color, with no support for color-cycle syntax. If *alpha* is given, force the alpha value of the returned RGBA tuple to *alpha*. Otherwise, the alpha value from *c* is used, if it has alpha information, or defaults to 1. *alpha* is ignored for the color value ``"none"`` (case-insensitive), which always maps to ``(0, 0, 0, 0)``. )ggggnoner z\A#[a-fA-F0-9]{6}\Zcss|]}t|ddVqdS)N)rI)r$nrrr sz)_to_rgba_no_colorcycle..Ng?z\A#[a-fA-F0-9]{3}\Zcss|]}t|ddVqdS)rRrSN)rI)r$rTrrrrUsz\A#[a-fA-F0-9]{8}\ZcSsg|]}t|ddqS)rRrS)rI)r$rTrrr sz*_to_rgba_no_colorcycle.. z\A#[a-fA-F0-9]{4}\ZcSsg|]}t|ddqS)rRrS)rI)r$rTrrrrZsrzInvalid string grayscale value z . Value must be within 0-1 rangezInvalid RGBA argument: )rVr]z'RGBA sequence should have length 3 or 4css|]}t|tVqdS)N)r1r)r$xrrrrUscss|]}|dkp|dkVqdS)rr Nr)r$elemrrrrUsz&RGBA values should be within 0-1 range)npmaZmaskedr1r2lowerr)rKrJr3r4tupler-r8ndarrayndimr?reshapeiterabler@mapany)r5rNZorig_cr4rErrrrMs         & & 0  0     rMc st|rt|}ttjrjjdkrjdkrj ddkrtj rjj j ddnd}tj t|rԈj ddkr|j ddkrt|j ddfnj d|j dkrtdj dd krtttg}|dk r |nd |ddd f<n2j dd krN}|dk rN||ddd f<|dk r`d||<t |dk|dkBrtd |StdrtdtSy>t|rtfdd|DtStt|gtSWnttfk rYnXttr tdtdkr&tdtSttrddD}|d hkrftttg}n,|d hkr~t}ntddD}ntddD}|dk r||ddd f<|S)a Convert *c* to a (n, 4) array of RGBA colors. Parameters ---------- c : Matplotlib color or array of colors If *c* is a masked array, an ndarray is returned with a (0, 0, 0, 0) row for each masked value or row in *c*. alpha : float or sequence of floats, optional If *alpha* is given, force the alpha value of the returned RGBA tuple to *alpha*. If None, the alpha value from *c* is used. If *c* does not have an alpha channel, then alpha defaults to 1. *alpha* is ignored for the color value ``"none"`` (case-insensitive), which always maps to ``(0, 0, 0, 0)``. If *alpha* is a sequence and *c* is a single color, *c* will be repeated to match the length of *alpha*. Returns ------- array (n, 4) array of RGBA colors, where each channel (red, green, blue, alpha) can assume values between 0 and 1. ifrYr )rVr])axisNrz^The number of colors must match the number of alpha values if there are more than one of each.rVg?r\r]z&RGBA values should be within 0-1 rangerQ)rr]csg|]}t|qSr)r7)r$a)r5rrrZ`sz!to_rgba_array..zUsing a string of single character colors as a color sequence is not supported. The colors can be passed as an explicit list instead.cSs&h|]}t|ttfrt|ndqS)r\)r1listrcrJ)r$ccrrr qsz to_rgba_array..cSsg|] }t|qSr)r7)r$rnrrrrZwscSsg|] }t|qSr)r7)r$rnrrrrZys)r`rgasarrayZravelr1rddtypekindrer?ra is_maskedmaskriZgetdatatiler8 column_stackzerosrJcopyrZ_str_lower_equalr-arrayr7rLr2rones)r5rNrtresultZlensrPr)r5rr=s\               r=cCst|ddS)zAConvert *c* to an RGB color, silently dropping the alpha channel.NrV)r7)r5rrrto_rgbsr|FcCs0t|}|s|dd}dddd|DS)aM Convert *c* to a hex color. Parameters ---------- c : :doc:`color ` or `numpy.ma.masked` keep_alpha: bool, default: False If False, use the ``#rrggbb`` format, otherwise use ``#rrggbbaa``. Returns ------- str ``#rrggbb`` or ``#rrggbbaa`` hex color string NrV#css$|]}ttt|ddVqdS)rS02xN)formatrIround)r$valrrrrUszto_hex..)r7join)r5 keep_alpharrrto_hexs rz\A#[a-fA-F0-9]{6}\Zc@s2eZdZdZeZejZeeZee Z ee Z dS)ColorConverterz A class only kept for backwards compatibility. Its functionality is entirely provided by module-level functions. N) rrr__doc__r)rOr staticmethodr|r7r=rrrrrs r?c Cst|r:tdd||}ttj||tddd}|Syt|}Wn,tk rt}ztd|Wdd}~XYnX|j}t |dks|ddkrt d|dddf}|dddf} |dddf} |dd ks|d d krt d t |dk rt d |dkr"t| d }n||d}|dtdd||}t ||dd } |dd || d|| || d} t| dg| | | | | d| | d| d gg}t|d d S)af Create an *N* -element 1D lookup table. This assumes a mapping :math:`f : [0, 1] \rightarrow [0, 1]`. The returned data is an array of N values :math:`y = f(x)` where x is sampled from [0, 1]. By default (*gamma* = 1) x is equidistantly sampled from [0, 1]. The *gamma* correction factor :math:`\gamma` distorts this equidistant sampling by :math:`x \rightarrow x^\gamma`. Parameters ---------- N : int The number of elements of the created lookup table; at least 1. data : (M, 3) array-like or callable Defines the mapping :math:`f`. If a (M, 3) array-like, the rows define values (x, y0, y1). The x values must start with x=0, end with x=1, and all x values be in increasing order. A value between :math:`x_i` and :math:`x_{i+1}` is mapped to the range :math:`y^1_{i-1} \ldots y^0_i` by linear interpolation. For the simple case of a y-continuous mapping, y0 and y1 are identical. The two values of y are to allow for discontinuous mapping functions. E.g. a sawtooth with a period of 0.2 and an amplitude of 1 would be:: [(0, 1, 0), (0.2, 1, 0), (0.4, 1, 0), ..., [(1, 1, 0)] In the special case of ``N == 1``, by convention the returned value is y0 for x == 1. If *data* is a callable, it must accept and return numpy arrays:: data(x : ndarray) -> ndarray and map values between 0 - 1 to 0 - 1. gamma : float Gamma correction factor for input distribution x of the mapping. See also https://en.wikipedia.org/wiki/Gamma_correction. Returns ------- array The lookup table where ``lut[x * (N-1)]`` gives the closest value for values of x between 0 and 1. Notes ----- This function is internally used for `.LinearSegmentedColormap`. rr )rqz$data must be convertible to an arrayNrYrVzdata must be nx3 formatgr\g?z8data mapping points must start with x=0 and end with x=1z3data mapping points must have x in increasing order)callabler`linspaceclipryr- ExceptionrLr?rJr8diffriZ searchsortedZ concatenate) NdatagammaZxindlutZadataerrr?r^y0y1indZdistancerrr_create_lookup_tables<;  ,"rcCs*t|ddr&tjddd|jdddS)N_globalFz3.3z3.6aYou are modifying the state of a globally registered colormap. This has been deprecated since %(since)s and %(removal)s, you will not be able to modify a registered colormap in-place. To remove this warning, you can make a copy of the colormap first. cmap = mpl.cm.get_cmap("z ").copy())Zremovalmessage)getattrrZwarn_deprecatedname)cmaprrr_warn_if_global_cmap_modifieds  rc@seZdZdZd/ddZd0ddZd d Zd d Zd dZd1ddZ ddZ d2ddZ ddZ d3ddZ ddddddZddddddZdd Zd!d"Zd#d$Zd%d&Zd4d'd(Zd)d*Zd+d,Zd-d.ZdS)5Colormapa Baseclass for all scalar to RGBA mappings. Typically, Colormap instances are used to convert data values (floats) from the interval ``[0, 1]`` to the RGBA color that the respective Colormap represents. For scaling of data into the ``[0, 1]`` interval see `matplotlib.colors.Normalize`. Subclasses of `matplotlib.cm.ScalarMappable` make heavy use of this ``data -> normalize -> map-to-color`` processing chain. cCsR||_t||_d|_d|_d|_|j|_|jd|_|jd|_d|_ d|_ dS)z Parameters ---------- name : str The name of the colormap. N : int The number of rgb quantization levels. )ggggNr rYF) rrIr _rgba_bad _rgba_under _rgba_over_i_under_i_over_i_bad_isinitcolorbar_extend)rrrrrrr5s    zColormap.__init__NFc Cs|js|tj|r |jnt|}tj|dd}|jj sL| }|jj dkrtj ddN||j9}d||dk<|jd|||jk<tj|d|j|d |t}Wd QRX|j|||jdk<|j||dk<|j||<|r|jd tj}n |j}tj|jd |jd }|j|dd|d|d k rt|rpt|}|j|jkrptd|j|jft|dd}|r|d tj}||d<|ddkrt|rt|r|j|jkrd||<nd|dd d f<t|st |}|S)a Parameters ---------- X : float or int, ndarray or scalar The data value(s) to convert to RGBA. For floats, X should be in the interval ``[0.0, 1.0]`` to return the RGBA values ``X*100`` percent along the Colormap line. For integers, X should be in the interval ``[0, Colormap.N)`` to return RGBA values *indexed* from the Colormap with index ``X``. alpha : float or array-like or None Alpha must be a scalar between 0 and 1, a sequence of such floats with shape matching X, or None. bytes : bool If False (default), the returned RGBA values will be floats in the interval ``[0, 1]`` otherwise they will be uint8s in the interval ``[0, 255]``. Returns ------- Tuple of RGBA values if X is scalar, otherwise an array of RGBA values with a shape of ``X.shape + (4, )``. T)rxfignore)invalidr\rr )outNrS)r])r?rqr)rkmoderz?alpha is array-like but its shape %s doesn't match that of X %s).r\)rrrr.)!r_initr`rarsrtisnanryrqZisnativebyteswapZ newbyteorderrrZerrstaterrastyperIrrr_lutZuint8rxemptyr?Ztakergrpr8r@rirc)rXrNbytesZmask_badZxarrPrrr__call__MsL           zColormap.__call__cCs<|j}||}|j|j|jr2t|j|_d|_|S)NF) r__new____dict__updaterr`rxrr)rclsZ cmapobjectrrr__copy__s zColormap.__copy__cCsRt|tr"|j|jks"|j|jkr&dS|js4||jsB|t|j|jS)NF) r1rrrrrr`Z array_equalr)rotherrrr__eq__s zColormap.__eq__cCs |js|t|j|jS)z Get the color for masked values.)rrr`ryrr)rrrrget_badszColormap.get_badr%cCs&t|t|||_|jr"|dS)z Set the color for masked values.N)rr7rr _set_extremes)rrErNrrrset_bads zColormap.set_badcCs |js|t|j|jS)z*Get the color for low out-of-range values.)rrr`ryrr)rrrr get_underszColormap.get_undercCs&t|t|||_|jr"|dS)z*Set the color for low out-of-range values.N)rr7rrr)rrErNrrr set_unders zColormap.set_undercCs |js|t|j|jS)z+Get the color for high out-of-range values.)rrr`ryrr)rrrrget_overszColormap.get_overcCs&t|t|||_|jr"|dS)z+Set the color for high out-of-range values.N)rr7rrr)rrErNrrrset_overs zColormap.set_over)badunderovercCs:|dk r|||dk r$|||dk r6||dS)z Set the colors for masked (*bad*) values and, when ``norm.clip = False``, low (*under*) and high (*over*) out-of-range values. N)rrr)rrrrrrr set_extremess   zColormap.set_extremescCst|}|j|||d|S)z Return a copy of the colormap, for which the colors for masked (*bad*) values and, when ``norm.clip = False``, low (*under*) and high (*over*) out-of-range values, have been set accordingly. )rrr)rxr)rrrrZnew_cmrrr with_extremess zColormap.with_extremescCsh|jr|j|j|j<n|jd|j|j<|jr>|j|j|j<n|j|jd|j|j<|j|j|j<dS)Nrr )rrrrrrrr)rrrrrszColormap._set_extremescCs tddS)z)Generate the lookup table, ``self._lut``.zAbstract class onlyN)NotImplementedError)rrrrrszColormap._initcCsb|js|t|jdddf|jdddfko`t|jdddf|jdddfkS)z)Return whether the colormap is grayscale.Nrr rY)rrr`r@r)rrrris_grays*zColormap.is_graycCs tdS)z-Return a new colormap with *lutsize* entries.N)r)rlutsizerrr _resampleszColormap._resamplecCs tdS)a Return a reversed instance of the Colormap. .. note:: This function is not implemented for base class. Parameters ---------- name : str, optional The name for the reversed colormap. If it's None the name will be the name of the parent colormap + "_r". See Also -------- LinearSegmentedColormap.reversed ListedColormap.reversed N)r)rrrrrreversedszColormap.reversedcCsttddtdtddf}||dd}t}|jd}dtjd}t }| d|| d || d || d |t |j |d |d |S)z.Generate a PNG representation of the Colormap.rr T)rz colormapz Matplotlib vz, https://matplotlib.orgZTitle DescriptionAuthorZSoftwareZpng)rpnginfo)r`rur_REPR_PNG_SIZEioBytesIOrmpl __version__radd_textrZ fromarraysavegetvalue)rrZpixels png_bytestitleauthorrrrr _repr_png_s      zColormap._repr_png_cCs||}t|d}dd}d|jd|jd|jd|dtd d d ||d ||d ||dS)z0Generate an HTML representation of the Colormap.asciicSst|dd}d|d|dS)NT)rz
)r)rE hex_colorrrr color_block-s z)Colormap._repr_html_..color_blockz-
z,
z colormap
zD under
bad z&
over z
) rbase64 b64encodedecoderrrrr)rrZ png_base64rrrr _repr_html_)s zColormap._repr_html_cCs|S)zReturn a copy of the colormap.)r)rrrrrxLsz Colormap.copy)r)NF)r%N)r%N)r%N)N)rrrrrrrrrrrrrrrrrrrrrrrrxrrrrr)s*   N         #rcs^eZdZdZdfdd ZddZdd Zedd d Zd d Z eddZ dddZ Z S)LinearSegmentedColormapz Colormap objects based on lookup tables using linear segments. The lookup table is generated using linear interpolation for each primary color, with the 0-1 domain divided into any number of segments. r?cs$d|_t||||_||_dS)a Create colormap from linear mapping segments segmentdata argument is a dictionary with a red, green and blue entries. Each entry should be a list of *x*, *y0*, *y1* tuples, forming rows in a table. Entries for alpha are optional. Example: suppose you want red to increase from 0 to 1 over the bottom half, green to do the same over the middle half, and blue over the top half. Then you would use:: cdict = {'red': [(0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (1.0, 1.0, 1.0)], 'green': [(0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)], 'blue': [(0.0, 0.0, 0.0), (0.5, 0.0, 0.0), (1.0, 1.0, 1.0)]} Each row in the table for a given color is a sequence of *x*, *y0*, *y1* tuples. In each sequence, *x* must increase monotonically from 0 to 1. For any input value *z* falling between *x[i]* and *x[i+1]*, the output value of a given color will be linearly interpolated between *y1[i]* and *y0[i+1]*:: row i: x y0 y1 / / row i+1: x y0 y1 Hence y0 in the first row and y1 in the last row are never used. See Also -------- LinearSegmentedColormap.from_list Static method; factory function for generating a smoothly-varying LinearSegmentedColormap. FN) monochromerr _segmentdata_gamma)rrZ segmentdatarr)rrrrZs-z LinearSegmentedColormap.__init__cCst|jddft|_t|j|jd|j|jdddf<t|j|jd|j|jdddf<t|j|jd|j|jddd f<d |jkrt|j|jd d|jdddf<d |_| dS) NrVr]redrgreenr bluerYrNT) r`rzrr-rrrrrr)rrrrrs"""  zLinearSegmentedColormap._initcCs||_|dS)z.Set a new gamma value and regenerate colormap.N)rr)rrrrr set_gammasz!LinearSegmentedColormap.set_gammac Cst|stdt|dtrLt|ddkrLt|dtsLt|\}}ntddt|}t |j \}}}}t |||gt |||gt |||gt |||gd} t || ||S)a Create a `LinearSegmentedColormap` from a list of colors. Parameters ---------- name : str The name of the colormap. colors : array-like of colors or array-like of (value, color) If only colors are given, they are equidistantly mapped from the range :math:`[0, 1]`; i.e. 0 maps to ``colors[0]`` and 1 maps to ``colors[-1]``. If (value, color) pairs are given, the mapping is from *value* to *color*. This can be used to divide the range unevenly. N : int The number of rgb quantization levels. gamma : float zcolors must be iterablerrYr )rrrrN) r`rgr8r1rrJr2ziprr=Trvr) rrOrrvalsrgbrlZcdictrrr from_lists z!LinearSegmentedColormap.from_listcCs,t|j|j|}|j|_|j|_|j|_|S)z-Return a new colormap with *lutsize* entries.)rrrrrr)rrnew_cmaprrrrs  z!LinearSegmentedColormap._resamplecCs |d|S)Nr r)funcr^rrr _reversersz!LinearSegmentedColormap._reverserNcsX|dkrjd}fddjD}t||jj}j|_j|_j|_|S)ag Return a reversed instance of the Colormap. Parameters ---------- name : str, optional The name for the reversed colormap. If it's None the name will be the name of the parent colormap + "_r". Returns ------- LinearSegmentedColormap The reversed colormap. N_rcs:i|]2\}}t|r"tj|nddt|D|qS)cSs g|]\}}}d|||fqS)g?r)r$r^rrrrrrZsz?LinearSegmentedColormap.reversed...)r functoolspartialrr)r$rr)rrrr'sz4LinearSegmentedColormap.reversed..) rrr:rrrrrr)rrZdata_rrr)rrrs  z LinearSegmentedColormap.reversed)rr)rr)N) rrrrrrrrrrrrr rr)rrrQs2 & rcs<eZdZdZd fdd ZddZdd Zd d d ZZS)ListedColormapa* Colormap object generated from a list of colors. This may be most useful when indexing directly into a colormap, but it can also be used to generate special colormaps for ordinary mapping. Parameters ---------- colors : list, array List of Matplotlib color specifications, or an equivalent Nx3 or Nx4 floating point array (*N* rgb or rgba values). name : str, optional String to identify the colormap. N : int, optional Number of entries in the map. The default is *None*, in which case there is one colormap entry for each element in the list of colors. If :: N < len(colors) the list will be truncated at *N*. If :: N > len(colors) the list will be extended by repetition. rNcsd|_|dkr||_t|}nt|tr<|g||_d|_njt|rrt|dkrXd|_tt t |||_n4y t |}Wnt k rYnX|g||_d|_t ||dS)NFTr )rrOrJr1r2r`rgrm itertoolsislicecycler-rLrr)rrOrrr")rrrrs&       zListedColormap.__init__cCs>t|jddft|_t|j|jdd<d|_|dS)NrVr]rT) r`rwrr-rr=rOrr)rrrrr(szListedColormap._initcCs<|tdd|}t||jd}|j|_|j|_|j|_|S)z-Return a new colormap with *lutsize* entries.rr )r)r`rrrrrr)rrrOrrrrr.s zListedColormap._resamplecCsL|dkr|jd}tt|j}t|||jd}|j|_|j|_|j|_|S)al Return a reversed instance of the Colormap. Parameters ---------- name : str, optional The name for the reversed colormap. If it's None the name will be the name of the parent colormap + "_r". Returns ------- ListedColormap A reversed instance of the colormap. Nr)rr) rrmrrOrrrrr)rrZcolors_rrrrrr8s zListedColormap.reversed)rN)N) rrrrrrrrr rr)rrrs  rc@seZdZdZdddZeddZejddZed d Zejd d Zed d Z e jdd Z ddZ e ddZ dddZ ddZddZddZddZdS) Normalizezd A class which, when called, linearly normalizes data into the ``[0.0, 1.0]`` interval. NFcCs.t||_t||_||_d|_t|_dS)aM Parameters ---------- vmin, vmax : float or None If *vmin* and/or *vmax* is not given, they are initialized from the minimum and maximum value, respectively, of the first input processed; i.e., ``__call__(A)`` calls ``autoscale_None(A)``. clip : bool, default: False If ``True`` values falling outside the range ``[vmin, vmax]``, are mapped to 0 or 1, whichever is closer, and masked values are set to 1. If ``False`` masked values remain masked. Clipping silently defeats the purpose of setting the over, under, and masked colors in a colormap, so it is likely to lead to surprises; therefore the default is ``clip=False``. Notes ----- Returns 0 if ``vmin == vmax``. N)r0_vmin_vmax_clip_scalerZCallbackRegistry callbacks)rvminvmaxrrrrrYs   zNormalize.__init__cCs|jS)N)r)rrrrruszNormalize.vmincCs$t|}||jkr ||_|dS)N)r0r_changed)rrrrrrys cCs|jS)N)r)rrrrrszNormalize.vmaxcCs$t|}||jkr ||_|dS)N)r0rr)rrrrrrs cCs|jS)N)r)rrrrrszNormalize.clipcCs||jkr||_|dS)N)rr)rrrrrrs cCs|jddS)z~ Call this whenever the norm is changed to notify all the callback listeners to the 'changed' signal. changedN)rprocess)rrrrrszNormalize._changedcCszt| }|r|g}t|}t|tjs:|jtjkrHt|tj}tj |}t |}tj j |||dd}||fS)ar Homogenize the input *value* for easy and efficient normalization. *value* can be a scalar or sequence. Returns ------- result : masked array Masked array with the same shape as *value*. is_scalar : bool Whether *value* is a scalar. Notes ----- Float dtypes are preserved; integer types with two bytes or smaller are converted to np.float32, and larger types are converted to np.float64. Preserving float32 when possible, and using in-place operations, greatly improves speed for large arrays. T)rtrqrx) r`rgZmin_scalar_typeZ issubdtypeintegertypeZbool_ promote_typesfloat32ragetmaskrpry)r is_scalarrqrtrr{rrr process_values    zNormalize.process_valuec Cs|dkr|j}||\}}||||j\\}}||j\\}}||kr^|dnp||krptdn^|rtj |}tjj t| ||||d}|j } | |8} | ||} tjj | |j dd}|r|d}|S)a Normalize *value* data in the ``[vmin, vmax]`` interval into the ``[0.0, 1.0]`` interval and return it. Parameters ---------- value Data to normalize. clip : bool If ``None``, defaults to ``self.clip`` (which defaults to ``False``). Notes ----- If not already initialized, ``self.vmin`` and ``self.vmax`` are initialized using ``self.autoscale_None(value)``. Nrz/minvalue must be less than or equal to maxvalue)rtF)rtrx)rrautoscale_Nonerrfillr8r`rarryfilledrrt) rrrr{rr_rrtresdatrrrrs*     zNormalize.__call__cCsn|std||j\\}}||j\\}}t|rZtj|}||||S||||SdS)Nz/Not invertible until both vmin and vmax are set) scaledr8rrrr`rgrarp)rrrrrrrrrinverses  zNormalize.inversecCs"t|}||_||_dS)z&Set *vmin*, *vmax* to min, max of *A*.N)r` asanyarrayminrr>r)rArrr autoscales  zNormalize.autoscalecCsBt|}|jdkr$|jr$||_|jdkr>|jr>||_dS)z@If vmin or vmax are not set, use the min/max of *A* to set them.N)r`rrsizerrr>)rrrrrrs   zNormalize.autoscale_NonecCs|jdk o|jdk S)z%Return whether vmin and vmax are set.N)rr)rrrrrszNormalize.scaled)NNF)N)rrrrrpropertyrsetterrrrrrrrrrrrrrrrSs     # - rcsVeZdZd fdd ZeddZejddZfddZdd d Zd d Z Z S) TwoSlopeNormNcsZtj||d||_|dk r6|dk r6||kr6td|dk rV|dk rV||krVtddS)a Normalize data with a set center. Useful when mapping data with an unequal rates of change around a conceptual center, e.g., data that range from -2 to 4, with 0 as the midpoint. Parameters ---------- vcenter : float The data value that defines ``0.5`` in the normalization. vmin : float, optional The data value that defines ``0.0`` in the normalization. Defaults to the min value of the dataset. vmax : float, optional The data value that defines ``1.0`` in the normalization. Defaults to the max value of the dataset. Examples -------- This maps data value -4000 to 0., 0 to 0.5, and +10000 to 1.0; data between is linearly interpolated:: >>> import matplotlib.colors as mcolors >>> offset = mcolors.TwoSlopeNorm(vmin=-4000., vcenter=0., vmax=10000) >>> data = [-4000., -2000., 0., 2500., 5000., 7500., 10000.] >>> offset(data) array([0., 0.25, 0.5, 0.625, 0.75, 0.875, 1.0]) )rrNz2vmin, vcenter, and vmax must be in ascending order)rr_vcenterr8)rvcenterrr)rrrr s zTwoSlopeNorm.__init__cCs|jS)N)r )rrrrr!5szTwoSlopeNorm.vcentercCs||jkr||_|dS)N)r r)rrrrrr!9s cs8t||j|jkr |j|_|j|jkr4|j|_dS)z= Get vmin and vmax, and then clip at vcenter N)rrrr!r)rr)rrrr?s    zTwoSlopeNorm.autoscale_NonecCs||\}}|||j|jkr2|jks>> import matplotlib.colors as mcolors >>> norm = mcolors.CenteredNorm(halfrange=4.0) >>> data = [-2., 0., 4.] >>> norm(data) array([0.25, 0.5 , 1. ]) N)rrr)rrr  halfrange)rr!r(r)rrrrgs!zCenteredNorm.__init__cCs |j|j|_|j|j|_dS)zK Set *vmin* and *vmax* based on *vcenter* and *halfrange*. N)r  _halfrangerr)rrrr_set_vmin_vmaxszCenteredNorm._set_vmin_vmaxcCs6t|}t|j|||j|_|dS)zY Set *halfrange* to ``max(abs(A-vcenter))``, then set *vmin* and *vmax*. N)r`rr>r rr)r*)rrrrrrs zCenteredNorm.autoscalecCs(t|}|jdkr$|jr$||dS)zSet *vmin* and *vmax*.N)r`rr)rr)rrrrrrs zCenteredNorm.autoscale_NonecCs|jS)N)r )rrrrr!szCenteredNorm.vcentercCsJ||jkr||_||jdk rFt|j|j|j|j|_|dS)N)r rrr>rr)r*)rr!rrrr!s   cCs|jS)N)r))rrrrr(szCenteredNorm.halfrangecCs*|dkrd|_d|_d|_n t||_dS)N)r)rrabs)rr(rrrr(s cs"|jdk r|tj||dS)N)r)r)r*rr)rrr)rrrrs zCenteredNorm.__call__)rNF)N) rrrrr*rrrr!rr(rr rr)rrr'fs&    r')initcs|dkrtjt|dS|dkr*d dd}t|Gfddd|}|tkr^jdn|j|_|j|_|j|_|j |_ j t dtj j fj d |j_|S) a/ Decorator for building a `.Normalize` subclass from a `~.scale.ScaleBase` subclass. After :: @make_norm_from_scale(scale_cls) class norm_cls(Normalize): ... *norm_cls* is filled with methods so that normalization computations are forwarded to *scale_cls* (i.e., *scale_cls* is the scale that would be used for the colorbar of a mappable normalized with *norm_cls*). If *init* is not passed, then the constructor signature of *norm_cls* will be ``norm_cls(vmin=None, vmax=None, clip=False)``; these three parameters will be forwarded to the base class (``Normalize.__init__``), and a *scale_cls* object will be initialized with no arguments (other than a dummy axis). If the *scale_cls* constructor takes additional parameters, then *init* should be passed to `make_norm_from_scale`. It is a callable which is *only* used for its signature. First, this signature will become the signature of *norm_cls*. Second, the *norm_cls* constructor will bind the parameters passed to it using this signature, extract the bound *vmin*, *vmax*, and *clip* values, pass those to ``Normalize.__init__``, and forward the remaining bound values (including any defaults defined by the signature) to the *scale_cls* constructor. N)r,FcSsdS)Nr)rrrrrrr,z"make_norm_from_scale..initcs2eZdZfddZdddZddZZS) z"make_norm_from_scale..NormcsVj||tjffdddDfddij|_|j|_dS)Ncsi|]}j||qSr) argumentspop)r$r%)barrr'sz?make_norm_from_scale..Norm.__init__..)rrrrk)bindapply_defaultsrrr.rZ get_transform_trf)rargsr;)rbound_init_signature scale_cls)r0rrs  z+make_norm_from_scale..Norm.__init__NcSs||\}}|||j|jkr,td|j|jkrDt|dS|dkrR|j}|rht||j|j}|j | t |}|j |j|jg\}}t ||g std||8}|||}tjj|dd}|r|dS|S)Nz"vmin must be less or equal to vmaxrzInvalid vmin or vmaxF)rx)rrrrr8r`Z full_likerr3 transformrfr?isfiniter@raZmasked_invalid)rrrrZt_valuet_vmint_vmaxrrrrs$     z+make_norm_from_scale..Norm.__call__cSs|std|j|jkr$td|j|j|jg\}}t||gsVtd| |\}}|||}||7}|j | t |}|r|dS|S)NzNot invertible until scaledz"vmin must be less or equal to vmaxzInvalid vmin or vmaxr) rr8rrr3r7r`r8r@rinvertedrfr?)rrr9r:rZrescaledrrrr s    z*make_norm_from_scale..Norm.inverse)N)rrrrrrr r)r5r6)rrNorms r<r) parameters)NNF)rrmake_norm_from_scaleinspect signaturerrrrrr# ParameterPOSITIONAL_OR_KEYWORDr=valuesr __signature__)r6Z base_norm_clsr,r<r)r5r6rr>s  /r>cCsdS)Nr)Z functionsrrrrrr)r-rEc@seZdZdZdS)FuncNorma, Arbitrary normalization using functions for the forward and inverse. Parameters ---------- functions : (callable, callable) two-tuple of the forward and inverse functions for the normalization. The forward function must be monotonic. Both functions must have the signature :: def forward(values: array-like) -> array-like vmin, vmax : float or None If *vmin* and/or *vmax* is not given, they are initialized from the minimum and maximum value, respectively, of the first input processed; i.e., ``__call__(A)`` calls ``autoscale_None(A)``. clip : bool, default: False If ``True`` values falling outside the range ``[vmin, vmax]``, are mapped to 0 or 1, whichever is closer, and masked values are set to 1. If ``False`` masked values remain masked. Clipping silently defeats the purpose of setting the over, under, and masked colors in a colormap, so it is likely to lead to surprises; therefore the default is ``clip=False``. N)rrrrrrrrrF'srFrt) nonpositivecs,eZdZdZfddZfddZZS)LogNormz8Normalize a given value to the 0-1 range on a log scale.cs ttjj||dkddS)Nr)rt)rrr`rary)rr)rrrrLszLogNorm.autoscalecs ttjj||dkddS)Nr)rt)rrr`rary)rr)rrrrPszLogNorm.autoscale_None)rrrrrrr rr)rrrHHs rH )basecCsdS)Nr) linthreshZlinscalerrrrJrrrrEWsc@s*eZdZdZeddZejddZdS) SymLogNorma The symmetrical logarithmic scale is logarithmic in both the positive and negative directions from the origin. Since the values close to zero tend toward infinity, there is a need to have a range around zero that is linear. The parameter *linthresh* allows the user to specify the size of this range (-*linthresh*, *linthresh*). Parameters ---------- linthresh : float The range within which the plot is linear (to avoid having the plot go to infinity around zero). linscale : float, default: 1 This allows the linear range (-*linthresh* to *linthresh*) to be stretched relative to the logarithmic range. Its value is the number of decades to use for each half of the linear range. For example, when *linscale* == 1.0 (the default), the space used for the positive and negative halves of the linear range will be equal to one decade in the logarithmic range. base : float, default: 10 cCs|jjS)N)rrK)rrrrrKrszSymLogNorm.linthreshcCs ||j_dS)N)rrK)rrrrrrKvsN)rrrrrrKrrrrrrLUs rLcs4eZdZdZd fdd Zd ddZdd ZZS) PowerNormzs Linearly map a given value to the 0-1 range and then apply a power-law normalization over that range. NFcst|||||_dS)N)rrr)rrrrr)rrrrszPowerNorm.__init__c Cs|dkr|j}||\}}|||j}|j|j}}||krLtdn||kr`|dn||rtj |}tj j t| ||||d}|j } | |8} d| | dk<t| || | |||} tj j | |jdd}|r|d}|S)Nz/minvalue must be less than or equal to maxvaluer)rtF)rtrx)rrrrrrr8rr`rarryrrpowerrt) rrrr{rrrrrtrrrrrs.     zPowerNorm.__call__cCsv|std|j}|j|j}}t|rXtj|}tj |d||||St |d||||SdS)NzNot invertible until scaledg?) rr8rrrr`rgrarprNpow)rrrrrrrrrrs  zPowerNorm.inverse)NNF)N)rrrrrrrr rr)rrrM{s rMcs:eZdZdZd ddfdd Zd dd Zd d ZZS) BoundaryNorma Generate a colormap index based on discrete intervals. Unlike `Normalize` or `LogNorm`, `BoundaryNorm` maps values to integers instead of to the interval 0-1. Mapping to the 0-1 interval could have been done via piece-wise linear interpolation, but using integers seems simpler, and reduces the number of conversions back and forth between integer and floating point. Fneither)extendcs|r|dkrtdtj|d|d|dt||_t|j|_|jdkr^td|||_||_ d|_ |jd |_ d|_ |d kr|j d 7_ d |_ |d kr|j d 7_ |j |jkrtd |j d |ddS)a Parameters ---------- boundaries : array-like Monotonically increasing sequence of at least 2 boundaries. ncolors : int Number of colors in the colormap to be used. clip : bool, optional If clip is ``True``, out of range values are mapped to 0 if they are below ``boundaries[0]`` or mapped to ``ncolors - 1`` if they are above ``boundaries[-1]``. If clip is ``False``, out of range values are mapped to -1 if they are below ``boundaries[0]`` or mapped to *ncolors* if they are above ``boundaries[-1]``. These are then converted to valid indices by `Colormap.__call__`. extend : {'neither', 'both', 'min', 'max'}, default: 'neither' Extend the number of bins to include one or both of the regions beyond the boundaries. For example, if ``extend`` is 'min', then the color to which the region between the first pair of boundaries is mapped will be distinct from the first color in the colormap, and by default a `~matplotlib.colorbar.Colorbar` will be drawn with the triangle extension on the left or lower end. Returns ------- int16 scalar or array Notes ----- *boundaries* defines the edges of bins, and data falling within a bin is mapped to the color with the same index. If the number of bins, including any extensions, is less than *ncolors*, the color index is chosen by linear interpolation, mapping the ``[0, nbins - 1]`` range onto the ``[0, ncolors - 1]`` range. rQz+'clip=True' is not compatible with 'extend'rr\)rrrrYzDYou must provide at least 2 boundaries (1 region) but you passed in Nr )rboth)r>rSz There are z0 color bins including extensions, but ncolors = z1; ncolors must equal or exceed the number of bins) r8rrr`rp boundariesrJrNcmaprRr _n_regions_offset)rrTncolorsrrR)rrrrs&'      zBoundaryNorm.__init__Nc Cs|dkr|j}||\}}tj|}t||jd}|rdtj||j|j|d|j d}n|j }t ||j d|j }|j |j kr|j dkr|j dd||dk<n|j d|j d|}|tj}d|||jk<||||jk<tjj||d}|rt|d}|S)Nr )rrYrr\)rt)rrr`raZ getmaskarrayr&rrrrUZdigitizerTrWrVrZint16ryrI) rrrZxxrrtZmax_colZiretr/rrrrs*      zBoundaryNorm.__call__cCs tddS)z Raises ------ ValueError BoundaryNorm is not invertible, so calling this method will always raise an error zBoundaryNorm is not invertibleN)r8)rrrrrr szBoundaryNorm.inverse)F)N)rrrrrrrr rr)rrrPs A &rPc@s"eZdZdZdddZddZdS)NoNormz Dummy replacement for `Normalize`, for the case where we want to use indices directly in a `~matplotlib.cm.ScalarMappable`. NcCs|S)Nr)rrrrrrr0szNoNorm.__call__cCs|S)Nr)rrrrrr3szNoNorm.inverse)N)rrrrrrrrrrrY+s rYcCsvt|}|jddkr(td|j|j}tj|dt|jtjdd}t |}| d}|dk}| d}t |}||||||<|dk}|d|k|@}||d f||df||||df<|d |k|@}d ||df||df||||df<|d |k|@}d ||df||d f||||df<|ddd|d<||d <||d <| |S)a, Convert float rgb values (in the range [0, 1]), in a numpy array to hsv values. Parameters ---------- arr : (..., 3) array-like All values must be in the range [0, 1] Returns ------- (..., 3) ndarray Colors converted to hsv values in range [0, 1] r\rVzZptprf)arrin_shaperZarr_maxZiposdeltasidxrrr rgb_to_hsv7s4      (,,r`cCs$t|}|jddkr*tdj|jd|j}tj|dt|jtjdd}|d}|d }|d }t |}t |}t |}|d  t }|d |} |d |} |d || } |d |d | } |d dk} || || <| | || <| | || <|dk} | | || <|| || <| | || <|dk} | | || <|| || <| | || <|dk} | | || <| | || <|| || <|dk} | | || <| | || <|| || <|dk} || || <| | || <| | || <|dk} || || <|| || <|| || <tj |||gdd}| |S)z Convert hsv values to rgb. Parameters ---------- hsv : (..., 3) array-like All values assumed to be in range [0, 1] Returns ------- (..., 3) ndarray Colors converted to RGB values in range [0, 1] r\rVz?Last dimension of input array must be 3; shape {shp} was found.)ZshpFrY)rxrqrZ).r).r ).rYg@g?rr r]rW)rk)r`rpr?r8rryr rqr Z empty_likerrIstackrf)hsvr\hr^r&rrrirpqtr_rgbrrr hsv_to_rgbksd                             rjcCs>d}x.t|jdD]}||d|tjfd7}qWt|S)Nrr\.rY)ranger?r`newaxissqrt)r[Zsum_sqrerrr_vector_magnitudesrnc@sheZdZdZdddZedd Zdd d Zdd dZdddZ d ddZ d!ddZ ddZ ddZ dS)" LightSourcea Create a light source coming from the specified azimuth and elevation. Angles are in degrees, with the azimuth measured clockwise from north and elevation up from the zero plane of the surface. `shade` is used to produce "shaded" rgb values for a data array. `shade_rgb` can be used to combine an rgb image with an elevation map. `hillshade` produces an illumination map of a surface. ;-rr cCs(||_||_||_||_||_||_dS)a{ Specify the azimuth (measured clockwise from south) and altitude (measured up from the plane of the surface) of the light source in degrees. Parameters ---------- azdeg : float, default: 315 degrees (from the northwest) The azimuth (0-360, degrees clockwise from North) of the light source. altdeg : float, default: 45 degrees The altitude (0-90, degrees up from horizontal) of the light source. Notes ----- For backwards compatibility, the parameters *hsv_min_val*, *hsv_max_val*, *hsv_min_sat*, and *hsv_max_sat* may be supplied at initialization as well. However, these parameters will only be used if "blend_mode='hsv'" is passed into `shade` or `shade_rgb`. See the documentation for `blend_hsv` for more details. N)azdegaltdeg hsv_min_val hsv_max_val hsv_min_sat hsv_max_sat)rrrrsrtrurvrwrrrrs zLightSource.__init__cCsRtd|j}t|j}tt|t|t|t|t|gS)z3The unit vector direction towards the light source.Z)r`radiansrrrsrycossin)razZaltrrr directions  zLightSource.direction?c Csj| }t||||\}}t|jdt|}| |d<| |d<d|d<|t|}|||S)a  Calculate the illumination intensity for a surface using the defined azimuth and elevation for the light source. This computes the normal vectors for the surface, and then passes them on to `shade_normals` Parameters ---------- elevation : 2D array-like The height values used to generate an illumination map vert_exag : number, optional The amount to exaggerate the elevation values by when calculating illumination. This can be used either to correct for differences in units between the x-y coordinate system and the elevation coordinate system (e.g. decimal degrees vs. meters) or to exaggerate or de-emphasize topographic effects. dx : number, optional The x-spacing (columns) of the input *elevation* grid. dy : number, optional The y-spacing (rows) of the input *elevation* grid. fraction : number, optional Increases or decreases the contrast of the hillshade. Values greater than one will cause intermediate values to move closer to full illumination or shadow (and clipping any values that move beyond 0 or 1). Note that this is not visually or mathematically the same as vertical exaggeration. Returns ------- ndarray A 2D array of illumination values between 0-1, where 0 is completely in shadow and 1 is completely illuminated. )rV).r).r r ).rY)r`Zgradientrr?viewr rn shade_normals) r elevation vert_exagdxdyfractionZe_dyZe_dxnormalrrr hillshades'   zLightSource.hillshadecCsX||j}||}}||9}||dkrF||8}|||}t|dd}|S)a  Calculate the illumination intensity for the normal vectors of a surface using the defined azimuth and elevation for the light source. Imagine an artificial sun placed at infinity in some azimuth and elevation position illuminating our surface. The parts of the surface that slope toward the sun should brighten while those sides facing away should become darker. Parameters ---------- fraction : number, optional Increases or decreases the contrast of the hillshade. Values greater than one will cause intermediate values to move closer to full illumination or shadow (and clipping any values that move beyond 0 or 1). Note that this is not visually or mathematically the same as vertical exaggeration. Returns ------- ndarray A 2D array of illumination values between 0-1, where 0 is completely in shadow and 1 is completely illuminated. gư>rr )dotr}rr>r`r)rZnormalsr intensityZiminZimaxrrrr3s   zLightSource.shade_normalsNoverlayc  Ks|dkr|}|dkr |}|dkr4t||d}|||} |j| f||||| | d| } | dddf| dddf<| S)a Combine colormapped data values with an illumination intensity map (a.k.a. "hillshade") of the values. Parameters ---------- data : 2D array-like The height values used to generate a shaded map. cmap : `~matplotlib.colors.Colormap` The colormap used to color the *data* array. Note that this must be a `~matplotlib.colors.Colormap` instance. For example, rather than passing in ``cmap='gist_earth'``, use ``cmap=plt.get_cmap('gist_earth')`` instead. norm : `~matplotlib.colors.Normalize` instance, optional The normalization used to scale values before colormapping. If None, the input will be linearly scaled between its min and max. blend_mode : {'hsv', 'overlay', 'soft'} or callable, optional The type of blending used to combine the colormapped data values with the illumination intensity. Default is "overlay". Note that for most topographic surfaces, "overlay" or "soft" appear more visually realistic. If a user-defined function is supplied, it is expected to combine an MxNx3 RGB array of floats (ranging 0 to 1) with an MxNx1 hillshade array (also 0 to 1). (Call signature ``func(rgb, illum, **kwargs)``) Additional kwargs supplied to this function will be passed on to the *blend_mode* function. vmin : float or None, optional The minimum value used in colormapping *data*. If *None* the minimum value in *data* is used. If *norm* is specified, then this argument will be ignored. vmax : float or None, optional The maximum value used in colormapping *data*. If *None* the maximum value in *data* is used. If *norm* is specified, then this argument will be ignored. vert_exag : number, optional The amount to exaggerate the elevation values by when calculating illumination. This can be used either to correct for differences in units between the x-y coordinate system and the elevation coordinate system (e.g. decimal degrees vs. meters) or to exaggerate or de-emphasize topography. dx : number, optional The x-spacing (columns) of the input *elevation* grid. dy : number, optional The y-spacing (rows) of the input *elevation* grid. fraction : number, optional Increases or decreases the contrast of the hillshade. Values greater than one will cause intermediate values to move closer to full illumination or shadow (and clipping any values that move beyond 0 or 1). Note that this is not visually or mathematically the same as vertical exaggeration. Additional kwargs are passed on to the *blend_mode* function. Returns ------- ndarray An MxNx4 array of floats ranging between 0-1. N)rr)r blend_moderrrr.rV)rr>r shade_rgb)rrrnormrrrrrrrr;Zrgb0Zrgb1rrrshadeas<   zLightSource.shadercc Ks||||||} | dtjf} |j|j|jd} || krN| ||| f|} nHy||| f|} Wn4tk r} ztd| j | Wdd} ~ XYnXtj | r| j d} x,t dD] }|d|f| | d|f| <qW| S)a Use this light source to adjust the colors of the *rgb* input array to give the impression of a shaded relief map with the given *elevation*. Parameters ---------- rgb : array-like An (M, N, 3) RGB array, assumed to be in the range of 0 to 1. elevation : array-like An (M, N) array of the height values used to generate a shaded map. fraction : number Increases or decreases the contrast of the hillshade. Values greater than one will cause intermediate values to move closer to full illumination or shadow (and clipping any values that move beyond 0 or 1). Note that this is not visually or mathematically the same as vertical exaggeration. blend_mode : {'hsv', 'overlay', 'soft'} or callable, optional The type of blending used to combine the colormapped data values with the illumination intensity. For backwards compatibility, this defaults to "hsv". Note that for most topographic surfaces, "overlay" or "soft" appear more visually realistic. If a user-defined function is supplied, it is expected to combine an MxNx3 RGB array of floats (ranging 0 to 1) with an MxNx1 hillshade array (also 0 to 1). (Call signature ``func(rgb, illum, **kwargs)``) Additional kwargs supplied to this function will be passed on to the *blend_mode* function. vert_exag : number, optional The amount to exaggerate the elevation values by when calculating illumination. This can be used either to correct for differences in units between the x-y coordinate system and the elevation coordinate system (e.g. decimal degrees vs. meters) or to exaggerate or de-emphasize topography. dx : number, optional The x-spacing (columns) of the input *elevation* grid. dy : number, optional The y-spacing (rows) of the input *elevation* grid. Additional kwargs are passed on to the *blend_mode* function. Returns ------- ndarray An (m, n, 3) array of floats ranging between 0-1. .)rcZsoftrz*"blend_mode" must be callable or one of {}N).rrV)rr`rl blend_hsvblend_soft_light blend_overlayrLr8rkeysrarsrtrk)rrirrrrrrr;rlookupblendrrtrerrrrs"/    zLightSource.shade_rgbc Csh|dkr|j}|dkr|j}|dkr*|j}|dkr8|j}|d}d|d}t|ddddddf}t|dd\}} } t| t| dk|dk@d|| ||t| t| dk|dk@d|| ||t| |dkd|| ||t| |dkd|| ||tj |ddddddfdd|ddddddfd t |S) a Take the input data array, convert to HSV values in the given colormap, then adjust those color values to give the impression of a shaded relief map with a specified light source. RGBA values are returned, which can then be used to plot the shaded image with imshow. The color of the resulting image will be darkened by moving the (s, v) values (in hsv colorspace) toward (hsv_min_sat, hsv_min_val) in the shaded regions, or lightened by sliding (s, v) toward (hsv_max_sat, hsv_max_val) in regions that are illuminated. The default extremes are chose so that completely shaded points are nearly black (s = 1, v = 0) and completely illuminated points are nearly white (s = 0, v = 1). Parameters ---------- rgb : ndarray An MxNx3 RGB array of floats ranging from 0 to 1 (color image). intensity : ndarray An MxNx1 array of floats ranging from 0 to 1 (grayscale image). hsv_max_sat : number, default: 1 The maximum saturation value that the *intensity* map can shift the output image to. hsv_min_sat : number, optional The minimum saturation value that the *intensity* map can shift the output image to. Defaults to 0. hsv_max_val : number, optional The maximum value ("v" in "hsv") that the *intensity* map can shift the output image to. Defaults to 1. hsv_min_val : number, optional The minimum value ("v" in "hsv") that the *intensity* map can shift the output image to. Defaults to 0. Returns ------- ndarray An MxNx3 RGB array representing the combined images. N).rrYr rrVr\g|=)r) rwrurvrtr`r`ZmoveaxisZputmaskr+rrj) rrirrwrurtrvrchuesatrrrrrs,(   >zLightSource.blend_hsvcCs d||dd||dS)a Combine an rgb image with an intensity map using "soft light" blending, using the "pegtop" formula. Parameters ---------- rgb : ndarray An MxNx3 RGB array of floats ranging from 0 to 1 (color image). intensity : ndarray An MxNx1 array of floats ranging from 0 to 1 (grayscale image). Returns ------- ndarray An MxNx3 RGB array representing the combined images. rYr r)rrirrrrr= szLightSource.blend_soft_lightcCs6d||}ddd|d|}t|dk||S)a Combine an rgb image with an intensity map using "overlay" blending. Parameters ---------- rgb : ndarray An MxNx3 RGB array of floats ranging from 0 to 1 (color image). intensity : ndarray An MxNx1 array of floats ranging from 0 to 1 (grayscale image). Returns ------- ndarray An MxNx3 RGB array representing the combined images. rYr g?)r`where)rrirlowhighrrrrP s zLightSource.blend_overlay)rprqrr r r)r r r r~)r~)NrNNr r r r )r~rcr r r )NNNN)rrrrrrr}rrrrrrrrrrrros   5 . J H GrorQc Cstddtddtddtddd}tj||d||}t|d}||j|jpXd}t||krtd|dt|d |d t|t|||d }|d kr||dn |d |dkr| |dn | d ||_ t ||d}||fS)aw A helper routine to generate a cmap and a norm instance which behave similar to contourf's levels and colors arguments. Parameters ---------- levels : sequence of numbers The quantization levels used to construct the `BoundaryNorm`. Value ``v`` is quantized to level ``i`` if ``lev[i] <= v < lev[i+1]``. colors : sequence of colors The fill color to use for each level. If *extend* is "neither" there must be ``n_level - 1`` colors. For an *extend* of "min" or "max" add one extra color, and for an *extend* of "both" add two colors. extend : {'neither', 'min', 'max', 'both'}, optional The behaviour when a value falls out of range of the given levels. See `~.Axes.contourf` for details. Returns ------- cmap : `~matplotlib.colors.Normalize` norm : `~matplotlib.colors.Colormap` r r\Nr)rSrr>rQ)rRzWith extend == z and z levels, expected z colors, but got )r)rrSrQ)r>rS)rX) slicerZ check_in_listrJstartstopr8rrrrrP) ZlevelsrOrRZ slice_mapZ color_sliceZ n_data_colorsZ n_expectedrrrrrfrom_levels_and_colorse s*  &   r)N)N)N)F)r)N)NNF)rNNF)rQ)Mrrcollections.abcrrrxrr?rrnumbersrr3ZPILrZPIL.PngImagePluginrrFrnumpyr`rrr Z _color_datar r r rdictrr)rr:rr*r0r6r9r<rCr7rMr=r|rZcnamescompileZhexColorPatternZrgb2hexZ hex2colorrZcolorConverterrrrrrrrr'r>Z FuncScalerFrZLogScalerHZSymmetricalLogScalerLrMrPrYr`rjrnrorrrrr(s             + \ a    d*$_9[a` "3} 4R !