gS`TdZddlZddlZddlmZddlmZmZmZm Z m Z ddlZ e jjjdGddZGd d ZGd d eZe jjjd ddGddee j$ZdZy)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_doccbeZdZdZddZdZedZejdZddZ e ddZ d Z d Z d Zed Zejd ZddZdZdZedZejdZedZejdZedZejdZy) Colorizera 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 Ncd|_|j|d|_d|_||_t j dg|_d|_y)Nchangedsignals) _cmap _set_cmap_id_norm_normnormrCallbackRegistry callbackscolorbar)selfcmaprs Q/var/www/dash_apps/app1/venv/lib/python3.12/site-packages/matplotlib/colorizer.py__init__zColorizer.__init__5sE  t   // D c||7|j||t|tjr t d|j |y)a, 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_normzColorizer._scale_normAsO  t/ MM$ %$ 0 01 =>> Arc|jSN)rrs rrzColorizer.normW zzrctjtjtdf||tj}n4t |tr$ t j|}t|}||jury|jdu}|s/|jjj|j||_|jjj#d|j$|_|s|j%yy#t$r-tddjt jdwxYw)Nrz;Invalid norm str name; the following values are supported: , r )rcheck_isinstancerr strrr_scale_mappingKeyErrorr!join_auto_norm_from_scalerr disconnectrrconnectr )rr scale_clsin_inits rrzColorizer.norm[s  v//d;$G <##%D c " !006 4(35D 499  ))t# II   * *4== 9  ++33I48LLB  LLN%  ""&))E,@,@"A!BD s D6E ct|tjr#|jdk(r|j ||||St j |}|r|j|}|j|||}|S) 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) rnpndarrayndim_pass_image_datarasarrayrr)rxr;r<rrgbas rto_rgbazColorizer.to_rgbaxsk> a $1((E5$? ? JJqM  ! Ayy%uy5 rc|jddk(r|d}|jtjk(rtj|dz}|jdd\}}tj||df|j}||ddddddf<||dddddf<n |jddk(r|}n t d|jj d k(rtjtj|x}r@|jddk(r|j}d |tj|d ddf<|r1|jdkDs|jd kr t d |r}|dzjtj}nZ|jtjk(r%|s;|jtjdz }nt d |jztjj|r9d |tjtjj!|d df<|S)z 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)rJrKr=uint8emptyr!kindanyisnancopymaxminastypefloat32r is_masked getmaskarray)rBr;r<rmnxxnanss rr@zColorizer._pass_image_datas 771:?}ww"(("-772A;DAqAq 9BBq!RaRxLBq!QwK WWQZ1_B=> > 88==C vvbhhqk)d*771:?B./266$Q'*+AA ">??3h&&rxx0 XX !YYrzz*S08:<((CD D 55??1 ; Set the norm limits for image scaling. Parameters ---------- vmin, vmax : float The limits. The limits may also be passed as a tuple (*vmin*, *vmax*) as a single positional argument. .. ACCEPTS: (vmin: float, vmax: float) N)rar!r_sanitize_extremarr#r$rr#r$s rrzColorizer.set_climso < ! d  #55d;DIIN  #55d;DIIN  z*  sAA)(A)cZ|jj|jjfSzV Return the values (min, max) that are mapped to the colormap limits. )rr#r$r)s rget_climzColorizer.get_climsyy~~tyy~~--rcH|jjdd|_yz Call this whenever the mappable is changed to notify all the callbackSM listeners to the 'changed' signal. r TNrprocessstaler)s rr zColorizer.changeds y) rc(|jdS)Nrrsr)s rr#zColorizer.vmin!}}q!!rc(|j|y)N)r#r)rr#s rr#zColorizer.vmin% 4  rc(|jdSNrGrzr)s rr$zColorizer.vmax)r{rc(|j|y)N)r$r})rr$s rr$zColorizer.vmax-r~rc.|jjSr(rclipr)s rrzColorizer.clip1syy~~rc&||j_yr(r)rrs rrzColorizer.clip5s  rNNNFT)__name__ __module__ __qualname____doc__rr&propertyrsetterrD staticmethodr@rbr"rrrrsr r#r$rrrr r &s&  , [[8'R((T  $  [[<4. "" [[!!"" [[!! [[rr ceZdZdZdZddZdZddZfdZe dZ e jdZ d Z d Z e d Zejd Zd ZdZdZe dZejdZdZxZS)_ColorizerInterfaceaB Base class that contains the interface to `Colorizer` objects from a `ColorizingArtist` or `.cm.ScalarMappable`. Note: This class only contain functions that interface the .colorizer attribute. Other functions that as shared between `.ColorizingArtist` and `.cm.ScalarMappable` are not included. cT|jj||||jyr() _colorizerr&_A)rrr#r$s rr&z_ColorizerInterface._scale_normCs ##D$dgg>rc@|jj||||S)r9)r;r<r)rrD)rrBr;r<rs rrDz_ColorizerInterface.to_rgbaFs"<&&qU&NNrc6|jjSrr)rrsr)s rrsz_ColorizerInterface.get_climfs''))rc<|jj||y)aO 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)rrrps rrz_ColorizerInterface.set_climls   t,rc@ t|S#t$rYywxYwr)super get_alphaAttributeError)r __class__s rrz_ColorizerInterface.get_alpha~s( 7$& &  s  c.|jjSr(rrr)s rrz_ColorizerInterface.cmap###rc&||j_yr(rrms rrz_ColorizerInterface.cmap#rc.|jjS)z Return the `.Colormap` instance.rr)s rget_cmapz_ColorizerInterface.get_cmaprrc||_y)rgN)rrms rset_cmapz_ColorizerInterface.set_cmaps  rc.|jjSr(rrr)s rrz_ColorizerInterface.normrrc&||j_yr(rrrs rrz_ColorizerInterface.normrrc||_y)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. Nr,rs rset_normz_ColorizerInterface.set_norms  rcN|jj|jy)r_N)rrbrr)s rrbz_ColorizerInterface.autoscales !!$''*rcN|jj|jy)reN)rr"rr)s rr"z"_ColorizerInterface.autoscale_Nones &&tww/rc.|jjS)zL The last colorbar associated with this object. May be None rrr)s rrz_ColorizerInterface.colorbars '''rc&||j_yr(r)rrs rrz_ColorizerInterface.colorbars#+ rc|jj}tjj |ry|j |}tj |rt|j tjrtjtj|j j|z }td|dz }tj|j j||dzj}n|j j|j j k(r-tj|j jdz}n^|j j#t%||ztj&ddgz|z }t||z j}t)j*||}nd}d|d|d d S) Nz[]rrGrFg?r:[z-#.g])rNr=rgetmaskrisfiniterr BoundaryNormargminabs boundariesrTdiffr#r$inverseintarrayr _g_sig_digits) rdatar[normedcur_idx neigh_idxdelta neighbors g_sig_digitss r_format_cursor_data_overridez0_ColorizerInterface._format_cursor_data_overridesn IIKK 55== 4 ;;v $))V%8%89))BFF499+?+?$+F$GH7Q;/ II((7Q;?#%499>>1tyy~~23!II--!_rxxA'771<> I,-113 ..tU;LL4L>*+1--rrr)rrrrr&rDrsrrrrrrrrrrbr"rr __classcell__rs@rrr:s?O@* -$ $$ [[$$$$$ [[$$ +0(( __,,!.rrc\eZdZdZd ddfd ZdZdZdZedZ ed Z xZ S) _ScalarMappablez 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 t|di|d|_|j||||_d|_|jj jd|j|_ tjdg|_y)ar 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)rrrr rr) rrr_get_colorizerrrrr5r _id_colorizerrr)rrrrkwargsrs rrz_ScalarMappable.__init__st "6"-- SW-X !__66>>y$,,W// Drc<|d|_ytj|d}tj|j t dstd|j d||_|jjs|jj|yy)aB 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)rS same_kindzImage data of dtype z cannot be converted to float) rrsafe_masked_invalidr=can_castrKfloatrarscaledrr"rcs r set_arrayz_ScalarMappable.set_arrays 9DG   % %ad 3{{177E;72177)<112 2yy! OO * *1 -"rc|jS)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_arrayz_ScalarMappable.get_array4s wwrcJ|jjd|d|_yrurvr)s rr z_ScalarMappable.changed=s y$/ rc |\t|jDcgc]}|duc}r2tddjd|j Dzyycc}w)zZ 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: r-c3(K|] }d|d yw)`Nr).0keys r z?_ScalarMappable._check_exclusionary_keywords..Ns,QCqQZ,Qs)rQvaluesr!r2keys)rrvals r_check_exclusionary_keywordsz,_ScalarMappable._check_exclusionary_keywordsEsh  v}}?CtO?@ "I#'99,Q6;;=,Q#Q"RSSA !?s A cvt|trtjt|||St||S)N)rr)rr rr)rrrs rrz_ScalarMappable._get_colorizerPs; i +  8 84 9  t$$rr) rrrrrrrr rrrrrs@rrrsO*E$E,.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_docc\eZdZdZfdZedZejdZdZxZ S)ColorizingArtistz 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 ^tjt|t|dd|i|y)zZ Parameters ---------- colorizer : `.colorizer.Colorizer` rrNr)rr.r rr)rrrrs rrzColorizingArtist.__init__s* i9= 7977rc|jSr()rr)s rrzColorizingArtist.colorizers rctjt||jjj |j ||_|jjd|j|_y)Nrr ) rr.r rrr4rr5r )rcls rrzColorizingArtist.colorizersT i26 !!,,T-?-?@\\11)T\\Jrc 8|j|fi|||_y)z[ Raises a ValueError if any kwarg is not None while colorizer is not None. N)rr)rrrs r_set_colorizer_check_keywordsz.ColorizingArtist._set_colorizer_check_keywordss  *)))>v>"r) rrrrrrrrrrrs@rrrwsB8KK #rrc. tjtj|dtj}t |S#t $r;tj|tj}Yt |SwxYw)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 ratype)r6rs rr3r3s$ >v**   iV <>     :  5v**95     : sAA7BB)rrnumpyr=rrirrrrrmpl _docstringinterpdregisterr rrArtistrr3rrrrs*993 QQhr.r.jh%)h%V 8' :!# !#Hr