Coding and Robotics Classes for Kids in Lodz

Chapter 164 — Image Processing with OpenCV and Python: A Beginner's Guide

1. Introduction to OpenCV & Environment Setup

In computer vision, theoretical concepts such as spatial filtering, feature extraction, and image transformations require practical hands-on execution. In Python, the industry-standard tool for image and video processing is OpenCV (Open Source Computer Vision Library).

  ┌─────────────────────────────────────────────────────────────┐
  │                   OpenCV Architecture & Setup               │
  ├─────────────────────────────────────────────────────────────┤
  │  • Core Engine: Written in C++ for maximum computational    │
  │    speed.                                                   │
  │                                                             │
  │  • Python Integration: Utilizes Python bindings (cv2        │
  │    module) that integrate seamlessly with NumPy arrays      │
  │                                                             │
  │  • Installation Command: pip install opencv-python          │
  │  • Import Statement   : import cv2                          │
  └─────────────────────────────────────────────────────────────┘
    

Key Application Domains:

OpenCV powers real-world computer vision systems across diverse fields:

• Object & Face Detection: Locating objects and human faces in digital frames.
• Traffic Sign Recognition: Identifying road signs in autonomous vehicles.
• Medical Image Enhancement: Refining CT and MRI visual scans.
• AR/VR & Robotics: Guiding robotic vision systems and augmented reality overlays.

2. Image Ingestion, Display, & Color Spaces (BGR vs. RGB)

A. Reading and Displaying Images:

To process an image, OpenCV loads file formats (such as JPEG, PNG, or TIFF) from disk into computer memory as a multidimensional NumPy array.

import cv2
import numpy as np

# 1. Read image from disk
image = cv2.imread('flower.jpg')

# Verify image loading
if image is None:
    print("Error: Image not found!")
    

To display an image on screen, OpenCV creates a window frame using cv2.imshow(). To prevent the display window from closing instantly, cv2.waitKey(0) pauses program execution until a keyboard key is pressed.

# 2. Display image in a popup window
cv2.imshow('Original Image', image)

# Wait indefinitely for a keypress before continuing
cv2.waitKey(0)
    

B. The BGR Color Format vs. Standard RGB:

A critical quirk of OpenCV is its native color channel order. While standard human-readable digital formats use RGB (Red, Green, Blue), OpenCV stores color channels in BGR (Blue, Green, Red) order.

  ┌─────────────────────────────────────────────────────────────┐
  │                 Color Channel Storage Order                 │
  ├───────────────────────────────┬─────────────────────────────┤
  │ Standard Visual Formats (RGB) │ OpenCV Native Format (BGR)  │
  ├───────────────────────────────┼─────────────────────────────┤
  │ • Channel 0 ──► Red           │ • Channel 0 ──► Blue        │
  │ • Channel 1 ──► Green         │ • Channel 1 ──► Green       │
  │ • Channel 2 ──► Blue          │ • Channel 2 ──► Red         │
  └───────────────────────────────┴─────────────────────────────┘
    

C. Converting to Grayscale:

For pre-processing, 3-channel BGR images are frequently converted into 1-channel Grayscale images using cv2.cvtColor(). This compresses visual data into 8 bits per pixel, representing 256 discrete shades of gray (ranging from 0 for pure black to 255 for pure white), which isolates spatial and geometric features while discarding color noise.

# Convert BGR color image to 8-bit Grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

cv2.imshow('Grayscale Image', gray_image)
cv2.waitKey(0)
    

3. Image Filtering & Noise Reduction (Gaussian & Median Blur)

Before extracting features, raw images must undergo spatial filtering to remove high-frequency noise. Applying edge detection to raw images directly can produce fragmented edge boundaries due to pixel noise. Applying blurring filters first ensures that downstream algorithms extract continuous, connected edge components.

  ┌─────────────────────────────────────────────────────────────┐
  │                  Spatial Filtering Operations               │
  ├───────────────────────────────┬─────────────────────────────┤
  │ Gaussian Blur (cv2.GaussianBlur)│ Median Blur (cv2.medianBlur)│
  ├───────────────────────────────┼─────────────────────────────┤
  │ • Uses a 2D Gaussian kernel   │ • Replaces target pixel with│
  │   (e.g., 5×5 grid).           │   the median of neighbors.  │
  │ • Smooths high-frequency noise│ • Highly effective at salt- │
  │   smoothly.                   │   and-pepper noise removal. │
  └───────────────────────────────┴─────────────────────────────┘
    

# 1. Apply 5x5 Gaussian Blur for smooth noise reduction
gaussian_blur = cv2.GaussianBlur(gray_image, (5, 5), 0)
cv2.imshow('Gaussian Blur', gaussian_blur)
cv2.waitKey(0)

# 2. Apply Median Blur with kernel size 5
median_blur = cv2.medianBlur(gray_image, 5)
cv2.imshow('Median Blur', median_blur)
cv2.waitKey(0)
    

4. Feature Extraction: Canny Edge Detection

Once an image has been smoothed, we can perform feature extraction to identify key structural boundaries.

  ┌─────────────────────────────────────────────────────────────┐
  │                Canny Edge Detector Pipeline                 │
  ├─────────────────────────────────────────────────────────────┤
  │  Input: Pre-processed & Blurred Grayscale Image             │
  │       │                                                     │
  │       ▼                                                     │
  │  cv2.Canny(image, threshold1, threshold2)                   │
  │       │                                                     │
  │       ▼                                                     │
  │  Dual Hysteresis Thresholds (e.g., 100 & 200)               │
  │       │                                                     │
  │       ▼                                                     │
  │  Output: Binary Edge Map (Highlights Structural Outlines)   │
  └─────────────────────────────────────────────────────────────┘
    

The Canny Edge Detector is an advanced edge detection algorithm that evaluates local pixel intensity gradients using dual hysteresis threshold parameters (e.g., threshold1 = 100, threshold2 = 200).

# Extract edges using Canny Edge Detection
edges = cv2.Canny(gaussian_blur, 100, 200)

cv2.imshow('Canny Edges', edges)
cv2.waitKey(0)
    

5. Geometric Image Transformations (Resize, Rotate, Flip)

OpenCV provides built-in functions to modify the spatial geometry and orientation of image matrices:

  ┌─────────────────────────────────────────────────────────────┐
  │                 Geometric Transformation Methods            │
  ├─────────────────────────────────────────────────────────────┤
  │  1. Resizing (cv2.resize):                                  │
  │     • Shrinks or expands spatial width and height.          │
  │     • Reduces computational load for faster execution.      │
  │                                                             │
  │  2. Rotation (cv2.getRotationMatrix2D + cv2.warpAffine):    │
  │     • Calculates center coordinates (width/2, height/2).    │
  │     • Generates affine rotation matrix at specified angle   │
  │       (e.g., 45°) with minimal quality loss.                │
  │                                                             │
  │  3. Flipping (cv2.flip):                                    │
  │     • Flips image along X-axis (0) or Y-axis (1).           │
  └─────────────────────────────────────────────────────────────┘
    

# 1. Resize Image to 400x300 pixels
resized_img = cv2.resize(image, (400, 300))
cv2.imshow('Resized Image', resized_img)
cv2.waitKey(0)

# 2. Rotate Image by 45 degrees around its center
height, width = image.shape[:2]
center = (width // 2, height // 2)

# Compute 2D rotation matrix for 45-degree angle
rotation_matrix = cv2.getRotationMatrix2D(center, 45, 1.0)
rotated_img = cv2.warpAffine(image, rotation_matrix, (width, height))

cv2.imshow('Rotated Image', rotated_img)
cv2.waitKey(0)

# 3. Flip Image along the Y-axis (horizontal flip)
flipped_img = cv2.flip(image, 1)
cv2.imshow('Flipped Image', flipped_img)
cv2.waitKey(0)
    

6. Saving Output Files & Memory Cleanup

After completing pre-processing, filtering, and feature extraction, the processed outputs can be written back to disk using cv2.imwrite().

  ┌─────────────────────────────────────────────────────────────┐
  │               Memory Management & Window Cleanup            │
  ├─────────────────────────────────────────────────────────────┤
  │  • Save Output Image : cv2.imwrite('edges_out.jpg', edges)  │
  │                                                             │
  │  • Clean Memory      : cv2.destroyAllWindows()              │
  │                                                             │
  │  • Crucial Rule: Destroying OpenCV display windows releases │
  │    allocated memory buffers and prevents memory leaks.      │
  └─────────────────────────────────────────────────────────────┘
    

# Save extracted edge output to disk
cv2.imwrite('edges_output.jpg', edges)

# Close all GUI windows and release allocated memory
cv2.destroyAllWindows()
    

7. Complete Executable Python Script

Below is the complete runnable Python script implementing Topic 164:

# =====================================================================
# Complete OpenCV Image Processing Pipeline (Topic 164)
# =====================================================================

import cv2
import numpy as np

# 1. Ingest Image from Disk
img_path = 'flower.jpg'
image = cv2.imread(img_path)

if image is None:
    print(f"Error: Could not read image at {img_path}")
else:
    # 2. Display Original BGR Image
    cv2.imshow('1 - Original Image', image)
    cv2.waitKey(0)

    # 3. Convert Color Space: BGR to Grayscale
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    cv2.imshow('2 - Grayscale', gray)
    cv2.waitKey(0)

    # 4. Apply Spatial Blurring Filters
    gauss_blur = cv2.GaussianBlur(gray, (5, 5), 0)
    cv2.imshow('3 - Gaussian Blur', gauss_blur)
    cv2.waitKey(0)

    med_blur = cv2.medianBlur(gray, 5)
    cv2.imshow('4 - Median Blur', med_blur)
    cv2.waitKey(0)

    # 5. Extract Features using Canny Edge Detection
    edges = cv2.Canny(gauss_blur, 100, 200)
    cv2.imshow('5 - Canny Edges', edges)
    cv2.waitKey(0)

    # 6. Apply Geometric Transformations: Resizing
    resized = cv2.resize(image, (400, 300))
    cv2.imshow('6 - Resized Image', resized)
    cv2.waitKey(0)

    # 7. Apply Geometric Transformations: 45-Degree Rotation
    h, w = image.shape[:2]
    center = (w // 2, h // 2)
    rot_mat = cv2.getRotationMatrix2D(center, 45, 1.0)
    rotated = cv2.warpAffine(image, rot_mat, (w, h))
    cv2.imshow('7 - Rotated Image', rotated)
    cv2.waitKey(0)

    # 8. Apply Geometric Transformations: Y-Axis Flip
    flipped = cv2.flip(image, 1)
    cv2.imshow('8 - Flipped Image', flipped)
    cv2.waitKey(0)

    # 9. Save Edge Feature Output to Disk
    cv2.imwrite('edges_output.jpg', edges)
    print("Successfully saved 'edges_output.jpg' to disk!")

    # 10. Memory Cleanup: Destroy all display windows
    cv2.destroyAllWindows()
    

8. Summary Pipeline Table

Processing Stage	OpenCV Function	Key Parameters & Operations	Practical Objective
Image Ingestion	cv2.imread()	File path string.	Loads image as a NumPy array.
Display Window	cv2.imshow() & cv2.waitKey(0)	Title string & image matrix.	Renders visual window & waits for keypress.
Color Conversion	cv2.cvtColor()	cv2.COLOR_BGR2GRAY.	Converts 3-channel BGR to 1-channel Grayscale.
Gaussian Blur	cv2.GaussianBlur()	(5, 5) kernel size.	Smooths high-frequency noise.
Median Blur	cv2.medianBlur()	Kernel threshold 5.	Removes salt-and-pepper noise.
Edge Detection	cv2.Canny()	Thresholds (100, 200).	Extracts structural boundary lines.
Resizing	cv2.resize()	Target dimensions (400, 300).	Reduces compute load for faster processing.
Rotation	cv2.getRotationMatrix2D() + cv2.warpAffine()	Center, 45° angle, scale 1.0.	Performs affine rotation with minimal loss.
Flipping	cv2.flip()	Flip code 1 (Y-axis) or 0 (X-axis).	Flips orientation horizontally/vertically.
File Writing	cv2.imwrite()	Output filename & array.	Saves processed output matrix to disk.
Cleanup	cv2.destroyAllWindows()	No arguments.	Frees allocated RAM & closes GUI windows.