Basic image manipulation with arrays in NumPy

Introduction

We use arrays to change images because images are just grids of numbers. Changing these numbers changes the picture.

You want to make a photo brighter or darker.

You want to flip or rotate a picture.

You want to crop a part of an image.

You want to change colors or add filters to a photo.

Syntax

NumPy

import numpy as np

# Load or create an image as a 2D (grayscale) or 3D (color) numpy array
image = np.array([...])  # Example image array

# Example operations:
# 1. Brightness change
brighter_image = np.clip(image + 50, 0, 255)  # Add 50 to all pixels and clip to valid range

# 2. Flip image horizontally
flipped_image = np.fliplr(image)

# 3. Crop image
cropped_image = image[10:100, 20:150]

# 4. Convert to grayscale (if color image)
gray_image = np.mean(image, axis=2).astype(np.uint8)

Images are stored as arrays where each number represents a pixel's brightness or color.

Use numpy functions to easily manipulate these arrays.

Examples

This creates a 5x5 black image (all pixels zero).

NumPy

import numpy as np

# Empty image (all zeros)
empty_image = np.zeros((5, 5), dtype=np.uint8)
print(empty_image)

An image with only one white pixel.

NumPy

import numpy as np

# Single pixel image
single_pixel_image = np.array([[255]], dtype=np.uint8)
print(single_pixel_image)

Flips the image left to right.

NumPy

import numpy as np

# Flip a small image horizontally
small_image = np.array([[10, 20, 30], [40, 50, 60]], dtype=np.uint8)
flipped = np.fliplr(small_image)
print(flipped)

Crops a part of the image; numpy handles out-of-bound indexes safely.

NumPy

import numpy as np

# Crop image edge case: cropping beyond image size
image = np.arange(100).reshape(10, 10)
cropped = image[8:15, 8:15]
print(cropped)

Sample Program

This program creates a small grayscale image as a numpy array. It then makes the image brighter, flips it horizontally, and crops the center part. Each step prints the image array so you can see the changes.

NumPy

import numpy as np

# Create a simple 5x5 grayscale image with values from 10 to 210
original_image = np.array([
    [10, 50, 90, 130, 170],
    [20, 60, 100, 140, 180],
    [30, 70, 110, 150, 190],
    [40, 80, 120, 160, 200],
    [50, 90, 130, 170, 210]
], dtype=np.uint8)

print("Original Image:\n", original_image)

# Increase brightness by 40 (clip max to 255)
brighter_image = np.clip(original_image + 40, 0, 255).astype(np.uint8)
print("\nBrighter Image:\n", brighter_image)

# Flip image horizontally
flipped_image = np.fliplr(original_image)
print("\nFlipped Image (Left-Right):\n", flipped_image)

# Crop the center 3x3 area
cropped_image = original_image[1:4, 1:4]
print("\nCropped Image (3x3 center):\n", cropped_image)

Important Notes

Brightness change operation runs in O(n*m) time where n and m are image dimensions.

Flipping and cropping also run in O(n*m) time but are very fast with numpy.

Common mistake: Not clipping values after brightness change can cause overflow and wrong colors.

Use cropping to focus on parts of an image; use flipping to mirror images easily.

Summary

Images are arrays of numbers representing pixels.

You can change images by adding, flipping, or slicing these arrays.

Numpy makes these operations simple and fast.

Practice

1. What does a 2D numpy array represent when used for a grayscale image?

easy

A. Pixel brightness values arranged in rows and columns

B. A list of image file names

C. The color channels of an image

D. The size of the image in bytes

Solution

1. Step 1: Understand image representation

   A grayscale image is made of pixels arranged in rows and columns, each pixel having a brightness value.

2. Step 2: Connect to numpy array structure

   A 2D numpy array stores these brightness values in a grid matching the image layout.

3. Final Answer:

   Pixel brightness values arranged in rows and columns -> Option A

4. Quick Check:

   Grayscale image = 2D pixel brightness array [OK]

Hint: Grayscale images use 2D arrays for pixel brightness [OK]

Common Mistakes:

• Confusing pixel values with file names
• Thinking 2D arrays store color channels
• Mixing image size with pixel data

2. Which numpy code correctly flips a 2D image array img vertically?

easy

A. np.fliplr(img)

B. np.flip(img, axis=1)

C. np.flip(img, axis=0)

D. np.flip(img)

Solution

1. Step 1: Understand vertical flip axis

   Vertical flip reverses rows, which corresponds to axis 0 in numpy arrays.

2. Step 2: Match numpy functions to axis

   np.flip(img, axis=0) flips vertically.

3. Final Answer:

   np.flip(img, axis=0) -> Option C

4. Quick Check:

   Vertical flip = axis 0 flip [OK]

Hint: Vertical flip uses axis=0 in np.flip [OK]

Common Mistakes:

• Using axis=1 flips horizontally
• np.flip(img) without axis reverses all axes
• Forgetting axis parameter in np.flip

3. Given this code:

import numpy as np
img = np.array([[10, 20], [30, 40]])
new_img = img + 5
print(new_img)

What is the output?

medium

A. [[10 20]
[30 40]]

B. [[5 15]
[25 35]]

C. [[50 60]
[70 80]]

D. [[15 25]
[35 45]]

Solution

1. Step 1: Understand numpy array addition

   Adding 5 to a numpy array adds 5 to every element (broadcasting).

2. Step 2: Calculate new array values

   Each element increases by 5: 10+5=15, 20+5=25, 30+5=35, 40+5=45.

3. Final Answer:

   [[15 25] [35 45]] -> Option D

4. Quick Check:

   Array + 5 adds 5 to all elements [OK]

Hint: Adding scalar adds to all pixels in array [OK]

Common Mistakes:

• Thinking addition changes shape
• Adding 5 only to first row or column
• Confusing addition with multiplication

4. What is wrong with this code to crop the top-left 2x2 part of a 3x3 image array img?:

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

medium

A. It crops 2 rows but 3 columns, not 2 columns

B. It causes an index error

C. It flips the image instead of cropping

D. It returns the whole image

Solution

1. Step 1: Analyze slicing indices

   The slice img[0:2, 0:3] selects rows 0 and 1 (2 rows) and columns 0,1,2 (3 columns).

2. Step 2: Compare to desired crop size

   We want a 2x2 crop, but this selects 2x3, so it includes one extra column.

3. Final Answer:

   It crops 2 rows but 3 columns, not 2 columns -> Option A

4. Quick Check:

   Slicing columns 0:3 selects 3 columns [OK]

Hint: Check slice ranges match desired rows and columns [OK]

Common Mistakes:

• Assuming slicing is exclusive of end index
• Expecting error from out-of-range slice
• Confusing rows and columns order

5. You have a color image as a 3D numpy array img with shape (100, 100, 3). How do you create a new image gray_img by averaging the color channels for each pixel?

hard

A. gray_img = img.sum(axis=0)

B. gray_img = img.mean(axis=2)

C. gray_img = img[:, :, 0]

D. gray_img = np.flip(img, axis=1)

Solution

1. Step 1: Understand image shape and channels

   The shape (100, 100, 3) means 100x100 pixels with 3 color channels (RGB) along axis 2.

2. Step 2: Average color channels per pixel

   Using img.mean(axis=2) calculates the average of the 3 channels for each pixel, producing a 2D grayscale image.

3. Final Answer:

   gray_img = img.mean(axis=2) -> Option B

4. Quick Check:

   Mean over axis 2 averages color channels [OK]

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

Common Mistakes:

• Summing over wrong axis
• Selecting only one color channel
• Using flip instead of averaging