"""

cmap_d = {**cmaps_listed}

for name, spec in datad.items():

cmap_d[name] = ( # Precache the cmaps at a fixed lutsize..

colors.LinearSegmentedColormap(name, spec, _LUTSIZE)

if 'red' in spec else

colors.ListedColormap(spec['listed'], name)

if 'listed' in spec else

colors.LinearSegmentedColormap.from_list(name, spec, _LUTSIZE))

# Register colormap aliases for gray and grey.

cmap_d['grey'] = cmap_d['gray']

cmap_d['gist_grey'] = cmap_d['gist_gray']

cmap_d['gist_yerg'] = cmap_d['gist_yarg']

cmap_d['Grays'] = cmap_d['Greys']

# Generate reversed cmaps.

for cmap in list(cmap_d.values()):

rmap = cmap.reversed()

cmap_d[rmap.name] = rmap

r"""

def __init__(self, cmaps):

self._cmaps = cmaps

self._builtin_cmaps = tuple(cmaps)

# A shim to allow register_cmap() to force an override

self._allow_override_builtin = False

def __getitem__(self, item):

try:

return self._cmaps[item].copy()

except KeyError:

raise KeyError(f"{item!r} is not a known colormap name") from None

def __iter__(self):

return iter(self._cmaps)

def __len__(self):

return len(self._cmaps)

def __str__(self):

return ('ColormapRegistry; available colormaps:\n' +

', '.join(f"'{name}'" for name in self))

def __call__(self):

"""

return list(self)

def register(self, cmap, *, name=None, force=False):

"""

_api.check_isinstance(colors.Colormap, cmap=cmap)

name = name or cmap.name

if name in self:

if not force:

# don't allow registering an already existing cmap

# unless explicitly asked to

raise ValueError(

f'A colormap named "{name}" is already registered.')

elif (name in self._builtin_cmaps

and not self._allow_override_builtin):

# We don't allow overriding a builtin unless privately

# coming from register_cmap()

raise ValueError("Re-registering the builtin cmap "

f"{name!r} is not allowed.")

# Warn that we are updating an already existing colormap

_api.warn_external(f"Overwriting the cmap {name!r} "

"that was already in the registry.")

self._cmaps[name] = cmap.copy()

# Someone may set the extremes of a builtin colormap and want to register it

# with a different name for future lookups. The object would still have the

# builtin name, so we should update it to the registered name

if self._cmaps[name].name != name:

self._cmaps[name].name = name

def unregister(self, name):

"""

if name in self._builtin_cmaps:

raise ValueError(f"cannot unregister {name!r} which is a builtin "

"colormap.")

self._cmaps.pop(name, None)

def get_cmap(self, cmap):

"""

# get the default color map

if cmap is None:

return self[mpl.rcParams["image.cmap"]]

# if the user passed in a Colormap, simply return it

if isinstance(cmap, colors.Colormap):

return cmap

if isinstance(cmap, str):

_api.check_in_list(sorted(_colormaps), cmap=cmap)

# otherwise, it must be a string so look it up

return self[cmap]

raise TypeError(

'get_cmap expects None or an instance of a str or Colormap . ' +

f'you passed {cmap!r} of type {type(cmap)}'

"""

_api.check_isinstance((str, None), name=name)

if name is None:

try:

name = cmap.name

except AttributeError as err:

raise ValueError("Arguments must include a name or a "

"Colormap") from err

# override_builtin is allowed here for backward compatibility

# this is just a shim to enable that to work privately in

# the global ColormapRegistry

_colormaps._allow_override_builtin = override_builtin

_colormaps.register(cmap, name=name, force=override_builtin)

"""

if name is None:

name = mpl.rcParams['image.cmap']

if isinstance(name, colors.Colormap):

return name

_api.check_in_list(sorted(_colormaps), name=name)

if lut is None:

return _colormaps[name]

else:

'3.7',

name='get_cmap',

alternative=(

"``matplotlib.colormaps[name]`` " +

"or ``matplotlib.colormaps.get_cmap(obj)``"

)

"""

cmap = _colormaps.get(name, None)

_colormaps.unregister(name)

"""

# 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)()

"""

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

"""

self._A = None

self._norm = None # So that the setter knows we're initializing.

self.set_norm(norm) # The Normalize instance of this ScalarMappable.

self.cmap = None # So that the setter knows we're initializing.

self.set_cmap(cmap) # The Colormap instance of this ScalarMappable.

#: The last colorbar associated with this ScalarMappable. May be None.

self.colorbar = None

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

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

"""

if vmin is not None or vmax is not None:

self.set_clim(vmin, vmax)

if isinstance(norm, colors.Normalize):

raise ValueError(

"Passing a Normalize instance simultaneously with "

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

"directly to the norm when creating it.")

# always resolve the autoscaling so we have concrete limits

# rather than deferring to draw time.

self.autoscale_None()

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

"""

# First check for special case, image input:

try:

if x.ndim == 3:

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 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

except AttributeError:

# e.g., x is not an ndarray; so try mapping it

pass

# This is the normal case, mapping a scalar array:

x = ma.asarray(x)

if norm:

x = self.norm(x)

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

return rgba

def set_array(self, A):

"""

if A is None:

self._A = None

return

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

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

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

"converted to float")

self._A = A

def get_array(self):

"""

return self._A

def get_cmap(self):

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

return self.cmap

def get_clim(self):

"""

return self.norm.vmin, self.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 vmax is None:

try:

vmin, vmax = vmin

except (TypeError, ValueError):

pass

if vmin is not None:

self.norm.vmin = colors._sanitize_extrema(vmin)

if vmax is not None:

self.norm.vmax = colors._sanitize_extrema(vmax)

def get_alpha(self):

"""

# This method is intended to be overridden by Artist sub-classes

return 1.

def set_cmap(self, cmap):

"""

in_init = self.cmap is None

self.cmap = _ensure_cmap(cmap)

if not in_init:

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

@property

def norm(self):

return self._norm

@norm.setter

def norm(self, norm):

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

if norm is None:

norm = colors.Normalize()

elif isinstance(norm, str):

try:

scale_cls = scale._scale_mapping[norm]

except KeyError:

raise ValueError(

"Invalid norm str name; the following values are "

f"supported: {', '.join(scale._scale_mapping)}"

) from None

norm = _auto_norm_from_scale(scale_cls)()

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 set_norm(self, norm):

"""

self.norm = norm

def autoscale(self):

"""

if self._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(self._A)

def autoscale_None(self):

"""

if self._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(self._A)

def changed(self):

"""

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

"""

if isinstance(cmap, colors.Colormap):

return cmap

cmap_name = cmap if cmap is not None else mpl.rcParams["image.cmap"]

# use check_in_list to ensure type stability of the exception raised by

# the internal usage of this (ValueError vs KeyError)

if cmap_name not in _colormaps:

_api.check_in_list(sorted(_colormaps), cmap=cmap_name)