NumPy in Practice — An Image is an Array

• Load an image into a NumPy array; read its shape (H, W, 3).
• Understand RGB pixel values 0-255.
• Crop, flip, brighten, and grayscale using array operations.
• Display arrays as images with matplotlib.

A colour image of height 400, width 600:
  shape = (400, 600, 3)
                      └─ 3 colour channels: Red, Green, Blue

One pixel = [R, G, B], each 0-255:
  [255,   0,   0]  → pure red
  [  0, 255,   0]  → pure green
  [255, 255, 255]  → white
  [  0,   0,   0]  → black

pip install numpy pillow matplotlib

Load & inspect

import numpy as np
from PIL import Image

img = Image.open("cat.jpg")
arr = np.array(img)

print(arr.shape)    # (400, 600, 3)  → height, width, channels
print(arr.dtype)    # uint8  (0-255)
print(arr[0, 0])    # [R G B] of the top-left pixel

Display it

import matplotlib.pyplot as plt
plt.imshow(arr)
plt.axis("off")
plt.show()

Crop = slice

# rows 50-250, cols 100-400, all channels
crop = arr[50:250, 100:400, :]
plt.imshow(crop); plt.show()

Flip = reverse an axis

flip_h = arr[:, ::-1, :]    # mirror left-right
flip_v = arr[::-1, :, :]    # upside down

Brighten = add, then clip

# add 50 to every value, but keep within 0-255
bright = np.clip(arr.astype(int) + 50, 0, 255).astype(np.uint8)

We cast to int first so adding doesn't overflow the uint8 range, then np.clip caps at 255, then cast back.

Grayscale = weighted channel sum

# human eyes weight green most, blue least
weights = np.array([0.299, 0.587, 0.114])
gray = (arr @ weights).astype(np.uint8)    # shape (H, W)
plt.imshow(gray, cmap="gray"); plt.show()

The @ operator (matrix multiply) collapses the 3 channels into 1 using the luminance weights. One line, real image processing.

# photo_edit.py — four edits, one figure
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

arr = np.array(Image.open("cat.jpg"))

def grayscale(a):
    return (a @ np.array([0.299, 0.587, 0.114])).astype(np.uint8)

def brighten(a, amount):
    return np.clip(a.astype(int) + amount, 0, 255).astype(np.uint8)

def red_only(a):
    out = a.copy()
    out[:, :, 1] = 0    # zero green
    out[:, :, 2] = 0    # zero blue
    return out

fig, axes = plt.subplots(2, 2, figsize=(8, 6))
axes[0, 0].imshow(arr);                   axes[0, 0].set_title("original")
axes[0, 1].imshow(grayscale(arr), cmap="gray"); axes[0, 1].set_title("grayscale")
axes[1, 0].imshow(brighten(arr, 60));     axes[1, 0].set_title("brighter")
axes[1, 1].imshow(red_only(arr));         axes[1, 1].set_title("red channel")
for ax in axes.flat:
    ax.axis("off")
fig.tight_layout()
fig.savefig("edits.png", dpi=150)
plt.show()

Read the diff

Every effect is pure array maths: a weighted sum for grayscale, clipped addition for brightness, zeroing channels for the red filter. No image library "effects" — just NumPy. This is exactly the data a CNN receives in Lesson 27.

An image is a (H, W, 3) array of 0-255 values. Crop = slice; flip = reverse an axis; brighten = clipped addition; grayscale = weighted channel sum; recolour = boolean mask. Computer vision is array maths all the way down. Next we go back to tabular data and prep it for models.