GURU TEGH BAHADUR
INSTITUTE OF TECHNOLOGY
Digital Image Processing
Practical File
Submitted by:
Name: Japjyot Singh
Branch: AI-DS
Roll no. 04313211921
Japjyot singh 04313211921 AI-DS
INDEX
Date of Date of Teacher’s
S.No. Topic
Experiment Submission Signature
Create a program to demonstrate
1. Geometric transformations- Image
rotation, scaling, and translation.
Display of FFT (1-D & 2-D) of an
image and apply Two-
dimensional Fourier transform to
2.
represent the content of an image
using the discrete Fourier
transform (DFT) and masking
with DFT.
Write a Program of Contrast
stretching of a low contrast image,
3. Histogram, and Histogram
Equalization and Display of bit
planes of an Image.
Computation of Mean, Standard
4. Deviation, Correlation coefficient of
the given Image.
Implementation of image
5. Smoothening Filters (Mean and
Median filtering of an image)
Implementation of image
sharpening filters and Edge
6.
Detection using Gradient
Filters.
Implementation of image Intensity
slicing technique for image
7.
enhancement.
Study and implement Canny edge
detection Algorithm to images and
8.
compare it with the existing edge
detection algorithms.
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 1
Aim: Create a program to demonstrate Geometric transformations- Image
rotation, scaling, and translation.
Code:
import cv2
import matplotlib.pyplot as plt
import numpy as np
# Read the image
I = cv2.imread('EXP1.jpg')
# Display the original image
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(I, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
# Input scaling factor
s = float(input('Enter Scaling Factor: '))
# Resize the image
j = cv2.resize(I, None, fx=s, fy=s)
# Display the scaled image
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(j, cv2.COLOR_BGR2RGB))
plt.title('Scaled Image')
# Input rotation angle
angle = float(input('Enter Rotation Angle in degrees: '))
# Rotate the image
rows, cols, _ = j.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1)
K = cv2.warpAffine(j, M, (cols, rows))
# Display the rotated image
plt.subplot(2, 2, 3)
plt.imshow(cv2.cvtColor(K, cv2.COLOR_BGR2RGB))
plt.title(f'Rotated Image {angle} deg')
Japjyot Singh 04313211921 AI-DS
# Input translation values
tx = float(input('Enter translation in x direction (pixels): '))
ty = float(input('Enter translation in y direction (pixels): '))
# Define translation matrix
M = np.float32([[1, 0, tx], [0, 1, ty]])
# Apply translation
translated_image = cv2.warpAffine(K, M, (cols, rows))
# Display the translated image
plt.subplot(2, 2, 4)
plt.imshow(cv2.cvtColor(translated_image, cv2.COLOR_BGR2RGB))
plt.title('Translated Image')
Output:
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 2
Aim: Display of FFT (1-D & 2-D) of an image and apply Two-dimensional
Fourier transform to represent the content of an image using the discrete Fourier
transform (DFT) and masking with DFT.
Code:
import cv2
import numpy as np
import matplotlib.pyplot as plt
Japjyot Singh 04313211921 AI-DS
Read the image
image = cv2.imread('EXP 2.jpg', cv2.IMREAD_GRAYSCALE)
# Display the original image
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
# Compute 1-D FFT
fft_1d = np.fft.fft(image[0])
# Plot 1-D FFT
plt.subplot(2, 3, 2)
plt.plot(np.abs(fft_1d))
plt.title('1-D FFT')
# Compute 2-D FFT
fft_2d =
np.fft.fft2(image)
# Shift the zero frequency component to the center
fft_2d_shifted = np.fft.fftshift(fft_2d)
# Plot magnitude of 2-D FFT
plt.subplot(2, 3, 3)
plt.imshow(np.log(1 + np.abs(fft_2d_shifted)), cmap='gray')
plt.title('Magnitude of 2-D FFT')
# Apply mask to the 2-D FFT
mask = np.zeros_like(fft_2d_shifted)
mask[100:400, 100:400] = 1 # Defining a square mask
fft_2d_shifted_masked = fft_2d_shifted * mask
# Plot masked 2-D FFT
plt.subplot(2, 3, 4)
plt.imshow(np.log(1 + np.abs(fft_2d_shifted_masked)), cmap='gray')
plt.title('Masked 2-D FFT')
# Inverse FFT to obtain the masked image
masked_image = np.fft.ifft2(np.fft.ifftshift(fft_2d_shifted_masked)).real
# Display the masked image
Japjyot Singh 04313211921 AI-DS
plt.subplot(2, 3, 5)
plt.imshow(masked_image, cmap='gray')
plt.title('Masked Image')
# Show plots
plt.tight_layout()
plt.show()
Output:
EXPERIMENT 3
Aim: Write a Program of Contrast stretching of a low contrast image,
Histogram, and Histogram Equalization and Display of bit planes of an Image.
Code:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Function for contrast stretching
Japjyot Singh 04313211921 AI-DS
def contrast_stretching(image, min_value, max_value):
normalized_image = cv2.normalize(image, None, min_value, max_value,
cv2.NORM_MINMAX)
return normalized_image
# Function for histogram equalization
def histogram_equalization(image):
equalized_image = cv2.equalizeHist(image)
return equalized_image
# Function to display bit planes of an image
def display_bit_planes(image):
bit_planes = [cv2.bitwise_and(image, 1 << i) for i in range(8)]
return bit_planes
# Read the image
image = cv2.imread('EXP 2.jpg', cv2.IMREAD_GRAYSCALE)
# Check if the image is loaded successfully
if image is None:
print("Error: Failed to read the image.")
else:
print("Image loaded successfully.")
# Display the original image
plt.subplot(3, 3, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image (OI)')
# Contrast Stretching
min_value = 0
max_value = 255
stretched_image = contrast_stretching(image, min_value, max_value)
plt.subplot(3, 3, 2)
plt.imshow(stretched_image, cmap='gray')
plt.title('Contrast Stretched Image (SI)')
# Histogram Equalization
equalized_image = histogram_equalization(image)
plt.subplot(3, 3, 3)
Japjyot Singh 04313211921 AI-DS
plt.imshow(equalized_image, cmap='gray')
plt.title('Equalized Image (EI)')
# Display Histogram
plt.subplot(3, 3, 4)
plt.hist(image.flatten(), bins=256, range=[0, 256], color='r')
plt.title('Histogram of OI')
plt.subplot(3, 3, 5)
plt.hist(stretched_image.flatten(), bins=256, range=[0, 256], color='g')
plt.title('Histogram of SI')
plt.subplot(3, 3, 6)
plt.hist(equalized_image.flatten(), bins=256, range=[0, 256], color='b')
plt.title('Histogram of EI')
plt.tight_layout()
plt.show()
# Display bit planes
bit_planes = display_bit_planes(image)
for i in range(8):
plt.subplot(3, 3, i+1)
plt.imshow(bit_planes[i], cmap='gray')
plt.title(f'BIT PLANE {i}')
plt.tight_layout()
Japjyot Singh 04313211921 AI-DS
Output:
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 4
Aim: Computation of Mean, Standard Deviation, Correlation coefficient of the
given Image.
Code:
import cv2
import numpy as np
# Read the image
image = cv2.imread('EXP3.jpg', cv2.IMREAD_GRAYSCALE)
# Compute the mean and standard deviation
mean_value = np.mean(image)
std_dev = np.std(image)
# Display the mean and standard deviation
print("Mean:", mean_value)
print("Standard Deviation:", std_dev)
# Generate two random checkerboard patterns
checkerboard1 = np.random.randint(0, 256, size=image.shape, dtype=np.uint8)
checkerboard2 = np.random.randint(0, 256, size=image.shape, dtype=np.uint8)
# Compute the correlation coefficient between the two checkerboard patterns
correlation = np.corrcoef(checkerboard1.flatten(), checkerboard2.flatten())[0, 1]
# Display the correlation coefficient
print("Correlation Coefficient:", correlation)
# Display the grayscale image
plt.subplot(2, 3, 2)
plt.imshow(image, cmap='gray')
plt.title('Grayscale Image')
Japjyot Singh 04313211921 AI-DS
Output:
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 5
Aim: Implementation of image Smoothening Filters (Mean and Median filtering
of an image)
Code:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Read the image
img = cv2.imread('IMG8.png', 0)
# Obtain number of rows and columns of the image
m, n = img.shape
# Develop Averaging filter(3, 3) mask
mask = np.ones([3, 3], dtype=int) / 1000
# Convolve the 3X3 mask over the image
img_new = np.zeros([m, n])
for i in range(1, m-1):
for j in range(1, n-1):
temp = img[i-1, j-1] * mask[0, 0] + img[i-1, j] * mask[0, 1] + img[i-1, j + 1]
* mask[0, 2] + \
img[i, j-1] * mask[1, 0] + img[i, j] * mask[1, 1] + img[i, j + 1] *
mask[1, 2] + \
img[i + 1, j-1] * mask[2, 0] + img[i + 1, j] * mask[2, 1] + img[i + 1, j
+ 1] * mask[2, 2]
img_new[i, j] = temp
# Convert the result to uint8 data type
img_new =
img_new.astype(np.uint8)
# Save the blurred image
cv2.imwrite('blurred.tif', img_new)
Japjyot Singh 04313211921 AI-DS
# Display the original and blurred images
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.subplot(1, 2, 2)
plt.imshow(img_new, cmap='gray')
plt.title('Blurred Image')
plt.show()
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Read the noisy image
img_noisy1 = cv2.imread('IMG8.png', 0)
# Obtain the number of rows and columns of the image
m, n = img_noisy1.shape
# Traverse the image. For every 3X3
area, # find the median of the pixels and
# replace the center pixel by the median
img_new1 = np.zeros([m, n])
for i in range(1, m-1):
for j in range(1, n-1):
temp = [img_noisy1[i-1, j-1],
img_noisy1[i-1, j],
img_noisy1[i-1, j + 1],
img_noisy1[i, j-1],
img_noisy1[i, j],
img_noisy1[i, j + 1],
img_noisy1[i + 1, j-1],
img_noisy1[i + 1, j],
img_noisy1[i + 1, j + 1]]
Japjyot Singh 04313211921 AI-DS
temp = sorted(temp)
img_new1[i, j]= temp[4]
img_new1 = img_new1.astype(np.uint8)
# Save the filtered image
cv2.imwrite('new_median_filtered.png', img_new1)
# Display the original and filtered images
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.imshow(img_noisy1, cmap='gray')
plt.title('Noisy Image')
plt.subplot(1, 2, 2)
plt.imshow(img_new1, cmap='gray')
plt.title('Median Filtered Image')
plt.show()
Output:
Japjyot Singh 04313211921 AI-DS
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 6
Aim: Implementation of image sharpening filters and Edge Detection using
Gradient Filters.
Code:
import cv2
import numpy as np
from matplotlib import pyplot as plt
# Read the image
img = cv2.imread('EXP4.jpg')
# Convert to grayscale
gray = cv2.cvtColor(img,
cv2.COLOR_BGR2GRAY) plt.figure(figsize=(12,
10))
# Display original image
plt.subplot(4, 2, 1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
# Display grayscale image
plt.subplot(4, 2, 2)
plt.imshow(gray, cmap='gray')
plt.title('Gray Image')
# Laplacian filter
laplacian = cv2.Laplacian(gray, cv2.CV_64F)
laplacian = np.uint8(np.absolute(laplacian)) # Convert back to uint8 for
visualization
plt.subplot(4, 2, 3)
plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian')
# Sobel edge detection
Japjyot Singh 04313211921 AI-DS
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0,
ksize=5) sobely = cv2.Sobel(gray, cv2.CV_64F, 0,
1, ksize=5) sobel = np.sqrt(sobelx**2 + sobely**2)
plt.subplot(4, 2, 4)
plt.imshow(sobel, cmap='gray')
plt.title('Sobel')
# Prewitt edge detection
prewittx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
prewitty = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
prewitt = np.sqrt(prewittx**2 + prewitty**2)
plt.subplot(4, 2, 5)
plt.imshow(prewitt, cmap='gray')
plt.title('Prewitt')
# Roberts edge detection
robertsx = cv2.filter2D(gray, -1, np.array([[1, 0], [0, -1]]))
robertsy = cv2.filter2D(gray, -1, np.array([[0, 1], [-1,
0]])) roberts = np.sqrt(robertsx**2 + robertsy**2)
plt.subplot(4, 2, 6)
plt.imshow(roberts, cmap='gray')
plt.title('Roberts')
# Sobel edge detection (horizontal and vertical)
sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=5)
sobel_horizontal = cv2.convertScaleAbs(sobelx)
sobel_vertical = cv2.convertScaleAbs(sobely)
plt.subplot(4, 2, 7)
plt.imshow(sobel_horizontal, cmap='gray')
plt.title('Sobel Horizontal')
plt.subplot(4, 2, 8)
plt.imshow(sobel_vertical, cmap='gray')
plt.title('Sobel Vertical')
plt.tight_layout()
plt.show()
Japjyot Singh 04313211921 AI-DS
Output:
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 7
Aim: Implementation of image Intensity slicing technique for image
enhancement.
Code:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Read the image
img = cv2.imread('IMG6.jpg', cv2.IMREAD_GRAYSCALE)
# Check if the image is loaded successfully
if img is None:
print("Error: Unable to read the image.")
else:
# Define intensity slicing parameters
low_threshold = 100
high_threshold = 200
# Apply intensity slicing
sliced_img = np.copy(img)
sliced_img[(img >= low_threshold) & (img <= high_threshold)] = 255 #
Enhance pixels within the specified range
sliced_img[(img < low_threshold) | (img > high_threshold)] = 0 # Keep
other pixels unchanged
# Display original and sliced images
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.subplot(1, 2, 2)
plt.imshow(sliced_img, cmap='gray')
Japjyot Singh 04313211921 AI-DS
plt.title('Intensity Sliced Image')
plt.show()
Output:
Japjyot Singh 04313211921 AI-DS
EXPERIMENT 8
Aim: Study and implement Canny edge detection Algorithm to images and
compare it with the existing edge detection algorithms.
Code:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Read the image
img = cv2.imread('IMG1.jpg', cv2.IMREAD_GRAYSCALE)
# Apply Canny edge detection
canny_edges = cv2.Canny(img, 100, 200)
# Apply Sobel edge detection
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0,
ksize=3) sobely = cv2.Sobel(img, cv2.CV_64F, 0,
1, ksize=3) sobel_edges = np.sqrt(sobelx**2 +
sobely**2)
# Apply Prewitt edge detection
prewittx = cv2.Sobel(img, cv2.CV_64F, 1, 0,
ksize=3) prewitty = cv2.Sobel(img, cv2.CV_64F, 0,
1, ksize=3) prewitt_edges = np.sqrt(prewittx**2 +
prewitty**2)
# Display original and edge-detected images
plt.figure(figsize=(12, 6))
# First row with two subplots
plt.subplot(2, 2, 1)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.subplot(2, 2, 2)
plt.imshow(canny_edges, cmap='gray')
plt.title('Canny Edge Detection')
Japjyot Singh 04313211921 AI-DS
# Second row with two subplots
plt.subplot(2, 2, 3)
plt.imshow(sobel_edges, cmap='gray')
plt.title('Sobel Edge Detection')
plt.subplot(2, 2, 4)
plt.imshow(prewitt_edges, cmap='gray')
plt.title('Prewitt Edge Detection')
plt.tight_layout()
plt.show()
Output:
Japjyot Singh 04313211921 AI-DS
