Matplotlib is a popular Python library used for data visualization and plotting. One of the most common tasks when using matplotlib is to set the colormap (also called the color map) for a plot. The colormap controls the colors used to map data values to colors in the plot. Matplotlib provides a wide range of builtin colormaps to choose from. In this article, we will explore the various colormap options available in matplotlib and how to use them effectively for data visualization.
Introduction to Colormaps
A colormap is essentially a mapping from data values to colors. It is used to assign colors to plot elements like lines, surfaces, scatter points etc based on the data values associated with them. For example, in a surface plot of a 2D function z=f(x,y), the colormap assigns colors to pixels in the plot based on the z-values computed from the function f(x,y) at those pixel locations.
Some common uses of colormaps are:
- To visualize height in a surface plot
- To distinguish different categories in a scatter plot
- To encode values in a filled contour plot
- To show intensity or concentration with pseudocolor plots
Matplotlib has a module dedicated to colormaps called matplotlib.cm. This module contains a collection of predefined colormaps that can be used in matplotlib visualizations. The cmap parameter in matplotlib plotting functions is used to specify the colormap. There are also helper functions like colormap.ScalarMappable that can map data values to colormap colors.
Types of Colormaps
Matplotlib colormaps can be broadly divided into three categories:
Sequential Colormaps
These map data values to colors along a sequential spectrum. Low data values are mapped to colors at one end of the spectrum while high data values are mapped to colors at the other end. Sequential colormaps are good for visualizing data that has a natural ordering or organizing data from low to high values. Some common sequential colormaps are:
- viridis – ranges from blue to yellow
- plasma – ranges from purple to yellow
- inferno – ranges from black to yellow
- magma – ranges from black to white
Diverging Colormaps
These map low and high data values to distinct colors with a transition color in the middle. The transition color is used to mark the critical midpoint value in the data. Diverging colormaps are useful when there is a need to highlight a specific mid value in the data being visualized. Some common diverging colormaps are:
- coolwarm – ranges from blue to red with white midpoint
- PiYG – ranges from pink to green with white midpoint
- PuOr – ranges from purple to orange with white midpoint
- RdBu – ranges from red to blue with white midpoint
Qualitative/Categorical Colormaps
These map discrete data values to a set of distinct colors. Categorical colormaps do not imply any ordering of colors but simply use different colors to distinguish between categories. These are useful for visualizing categorical data. Some common categorical colormaps are:
- Set1, Set2, Set3 – color palettes with 9 distinct colors
- tab10, tab20, tab20b, tab20c – color palettes with 10-20 distinct colors
- Paired – color palette with 12 distinct colors
- Pastel1, Pastel2 – soft color palettes
Commonly Used Colormaps
Here are some of the most commonly used colormaps in matplotlib:
viridis
This is the default sequential colormap in matplotlib. It is perceptually uniform and colorblind friendly. The colors range from blue to yellow.
inferno
This is another perceptual uniform colormap that goes from black to yellow. Useful for visualizing hot or bright data.
magma
Perceptual uniform colormap ranging from black to white, useful for high contrast visualizations.
coolwarm
Diverging colormap from blue to red with white mid point, good for deviating negative/positive values.
RdBu
Diverging colormap from red to blue with white mid point. Helps highlight the mid value threshold.
tab20
Qualitative colormap with 20 distinct colors, useful for visualizing up to 20 discrete categories.
tab10
Compact qualitative colormap with 10 colors for fewer categories.
Perceptually Uniform Colormaps
Recent matplotlib versions (>=2.0) have added new colormaps like viridis, magma, inferno and plasma that are perceptually uniform. This means that equal steps in data values are perceived as equal steps visually in the colormap. Traditionally colormaps like jet tend to have uneven perceptual contrast which can distort the visualization. Perceptual uniform colormaps fix this issue and greatly improve ability to understand variations in data. They should be preferred for sequential data.
Colorblind Friendly Colormaps
Some colormaps like viridis are designed to be color blind friendly by avoiding colors that are difficult to distinguish for people with color blindness. When creating visualizations for public use, it is essential to ensure that the colormaps chosen are colorblind friendly. Some options are viridis, plasma and magma for sequential data and coolwarm for diverging data. Avoid rainbow color maps.
Custom Colormaps
Matplotlib also makes it possible to create custom colormaps by specifying the list of colors comprising the colormap. For example:
from matplotlib.colors import LinearSegmentedColormap
cm = LinearSegmentedColormap.from_list('custom', ['red', 'green', 'blue'])
This creates a custom 3 color sequential colormap. We can specify any colors and any number of colors in the list as needed. Custom colormaps give full flexibility in trading off number of colors versus perceptual uniformity.
Colormap Normalization and Scaling
Matplotlib colormaps are generally normalized to map the data values in the range [0, 1] to colors. However, we often need to map custom data ranges to the colormap. This can be done using the vmin and vmax arguments to the plotting functions in matplotlib. For example:
plot(data, vmin=-100, vmax=500, cmap='coolwarm')
This will map data values ranging from -100 to 500 to the coolwarm colormap. Values below -100 will get the lowest colormap color and values above 500 will get the highest colormap color.
The matplotlib.colors.Normalize class can also be used to customize data normalization for the colormaps. This gives more control over scaling including mapping only part of the colormap to data values or applying non-linear scaling.
Diverging Colormaps with a Center Value
For diverging colormaps like coolwarm or RdBu we often want to explicitly set the data value that maps to the center/transition color in the colormap. This is done using the center argument to Normalize. For example:
from matplotlib.colors import Normalize
norm = Normalize(vmin=-100, vmax=150, center=0)
plot(data, cmap='coolwarm', norm=norm)
Here 0 will be mapped to the white midpoint of the coolwarm colormap. Data values between -100 and 0 will get the bluish colors and values between 0 and 150 will get the reddish colors.
Colormap Reference for Categories
Qualitative colormaps that are useful for categorical data are:
| Colormap | Number of Colors |
|---|---|
| tab10 | 10 |
| tab20 | 20 |
| tab20b | 20 |
| tab20c | 20 |
| Pastel1 | 9 |
| Pastel2 | 8 |
| Paired | 12 |
| Accent | 8 |
| Dark2 | 8 |
| Set1 | 9 |
| Set2 | 8 |
| Set3 | 12 |
These provide a wide range of distinct colors for visualizing up to 10-20 categories in plots.
Colormap Reference for Sequential Data
Recommended colormaps for sequential data are:
| Colormap | Description |
|---|---|
| viridis | Perceptual uniform, from blue to yellow |
| plasma | Perceptual uniform, from purple to yellow |
| inferno | Perceptual uniform, from black to yellow |
| magma | Perceptual uniform, from black to white |
| cividis | Perceptual uniform, from blue to yellow |
| Greys | White to black greyscale |
| Purples | White to purple |
| Blues | White to blue |
| Greens | White to green |
| Oranges | White to orange |
| Reds | White to red |
Colormap Reference for Diverging Data
Recommended colormaps for diverging data around a center point are:
| Colormap | Description |
|---|---|
| coolwarm | Blue to red with white midpoint |
| PiYG | Pink to green with white midpoint |
| PRGn | Purple to green with white midpoint |
| PuOr | Purple to orange with white midpoint |
| RdBu | Red to blue with white midpoint |
| RdYlBu | Red to yellow to blue with white midpoint |
| RdYlGn | Red to yellow to green with white midpoint |
| Spectral | Red to blue with unsaturated colors |
Setting the Default Colormap
The default colormap in matplotlib can be globally set using:
import matplotlib.pyplot as plt
plt.rcParams['image.cmap'] = 'viridis'
This will make viridis the default for all plots created in the session. Similar rcParams exist for specific plot kinds like image, pcolor, scatter etc.
The default can be set back to the original using:
plt.rcParams['image.cmap'] = None
Colormap Summary
To summarize, effective use of colormaps involves:
- Using perceptually uniform maps like viridis for sequential data
- Using diverging colormaps like coolwarm to highlight a midpoint
- Using categorical maps like tab10 for discrete categories
- Setting perceptually uniform maps like viridis as default
- Avoiding rainbow color maps for continuous data
Matplotlib provides a wide selection of colormaps that cover most data visualization needs. The cmap argument and matplotlib.cm module give access to both builtin and custom colormaps for versatile control over color mapping in plots.
Conclusion
In this article, we looked at the various colormap options available in matplotlib. The key points are:
- Colormaps control the mapping of data values to colors when plotting
- Main colormap types are sequential, diverging and categorical
- Perceptually uniform colormaps like viridis improve visualization
- Diverging colormaps highlight a critical midpoint value
- Categorical colormaps distinguish distinct data classes
- Colormaps can be customized using lists of colors
- Normalization and scaling maps data ranges to colormaps
- Choosing the right colormap is important for effective visualization
Matplotlib’s versatile colormap options along with the ability to create custom maps enables detailed control over the colors used for data visualization in Python plots.
