does it have to be 0,50,100 as values?
No, it needs to be a linear gradient between 0 and 100. I just used those values as examples of expected outputs.
In order to do that, I would need to map my value from 0 to 100 → 0 to 120 to match the hue numbers. Is there a function to map inside of an expression?
just multiply by 1.2
Oh, haha! Yep. Well, that’s another solution, thanks!
I had written a class for such a thing.
EDIT: Oops! Sent it before I was ready. This will also do multi-color gradients. A script transform could use this class to pick a point along the gradient.
class gradientPoint:
'''
Calculate the RGB value of a point on a gradient.
Usage: gradient(minval, maxval, [colors])
minval - minimun value to scale to
maxval - maximum value to scale to
colors - A list of RGB colors delineating a series of
adjacent linear color gradients between each pair.
Example: scale the values between 20 and 35 to a three color gradient.
p = gradientPoint(20, 35, ['#0000FF', '#FFFF00', '#FF0000'])
After the instance is created, call it with a value to get the scaled color
p(20) returns '#0000FF'
p(25) returns '#AAAA55'
'''
def __init__(self, minval, maxval, colors):
self.minval = minval
self.maxval = maxval
self.colors = []
for color in colors:
if type(color).__name__ == 'str':
c = self.hex_to_rgb(color)
elif type(color).__name__ == 'list':
c = tuple(color)
elif type(color).__name__ == 'tuple':
c = color
self.colors.append(c)
def __call__(self, value):
return self.calc(value)
def calc(self, value):
import sys
# Smallest possible difference.
epsilon = sys.float_info.epsilon
# Keep value within limits
if value < self.minval:
value = self.minval
if value > self.maxval:
value = self.maxval
'''
Determine where the given value falls proportionality within
the range from minval->maxval and scale that fractional value
by the total number in the "colors" pallette.
'''
i_f = float(value-self.minval) / float(self.maxval-self.minval) * (len(self.colors)-1)
'''
Determine the lower index of the pair of color indices this
value corresponds and its fractional distance between the lower
and the upper colors.
'''
# Split into integer & fractional parts.
i, f = int(i_f // 1), i_f % 1
# Does it fall exactly on one of the color points?
if f < epsilon:
return self.rgb_to_hex(self.colors[i])
# Otherwise return a color within the range between them.
else:
(r1, g1, b1), (r2, g2, b2) = self.colors[i], self.colors[i+1]
#print (r1, g1, b1), (r2, g2, b2)
#print int(r1 + f*(r2-r1)), int(g1 + f*(g2-g1)), int(b1 + f*(b2-b1))
return self.rgb_to_hex((int(r1 + f*(r2-r1)), int(g1 + f*(g2-g1)), int(b1 + f*(b2-b1))))
def hex_to_rgb(self, value):
'''
Convert a hex RGB value to a tuple of 0-255 values
'''
value = value.lstrip('#')
return tuple(int(value[i:i+2], 16) for i in (0, 2, 4))
def rgb_to_hex(self, rgb):
'''
Convert an RGB tuple to a hex string
'''
return '#%02x%02x%02x' % rgb