def testLogarithmicNormalization(self):
"""Test for LogarithmicNormalization"""
normalization = colormap.LogarithmicNormalization()
# relative tolerance is higher because of the log approximation
self._testCodec(normalization, rtol=1e-3)
# Specific extra tests
self.assertTrue(numpy.isnan(normalization.apply(-1., 1., 100.)))
self.assertTrue(numpy.isnan(normalization.apply(numpy.nan, 1., 100.)))
self.assertEqual(normalization.apply(numpy.inf, 1., 100.), numpy.inf)
self.assertEqual(normalization.apply(0, 1., 100.), -numpy.inf)
class Colormap(qt.QObject):
"""Description of a colormap
If no `name` nor `colors` are provided, a default gray LUT is used.
:param str name: Name of the colormap
:param tuple colors: optional, custom colormap.
Nx3 or Nx4 numpy array of RGB(A) colors,
either uint8 or float in [0, 1].
If 'name' is None, then this array is used as the colormap.
:param str normalization: Normalization: 'linear' (default) or 'log'
:param vmin: Lower bound of the colormap or None for autoscale (default)
:type vmin: Union[None, float]
:param vmax: Upper bounds of the colormap or None for autoscale (default)
:type vmax: Union[None, float]
"""
LINEAR = 'linear'
"""constant for linear normalization"""
LOGARITHM = 'log'
"""constant for logarithmic normalization"""
SQRT = 'sqrt'
"""constant for square root normalization"""
GAMMA = 'gamma'
"""Constant for gamma correction normalization"""
ARCSINH = 'arcsinh'
"""constant for inverse hyperbolic sine normalization"""
_BASIC_NORMALIZATIONS = {
LINEAR: _colormap.LinearNormalization(),
LOGARITHM: _colormap.LogarithmicNormalization(),
SQRT: _colormap.SqrtNormalization(),
ARCSINH: _colormap.ArcsinhNormalization(),
}
"""Normalizations without parameters"""
NORMALIZATIONS = LINEAR, LOGARITHM, SQRT, GAMMA, ARCSINH
"""Tuple of managed normalizations"""
MINMAX = 'minmax'
"""constant for autoscale using min/max data range"""
STDDEV3 = 'stddev3'
"""constant for autoscale using mean +/- 3*std(data)
with a clamp on min/max of the data"""
AUTOSCALE_MODES = (MINMAX, STDDEV3)
"""Tuple of managed auto scale algorithms"""
sigChanged = qt.Signal()
"""Signal emitted when the colormap has changed."""
_DEFAULT_NAN_COLOR = 255, 255, 255, 0
def __init__(self, name=None, colors=None, normalization=LINEAR, vmin=None, vmax=None, autoscaleMode=MINMAX):
qt.QObject.__init__(self)
self._editable = True
self.__gamma = 2.0
# Default NaN color: fully transparent white
self.__nanColor = numpy.array(self._DEFAULT_NAN_COLOR, dtype=numpy.uint8)
assert normalization in Colormap.NORMALIZATIONS
assert autoscaleMode in Colormap.AUTOSCALE_MODES
if normalization is Colormap.LOGARITHM:
if (vmin is not None and vmin < 0) or (vmax is not None and vmax < 0):
m = "Unsuported vmin (%s) and/or vmax (%s) given for a log scale."
m += ' Autoscale will be performed.'
m = m % (vmin, vmax)
_logger.warning(m)
vmin = None
vmax = None
self._name = None
self._colors = None
if colors is not None and name is not None:
deprecation.deprecated_warning("Argument",
name="silx.gui.plot.Colors",
reason="name and colors can't be used at the same time",
since_version="0.10.0",
skip_backtrace_count=1)
colors = None
if name is not None:
self.setName(name) # And resets colormap LUT
elif colors is not None:
self.setColormapLUT(colors)
else:
# Default colormap is grey
self.setName("gray")
self._normalization = str(normalization)
self._autoscaleMode = str(autoscaleMode)
self._vmin = float(vmin) if vmin is not None else None
self._vmax = float(vmax) if vmax is not None else None
self.__warnBadVmin = True
self.__warnBadVmax = True
def setFromColormap(self, other):
"""Set this colormap using information from the `other` colormap.
:param ~silx.gui.colors.Colormap other: Colormap to use as reference.
"""
if not self.isEditable():
raise NotEditableError('Colormap is not editable')
if self == other:
return
with blockSignals(self):
name = other.getName()
if name is not None:
self.setName(name)
else:
self.setColormapLUT(other.getColormapLUT())
self.setNaNColor(other.getNaNColor())
self.setNormalization(other.getNormalization())
self.setGammaNormalizationParameter(
other.getGammaNormalizationParameter())
self.setAutoscaleMode(other.getAutoscaleMode())
self.setVRange(*other.getVRange())
self.setEditable(other.isEditable())
self.sigChanged.emit()
def getNColors(self, nbColors=None):
"""Returns N colors computed by sampling the colormap regularly.
:param nbColors:
The number of colors in the returned array or None for the default value.
The default value is the size of the colormap LUT.
:type nbColors: int or None
:return: 2D array of uint8 of shape (nbColors, 4)
:rtype: numpy.ndarray
"""
# Handle default value for nbColors
if nbColors is None:
return numpy.array(self._colors, copy=True)
else:
nbColors = int(nbColors)
colormap = self.copy()
colormap.setNormalization(Colormap.LINEAR)
colormap.setVRange(vmin=0, vmax=nbColors - 1)
colors = colormap.applyToData(
numpy.arange(nbColors, dtype=numpy.int32))
return colors
def getName(self):
"""Return the name of the colormap
:rtype: str
"""
return self._name
def setName(self, name):
"""Set the name of the colormap to use.
:param str name: The name of the colormap.
At least the following names are supported: 'gray',
'reversed gray', 'temperature', 'red', 'green', 'blue', 'jet',
'viridis', 'magma', 'inferno', 'plasma'.
"""
name = str(name)
if self._name == name:
return
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
if name not in self.getSupportedColormaps():
raise ValueError("Colormap name '%s' is not supported" % name)
self._name = name
self._colors = _getColormap(self._name)
self.sigChanged.emit()
def getColormapLUT(self, copy=True):
"""Return the list of colors for the colormap or None if not set.
This returns None if the colormap was set with :meth:`setName`.
Use :meth:`getNColors` to get the colormap LUT for any colormap.
:param bool copy: If true a copy of the numpy array is provided
:return: the list of colors for the colormap or None if not set
:rtype: numpy.ndarray or None
"""
if self._name is None:
return numpy.array(self._colors, copy=copy)
else:
return None
def setColormapLUT(self, colors):
"""Set the colors of the colormap.
:param numpy.ndarray colors: the colors of the LUT.
If float, it is converted from [0, 1] to uint8 range.
Otherwise it is casted to uint8.
.. warning: this will set the value of name to None
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
assert colors is not None
colors = numpy.array(colors, copy=False)
if colors.shape == ():
raise TypeError("An array is expected for 'colors' argument. '%s' was found." % type(colors))
assert len(colors) != 0
assert colors.ndim >= 2
colors.shape = -1, colors.shape[-1]
self._colors = _colormap.array_to_rgba8888(colors)
self._name = None
self.sigChanged.emit()
def getNaNColor(self):
"""Returns the color to use for Not-A-Number floating point value.
:rtype: QColor
"""
return qt.QColor(*self.__nanColor)
def setNaNColor(self, color):
"""Set the color to use for Not-A-Number floating point value.
:param color: RGB(A) color to use for NaN values
:type color: QColor, str, tuple of uint8 or float in [0., 1.]
"""
color = (numpy.array(rgba(color)) * 255).astype(numpy.uint8)
if not numpy.array_equal(self.__nanColor, color):
self.__nanColor = color
self.sigChanged.emit()
def getNormalization(self):
"""Return the normalization of the colormap.
See :meth:`setNormalization` for returned values.
:return: the normalization of the colormap
:rtype: str
"""
return self._normalization
def setNormalization(self, norm):
"""Set the colormap normalization.
Accepted normalizations: 'log', 'linear', 'sqrt'
:param str norm: the norm to set
"""
assert norm in self.NORMALIZATIONS
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
norm = str(norm)
if norm != self._normalization:
self._normalization = norm
self.__warnBadVmin = True
self.__warnBadVmax = True
self.sigChanged.emit()
def setGammaNormalizationParameter(self, gamma: float) -> None:
"""Set the gamma correction parameter.
Only used for gamma correction normalization.
:param float gamma:
:raise ValueError: If gamma is not valid
"""
if gamma < 0. or not numpy.isfinite(gamma):
raise ValueError("Gamma value not supported")
if gamma != self.__gamma:
self.__gamma = gamma
self.sigChanged.emit()
def getGammaNormalizationParameter(self) -> float:
"""Returns the gamma correction parameter value.
:rtype: float
"""
return self.__gamma
def getAutoscaleMode(self):
"""Return the autoscale mode of the colormap ('minmax' or 'stddev3')
:rtype: str
"""
return self._autoscaleMode
def setAutoscaleMode(self, mode):
"""Set the autoscale mode: either 'minmax' or 'stddev3'
:param str mode: the mode to set
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
assert mode in self.AUTOSCALE_MODES
if mode != self._autoscaleMode:
self._autoscaleMode = mode
self.sigChanged.emit()
def isAutoscale(self):
"""Return True if both min and max are in autoscale mode"""
return self._vmin is None and self._vmax is None
def getVMin(self):
"""Return the lower bound of the colormap
:return: the lower bound of the colormap
:rtype: float or None
"""
return self._vmin
def setVMin(self, vmin):
"""Set the minimal value of the colormap
:param float vmin: Lower bound of the colormap or None for autoscale
(default)
value)
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
if vmin is not None:
if self._vmax is not None and vmin > self._vmax:
err = "Can't set vmin because vmin >= vmax. " \
"vmin = %s, vmax = %s" % (vmin, self._vmax)
raise ValueError(err)
if vmin != self._vmin:
self._vmin = vmin
self.__warnBadVmin = True
self.sigChanged.emit()
def getVMax(self):
"""Return the upper bounds of the colormap or None
:return: the upper bounds of the colormap or None
:rtype: float or None
"""
return self._vmax
def setVMax(self, vmax):
"""Set the maximal value of the colormap
:param float vmax: Upper bounds of the colormap or None for autoscale
(default)
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
if vmax is not None:
if self._vmin is not None and vmax < self._vmin:
err = "Can't set vmax because vmax <= vmin. " \
"vmin = %s, vmax = %s" % (self._vmin, vmax)
raise ValueError(err)
if vmax != self._vmax:
self._vmax = vmax
self.__warnBadVmax = True
self.sigChanged.emit()
def isEditable(self):
""" Return if the colormap is editable or not
:return: editable state of the colormap
:rtype: bool
"""
return self._editable
def setEditable(self, editable):
"""
Set the editable state of the colormap
:param bool editable: is the colormap editable
"""
assert type(editable) is bool
self._editable = editable
self.sigChanged.emit()
def _getNormalizer(self):
"""Returns normalizer object"""
normalization = self.getNormalization()
if normalization == self.GAMMA:
return _colormap.GammaNormalization(self.getGammaNormalizationParameter())
else:
return self._BASIC_NORMALIZATIONS[normalization]
def _computeAutoscaleRange(self, data):
"""Compute the data range which will be used in autoscale mode.
:param numpy.ndarray data: The data for which to compute the range
:return: (vmin, vmax) range
"""
return self._getNormalizer().autoscale(
data, mode=self.getAutoscaleMode())
def getColormapRange(self, data=None):
"""Return (vmin, vmax) the range of the colormap for the given data or item.
:param Union[numpy.ndarray,~silx.gui.plot.items.ColormapMixIn] data:
The data or item to use for autoscale bounds.
:return: (vmin, vmax) corresponding to the colormap applied to data if provided.
:rtype: tuple
"""
vmin = self._vmin
vmax = self._vmax
assert vmin is None or vmax is None or vmin <= vmax # TODO handle this in setters
normalizer = self._getNormalizer()
# Handle invalid bounds as autoscale
if vmin is not None and not normalizer.is_valid(vmin):
if self.__warnBadVmin:
self.__warnBadVmin = False
_logger.info(
'Invalid vmin, switching to autoscale for lower bound')
vmin = None
if vmax is not None and not normalizer.is_valid(vmax):
if self.__warnBadVmax:
self.__warnBadVmax = False
_logger.info(
'Invalid vmax, switching to autoscale for upper bound')
vmax = None
if vmin is None or vmax is None: # Handle autoscale
from .plot.items.core import ColormapMixIn # avoid cyclic import
if isinstance(data, ColormapMixIn):
min_, max_ = data._getColormapAutoscaleRange(self)
# Make sure min_, max_ are not None
min_ = normalizer.DEFAULT_RANGE[0] if min_ is None else min_
max_ = normalizer.DEFAULT_RANGE[1] if max_ is None else max_
else:
min_, max_ = normalizer.autoscale(
data, mode=self.getAutoscaleMode())
if vmin is None: # Set vmin respecting provided vmax
vmin = min_ if vmax is None else min(min_, vmax)
if vmax is None:
vmax = max(max_, vmin) # Handle max_ <= 0 for log scale
return vmin, vmax
def getVRange(self):
"""Get the bounds of the colormap
:rtype: Tuple(Union[float,None],Union[float,None])
:returns: A tuple of 2 values for min and max. Or None instead of float
for autoscale
"""
return self.getVMin(), self.getVMax()
def setVRange(self, vmin, vmax):
"""Set the bounds of the colormap
:param vmin: Lower bound of the colormap or None for autoscale
(default)
:param vmax: Upper bounds of the colormap or None for autoscale
(default)
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
if vmin is not None and vmax is not None:
if vmin > vmax:
err = "Can't set vmin and vmax because vmin >= vmax " \
"vmin = %s, vmax = %s" % (vmin, vmax)
raise ValueError(err)
if self._vmin == vmin and self._vmax == vmax:
return
if vmin != self._vmin:
self.__warnBadVmin = True
self._vmin = vmin
if vmax != self._vmax:
self.__warnBadVmax = True
self._vmax = vmax
self.sigChanged.emit()
def __getitem__(self, item):
if item == 'autoscale':
return self.isAutoscale()
elif item == 'name':
return self.getName()
elif item == 'normalization':
return self.getNormalization()
elif item == 'vmin':
return self.getVMin()
elif item == 'vmax':
return self.getVMax()
elif item == 'colors':
return self.getColormapLUT()
elif item == 'autoscaleMode':
return self.getAutoscaleMode()
else:
raise KeyError(item)
def _toDict(self):
"""Return the equivalent colormap as a dictionary
(old colormap representation)
:return: the representation of the Colormap as a dictionary
:rtype: dict
"""
return {
'name': self._name,
'colors': self.getColormapLUT(),
'vmin': self._vmin,
'vmax': self._vmax,
'autoscale': self.isAutoscale(),
'normalization': self.getNormalization(),
'autoscaleMode': self.getAutoscaleMode(),
}
def _setFromDict(self, dic):
"""Set values to the colormap from a dictionary
:param dict dic: the colormap as a dictionary
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
name = dic['name'] if 'name' in dic else None
colors = dic['colors'] if 'colors' in dic else None
if name is not None and colors is not None:
if isinstance(colors, int):
# Filter out argument which was supported but never used
_logger.info("Unused 'colors' from colormap dictionary filterer.")
colors = None
vmin = dic['vmin'] if 'vmin' in dic else None
vmax = dic['vmax'] if 'vmax' in dic else None
if 'normalization' in dic:
normalization = dic['normalization']
else:
warn = 'Normalization not given in the dictionary, '
warn += 'set by default to ' + Colormap.LINEAR
_logger.warning(warn)
normalization = Colormap.LINEAR
if name is None and colors is None:
err = 'The colormap should have a name defined or a tuple of colors'
raise ValueError(err)
if normalization not in Colormap.NORMALIZATIONS:
err = 'Given normalization is not recognized (%s)' % normalization
raise ValueError(err)
autoscaleMode = dic.get('autoscaleMode', Colormap.MINMAX)
if autoscaleMode not in Colormap.AUTOSCALE_MODES:
err = 'Given autoscale mode is not recognized (%s)' % autoscaleMode
raise ValueError(err)
# If autoscale, then set boundaries to None
if dic.get('autoscale', False):
vmin, vmax = None, None
if name is not None:
self.setName(name)
else:
self.setColormapLUT(colors)
self._vmin = vmin
self._vmax = vmax
self._autoscale = True if (vmin is None and vmax is None) else False
self._normalization = normalization
self._autoscaleMode = autoscaleMode
self.__warnBadVmin = True
self.__warnBadVmax = True
self.sigChanged.emit()
@staticmethod
def _fromDict(dic):
colormap = Colormap()
colormap._setFromDict(dic)
return colormap
def copy(self):
"""Return a copy of the Colormap.
:rtype: silx.gui.colors.Colormap
"""
colormap = Colormap(name=self._name,
colors=self.getColormapLUT(),
vmin=self._vmin,
vmax=self._vmax,
normalization=self.getNormalization(),
autoscaleMode=self.getAutoscaleMode())
colormap.setNaNColor(self.getNaNColor())
colormap.setGammaNormalizationParameter(
self.getGammaNormalizationParameter())
colormap.setEditable(self.isEditable())
return colormap
def applyToData(self, data, reference=None):
"""Apply the colormap to the data
:param Union[numpy.ndarray,~silx.gui.plot.item.ColormapMixIn] data:
The data to convert or the item for which to apply the colormap.
:param Union[numpy.ndarray,~silx.gui.plot.item.ColormapMixIn,None] reference:
The data or item to use as reference to compute autoscale
"""
if reference is None:
reference = data
vmin, vmax = self.getColormapRange(reference)
if hasattr(data, "getColormappedData"): # Use item's data
data = data.getColormappedData(copy=False)
return _colormap.cmap(
data,
self._colors,
vmin,
vmax,
self._getNormalizer(),
self.__nanColor)
@staticmethod
def getSupportedColormaps():
"""Get the supported colormap names as a tuple of str.
The list should at least contain and start by:
('gray', 'reversed gray', 'temperature', 'red', 'green', 'blue',
'viridis', 'magma', 'inferno', 'plasma')
:rtype: tuple
"""
registered_colormaps = _colormap.get_registered_colormaps()
colormaps = set(registered_colormaps)
if _matplotlib_colormaps is not None:
colormaps.update(_matplotlib_colormaps())
# Put registered_colormaps first
colormaps = tuple(cmap for cmap in sorted(colormaps)
if cmap not in registered_colormaps)
return registered_colormaps + colormaps
def __str__(self):
return str(self._toDict())
def __eq__(self, other):
"""Compare colormap values and not pointers"""
if other is None:
return False
if not isinstance(other, Colormap):
return False
if self.getNormalization() != other.getNormalization():
return False
if self.getNormalization() == self.GAMMA:
delta = self.getGammaNormalizationParameter() - other.getGammaNormalizationParameter()
if abs(delta) > 0.001:
return False
return (self.getName() == other.getName() and
self.getAutoscaleMode() == other.getAutoscaleMode() and
self.getVMin() == other.getVMin() and
self.getVMax() == other.getVMax() and
numpy.array_equal(self.getColormapLUT(), other.getColormapLUT())
)
_SERIAL_VERSION = 3
def restoreState(self, byteArray):
"""
Read the colormap state from a QByteArray.
:param qt.QByteArray byteArray: Stream containing the state
:return: True if the restoration sussseed
:rtype: bool
"""
if self.isEditable() is False:
raise NotEditableError('Colormap is not editable')
stream = qt.QDataStream(byteArray, qt.QIODevice.ReadOnly)
className = stream.readQString()
if className != self.__class__.__name__:
_logger.warning("Classname mismatch. Found %s." % className)
return False
version = stream.readUInt32()
if version not in numpy.arange(1, self._SERIAL_VERSION+1):
_logger.warning("Serial version mismatch. Found %d." % version)
return False
name = stream.readQString()
isNull = stream.readBool()
if not isNull:
vmin = stream.readQVariant()
else:
vmin = None
isNull = stream.readBool()
if not isNull:
vmax = stream.readQVariant()
else:
vmax = None
normalization = stream.readQString()
if normalization == Colormap.GAMMA:
gamma = stream.readFloat()
else:
gamma = None
if version == 1:
autoscaleMode = Colormap.MINMAX
else:
autoscaleMode = stream.readQString()
if version <= 2:
nanColor = self._DEFAULT_NAN_COLOR
else:
nanColor = stream.readInt32(), stream.readInt32(), stream.readInt32(), stream.readInt32()
# emit change event only once
old = self.blockSignals(True)
try:
self.setName(name)
self.setNormalization(normalization)
self.setAutoscaleMode(autoscaleMode)
self.setVRange(vmin, vmax)
if gamma is not None:
self.setGammaNormalizationParameter(gamma)
self.setNaNColor(nanColor)
finally:
self.blockSignals(old)
self.sigChanged.emit()
return True
def saveState(self):
"""
Save state of the colomap into a QDataStream.
:rtype: qt.QByteArray
"""
data = qt.QByteArray()
stream = qt.QDataStream(data, qt.QIODevice.WriteOnly)
stream.writeQString(self.__class__.__name__)
stream.writeUInt32(self._SERIAL_VERSION)
stream.writeQString(self.getName())
stream.writeBool(self.getVMin() is None)
if self.getVMin() is not None:
stream.writeQVariant(self.getVMin())
stream.writeBool(self.getVMax() is None)
if self.getVMax() is not None:
stream.writeQVariant(self.getVMax())
stream.writeQString(self.getNormalization())
if self.getNormalization() == Colormap.GAMMA:
stream.writeFloat(self.getGammaNormalizationParameter())
stream.writeQString(self.getAutoscaleMode())
nanColor = self.getNaNColor()
stream.writeInt32(nanColor.red())
stream.writeInt32(nanColor.green())
stream.writeInt32(nanColor.blue())
stream.writeInt32(nanColor.alpha())
return data
class TestColormap(ParametricTestCase):
"""Test silx.math.colormap.cmap"""
NORMALIZATIONS = ('linear', 'log', 'arcsinh', 'sqrt',
colormap.LinearNormalization(),
colormap.LogarithmicNormalization(),
colormap.PowerNormalization(2.),
colormap.PowerNormalization(0.5))
@staticmethod
def ref_colormap(data, colors, vmin, vmax, normalization, nan_color):
"""Reference implementation of colormap
:param numpy.ndarray data: Data to convert
:param numpy.ndarray colors: Color look-up-table
:param float vmin: Lower bound of the colormap range
:param float vmax: Upper bound of the colormap range
:param str normalization: Normalization to use
:param Union[numpy.ndarray, None] nan_color: Color to use for NaN
"""
norm_functions = {
'linear': lambda v: v,
'log': numpy.log10,
'arcsinh': numpy.arcsinh,
'sqrt': numpy.sqrt
}
if isinstance(normalization, str):
norm_function = norm_functions[normalization]
else:
def norm_function(value):
return normalization.apply(value, vmin, vmax)
with numpy.errstate(divide='ignore', invalid='ignore'):
# Ignore divide by zero and invalid value encountered in log10, sqrt
norm_data, vmin, vmax = map(norm_function, (data, vmin, vmax))
if normalization == 'arcsinh' and sys.platform == 'win32':
# There is a difference of behavior of numpy.arcsinh
# between Windows and other OS for results of infinite values
# This makes Windows behaves as Linux and MacOS
norm_data[data == numpy.inf] = numpy.inf
norm_data[data == -numpy.inf] = -numpy.inf
nb_colors = len(colors)
scale = nb_colors / (vmax - vmin)
# Substraction must be done in float to avoid overflow with uint
indices = numpy.clip(scale * (norm_data - float(vmin)), 0,
nb_colors - 1)
indices[numpy.isnan(indices)] = nb_colors # Use an extra index for NaN
indices = indices.astype('uint')
# Add NaN color to array
if nan_color is None:
nan_color = (0, ) * colors.shape[-1]
colors = numpy.append(colors, numpy.atleast_2d(nan_color), axis=0)
return colors[indices]
def _test(self, data, colors, vmin, vmax, normalization, nan_color):
"""Run test of colormap against alternative implementation
:param numpy.ndarray data: Data to convert
:param numpy.ndarray colors: Color look-up-table
:param float vmin: Lower bound of the colormap range
:param float vmax: Upper bound of the colormap range
:param str normalization: Normalization to use
:param Union[numpy.ndarray, None] nan_color: Color to use for NaN
"""
image = colormap.cmap(data, colors, vmin, vmax, normalization,
nan_color)
ref_image = self.ref_colormap(data, colors, vmin, vmax, normalization,
nan_color)
self.assertTrue(numpy.allclose(ref_image, image))
self.assertEqual(image.dtype, colors.dtype)
self.assertEqual(image.shape, data.shape + (colors.shape[-1], ))
def test(self):
"""Test all dtypes with finite data
Test all supported types and endianness
"""
colors = numpy.zeros((256, 4), dtype=numpy.uint8)
colors[:, 0] = numpy.arange(len(colors))
colors[:, 3] = 255
# Generates (u)int and floats types
dtypes = [
e + k + i for e in '<>' for k in 'uif' for i in '1248'
if k != 'f' or i != '1'
]
dtypes.append(numpy.dtype(numpy.longdouble).name) # Add long double
for normalization in self.NORMALIZATIONS:
for dtype in dtypes:
with self.subTest(dtype=dtype, normalization=normalization):
_logger.info('normalization: %s, dtype: %s', normalization,
dtype)
data = numpy.arange(-5, 15, dtype=dtype).reshape(4, 5)
self._test(data, colors, 1, 10, normalization, None)
def test_not_finite(self):
"""Test float data with not finite values"""
colors = numpy.zeros((256, 4), dtype=numpy.uint8)
colors[:, 0] = numpy.arange(len(colors))
colors[:, 3] = 255
test_data = { # message: data
'no finite values': (float('inf'), float('-inf'), float('nan')),
'only NaN': (float('nan'), float('nan'), float('nan')),
'mix finite/not finite': (float('inf'), float('-inf'), 1., float('nan')),
}
for normalization in self.NORMALIZATIONS:
for msg, data in test_data.items():
with self.subTest(msg, normalization=normalization):
_logger.info('normalization: %s, %s', normalization, msg)
data = numpy.array(data, dtype=numpy.float64)
self._test(data, colors, 1, 10, normalization,
(0, 0, 0, 0))
def test_errors(self):
"""Test raising exception for bad vmin, vmax, normalization parameters
"""
colors = numpy.zeros((256, 4), dtype=numpy.uint8)
colors[:, 0] = numpy.arange(len(colors))
colors[:, 3] = 255
data = numpy.arange(10, dtype=numpy.float64)
test_params = [ # (vmin, vmax, normalization)
(-1., 2., 'log'),
(0., 1., 'log'),
(1., 0., 'log'),
(-1., 1., 'sqrt'),
(1., -1., 'sqrt'),
]
for vmin, vmax, normalization in test_params:
with self.subTest(vmin=vmin,
vmax=vmax,
normalization=normalization):
_logger.info('normalization: %s, range: [%f, %f]',
normalization, vmin, vmax)
with self.assertRaises(ValueError):
self._test(data, colors, vmin, vmax, normalization, None)