# Color Spectrums in Python

This tutorial will discuss the method to create images with color spectrum in Python.

## Color Spectrum With the `PIL` Library in Python

The dispersion of white light from the sun into its components after passing through a prism is called a color spectrum. It contains the entire range of light wavelengths visible to the naked human eye. In other words, a color spectrum contains the primary colors(red, green, and blue) and all the intermediate combinations of the primary colors. The Python Imaging Library `PIL` is used for working with images in Python. We can use the `PIL` library to create an image that contains our desired color spectrum. For the purpose of this tutorial, we will recreate the following color spectrum in an image with our desired dimensions using `PIL` in Python. The following code example shows us how to recreate the same color spectrum inside an image of our desired dimensions with the `PIL` library.

``````from PIL import Image

def color_spectrum(height, width):

spectrum_ratio = 255*6 / width

red = 255
green = 0
blue = 0

colors = []

step = round(spectrum_ratio)

for i in range (0, height):
for j in range (0, 255*6+1, step):
if j > 0 and j <= 255:
blue += step
elif j > 255 and j <= 255*2:
red -= step
elif j > 255*2 and j <= 255*3:
green += step
elif j > 255*3 and j <= 255*4:
blue -= step
elif j > 255*4 and j <= 255*5:
red += step
elif j > 255*5 and j <= 255*6:
green -= step

colors.append((red, green, blue))

width2 = int(j/step+1)

image = Image.new("RGB", (width2, height))
image.putdata(colors)
image.save("Picture2.png", "PNG")

if __name__ == "__main__":
create_spectrum(100,300)
``````

Output: We replicated the same color spectrum as shown in the sample image with `PIL` in the above code.

We created an RGB image with `image = Image.new("RGB", (width2, height))` and populated it with 8-bit color values with `image.putdata(colors)`. Here, `colors` is a list of tuples where each tuple contains three values (red, green, and blue). As we know, 8-bit colors have values ranging from 0 to 255. We initialized three variables `red`, `green`, and `blue`, each representing the values of a primary color. The `spectrum_ratio` is used to simplify the computation. It represents for how many pixels do we see the same color. Our nested loop is incremented by one `step` because there is no need to loop through many different pixels having the same color. The `step` variable is calculated by rounding off the `spectrum_ratio` with `step = round(spectrum_ratio)`.

As we can see that the color spectrum starts with red, gradually the red color starts to fade, and the blue color increases its intensity close to the middle of the image. When there is only blue color left in the color spectrum, the green color starts to intensify, and the blue color slowly starts to fade from left to right. When all the blue color has disappeared, and there is only the green color left, the intensity of the red color starts to increase again, and the green color starts to fade. The image ends when the green color has completely disappeared, and we are only left with the red color again.

The logic described in the previous paragraph has been encoded in our nested loop, and we append the new RGB values into our list `colors` after each iteration with `colors.append((red, green, blue))`. The image’s original width has been changed because we have rounded off the `spectrum_ratio` into `step`. We created `width2` to cope with this change. After writing the color values into our new image, we saved the image with `image.save("Picture2.png", "PNG")`.

Contribute
DelftStack is a collective effort contributed by software geeks like you. If you like the article and would like to contribute to DelftStack by writing paid articles, you can check the write for us page.

## Related Article - Python Graph

• Smooth Data in Python
• ## Related Article - Python Color

• Generate Random Colors in Python