hW SrSSKrSSKJrJrJr SSKrSSKrSSKrSSK r SSK r SSK J r SSK r SSKJr SSKJr SSKrSSKrSSKJrJrJrJrJr SS KJrJrJrJr "S S \ 5r!0r"\"RG\5 \"RG\RH"5VVs0sH upS U;dM URKS S 5U_M" snn5 \"RG\5 \"RG\5 \"RG\RH"5VVs0sH upS U;dM URKS S 5U_M" snn5 \"RG\5 \!"\"5r"Sr&Sr'Sr("SS\5r)\)"5r*Sr+\ RX"S5r-Sr.Sr/Sr0Sr1Sr2SWSjr3SWSjr4SWSjr5Sr6SXSjr7\r8\ RX"S5r9\7r:\6r;"S S!5r<\<"5r=SYS"jr>"S#S$5r?"S%S&\?5r@"S'S(\?5rA"S)S*5rB"S+S,5rC"S-S.\C5rD"S/S0\C5rE"S1S25rF"S3S4\F5rG"S5S6\F5rHSWSS7.S8jjrI\RS95rKS:rLS;rM\I"\RSZS<jS79"S=S>\F55rO\I"\R"\RS?S@95"\F5rRSA=\RlS\RlTSB\Rl\I"\RS[SCSD.SEjjS79"SFSG\F55rV\I"\RS\SHjS79"SISJ\F55rX"SKSL\F5rY"SMSN\F5rZ"SOSP\F5r[SQr\SRr]SSr^"STSU5r_S]SVjr`gs snnfs snnf)^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_COLORSc@^\rSrSrU4SjrU4SjrU4SjrSrU=r$) _ColorMapping=c2>[TU]U5 0UlgN)super__init__cache)selfmapping __class__s C/var/www/html/env/lib/python3.13/site-packages/matplotlib/colors.pyr_ColorMapping.__init__>s ! cX>[TU]X5 URR5 gr)r __setitem__rclear)rkeyvaluers rr"_ColorMapping.__setitem__Bs  C' r cX>[TU]U5 URR5 gr)r __delitem__rr#)rr$rs rr(_ColorMapping.__delitem__Fs  C  r )r) __name__ __module__ __qualname____firstlineno__rr"r(__static_attributes__ __classcell__rs@rrr=sr rgreygray)i@c[$)z3Return the global mapping of names to named colors.)_colors_full_mapr rget_named_colors_mappingr8]s r cf\rSrSrSr\R \R\R\R\R\R\R\R\R\R\R \R"\R$S. rSrSrSrSrSrS rS rS rg ) ColorSequenceRegistryba 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'] For a list of built in color sequences, see :doc:`/gallery/color/color_sequences`. 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*0UREUlgr)_BUILTIN_COLOR_SEQUENCES_color_sequencesrs rrColorSequenceRegistry.__init__s A4#@#@ Ar cn[URU5$![a [U<S35ef=f)Nz# is not a known color sequence name)listrKKeyErrorritems r __getitem__!ColorSequenceRegistry.__getitem__sB K--d34 4 KdX%HIJ J Ks4c,[UR5$r)iterrKrLs r__iter__ColorSequenceRegistry.__iter__sD))**r c,[UR5$r)lenrKrLs r__len__ColorSequenceRegistry.__len__s4(())r c8SSRSU55-$)Nz,ColorSequenceRegistry; available colormaps: z, c3.# UH nSUS3v M g7f)'Nr7).0names r 0ColorSequenceRegistry.__str__..s7$$AdV1+$s)joinrLs r__str__ColorSequenceRegistry.__str__s!? 7$778 9r cXR;a[U<S35e[U5nUHn[U5 M X RU'g![a [U<S35ef=f)a0 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)rJ ValueErrorrOto_rgbarK)rra color_listcolors rregisterColorSequenceRegistry.registers( 00 0x(../ /*% E E '1d#  E iBCEE Es AA(cxXR;a[SU<35eURRUS5 g)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)rJrhrKpoprras r unregister ColorSequenceRegistry.unregisters? 00 0;D8DF F !!$-r )rKN)r*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_datarJrrSrWr[rerlrqr.r7r rr:r:bs.""""$$$$""""((  BK +*9 1D .r r:cjUcU$UR5nU$![a [U5nU$f=fr)rRAttributeErrorfloat)exrets r_sanitize_extremarsB z ggi J Bi Js 22z \AC[0-9]+\ZcZ[U[5=(a [RU5$)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"88r cj[U5(ag[U5 g![[4a gf=f)z9Return whether *c* can be interpreted as an RGB(A) color.TF)rri TypeErrorrhrs r is_color_likers<Q  z "s 22cV[U[5(+=(a [U5S:H$)z4Return whether *c* is a color with an alpha channel.)rrrZrs r_has_alpha_channelrs!!S! ! 1c!fk1r c zUR5H'up[U5(aM[U<SUS35e g)zK 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)itemsrrh)kwargskvs r_check_color_likersH Q%1!5KLM Mr c[U5n[U5n[URSS5n[URSS5nX#:wa [S5eURUR:H=(a X:HR 5$)zs 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_arraymaxshaperhall)c1c2n1n2s r same_colorrst r B r B RXXa[! B RXXa[! B x?@@ 88rxx  4RXNN$44r c[U[5(a[U5S:Xa UcUupOUSn[U5(aQ[R SnUR 5RSS/5nU[USS5[U5-n[RX4nUc"[X5nU[RX4'U$U$![[4a SnN;f=f![a U$f=f)aN 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_cyclerkrr)rtuplerZrmplrcParamsby_keygetintr6rrPr_to_rgba_no_colorcycle)ralpha prop_cyclercolorsrgbas rriris0!UA! =HAu!AQll#45 ##%))'C59 3qu:F + ,%%ah/ |%a/ /3  " "18 , K4K i     K s$C7C'C$#C$' C54C5c`UbSUs=::aS::d O [S5eUnU[RRLag[ U[ 5(aUR 5S:Xag[Un[ U[ 5(Ga[R"SU5nU(a*[SUSS US S US S 455UbU4-$S 4-$[R"S U5nU(a3[SUSS-USS-US S-455UbU4-$S 4-$[R"SU5nU(aAUSS US S US S US S4Vs/sHn[US5S- PM nnUbXS'[U5$[R"SU5nU(aMUSS-USS-US S-USS-4Vs/sHn[US5S- PM nnUbXS'[U5$[U5nSUs=::aS::dO [SU<S35eXXbU4$S 4$[ U[R5(a4UR S:Xa$UR"SS:XaUR%S5n[R&"U5(d[SU<35e[U5S;a [S5e[)SU55(d[SU<35e[[+[U55n[U5S :XaUcSnUb USS U4-n[-SU55(a [S5eU$![a@ [U5S:wa-[UR 5nGN![a GN f=fGNf=fs snfs snf![a Of=f[SU<35e)ad 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@# UHn[US5S- v M g7fNrr`ns rrb)_to_rgba_no_colorcycle..f"=#;aa*s*#;?z\A#[a-fA-F0-9]{3}\Zc3@# UHn[US5S- v M g7frrrs rrbrlrrrz\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 4c3B# UHn[U[5v M g7fr)rr)r`xs rrbrs.Aqz!T""Ac3B# UHoS:=(d US:v M g7f)rrNr7)r`elems rrbrs .AD!8 tax Ar&RGBA values should be within 0-1 range)rhnpmamaskedrrlowerr6rPrZrerrrrndarrayndimrreshapeiterablermapany)rrorig_crrrks rrrEs  eqEFF FBEELL!S 779 #  #A!S/3 =$%aFAaFAaF#;== % 1u;< =79;< =/3 =$%aDFAaDFAaDF#;== % 1u;< =79;< =/3  1vq1vq1vq1v>@>BZ#%> @ !b < /3  tAvqtAvqtAvqtAv>@>BZ#%> @ !b <  ?aAKaK 5fZ@5677%6E> >B> >!RZZ  66Q;1771:? " A ;;q>>26*=>> 1vVBCC .A. . .26*=>> c%mA 1v{u}  bqEUH  .A ...ABB HI 6{a(3A  ,@@   26*=>>sN) L:N>N , N:NM.. M=8N<M==NN NNc  [U[5(a4[U5S:Xa%[US[5(a UcUupOUSn[R "U5(a$[R "U5R5n[U[R5(GaURRS;GaURS:XGaURSS;Ga[RRU5(aURR!SS9OSn[RR#U5n[R "U5(awURSS:Xa9URSS:a&[R$"XRSS45nO+URSURS:wa ['S5eURSS :XaD[R("U[R*"[U55/5nUbUOS USS2S 4'O.URSS :XaUR-5nUbXSS2S 4'UbSWU'[R "WS:US:-5(a ['S 5eU$[.R0"US5(a[R*"S[25$[R "U5(a5[R4"UVs/sHn[7X5PM sn[25$[R4"[7X5/[25$s snf![8a O([&anUR:S:XaUeSnAOSnAff=f[U[<5(a['U<S35e[U5S:Xa[R*"S[25$[U[>5(aUVs1sH+n[U[@[45(a [U5OS iM- Os snfnnUS 1:Xa6[R("U[RB"[U55/5nOUS 1:Xa[R4"U5nOm[R4"UVs/sHn[7U5PM Os snfsn5nO6[R4"UVs/sHn[7U5PM Os snfsn5nUbVXSS2S 4'[U[>5(a9UVs/sHn[.RD"US5PM Os snfn nSUSS2S 4U 'U$)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.)#rrrZrrrasarrayravelrdtypekindrrr is_maskedmaskrgetdatatilerh column_stackzeroscopyr _str_lower_equalrarrayrirargsrrrOones _str_equal) rrrresultaecclensr none_masks rrrs:!UA! 1Q40F0F =HAu!A {{5 5!'')1bjj!!agglld&:!  f 4%'UU__Q%7%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:EqWQ]E:EB B88WQ./7 7;    66E EG F!SA5 <=>> 1v{xx&&!XKLM1R:b4-88Bb@1MM A3;??Arwws1v#78D aS[88A;D88151RWR[156Dxxq1qq12 QT a " "ABB"))"f5BIB$%DAJy ! KsN/M >M M $M M M: M:M55M:$2P R#S !T,c[U5SS$)zAConvert *c* to an RGB color, silently dropping the alpha channel.Nr)rirs rto_rgbrs 1:bq>r cf[U5nU(dUSSnSSRSU55-$)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#c3R# UHn[[US-5S5v M g7f)r02xN)formatround)r`vals rrbto_hex..'s#FAScCi 0%88As%')rird)r keep_alphas rto_hexrs5  A  bqE FAFF FFr rcd\rSrSrSr\r\Rr\"\ 5r \"\ 5r \"\ 5r Sr g)ColorConverteri3zs A class only kept for backwards compatibility. Its functionality is entirely provided by module-level functions. r7N) r*r+r,r-rsr6rr staticmethodrrirr.r7r rrr3s7 F  " "E & !F7#G /Mr rc[U5(aR[R"SSU5U-n[R"[R"U"U5[ S9SS5nU$[R"U5n[R"SUS9 USS2S4nUSS2S4nUSS2S4n USS :wd US S :wa [S 5e[R"U5S:R5(a [S 5eUS:Xa[R"US 5nOXpS- -nUS- [R"SSU5U--n[R"Xs5SS n USS XzS- - XzXzS- - - n [R"U S/XU XS- - -XS- -US //5n[R"US S 5$![ an[S5UeSnAff=f)a 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)callablerlinspacecliprr Exceptionrr check_shaperhdiffr searchsorted concatenate) Nrgammaxindlutadataerrry0y1inddistances r_create_lookup_tablerFsv~~{{1a#u,ggbhhtDz7A> I YU+ ad A q!tB q!tBtrzQrUc\ FH H  QNOOAvhhr"v QKAQ1-66ooa&q,2J7+70CDnn UG 3"1W+- .!G < VH   773S !!; I>?SHIs$G G" GG"c\rSrSrSrSSjrSSjrSSjrSrSr S r SS jr S r SS jr S rSSjrSSSS.SjrSSSS.SjrSrSrSrSrSSjrSrSrSrSrg)Colormapia 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. cXl[U5UlSUlSUlSUlURUlURS-UlURS-UlSUl SUl SUl g)zs Parameters ---------- name : str The name of the colormap. N : int The number of RGB quantization levels. rNrrF) rarr _rgba_bad _rgba_under _rgba_over_i_under_i_over_i_bad_isinit n_variatescolorbar_extend)rrars rrColormap.__init__sk Q- vvz ffqj   %r NcvURXUS9upE[R"U5(d [U5nU$)aB Parameters ---------- X : float or int or array-like 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)rXrr*rrs r__call__Colormap.__call__s6.,,Q5,I {{1~~;D r cUR(dUR5 [R"USS9nURR (d7UR 5RURR55nURRS:Xa,X@R-nURS- XDUR:H'US:nX@R:n[RRU5(a URO[R"U5n[R"SS9 UR!["5nSSS5 UR$XE'UR&XF'UR(XG'UR*nU(a"US -R![R,5nUR/USS S 9n Ub[R0"USS5nU(aUS -nUR2S UR24;a%[5S UR2SUR235eX)S'USS:HR75(aSX'X4$!,(df  GN =f)a Parameters ---------- X : float or int or array-like 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 )rmoder7"alpha is array-like but its shape z does not match that of X .rrrrrr)r%_initrrrisnativebyteswapview newbyteorderrrrrrisnanerrstateastyperr"r#r$_lutuint8taker rrhr) rr,rr*xa mask_under mask_overmask_badrrs rr+Colormap._get_rgba_and_masks2|| JJL XXad #xx  ##BHH$9$9$; ? LL    NN5 !   MM$  r cFUR5nURXUS9 U$)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. rn)rrs)rrorprqnew_cms r with_extremesColormap.with_extremesrs' t< r cUR(a$URURUR'O&URSURUR'UR(a$URURUR'O3URUR S- URUR'UR URUR'g)Nrr)r rAr"r!r#rrr$rLs rr^Colormap._set_extremes|s   '+'7'7DIIdmm $'+yy|DIIdmm $ ??&*ooDIIdll #&*ii &;DIIdll #!% $++r c[S5ez)Generate the lookup table, ``self._lut``.zAbstract class onlyNotImplementedErrorrLs rr9Colormap._init!"788r c>UR(dUR5 [R"URSS2S4URSS2S4:H5=(a; [R"URSS2S4URSS2S4:H5$)z)Return whether the colormap is grayscale.Nrrr)r%r9rrrArLs ris_grayColormap.is_graysn|| JJLtyyA$))AqD/9:;tyyA$))AqD/9: >'* *!##r c[5e)aC 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}rps rreversedColormap.reverseds ""##r c[R"[R"SS[S5[SS45nU"USS9n[R "5nUR S-nS[RS3n[5nURSU5 URS U5 URS U5 URS U5 [R"U5RUS US 9 UR5$).Generate a PNG representation of the Colormap.rrTr*z colormap Matplotlib v, https://matplotlib.orgTitle DescriptionAuthorSoftwarepngrpnginfo)rrr _REPR_PNG_SIZEioBytesIOrar __version__radd_textr fromarraysavegetvalue)rr,pixels png_bytestitleauthorrs r _repr_png_Colormap._repr_png_s GGBKK1nQ&78#A&* ,at$JJL  K'00HI)%(.6*V, $$Yug$N!!##r cpUR5n[R"U5RS5nSnSURSURSURSUS[ SS -S U"UR 55S U"UR55S U"UR55S 3$)0Generate an HTML representation of the Colormap.asciic([USS9nSUSUS3$NT)rz
rrk hex_colors r color_block)Colormap._repr_html_..color_block-u6I"9+.) *3 9 > ?r -
,
z colormap
zD under
bad z&
over
) rbase64 b64encodedecoderarrcr[rirr png_base64rs r _repr_html_Colormap._repr_html_sOO% %%i077@  ?99+& {#))%..8\:,Q/123-t~~/012#4<<>23#DMMO45' r c"UR5$zReturn a copy of the colormap.rPrLs rr Colormap.copy}}r ) rr$r#r"r%rr!r r'r&ra)r4rS)rNr)r*r+r,r-rsrr-r+rPrWr[r`rcrfrirlrsrwr^r9rrrrrrr.r7r rrrs %28DL 50 ! 2 ! 1 ! #'d  $(t$ 09< $$&$ "Hr rcp^\rSrSrSrS U4SjjrSrSr\S Sj5r Sr \S5r S S jr S r U=r$) LinearSegmentedColormapiz 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. cJ>SUl[TU] X5 X lX@lg)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)rra segmentdatarrrs rr LinearSegmentedColormap.__init__s%Z  !' r c[R"URS-S4[5Ul[ URUR SUR5URSS2S4'[ URUR SUR5URSS2S4'[ URUR SUR5URSS2S 4'S UR ;a5[ URUR S S5URSS2S4'S UlUR5 g) NrrredrgreenrbluerrT) rrrrrArrrr%r^rLs rr9LinearSegmentedColormap._init&sGGTVVaZOU3 0 FFD%%e,dkk; #2#q&0 FFD%%g. = #2#q&0 FFD%%f-t{{< #2#q& d'' ' 4))'2A!7DIIcrc1f   r c0XlUR5 g)z.Set a new gamma value and regenerate colormap.N)rr9)rrs r set_gamma!LinearSegmentedColormap.set_gamma4s  r c0[R"U5(d [S5e[US[5(a5[ US5S:Xa#[US[ 5(d [U6upAO![R"SS[ U55n[U5RupVpx[R"XEU/5[R"XFU/5[R"XGU/5[R"XHU/5S.n [X X#5$)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) rrrhrrrZrzipr rTrr) rarrrvalsrgbrcdicts r from_list!LinearSegmentedColormap.from_list9s&{{6""67 7 vay% ( (S^q-@"6!9c22$=ic#D>>"))$..$? +4M"..#!^^L>sA C< <C5 C< 5C< )rr%rArr)r4rr)r*r+r,r-rsrr9rrrrrrr.r/r0s@rrrsP0d  $>$>Lr rcF^\rSrSrSrSU4SjjrSrSrS SjrSr U=r $) ListedColormapia 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. c>SUlUcXl[U5nO[U[5(aU/U-UlSUlO[ R "U5(aP[U5S:XaSUl[[R"[R"U5U55UlO[U5nU/U-UlSUl[TU]9X#5 g![a N#f=f)NFTr)rrrZrrrrrO itertoolsislicecyclerrrr)rrrarr2rs rrListedColormap.__init__s 9 KF A&#&&%hl "&V$$v;!#&*DO"$$Y__V% 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)rarrrZrrrhrO enumerater colormapsr _colormapsr check_in_list_combination_moder&r)rrrraicmaps rrMultivarColormap.__init__s  {{9%%)n!C((ST TO  +GA$$$"}}T2 h// "WXX ,$ J 3FVW!1i.-r Nc [U5[U5:wa#[S[U5S[U535eUSRUSSS9upV[USSUSS5HCupxURUSS9upUSSS 24==U SSS 24- ss'US ==U S -ss'Xj-nME URS :XaUSSS 24==[U5S- -ss'UR 5XV'U(a[ R"USS5nUbU(a[ R"USS5n[ R"U5S [ R"US54;a<[S [ R"U5S[ R"US535eUS==U-ss'U(a&U(d [S5eUS-RS5n[ R"US5(d [U5nU$)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 rFrrN.r).rrr7r6 does not match that of X[0] r7z_clip cannot be false while bytes is true as uint8 does not support values below 0 or above 255.rrB) rZrhr+rrr[rr rr@rr) rr,rr*r rrGrxxsub_rgba sub_mask_bads rr-MultivarColormap.__call__s: q6SY Qt9+VCF8-. .a33AaD3Fab1QR5)EA%&%9%9"E%9%J "H bqbMXc2A2g. .M LHV, ,L  $H *  J . bqbMSY] *M 774A&D  q!,xxr288AaD>&:: 8%8IJ..0hhqtn-=?@@ MU "M  %&&3J&&w/D{{1Q4  ;D r c"UR5$)z&Return a copy of the multivarcolormap.rrLs rrMultivarColormap.copy\rr c<URnURU5nURRUR5 URVs/sHo3R 5PM snUl[ R "UR5UlU$s snfr)rrJrKrLrrrr)rrNrOcms rrPMultivarColormap.__copy__`sqnn[[% ""4==159__ E_r_ E !wwt~~6 !FsBc[U[5(dg[U5[U5:wag[X5H up#X#:wdM g [ UR UR :H5(dgUR UR :waggNFT)rrrZrrrr)rrVc0rs rrWMultivarColormap.__eq__hsv%!122 t9E "$&FBx'4>>U__455  E$:$: :r c URU$rrrQs rrSMultivarColormap.__getitem__vst$$r c#:# URHnUv M g7frrrrs rrWMultivarColormap.__iter__ysAG!sc,[UR5$r)rZrrLs rr[MultivarColormap.__len__}s4??##r cUR$rrrLs rreMultivarColormap.__str__s yyr cB[R"UR5$rZ)rrrrLs rr[MultivarColormap.get_badsxx''r c,[R"U5(a[U5[U5:wa[S[U535eUR 5n[ U5H*up4UcM XR U5URU'M, U$)aa 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 )rrrZrhrrrr)rlutshaperr ss rrMultivarColormap.resampleds~ {{8$$H T(B:3t9+FG G99;h'DA})-):):1)=##A&(r rncUR5nUb[U5UlUbp[R"U5(a[ U5[ U5:wa[ S[ U5S35e[XB5HupVURU5 M Ubp[R"U5(a[ U5[ U5:wa[ S[ U5S35e[XC5HupVURU5 M U$)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 ) rrirrrrZrhrrfrl)rrorprqrvrrs rrwMultivarColormap.with_extremess8 ?&s|F   ;;u%%Us6{)B "77:6{m1"FGG .DAKKN/  ;;t$$D S[(@ "77:6{m1"FGG -DAJJqM. r cUR$r)r rLs rr!MultivarColormap.combination_modes%%%r c[R"[R"SS[S5[SS45n[R"[S[ U5-[SS4[R S9n[U5H+up4U"USS9X#[S-US-[S-2SS24'M- [R"5nURS-nS [RS 3n[5nURS U5 URS U5 URS U5 URSU5 [R "U5R#USUS9 UR%5$)rrrrrTrNz multivariate colormaprrrrrrrr)rrr rrrZrBrrrrarrrrrrrr) rr,rr rrrrrs rrMultivarColormap._repr_png_sF GGBKK1nQ&78!/!2A 6 8>!,SY6q8I1M "*dODAEFqPTEUF^A&&!^A->'>>A B$JJL  4400HI)%(.6*V, $$Yug$N!!##r c~SRURVs/sHoR5PM sn5$s snf)z8Generate an HTML representation of the MultivarColormap.r)rdrrr s rrMultivarColormap._repr_html_s+wwAA ABBAs:)rr rr&ra)zmultivariate colormapr)r*r+r,r-rsrr-rrPrWrSrWr[rer[rrwpropertyrrrr.r7r rrrso".HDL %$(0$(t$-^&&$&Cr rc\rSrSrSrSSjrSSjr\S5rSr Sr S r S r SS jr SS jrS rSSSSS.SjrSr\S5r\S5rSrSrSrSrSrSrg) BivarColormapiz 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`. cXPl[U5Ul[U5Ul[R "/SQUS9 X0lSUlSUlSUl SUl [US5[US54Ul g ) 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. squarecircler2 circleignorerr)rrrrFrrrN) rarrMr r_shaper _rgba_outsider%r&r_origin)rrr>roriginras rrBivarColormap.__init__sv8 QQ IQVW -1 fQi(%q *:;  (r Nc[U5S:wa[S[U535eUR(dUR5 [R R USSS9n[R R USSS9nURXE45 URR(d7UR5RURR55nURR(d7UR5RURR55nURRS:Xa,X@R-nURS- XDUR:H'URRS:Xa,XPR-nURS- XUUR:H'US:US:-X@R:-XPR:-n[R R!U5(a UR"O[R$"U5n[R R!U5(a UR"O[R$"U5nXx-n [R&"SS 9 UR)[*5nUR)[*5nS S S 5 XE4H n SX'SX'M UR,XE4n [R."US5(a[R0"U 5n UR2X'UR4X'U(a"U S -R)[R65n Ub[R8"USS5nU(aUS -n[R:"U5S [R:"U54;a9[S [R:"U5S[R:"U535eX+S'[R "UR45S:HR=5(aSX'[R>"US5(d [AU 5n U $!,(df  GN=f)ar Parameters ---------- X : tuple (X0, X1), X0 and X1: float or int or array-like 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 rTr0rr1r2r3Nrr7r6rr7r8)!rZrhr%r9rrr_cliprr:r;r<r=rrr>rrr>r?r@rrAisscalarrr@rrBr rrrr) rr,rr*X0X1 mask_outside mask_bad_0 mask_bad_1rGX_partrs rr-BivarColormap.__call__sH4 q6Q;a&#$ $|| JJL UU[[1D[ ) UU[[1D[ ) B8xx  ##BHH$9$9$;>"M(A-2244!-{{1Q4  ;D C+ *s +Q  Q/cUR(dUR5 [R"UR5nUR S:XdUR S:Xa[R "SSUR5n[R "SSUR5nUS-SS2[R4US-[RSS24-nUS:nSXS4'U$) 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 r;r<rrrNrr) r%r9rrrArr rr>newaxis)rrrm radii_sqrrIs rrBivarColormap.luts|| JJLggdii  :: !TZZ>%A B466*A B466*AAq"**}-Arzz1}0EEI$q=L#$Ca  r cURnURU5nURRUR5 [R "UR 5Ul[R "UR5UlURUl UR(a%[R "UR5Ul U$r) rrJrKrLrrr@rrr?r%rArMs rrPBivarColormap.__copy__snn[[% ""4==1#%774+=+=#>  !wwt~~6  JJ  << ggdii0JOr c[U[5(dgUR(dUR5 UR(dUR5 [R "UR UR 5(dg[R "URUR5(dg[R "URUR5(dgURUR:waggr) rr7r%r9rrTrArr@rrUs rrWBivarColormap.__eq__s%//|| JJL}} KKM~~dii44~~dnneoo>>~~d00%2E2EFF :: $r cUR$rZ)rrLs rr[BivarColormap.get_bads ~~r cUR$)z&Get the color for out-of-range values.)r@rLs r get_outsideBivarColormap.get_outsides!!!r c [R"U5(a[U5S:wa [S5eUSUS/nUSb USS:XaURUS'USb USS:XaUR US'SS/nUSS:a&SUS'US*US'USS:XaURUS'USS:a&SUS'US*US'USS:XaUR US'[R SSUSS-2SSUSS-24upEUS(a USSS 2SS24nUS(a USS2SSS 24nURnS UlU(a/U"XT45n[XpRUURSSS 2S 9nO(U"XE45n[XpRUURS 9nX`lURUl URUl U$) a3 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:)rarrB) rrrZrhrr>mgridr?BivarColormapFromImagerarBrr@) rr) transposedinvertedx_0x_1 shape_memorynew_lutrs rrBivarColormap.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!r9I4JJK A;ddAg,C A;a2g,C {{  C:&G-gII4@59[[25FHHC:&G-gII4@59[[BH# !^^!%!3!3r cRU(aSOSnU(aSOSnURX445$)z# Reverses both or one of the axis. rrr)raxis_0axis_1r_0r_1s rrBivarColormap.reverseds'bb~~sj))r c"URSSS9$)z; Transposes the colormap by swapping the order of the axis NNT)r_rgrLs rr_BivarColormap.transposed s~~lt~<rrr~rsqrt)rr,rLmxrQrI overextends rrEBivarColormap._clipPs0 :: !!!ffdff%56 %&z"<<$$+)*FA:&+-6FR<( 7ZZ8 #!!ffdff%56 %'z"<<$$+)+FA:&+-FR<( 7ZZ8 #tzz^'C<<$$+-@AA 1a1Q4#:/9I$t+LzzX%)@!AA &'d<&83&>*%Ls%R!\"&'d<&83&>*%Ls%R!\"%'!\"%'!\"(Dr cUR(dUR5 US:Xa{[URSUR-5nX RS- :aURS- nUR SS2U4n[ X0RS3URS9nOUS:Xa{[URSUR-5nXPRS- :aURS- nUR USS24n[ X0RS3URS9nO[SU<35eURUl URS;a6URUR5 URUR5 U$) z6Creates and returns a colorbar along the selected axisrrN_0r_1z2only 0 or 1 are valid keys for BivarColormap, not )r2r<)r%r9rrAr>rArrarrPrrrlr@rf)rrRorigin_1_as_int one_d_lutrorigin_0_as_ints rrSBivarColormap.__getitem__sN|| JJL 19!$,,q/$&&"89O)"&&&( !_"45I%i 26F$&&QH QY!$,,q/$&&"89O)"&&&( /1"45I%i 26F$&&QHAAEJK K!^^ ::3 3   d00 1   t11 2r c`UR(dUR5 URnURS[:a3[ R "U[URS-SS9SS2SS24nURS[:a3[ R "U[URS-SS9SS2SS24nUSSS2SS2SS24S-R[ R5n[R"5nURS-nS [RS 3n[5nURS U5 URS U5 URS U5 URSU5 [ R""U5R%USUS9 UR'5$)z3Generate a PNG representation of the BivarColormap.r)repeatsrNr4rrrz BivarColormaprrrrrrrr)r%r9rr_BIVAR_REPR_PNG_SIZErrepeatr@rBrrrarrrrrrrr)rrrrrrs rrBivarColormap._repr_png_sq|| JJL <<?1 1YYv';V\\!_'L$%''+tQw0F <<?1 1YYv';V\\!_'L$%''($3$w0F2q!$s*22288<JJL  ,,00HI)%(.6*V, $$Yug$N!!##r c<UR5n[R"U5RS5nSnSURSURSURSUS[ S-S U"UR 55S U"UR55S 3$) rrc([USS9nSUSUS3$rrrs rr.BivarColormap._repr_html_..color_blockrr rrz BivarColormap" title="rrrrz- outside
bad r)rrrrrarrZr[rs rrBivarColormap._repr_html_sOO% %%i077@  ?99+& {#))%..8\:21456-t//1234#4<<>23! r c"UR5$rrrLs rrBivarColormap.copyrr ) r>rr%rArr@r?r&ra)r4r4r:rrzbivariate colormaprSF)TT)r*r+r,r-rsrr-r5rrPrWr[rZrrr_rwr9rrBrErSrrrr.r7r rr7r7s=C**(X_B. $"DL*= $(T$1f96(p4$2 @r r7c:^\rSrSrSrSU4SjjrSrSrU=r$)SegmentedBivarColormapia 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. cZ>[R"SUS9 Xl[TU]X"X4US9 g)N)NNr)patchr)r r rrr)rrrrrBrars rrSegmentedBivarColormap.__init__s, 6  u48r c PURRn[R"USUSS45nURUSS2SS2SS24'SUSS2SS2S4'[R R 5RSS5RURUSS- - URUSS- - 5n[R"URURS45Ul [R"X RU[RSSS9 SUlg) NrrrrgF)resamplerT)rrremptyr transformsAffine2D translater rrAr rBILINEARr%)rr*_patch transforms rr9SegmentedBivarColormap._inits JJ  1Q41q/*::q!RaRxq!QwNN++-77dC!&tvv1':DFFadQh[R"USS9nURS:wdURSS;a [ SS5eUR [R :Xa"UR[R5S- nURSS:XaW[R"URS URS S 4UR S 9nXSS2SS2SS24'S USS2SS2S4'UnXl [TU]1URS URS X#US9 g)NTr0rrrz8The lut must be an array of shape (n, m, 3) or (n, m, 4)z& or a PIL.image encoded as RGB or RGBArrrrrrr) rrrrrhrrBr@float32rrArr)rrrrBrardrs rrBivarColormapFromImage.__init__-shhs& 88q=CIIaL6WEG G 99 **RZZ(,C 99Q<1 hh ! ciilA>ciiPG #Aq"1"H !GAq!G C  1syy|UNr cSUlg)NT)r%rLs rr9BivarColormapFromImage._initCs  r )r%rA)r:rz from imagerr0s@rr^r^s4O,r r^c\rSrSrSrSSjr\S5r\RS5r\S5r \ RS5r \S 5r \ RS 5r S r \ S 5r SS jrSrSrSrSrSrg) NormalizeiGa 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` Nc[U5Ul[U5UlX0lSUl[ R "S/S9Ulg)a 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)r_vmin_vmaxrE_scaler CallbackRegistry callbacks)rvminvmaxr s rrNormalize.__init__]s<8't, &t,   // Dr cUR$rrrLs rrNormalize.vmin zzr cf[U5nXR:waXlUR5 ggr)rr_changedrr%s rrr)!%( JJ J MMO r cUR$rrrLs rrNormalize.vmaxrr cf[U5nXR:waXlUR5 ggr)rrrrs rrrrr cUR$r)rErLs rr Normalize.cliprr cPXR:waXlUR5 ggr)rErrs rr rs JJ J MMO r c:URRS5 g)zf Call this whenever the norm is changed to notify all the callback listeners to the 'changed' signal. rN)rprocessrLs rrNormalize._changeds y)r c[R"U5(+nU(aU/n[R"U5n[R"U[R5(dUR [R La%[R"U[R5n[RRU5n[R"U5n[RRXCUSS9nXQ4$)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 issubdtypeintegerrbool_ promote_typesrrgetmaskrr)r% is_scalarrrrrs r process_valueNormalize.process_values4 E** GE""5) == + +uzzRXX/E$$UBJJ7Euu}}U#zz% TEE  r cUc URnURU5up4URb URcUR U5 URUR5uupVURUR5uupvXW:XaUR S5 OXW:a [ S5eU(aa[RRU5n[RR[R"URU5XW5US9nURn X-n XU- -n [RRXRSS9nU(aUSnU$)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)r rrrautoscale_Nonefillrhrrrrfilledrr) rr%r rrr_rrresdats rr-Normalize.__call__s%& <99D ..u5 99  1    ''' 2 '' 2  < KKN [NO Ouu}}V,RWWV]]4-@$%M*.%0[[F NF d{ #FUU[[kk[FF AYF r cVUR5(d [S5eURUR5uup#URUR5uupC[ R "U5(a([ RRU5nX%XB- --$X!XB- --$)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) scaledrhrrrrrrr)rr%rrrrs rinverseNormalize.inverses{{}}NO O'' 2 '' 2  ;;u  %%--&C-- -4;// /r cURR5 S=UlUlUR U5 SSS5 UR 5 g!,(df  N=f)z&Set *vmin*, *vmax* to min, max of *A*.N)rblockedrrrrrAs r autoscaleNormalize.autoscale sI ^^ # # %%) (DI    " &  & %s A A"c[R"U5n[U[RR5(a6UR SLdUR R (d URnURc&UR(aUR5UlURc(UR(aUR5Ul ggg)zDIf *vmin* or *vmax* are not set, use the min/max of *A* to set them.FN) r asanyarrayrr MaskedArrayrrrrsizeminrrrs rrNormalize.autoscale_None s MM!  a** + +vvaffllFF 99 DI 99 DI"( r cHURSL=(a URSL$)z.Return whether *vmin* and *vmax* are both set.NrrrLs rrNormalize.scaled) syy$>$)>>r )rErrrrrrNNFr)r*r+r,r-rsrr5rsetterrr rrrr-rrrrr.r7r rrrGs* ED [[  [[  [[ *%!%!N-^0*  ?r rc|^\rSrSrS U4Sjjr\S5r\RS5rU4SjrS Sjr Sr Sr U=r $) TwoSlopeNormi. c>[TU]X#S9 XlUbUbX:a [S5eUbUbX::a [S5eggg)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_vcenterrh)rvcenterrrrs rrTwoSlopeNorm.__init__/ si@ d.  4#3/0 0  4#3/0 09H#3 r cUR$rrrLs rrTwoSlopeNorm.vcenterX }}r cPXR:waXlUR5 ggr)rrrs rrr\ s MM !!M MMO "r c:>[TU]U5 URUR:a+URURUR- - UlURUR::a,URURUR- -Ulgg)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)rrrrr)rrrs rrTwoSlopeNorm.autoscale_Noneb sq q! 99 $  DLL(@ADI 99 $  tyy(@ADI %r c URU5up4URU5 URURs=::aUR::d O [ S5e[ RR[ R"X0RURUR//SQ[ R*[ RS9[ RRU5S9nU(a[ R"U5SnU$)zB Map value to the interval [0, 1]. The *clip* argument is unused. z/vmin, vcenter, vmax must increase monotonicallyrrzrleftrightrr) rrrrrrhrr masked_arrayinterpinfr atleast_1d)rr%r rrs rr-TwoSlopeNorm.__call__p s!..u5 F#yyDLL5DII5NO O## IIfyy$,, B!rvv ?v&$( ]]6*1-F r crUR5(d [S5eURUR5uup#URUR5uupCURUR 5uupS[ R"U/SQX%U/[ R*[ RS9nU$)Nrrr) rrhrrrrrrr)rr%rrrrrs rrTwoSlopeNorm.inverse s{{}}NO O'' 2 '' 2 **4<<8 5+t/D!#rvv7 r )rrrrnr) r*r+r,r-rr5rrrr-rr.r/r0s@rrr. sJ'0R ^^ B$r rc^\rSrSrSU4SjjrSrSr\S5r\RS5r\S5r \ RS5r \S 5r \ RS 5r \S 5r \ RS 5r S r U=r$) CenteredNormi c<>[TU]SSUS9 XlX lg)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. ]) Nrrr )rrr halfrange)rrrr rs rrCenteredNorm.__init__ s$\ dD9 "r c[R"U5n[URUR 5- UR5UR- 5Ulg)zI Set *halfrange* to ``max(abs(A-vcenter))``, then set *vmin* and *vmax*. N)rrrrrrrs rrCenteredNorm.autoscale sA MM! T]]15572UUWT]]24r c[R"U5nURc$UR(aUR U5 ggg)zSet *vmin* and *vmax*.N)rrrrrrs rrCenteredNorm.autoscale_None s4 MM!  >> !aff NN1 '- !r cUR$rrrLs rrCenteredNorm.vmin rr c[U5nXR:wa.XlSUR-U- UlUR 5 ggNr)rrrrrrs rrr =!%( JJ J4<<%/DJ MMO r cUR$rrrLs rrCenteredNorm.vmax rr c[U5nXR:wa.XlSUR-U- UlUR 5 ggr)rrrrrrs rrr rr cUR$rrrLs rrCenteredNorm.vcenter rr crXR:wa(XlURUlUR5 ggr)rrr)rrs rrr s* mm ##M!^^DN MMO $r cpURb URcgURUR- S- $rrrLs rrCenteredNorm.halfrange s0 99  1 DII%**r cUcSUlSUlgUR[U5- UlUR[U5-Ulgr)rrrabs)rrs rrr! s>  DIDI s9~5DI s9~5DIr )rrrrrr)rNF)r*r+r,r-rrrr5rrrrrr.r/r0s@rr r  s1#f4  [[ [[ ^^++ 66r r initc JUc[R"[XS9$[U[R5(a<URn[ UR R55nURnOS=p4UcSSjn[XUU[R"U55$)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. r$r7cgrr7rs rr%"make_norm_from_scale..init- sDr r) rrmake_norm_from_scalerrrkeywordsrr_make_norm_from_scaleinspect signature) scale_cls base_norm_clsr% scale_argsscale_kwargs_itemss rr)r) s>  !5yLL)Y..//^^ "9#5#5#;#;#=>NN *,,  |8 1w((. 00r c ^^^^^"UUUUU4SjST5nT[La)TRS3UlTRS3UlO"TRUlTRUlTRUlTRUlU$)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. c>^\rSrSrUUUUU4SjrUUUUU4SjrYR \R"S\RR5/YRR5QS9\l S Sjr SrU4SjrS rU=r$) #_make_norm_from_scale..NormiF c >[U5nU[[R"UR5UR 5La[ U4[U54$[TTTTT4[U54$![[4a N)f=fr) rgetattr importlib import_moduler+r,_create_empty_object_of_classvars ImportErrorr_picklable_norm_constructor)rrNr/bound_init_signaturer0r.r1s r __reduce__._make_norm_from_scale..Norm.__reduce__G st*C ')"9"9#.."I"%"2"2449C64:NN4 0 ,>"$8:J   0  sA A00BBc z>TR"U0UD6nUR5 [TU] "S0SVs0sHoDURR U5_M snD6 [ R"T/TQ70[T 5D6"SSS0URD6Ul URR5Ul gs snf)Nrrr7) bindapply_defaultsrr argumentsrorrdictr get_transform_trf) rrrbarrr=r0r.r1s rr,_make_norm_from_scale..Norm.__init__Z s%**D;F;B     G  N3KL3Kabll&&q))3KL N#++D&D*./A*BD//!#/DK 113DI Ms%B8 r) parameterscfURU5upURb URcURU5 URUR:a [ S5eURUR:Xa[ R "US5$Uc URnU(a+[ R"XRUR5nURRU5R[ R"U55nURRURUR/5upV[ R"XV/5R5(d [ S5eXE-nXFU- -n[ RRUSS9nU(aUS$U$)N"vmin must be less or equal to vmaxrInvalid vmin or vmaxFr0)rrrrrhr full_liker rFrrrisfiniterrmasked_invalid)rr%r rt_valuet_vmint_vmaxs rr-,_make_norm_from_scale..Norm.__call__h sK#11%8 Eyy DII$5##E*yy499$ !EFFyyDII%||E1--|yyyy$))<ii))%088%IG!YY00$))TYY1GHNF;;/04466 !788  G  (Gee**7*?G!*71: 7 7r cLUR5(d [S5eURUR:a [S5eURR URUR/5up#[ R"X#/5R5(d [S5eURU5upXU- -nXR- nURR5R U5R[ R"U55nU(aUS$U$)NNot invertible until scaledrKrLr) rrhrrrFrrrNrrr`rr)rr%rQrRrrescaleds rr+_make_norm_from_scale..Norm.inverse} s;;== !>??yy499$ !EFF!YY00$))TYY1GHNF;;/04466 !788#11%8 E0H  HYYhji)gbhhuo.  )58 3e 3r c>[R"[R"URR U55U5nUR S:Xa[R Rn[TU]%U5$)Nr) rextractrNrFrrrrrr)rr in_trf_domainrs rr2_make_norm_from_scale..Norm.autoscale_None sVJJr{{4993F3Fq3I'JANM!!Q& " 7)-8 8r )rrFr)r*r+r,r-r>rreplacer, ParameterPOSITIONAL_OR_KEYWORDrIvalues __signature__r-rrr.r/)rr/r=r0r.r1s@rNormr4F s}  & 4 4"6!=!=   fg&7&7&M&M NJ7 ! , , 3 3 5J7!="8 8* 4" 9 9r ra)rr*r,r+rs)r.r0r1r/r=ras````` rr+r+4 s$M9M9}M9^ !$--.d3 (556d;%.. )66#..DO ((DL Kr c$URU5$r)rJ)rNs rr9r9 s ;;s r c$[[U65$r)r9r+)rs rr<r< s ()>)E FFr cgrr7) functionsrrr s rrf sTr c\rSrSrSrSrg)FuncNormi a 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. r7N)r*r+r,r-rsr.r7r rrhrh sr rhr) nonpositiveLogNormz8Normalize a given value to the 0-1 range on a log scale. )basecgrr7) linthreshlinscalerrr rls rrfrf sr cL\rSrSrSr\S5r\RS5rSrg) SymLogNormi a 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.URR$rrrnrLs rrnSymLogNorm.linthresh s{{$$$r c$XRlgrrsrs rrnrt s % r r7N) r*r+r,r-rsr5rnrr.r7r rrqrq s5 0%%&&r rqcgrr7) linear_widthrrr s rrfrf s$r cL\rSrSrSr\S5r\RS5rSrg) AsinhNormi a1 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.URR$rrrwrLs rrwAsinhNorm.linear_width s{{'''r c$XRlgrr{rs rrwr| s #(  r r7N) r*r+r,r-rsr5rwrr.r7r rryry s5&(())r ryc@^\rSrSrSrSU4SjjrSSjrSrSrU=r $) PowerNormi a 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. c2>[TU]X#U5 Xlgr)rrr)rrrrr rs rrPowerNorm.__init__> s T* r cUc URnURU5up4URU5 URnURUR pvXg:a [ S5eXg:XaURS5 OU(aa[RRU5n[RR[R"URU5Xg5US9nURn X-n XU- -n [R"XS:U5XS:'[RRXRSS9nU(aUSnU$)NrrrFr)r rrrrrrhrrrrrrrpowerr) rr%r rrrrrrrs rr-PowerNorm.__call__B s <99D ..u5 F# YY d ;NO O \ KKNuu}}V,RWWV]]4-@$%M*.%0[[F NF d{ #F!#&!*U(aUS:wa [S5e[TU] USUSUS9 [R"U5Ul[ UR 5UlURS:a[SU<35eX lX@l SUl URS - Ul SUl US ;aU=RS - sl S Ul US ;aU=RS - sl URUR:a[S URS US35eg)a Parameters ---------- boundaries : array-like Monotonically increasing sequence of at least 2 bin edges: data falling in the n-th bin will be mapped to the n-th color. 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. Notes ----- If there are fewer bins (including extensions) than colors, then the color index is chosen by linearly interpolating the ``[0, nbins - 1]`` range onto the ``[0, ncolors - 1]`` range, effectively skipping some colors in the middle of the colormap. rz+'clip=True' is not compatible with 'extend'rrrrzDYou must provide at least 2 boundaries (1 region) but you passed in Nrrbothrrz There are z0 color bins including extensions, but ncolors = z1; ncolors must equal or exceed the number of bins) rhrrrr boundariesrZrNcmaprr _n_regions_offset)rrncolorsr rrs rrBoundaryNorm.__init__~ sJ Fi'JK K jm*R.tL**Z0T__% 66A:==GNLM M   &&1* _ $ OOq ODL _ $ OOq O ??TZZ 'z$//):;D 'y)../ / (r cUc URnURU5up4[RR U5n[R "UR URS-55nU(a:[R"X0RURUS9 URS- nO URn[R"X0R5S- UR-nURUR:aJURS:XaURS- S-XwS:H'O"URS- URS- - U-nUR[R5nSXsUR:'XgX0R:'[RR!XuS9nU(a[#US5nU$)zm This method behaves similarly to `.Normalize.__call__`, except that it returns integers or arrays of int16. routrrrr)r rrr getmaskarrayrrrrrdigitizerrrr@int16rr) rr%r rrrmax_coliretrs rr-BoundaryNorm.__call__ s[ <99D**51 uu!!"% ]]299TYY]3 4  GGB 499" 5jj1nGjjG{{2/!3dllB :: '!##'::>a"7QY Q4??Q+>?$F{{288$!$))^ 'R99_eekk$k* c!f+C r c[S5e)zt Raises ------ ValueError BoundaryNorm is not invertible, so calling this method will always raise an error zBoundaryNorm is not invertible)rhrs rrBoundaryNorm.inverse s9::r )rrrrrrrrrrr0s@rrrr s*=/)=/=/~(T;;r rc(\rSrSrSrSSjrSrSrg)NoNormi z} Dummy replacement for `Normalize`, for the case where we want to use indices directly in a `~matplotlib.cm.ScalarMappable`. Ncz[R"U5(a[RRU5$U$rrrrr)rr%r s rr-NoNorm.__call__ ) ;;u  55;;u% % r cz[R"U5(a[RRU5$U$rrrs rrNoNorm.inverse rr r7r)r*r+r,r-rsr-rr.r7r rrr s r rc[R"U5nURSS:wa[SURS35eURn[R"US[R "UR [R5SS9n[R"U5nURS5n[R"US:5(a[S UR535eUR5S :a[S UR535eUS :n[R"US5n[R"U5nXTX4- Xd'US :nUS U:HU-nXS4XS4- XW- X'S 4'US U:HU-nSXS4XS 4- XW- -X'S 4'USU:HU-nSXS 4XS4- XW- -X'S 4'US S- S-US 'XbS 'X2S'URU5$)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)rrrrhrrrr zeros_likerrrptpr)arrin_shaperarr_maxiposdeltar*idxs r rgb_to_hsvr s" **S/C yy}""%))K9: :yyH (( %syy"**5 C -- CggbkG vvgk ((/  8   wwy1} ((+ { 4  Q;D FF3OE eAkGM)AG 19D v;' !T )CAv;!V, :CQK v;' !T )CF cq&k1UZ??CQK v;' !T )CF cq&k1UZ??CQKv;$+CKKK ;;x  r c[R"U5nURSS:wa[SURS35eURn[R"US[R "UR [R5SS9nUSnUS nUS n[R"U5n[R"U5n[R"U5nUS -R[5nUS -U- n US U- -n US X9-- -n US US U - -- -n US -S:Hn XMX]'XXm'XX}'US:Hn XX]'XMXm'XX}'US:Hn XX]'XMXm'XX}'US:Hn XX]'XXm'XMX}'US:Hn XX]'XXm'XMX}'US:Hn XMX]'XXm'XX}'US:Hn XMX]'XMXm'XMX}'[R"XVU/SS9nURU5$)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] rrrrFrrrrrrrrrrrr) rrrrhrrrr empty_liker@rstackr)hsvrhr*rrrrr r1pqtrrgbs r hsv_to_rgbrC s= **S/C yy}""%))K9: :yyH (( %syy"**5 C F A F A F A aA aA aA SA SA A S1W A S15[A S1a= !A a%1*C VAF VAF VAF q&C VAF VAF VAF q&C VAF VAF VAF q&C VAF VAF VAF q&C VAF VAF VAF q&C VAF VAF VAF q&C VAF VAF VAF ((A!92 &C ;;x  r cSn[URS5HnXSU[R4S-- nM [R"U5$)Nrr.r)rangerrrOr{)rsum_sqr s r_vector_magnituder sKF 399R= !c1bjj()Q.." 776?r c\rSrSrSrSSjr\S5rSSjrSSjr SSjr SS jr SS jr S r S rS rg) LightSourcei a 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. cLXlX lX0lX@lXPlX`lg)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)rrrrrrrs rrLightSource.__init__ s'H  &&&&r c[R"SUR- 5n[R"UR5n[R"[R "U5[R "U5-[R "U5[R "U5-[R "U5/5$)z3The unit vector direction towards the light source.Z)rradiansrrrcossin)razalts r directionLightSource.direction s} ZZTZZ (jj%xx FF2J $ FF2J $ FF3K   r cU*n[R"X!-XC5upg[R"URS-5R [ U55nU*US'U*US'SUS'U[ U5-nURX5$)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. )rrrrr)rgradientrrr<rr shade_normals) r elevation vert_exagdxdyfractione_dye_dxnormals r hillshadeLightSource.hillshade sNS[[!6? )//D0166tIGvvv#F++!!&33r cURUR5nUR5UR5pTX2-nXT- S:a X4-nX5U- -n[R "USS5nU$)ar 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)dotrrrrr )rnormalsr intensityiminimaxs rrLightSource.shade_normals sm4KK/ ]]_immod K4   I + &IGGIq!, r Nc UcUR5nUcUR5nUc [XVS9nU"U"U55n UR"U 4XXxU U S.U D6n U SSS24U SSS24'U $)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_moderrrr.r)rrr shade_rgb)rrr normrrrrrrrrrgb0rgb1s rshadeLightSource.shadeE sz <88:D <88:D <$2DDJ~~d;d(1R'/;39;S"1"W S"1"W  r c URX%XgU5n U S[R4n URURUR S.n XJ;a X"X40UD6n O U"X40UD6n [RRU 5(a3U RSn [S5HnUSU4U U SU4U 'M U $![ an [SU R35U eSn A ff=f)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. .)rsoftoverlayz("blend_mode" must be callable or one of Nrr) rrrO blend_hsvblend_soft_light blend_overlayrrhkeysrrrr)rrrrrrrrrrlookupblendrrr s rrLightSource.shade_rgb s`NN9J c2::o. ~~----  &s@@E <"3>&)D1X&)#q&k$&7c1f d#  < !K$*KK="238;< I  y0#KK!OM!2!22k6F6F6K!LJ 6{j fZuS[M:"|#4S[M CD D &- ?D   vay! v   fRj! f!  6D :r rrrr)rNNF)rNNF)r)arsrcollections.abcrrrrr7r,rrnumbersrrPILrPIL.PngImagePluginr matplotlibrnumpyrr r r r r _color_datarrrrrDrr6rLrr\rrr8r:rKrcompilerrrrrrrirrrrcnameshexColorPatternrgb2hex hex2colorrcolorConverterrrrrrr7rr^rrr r)rr+r9r< FuncScalerhrLogScalerjr*r,SymmetricalLogScalerq AsinhScaleryrrrrrrrr)rrs00rr.s'R44  &66NN D  $%0%6%6%8)%8TQ"aK6662A5%8)* $'%3%9%9%;)%;TQ"aK6662A5%;)* $ !12 g.Gg.T)* >* 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  enn&9 ;;D F*337'L   && &D  FH) )H):U Up};9};@ Y  >!BO!dk/k/\ 6o) )s L? *L? M M