Mahmoud Abas, Full-Stack Software Engineer & AI

ROS 2 Practical - Computer Vision Lab: Image Processing & Object Detection

In the print dialog, choose "Save as PDF" as the destination.

ROS 2 Practical - Lesson 8

Computer Vision Lab: Image Processing and Object Detection

OpenCV fundamentals, from pixels to pedestrian detection

What This Lab Covers

Basic image operations: read, resize, color conversion
Edge detection: Laplacian, Sobel, Canny
Thresholding: global and adaptive
Pedestrian detection using HOG descriptors
Camera calibration: intrinsic and extrinsic parameters

python

import cv2 as cv
import numpy as np
print(f"OpenCV Version: {cv.__version__}")

Check the installed OpenCV version before anything else.

Basic Image Operations

Images load as BGR NumPy arrays: img.shape = (height, width, channels)
Rescaling a frame keeps processing fast, especially on video

python

def rescale(frame, scale=0.75):
    height = int(frame.shape[0] * scale)
    width = int(frame.shape[1] * scale)
    return cv.resize(frame, (width, height), interpolation=cv.INTER_AREA)

Scale factor 0.75 keeps 75% of the original size.

Grayscale conversion is a common preprocessing step before edge detection

python

gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

Gaussian Blur and Morphology

Gaussian blur reduces noise and detail before edge detection
Kernel size must be odd (3x3, 5x5, 7x7); a larger kernel means more blur

python

blur = cv.GaussianBlur(img, (7, 7), cv.BORDER_DEFAULT)

Morphological operations refine a binary image after edge detection

python

canny = cv.Canny(img, 125, 175)
kernel = np.ones((3, 3), np.uint8)
dilated = cv.dilate(canny, kernel, iterations=1)  # expand white regions
eroded = cv.erode(canny, kernel, iterations=1)    # shrink white regions

dilate expands white regions, erode shrinks them.

Edge Detection: Laplacian and Sobel

Laplacian: A second-derivative operator that detects edges in all directions and is sensitive to noise. Use cv.CV_64F to preserve negative values before taking abs().

python

lap = cv.Laplacian(gray, cv.CV_64F)
lap_abs = np.uint8(np.absolute(lap))

Sobel: A first-derivative operator with separate X/Y gradients that can be combined into one edge map.

python

sobelx = cv.Sobel(gray, cv.CV_64F, 1, 0)   # vertical edges
sobely = cv.Sobel(gray, cv.CV_64F, 0, 1)   # horizontal edges
combined = cv.bitwise_or(np.uint8(np.absolute(sobelx)),
                          np.uint8(np.absolute(sobely)))

Edge Detection: Canny

A multi-stage algorithm, best for clean, well-defined edges

Gaussian Blur

Gradient Calculation

Non-Max Suppression

Double Thresholding

Hysteresis Edge Tracking

python

canny = cv.Canny(gray, 150, 175)

Thresholding: Global vs Adaptive

Global (simple): One threshold value applied to the whole image.

python

_, thresh_binary = cv.threshold(gray, 150, 255, cv.THRESH_BINARY)

Adaptive: Threshold computed per local neighborhood, better for uneven lighting.

python

adaptive_mean = cv.adaptiveThreshold(
    gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY,
    11,   # block size (must be odd)
    9)    # C: constant subtracted from the mean

11 is the block size (must be odd); 9 is C, subtracted from the local mean.

	Global	Adaptive
Threshold	Single value	Local values
Best for	Uniform lighting	Varying lighting
Speed	Faster	Slower

HOG Pedestrian Detection

HOG (Histogram of Oriented Gradients): A feature descriptor paired with an SVM classifier for detecting people.

Compute Gradients

Per-Cell Histograms

Normalize Across Blocks

Feature Vector

SVM Classify

python

hog = cv.HOGDescriptor()
hog.setSVMDetector(cv.HOGDescriptor_getDefaultPeopleDetector())

(regions, weights) = hog.detectMultiScale(
    image,
    winStride=(4, 4),   # sliding window step (smaller = more detections, slower)
    padding=(4, 4),     # padding around detected regions
    scale=1.05)         # image pyramid scale factor

winStride smaller means more detections but slower; scale is the image pyramid factor.

Applying HOG

HOG on Video

python

cap = cv2.VideoCapture('streetup.mp4')
while cap.isOpened():
    ret, image = cap.read()
    if not ret:
        break
    image = imutils.resize(image, width=min(400, image.shape[1]))
    (regions, _) = hog.detectMultiScale(image, winStride=(4, 4),
                                         padding=(4, 4), scale=1.05)
    for (x, y, w, h) in regions:
        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)
    cv2.imshow('Pedestrian Detection', image)
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

Same hog descriptor from the previous slide, run frame by frame on streetup.mp4.

Camera Calibration: Why and What

Determines intrinsic (camera matrix) and extrinsic (rotation and translation) parameters
Needed for 3D reconstruction, accurate measurement, and removing lens distortion

text

Camera Matrix:        Distortion Coefficients:
[fx  0  cx]            [k1, k2, p1, p2, k3]
[0  fy  cy]            k1,k2,k3 = radial
[0   0   1]            p1,p2 = tangential

Capture Checkerboard Images

Detect Corners

Refine Corners

3D Coordinates

calibrateCamera

Running a Calibration

python

CHECKERBOARD = (6, 9)   # internal corners
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

for fname in glob.glob('./images/*.jpg'):
    gray = cv2.cvtColor(cv2.imread(fname), cv2.COLOR_BGR2GRAY)
    ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, None)
    if ret:
        objpoints.append(objp)
        corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        imgpoints.append(corners2)

ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(
    objpoints, imgpoints, gray.shape[::-1], None, None)

Loops every calibration image, finds and refines its corners, then calibrates once over the whole set.

Function Reference Summary

Topic	Key Functions
Basic ops	`imread`, `resize`, `cvtColor`, `GaussianBlur`
Edge detection	`Laplacian`, `Sobel`, `Canny`
Thresholding	`threshold`, `adaptiveThreshold`
HOG detection	`HOGDescriptor`, `detectMultiScale`
Calibration	`findChessboardCorners`, `calibrateCamera`

Key Takeaways

Grayscale conversion and Gaussian blur are the standard preprocessing steps before edge detection
Canny, being multi-stage, generally gives cleaner edges than Laplacian or Sobel alone
Adaptive thresholding beats global thresholding whenever lighting is uneven across the image
HOG + SVM is a classic, lightweight pipeline for pedestrian detection; tune winStride and scale to trade speed for accuracy
Camera calibration with a checkerboard yields the camera matrix (focal length, principal point) and the distortion coefficients needed to undistort images
These techniques are the building blocks a robot's vision pipeline layers on top of: obstacle detection, marker tracking, calibrated stereo vision

Open this lesson

Mahmoud AbasComputer Vision Lab: Image Processing & Object Detection

canny = cv.Canny(img, 125, 175) kernel = np.ones((3, 3), np.uint8) dilated = cv.dilate(canny, kernel, iterations=1) # expand white regions eroded = cv.erode(canny, kernel, iterations=1) # shrink white regions

sobelx = cv.Sobel(gray, cv.CV_64F, 1, 0) # vertical edges sobely = cv.Sobel(gray, cv.CV_64F, 0, 1) # horizontal edges combined = cv.bitwise_or(np.uint8(np.absolute(sobelx)), np.uint8(np.absolute(sobely)))

Global

Adaptive

Threshold

Single value

Local values

Best for

Uniform lighting

Varying lighting

Speed

Faster

Slower

hog = cv.HOGDescriptor() hog.setSVMDetector(cv.HOGDescriptor_getDefaultPeopleDetector()) (regions, weights) = hog.detectMultiScale( image, winStride=(4, 4), # sliding window step (smaller = more detections, slower) padding=(4, 4), # padding around detected regions scale=1.05) # image pyramid scale factor

cap = cv2.VideoCapture('streetup.mp4') while cap.isOpened(): ret, image = cap.read() if not ret: break image = imutils.resize(image, width=min(400, image.shape[1])) (regions, _) = hog.detectMultiScale(image, winStride=(4, 4), padding=(4, 4), scale=1.05) for (x, y, w, h) in regions: cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2) cv2.imshow('Pedestrian Detection', image) if cv2.waitKey(25) & 0xFF == ord('q'): break

CHECKERBOARD = (6, 9) # internal corners criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001) for fname in glob.glob('./images/*.jpg'): gray = cv2.cvtColor(cv2.imread(fname), cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, CHECKERBOARD, None) if ret: objpoints.append(objp) corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria) imgpoints.append(corners2) ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera( objpoints, imgpoints, gray.shape[::-1], None, None)

Topic

Key Functions

Basic ops

imread, resize, cvtColor, GaussianBlur

Edge detection

Laplacian, Sobel, Canny

Thresholding

threshold, adaptiveThreshold

HOG detection

HOGDescriptor, detectMultiScale

Calibration

findChessboardCorners, calibrateCamera