Matplotlib Colormaps

Matplotlib Colormaps

Matplotlib is a popular data visualization library in Python that provides a wide range of functionalities for creating high-quality plots and charts. One important aspect of creating visually appealing plots is choosing the right colormap.

In this article, we will explore different colormaps provided by Matplotlib, understand how colormaps work, how to use them in your plots, and how to customize them to suit your specific needs.

What is a Colormap?

A colormap, also known as a color map or a color scale, is a mapping of scalar values to colors. It is used to represent quantitative data in an informative and visually appealing way. Matplotlib provides a variety of built-in colormaps that you can use to customize the colors of your plots.

Available Colormaps in Matplotlib

Matplotlib provides a wide range of built-in colormaps that you can choose from based on your data and visualization requirements. Some of the commonly used colormaps in Matplotlib include:

1. viridis
2. plasma
3. inferno
4. magma
5. cividis
6. coolwarm
7. bone
8. spring
9. autumn
10. winter

Let’s dive into some examples of using these colormaps in Matplotlib plots.

Example 1: Using the viridis Colormap

The viridis colormap is a perceptually uniform colormap designed for use in visualization tasks. Let’s see how to use the viridis colormap in a simple scatter plot.

import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.random.rand(100)
colors = np.random.rand(100)

plt.scatter(x, y, c=colors, cmap='viridis')
plt.colorbar()
plt.show()

Output:

In this example, we generate random data points and assign random colors to each point using the viridis colormap. The resulting scatter plot will have a smooth color gradient that is visually appealing.

Example 2: Using the plasma Colormap

The plasma colormap is similar to the viridis colormap but has a different color scheme. Let’s see how to use the plasma colormap in a contour plot.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-2, 2, 100)
y = np.linspace(-2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)

plt.contourf(X, Y, Z, cmap='plasma')
plt.colorbar()
plt.show()

Output:

In this example, we create a contour plot of a 2D sinusoidal function using the plasma colormap. The resulting plot will have a vibrant color scheme that enhances the visualization of the data.

Example 3: Using the inferno Colormap

The inferno colormap is a dark color scheme that is useful for highlighting details in plots. Let’s see how to use the inferno colormap in a surface plot.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='inferno')
fig.colorbar(surf)
plt.show()

Output:

In this example, we create a 3D surface plot of a radial sinusoidal function using the inferno colormap. The dark color scheme of the colormap enhances the visual contrast in the plot.

Example 4: Using the coolwarm Colormap

The coolwarm colormap is a diverging colormap that transitions from cool colors to warm colors. Let’s see how to use the coolwarm colormap in a heatmap plot.

import matplotlib.pyplot as plt
import numpy as np

data = np.random.randn(10, 10)

plt.imshow(data, cmap='coolwarm')
plt.colorbar()
plt.show()

Output:

In this example, we create a heatmap plot of random data using the coolwarm colormap. The resulting plot will have a smooth transition from cool colors (blue) to warm colors (red).

Example 5: Using the bone Colormap

The bone colormap is a grayscale colormap that is useful for highlighting edges and contours in plots. Let’s see how to use the bone colormap in an image plot.

import matplotlib.pyplot as plt
import numpy as np

data = np.random.rand(100, 100)

plt.imshow(data, cmap='bone')
plt.colorbar()
plt.show()

Output:

In this example, we create an image plot of random data using the bone colormap. The grayscale color scheme enhances the visual representation of the data.

Example 6: Using the spring Colormap

The spring colormap is a colormap with a bright, warm color scheme. Let’s see how to use the spring colormap in a bar plot.

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)
y = np.random.rand(10)

plt.bar(x, y, color=plt.cm.spring(y/max(y)))
plt.show()

Output:

In this example, we create a bar plot with colors mapped to the spring colormap based on the value of the data points. The resulting plot will have a vibrant color scheme that enhances the visual appeal.

Example 7: Using the autumn Colormap

The autumn colormap is a colormap with warm colors that transition from yellow to red. Let’s see how to use the autumn colormap in a line plot.

import matplotlib.pyplot as plt
import numpy as np

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

plt.plot(x, y, color=plt.cm.autumn(x/10))
plt.show()

In this example, we create a line plot with colors mapped to the autumn colormap based on the value of the x-axis. The resulting plot will have a warm color scheme that enhances the visualization of the data.

Example 8: Using the winter Colormap

The winter colormap is a colormap with cool colors that transition from blue to white. Let’s see how to use the winter colormap in a scatter plot.

import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.random.rand(100)
colors = np.random.rand(100)

plt.scatter(x, y, c=colors, cmap='winter')
plt.colorbar()
plt.show()

Output:

In this example, we generate random data points and assign random colors to each point using the winter colormap. The resulting scatter plot will have a cool color scheme that is visually appealing.

Customizing Colormaps

In addition to using the built-in colormaps provided by Matplotlib, you can also customize colormaps to suit your specific needs. One way to customize colormaps is by creating your own colormap using the ListedColormap class.

Example 9: Customizing a Colormap

Let’s create a custom colormap that transitions from blue to red using the ListedColormap class.

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

colors = [(0, 0, 1), (1, 0, 0)]  # Blue to red colormap
cmap_custom = ListedColormap(colors)

x = np.linspace(0, 1, 100)
y = x**2

plt.scatter(x, y, c=y, cmap=cmap_custom)
plt.colorbar()
plt.show()

Output:

In this example, we create a custom colormap that transitions from blue to red using the ListedColormap class. We then apply this custom colormap to a scatter plot of quadratic data points.

Example 10: Reversing a Colormap

You can also reverse a colormap to change the direction of the color gradient. Let’s see how to reverse the coolwarm colormap.

import matplotlib.pyplot as plt
import numpy as np

data = np.random.randn(10, 10)

plt.imshow(data, cmap='coolwarm_r')  # `_r` suffix reverses the colormap
plt.colorbar()
plt.show()

Output:

In this example, we create a heatmap plot of random data using the reversed coolwarm colormap. The resulting plot will have a reversed color scheme that transitions from warm colors to cool colors.

Example 11: Adding Transparency to a Colormap

You can add transparency to a colormap by adjusting the alpha (transparency) values of the colors. Let’s see how to add transparency to the viridis colormap.

import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.random.rand(100)
colors = np.random.rand(100)

rgba_colors = plt.cm.viridis(colors)
rgba_colors[:, 3] = 0.5  # Set alpha value to 0.5 for transparency

plt.scatter(x, y, c=rgba_colors)
plt.show()

Output:

In this example, we generate random data points and assign random colors to each point using the viridis colormap with added transparency. The resulting scatter plot will have transparent data points with a smooth color gradient.

Example 12: Discretizing a Colormap

You can discretize a colormap by converting it into a ListedColormap with a specified number of colors. Let’s see how to discretize the viridis colormap into 4 colors.

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

cmap_viridis = plt.cm.get_cmap('viridis', 4)

x = np.random.rand(100)
y = np.random.rand(100)
colors = np.random.rand(100)

plt.scatter(x, y, c=colors, cmap=cmap_viridis)
plt.colorbar()
plt.show()

In this example, we generate random data points and assign random colors to each point using a discretized version of the viridis colormap with 4 colors. The resulting scatter plot will have a discrete color scheme.

Matplotlib Colormaps Conclusion

In this article, we explored different colormaps provided by Matplotlib and learned how to use them in various types of plots. We also saw how to customize colormaps to suit our specific needs by creating custom colormaps, reversing colormaps, adding transparency, and discretizing colormaps.

Colormaps play a crucial role in data visualization by enhancing the visual representation of quantitative data. By choosing the right colormap and customizing it, you can create visually appealing and informative plots that effectively communicate your data insights.