g) ~dZddlZddlmZmZmZddlZddlZddlZddl Z ddl Z ddl m Z ddl Z ddlmZddlmZddlZddlZddlmZmZmZmZmZdd lmZmZmZmZGd d e Z!iZ"e"jGee"jGejHDcic]\}}d |vr|jKd d |c}}e"jGee"jGee"jGejHDcic]\}}d |vr|jKd d |c}}e"jGee!e"Z"dZ&dZ'dZ(GddeZ)e)Z*dZ+e jXdZ-dZ.dZ/dZ0dZ1dZ2dWdZ3dWdZ4dWdZ5dZ6dXdZ7eZ8e jXdZ9e7Z:e6Z;Gd d!Z<e<Z=dYd"Z>Gd#d$Z?Gd%d&e?Z@Gd'd(e?ZAGd)d*ZBGd+d,ZCGd-d.eCZDGd/d0eCZEGd1d2ZFGd3d4eFZGGd5d6eFZHdWdd7d8ZIejd9ZKd:ZLd;ZMeIejdZd<7Gd=d>eFZOeIejejd?@eFZRdAxeR_SeR_TdBeR_eIejd[dCdDdE7GdFdGeFZVeIejd\dH7GdIdJeFZXGdKdLeFZYGdMdNeFZZGdOdPeFZ[dQZ\dRZ]dSZ^GdTdUZ_d]dVZ`ycc}}wcc}}w)^a 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:: :ref:`colormap-manipulation` for examples of how to make colormaps and :ref:`colormaps` for a list of built-in colormaps. :ref:`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 :ref:`colors_def`. .. _palettable: https://jiffyclub.github.io/palettable/ .. _xkcd color survey: https://xkcd.com/color/rgb/ N)SizedSequenceMapping)Real)Image)PngInfo)_api_cmcbookscale_image) BASE_COLORSTABLEAU_COLORS CSS4_COLORS XKCD_COLORSc2eZdZfdZfdZfdZxZS) _ColorMappingc2t||i|_yN)super__init__cache)selfmapping __class__s N/var/www/dash_apps/app1/venv/lib/python3.12/site-packages/matplotlib/colors.pyrz_ColorMapping.__init__>s ! cZt||||jjyr)r __setitem__rclear)rkeyvaluers rr z_ColorMapping.__setitem__Bs" C' rcXt|||jjyr)r __delitem__rr!)rr"rs rr%z_ColorMapping.__delitem__Fs  C  r)__name__ __module__ __qualname__rr r% __classcell__rs@rrr=srrgreygray)i@ctS)z3Return the global mapping of names to named colors.)_colors_full_maprrget_named_colors_mappingr2]s rc^eZdZdZej ej ejejejejejejejejejej ej"d ZdZdZdZdZdZdZd Zy ) ColorSequenceRegistrya Container for sequences of colors that are known to Matplotlib by name. The universal registry instance is `matplotlib.color_sequences`. There should be no need for users to instantiate `.ColorSequenceRegistry` themselves. Read access uses a dict-like interface mapping names to lists of colors:: import matplotlib as mpl colors = mpl.color_sequences['tab10'] The returned lists are copies, so that their modification does not change the global definition of the color sequence. Additional color sequences can be added via `.ColorSequenceRegistry.register`:: mpl.color_sequences.register('rgb', ['r', 'g', 'b']) ) tab10tab20tab20btab20cPastel1Pastel2PairedAccentDark2Set1Set2Set3 petroff10c*i|j|_yr)_BUILTIN_COLOR_SEQUENCES_color_sequencesrs rrzColorSequenceRegistry.__init__s A4#@#@ Arcj t|j|S#t$rt|dwxYw)Nz# is not a known color sequence name)listrDKeyErrorritems r __getitem__z!ColorSequenceRegistry.__getitem__sB K--d34 4 KdX%HIJ J Ks2c,t|jSr)iterrDrEs r__iter__zColorSequenceRegistry.__iter__sD))**rc,t|jSr)lenrDrEs r__len__zColorSequenceRegistry.__len__s4(())rc8ddjd|DzS)Nz,ColorSequenceRegistry; available colormaps: z, c3(K|] }d|d yw)'Nr1).0names r z0ColorSequenceRegistry.__str__..s7$AdV1+7s)joinrEs r__str__zColorSequenceRegistry.__str__s!? 7$778 9rc||jvrt|dt|}|D]} t|||j|<y#t$rt|dwxYw)a Register a new color sequence. The color sequence registry stores a copy of the given *color_list*, so that future changes to the original list do not affect the registered color sequence. Think of this as the registry taking a snapshot of *color_list* at registration. Parameters ---------- name : str The name for the color sequence. color_list : list of :mpltype:`color` An iterable returning valid Matplotlib colors when iterating over. Note however that the returned color sequence will always be a list regardless of the input type. z0 is a reserved name for a builtin color sequencez# is not a valid color specificationN)rC ValueErrorrGto_rgbarD)rrV color_listcolors rregisterzColorSequenceRegistry.registers( 400 0x(../ /*%  EE E E'1d#  E iBCEE Es A  A#ct||jvrtd||jj|dy)z Remove a sequence from the registry. You cannot remove built-in color sequences. If the name is not registered, returns with no error. z)Cannot unregister builtin color sequence N)rCr[rDpoprrVs r unregisterz ColorSequenceRegistry.unregistersA 400 0;D8DF F !!$-rN)r&r'r(__doc__r _tab10_data _tab20_data _tab20b_data _tab20c_data _Pastel1_data _Pastel2_data _Paired_data _Accent_data _Dark2_data _Set1_data _Set2_data _Set3_data_petroff10_datarCrrKrNrQrYr_rcr1rrr4r4bs,""""$$$$""""((  BK +*9 1D .rr4cf||S |j}|S#t$rt|}Y|SwxYwr)rJAttributeErrorfloat)exrets r_sanitize_extremarwsB z ggi J Bi Js 00z \AC[0-9]+\ZcPt|txrtj|S)zDReturn whether *c* can be interpreted as an item in the color cycle.) isinstancestr _nth_color_rematchcs r _is_nth_colorrs a  8-"5"5a"88rc^t|ry t|y#ttf$rYywxYw)z9Return whether *c* can be interpreted as an RGB(A) color.TF)rr\ TypeErrorr[r}s r is_color_likers9Q  z "s ,,cDt|t xrt|dk(S)z4Return whether *c* is a color with an alpha channel.)ryrzrPr}s r_has_alpha_channelrs!!S! ! 1c!fk1rc l|jD]!\}}t|rt|d|dy)zS For each *key, value* pair in *kwargs*, check that *value* is color-like. z is not a valid value for a*: supported inputs are (r, g, b) and (r, g, b, a) 0-1 float tuples; '#rrggbb', '#rrggbbaa', '#rgb', '#rgba' strings; named color strings; string reprs of 0-1 floats for grayscale values; 'C0', 'C1', ... strings for colors of the color cycle; and pairs combining one of the above with an alpha valueN)itemsrr[)kwargskvs r_check_color_likersN  M1Q%1!5KLM M Mrct|}t|}t|jdd}t|jdd}||k7r td|j|jk(xr||k(j S)z Return whether the colors *c1* and *c2* are the same. *c1*, *c2* can be single colors or lists/arrays of colors. rrz$Different number of elements passed.) to_rgba_arraymaxshaper[all)c1c2n1n2s r same_colorrsx r B r B RXXa[! B RXXa[! B Rx?@@ 88rxx  4R2XNN$44rct|trt|dk(r ||\}}n|d}t|rQtj d}|j jddg}|t|ddt|z} tj||f}|$t||} |tj||f<|S|S#ttf$rd}Y;wxYw#t$rY|SwxYw)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. Nrzaxes.prop_cycler^rr)rytuplerPrmplrcParamsby_keygetintr0rrHr_to_rgba_no_colorcycle)r~alpha prop_cyclercolorsrgbas rr\r\s0!UA! =HAu!AQll#45 ##%))'C59 3qu:F + ,%%ah/ |%a/ /3  " "1e8 , K4K i     K s$ C-CCC C*)C*c|"d|cxkrdkstdtd|}|tjjuryt |t r|j dk(ry t|}t |t rvtjd|}|r)td|dd |d d |d d fD||fzSd fzStjd |}|r2td|ddz|ddz|d dzfD||fzSd fzStjd|}|r>|dd |d d |d d |d dfDcgc]}t|ddz }}|||d<t|Stjd|}|rJ|ddz|ddz|d dz|ddzfDcgc]}t|ddz }}|||d<t|S t|}d|cxkrdksntd|d|||||fSd fSt |tjr2|j dk(r#|j"ddk(r|j%d}tj&|std|t|dvr tdt)d|Dstd|tt+t|}t|d k(r|d}| |dd |fz}t-d|Dr td|S#t$r:t|dk7r( t|j }n#t$rYnwxYwYwxYwcc}wcc}w#t$rYnwxYwtd|)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)``. Nrr*'alpha' must be between 0 and 1, inclusiverrrnone\A#[a-fA-F0-9]{6}\Zc3:K|]}t|ddz ywNrrUns rrWz)_to_rgba_no_colorcycle..e#=a*s*=?z\A#[a-fA-F0-9]{3}\Zc3:K|]}t|ddz ywrrrs rrWz)_to_rgba_no_colorcycle..krrrz\A#[a-fA-F0-9]{8}\Z rrz\A#[a-fA-F0-9]{4}\ZrzInvalid string grayscale value z . Value must be within 0-1 rangezInvalid RGBA argument: rrz'RGBA sequence should have length 3 or 4c3<K|]}t|tywr)ryr)rUxs rrWz)_to_rgba_no_colorcycle..s.qz!T".sc34K|]}|dkxs|dkDyw)rrNr1)rUelems rrWz)_to_rgba_no_colorcycle..s .D4!8 tax  .s&RGBA values should be within 0-1 range)r[npmamaskedryrzlowerr0rHrPrer|rrrtndarrayndimrreshapeiterablermapany)r~rorig_cr|rr^s rrrDs  eqEFF"1EFF FBEELL!S 779 #  #A!S/3 =$%aFAaFAaF#;== % 1u;< =79;< =/3 =$%aDFAaDFAaDF#;== % 1u;< =79;< =/3  1vq1vq1vq1v>@BZ#%@E@ !b < /3  tAvqtAvqtAvqtAv>@BZ#%@E@ !b <  ?aAKaK 5fZ@5677aU%6E> >B> >!RZZ 66Q;1771:? " A ;;q>26*=>> 1vVBCC .A. .26*=>> c%mA 1v{u}  bqEUH  .A ..ABB HI 6{a(3A  ,@@   26*=>>sT) K5:L;M M5L8 L%$L8% L1.L80L11L87L8 MMc  t|tr.t|dk(r t|dtr ||\}}n|d}t j |r#t j |j}t|tjr|jjdvr|jdk(r|jddvrtjj|r|jj!dnd}tjj#|}t j |rt|jddk(r8|jddkDr&t j$||jddf}n*|jd|jdk7r t'd|jdd k(rAt j(|t j*t|g}||nd |ddd f<n-|jdd k(r|j-}| ||ddd f<|d|<t j dk|dkDzr t'd |St/j0|drt j*dt2S t j |r2t j4|Dcgc]}t7||c}t2St j4t7||gt2Scc}w#t8$rYn&t&$r}|j:dk(r|Yd}~nd}~wwxYwt|t<rt'|dt|dk(rt j*dt2St|t>r|Dchc]%}t|t@tfr t|nd 'ncc}w}}|d hk(r4t j(|t jBt|g}n|d hk(rt j4|}net j4|Dcgc] }t7|ncc}wc}}n2t j4|Dcgc] }t7|ncc}wc}}|N||ddd f<t|t>r5|Dcgc]}t/jD|dncc}w} }d|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 `~numpy.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. rrNrifraxisz^The number of colors must match the number of alpha values if there are more than one of each.rrrrrr)rr)rz is not a valid color value.)#ryrrPrrrasarrayravelrdtypekindrrr is_maskedmaskrgetdatatiler[ column_stackzeroscopyr _str_lower_equalrtarrayr\rargsrzrrGones _str_equal) r~rrresultaecclensr none_masks rrrs:!UA! 1Q40F =HAu!A {{5 5!'')1bjj!agglld&:!  f 4%'UU__Q%7qvvzzqz!T EEMM!  ;;u wwqzQ5;;q>A#5GGA A23u{{1~- "-.. 771:?__a#a&)9%:;F%*%6EBF1b5M WWQZ1_VVXF %q"u  F4L 666A:&1*- .EF F  a(xx&&  ;;u 88E:qWQ]:EB B88WQ./7 7;    66E EG F!SA5 <=>> 1v{xx&&!XKLMR:b4-8Bb@MMM A3;??Arwws1v#78D aS[88A;D8815RWR[556Dxxq1112 QT a "ABB"))"f5BBIB$%DAJy ! KsN(L=L L$LL L4L4L//L4*N<,P?Q2R;ct|ddS)zAConvert *c* to an RGB color, silently dropping the alpha channel.Nr)r\r}s rto_rgbrs 1:bq>rc\t|}|s|dd}ddjd|DzS)a@ Convert *c* to a hex color. Parameters ---------- c : :ref:`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 Nr#c3LK|]}tt|dzdyw)r02xN)formatround)rUvals rrWzto_hex..&s FScCi 0%8Fs"$)r\rX)r~ keep_alphas rto_hexrs5  A  bqE FAFF FFrrc\eZdZdZeZej ZeeZee Z ee Z y)ColorConverterz A class only kept for backwards compatibility. Its functionality is entirely provided by module-level functions. N) r&r'r(rdr0rr staticmethodrr\rr1rrrr2s7 F  " "E & !F7#G /Mrrct|rRtjdd||z}tjtj||t dd}|S tj|}tjd||dddf}|dddf}|dddf} |dd k7s|d d k7r td tj|dkjr td |dk(rtj|d }n||dz z}|dz tjdd||zz}tj||dd } |dd || dz z || || dz z z } tj| dg| || | | dz z z| | dz z|d gg}tj|d d S#t $r}td|d}~wwxYw)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`. rrrz$data must be convertible to an arrayN)Nr)datarrrrz8data mapping points must start with x=0 and end with x=1z3data mapping points must have x in increasing order)callablerlinspacecliprrt Exceptionrr check_shaper[diffr searchsorted concatenate) Nrgammaxindlutadataerrry0y1inddistances r_create_lookup_tabler Esv~{{1a#u,ggbhhtDz7A> I YU+ ad A q!tB q!tBtrzQrUc\ FH H  QNOOAvhhr"v QKAQ1-66ooa&q,2J37+#370CDnn UG 3"S1W+- .C!G < VH   773S !!; I>?SHIsF== G GGceZdZdZddZddZddZdZdZdZ dd Z d Z dd Z d Z dd ZdddddZdddddZdZdZdZdZddZdZdZdZy)Colormapa 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. c||_t||_d|_d|_d|_|j|_|jdz|_|jdz|_d|_ d|_ d|_ y)z Parameters ---------- name : str The name of the colormap. N : int The number of RGB quantization levels. rNrrF) rVrr _rgba_bad _rgba_under _rgba_over_i_under_i_over_i_bad_isinit n_variatescolorbar_extend)rrVrs rrzColormap.__init__sm Q- vvz ffqj   %rNct|j|||\}}tj|s t|}|S)a Parameters ---------- X : float or int, `~numpy.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, default: False If False (default), the returned RGBA values will be floats in the interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s 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, )``. )rbytes)_get_rgba_and_maskrrr)rXrrrrs r__call__zColormap.__call__s8.,,Qe5,I d{{1~;D rc|js|jtj|d}|jj s7|j j|jj}|jjdk(r.||jz}|jdz |||jk(<|dk}||jk\}tjj|r |jntj|}tjd5|j!t"}ddd|j$||<|j&||<|j(||<|j*}|r"|d zj!tj,}|j/|dd } |}tj0|dd}|r|d z}|j2d |j2fvr%t5d |j2d|j2|| d<|ddk(j7rd| |<| |fS#1swYxYw)a= Parameters ---------- X : float or int, `~numpy.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, default: False If False (default), the returned RGBA values will be floats in the interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the interval ``[0, 255]``. Returns ------- colors : np.ndarray Array of RGBA values with a shape of ``X.shape + (4, )``. mask : np.ndarray Boolean array with True where the input is ``np.nan`` or masked. TrfrrignoreinvalidNrr)rmoder1"alpha is array-like but its shape z does not match that of X .rrrrrr)r_initrrrisnativebyteswapview newbyteorderrrrrrisnanerrstateastyperrrr_lutuint8takerrr[r) rrrrxa mask_under mask_overmask_badrrs rrzColormap._get_rgba_and_masks2|| JJL XXad #xx  ##BHH$9$9$; ? LL    NN5 !   MM$  rcN|j}|j||||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. rQ)rrV)rrRrSrTnew_cms r with_extremeszColormap.with_extremesqs) 5t< rc|jr$|j|j|j<n&|jd|j|j<|jr$|j|j|j<n3|j|j dz |j|j<|j |j|j<y)Nrr)rr-rrrrr rrEs rrFzColormap._set_extremes{s   '+'7'7DIIdmm $'+yy|DIIdmm $ ??&*ooDIIdll #&*ii &;DIIdll #!% $++rctdz)Generate the lookup table, ``self._lut``.zAbstract class onlyNotImplementedErrorrEs rr%zColormap._init!"788rc&|js|jtj|jdddf|jdddfk(xr:tj|jdddf|jdddfk(S)z)Return whether the colormap is grayscale.Nrrr)rr%rrr-rEs ris_grayzColormap.is_graysn|| JJLtyyA$))AqD/9:;tyyA$))AqD/9: >'* *!##rct)a Return a reversed instance of the Colormap. .. note:: This function is not implemented for the base class. Parameters ---------- name : str, optional The name for the reversed colormap. If None, the name is set to ``self.name + "_r"``. See Also -------- LinearSegmentedColormap.reversed ListedColormap.reversed r]rbs rreversedzColormap.reverseds ""##rc tjtjddtdtddf}||d}t j }|j dz}dtjd}t}|jd||jd ||jd ||jd |tj|j|d | |jS).Generate a PNG representation of the Colormap.rrTrz colormap Matplotlib v, https://matplotlib.orgTitle DescriptionAuthorSoftwarepngrpnginfo)rrr_REPR_PNG_SIZEioBytesIOrVr __version__radd_textr fromarraysavegetvalue)rrpixels png_bytestitleauthorrws r _repr_png_zColormap._repr_png_s GGBKK1nQ&78#A&* ,at$JJL  K'00HI)%(.6*V, $$Yug$N!!##rcn|j}tj|jd}d}d|jd|jd|jd|dt dd zd ||j d ||jd ||jd S)0Generate an HTML representation of the Colormap.asciic.t|d}d|d|dSNT)rz
rr^ hex_colors r color_blockz)Colormap._repr_html_..color_block-u6I"9+.) *3 9 > ?r-
,
z colormap
zD under
bad z&
over
) rbase64 b64encodedecoderVrxrJrDrNrr png_base64rs r _repr_html_zColormap._repr_html_sOO% %%i077@  ?99+& {#))%..8\:,Q/123-t~~/012#4<<>23#DMMO45' rc"|jSzReturn a copy of the colormap.r;rEs rrz Colormap.copy}}r)r.r=)rNr)r&r'r(rdrrrr;rArDrHrJrLrNrPrVrYrFr%rarirkrrrr1rrr r s %28DL 50 ! 2 ! 1 ! #'d  $(t$ 09< $$&$ "Hrr c`eZdZdZd fd ZdZdZed dZdZ edZ d dZ xZ 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. cPd|_t| ||||_||_y)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)rrV segmentdatarrrs rrz LinearSegmentedColormap.__init__s+Z  q!' rctj|jdzdft|_t |j|j d|j|jdddf<t |j|j d|j|jdddf<t |j|j d|j|jddd f<d |j vr5t |j|j d d|jdddf<d |_|jy) NrrredrgreenrbluerrT) rrrrtr-r rrrrFrEs rr%zLinearSegmentedColormap._init%sGGTVVaZOU3 0 FFD%%e,dkk; #2#q&0 FFD%%g. = #2#q&0 FFD%%f-t{{< #2#q& d'' ' 4))'2A!7DIIcrc1f   rc2||_|jy)z.Set a new gamma value and regenerate colormap.N)rr%)rrs r set_gammaz!LinearSegmentedColormap.set_gamma3s  rctj|s tdt|dtr0t |ddk(rt|dt s t|\}}n tjddt |}t|j\}}}}tj|||gtj|||gtj|||gtj|||gd} t|| ||S)a Create a `LinearSegmentedColormap` from a list of colors. Parameters ---------- name : str The name of the colormap. colors : list of :mpltype:`color` or list 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 iterablerrr)rrrr) rrr[ryrrPrzziprrTrr) rVrrrvalsrgbrcdicts r from_listz!LinearSegmentedColormap.from_list8s&{{6"67 7 vay% (S^q-@"6!9c2> c4#D>"))$..$?> +4M"..#!^^L>sAC3 5C,C3 ,C3 )r.rr) r&r'r(rdrr%rrrrirrkr)r*s@rrrsK0d  $>$>Lrrc8eZdZdZdfd ZdZdZddZxZS)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 Sequence of Matplotlib color specifications (color names or RGB(A) 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. cd|_|||_t|}nt|tr|g|z|_d|_nt j |rMt|dk(rd|_ttjtj|||_n t|}|g|z|_d|_t|9||y#t$rY#wxYw)NFTr)rrrPryrzrrrG itertoolsislicecyclertrrr)rrrVrr,rs rrzListedColormap.__init__s 9 DKF A&#&%hl "&V$v;!#&*DO"$$Y__V%t d||_ tjddg|||_t||_d|_y) a; Parameters ---------- colormaps: list or tuple of `~matplotlib.colors.Colormap` objects The individual colormaps that are combined combination_mode: str, 'sRGB_add' or 'sRGB_sub' Describe how colormaps are combined in sRGB space - If 'sRGB_add' -> Mixing produces brighter colors `sRGB = sum(colors)` - If 'sRGB_sub' -> Mixing produces darker colors `sRGB = 1 - sum(1 - colors)` name : str, optional The name of the colormap family. rz4A MultivarColormap must have more than one colormap.zdcolormaps must be a list of objects that subclass Colormap or a name found in the colormap registry.sRGB_addsRGB_sub)combination_moderN)rVrrrPryrzr[rG enumerater colormapsr  _colormapsr check_in_list_combination_moderr )rrrrVicmaps rrzMultivarColormap.__init__s  {{9%)n!C(ST TO  + XGAt$$"}}T2 ! h/ "WXX  X$ J 3FVW!1i.-rNc t|t|k7r#tdt|dt||dj|dd\}}t|dd|ddD]H\}}|j|d\} } |ddd fxx| ddd fz cc<|d xx| d zcc<|| z}J|jd k(r|ddd fxxt|dz zcc<|j ||<|rt j|dd}||rt j|dd}t j|d t j|dfvr:td t j|dt j|d|dxx|zcc<|r!|s td|dzjd}t j|ds t|}|S)a Parameters ---------- X : tuple (X0, X1, ...) of length equal to the number of colormaps X0, X1 ...: float or int, `~numpy.ndarray` or scalar The data value(s) to convert to RGBA. For floats, *Xi...* should be in the interval ``[0.0, 1.0]`` to return the RGBA values ``X*100`` percent along the Colormap line. For integers, *Xi...* should be in the interval ``[0, self[i].N)`` to return RGBA values *indexed* from colormap [i] with index ``Xi``, where self[i] is colormap i. alpha : float or array-like or None Alpha must be a scalar between 0 and 1, a sequence of such floats with shape matching *Xi*, or None. bytes : bool, default: False If False (default), the returned RGBA values will be floats in the interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the interval ``[0, 255]``. clip : bool, default: True If True, clip output to 0 to 1 Returns ------- Tuple of RGBA values if X[0] is scalar, otherwise an array of RGBA values with a shape of ``X.shape + (4, )``. z?For the selected colormap the data must have a first dimension z, not rFrnrN.r).rrr1r" does not match that of X[0] r#z_clip cannot be false while bytes is true as uint8 does not support values below 0 or above 255.rr.) rPr[rrrrDrrrr,rr) rrrrrrr3r~xxsub_rgba sub_mask_bads rrzMultivarColormap.__call__s: q6SY Qt9+VCF8-. .a33AaD3Fhab1QR5) %EAr%&%9%9"E%9%J "Hl bqbMXc2A2g. .M LHV, ,L  $H  %  J . bqbMSY] *MX 774A&D  q!,xxr288AaD>&:: 8%8IJ..0hhqtn-=?@@ MU "M  %&&3J&&w/D{{1Q4 ;D rc"|jS)z&Return a copy of the multivarcolormap.rrEs rrzMultivarColormap.copy[rrc6|j}|j|}|jj|j|jDcgc]}|j c}|_t j |j|_|Scc}wr)rr5r6r7rrrr )rr9r:cms rr;zMultivarColormap.__copy___sonn[[% ""4==159__ Er E !wwt~~6 !FsBct|tsyt|t|k7ryt||D] \}}||k7s yt |j |j k(sy|j |j k7ryyNFT)ryrrPrrr r)rr@c0rs rrAzMultivarColormap.__eq__gs{%!12 t9E "$& FBRx 4>>U__45  E$:$: :rc |j|SrrrIs rrKzMultivarColormap.__getitem__ust$$rc#6K|jD]}|ywrrrr~s rrNzMultivarColormap.__iter__xs AG sc,t|jSr)rPrrEs rrQzMultivarColormap.__len__|s4??##rc|jSrrrEs rrYzMultivarColormap.__str__s yyrc@tj|jSrC)rrr rEs rrDzMultivarColormap.get_badsxx''rctj|rt|t|k7rtdt||j }t |D])\}}| ||j ||j|<+|S)a Return a new colormap with *lutshape* entries. Parameters ---------- lutshape : tuple of (`int`, `None`) The tuple must have a length matching the number of variates. For each element in the tuple, if `int`, the corresponding colorbar is resampled, if `None`, the corresponding colorbar is not resampled. Returns ------- MultivarColormap zlutshape must be of length )rrrPr[rrrir)rlutshaperrss rrizMultivarColormap.resampleds {{8$H T(B:3t9+FG G99;h' >DAq})-a):):1)=##A& >rrQc|j}|t||_|itj|rt |t |k7rt dt |dt||D]\}}|j||itj|rt |t |k7rt dt |dt||D]\}}|j||S)a Return a copy of the `MultivarColormap` with modified out-of-range attributes. The *bad* keyword modifies the copied `MultivarColormap` while *under* and *over* modifies the attributes of the copied component colormaps. Note that *under* and *over* colors are subject to the mixing rules determined by the *combination_mode*. Parameters ---------- bad: :mpltype:`color`, default: None If Matplotlib color, the bad value is set accordingly in the copy under tuple of :mpltype:`color`, default: None If tuple, the `under` value of each component is set with the values from the tuple. over tuple of :mpltype:`color`, default: None If tuple, the `over` value of each component is set with the values from the tuple. Returns ------- MultivarColormap copy of self with attributes set zH*under* must contain a color for each scalar colormap i.e. be of length .zG*over* must contain a color for each scalar colormap i.e. be of length ) rr\r rrrPr[rrLrP)rrRrSrTrXr~rs rrYzMultivarColormap.with_extremess8 ?&s|F   ;;u%Us6{)B "77:6{m1"FGG .#DAqKKN#  ;;t$D S[(@ "77:6{m1"FGG -"DAqJJqM" rc|jSr)rrEs rrz!MultivarColormap.combination_modes%%%rctjtjddtdtddf}tjtdt |ztddftj }t|D]/\}}||d||tdz|dztdzddf<1tj}|jdz}d tjd }t}|jd ||jd ||jd ||jd|tj |j#|d||j%S)rmrrrrTrnNz multivariate colormaprorprqrrrsrtrurv)rrrrxrrPr.rryrzrVrr{rr|rr}r~r) rrrrr~rrrrws rrzMultivarColormap._repr_png_sQ GGBKK1nQ&78!/!2A 6 8>!,SY6q8I1M "*dO VDAqEFqPTEUF1^A&&!^A->'>>A B VJJL  4400HI)%(.6*V, $$Yug$N!!##rczdj|jDcgc]}|jc}Scc}w)z8Generate an HTML representation of the MultivarColormap.r)rXrrrs rrzMultivarColormap._repr_html_s)wwAA ABBAs8)zmultivariate colormapr)r&r'r(rdrrrr;rArKrNrQrYrDrirYpropertyrrrr1rrrrso".HDL %$(0$(t$-^&&$&CrrceZdZdZ ddZddZedZdZdZ dZ d Z dd Z dd Z d Zddddd dZdZedZedZdZdZdZdZdZy) BivarColormapz Base class for all bivariate to RGBA mappings. Designed as a drop-in replacement for Colormap when using a 2D lookup table. To be used with `~matplotlib.cm.ScalarMappable`. c ||_t||_t||_t j gd|||_d|_d|_d|_ d|_ t|dt|df|_ y ) a~ Parameters ---------- N : int, default: 256 The number of RGB quantization levels along the first axis. M : int, default: 256 The number of RGB quantization levels along the second axis. shape : {'square', 'circle', 'ignore', 'circleignore'} - 'square' each variate is clipped to [0,1] independently - 'circle' the variates are clipped radially to the center of the colormap, and a circular mask is applied when the colormap is displayed - 'ignore' the variates are not clipped, but instead assigned the 'outside' color - 'circleignore' a circular mask is applied, but the data is not clipped and instead assigned the 'outside' color origin : (float, float), default: (0,0) The relative origin of the colormap. Typically (0, 0), for colormaps that are linear on both axis, and (.5, .5) for circular colormaps. Used when getting 1D colormaps from 2D colormaps. name : str, optional The name of the colormap. squarecircler circleignorerr)rrrrFrrrN) rVrrMr r_shaper  _rgba_outsiderrrt_origin)rrrroriginrVs rrzBivarColormap.__init__sz8 QQ IQVW -1 fQi(%q *:;  (rNct|dk7rtdt||js|jtj j |dd}tj j |dd}|j||f|jjs7|jj|jj}|jjs7|jj|jj}|jjdk(r.||jz}|jdz |||jk(<|jjdk(r.||jz}|jdz |||jk(<|dk|dkz||jk\z||jk\z}tj j!|r |j"nt j$|}tj j!|r |j"nt j$|}||z} t j&d 5|j)t*}|j)t*}d d d ||fD] } d| |<d| | <|j,||f} t j.|drt j0| } |j2| |<|j4| | <|r"| d zj)tj6} |t j8|dd}|r|d z}t j:|d t j:|fvr7td t j:|dt j:||| d<t j |j4dk(j=rd| | <t j>|ds tA| } | S#1swYxYw)a Parameters ---------- X : tuple (X0, X1), X0 and X1: float or int `~numpy.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. - 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, default: None Alpha must be a scalar between 0 and 1, a sequence of such floats with shape matching X0, or None. bytes : bool, default: False If False (default), the returned RGBA values will be floats in the interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s 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, )``. rzBFor a `BivarColormap` the data must have a first dimension 2, not rTrrrrrNrr1r"rr#r$)!rPr[rr%rrr_cliprr&r'r(r)rrrrrr*r+r,rr-isscalarrrr r.rrrrr) rrrrX0X1 mask_outside mask_bad_0 mask_bad_1r3X_partrs rrzBivarColormap.__call__se4 q6Q;a&#$ $|| JJL UU[[1D[ ) UU[[1D[ ) B8xx  ##BHH$9$9$;>"DM(A-224!-X{{1Q4 ;D C  s +P33P=c|js|jtj|j}|j dk(s|j dk(rtj dd|j}tj dd|j}|dzddtjf|dztjddfz}|dkD}d||df<|S) a For external access to the lut, i.e. for displaying the cmap. For circular colormaps this returns a lut with a circular mask. Internal functions (such as to_rgb()) should use _lut which stores the lut without a circular mask A lut without the circular mask is needed in to_rgb() because the conversion from floats to ints results in some some pixel-requests just outside of the circular mask rrrrrNrr) rr%rrr-rrrrnewaxis)rrrm radii_sqrrs rrzBivarColormap.lut~s|| JJLggdii  :: !TZZ>%A B466*A B466*AAq"**}-Arzz1}0EEI$q=L#$C a  rc|j}|j|}|jj|jt j |j |_t j |j|_|j|_ |jr$t j |j|_ |Sr) rr5r6r7rrrr rrrr-r8s rr;zBivarColormap.__copy__snn[[% ""4==1#%774+=+=#>  !wwt~~6  JJ  << ggdii0JOrct|tsy|js|j|js|jt j |j |j syt j |j|jsyt j |j|jsy|j|jk7ryyr) ryrrr%rr>r-r rrr?s rrAzBivarColormap.__eq__s%/|| JJL}} KKM~~dii4~~dnneoo>~~d00%2E2EF :: $rc|jSrC)r rEs rrDzBivarColormap.get_bads ~~rc|jS)z&Get the color for out-of-range values.)rrEs r get_outsidezBivarColormap.get_outsides!!!rc xtj|rt|dk7r td|d|dg}|d|ddk(r|j|d<|d|ddk(r|j |d<ddg}|ddkr%d|d<|d |d<|ddk(r|j|d<|ddkr%d|d<|d |d<|ddk(r|j |d<tj dd|ddzdd|ddzf\}}|dr |ddd ddf}|dr |ddddd f}|j}d |_|r4|||f}t||j||jddd  }n-|||f}t||j||j }||_|j|_ |j|_ |S) a Return a new colormap with *lutshape* entries. Note that this function does not move the origin. Parameters ---------- lutshape : tuple of ints or None The tuple must be of length 2, and each entry is either an int or None. - If an int, the corresponding axis is resampled. - If negative the corresponding axis is resampled in reverse - If -1, the axis is inverted - If 1 or None, the corresponding axis is not resampled. transposed : bool, default: False if True, the axes are swapped after resampling Returns ------- BivarColormap rzlutshape must be of length 2rrNFTy?rr)rVrr) rrrPr[rrmgridrBivarColormapFromImagerVrr r) rr transposedinvertedx_0x_1 shape_memorynew_lutrs rrizBivarColormap.resampleds0{{8$H (:;< <QK!- A; (1+"2&&HQK A; (1+"2&&HQK5> A;?HQK#A;,HQK{a"ff A;?HQK#A;,HQK{a"ff 88Aa!r!12Aa!r9I4JJKS A;ddAg,C A;a2g,C {{  C:&G-gDII4@59[[25FHHC:&G-gDII4@59[[BH# !^^!%!3!3rc@|rdnd}|rdnd}|j||fS)z3 Reverses both or one of the axis. rrri)raxis_0axis_1r_0r_1s rrkzBivarColormap.reverseds)bb~~sCj))rc(|jddS)zK Transposes the colormap by swapping the order of the axis NNT)rrrEs rrzBivarColormap.transposed s~~lt~<*%Ls%R!\"&'d<&83&>*%Ls%R!\"%'!\"%'!\"(Drc|js|j|dk(rt|jd|jz}||jdz kDr|jdz }|j dd|f}t ||jd|j}n|dk(rt|jd|jz}||jdz kDr|jdz }|j |ddf}t ||jd|j}ntd||j|_ |jdvr6|j|j|j|j|S) z6Creates and returns a colorbar along the selected axisrrN_0r_1z2only 0 or 1 are valid keys for BivarColormap, not )rr)rr%rrrr-rrVrrHr rrPrrL)rrJorigin_1_as_int one_d_lutrorigin_0_as_ints rrKzBivarColormap.__getitem__sV|| JJL 19!$,,q/$&&"89O)"&&&( !_"45I%i 26F$&&QH QY!$,,q/$&&"89O)"&&&( /1"45I%i 26F$&&QHAAEJK K!^^ ::3 3   d00 1   t11 2rc\|js|j|j}|jdtkr5t j |t|jdzdddddf}|jdtkr5t j |t|jdzdddddf}|dddddddfdzjt j}tj}|jdz}d tjd }t}|jd ||jd ||jd ||jd|t!j"|j%|d||j'S)z3Generate a PNG representation of the BivarColormap.r)repeatsrNr.rrrz BivarColormaprorprqrrrsrtrurv)rr%rr_BIVAR_REPR_PNG_SIZErrepeatr,r.ryrzrVrr{rr|rr}r~r)rrrrrrws rrzBivarColormap._repr_png_sq|| JJL <<?1 1YYv';V\\!_'L$%''+tQw0F <<?1 1YYv';V\\!_'L$%''($3$w0F2q!$s*22288<JJL  ,,00HI)%(.6*V, $$Yug$N!!##rc:|j}tj|jd}d}d|jd|jd|jd|dt dzd ||j d ||jd S) rrc.t|d}d|d|dSrrrs rrz.BivarColormap._repr_html_..color_blockrrrrz BivarColormap" title="rrrrz- outside
bad r)rrrrrVr6rrDrs rrzBivarColormap._repr_html_sOO% %%i077@  ?99+& {#))%..8\:21456-t//1234#4<<>23! rc"|jSrrrEs rrzBivarColormap.copyrr)r.r.rrrzbivariate colormapr=F)TT)r&r'r(rdrrrrr;rArDrrirkrrYr%rrrrKrrrr1rrrrs=C**(X_B. $"DL*= $(T$1f96(p4$2 @rrc.eZdZdZ dfd ZdZxZS)SegmentedBivarColormapaL BivarColormap object generated by supersampling a regular grid. Parameters ---------- patch : np.array Patch is required to have a shape (k, l, 3), and will get supersampled to a lut of shape (N, N, 4). N : int The number of RGB quantization levels along each axis. shape : {'square', 'circle', 'ignore', 'circleignore'} - If 'square' each variate is clipped to [0,1] independently - If 'circle' the variates are clipped radially to the center of the colormap, and a circular mask is applied when the colormap is displayed - If 'ignore' the variates are not clipped, but instead assigned the 'outside' color - If 'circleignore' a circular mask is applied, but the data is not clipped origin : (float, float) The relative origin of the colormap. Typically (0, 0), for colormaps that are linear on both axis, and (.5, .5) for circular colormaps. Used when getting 1D colormaps from 2D colormaps. name : str, optional The name of the colormap. cjtjd|||_t||||||y)N)NNr)patchr)r rr@rr)rr@rrrrVrs rrzSegmentedBivarColormap.__init__s2 6  Auf48rcR|jj}tj|d|ddf}|j|ddddddf<d|dddddf<tj j jddj|j|ddz z |j|ddz z }tj|j|jdf|_ tj||j|tjddd|_y) NrrrrgF)resamplerT)r@rremptyr transformsAffine2D translater rr-r rBBILINEARr)rr_patch transforms rr%zSegmentedBivarColormap._inits JJ  1Q41q/*::q!RaRxq!QwNN++-77dC!&tvv1':DFFadQhr>s:=C49 rr>c*eZdZdZdfd ZdZxZS)ra BivarColormap object generated by supersampling a regular grid. Parameters ---------- lut : nparray of shape (N, M, 3) or (N, M, 4) The look-up-table shape: {'square', 'circle', 'ignore', 'circleignore'} - If 'square' each variate is clipped to [0,1] independently - If 'circle' the variates are clipped radially to the center of the colormap, and a circular mask is applied when the colormap is displayed - If 'ignore' the variates are not clipped, but instead assigned the 'outside' color - If 'circleignore' a circular mask is applied, but the data is not clipped origin: (float, float) The relative origin of the colormap. Typically (0, 0), for colormaps that are linear on both axis, and (.5, .5) for circular colormaps. Used when getting 1D colormaps from 2D colormaps. name : str, optional The name of the colormap. cLtj|d}|jdk7s|jddvr t dd|j tj k(r"|jtjdz }|jddk(rZtj|jd |jd d f|j }||ddddddf<d |dddddf<|}||_ t|1|jd |jd |||y)NTrrrrz8The lut must be an array of shape (n, m, 3) or (n, m, 4)z& or a PIL.image encoded as RGB or RGBArrrrrrr) rrrrr[rr.r,float32rCr-rr)rrrrrVrrs rrzBivarColormapFromImage.__init__,shhs& 88q=CIIaL6WEG G 99 **RZZ(,C 99Q<1 hh ! ciilA>ciiPG #GAq"1"H !GAq!G C  1syy|UFNrcd|_y)NT)rrEs rr%zBivarColormapFromImage._initBs  r)rr;z from imagerJr*s@rrrs4O,rrceZdZdZddZedZejdZedZejdZedZ e jd Z d Z e d Z dd Z d ZdZdZdZy) Normalizea A class which, when called, maps values within the interval ``[vmin, vmax]`` linearly to the interval ``[0.0, 1.0]``. The mapping of values outside ``[vmin, vmax]`` depends on *clip*. Examples -------- :: x = [-2, -1, 0, 1, 2] norm = mpl.colors.Normalize(vmin=-1, vmax=1, clip=False) norm(x) # [-0.5, 0., 0.5, 1., 1.5] norm = mpl.colors.Normalize(vmin=-1, vmax=1, clip=True) norm(x) # [0., 0., 0.5, 1., 1.] See Also -------- :ref:`colormapnorms` Nct||_t||_||_d|_t j dg|_y)ad Parameters ---------- vmin, vmax : float or None Values within the range ``[vmin, vmax]`` from the input data will be linearly mapped to ``[0, 1]``. If either *vmin* or *vmax* is not provided, they default to the minimum and maximum values of the input, respectively. clip : bool, default: False Determines the behavior for mapping values outside the range ``[vmin, vmax]``. If clipping is off, values outside the range ``[vmin, vmax]`` are also transformed, resulting in values outside ``[0, 1]``. This behavior is usually desirable, as colormaps can mark these *under* and *over* values with specific colors. If clipping is on, values below *vmin* are mapped to 0 and values above *vmax* are mapped to 1. Such values become indistinguishable from regular boundary values, which may cause misinterpretation of the data. Notes ----- If ``vmin == vmax``, input data will be mapped to 0. Nchanged)signals)rw_vmin_vmaxr_scaler CallbackRegistry callbacks)rvminvmaxrs rrzNormalize.__init__\s>8't, &t,   // Drc|jSrrTrEs rrYzNormalize.vmin~ zzrcht|}||jk7r||_|jyyr)rwrT_changedrr#s rrYzNormalize.vmin-!%( DJJ DJ MMO rc|jSrrUrEs rrZzNormalize.vmaxr]rcht|}||jk7r||_|jyyr)rwrUr_r`s rrZzNormalize.vmaxrarc|jSr)rrEs rrzNormalize.clipr]rcR||jk7r||_|jyyr)rr_r`s rrzNormalize.clips# DJJ DJ MMO rc:|jjdy)z~ Call this whenever the norm is changed to notify all the callback listeners to the 'changed' signal. rRN)rXprocessrEs rr_zNormalize._changeds y)rctj| }|r|g}tj|}tj|tjs|j tj ur$tj|tj}tjj|}tj|}tjj|||d}||fS)a Homogenize the input *value* for easy and efficient normalization. *value* can be a scalar or sequence. Parameters ---------- value Data to normalize. 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)rrr) rrmin_scalar_type issubdtypeintegerrgbool_ promote_typesrMrgetmaskrr)r# is_scalarrrrrs r process_valuezNormalize.process_values4 E** GE""5) == +uzzRXX/E$$UBJJ7Euu}}U#zz% TEEy  rc| |j}|j|\}}|j |j|j ||j|j\\}}|j|j\\}}||k(r|j dn||kDr t d|rdtjj|}tjjtj|j||||}|j} | |z} | ||z z} tjj| |jd}|r|d}|S)a Normalize the data and return the normalized data. Parameters ---------- value Data to normalize. clip : bool, optional See the description of the parameter *clip* in `.Normalize`. 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)``. r/minvalue must be less than or equal to maxvaluerFrr)rrqrYrZautoscale_Nonefillr[rrrorfilledrr) rr#rrrprY_rZrresdats rrzNormalize.__call__s7& <99D ..u5 99  1    ''' 2 '' 2  4< KKN D[NO Ouu}}V,RWWV]]4-@$%M*.%0[[F dNF td{ #FUU[[fkk[FF AYF rcL|js td|j|j\\}}|j|j\\}}t j |r*t jj|}||||z zzS||||z zzS)z Maps the normalized value (i.e., index in the colormap) back to image data value. Parameters ---------- value Normalized value. /Not invertible until both vmin and vmax are set) scaledr[rqrYrZrrrr)rr#rYryrZrs rinversezNormalize.inverses{{}NO O'' 2 '' 2  ;;u %%--&C#-- -%4$;// /rc|jj5dx|_|_|j |ddd|j y#1swYxYw)z&Set *vmin*, *vmax* to min, max of *A*.N)rXblockedrYrZrvr_rAs r autoscalezNormalize.autoscale sP ^^ # # % #%) (DI    "  #   # #s AActj|}t|tjjr0|j dus|j j s |j}|j!|jr|j|_|j#|jr|j|_ yyy)zDIf *vmin* or *vmax* are not set, use the min/max of *A* to set them.FN) r asanyarrayryr MaskedArrayrrrrYsizeminrZrrs rrvzNormalize.autoscale_None s MM!  a** +vvaffllFF 99 DI 99 DI"( rc>|jduxr|jduS)z.Return whether *vmin* and *vmax* are both set.NrYrZrEs rr}zNormalize.scaled( syy$>$)>>rNNFr)r&r'r(rdrrrYsetterrZrr_rrqrr~rrvr}r1rrrPrPFs* ED [[  [[  [[ *%!%!N-^0*  ?rrPcleZdZdfd ZedZej dZfdZddZdZ xZ S) TwoSlopeNormct|||||_||||k\r td||||kr tdyyy)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]) rNz2vmin, vcenter, and vmax must be in ascending order)rr_vcenterr[)rvcenterrYrZrs rrzTwoSlopeNorm.__init__. sq@ d.  4#34/0 0  4#34/0 09H#3 rc|jSrrrEs rrzTwoSlopeNorm.vcenterW }}rcR||jk7r||_|jyyr)rr_r`s rrzTwoSlopeNorm.vcenter[ s# DMM !!DM MMO "rc6t|||j|jk\r+|j|j|jz z |_|j|jkr,|j|j|jz z|_yy)z Get vmin and vmax. If vcenter isn't in the range [vmin, vmax], either vmin or vmax is expanded so that vcenter lies in the middle of the modified range [vmin, vmax]. N)rrvrYrrZ)rrrs rrvzTwoSlopeNorm.autoscale_Nonea sq q! 99 $  DLL(@ADI 99 $  tyy(@ADI %rc 0|j|\}}|j||j|jcxkr|jkst dt dt jjt j||j|j|jggdt j t jt jj|}|rt j|d}|S)zR Map value to the interval [0, 1]. The *clip* argument is unused. z/vmin, vcenter, vmax must increase monotonicallyrr*rleftrightrtr) rqrvrYrrZr[rr masked_arrayinterpinfro atleast_1d)rr#rrrps rrzTwoSlopeNorm.__call__o s!..u5  F#yyDLL5DII5NO O6NO O## IIftyy$,, B!rvv ?v&$( ]]6*1-F rct|js td|j|j\\}}|j|j\\}}|j|j \\}}t j|gd|||gt j t j}|S)Nr|rr) r}r[rqrYrZrrrr)rr#rYryrZrrs rr~zTwoSlopeNorm.inverse s{{}NO O'' 2 '' 2 **4<<8 A5+gt/D!#rvv7 rr#r) r&r'r(rrrrrvrr~r)r*s@rrr- sE'0R ^^ B$rrceZdZd fd ZdZdZedZejdZedZ e jdZ edZ e jd Z ed Z e jd Z xZ S) CenteredNormcFt|dd|||_||_y)a Normalize symmetrical data around a center (0 by default). Unlike `TwoSlopeNorm`, `CenteredNorm` applies an equal rate of change around the center. Useful when mapping symmetrical data around a conceptual center e.g., data that range from -2 to 4, with 0 as the midpoint, and with equal rates of change around that midpoint. Parameters ---------- vcenter : float, default: 0 The data value that defines ``0.5`` in the normalization. halfrange : float, optional The range of data values that defines a range of ``0.5`` in the normalization, so that *vcenter* - *halfrange* is ``0.0`` and *vcenter* + *halfrange* is ``1.0`` in the normalization. Defaults to the largest absolute difference to *vcenter* for the values in the dataset. clip : bool, default: False Determines the behavior for mapping values outside the range ``[vmin, vmax]``. If clipping is off, values outside the range ``[vmin, vmax]`` are also transformed, resulting in values outside ``[0, 1]``. This behavior is usually desirable, as colormaps can mark these *under* and *over* values with specific colors. If clipping is on, values below *vmin* are mapped to 0 and values above *vmax* are mapped to 1. Such values become indistinguishable from regular boundary values, which may cause misinterpretation of the data. Examples -------- This maps data values -2 to 0.25, 0 to 0.5, and 4 to 1.0 (assuming equal rates of change above and below 0.0): >>> import matplotlib.colors as mcolors >>> norm = mcolors.CenteredNorm(halfrange=4.0) >>> data = [-2., 0., 4.] >>> norm(data) array([0.25, 0.5 , 1. ]) NrYrZr)rrr halfrange)rrrrrs rrzCenteredNorm.__init__ s(\ dD9 "rctj|}t|j|j z |j|jz |_y)zY Set *halfrange* to ``max(abs(A-vcenter))``, then set *vmin* and *vmax*. N)rrrrrrrs rrzCenteredNorm.autoscale sA MM! T]]15572UUWT]]24rctj|}|j|jr|j |yyy)zSet *vmin* and *vmax*.N)rrrrrrs rrvzCenteredNorm.autoscale_None s4 MM!  >> !aff NN1 '- !rc|jSrr\rEs rrYzCenteredNorm.vmin r]rct|}||jk7r/||_d|jz|z |_|j yyNr)rwrTrrUr_r`s rrYzCenteredNorm.vmin A!%( DJJ DJ4<<%/DJ MMO rc|jSrrcrEs rrZzCenteredNorm.vmax r]rct|}||jk7r/||_d|jz|z |_|j yyr)rwrUrrTr_r`s rrZzCenteredNorm.vmax rrc|jSrrrEs rrzCenteredNorm.vcenter rrct||jk7r)||_|j|_|jyyr)rrr_)rrs rrzCenteredNorm.vcenter s. dmm ##DM!^^DN MMO $rcl|j |jy|j|jz dz SrrrEs rrzCenteredNorm.halfrange s0 99  1 DII%**rc|d|_d|_y|jt|z |_|jt|z|_yr)rYrZrabs)rrs rrzCenteredNorm.halfrange s>  DIDI s9~5DI s9~5DIr)rNF) r&r'r(rrrvrrYrrZrrr)r*s@rrr s1#f4  [[ [[ ^^++ 66rrinitc B|tjt||St|tjr<|j}t |j j}|j}ndx}}|dd}t||||tj|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. rr1cyrr1rs rrz"make_norm_from_scale..init, rr) rrmake_norm_from_scaleryrrkeywordsrr_make_norm_from_scaleinspect signature) scale_cls base_norm_clsr scale_argsscale_kwargs_itemss rrr s>  !5ytLL)Y../^^ "9#5#5#;#;#=>NN *,, ' |8 :1w((. 00rcGfdd}tur)jd|_jd|_n"j|_j|_j|_j|_|S)a  Helper for `make_norm_from_scale`. This function is split out to enable caching (in particular so that different unpickles reuse the same class). In order to do so, - ``functools.partial`` *scale_cls* is expanded into ``func, args, kwargs`` to allow memoizing returned norms (partial instances always compare unequal, but we can check identity based on ``func, args, kwargs``; - *init* is replaced by *init_signature*, as signatures are picklable, unlike to arbitrary lambdas. ceZdZfdZfdZWj ejdejjgWjje_ ddZ dZ fdZxZS) #_make_norm_from_scale..Normct|} |ttj|j|j urt |ft|fS tft|fS#ttf$rY(wxYwr) rggetattr importlib import_moduler'r(_create_empty_object_of_classvars ImportErrorrs_picklable_norm_constructor)rr9rbound_init_signaturerrrs r __reduce__z._make_norm_from_scale..Norm.__reduce__F st*C ')"9"9#.."I"%"2"2449C64:NN4 0 ,>"$8:J   0  sAA..B?Bc rj|i|}|jt| didDcic]}||jj | c}t jgit dddi|j|_ |jj|_ ycc}w)Nrrr1) bindapply_defaultsrr argumentsrarrdictrV get_transform_trf) rrrbarrrrrrs rrz,_make_norm_from_scale..Norm.__init__Y s*%**D;F;B     G  N3KLa1bll&&q))L ND)++D&D*./A*BD//!#/DK 113DI Ms#B4 r) parameterscH|j|\}}|j |j|j||j|jkDr t d|j|jk(rt j |dS| |j}|r+t j||j|j}|jj|jt j|}|jj|j|jg\}}t j||gjs t d||z}|||z z}t jj|d}|r|dS|S)N"vmin must be less or equal to vmaxrInvalid vmin or vmaxFr)rqrYrZrvr[r full_likerrrIrrisfiniterrmasked_invalid)rr#rrpt_valuet_vmint_vmaxs rrz,_make_norm_from_scale..Norm.__call__g sT#11%8 E9yy DII$5##E*yy499$ !EFFyyDII%||E1--|yytyy$))<ii))%088%IG!YY00$))TYY1GHNFF;;/0446 !788 v G  (Gee**7*?G!*71: 7 7rc2|js td|j|jkDr td|jj |j|jg\}}t j||gjs td|j|\}}|||z z}||z }|jjj |jt j|}|r|dS|S)NNot invertible until scaledrrr) r}r[rYrZrrIrrrrqrrr)rr#rrrprescaleds rr~z+_make_norm_from_scale..Norm.inverse| s;;= !>??yy499$ !EFF!YY00$))TYY1GHNFF;;/0446 !788#11%8 E90H  HYYhji)gbhhuo.  )58 3e 3rctjtj|jj ||}|j dk(rtj j}t|%|S)Nr) rextractrrrIrrrrrv)rr in_trf_domainrs rrvz2_make_norm_from_scale..Norm.autoscale_None sVJJr{{4993F3Fq3I'JANM!!Q& " 7)-8 8rr)r&r'r(rrreplacer ParameterPOSITIONAL_OR_KEYWORDrvalues __signature__rr~rvr))rrrrrrs@rNormrE s  & 4 4"6!=!= G  fg&7&7&M&M NJ7 ! , , 3 3 5J7!="8 8* 4" 9 9rr)rPr&r(r'rd)rrrrrrs````` rrr3 s$M9M9}M9^ !$--.d3 (556d;%.. )66#..DO ((DL Krc$|j|Sr)r5)r9s rrr s ;;s rc$tt|Sr)rr)rs rrr s ()>)E FFrcyrr1) functionsrYrZrs rr rrceZdZdZy)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 Determines the behavior for mapping values outside the range ``[vmin, vmax]``. If clipping is off, values outside the range ``[vmin, vmax]`` are also transformed by the function, resulting in values outside ``[0, 1]``. This behavior is usually desirable, as colormaps can mark these *under* and *over* values with specific colors. If clipping is on, values below *vmin* are mapped to 0 and values above *vmax* are mapped to 1. Such values become indistinguishable from regular boundary values, which may cause misinterpretation of the data. N)r&r'r(rdr1rrrr srrr) nonpositiveLogNormz8Normalize a given value to the 0-1 range on a log scale. )basec yrr1) linthreshlinscalerYrZrrs rrr s rcDeZdZdZedZej dZy) 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 c.|jjSrrVrrEs rrzSymLogNorm.linthresh s{{$$$rc&||j_yrrr`s rrzSymLogNorm.linthresh s % rN)r&r'r(rdrrrr1rrrr s5 0%%&&rrcyrr1) linear_widthrYrZrs rrr rrcDeZdZdZedZej dZy) AsinhNormai The inverse hyperbolic sine scale is approximately linear near the origin, but becomes logarithmic for larger positive or negative values. Unlike the `SymLogNorm`, the transition between these linear and logarithmic regions is smooth, which may reduce the risk of visual artifacts. .. note:: This API is provisional and may be revised in the future based on early user feedback. Parameters ---------- linear_width : float, default: 1 The effective width of the linear region, beyond which the transformation becomes asymptotically logarithmic c.|jjSrrVrrEs rrzAsinhNorm.linear_width s{{'''rc&||j_yrrr`s rrzAsinhNorm.linear_width s#(  rN)r&r'r(rdrrrr1rrrr s5&(())rrc2eZdZdZdfd ZddZdZxZS) PowerNorma2 Linearly map a given value to the 0-1 range and then apply a power-law normalization over that range. Parameters ---------- gamma : float Power law exponent. 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 Determines the behavior for mapping values outside the range ``[vmin, vmax]``. If clipping is off, values above *vmax* are transformed by the power function, resulting in values above 1, and values below *vmin* are linearly transformed resulting in values below 0. This behavior is usually desirable, as colormaps can mark these *under* and *over* values with specific colors. If clipping is on, values below *vmin* are mapped to 0 and values above *vmax* are mapped to 1. Such values become indistinguishable from regular boundary values, which may cause misinterpretation of the data. Notes ----- The normalization formula is .. math:: \left ( \frac{x - v_{min}}{v_{max} - v_{min}} \right )^{\gamma} For input values below *vmin*, gamma is set to one. c6t||||||_yr)rrr)rrrYrZrrs rrzPowerNorm.__init__= s tT* rc| |j}|j|\}}|j||j}|j|j }}||kDr t d||k(r|jdn|rdtjj|}tjjtj|j||||}|j} | |z} | ||z z} tj| | dkD|| | dkD<tjj| |jd}|r|d}|S)NrsrrtFru)rrqrvrrYrZr[rwrrrorrxrpowerr) rr#rrrprrYrZrrzs rrzPowerNorm.__call__A s( <99D ..u5  F# YY d $;NO O T\ KKNuu}}V,RWWV]]4-@$%M*.%0[[F dNF td{ #F!#&!*a"7TQY Q4??Q+>?$F{{288$!R$))^ 'R499_eekk$Tk* c!f+C rctd)z Raises ------ ValueError BoundaryNorm is not invertible, so calling this method will always raise an error zBoundaryNorm is not invertible)r[r`s rr~zBoundaryNorm.inverse s9::rr<rr r*s@rrrq s =/)=/~(T;rrceZdZdZddZdZy)NoNormz Dummy replacement for `Normalize`, for the case where we want to use indices directly in a `~matplotlib.cm.ScalarMappable`. Ncntj|rtjj|S|Srrrrr)rr#rs rrzNoNorm.__call__ & ;;u 55;;u% % rcntj|rtjj|S|Srr'r`s rr~zNoNorm.inverse r(rr)r&r'r(rdrr~r1rrr%r% s rr%ctj|}|jddk7rtd|jd|j}tj|dtj |j tjd}tj|}|jd}tj|dkDrtd |j|jd krtd |j|d kD}tj|d}tj|}||||z ||<|d kD}|d |k(|z}||df||dfz ||z ||d f<|d |k(|z}d||df||d fz ||z z||d f<|d|k(|z}d||d f||dfz ||z z||d f<|d dz dz|d <||d <||d<|j|S)a+ Convert an array of float RGB values (in the range [0, 1]) to HSV values. Parameters ---------- arr : (..., 3) array-like All values must be in the range [0, 1] Returns ------- (..., 3) `~numpy.ndarray` Colors converted to HSV values in range [0, 1] rr/Last dimension of input array must be 3; shape was found.FrrrndminrzBInput array must be in the range [0, 1]. Found a maximum value of rzBInput array must be in the range [0, 1]. Found a minimum value of .r.rg@.rg@@r)rrrr[rrnrrM zeros_likerrrptpr)arrin_shaperarr_maxiposdeltaridxs r rgb_to_hsvr; sA **S/C yy}""%))K9: :yyH (( %syy"**5 C -- CggbkG vvgk ((/  8   wwy1} ((+ { 4  Q;D FF3OE eADkGDM)AdG 19D v;' !T )CsAv;S!V,c :CQK v;' !T )CCF c#q&k1U3Z??CQK v;' !T )CCF c#q&k1U3Z??CQKv;$+CKCKCK ;;x  rc4tj|}|jddk7rtd|jd|j}tj|dtj |j tjd}|d}|d }|d }tj|}tj|}tj|}|d zjt}|d z|z } |d |z z} |d || zz z} |d |d | z zz z} |d zdk(} || || <| | || <| | || <|dk(} | | || <|| || <| | || <|dk(} | | || <|| || <| | || <|dk(} | | || <| | || <|| || <|dk(} | | || <| | || <|| || <|dk(} || || <| | || <| | || <|dk(} || || <|| || <|| || <tj|||gd}|j|S)z Convert HSV values to RGB. Parameters ---------- hsv : (..., 3) array-like All values assumed to be in range [0, 1] Returns ------- (..., 3) `~numpy.ndarray` Colors converted to RGB values in range [0, 1] rrr+r,Frr-r/r0r1r2rrrrrr) rrrr[rrnrrM empty_liker,rstackr)hsvr6hrrrrrrrpqtr:rgbs r hsv_to_rgbrFB s **S/C yy}""%))K9: :yyH (( %syy"**5 C F A F A F A aA aA aA SA SA A S1W A S1q5[A S1a= !A a%1*C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF q&C sVAcF sVAcF sVAcF ((Aq!92 &C ;;x  rcd}t|jdD]}||d|tjfdzz } tj|S)Nrr.r)rangerrr r+)r5sum_sqrs r_vector_magnituderJ sRF 399R= !/#c1bjj()Q../ 776?rcleZdZdZ d dZedZd dZddZ ddZ ddZ dd Z d Z d Z y) 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. cX||_||_||_||_||_||_y)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. hsv_min_val : number, default: 0 The minimum value ("v" in "hsv") that the *intensity* map can shift the output image to. hsv_max_val : number, default: 1 The maximum value ("v" in "hsv") that the *intensity* map can shift the output image to. hsv_min_sat : number, default: 1 The minimum saturation value that the *intensity* map can shift the output image to. hsv_max_sat : number, default: 0 The maximum saturation value that the *intensity* map can shift the output image to. 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)rrNrOrPrQrRrSs rrzLightSource.__init__ s3H  &&&&rc~tjd|jz }tj|j}tjtj |tj |ztj |tj |ztj |gS)z3The unit vector direction towards the light source.Z)rradiansrNrOrcossin)razalts r directionzLightSource.direction s} ZZTZZ (jj%xx FF2J $ FF2J $ FF3K   rc| }tj||z||\}}tj|jdzj t |}| |d<| |d<d|d<|t |z}|j||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 ------- `~numpy.ndarray` A 2D array of illumination values between 0-1, where 0 is completely in shadow and 1 is completely illuminated. )rr/r0rr1)rgradientrCrr(rgrJ shade_normals) r elevation vert_exagdxdyfractione_dye_dxnormals r hillshadezLightSource.hillshade sNS[[Y!6B? d)//D0166tIGvvv#F++!!&(33rc|j|j}|j|j}}||z}||z dkDr ||z}|||z z}t j |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 ------- `~numpy.ndarray` A 2D array of illumination values between 0-1, where 0 is completely in shadow and 1 is completely illuminated. gư>rr)dotr[rrrr)rnormalsrc intensityiminimaxs rr^zLightSource.shade_normals sw4KK/ ]]_immodX 4K4   I $+ &IGGIq!, rNc ||j}||j}| t||}|||} |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 (M, N, 3) RGB array of floats (ranging 0 to 1) with an (M, N, 1) 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. **kwargs Additional kwargs are passed on to the *blend_mode* function. Returns ------- `~numpy.ndarray` An (M, N, 4) array of floats ranging between 0-1. Nr)r_ blend_moder`rarbrc.r)rrrP shade_rgb)rrrnormrorYrZr`rarbrcrrgb0rgb1s rshadezLightSource.shadeD sz <88:D <88:D <$T2DDJt~~d;dz(1bR'/;39;S"1"W S"1"W  rc |j|||||} | dtjf} |j|j|j d} || vr| ||| fi|} n ||| fi|} tjj| r1| jd} tdD]}|d|f| | d|f| <| S#t $r} td| j| d} ~ wwxYw)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 (M, N, 3) RGB array of floats (ranging 0 to 1) with an (M, N, 1) 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. **kwargs Additional kwargs are passed on to the *blend_mode* function. Returns ------- `~numpy.ndarray` An (m, n, 3) array of floats ranging between 0-1. .)r@softoverlayz("blend_mode" must be callable or one of Nr/r) rgrr  blend_hsvblend_soft_light blend_overlayrr[keysrrrrH)rrEr_rcror`rarbrrklookupblendrrrs rrpzLightSource.shade_rgb s`NN9iRJ c2::o. ~~----  &F:&sI@@E <"3 >&)D1X 8&)#q&k$&7c1f d# 8  < !K$*KK="238;< > C%C  C%c | |j}| |j}| |j}| |j}|d}d|zdz }t |ddddddf}t j |dd\}} } t j| t j| dkD|dkDzd|z | z||zzt j| t j| dkD|dkzd|z| z||zz t j| |dkDd|z | z||zzt j| |dkd|z| z||zz t j|ddddddfdd|ddddddf 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 : `~numpy.ndarray` An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image). intensity : `~numpy.ndarray` An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image). hsv_max_sat : number, optional The maximum saturation value that the *intensity* map can shift the output image to. If not provided, use the value provided upon initialization. hsv_min_sat : number, optional The minimum saturation value that the *intensity* map can shift the output image to. If not provided, use the value provided upon initialization. hsv_max_val : number, optional The maximum value ("v" in "hsv") that the *intensity* map can shift the output image to. If not provided, use the value provided upon initialization. hsv_min_val : number, optional The minimum value ("v" in "hsv") that the *intensity* map can shift the output image to. If not provided, use the value provided upon initialization. Returns ------- `~numpy.ndarray` An (M, N, 3) RGB array representing the combined images. Nr/rrrrrg|=r) rSrQrRrPr;rmoveaxisputmaskrrrF) rrErkrSrQrPrRr@huesatrs rrxzLightSource.blend_hsv sT  **K  **K  **K  **Kf%  MA% Q1Q3Y( CQ/ S# 3v-)a-@ MS(9{+BB D 3v-)a-@ MS(9{+BB D 3 A  MS(9{+BB D 3 A  MS(9{+BB D Aq!"H q!Q12X7#rc0d|z|zdd|zz |dzzzS)a Combine an RGB image with an intensity map using "soft light" blending, using the "pegtop" formula. Parameters ---------- rgb : `~numpy.ndarray` An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image). intensity : `~numpy.ndarray` An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image). Returns ------- `~numpy.ndarray` An (M, N, 3) RGB array representing the combined images. rrr1)rrErks rryzLightSource.blend_soft_light$s*"9}s"a!i-&736%AAArchd|z|z}ddd|z zd|z zz }tj|dk||S)a Combine an RGB image with an intensity map using "overlay" blending. Parameters ---------- rgb : `~numpy.ndarray` An (M, N, 3) RGB array of floats ranging from 0 to 1 (color image). intensity : `~numpy.ndarray` An (M, N, 1) array of floats ranging from 0 to 1 (grayscale image). Returns ------- ndarray An (M, N, 3) RGB array representing the combined images. rrr*)rwhere)rrErklowhighs rrzzLightSource.blend_overlay7sE )mc!1I &!c'22xxs C..r)i;-rrrr)rrrrr)NrwNNrrrr)rr@rrr)NNNN)r&r'r(rdrrr[rgr^rtrprxryrzr1rrrLrL suIJ,-)'V    34j,\GK;<JXAF()HTGK04HTB&/rrLc Ztddtddtddtddd}tj||||}t|dz }||jz|j xsdz }t||k7r)t d|dt|d |d t|t||| }|d vr|j|dn|jd |dvr|j|dn|jd ||_ t||}||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.Colormap` norm : `~matplotlib.colors.Normalize` rrNr)rrrrrzWith extend == z and z levels, expected z colors, but got )rrrr)r) slicer rrPstartstopr[rrLrPrr) levelsrr slice_map color_slice n_data_colors n_expectedrrqs rfrom_levels_and_colorsrLs80a Q~Q|D> I  y0F#KK!OM!2!22k6F6F6K!LJ 6{j fZuS[M:"|#4S[M CD D &- ?D   vay! v   fRj! f!D  6D :rrr<rr)rNNF)rNNF)r)ardrcollections.abcrrrrrrryrnumbersrrPILrPIL.PngImagePluginr matplotlibrnumpyrr r r r r _color_datarrrrrrr0r7rrrxr6r2r4rDrwcompiler{rrrrrr\rrrrcnameshexColorPatternrgb2hex hex2colorrcolorConverterr r rrrrr>rrPrrrrrrr FuncScalerrLogScalerr&r(SymmetricalLogScaler AsinhScalerrrr%r;rFrJrLr)rrs00rrs'R44  &66NN D  $%6[%6%6%8)!Q"aK662A5)* $'%9^%9%9%;)!Q"aK662A5)* $ !12 f.Gf.R)* >* 9 2 M 5&,^[ |iX G2 "**34    0 0 ! _"D@@F `h`F\X\~zCzCzssl/]/d2]2jd?d?N\9\~s69s6l.0.0b iiXG OO ACyCD ; Ienn&9 ;;D F*337'L   && &D  FH) )H):U Up};9};@ Y  >!BO!dk/k/\ 6}o) )s !L3 !L9