Image colormaps in Matplotlib - Deep Dive

Overview - Image colormaps

What is it?

Image colormaps are ways to assign colors to the numbers in an image or data visualization. They help turn raw numbers into colors that our eyes can understand easily. Each number in the image gets a color based on the colormap, making patterns or details visible. This is especially useful for grayscale images or heatmaps.

Why it matters

Without colormaps, images with many shades of gray or numbers would be hard to interpret. Colormaps make it easier to spot trends, differences, or important features in data. For example, doctors use colormaps to see details in medical scans, and scientists use them to understand heat or intensity in images. Without colormaps, these insights would be hidden in plain numbers.

Where it fits

Before learning about image colormaps, you should understand basic image representation as arrays of numbers and how to plot images using matplotlib. After mastering colormaps, you can explore advanced visualization techniques like color normalization, custom colormaps, and perceptual color spaces.

Mental Model

Core Idea

A colormap is a color translator that changes numbers in an image into colors so we can see patterns and details clearly.

Think of it like...

Imagine a weather map showing temperatures. Instead of numbers, colors like blue for cold and red for hot help you quickly understand the weather. Colormaps do the same for any image data.

┌───────────────┐
│ Numeric Image │
│  (array of   │
│   numbers)   │
└──────┬────────┘
       │ Apply colormap
       ▼
┌───────────────┐
│ Colored Image │
│ (array of    │
│  colors)     │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Image Data Arrays

Concept: Images are stored as arrays of numbers representing brightness or intensity.

An image can be thought of as a grid of numbers. For grayscale images, each number shows how bright that spot is, from black (0) to white (255 or 1). Color images have three numbers per spot for red, green, and blue. We use libraries like matplotlib to read and show these arrays as pictures.

Result

You can see how images are just numbers arranged in rows and columns.

Understanding that images are numeric arrays helps you realize why we need colormaps to turn these numbers into visible colors.

2

Foundation

Displaying Images with Matplotlib

Concept: Matplotlib can show images by mapping array values to grayscale by default.

Using matplotlib's imshow() function, you can display an image array. By default, grayscale images show as shades of gray. For example, imshow(image_array, cmap='gray') shows the image in black and white.

Result

You see the image in grayscale, where darker means lower numbers and lighter means higher numbers.

Knowing how to display images is the first step before changing how colors represent data.

3

Intermediate

Applying Built-in Colormaps

🤔Before reading on: do you think changing the colormap changes the data or just the colors? Commit to your answer.

Concept: Colormaps change only how numbers map to colors, not the underlying data.

Matplotlib offers many colormaps like 'viridis', 'plasma', 'inferno', and 'magma'. You can apply them by passing cmap='colormap_name' to imshow(). For example, imshow(image_array, cmap='viridis') colors the image with a smooth blue-to-yellow scale.

Result

The image colors change, revealing different visual patterns without altering the original numbers.

Understanding that colormaps only change appearance helps you experiment safely without losing data integrity.

4

Intermediate

Sequential vs Diverging Colormaps

🤔Before reading on: do you think all colormaps are good for every type of data? Commit to your answer.

Concept: Different colormaps suit different data types: sequential for ordered data, diverging for data with a midpoint.

Sequential colormaps smoothly change from dark to light colors and are good for data that goes from low to high. Diverging colormaps have two contrasting colors with a neutral middle, useful for data centered around zero (like positive and negative values). Choosing the right colormap helps highlight important features.

Result

You can pick colormaps that make your data's story clearer and easier to understand.

Knowing colormap types prevents misleading visuals and improves communication of data meaning.

5

Intermediate

Using Color Normalization

🤔Before reading on: do you think colormaps always map colors linearly to data values? Commit to your answer.

Concept: Color normalization controls how data values map to colors, allowing non-linear scaling.

Matplotlib lets you normalize data before applying colormaps. For example, LogNorm applies logarithmic scaling, making small differences in low values more visible. You use it by passing norm=LogNorm() to imshow(). This is useful when data spans many orders of magnitude.

Result

The image colors better represent important details that linear mapping might hide.

Understanding normalization lets you tailor color mapping to your data's distribution for clearer insights.

6

Advanced

Creating Custom Colormaps

🤔Before reading on: do you think you can make your own colormaps in matplotlib? Commit to your answer.

Concept: You can design custom colormaps by combining colors or modifying existing ones.

Matplotlib allows creating colormaps from lists of colors or by modifying existing colormaps. For example, you can use LinearSegmentedColormap.from_list() to define a new colormap with chosen colors. This helps match your visualization style or highlight specific data ranges.

Result

You get unique color mappings tailored exactly to your needs.

Knowing how to create custom colormaps gives you full control over how data is visually communicated.

7

Expert

Perceptual Uniformity and Colorblind Safety

🤔Before reading on: do you think all colormaps are equally easy for everyone to interpret? Commit to your answer.

Concept: Good colormaps are perceptually uniform and accessible to people with color vision differences.

Perceptual uniformity means equal steps in data produce equal perceived color changes. Colormaps like 'viridis' are designed this way. Also, some colormaps are colorblind-friendly, avoiding colors that are hard to distinguish. Using these improves clarity and inclusivity in visualizations.

Result

Your images communicate data accurately and are easier for all viewers to understand.

Understanding perceptual design principles prevents misleading visuals and makes your work accessible to a wider audience.

Under the Hood

Internally, matplotlib maps each data value to a position between 0 and 1 using normalization. This position indexes into a colormap, which is a list or function of colors. The selected color replaces the original number in the image display. This process happens efficiently in C and Python layers, allowing fast rendering of images with millions of pixels.

Why designed this way?

This design separates data from color representation, allowing flexible visualization without changing data. Early plotting libraries used fixed grayscale, but separating normalization and colormaps made visualizations more expressive and customizable. The modular approach also supports adding new colormaps easily.

┌───────────────┐
│ Raw Data Array│
└──────┬────────┘
       │ Normalize (scale 0 to 1)
       ▼
┌───────────────┐
│ Normalized    │
│ Data (0-1)   │
└──────┬────────┘
       │ Map to color via colormap
       ▼
┌───────────────┐
│ RGB Colors    │
│ (image pixels)│
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does changing a colormap change the actual data values? Commit to yes or no.

Common Belief: Changing the colormap changes the data itself.

Reality: Colormaps only change how data values are shown as colors; the underlying data stays the same.

Why it matters: If you think colormaps change data, you might mistakenly alter or misinterpret your dataset.

Quick: Are all colormaps equally good for all types of data? Commit to yes or no.

Common Belief: Any colormap works fine for any data visualization.

Reality: Different data types need different colormaps; using the wrong one can hide or distort information.

Why it matters: Using inappropriate colormaps can mislead viewers or hide important data features.

Quick: Do brighter colors always mean higher data values? Commit to yes or no.

Common Belief: Brighter colors always represent higher values in colormaps.

Reality: Some colormaps use color hues or saturation instead of brightness to represent values, so brightness alone can be misleading.

Why it matters: Assuming brightness equals value can cause wrong conclusions about data patterns.

Quick: Are all colormaps equally easy to interpret for colorblind people? Commit to yes or no.

Common Belief: All colormaps are equally accessible to everyone.

Reality: Many colormaps are hard for colorblind viewers to distinguish; special colorblind-friendly colormaps exist.

Why it matters: Ignoring accessibility excludes part of your audience and reduces the effectiveness of your visualization.

Expert Zone

1

Some colormaps are designed to be perceptually uniform, meaning equal data steps look like equal color changes, which is crucial for accurate interpretation.

2

Color normalization can be customized with boundaries or masked values to highlight specific data ranges or ignore invalid data.

3

Combining multiple colormaps or using alpha transparency can create complex visualizations but requires careful design to avoid confusion.

When NOT to use

Avoid using colormaps when precise numeric values are critical; instead, use direct numeric labels or interactive tools. For categorical data, use discrete color palettes rather than continuous colormaps. Also, avoid rainbow colormaps for scientific data as they can distort perception.

Production Patterns

Professionals use perceptually uniform colormaps like 'viridis' by default for scientific plots. Custom colormaps are created for branding or specific data highlights. Color normalization is applied to handle skewed data distributions. Accessibility checks ensure colorblind-friendly visuals before publishing.

Connections

Data Normalization

Image colormaps build on data normalization to scale values before coloring.

Understanding normalization helps grasp how colormaps map data ranges to colors effectively.

Human Color Perception

Colormaps rely on how humans perceive color differences to communicate data.

Knowing color perception principles guides choosing colormaps that are clear and non-misleading.

Cartography (Map Coloring)

Both use color schemes to represent data values spatially for easy interpretation.

Recognizing this connection shows how visual encoding of data is a universal challenge across fields.

Common Pitfalls

#1 Using a rainbow colormap for scientific data.

Wrong approach:

plt.imshow(image_array, cmap='jet')

Correct approach:

plt.imshow(image_array, cmap='viridis')

Root cause:

Rainbow colormaps have uneven perceptual changes and can mislead interpretation.

#2 Not normalizing data before applying colormap to skewed data.

Wrong approach:

plt.imshow(image_array, cmap='plasma') # without normalization

Correct approach:

from matplotlib.colors import LogNorm
plt.imshow(image_array, cmap='plasma', norm=LogNorm())

Root cause:

Linear mapping hides details in data with wide value ranges.

#3 Using a colormap that is not colorblind-friendly.

Wrong approach:

plt.imshow(image_array, cmap='coolwarm')

Correct approach:

plt.imshow(image_array, cmap='cividis')

Root cause:

Ignoring accessibility reduces clarity for colorblind viewers.

Key Takeaways

Image colormaps translate numeric data into colors to make patterns visible and understandable.

Choosing the right colormap type and normalization method is essential for accurate and clear visualizations.

Custom colormaps and perceptual design improve communication and accessibility of image data.

Misusing colormaps can mislead interpretation, so understanding their principles prevents common visualization errors.

Colormaps connect deeply with human perception and data scaling, making them a powerful tool in data science.