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.

Practice

1. What does the cmap parameter do in plt.imshow() when displaying an image?

easy

A. It changes how numbers map to colors in the image.

B. It changes the image size.

C. It adds a title to the image.

D. It saves the image to a file.

Solution

1. Step 1: Understand the role of cmap in plt.imshow()

   The cmap parameter controls the colormap, which maps numeric values to colors in the image.

2. Step 2: Identify what cmap affects visually

   Changing cmap changes the colors shown, helping interpret data better.

3. Final Answer:

   It changes how numbers map to colors in the image. -> Option A

4. Quick Check:

   Colormap = color mapping [OK]

Hint: Remember: cmap controls colors, not size or titles [OK]

Common Mistakes:

• Thinking cmap changes image size
• Confusing cmap with adding titles
• Assuming cmap saves the image

2. Which of the following is the correct way to apply the 'viridis' colormap to an image using matplotlib?

easy

A. plt.imshow(image, color='viridis')

B. plt.imshow(image, cmap='viridis')

C. plt.imshow(image, cmap=viridis)

D. plt.imshow(image, colormap='viridis')

Solution

1. Step 1: Recall the correct parameter name for colormap

   The parameter to set colormap in plt.imshow() is cmap, and it expects a string name.

2. Step 2: Check the syntax for passing the colormap

   Passing cmap='viridis' is correct. Using color or colormap is incorrect, and omitting quotes causes an error.

3. Final Answer:

   plt.imshow(image, cmap='viridis') -> Option B

4. Quick Check:

   Use cmap='name' syntax [OK]

Hint: Use cmap='colormap_name' exactly [OK]

Common Mistakes:

• Using color instead of cmap
• Forgetting quotes around colormap name
• Using colormap instead of cmap

3. What will the following code display?

import matplotlib.pyplot as plt
import numpy as np
image = np.array([[0, 1], [2, 3]])
plt.imshow(image, cmap='gray')
plt.colorbar()
plt.show()

medium

A. A 2x2 image with shades of gray from black (0) to white (3) and a colorbar showing values 0 to 3.

B. A 2x2 image with random colors and no colorbar.

C. A 2x2 image with rainbow colors and a colorbar showing values 0 to 1.

D. An error because 'gray' is not a valid colormap.

Solution

1. Step 1: Understand the image data and colormap

   The image is a 2x2 array with values 0 to 3. The 'gray' colormap maps low values to black and high values to white.

2. Step 2: Analyze the colorbar and display

   The colorbar shows the numeric range from 0 to 3, matching the image values. The image colors range from black (0) to white (3).

3. Final Answer:

   A 2x2 image with shades of gray from black (0) to white (3) and a colorbar showing values 0 to 3. -> Option A

4. Quick Check:

   Gray cmap maps 0-3 to black-white [OK]

Hint: Gray cmap means black to white shades [OK]

Common Mistakes:

• Thinking 'gray' is invalid
• Ignoring the colorbar range
• Assuming rainbow colors with 'gray'

4. The code below is intended to show an image with the 'hot' colormap and a colorbar, but it raises an error. What is the problem?

import matplotlib.pyplot as plt
import numpy as np
image = np.random.rand(3,3)
plt.imshow(image, cmap=hot)
plt.colorbar()
plt.show()

medium

A. plt.colorbar() must be called before plt.imshow().

B. The image array shape is invalid for imshow.

C. The colormap name 'hot' should be a string: cmap='hot'.

D. np.random.rand() cannot be used for images.

Solution

1. Step 1: Check the cmap parameter usage

   The colormap name must be a string. Here, hot is used without quotes, causing a NameError.

2. Step 2: Verify other code parts

   The image shape is valid, and colorbar usage is correct. np.random.rand() is valid for image data.

3. Final Answer:

   The colormap name 'hot' should be a string: cmap='hot'. -> Option C

4. Quick Check:

   Colormap names need quotes [OK]

Hint: Always put colormap names in quotes [OK]

Common Mistakes:

• Forgetting quotes around colormap name
• Thinking image shape is wrong
• Misordering colorbar and imshow

5. You have a 5x5 numpy array with values from 0 to 24. You want to display it using plt.imshow() with the 'coolwarm' colormap but only show colors for values between 5 and 20. Which code snippet correctly applies this?

hard

A. plt.imshow(data, cmap='coolwarm'); plt.colorbar(vmin=5, vmax=20)

B. plt.imshow(data, cmap='coolwarm', min=5, max=20); plt.colorbar()

C. plt.imshow(data, cmap='coolwarm', clip=(5,20)); plt.colorbar()

D. plt.imshow(data, cmap='coolwarm', vmin=5, vmax=20); plt.colorbar()

Solution

1. Step 1: Understand how to limit color range in imshow

   Use vmin and vmax parameters to set the data range for colormap scaling.

2. Step 2: Check each option for correct syntax

   plt.imshow(data, cmap='coolwarm', vmin=5, vmax=20); plt.colorbar() uses vmin=5 and vmax=20, which is correct. Other options use invalid parameters or place them incorrectly.

3. Final Answer:

   plt.imshow(data, cmap='coolwarm', vmin=5, vmax=20); plt.colorbar() -> Option D

4. Quick Check:

   Use vmin and vmax to clip colors [OK]

Hint: Use vmin and vmax to set color limits [OK]

Common Mistakes:

• Using min/max instead of vmin/vmax
• Trying to clip with non-existent parameters
• Passing vmin/vmax to colorbar instead of imshow