Computer Vision Basics

A pixel ("picture element") is one dot of an image. In a grayscale image each pixel is a single number from 0 (black) to 255 (white), with greys in between. You store the whole image as a list of rows — a nested list — and read any pixel with image[row][col].

A colour image adds a third dimension: every pixel becomes three numbers — Red, Green and Blue (RGB). That is why a 224×224 colour photo is 224 × 224 × 3 = 150,528 numbers. Run the worked example below to read pixels and measure an image's size.

# An image is just a grid of numbers. No libraries needed.
# Each number is a "pixel": 0 = black, 255 = white, in between = grey.

# A tiny 3x3 grayscale image stored as a nested list (a list of rows)
image = [
    [  0, 128, 255],   # row 0: black, grey, white
    [128, 255, 128],   # row 1
    [255, 128,   0],   # row 2
]

# Print it like a picture so you can "see" the numbers
print("=== Pixel values ===")
for row in image:
    print(row)

# Read one pixel: image[row][col]
print()
print("Top-l
...

Once an image is numbers, editing it is just arithmetic. Brightening adds a fixed amount to every pixel — but you must clip the result to the 0–255 range, because a pixel can never be darker than black or brighter than white. Thresholding turns the image pure black-and-white: any pixel at or above a cutoff becomes 255, everything else becomes 0. That is the simplest way to separate a bright object from a dark background.

# Two of the most common image operations, written by hand.

image = [
    [  0, 128, 255],
    [128, 255, 128],
    [255, 128,   0],
]

# 1) BRIGHTEN: add a value to every pixel, then "clip" to the 0-255 range.
#    Clipping matters: pixels can never go below 0 or above 255.
def brighten(img, amount):
    out = []
    for row in img:
        new_row = []
        for pixel in row:
            value = pixel + amount
            value = max(0, min(255, value))   # clip into 0..255
            new_
...

Convolution is the single most important idea in computer vision, and it is much simpler than it sounds: slide a small grid of numbers (a "filter" or "kernel") across the image and combine the pixels underneath it. A 2×2 average filter replaces each region with the average of its four pixels — that softens the image (a blur). The result is slightly smaller than the input, because the window cannot hang off the edge.

# Convolution sounds scary; it is just "slide a small grid over the image
# and combine the numbers underneath." Here is a 2x2 AVERAGE (blur) filter.

image = [
    [ 10,  20,  30],
    [ 40,  50,  60],
    [ 70,  80,  90],
]

# Slide a 2x2 window across the image. For a 3x3 image, the window fits in
# 2 positions across and 2 down -> the result is 2x2 (it shrinks at the edges).
def average_2x2(img):
    out = []
    for i in range(len(img) - 1):          # rows 0,1
        new_row = []
        
...

Swap the filter's numbers and the same sliding machinery does something else entirely. An edge-detection kernel gives a strong response wherever brightness changes sharply, and near zero across flat regions. That is the intuition behind "finding edges." The numpy example below applies a real edge kernel to a 5×5 image.

import numpy as np   # the real world uses numpy, not nested lists

# A 5x5 image with a bright square in the middle
image = np.array([
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0],
], dtype=float)

# A 3x3 edge-detection kernel: it fires where the centre differs from neighbours
edge_kernel = np.array([
    [-1, -1, -1],
    [-1,  8, -1],
    [-1, -1, -1],
], dtype=float)

def convolve(img, kernel):
    kh, kw = kernel.shape
    out = np
...

A CNN stacks the idea you just built. A convolution layer applies many filters at once — but instead of you choosing the numbers, the network learns them during training. Each filter produces a feature map: a grid showing where that pattern was found. Early layers learn edge filters, deeper layers learn shape and object filters — exactly the eye/brain ladder from the analogy.

A pooling layer (usually MaxPool 2×2) then shrinks each feature map by keeping only the strongest value in each 2×2 block. This throws away precise positions but keeps "was the feature here, roughly?", which makes the network smaller and more robust. Conv → Pool → Conv → Pool repeats until a Flatten turns the maps into a vector for a final Dense classifier.

In real frameworks you describe this stack in a few lines. The example below sketches an OpenCV pre-processing step (note the BGR→RGB fix) and a small Keras CNN. The shapes shrink layer by layer — read the # Expected output to see how.

# ── OpenCV reads images as BGR, not RGB! A classic bug. ──
import cv2                       # pip install opencv-python
img = cv2.imread("cat.jpg")      # shape (H, W, 3) in B, G, R order
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   # convert before showing/feeding
img = cv2.resize(img, (224, 224))            # CNNs need a fixed input size
img = img / 255.0                            # normalise pixels to 0..1

# ── A small image classifier in Keras (TensorFlow) ──
from tensorflow import keras

...

These four mistakes trip up nearly every beginner. Spotting them saves hours.

image = image / 255.0   # now every pixel is between 0.0 and 1.0

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

img = cv2.resize(img, (224, 224))