在 python 中生成梯度 colors

Question

Given N number of buckets, I would like to generate colors continuously on the rainbow (where n>=2):

For example, if n=2, the colors would be:

rgb(255,0,0) -->rgb(0,0,255)

If n=3, the colors would be:

rgb(255,0,0) --> rgb(0,255,0) --> rgb(0,0,255)

What would be a good way to generate these color codes?

Answer 1

Your rainbow gradient smoothly varies the hue from 0 degrees to 240 degrees (the hue of the pure blue colour). Therefore it will be easiest to work with eg HSL values rather than RGB values, so you can vary the hue while leaving the saturation and lightness constant.

The colorsys library allows conversion between different colour spaces, so you can use this to generate the RGB values along the rainbow gradient as you need. The hls_to_rgb function uses float values between 0 and 1, so 2/3 is the hue for blue, and the bright colours should have a lightness of 0.5 and a saturation of 1 .

from colorsys import hls_to_rgb

def rainbow_color_stops(n=10, end=2/3):
    return [ hls_to_rgb(end * i/(n-1), 0.5, 1) for i in range(n) ]

The result is a list of (r,g,b) tuples.

Answer 2

Here's a little script to do so, using kaya3's suggestion about HSV. Was a fun little exercise.

import colorsys
import numpy as np
from matplotlib import pyplot as plt


def spectrum(n : int):
    hsv = [(h, 1, 1) for h in np.linspace(0, 240/360, n)]
    rgb = [colorsys.hsv_to_rgb(*tup) for tup in hsv]
    defloat = lambda x: tuple((int(255 * i) for i in x))
    return [defloat(x) for x in rgb]

if __name__ == '__main__':
    n = 100
    rgb = np.array(spectrum(n))
    rgb = rgb.reshape((1, n, 3))
    rgb = np.tile(rgb, (n, 1, 1))
    plt.imshow(rgb)
    plt.show()

Which generates the following figure

Answer 3

Using the RGB scale, Red starts at (255,0,0) and the middle, Green, is at (0,255,0) and the end, Blue, is at (0,0,255) . We can move through the scale by starting at (255,0,0) and 'stepping' until we get to the end.

Let's say there are 256*2 steps to get from red to green (red goes from 256->0 and green goes from 0->256) and 256*2 to get from green to blue. This comes up to 1024 steps. Now we can divide 1024 by the number of buckets we want, n . Here's an example:

def generate_gradient_rgbs(num_buckets):
    rgb_codes = []
    step_size = 1024 / num_buckets
    for step in range(0,num_buckets):
        red = int(max(0, 255 - (step_size*step*0.5))) # step size is half of the step size since both this item goes down and the next one goes up
        blue = int(max(0, 255 - (step_size*0.5*(num_buckets-step-1))))
        green = (255 - red) if red else (255 - blue)
        rgb_codes.append((red, green, blue))
    return rgb_codes

 >>> generate_gradient_rgbs(4) [(255, 0, 0), (127, 128, 0), (0, 128, 127), (0, 0, 255)]

Of course this is a starting point but for a quick-and-dirty way to get rgb's, this is a possible approach.