Image Processing Algorithms in Computer Vision

Last Updated : 23 Jul, 2025

In the field of computer vision, image preprocessing is a crucial step that involves transforming raw image data into a format that can be effectively utilized by machine learning algorithms. Proper preprocessing can significantly enhance the accuracy and efficiency of image recognition tasks. This article explores various image preprocessing algorithms commonly used in computer vision.

What is image processing in computer vision?

Image processing in computer vision refers to a set of techniques and algorithms used to manipulate and analyze digital images to extract meaningful information. It involves transforming raw image data into a format that is easier to understand and interpret by both humans and machine learning algorithms. The goal of image processing is to improve the quality of images, enhance specific features, and prepare the data for further analysis, recognition, and decision-making tasks.

Key Objectives of Image Processing

Enhancement: Improving the visual appearance of an image or accentuating certain features to make them more prominent.
Restoration: Correcting defects or distortions in an image to recover the original scene.
Segmentation: Dividing an image into meaningful regions or objects for easier analysis.
Compression: Reducing the size of image files for storage and transmission efficiency.
Analysis: Extracting quantitative or qualitative information from images.

Now we will discuss all the different preprocessing algorithms used in computer vision;

1. Image Resizing

Image resizing changes the dimensions of an image. The challenge is to maintain image quality while altering its size. Here are the main interpolation methods:

a) Nearest Neighbor Interpolation:

Simplest and fastest method
Selects the pixel value of the nearest neighbor
Results in a blocky image when enlarging

b) Bilinear Interpolation:

Uses a weighted average of the 4 nearest pixel values
Smoother results than nearest neighbor, but can cause some blurring

c) Bicubic Interpolation:

Uses a weighted average of the 16 nearest pixel values
Produces the smoothest results, especially for photographic images

Code Implementation

Python

import cv2
import numpy as np
import matplotlib.pyplot as plt

def resize_image(image, target_size):
    print(f"Original image shape: {image.shape}")
    print(f"Target size: {target_size}")
    
    resized_nn = cv2.resize(image, target_size, interpolation=cv2.INTER_NEAREST)
    resized_bilinear = cv2.resize(image, target_size, interpolation=cv2.INTER_LINEAR)
    resized_bicubic = cv2.resize(image, target_size, interpolation=cv2.INTER_CUBIC)
    
    print(f"Resized image shape: {resized_nn.shape}")
    
    return resized_nn, resized_bilinear, resized_bicubic

# Example usage
image_path = '/kaggle/input/sample-image/tint1.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    target_size = (800, 600)
    nn, bilinear, bicubic = resize_image(image, target_size)
    
    # Display the results
    plt.figure(figsize=(15, 5))
    
    plt.subplot(131)
    plt.imshow(cv2.cvtColor(nn, cv2.COLOR_BGR2RGB))
    plt.title('Nearest Neighbor')
    plt.axis('off')
    
    plt.subplot(132)
    plt.imshow(cv2.cvtColor(bilinear, cv2.COLOR_BGR2RGB))
    plt.title('Bilinear')
    plt.axis('off')
    
    plt.subplot(133)
    plt.imshow(cv2.cvtColor(bicubic, cv2.COLOR_BGR2RGB))
    plt.title('Bicubic')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Code Explanation:

Import Libraries: Imports cv2 for image processing, numpy for calculations, and matplotlib.pyplot for plotting images.
Define resize_image Function: Resizes the image using three methods: Nearest Neighbor, Bilinear, and Bicubic interpolation.
Load Image: Reads the image from the specified path and checks if the image was loaded successfully.
Perform Resizing: Applies Nearest Neighbor, Bilinear, and Bicubic resizing methods to the image.
Display Results: Shows the original image resized using different methods side by side using matplotlib.

2. Image Normalization

Normalization adjusts pixel intensity values to a standard scale. Common techniques include:

a) Min-Max Scaling:

Scales values to a fixed range, typically [0, 1].

Formula: (x - min) / (max - min)

b) Z-score Normalization:

Transforms data to have a mean of 0 and standard deviation of 1.

Formula: (x - mean) / standard_deviation

c) Histogram Equalization:

Enhances contrast by spreading out the most frequent intensity values.

Implementation

Python

import cv2
import numpy as np
import matplotlib.pyplot as plt

def normalize_image(image):
    print("Performing image normalization...")
    
    # Min-Max Scaling
    min_max = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX)
    
    # Z-score Normalization
    z_score = np.zeros_like(image, dtype=np.float32)
    for i in range(3):  # for each channel
        channel = image[:,:,i]
        mean = np.mean(channel)
        std = np.std(channel)
        z_score[:,:,i] = (channel - mean) / (std + 1e-8)  # adding small value to avoid division by zero
    z_score = cv2.normalize(z_score, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
    
    # Histogram Equalization
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    hist_eq = cv2.equalizeHist(gray)
    
    print("Normalization complete.")
    return min_max, z_score, hist_eq

# Example usage
image_path = '/kaggle/input/sample-image/input_image.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    min_max, z_score, hist_eq = normalize_image(image)
    
    # Display the results
    plt.figure(figsize=(20, 5))
    
    plt.subplot(141)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title('Original')
    plt.axis('off')
    
    plt.subplot(142)
    plt.imshow(cv2.cvtColor(min_max, cv2.COLOR_BGR2RGB))
    plt.title('Min-Max Scaling')
    plt.axis('off')
    
    plt.subplot(143)
    plt.imshow(cv2.cvtColor(z_score, cv2.COLOR_BGR2RGB))
    plt.title('Z-score Normalization')
    plt.axis('off')
    
    plt.subplot(144)
    plt.imshow(hist_eq, cmap='gray')
    plt.title('Histogram Equalization')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Code Explanation:

Import Libraries: Imports cv2, numpy, and matplotlib.pyplot for image processing and visualization.
Define normalize_image Function: Applies Min-Max Scaling, Z-Score Normalization, and Histogram Equalization to the image.
Load Image: Reads an image from a specified path and checks if it loaded successfully.
Perform Normalization: Executes Min-Max Scaling, Z-Score Normalization, and Histogram Equalization to adjust the image.
Display Results: Shows the original and processed images side by side using matplotlib.

3. Image Augmentation

Image augmentation creates modified versions of images to expand the training dataset. Key techniques include:

a.) Geometric Transformations:

Rotation: Turning the image around a center point.
Flipping: Mirroring the image horizontally or vertically.
Scaling: Changing the size of the image.
Cropping: Cutting out a part of the image to use.

b) Color Adjustments:

Brightness: Making the image lighter or darker.
Contrast: Changing the difference between light and dark areas.
Saturation: Adjusting the intensity of colors.
Hue: Shifting the overall color tone of the image.

c) Noise Addition:

Adding Random Noise: Introducing random variations to pixel values to simulate imperfections.

Python

import cv2
import numpy as np
import matplotlib.pyplot as plt

def augment_image(image):
    print("Performing image augmentation...")
    
    # Rotation
    rows, cols = image.shape[:2]
    M = cv2.getRotationMatrix2D((cols/2, rows/2), 45, 1)
    rotated = cv2.warpAffine(image, M, (cols, rows))
    
    # Flipping
    flipped = cv2.flip(image, 1)  # 1 for horizontal flip
    
    # Brightness adjustment
    bright = cv2.convertScaleAbs(image, alpha=1.5, beta=0)
    
    # Add noise
    noise = np.random.normal(0, 25, image.shape).astype(np.uint8)
    noisy = cv2.add(image, noise)
    
    print("Augmentation complete.")
    return rotated, flipped, bright, noisy

# Example usage
image_path = '/kaggle/input/sample-image/input_image.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    rotated, flipped, bright, noisy = augment_image(image)
    
    # Display the results
    plt.figure(figsize=(20, 5))
    
    plt.subplot(151)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title('Original')
    plt.axis('off')
    
    plt.subplot(152)
    plt.imshow(cv2.cvtColor(rotated, cv2.COLOR_BGR2RGB))
    plt.title('Rotated')
    plt.axis('off')
    
    plt.subplot(153)
    plt.imshow(cv2.cvtColor(flipped, cv2.COLOR_BGR2RGB))
    plt.title('Flipped')
    plt.axis('off')
    
    plt.subplot(154)
    plt.imshow(cv2.cvtColor(bright, cv2.COLOR_BGR2RGB))
    plt.title('Brightness Adjusted')
    plt.axis('off')
    
    plt.subplot(155)
    plt.imshow(cv2.cvtColor(noisy, cv2.COLOR_BGR2RGB))
    plt.title('Noisy')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Code Explanation:

Import Libraries: Imports cv2 for image processing, numpy for numerical operations, and matplotlib.pyplot for displaying images.
Define augment_image Function: Performs four types of image augmentations: rotation, flipping, brightness adjustment, and noise addition.
Load Image: Reads the image from the specified path and confirms successful loading.
Perform Augmentation: Applies rotation, horizontal flipping, brightness adjustment, and adds Gaussian noise to the image.
Display Results: Shows the original and augmented images (rotated, flipped, brightness adjusted, noisy) side by side using matplotlib.

4. Image Denoising

Denoising removes noise from images, enhancing quality and clarity. Common methods include:

a) Gaussian Blur:

Applies a Gaussian function to smooth the image.
Effective for reducing Gaussian noise.

b) Median Filtering:

Replaces each pixel with the median of neighboring pixels.
Effective for salt-and-pepper noise.

c) Bilateral Filtering:

Preserves edges while reducing noise.

Code Implementation

Python

import cv2
import matplotlib.pyplot as plt

def denoise_image(image):
    print("Performing image denoising...")
    
    gaussian = cv2.GaussianBlur(image, (5, 5), 0)
    median = cv2.medianBlur(image, 5)
    bilateral = cv2.bilateralFilter(image, 9, 75, 75)
    
    print("Denoising complete.")
    return gaussian, median, bilateral

# Example usage
image_path = '/kaggle/input/sample-image/noisy_image.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    gaussian, median, bilateral = denoise_image(image)
    
    # Display the results
    plt.figure(figsize=(20, 5))
    
    plt.subplot(141)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title('Original (Noisy)')
    plt.axis('off')
    
    plt.subplot(142)
    plt.imshow(cv2.cvtColor(gaussian, cv2.COLOR_BGR2RGB))
    plt.title('Gaussian Blur')
    plt.axis('off')
    
    plt.subplot(143)
    plt.imshow(cv2.cvtColor(median, cv2.COLOR_BGR2RGB))
    plt.title('Median Blur')
    plt.axis('off')
    
    plt.subplot(144)
    plt.imshow(cv2.cvtColor(bilateral, cv2.COLOR_BGR2RGB))
    plt.title('Bilateral Filter')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Code Explanation:

Import Libraries: Imports cv2 for image processing and matplotlib.pyplot for displaying images.
Define denoise_image Function: Applies three different denoising techniques to the noisy image: Gaussian Blur, Median Blur, and Bilateral Filter.
Load Image: Reads the noisy image from the specified path and checks if the image was successfully loaded.
Perform Denoising: Applies Gaussian Blur, Median Blur, and Bilateral Filter to the noisy image to reduce noise.
Display Results: Uses matplotlib to display the original noisy image and the results of the three denoising methods side by side.

5. Edge Detection

Edge detection identifies boundaries of objects within images. Key algorithms include:

a) Sobel Operator

Gradient Calculation: Measures changes in image intensity.
Edge Emphasis: Highlights horizontal and vertical edges using convolution kernels.

b) Canny Edge Detector

Multi-stage Algorithm: Involves noise reduction, gradient calculation, and edge tracking.
Intensity Gradients and Non-maximum Suppression: Detects edges by suppressing non-maximal pixels.

c) Laplacian of Gaussian (LoG)

Combines Gaussian Smoothing with Laplacian Operator: Smooths image to reduce noise, then applies Laplacian to detect edges.

Code Example:

Python

import cv2
import numpy as np
import matplotlib.pyplot as plt

def detect_edges(image):
    print("Performing edge detection...")
    
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Sobel
    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
    sobel = np.sqrt(sobelx**2 + sobely**2)
    sobel = np.uint8(sobel / sobel.max() * 255)
    
    # Canny
    canny = cv2.Canny(gray, 100, 200)
    
    # Laplacian of Gaussian
    blur = cv2.GaussianBlur(gray, (3, 3), 0)
    log = cv2.Laplacian(blur, cv2.CV_64F)
    log = np.uint8(np.absolute(log))
    
    print("Edge detection complete.")
    return sobel, canny, log

# Example usage
image_path = '/kaggle/input/sample-image/tint1.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    sobel, canny, log = detect_edges(image)
    
    # Display the results
    plt.figure(figsize=(20, 5))
    
    plt.subplot(141)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title('Original')
    plt.axis('off')
    
    plt.subplot(142)
    plt.imshow(sobel, cmap='gray')
    plt.title('Sobel')
    plt.axis('off')
    
    plt.subplot(143)
    plt.imshow(canny, cmap='gray')
    plt.title('Canny')
    plt.axis('off')
    
    plt.subplot(144)
    plt.imshow(log, cmap='gray')
    plt.title('Laplacian of Gaussian')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Explanation:

Import Libraries: Imports cv2 for image processing, numpy for calculations, and matplotlib.pyplot for plotting images.
Define detect_edges Function: Converts the image to grayscale and applies Sobel, Canny, and Laplacian of Gaussian methods to detect edges.
Load Image: Reads an image from a specified path and verifies if it was loaded successfully.
Perform Edge Detection: Calls detect_edges to get edge-detected versions of the image using Sobel, Canny, and LoG techniques.
Display Results: Uses matplotlib to show the original image and the edge-detected results side by side.

6. Image Binarization

Binarization converts an image to black and white based on a threshold. Methods include:

a) Global Thresholding:

Applies a single threshold value for the entire image.
Otsu's method automatically determines the optimal threshold.

b) Adaptive Thresholding:

Uses different thresholds for different regions of the image.
Better for images with varying illumination.

Python

import cv2
import matplotlib.pyplot as plt

def binarize_image(image):
    print("Performing image binarization...")
    
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # Global thresholding (Otsu's method)
    _, global_thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    # Adaptive thresholding
    adaptive_thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
                                            cv2.THRESH_BINARY, 11, 2)
    
    print("Binarization complete.")
    return global_thresh, adaptive_thresh

# Example usage
image_path = '/kaggle/input/sample-image/tint1.jpg'
image = cv2.imread(image_path)

if image is None:
    print(f"Failed to load image from {image_path}")
else:
    print(f"Successfully loaded image from {image_path}")
    
    global_thresh, adaptive_thresh = binarize_image(image)
    
    # Display the results
    plt.figure(figsize=(15, 5))
    
    plt.subplot(131)
    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
    plt.title('Original')
    plt.axis('off')
    
    plt.subplot(132)
    plt.imshow(global_thresh, cmap='gray')
    plt.title('Global Thresholding')
    plt.axis('off')
    
    plt.subplot(133)
    plt.imshow(adaptive_thresh, cmap='gray')
    plt.title('Adaptive Thresholding')
    plt.axis('off')
    
    plt.tight_layout()
    plt.show()

print("Script completed")

Output:

Explanation:

Import Libraries: Imports cv2 for image processing and matplotlib.pyplot for visualizing images.
Define binarize_image Function: Converts the image to grayscale and applies global thresholding (Otsu’s method) and adaptive thresholding for binary image creation.
Load Image: Reads an image from the specified path and checks if it was loaded correctly.
Perform Binarization: Calls binarize_image to apply global and adaptive thresholding methods on the grayscale image to create binary images.
Display Results: Uses matplotlib to show the original image, global thresholded image, and adaptive thresholded image in a 1x3 grid layout.

Conclusion

Image preprocessing is a vital step in computer vision that significantly influences the performance of machine learning models. Techniques such as resizing, normalization, augmentation, denoising, histogram equalization, edge detection, and binarization help in transforming raw image data into a more usable form. Understanding and effectively applying these preprocessing algorithms can lead to more accurate and efficient image recognition systems.

poojashu00qn

Improve

Article Tags :

Image Processing Algorithms in Computer Vision

What is image processing in computer vision?

Key Objectives of Image Processing

1. Image Resizing

a) Nearest Neighbor Interpolation:

b) Bilinear Interpolation:

c) Bicubic Interpolation:

Code Implementation

2. Image Normalization

a) Min-Max Scaling:

b) Z-score Normalization:

c) Histogram Equalization:

Implementation

3. Image Augmentation

a.) Geometric Transformations:

b) Color Adjustments:

c) Noise Addition:

4. Image Denoising

a) Gaussian Blur:

b) Median Filtering:

c) Bilateral Filtering:

Code Implementation

5. Edge Detection

a) Sobel Operator

b) Canny Edge Detector

c) Laplacian of Gaussian (LoG)

Code Example:

6. Image Binarization

a) Global Thresholding:

b) Adaptive Thresholding:

Conclusion

Similar Reads

Introduction to Computer Vision

Image Processing & Transformation

Feature Extraction and Description

Deep Learning for Computer Vision

Object Detection and Recognition

Image Segmentation

3D Reconstruction

Thank You!

What kind of Experience do you want to share?