Overview

Basic image processing operations are the essential tools for manipulating and enhancing digital images. These operations allow us to:

• Reduce noise
• Enhance edges or contrast
• Highlight features
• Prepare images for higher-level vision tasks such as object detection, segmentation, or feature extraction.

We’ll explore the following core operations with a mathematical and implementation-oriented perspective:

1. Image Filtering
2. Edge Detection
3. Histogram Operations (Equalization and Enhancement)

1 Image Filtering (Linear and Non-linear)

What Is Image Filtering?

Filtering is the process of modifying the intensity of each pixel based on its neighbors. It's achieved by convolving the image with a kernel (also called a filter or mask).

Convolution Operation

Let $I(x, y)$ be the input image, and $K(i, j)$ be the kernel (of size $m \times n$). The filtered image $I'(x, y)$ is computed as:

$$I'(x, y) = \sum_{i=-k}^{k} \sum_{j=-l}^{l} K(i, j) \cdot I(x+i, y+j)$$

• $k = \left\lfloor \frac{m}{2} \right\rfloor$, $l = \left\lfloor \frac{n}{2} \right\rfloor$
• This is a 2D discrete convolution (though in practice OpenCV often uses correlation).

Common Linear Filters

Filter	Kernel	Effect
Mean Filter (Box)	All ones, normalized	Blurs image uniformly
Gaussian Filter	Weighted by 2D Gaussian	Smooths image while preserving edges slightly
Laplacian	Second derivative	Detects rapid intensity changes (edges)
Sobel / Prewitt	First derivative	Highlights edges in horizontal/vertical directions

Gaussian Kernel (2D):

$$G(x, y) = \frac{1}{2\pi\sigma^2} \cdot e^{-\frac{x^2 + y^2}{2\sigma^2}}$$

• Used for Gaussian smoothing
• Parameter $\sigma$ controls the degree of blurring

Non-linear Filters

• Median Filter: Replaces each pixel with the median of its neighborhood

  • Excellent for removing salt-and-pepper noise
  • Not a convolution

Implementation Examples (OpenCV)

# Mean filter
blurred = cv2.blur(img, (5, 5))

# Gaussian filter
gauss = cv2.GaussianBlur(img, (5, 5), sigmaX=1.0)

# Median filter
median = cv2.medianBlur(img, 5)

2 Edge Detection

Edge detection identifies points in the image where intensity changes sharply, corresponding to object boundaries or texture changes.

Gradient-Based Methods

We approximate image gradients by convolving with derivative kernels.

First-Order Derivatives (Sobel Operator):

• Horizontal Gradient $G_x$:

$$G_x = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix}$$

• Vertical Gradient $G_y$:

$$G_y = \begin{bmatrix} +1 & +2 & +1 \\ 0 & 0 & 0 \\ -1 & -2 & -1 \end{bmatrix}$$

• Gradient Magnitude:

$$G = \sqrt{G_x^2 + G_y^2}$$

• Direction:

$$\theta = \arctan\left(\frac{G_y}{G_x}\right)$$

Canny Edge Detection (Multi-stage)

A more robust and widely used edge detector. Steps:

1. Gaussian smoothing
2. Gradient computation (Sobel)
3. Non-maximum suppression
4. Double thresholding (hysteresis)

Parameters:

• Low and high threshold for edge strength
• Gaussian kernel size

edges = cv2.Canny(image, threshold1=100, threshold2=200)

3 Histogram Analysis and Equalization

What Is a Histogram?

An image histogram plots the frequency of each intensity level (usually 0–255 for uint8 images).

• For grayscale images: simple 1D histogram of intensity.
• For color images: compute separate histograms for each channel.

Histogram Equalization

Enhances the contrast of an image by spreading out the intensity distribution.

Let $h(i)$ be the histogram, $p(i) = \frac{h(i)}{N}$ the probability of intensity $i$, and the cumulative distribution function (CDF) be:

$$\text{CDF}(i) = \sum_{j=0}^{i} p(j)$$

Then, the equalized value $i'$ is:

$$i' = \text{round}(255 \cdot \text{CDF}(i))$$

This mapping redistributes pixel values so that the histogram becomes approximately uniform.

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
equalized = cv2.equalizeHist(gray)

Adaptive Histogram Equalization (CLAHE)

• CLAHE = Contrast Limited Adaptive Histogram Equalization
• Divide the image into tiles, and apply equalization on each local tile (e.g., 8x8)
• Prevents overamplification of noise by histogram clipping

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
enhanced = clahe.apply(gray)

Summary Table

Operation	Math Principle	Common Use
Mean / Gaussian Blur	Convolution with smoothing kernel	Denoising, pre-processing
Median Filter	Non-linear local sorting	Removing salt-and-pepper noise
Sobel / Prewitt	First derivative (gradient)	Edge detection
Laplacian	Second derivative	Edge enhancement
Canny Edge	Multi-step gradient & thresholding	High-quality edge map
Histogram Equalization	CDF-based mapping	Global contrast enhancement
CLAHE	Local histogram equalization	Local contrast enhancement

Suggested Exercises

1. Manually implement a 3×3 mean filter using NumPy and compare with cv2.blur.
2. Plot the histogram of a grayscale image before and after equalization.
3. Try Canny edge detection with different thresholds. Observe how edge maps change.
4. Visualize Sobel gradients ($G_x$, $G_y$, and magnitude) using matplotlib.