How to Fill Rainbow Color Under a Curve in Python Matplotlib

💡 Problem Formulation: Visualizing data with a spectrum of colors can enhance comprehension and aesthetic appeal. In Python matplotlib, users often seek to accentuate curves by filling the area beneath them with a gradient, resembling a rainbow. The aim is to transform a standard plot into a colorfully shaded masterpiece, with the input being a set of data points and the desired output a graph displaying a curve over a progressive color fill from one end of the spectrum to the other.

Method 1: Using Linear Gradient with RGB tuples

This method involves the calculation of RGB tuples to create a linear gradient effect under the curve. The fill_between function of matplotlib can be employed, and RGB values are altered incrementally to simulate a rainbow. Functionality offered is specific, allowing for heavy customization of the color transition and shading intensity.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap

x = np.linspace(0, 10, 100)
y = np.sin(x)

fig, ax = plt.subplots()
colors = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]  # R -> G -> B
n_bins = 100  # Increase this for smoother color transitions
cm = LinearSegmentedColormap.from_list('custom', colors, N=n_bins)

z = np.linspace(0, 1, len(x))
ax.plot(x, y, color='black')
ax.fill_between(x, 0, y, color='white', where=y > 0, zorder=3)
for i in range(1, len(x)):
    ax.fill_between(x[i-1:i+1], y[i-1:i+1], color=cm(z[i-1]), step='pre', zorder=2)

plt.show()

The output is a plot with a rainbow gradient fill under the sine curve.

The example demonstrates how to map a set of colors to a curve by filling the area between the curve and the x-axis with colors from a custom-made colormap. The LinearSegmentedColormap creates a seamless gradient by blending the specified colors.

Method 2: Using imshow with Extent

Imshow can produce a smoother gradient by treating the area under the curve as an image. This method utilizes the ‘extent’ parameter to stretch the image across the desired plot area. It’s less granular than other methods but requires less code and is computationally efficient.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 1000)
y = np.sin(x)
gradient = np.linspace(0, 1, 256).reshape(1, -1)
gradient = np.vstack((gradient, gradient))

fig, ax = plt.subplots()
ax.plot(x, y, color='k')
ax.imshow(gradient, aspect='auto', cmap=plt.get_cmap('rainbow'), 
          extent=(min(x), max(x), min(y), max(y)))
ax.fill_between(x, min(y), y, color='white', zorder=2)

plt.show()

The output is a plot with a smooth rainbow gradient under the sine curve.

The code snippet leverages the ‘imshow’ function, traditionally used for showing images, to create a smooth gradient effect. The gradient is generated as a 2D array and stretched along the curve with the ‘extent’ parameter, which is limited to the range of x and y values.

Method 3: Adding ColorMap to Fill Between

This method employs a colormap directly within the fill_between method by interpolating a normalized array to map to the colormap. The method is straightforward and leverages robust built-in matplotlib colormaps for a quick and clean result.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 1000)
y = np.sin(x)
z = np.linspace(0, 1, 1000)
norm = plt.Normalize(0, 1)
cmap = plt.get_cmap('rainbow')

fig, ax = plt.subplots()
ax.plot(x, y, color='k')
ax.fill_between(x, y, color='white', where=y >= min(y))
for i in range(len(x)-1):
    ax.fill_between(x[i:i + 2], y[i:i + 2], color=cmap(norm(z[i])))

plt.show()

The output is a plot with a multi-colored gradient under the sine curve.

The code here again uses fill_between, but instead of creating a custom colormap, it leverages an existing one. The loop fills small sections of the curve incrementally, coloring each based on the normalized position along the curve, resulting in a color-mapped gradient.

Method 4: Using PathPatch for Arbitrary Shaped Gradient

Utilizing the PathPatch object from matplotlib’s patches library, one can create a gradient fill for shapes of arbitrary complexity under the curve. By defining a path and applying a transform, this method provides precision and creative control over the filled area.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.path as mpath
import matplotlib.patches as patches
import matplotlib.colors as mcolors

x = np.linspace(0, 10, 1000)
y = np.sin(x)
path = mpath.Path(np.array([x, y]).T)
patch = patches.PathPatch(path, facecolor='none', lw=2)

fig, ax = plt.subplots()
ax.plot(x, y, color='k')
ax.add_patch(patch)

cmap = plt.get_cmap('rainbow')
bounds = [np.min(x), np.max(x)]
norm = mcolors.Normalize(vmin=bounds[0], vmax=bounds[1])
patch.set_facecolor(cmap(norm(x)))
patch.set_alpha(0.5)

plt.show()

The output is a plot where a semi-transparent rainbow gradient is rendered under the sine curve with arbitrary shape capability.

Instead of a straight fill, the PathPatch object offers a more nuanced approach. The facecolor of the patch is set according to the colormap and normalized values, giving detailed control over the formed gradient under the curve.

Bonus One-Liner Method 5: Simple Fill with Color Argument

For an uncomplicated one-liner solution, matplotlib’s fill_between method can be used with a color argument generating a simple, solid rainbow effect under the curve. While limited, it is by far the easiest implementation.

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
y = np.sin(x)
fig, ax = plt.subplots()
ax.plot(x, y, color='k')
ax.fill_between(x, y, color='rainbow', alpha=0.5)

plt.show()

The output is a plot with a solid rainbow color under the sine curve.

This code employs a get-out-of-jail-free card; it sets a solid ‘rainbow’ color under the curve with an alpha value to make it semi-transparent, introducing an element of simplicity.

Summary/Discussion

Method 1:

Method 2:

Method 3:

Method 4:

Method 5: