National University of Technology (NUTECH)

Electrical Engineering Department

EE4407-Machine Learning Lab

LAB No: 05

NAME: Muhammad Naqash

NUTECH ID F20603019
DATE: 13-11-2023

Lab 05: Fundamentals of Image Processing for Machine Learning

Objective:

To introduce the fundamental concepts and applications of image processing within the field of
machine learning. Students will learn to manipulate and analyze image data, preparing them for
advanced topics like feature extraction and model training.

Tools/Software Requirements:

 Python 3.x
 Integrated Development Environment (IDE) such as PyCharm or Jupyter Notebook
 Image processing libraries such as PIL (Pillow) or OpenCV
 matplotlib library for displaying images
 Sample images to work with

Image processing involves performing operations on images to enhance them or to extract useful
information. It is a form of signal processing where the input is an image, like a photograph or video
frame, and the output can be either an image or a set of characteristics or parameters related to the
image. In machine learning and computer vision, image processing is a critical step that precedes the
actual learning process. It transforms raw image data into a format that can be analyzed and used by
machine learning models to perform tasks such as classification, detection, and segmentation

Role in Machine Learning and Computer Vision

In machine learning, particularly in the field of computer vision, image processing is used to
preprocess images for better feature extraction, which is essential for the performance of machine
learning algorithms. Preprocessed images can feed into machine learning models more effectively,
allowing the models to train faster and perform better. In computer vision, image processing is used
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

to understand and interpret the visual world. It plays a crucial role in various applications, from facial
recognition and autonomous vehicles to medical imaging analysis.

Overview of Common Image Processing Tasks

1. Reading: The process of loading an image file into an array of pixel values that can be
manipulated by a computer program.
2. Resizing: Altering the size of an image to meet specific dimensions, which is often
necessary for standardizing inputs to a machine-learning model. Standardizing input for a
Convolutional Neural Network (CNN) used in facial recognition systems. Without resizing,
the CNN may not be able to process the images if they do not all match its required input
dimensions.

3. Filtering: Applying filters to an image to enhance certain features or remove noise.

Examples include smoothing, sharpening, and edge enhancement filters.

4. Grayscale Conversion: Removing the color information from an image, leaving just the
intensity of light. This simplifies the image data and is often used where color is not critical
to the analysis. Preprocessing for medical image analysis to highlight larger structures while
suppressing fine details that may not be of interest. Small variations or noise in medical
images could be misinterpreted as anomalies, leading to false positives.

5. Edge Detection: Identifying the boundaries of objects within an image. Edge detection is
used to isolate feature. Autonomous vehicles use edge detection in lane detection
algorithms to understand road boundaries. Without clear edge detection, the vehicle's
guidance system may have difficulty identifying lane markings, leading to navigation errors.

Implementation
Import Necessary Libraries:

import os # for operating system interaction

import cv2 # used for image processing
import numpy as np # OpenCV uses for image arrays
import matplotlib.pyplot as plt # for displaying images

Define Directories:

input_dir = 'path_to_input_images'
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

output_dir = 'path_to_output_images'

Get List of Image Filenames:

filenames = [f for f in os.listdir(input_dir) if

f.endswith('.jpg')]

Image Processing Loop: Within a for loop, each image file is processed:
Read Image in Grayscale:

gray_image = cv2.imread(os.path.join(input_dir, filename),

cv2.IMREAD_GRAYSCALE)

Each image is read in grayscale, reducing the data needed for

processing.

Resize Image:

resized_image = cv2.resize(gray_image, (64, 64))

The image is resized to 64x64 pixels, a common requirement for

machine learning models.

Apply Gaussian Blur:

blurred_image = cv2.GaussianBlur(resized_image, (5, 5), 0)

A Gaussian blur is applied to the resized image, which helps

to reduce image noise and detail.

Perform Edge Detection:

edges = cv2.Canny(blurred_image, 100, 200)

The Canny edge detection algorithm is applied to the blurred

image to highlight edges.

Save Processed Image:

 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

cv2.imwrite(os.path.join(output_dir, filename), edges)

The processed image with detected edges is saved to the output

directory.

Display Images: The original and processed images are displayed side by
side for comparison:

Read and Convert Original Image for Display:

original_image =
cv2.cvtColor(cv2.imread(os.path.join(input_dir, filename)),
cv2.COLOR_BGR2RGB)

The original image is read again and converted from BGR to RGB
for correct color representation when displaying.

Convert Edge Image for Display:

processed_image = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)

The edge-detected image is converted from grayscale to RGB to

match the format expected by matplotlib.

Plotting the Images side by side

plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.imshow(original_image)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(processed_image)
plt.title('Processed Image')
plt.axis('off')
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

plt.show()

Code:
import os # for operating system interaction
import cv2 # used for image processing
import numpy as np # OpenCV uses for image arrays
import matplotlib.pyplot as plt # for displaying images
input_dir = 'C:\\Users\\Student\\naqash'
output_dir = 'C:\\Users\\Student.DESKTOP-7S88DU4\\Desktop\\output'
filenames = [f for f in os.listdir(input_dir) if f.endswith('.jpg')]

for filename in filenames:

gray_image = cv2.imread(os.path.join(input_dir, filename), cv2.IMREAD_GRAYSCALE)
resized_image = cv2.resize(gray_image, (64, 64))
blurred_image = cv2.GaussianBlur(resized_image, (5, 5), 0)
edges = cv2.Canny(blurred_image, 100, 200)
cv2.imwrite(os.path.join(output_dir, filename), edges)
original_image = cv2.cvtColor(cv2.imread(os.path.join(input_dir, filename)),
cv2.COLOR_BGR2RGB)
processed_image = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.imshow(original_image)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(processed_image)
plt.title('Processed Image')
plt.axis('off')

plt.show()
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

Screenshot:
National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab
National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

Code Explanation:
The script performs the following operations for each image:

 Reads the image in grayscale.

 Resizes the image to 64x64 pixels.
 Applies Gaussian blur to the resized image.
 Detects edges using the Canny edge detector.
 Writes the resulting edge-detected image to an output directory.
 Reads the original image in color (BGR format).
 National University of Technology (NUTECH)
Electrical Engineering Department
EE4407-Machine Learning Lab

 Converts the edge-detected image to color format for display.

 Displays the original and processed images side by side using matplotlib.

Lab Task
Implement an image-preprocessing pipeline that prepares an image dataset for machine
learning model input. For this, create a folder having the 3x images in jpg format and bring
them to the IDE for further processing.

CONCLUSION