Sure, let me focus just on the interpolation and I'll leave the
filtering issue out.
In the script below, I plot a 3x3 array with the center element having
an "over" value. In the default case, because its value is over, the
colormap will assign it the maximum color. I also plot the case when
the "over" color is explicitly set to the minimum color and also to
white. What I want is this:
The center element should be an equal mixture of the 4 elements around it.
This is partially achieved with "white" (and I suppose I could pick
"grey" or "black"), but I think it might be nicer if it were a pure
mixture, rather than a mixture of the surrounding colors and the
"over" color.
The script is attached below. Sorry it is a bit long, but I needed a
discrete colormap. Can we get cmap_discrete() into matplotlib?
···
On Thu, May 27, 2010 at 3:23 PM, Eric Firing <efiring@...202...> wrote:
I'm not sure I understand the problem; could you provide a tiny example
to illustrate?
------------------
import matplotlib.pyplot as plt
import matplotlib.colors
import numpy as np
from scipy import interpolate
#### http://www.scipy.org/Cookbook/Matplotlib/ColormapTransformations
#### Can this be added to matplotlib?
def cmap_discretize(cmap, N):
"""Return a discrete colormap from the continuous colormap cmap.
cmap: colormap instance, eg. cm.jet.
N: Number of colors.
Example
x = resize(arange(100), (5,100))
djet = cmap_discretize(cm.jet, 5)
imshow(x, cmap=djet)
"""
cdict = cmap._segmentdata.copy()
# N colors
colors_i = np.linspace(0,1.,N)
# N+1 indices
indices = np.linspace(0,1.,N+1)
for key in ('red','green','blue'):
# Find the N colors
D = np.array(cdict[key])
I = interpolate.interp1d(D[:,0], D[:,1])
colors = I(colors_i)
# Place these colors at the correct indices.
A = np.zeros((N+1,3), float)
A[:,0] = indices
A[1:,1] = colors
A[:-1,2] = colors
# Create a tuple for the dictionary.
L =
for l in A:
L.append(tuple(l))
cdict[key] = tuple(L)
# Return colormap object.
return matplotlib.colors.LinearSegmentedColormap('colormap',cdict,1024)
def draw(m, cm, norm, ncolors):
ax = plt.gca()
ai = ax.imshow(m, cmap=cm, norm=norm, interpolation='gaussian')
cb = ax.figure.colorbar(ai)
cb.set_ticks(np.linspace(.5, ncolors-.5, ncolors))
cb.set_ticklabels(['%s' % (i,) for i in np.arange(ncolors)])
return ai, cb
if __name__ == '__main__':
ncolors = 4
norm = plt.Normalize(vmax=ncolors)
m = np.array([[0, 0, 1],
[3, 10, 1],
[3, 2, 2]])
for over in [None, 'min', (1,1,1,1)]:
f = plt.figure()
cm = cmap_discretize(plt.cm.jet, ncolors)
if over == 'min':
cm.set_over(cm(0.0))
elif over is not None:
cm.set_over(over)
ai, cb = draw(m, cm, norm, ncolors)
plt.show()