Allow user to not interpolate colours

[gerritholl]

Feature Request

Is your feature request related to a problem? Please describe.

In data visualisation, it is often appropriate to limit the number of data classes. This makes it easier for the user to read data values. For example, colorbrewer recommends to use between 3 and 9 data classes. But in trollimage, if we apply a colormap with a small number of data classes, it interpolates between the colours:

import numpy as np
import matplotlib.colors
import matplotlib.pyplot as plt
import xarray as xr
from trollimage.colormap import Colormap
from trollimage.xrimage import XRImage
my_cmap = matplotlib.colors.ListedColormap([[1, 1, .8], [.8, .9, .75], [.75, .9, .5], [.5, .85, .3], [0, 0.5, 0.2]])
data = np.linspace(0.4, 1, 500*500).reshape(500, 500)
ax = plt.axes()
plt.imshow(data, cmap=my_cmap)
plt.savefig("image-mpl.png")

tcm_rh=Colormap(colors=my_cmap.colors, values=np.linspace(0.4, 1, len(my_cmap.colors)))
im = XRImage(xr.DataArray(data, dims=("y", "x")))
im.colorize(tcm_rh)
im.rio_save("image-trollimage.png")

Output matplotlib:

Output trollimage:

The decision to interpolate is hardcoded in trollimage and cannot currently be disabled:

trollimage/trollimage/colormap.py

Lines 93 to 99 in 5a3fb0c

	def _colorize(arr, colors, values):
	"""Colorize the array."""
	channels = _interpolate_rgb_colors(arr, colors, values)
	alpha = _interpolate_alpha(arr, colors, values)
	channels.extend(alpha)
	channels = _mask_channels(channels, arr)
	return np.stack(channels, axis=0)

Describe the solution you'd like

I would like that trollimage allows to not interpolate the colors in a colormap.

Describe any changes to existing user workflow

The default would be the status quo.

Additional context

A workaround would be to create a colormap where colours are repeated for different values.

[djhoese]

Yes, repeating colors and depending on floating point precision in the "values" of the colormap (I refer to these as control points) is the best workaround so far. For example:

0.000 -> (0, 0, 0)
0.200 -> (0, 0, 0)
0.200001 -> (1, 0, 0)
0.400 -> (1, 0, 0)
0.400001 -> (0, 1, 0)
...

I've always wanted a discrete colormap but felt like it was "shaking things up" too much. A separate class or classes would be really nice and easy to not break backwards compatibility. Or a kwarg and property (to check if a colormap is discrete) would be nice if it wasn't too hard to update existing code using Colormaps.

[mraspaud]

but we have palettize for that, don't we? https://trollimage.readthedocs.io/en/latest/api/trollimage.html#trollimage.colormap.Colormap.palettize

[gerritholl]

As far as I know, the only difference between palettize and colorize is that palettize produces a mode P image and colorize a mode RGB image. Mode P or mode RGB is orthogonal to interpolating colours or not.

[pnuu]

I have a feeling somewhere in the past palettize didn't produce P mode images but uninterpolated colorization 🤔

[gerritholl]

It does look like palettize indeed avoids interpolation. I don't think this difference is documented. So then another workaround is for someone to use palettize and then save the resulting image with keep_palette=False, which is the default.

[pnuu]

The change I was thinking of was done here: #39

So indeed, keep_palette=False should solve the discrete colors by using palettize instead of colorize.

[djhoese]

Ah that was my student progranmer. I still think colorize versus palettize doesn't describe the colormap but how it is applied. In that case the same colormap means 2 things.

[pnuu]

Colorization changes the palette by interpolating the values, while palettize applies it as-is, so strictly the same palette is not applied in the two use cases.

[gerritholl]

I don't find it intuitive that colorize produces RGB with interpolation, and palettize produced P without interpolation, that can be converted to RGB upon writing.

Interpolation	Mode	colorize/palettize	keep_palette
No	RGB	palettize	False
No	P	palettize	True
Yes	RGB	colorize	True
Yes	P	not possible	not possible

Displayed differently

Interpolation/Mode	Interpolated	Not interpolated
RGB	colorize	palettize, keep_palette=False
P	not possible?	palettize, keep_palette=True

It would be more intuitive to have flags for interpolate=True/False and mode=RGB/P, where in the second case hopefully without a need to repeat the palette instruction when saving.

[pnuu]

Historically, since mpop times, their only difference was the interpolation vs. no interpolation. Both returned RGB composites until the linked PR.

[gerritholl]

Historically, since mpop times, their only difference was the interpolation vs. no interpolation. Both returned RGB composites until the linked PR.

I see. That is not clear from the documentation. I've always used colorize when I wanted a RGB and palettize when I wanted a P.