Color channel handling in Matplotlib - Step-by-Step Execution

Concept Flow - Color channel handling

Load Image as Array

↓

Separate Color Channels

↓

Red

↓

Modify or Analyze Channels

↓

Combine Channels Back

↓

Display or Save Image

The image is loaded as an array, color channels are separated, optionally modified or analyzed, then combined back and displayed.

Execution Sample

Matplotlib

import matplotlib.pyplot as plt
import numpy as np
img = plt.imread('image.png')
red = img[:,:,0]
plt.imshow(red, cmap='Reds')
plt.show()

This code loads an image, extracts the red channel, and displays it using a red color map.

Execution Table

Step	Action	Variable	Value/Result
1	Load image	img	3D array shape (height, width, 3) with RGB values
2	Extract red channel	red	2D array shape (height, width) with red values
3	Display red channel	plt.imshow(red, cmap='Reds')	Image shown with red intensities
4	End	-	Image display complete

💡 Image displayed and process ends

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
img	undefined	3D array with RGB	3D array with RGB	3D array with RGB
red	undefined	undefined	2D array red channel	2D array red channel

Key Moments - 2 Insights

Why do we use img[:,:,0] to get the red channel?

Because the image array stores colors in the last dimension as [Red, Green, Blue], so index 0 selects the red values (see execution_table step 2).

Why does plt.imshow(red, cmap='Reds') show a red image?

Because we tell matplotlib to use the 'Reds' color map, which colors the grayscale red channel data in shades of red (see execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution table, what is the shape of 'red' after step 2?

A 2D array with red channel values

B 3D array with 3 color channels

C 1D array with pixel values

D Scalar value

💡 Hint

Check the 'Variable' and 'Value/Result' columns in step 2 of execution_table

At which step is the image actually shown on screen?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for plt.imshow and plt.show actions in execution_table

If we want to extract the blue channel, which index should we use?

A 1

B 2

C 0

D 3

💡 Hint

Recall RGB channels are indexed as 0=Red, 1=Green, 2=Blue (see key_moments question 1)

Concept Snapshot

Color channel handling:
- Images are arrays with shape (height, width, 3)
- Channels: 0=Red, 1=Green, 2=Blue
- Extract channel: img[:,:,channel_index]
- Display single channel with plt.imshow(channel, cmap='ColorMap')
- Combine channels back with np.stack or similar

Full Transcript

We start by loading an image as a 3D array with RGB channels. Then we extract one color channel by selecting the appropriate slice in the last dimension. For example, img[:,:,0] gives the red channel. We can display this channel using matplotlib's imshow with a color map like 'Reds' to see the intensity of red in the image. This process helps us analyze or modify individual color channels before combining them back to form a full color image.

Practice

1. What does the last dimension in a matplotlib image array usually represent?

easy

A. The image width

B. The image height

C. The color channels like red, green, and blue

D. The number of images in a batch

Solution

1. Step 1: Understand image array structure

   Matplotlib images are stored as arrays where the last dimension holds color information.

2. Step 2: Identify what the last dimension holds

   This last dimension typically contains the red, green, and blue channels for each pixel.

3. Final Answer:

   The color channels like red, green, and blue -> Option C

4. Quick Check:

   Last dimension = color channels [OK]

Hint: Remember: last dimension = RGB colors in image arrays [OK]

Common Mistakes:

• Confusing width or height with the last dimension
• Thinking the last dimension is batch size
• Assuming grayscale images have 3 channels

2. Which of the following is the correct way to extract the green channel from a 3D image array named img in matplotlib?

easy

A. green = img[2, :, :]

B. green = img[1, :, :]

C. green = img[:, 1, :]

D. green = img[:, :, 1]

Solution

1. Step 1: Recall channel indexing in image arrays

   Color channels are stored in the last dimension, with red=0, green=1, blue=2.

2. Step 2: Extract green channel correctly

   To get green, select all rows and columns, but only index 1 in the last dimension: img[:, :, 1].

3. Final Answer:

   green = img[:, :, 1] -> Option D

4. Quick Check:

   Green channel index = 1 [OK]

Hint: Use img[:, :, 1] to get green channel [OK]

Common Mistakes:

• Mixing up axis order and indexing rows or columns
• Using wrong channel index for green
• Selecting wrong dimensions

3. Given the code below, what will be the shape of red_channel?

import numpy as np
img = np.random.rand(100, 150, 3)
red_channel = img[:, :, 0]

medium

A. (100, 150)

B. (100, 150, 3)

C. (3, 100, 150)

D. (150, 3)

Solution

1. Step 1: Understand original image shape

   img has shape (100, 150, 3) meaning 100 rows, 150 columns, 3 color channels.

2. Step 2: Extract red channel shape

   Extracting img[:, :, 0] selects all rows and columns but only the first channel, so shape becomes (100, 150).

3. Final Answer:

   (100, 150) -> Option A

4. Quick Check:

   Channel extraction removes last dimension [OK]

Hint: Extracting one channel drops last dimension [OK]

Common Mistakes:

• Expecting 3 channels after extraction
• Confusing axis order
• Misreading shape tuple

4. What is wrong with this code snippet that tries to swap the red and blue channels of an image array img?

img[:, :, 0] = img[:, :, 2]
img[:, :, 2] = img[:, :, 0]

medium

A. The syntax for slicing is invalid

B. It overwrites red channel before saving it, losing original data

C. The channel indices are incorrect for red and blue

D. It should use img[0, :, :] instead of img[:, :, 0]

Solution

1. Step 1: Analyze channel swapping logic

   The code assigns blue channel to red, then red channel to blue without temporary storage.

2. Step 2: Identify data overwrite problem

   After first line, original red data is lost, so second line copies new red (which is blue) back to blue channel.

3. Final Answer:

   It overwrites red channel before saving it, losing original data -> Option B

4. Quick Check:

   Swap needs temp variable to avoid overwrite [OK]

Hint: Use a temp variable when swapping channels [OK]

Common Mistakes:

• Not using a temporary variable for swap
• Mixing up channel indices
• Incorrect slicing syntax

5. You want to create a grayscale image by averaging the red, green, and blue channels of an image array img. Which code correctly does this and keeps the result as a 2D array?

hard

A. gray = img.mean(axis=2)

B. gray = img.mean(axis=0)

C. gray = img[:, :, 0] + img[:, :, 1] + img[:, :, 2]

D. gray = img.sum(axis=1)

Solution

1. Step 1: Understand axis for color channels

   Color channels are in the last dimension (axis=2) of img.

2. Step 2: Average across color channels

   Using img.mean(axis=2) averages red, green, and blue for each pixel, resulting in a 2D array.

3. Final Answer:

   gray = img.mean(axis=2) -> Option A

4. Quick Check:

   Mean over axis=2 gives grayscale 2D image [OK]

Hint: Use mean(axis=2) to average RGB channels [OK]

Common Mistakes:

• Averaging over wrong axis
• Summing channels without dividing
• Resulting in 3D array instead of 2D