Range values to pseudocolor
Solution 1:
You could write your own function that converted the values 0…100 → 0…120 degrees and then used that value as the H (or angle) of a color in the HSV (or HLS) colorspace. This could then be converted into an RGB color for display purposes. Linearly interpreted colors often look better when they're calculated in this colorspace: Here's what HSV colorspace looks like:
Update:
Good news, I was pleasantly surprised to discover that Python has colorspace conversion routines in its built-in colorsys module (they really mean "batteries included"). What's nice about that is that it makes creating a function that does what I described fairly easy, as illustrated below:
from colorsys import hsv_to_rgb
def pseudocolor(val, minval, maxval):
""" Convert val in range minval..maxval to the range 0..120 degrees which
correspond to the colors Red and Green in the HSV colorspace.
"""
h = (float(val-minval) / (maxval-minval)) * 120
# Convert hsv color (h,1,1) to its rgb equivalent.
# Note: hsv_to_rgb() function expects h to be in the range 0..1 not 0..360
r, g, b = hsv_to_rgb(h/360, 1., 1.)
return r, g, b
if __name__ == '__main__':
steps = 10
print('val R G B')
for val in range(0, 100+steps, steps):
print('{:3d} -> ({:.3f}, {:.3f}, {:.3f})'.format(
val, *pseudocolor(val, 0, 100)))
Output:
val R G B
0 -> (1.000, 0.000, 0.000)
10 -> (1.000, 0.200, 0.000)
20 -> (1.000, 0.400, 0.000)
30 -> (1.000, 0.600, 0.000)
40 -> (1.000, 0.800, 0.000)
50 -> (1.000, 1.000, 0.000)
60 -> (0.800, 1.000, 0.000)
70 -> (0.600, 1.000, 0.000)
80 -> (0.400, 1.000, 0.000)
90 -> (0.200, 1.000, 0.000)
100 -> (0.000, 1.000, 0.000)
Here's a sample showing what its output looks like:
I think you may find the colors generated nicer than in my other answer.
Generalizing:
It's possible to modify this function to be a little more generic in the sense that it will work with colors other then just the Red and Green currently hardcoded into it.
Here's how to do that:
def pseudocolor(val, minval, maxval, start_hue, stop_hue):
""" Convert val in range minval..maxval to the range start_hue..stop_hue
degrees in the HSV colorspace.
"""
h = (float(val-minval) / (maxval-minval)) * (stop_hue-start_hue) + start_hue
# Convert hsv color (h,1,1) to its rgb equivalent.
# Note: hsv_to_rgb() function expects h to be in the range 0..1 not 0..360
r, g, b = hsv_to_rgb(h/360, 1., 1.)
return r, g, b
if __name__ == '__main__':
# angles of common colors in hsv colorspace
RED, YELLOW, GREEN, CYAN, BLUE, MAGENTA = range(0, 360, 60)
steps = 10
print('val R G B')
for val in range(0, 100+steps, steps):
print('{:3d} -> ({:.3f}, {:.3f}, {:.3f})'.format(
val, *pseudocolor(val, 0, 100, YELLOW, BLUE)))
Results:
Solution 2:
While arguably not as pretty as interpolating H in the HLS or HSV colorspace, a much simpler to implement approach would be to write a function that mapped the single value into three components corresponding to a linearly-interpolated color between completely red (1,0,0) and completely green (0,1,0) in the RGB colorspace.
Here's what I mean:
def pseudocolor(val, minval, maxval):
""" Convert value in the range minval...maxval to a color between red
and green.
"""
f = float(val-minval) / (maxval-minval)
r, g, b = 1-f, f, 0.
return r, g, b
if __name__ == '__main__':
steps = 10
print('val R G B')
for val in xrange(0, 100+steps, steps):
print('{:3d} -> ({:.3f}, {:.3f}, {:.3f})'.format(
val, *pseudocolor(val, 0, 100)))
Output:
val R G B
0 -> (1.000, 0.000, 0.000)
10 -> (0.900, 0.100, 0.000)
20 -> (0.800, 0.200, 0.000)
30 -> (0.700, 0.300, 0.000)
40 -> (0.600, 0.400, 0.000)
50 -> (0.500, 0.500, 0.000)
60 -> (0.400, 0.600, 0.000)
70 -> (0.300, 0.700, 0.000)
80 -> (0.200, 0.800, 0.000)
90 -> (0.100, 0.900, 0.000)
100 -> (0.000, 1.000, 0.000)
You can transform the floating-point r,g,b components as needed, such as to integers in the range of 0..255.
Here's a sample showing what its output looks like:
If you want to go from green to red, just reverse the calculations for r and g in the function. Without too much additional effort, you could generalize the concept to allow linear-interpolation between any two given colors.
Here's how that could be done:
def pseudocolor(val, minval, maxval, startcolor, stopcolor):
""" Convert value in the range minval...maxval to a color in the range
startcolor to stopcolor. The colors passed and the the one returned are
composed of a sequence of N component values.
"""
f = float(val-minval) / (maxval-minval)
return tuple(f*(b-a)+a for (a, b) in zip(startcolor, stopcolor))
if __name__ == '__main__':
YELLOW, BLUE = (1, 1, 0), (0, 0, 1)
steps = 10
print('val R G B')
for val in range(0, 100+steps, steps):
print('{:3d} -> ({:.3f}, {:.3f}, {:.3f})'.format(
val, *pseudocolor(val, 0, 100, YELLOW, BLUE)))
Sample output using the provided colors:
Solution 3:
You can access matplolib's built-in colormaps directly, which are exactly what pcolor uses to determine its colormapping. Each map takes in a float in the range [0, 1] and returns a 4 element tuple of floats in the range [0, 1] with the components (R, G, B, A). Here is an example of a function which returns an RGBA tuple using the standard jet colormap:
from matplotlib import cm
def pseudocolor(val, minval, maxmal):
# Scale val to be in the range [0, 1]
val = (val - minval) / (maxval - minval)
# Return RGBA tuple from jet colormap
return cm.jet(val)
pseudocolor(20, 0, 100)
# Returns: (0.0, 0.3, 1.0, 1.0)
pseudocolor(80, 0, 100)
# Returns: (1.0, 0.4074, 0.0, 1.0)
This would map to the color range shown in the image below.
One of the convenient features about this method is that you can easily switch to any one of the matplotlib colormaps by changing cm.jet to cm.rainbow, cm.nipy_spectral, cm.Accent, etc.