"""

def __init__(self, cmap=None, norm=None):

self._cmap = None

self._set_cmap(cmap)

self._id_norm = None

self._norm = None

self.norm = norm

self.callbacks = cbook.CallbackRegistry(signals=["changed"])

self.colorbar = None

def _scale_norm(self, norm, vmin, vmax, A):

"""

if vmin is not None or vmax is not None:

self.set_clim(vmin, vmax)

if isinstance(norm, colors.Norm):

raise ValueError(

"Passing a Normalize instance simultaneously with "

"vmin/vmax is not supported. Please pass vmin/vmax "

"as arguments to the norm object when creating it")

# always resolve the autoscaling so we have concrete limits

# rather than deferring to draw time.

self.autoscale_None(A)

@property

def norm(self):

return self._norm

@norm.setter

def norm(self, norm):

norm = _ensure_norm(norm, n_components=self.cmap.n_variates)

if norm is self.norm:

# We aren't updating anything

return

in_init = self.norm is None

# Remove the current callback and connect to the new one

if not in_init:

self.norm.callbacks.disconnect(self._id_norm)

self._norm = norm

self._id_norm = self.norm.callbacks.connect('changed',

self.changed)

if not in_init:

self.changed()

def to_rgba(self, x, alpha=None, bytes=False, norm=True):

"""

# First check for special case, image input:

if isinstance(x, np.ndarray) and x.ndim == 3:

return self._pass_image_data(x, alpha, bytes, norm)

# Otherwise run norm -> colormap pipeline

x = ma.asarray(x)

if norm:

x = self.norm(x)

rgba = self.cmap(x, alpha=alpha, bytes=bytes)

return rgba

@staticmethod

def _pass_image_data(x, alpha=None, bytes=False, norm=True):

"""

if x.shape[2] == 3:

if alpha is None:

alpha = 1

if x.dtype == np.uint8:

alpha = np.uint8(alpha * 255)

m, n = x.shape[:2]

xx = np.empty(shape=(m, n, 4), dtype=x.dtype)

xx[:, :, :3] = x

xx[:, :, 3] = alpha

elif x.shape[2] == 4:

xx = x

else:

raise ValueError("Third dimension must be 3 or 4")

if xx.dtype.kind == 'f':

# If any of R, G, B, or A is nan, set to 0

if np.any(nans := np.isnan(x)):

if x.shape[2] == 4:

xx = xx.copy()

xx[np.any(nans, axis=2), :] = 0

if norm and (xx.max() > 1 or xx.min() < 0):

raise ValueError("Floating point image RGB values "

"must be in the [0,1] range")

if bytes:

xx = (xx * 255).astype(np.uint8)

elif xx.dtype == np.uint8:

if not bytes:

xx = xx.astype(np.float32) / 255

else:

raise ValueError("Image RGB array must be uint8 or "

"floating point; found %s" % xx.dtype)

# Account for any masked entries in the original array

# If any of R, G, B, or A are masked for an entry, we set alpha to 0

if np.ma.is_masked(x):

xx[np.any(np.ma.getmaskarray(x), axis=2), 3] = 0

return xx

def autoscale(self, A):

"""

if A is None:

raise TypeError('You must first set_array for mappable')

# If the norm's limits are updated self.changed() will be called

# through the callbacks attached to the norm

self.norm.autoscale(A)

def autoscale_None(self, A):

"""

if A is None:

raise TypeError('You must first set_array for mappable')

# If the norm's limits are updated self.changed() will be called

# through the callbacks attached to the norm

self.norm.autoscale_None(A)

def _set_cmap(self, cmap):

"""

in_init = self._cmap is None

cmap_obj = _ensure_cmap(cmap, accept_multivariate=True)

if not in_init and self.norm.n_components != cmap_obj.n_variates:

raise ValueError(f"The colormap {cmap} does not support "

f"{self.norm.n_components} variates as required by "

f"the {type(self.norm)} on this Colorizer")

self._cmap = cmap_obj

if not in_init:

self.changed() # Things are not set up properly yet.

@property

def cmap(self):

return self._cmap

@cmap.setter

def cmap(self, cmap):

self._set_cmap(cmap)

def set_clim(self, vmin=None, vmax=None):

"""

if self.norm.n_components == 1:

if vmax is None:

try:

vmin, vmax = vmin

except (TypeError, ValueError):

pass

orig_vmin_vmax = self.norm.vmin, self.norm.vmax

# Blocked context manager prevents callbacks from being triggered

# until both vmin and vmax are updated

with self.norm.callbacks.blocked(signal='changed'):

# Since the @vmin/vmax.setter invokes colors._sanitize_extrema()

# to sanitize the input, the input is not sanitized here

if vmin is not None:

self.norm.vmin = vmin

if vmax is not None:

self.norm.vmax = vmax

# emit a update signal if the limits are changed

if orig_vmin_vmax != (self.norm.vmin, self.norm.vmax):

self.norm.callbacks.process('changed')

def get_clim(self):

"""

if self.norm.n_components == 1:

return (self.norm.vmin, ), (self.norm.vmax, )

else:

return self.norm.vmin, self.norm.vmax

def changed(self):

"""

self.callbacks.process('changed')

self.stale = True

@property

def vmin(self):

return self.get_clim()[0]

@vmin.setter

def vmin(self, vmin):

self.set_clim(vmin=vmin)

@property

def vmax(self):

return self.get_clim()[1]

@vmax.setter

def vmax(self, vmax):

self.set_clim(vmax=vmax)

@property

def clip(self):

if self.norm.n_components == 1:

return (self.norm.clip, )

else:

return self.norm.clip

@clip.setter

def clip(self, clip):

"""

def _scale_norm(self, norm, vmin, vmax):

self._colorizer._scale_norm(norm, vmin, vmax, self._A)

def to_rgba(self, x, alpha=None, bytes=False, norm=True):

"""

return self._colorizer.to_rgba(x, alpha=alpha, bytes=bytes, norm=norm)

def get_clim(self):

"""

if self._colorizer.norm.n_components > 1:

raise RuntimeError("get_clim() cannot be used with a multi-component "

"colormap. Use .colorizer.get_clim() instead")

return self.colorizer.norm.vmin, self.colorizer.norm.vmax

def set_clim(self, vmin=None, vmax=None):

"""

# If the norm's limits are updated self.changed() will be called

# through the callbacks attached to the norm

if self._colorizer.norm.n_components > 1:

raise RuntimeError("set_clim() cannot be used with a multi-component "

"colormap. Use .colorizer.set_clim() instead")

self._colorizer.set_clim(vmin, vmax)

def get_alpha(self):

try:

return super().get_alpha()

except AttributeError:

return 1

@property

def cmap(self):

return self._colorizer.cmap

@cmap.setter

def cmap(self, cmap):

self._colorizer.cmap = cmap

def get_cmap(self):

"""Return the `.Colormap` instance."""

return self._colorizer.cmap

def set_cmap(self, cmap):

"""

self.cmap = cmap

@property

def norm(self):

return self._colorizer.norm

@norm.setter

def norm(self, norm):

self._colorizer.norm = norm

def set_norm(self, norm):

"""

self.norm = norm

def autoscale(self):

"""

self._colorizer.autoscale(self._A)

def autoscale_None(self):

"""

self._colorizer.autoscale_None(self._A)

@property

def colorbar(self):

"""

return self._colorizer.colorbar

@colorbar.setter

def colorbar(self, colorbar):

self._colorizer.colorbar = colorbar

def _format_cursor_data_override(self, data):

# This function overwrites Artist.format_cursor_data(). We cannot

# implement cm.ScalarMappable.format_cursor_data() directly, because

# most cm.ScalarMappable subclasses inherit from Artist first and from

# cm.ScalarMappable second, so Artist.format_cursor_data would always

# have precedence over cm.ScalarMappable.format_cursor_data.

# Note if cm.ScalarMappable is depreciated, this functionality should be

# implemented as format_cursor_data() on ColorizingArtist.

if np.ma.getmask(data) or data is None:

# NOTE: for multivariate data, if *any* of the fields are masked,

# "[]" is returned here

return "[]"

if isinstance(self.norm, colors.MultiNorm):

norms = self.norm.norms

if isinstance(self.cmap, colors.BivarColormap):

n_s = (self.cmap.N, self.cmap.M)

else: # colors.MultivarColormap

n_s = [part.N for part in self.cmap]

else: # colors.Colormap

norms = [self.norm]

data = [data]

n_s = [self.cmap.N]

os = [f"{d:-#.{self._sig_digits_from_norm(no, d, n)}g}"

for no, d, n in zip(norms, data, n_s)]

return f"[{', '.join(os)}]"

@staticmethod

def _sig_digits_from_norm(norm, data, n):

# Determines the number of significant digits

# to use for a number given a norm, and n, where n is the

# number of colors in the colormap.

normed = norm(data)

if np.isfinite(normed):

if isinstance(norm, colors.BoundaryNorm):

# not an invertible normalization mapping

cur_idx = np.argmin(np.abs(norm.boundaries - data))

neigh_idx = max(0, cur_idx - 1)

# use max diff to prevent delta == 0

delta = np.diff(norm.boundaries[neigh_idx:cur_idx + 2]).max()

elif norm.vmin == norm.vmax:

# singular norms, use delta of 10% of only value

delta = np.abs(norm.vmin * .1)

else:

# Midpoints of neighboring color intervals.

neighbors = norm.inverse(

(int(float(normed) * n) + np.array([0, 1])) / n)

delta = abs(neighbors - data).max()

g_sig_digits = cbook._g_sig_digits(data, delta)

else:

g_sig_digits = 3 # Consistent with default below.

"""

# _ScalarMappable exists for compatibility with

# code written before the introduction of the Colorizer

# and ColorizingArtist classes.

# _ScalarMappable can be depreciated so that ColorizingArtist

# inherits directly from _ColorizerInterface.

# in this case, the following changes should occur:

# __init__() has its functionality moved to ColorizingArtist.

# set_array(), get_array(), _get_colorizer() and

# _check_exclusionary_keywords() are moved to ColorizingArtist.

# changed() can be removed so long as colorbar.Colorbar

# is changed to connect to the colorizer instead of the

# ScalarMappable/ColorizingArtist,

# otherwise changed() can be moved to ColorizingArtist.

def __init__(self, norm=None, cmap=None, *, colorizer=None, **kwargs):

"""

super().__init__(**kwargs)

self._A = None

self._colorizer = self._get_colorizer(colorizer=colorizer, norm=norm, cmap=cmap)

self.colorbar = None

self._id_colorizer = self._colorizer.callbacks.connect('changed', self.changed)

self.callbacks = cbook.CallbackRegistry(signals=["changed"])

def set_array(self, A):

"""

if A is None:

self._A = None

return

A = _ensure_multivariate_data(A, self.norm.n_components)

A = cbook.safe_masked_invalid(A, copy=True)

if not np.can_cast(A.dtype, float, "same_kind"):

if A.dtype.fields is None:

raise TypeError(f"Image data of dtype {A.dtype} cannot be "

f"converted to float")

else:

for key in A.dtype.fields:

if not np.can_cast(A[key].dtype, float, "same_kind"):

raise TypeError(f"Image data of dtype {A.dtype} cannot be "

f"converted to a sequence of floats")

self._A = A

if not self.norm.scaled():

self._colorizer.autoscale_None(A)

def get_array(self):

"""

return self._A

def _getmaskarray(self, A):

"""

mask = np.ma.getmaskarray(A)

if isinstance(self.norm, colors.MultiNorm):

mask = np.any(mask.view('bool').reshape((*A.shape, -1)), axis=-1)

return mask

def changed(self):

"""

self.callbacks.process('changed', self)

self.stale = True

@staticmethod

def _check_exclusionary_keywords(colorizer, **kwargs):

"""

if colorizer is not None:

if any([val is not None for val in kwargs.values()]):

raise ValueError("The `colorizer` keyword cannot be used simultaneously"

" with any of the following keywords: "

+ ", ".join(f'`{key}`' for key in kwargs.keys()))

@staticmethod

def _get_colorizer(cmap, norm, colorizer):

if isinstance(colorizer, Colorizer):

_ScalarMappable._check_exclusionary_keywords(

Colorizer, cmap=cmap, norm=norm

)

return colorizer

"""

def __init__(self, colorizer, **kwargs):

"""

_api.check_isinstance(Colorizer, colorizer=colorizer)

super().__init__(colorizer=colorizer, **kwargs)

@property

def colorizer(self):

return self._colorizer

@colorizer.setter

def colorizer(self, cl):

_api.check_isinstance(Colorizer, colorizer=cl)

self._colorizer.callbacks.disconnect(self._id_colorizer)

self._colorizer = cl

self._id_colorizer = cl.callbacks.connect('changed', self.changed)

def _set_colorizer_check_keywords(self, colorizer, **kwargs):

"""

self._check_exclusionary_keywords(colorizer, **kwargs)

"""

# Actually try to construct an instance, to verify whether

# ``nonpositive="mask"`` is supported.

try:

norm = colors.make_norm_from_scale(

functools.partial(scale_cls, nonpositive="mask"))(

colors.Normalize)()

except TypeError:

norm = colors.make_norm_from_scale(scale_cls)(

colors.Normalize)()

if n_components == 1:

_api.check_isinstance((colors.Norm, str, None), norm=norm)

if norm is None:

norm = colors.Normalize()

elif isinstance(norm, str):

scale_cls = _api.getitem_checked(scale._scale_mapping, norm=norm)

return _auto_norm_from_scale(scale_cls)()

return norm

elif n_components > 1:

if not np.iterable(norm):

_api.check_isinstance((colors.MultiNorm, None, tuple), norm=norm)

if norm is None:

norm = colors.MultiNorm(['linear']*n_components)

else: # iterable, i.e. multiple strings or Normalize objects

norm = colors.MultiNorm(norm)

if isinstance(norm, colors.MultiNorm) and norm.n_components == n_components:

return norm

raise ValueError(

f"Invalid norm for multivariate colormap with {n_components} inputs")

else: # n_components == 0

raise ValueError(

"""

if accept_multivariate:

types = (colors.Colormap, colors.BivarColormap, colors.MultivarColormap)

mappings = (mpl.colormaps, mpl.multivar_colormaps, mpl.bivar_colormaps)

else:

types = (colors.Colormap, )

mappings = (mpl.colormaps, )

if isinstance(cmap, types):

return cmap

cmap_name = mpl._val_or_rc(cmap, "image.cmap")

for mapping in mappings:

if cmap_name in mapping:

return mapping[cmap_name]

# this error message is a variant of _api.check_in_list but gives

# additional hints as to how to access multivariate colormaps

raise ValueError(_api.list_suggestion_error_msg('cmap', cmap, mpl.colormaps) +

"\nSee `matplotlib.bivar_colormaps()` and"

" `matplotlib.multivar_colormaps()` for"

"""

if isinstance(data, np.ndarray):

if len(data.dtype.descr) == n_components:

# pass scalar data

# and already formatted data

return data

elif data.dtype in [np.complex64, np.complex128]:

if n_components != 2:

raise ValueError("Invalid data entry for multivariate data. "

"Complex numbers are incompatible with "

f"{n_components} variates.")

# pass complex data

if data.dtype == np.complex128:

dt = np.dtype('float64, float64')

else:

dt = np.dtype('float32, float32')

reconstructed = np.ma.array(np.ma.getdata(data).view(dt))

if np.ma.is_masked(data):

for descriptor in dt.descr:

reconstructed[descriptor[0]][data.mask] = np.ma.masked

return reconstructed

if n_components > 1 and len(data) == n_components:

# convert data from shape (n_components, n, m)

# to (n, m) with a new dtype

data = [np.ma.array(part, copy=False) for part in data]

dt = np.dtype(', '.join([f'{part.dtype}' for part in data]))

fields = [descriptor[0] for descriptor in dt.descr]

reconstructed = np.ma.empty(data[0].shape, dtype=dt)

for i, f in enumerate(fields):

if data[i].shape != reconstructed.shape:

raise ValueError("For multivariate data all variates must have same "

f"shape, not {data[0].shape} and {data[i].shape}")

reconstructed[f] = data[i]

if np.ma.is_masked(data[i]):

reconstructed[f][data[i].mask] = np.ma.masked

return reconstructed

if n_components == 1:

# PIL.Image gets passed here

return data

elif n_components == 2:

raise ValueError("Invalid data entry for multivariate data. The data"

" must contain complex numbers, or have a first dimension 2,"

" or be of a dtype with 2 fields")

else:

raise ValueError("Invalid data entry for multivariate data. The shape"

f" of the data must have a first dimension {n_components}"