hS`HSrSSKrSSKrSSKJr SSKJrJrJrJ r J r SSKr \ RRRSS9 "SS5r"S S 5r"S S \5r\ RRRS SSS9 "SS\\ R$5rSrg)aN The Colorizer class which handles the data to color pipeline via a normalization and a colormap. .. admonition:: Provisional status of colorizer The ``colorizer`` module and classes in this file are considered provisional and may change at any time without a deprecation period. .. seealso:: :doc:`/gallery/color/colormap_reference` for a list of builtin colormaps. :ref:`colormap-manipulation` for examples of how to make colormaps. :ref:`colormaps` for an in-depth discussion of choosing colormaps. :ref:`colormapnorms` for more details about data normalization. N)ma)_apicolorscbookscaleartistzcolorizer : `~matplotlib.colorizer.Colorizer` or None, default: None The Colorizer object used to map color to data. If None, a Colorizer object is created from a *norm* and *cmap*.) colorizer_doccr\rSrSrSrSSjrSr\S5r\RS5rSSjr \ SS j5r S r S rS r\S 5r\RS5rSSjrSrSr\S5r\RS5r\S5r\RS5r\S5r\RS5rSrg) Colorizer&aq Data to color pipeline. This pipeline is accessible via `.Colorizer.to_rgba` and executed via the `.Colorizer.norm` and `.Colorizer.cmap` attributes. Parameters ---------- cmap: colorbar.Colorbar or str or None, default: None The colormap used to color data. norm: colors.Normalize or str or None, default: None The normalization used to normalize the data NcSUlURU5 SUlSUlX l[ R "S/S9UlSUlg)Nchangedsignals) _cmap _set_cmap_id_norm_normnormrCallbackRegistry callbackscolorbar)selfcmaprs F/var/www/html/env/lib/python3.13/site-packages/matplotlib/colorizer.py__init__Colorizer.__init__5sC  t   // D cUcUb;URX#5 [U[R5(a [ S5eUR U5 g)z Helper for initial scaling. Used by public functions that create a ScalarMappable and support parameters *vmin*, *vmax* and *norm*. This makes sure that a *norm* will take precedence over *vmin*, *vmax*. Note that this method does not set the norm. NzPassing a Normalize instance simultaneously with vmin/vmax is not supported. Please pass vmin/vmax directly to the norm when creating it.)set_clim isinstancer Normalize ValueErrorautoscale_None)rrvminvmaxAs r _scale_normColorizer._scale_normAsP  t/ MM$ %$ 0 011 =>> ArcUR$N)rrs rrColorizer.normW zzrc[R"[R[S4US9 Uc[R"5nO9[ U[5(a$[ RUn[U5"5nXRLagURSLnU(d/URRRUR5 XlURRR#SUR$5UlU(dUR%5 gg![a- [SSR[ R535Sef=f)Nrz;Invalid norm str name; the following values are supported: , r)rcheck_isinstancerr"strr!r_scale_mappingKeyErrorr#join_auto_norm_from_scalerr disconnectrrconnectr)rr scale_clsin_inits rrr-[s v//d;$G <##%D c " " !006 )35D 99  ))t# II   * *4== 9  ++33I48LLB  LLN%  ""&))E,@,@"A!BD s D$$7Ec[U[R5(a"URS:XaUR XX45$[ R "U5nU(aURU5nURXUS9nU$)  Return a normalized RGBA array corresponding to *x*. In the normal case, *x* is a 1D or 2D sequence of scalars, and the corresponding `~numpy.ndarray` of RGBA values will be returned, based on the norm and colormap set for this Colorizer. There is one special case, for handling images that are already RGB or RGBA, such as might have been read from an image file. If *x* is an `~numpy.ndarray` with 3 dimensions, and the last dimension is either 3 or 4, then it will be treated as an RGB or RGBA array, and no mapping will be done. The array can be `~numpy.uint8`, or it can be floats with values in the 0-1 range; otherwise a ValueError will be raised. Any NaNs or masked elements will be set to 0 alpha. If the last dimension is 3, the *alpha* kwarg (defaulting to 1) will be used to fill in the transparency. If the last dimension is 4, the *alpha* kwarg is ignored; it does not replace the preexisting alpha. A ValueError will be raised if the third dimension is other than 3 or 4. In either case, if *bytes* is *False* (default), the RGBA array will be floats in the 0-1 range; if it is *True*, the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range. If norm is False, no normalization of the input data is performed, and it is assumed to be in the range (0-1). )alphabytes) r!npndarrayndim_pass_image_datarasarrayrr)rxr?r@rrgbas rto_rgbaColorizer.to_rgbaxsh> a $ $1((5? ? JJqM  ! Ayyuy5 rcURSS:XaUcSnUR[R:Xa[R"US-5nURSSupE[R"XES4URS9nXSS2SS2SS24'XSS2SS2S4'O!URSS:XaUnO [ S5eURR S :Xa[R"[R"U5=n5(a?URSS:XaUR5nS U[R"USS 9SS24'U(a3UR5S:dUR5S :a [ S 5eU(a"US-R[R5nO`UR[R:Xa*U(d"UR[R5S- nO[ S UR-5e[RRU5(a7S U[R"[RR!U5SS 9S4'U$)zr Helper function to pass ndarray of shape (...,3) or (..., 4) through `to_rgba()`, see `to_rgba()` for docstring. r>N)shapedtypezThird dimension must be 3 or 4fr)axisz:Floating point image RGB values must be in the 0..1 range.z9Image RGB array must be uint8 or floating point; found %s)rOrPrAuint8emptyr#kindanyisnancopymaxminastypefloat32r is_masked getmaskarray)rFr?r@rmnxxnanss rrDColorizer._pass_image_datas 771:?}ww"(("-772A;DAq 9Bq!RaRxLq!QwK WWQZ1_B=> > 88==C vvbhhqk)d**771:?B./266$Q'*+AA ">??3h&&rxx0 XX !YYrzz*S08:<((CD D 55??1  ;rc6URRXX4S9$)r=)r?r@r)rrH)rrFr?r@rs rrH_ColorizerInterface.to_rgbaFs<&&qU&NNrc6URR5$r})rr~r,s rr~_ColorizerInterface.get_climfs''))rc:URRX5 g)a Set the norm limits for image scaling. Parameters ---------- vmin, vmax : float The limits. For scalar data, the limits may also be passed as a tuple (*vmin*, *vmax*) as a single positional argument. .. ACCEPTS: (vmin: float, vmax: float) N)rr rzs rr _ColorizerInterface.set_climls   ,rcB>[TU]5$![a gf=fr)super get_alphaAttributeError)r __class__s rr_ColorizerInterface.get_alpha~s( 7$& &  s  c.URR$r+rrr,s rr_ColorizerInterface.cmap###rc$XRlgr+rrws rrr #rc.URR$)z Return the `.Colormap` instance.rr,s rget_cmap_ColorizerInterface.get_cmaprrcXlg)roN)rrws rset_cmap_ColorizerInterface.set_cmaps  rc.URR$r+rrr,s rr_ColorizerInterface.normrrc$XRlgr+rrrs rrrrrcXlg)a Set the normalization instance. Parameters ---------- norm : `.Normalize` or str or None Notes ----- If there are any colorbars using the mappable for this norm, setting the norm of the mappable will reset the norm, locator, and formatters on the colorbar to default. Nr0rs rset_norm_ColorizerInterface.set_norms  rcNURRUR5 g)reN)rrhrr,s rrh_ColorizerInterface.autoscales !!$''*rcNURRUR5 g)rlN)rr$rr,s rr$"_ColorizerInterface.autoscale_Nones &&tww/rc.URR$)z< The last colorbar associated with this object. May be None rrr,s rr_ColorizerInterface.colorbars '''rc$XRlgr+r)rrs rrrs #+ rcURRn[RR U5(agUR U5n[R "U5(Ga[UR [R5(a[R"[R"UR RU- 55n[SUS- 5n[R"UR RXTS-5R5nOUR RUR R :Xa.[R"UR RS-5nO]UR R#[%X2-5[R&"SS/5-U- 5n[Xq- 5R5n[(R*"X5nOSnSUSUS 3S 3$) Nz[]rrLrKg?r>[z-#.g])rNrArgetmaskrisfiniter!r BoundaryNormargminabs boundariesrYdiffr%r&inverseintarrayr _g_sig_digits) rdatar`normedcur_idx neigh_idxdelta neighbors g_sig_digitss r_format_cursor_data_override0_ColorizerInterface._format_cursor_data_overrideso IIKK 55==  4 ;;v  $))V%8%899))BFF499+?+?$+F$GH7Q;/ II((Q;?#%499>>1tyy~~23!II--_rxxA'771<> I,-113 ..t;LL4L>*+1--rrrrr)rrrrrr(rHr~r rrrrrrrrrhr$rrr __classcell__rs@rrr:s?O@* -$ $$ [[$$$$$ [[$$ +0(( __,,!.!.rrcj^\rSrSrSrS SS.U4SjjjrSrSrSr\ S 5r \ S 5r S r U=r $) _ScalarMappableiz A mixin class to map one or multiple sets of scalar data to RGBA. The ScalarMappable applies data normalization before returning RGBA colors from the given `~matplotlib.colors.Colormap`. N colorizerc >[TU]"S0UD6 SUlURX1US9UlSUlURR RSUR5Ul [R"S/S9Ulg)a Parameters ---------- norm : `.Normalize` (or subclass thereof) or str or None The normalizing object which scales data, typically into the interval ``[0, 1]``. If a `str`, a `.Normalize` subclass is dynamically generated based on the scale with the corresponding name. If *None*, *norm* defaults to a *colors.Normalize* object which initializes its scaling based on the first data processed. cmap : str or `~matplotlib.colors.Colormap` The colormap used to map normalized data values to RGBA colors. N)rrrrrr) rrr_get_colorizerrrrr9r _id_colorizerrr)rrrrkwargsrs rr_ScalarMappable.__init__sr "6"-- SW-X !__66>>y$,,W// DrcNUcSUlg[R"USS9n[R"UR [ S5(d[SUR S35eXlURR5(dURRU5 gg)a Set the value array from array-like *A*. Parameters ---------- A : array-like or None The values that are mapped to colors. The base class `.ScalarMappable` does not make any assumptions on the dimensionality and shape of the value array *A*. NT)rX same_kindzImage data of dtype z cannot be converted to float) rrsafe_masked_invalidrAcan_castrPfloatrgrscaledrr$ris r set_array_ScalarMappable.set_arrays 9DG   % %ad 3{{177E;772177)<112 2yy!! OO * *1 -"rcUR$)z Return the array of values, that are mapped to colors. The base class `.ScalarMappable` does not make any assumptions on the dimensionality and shape of the array. )rr,s r get_array_ScalarMappable.get_array4s wwrcJURRSU5 SUlgrrr,s rr_ScalarMappable.changed=s y$/ rc Ubc[UR5Vs/sHo"SLPM sn5(a2[SSRSUR 555-5eggs snf)zJ Raises a ValueError if any kwarg is not None while colorizer is not None NzZThe `colorizer` keyword cannot be used simultaneously with any of the following keywords: r1c3.# UH nSUS3v M g7f)`Nr).0keys r ?_ScalarMappable._check_exclusionary_keywords..Ns,Q=CqQZ=s)rVvaluesr#r6keys)rrvals r_check_exclusionary_keywords,_ScalarMappable._check_exclusionary_keywordsEsm  v}}?tO?@@ "I#'99,Q6;;=,Q#Q"RSSA !?s A(cv[U[5(a[R[XS9 U$[X5$)Nr)r!r rr )rrrs rr_ScalarMappable._get_colorizerPs: i + +  8 8 9  $$r)rrrrrrr)rrrrrrrrrrr rrrrs@rrrsU*E$EE,.2SS%%rrzcmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap` The Colormap instance or registered colormap name used to map scalar data to colors.anorm : str or `~matplotlib.colors.Normalize`, optional The normalization method used to scale scalar data to the [0, 1] range before mapping to colors using *cmap*. By default, a linear scaling is used, mapping the lowest value to 0 and the highest to 1. If given, this can be one of the following: - An instance of `.Normalize` or one of its subclasses (see :ref:`colormapnorms`). - A scale name, i.e. one of "linear", "log", "symlog", "logit", etc. For a list of available scales, call `matplotlib.scale.get_scale_names()`. In that case, a suitable `.Normalize` subclass is dynamically generated and instantiated.avmin, vmax : float, optional When using scalar data and no explicit *norm*, *vmin* and *vmax* define the data range that the colormap covers. By default, the colormap covers the complete value range of the supplied data. It is an error to use *vmin*/*vmax* when a *norm* instance is given (but using a `str` *norm* name together with *vmin*/*vmax* is acceptable).)cmap_docnorm_doc vmin_vmax_doccf^\rSrSrSrU4Sjr\S5r\RS5rSr Sr U=r $)ColorizingArtistiwz Base class for artists that make map data to color using a `.colorizer.Colorizer`. The `.colorizer.Colorizer` applies data normalization before returning RGBA colors from a `~matplotlib.colors.Colormap`. c \>[R"[US9 [TU]"SSU0UD6 g)z: Parameters ---------- colorizer : `.colorizer.Colorizer` rrNr)rr2r rr)rrrrs rrColorizingArtist.__init__s* i9= 7977rcUR$r+)rr,s rrColorizingArtist.colorizers rc[R"[US9 URRR UR 5 XlURRSUR5Ulg)Nrr) rr2r rrr8rr9r)rcls rrrsR i26 !!,,T-?-?@\\11)T\\Jrc 6UR"U40UD6 Xlg)zK Raises a ValueError if any kwarg is not None while colorizer is not None. N)r r)rrrs r_set_colorizer_check_keywords.ColorizingArtist._set_colorizer_check_keywordss )))>v>"r)rrr) rrrrrrrrrrrrrs@rrrwsG8KK ##rrc[R"[R"USS95"[R5"5n[ U5$![ a2 [R"U5"[R5"5nNFf=f)a Automatically generate a norm class from *scale_cls*. This differs from `.colors.make_norm_from_scale` in the following points: - This function is not a class decorator, but directly returns a norm class (as if decorating `.Normalize`). - The scale is automatically constructed with ``nonpositive="mask"``, if it supports such a parameter, to work around the difference in defaults between standard scales (which use "clip") and norms (which use "mask"). Note that ``make_norm_from_scale`` caches the generated norm classes (not the instances) and reuses them for later calls. For example, ``type(_auto_norm_from_scale("log")) == LogNorm``. mask) nonpositive)rmake_norm_from_scale functoolspartialr"rgtype)r:rs rr7r7sz$ **   iV <>     :  **95     sAA9B  B )rr"numpyrArrqrrrrrmpl _docstringinterpdregisterr rrArtistrr7rrrr+s*993 QQhr.r.jh%)h%V 8' :!# !#Hr