DIGITAL IMAGE PROCESSING

(BECE316E)

LAB EXPERIMENTS
(Consolidated file)

Submitted to
Dr. P. Nirmala

Submitted by
Vadde Surya Teja
21BEC1484

1
 Contents

Experiment Page Number Range

Lab 1 3-9
Lab 2 10 - 19
Lab 3 20 - 29
Lab 4 30 - 39
Lab 5 40 - 50
Lab 6 51 - 59
Lab 7 60 - 64
Lab 8 65 - 68
Lab 9 69 - 72
Lab 10 73 - 79
Lab 11 80 - 87
Lab 12 88 - 94
Lab 13 95 - 99

2
 LAB EXPERIMENT -1
Digital Image Processing

Name: Vadde Surya Teja

REG number: 21BEC1484

Aim: To apply basic operations of image processing on images and observe the
result accordingly

Software Required: MATLAB Software

Procedure:

1. Open Matlab software.

2. Upload and import the images to be processed.
3. Write the code for given task in matlab and execute.
4. Observe the output and changes accordingly.

1. Splitting of color panels

Code:
% Read the image

img = imread('/MATLAB Drive/DIP/images/rgb.jpg'); % Replace 'your_image.jpg' with

your image file

% Check image type and size

whos img

% Split the image into RGB channels

redChannel = img(:, :, 1);
greenChannel = img(:, :, 2);
blueChannel = img(:, :, 3);

% Display range of values in each channel

disp(['Red Channel - min:', num2str(min(redChannel(:))), ', max:',
num2str(max(redChannel(:)))]);
disp(['Green Channel - min:', num2str(min(greenChannel(:))), ', max:',
num2str(max(greenChannel(:)))]);
disp(['Blue Channel - min:', num2str(min(blueChannel(:))), ', max:',
num2str(max(blueChannel(:)))]);

% Display each channel separately

figure;
subplot(2, 2, 1);
imshow(img);
title('Original Image');

3
subplot(2, 2, 2);
imshow(redChannel);
title('Red Channel');

subplot(2, 2, 3);
imshow(greenChannel);
title('Green Channel');

subplot(2, 2, 4);
imshow(blueChannel);
title('Blue Channel');

Output:

2. Image negative
Code:
% Read the RGB image
img = imread('/MATLAB Drive/DIP/images/city.jpeg');
% Convert to grayscale
gray_img = rgb2gray(img);
% Define the center region (5x5 grid at the center)
center_x = size(gray_img, 2) / 2; % X-coordinate of the center of
the grid
center_y = size(gray_img, 1) / 2; % Y-coordinate of the center of
the grid
grid_size = 5; % Size of the grid
% Calculate the region of interest
x_start = round(center_x - grid_size / 2);
x_end = round(center_x + grid_size / 2);
y_start = round(center_y - grid_size / 2);
y_end = round(center_y + grid_size / 2);
% Ensure the region is within image bounds
x_start = max(x_start, 1);
x_end = min(x_end, size(gray_img, 2));
y_start = max(y_start, 1);

4
 y_end = min(y_end, size(gray_img, 1));
% Extract the region of interest from grayscale image
gray_grid = gray_img(y_start:y_end, x_start:x_end);
% Create the negative grayscale image
negative_gray_img = 255 - gray_img;
% Extract the corresponding region from negative grayscale image
negative_gray_grid = negative_gray_img(y_start:y_end, x_start:x_end);
% Display the grayscale image, negative image, and grids in a figure
figure;
% Original grayscale image with grid
subplot(2, 2, 1);
imshow(gray_img);
hold on;
rectangle('Position', [x_start-0.5, y_start-0.5, grid_size,
grid_size], 'EdgeColor', 'r', 'LineWidth', 2);
title('Grayscale Image with Grid');
% Negative grayscale image with grid
subplot(2, 2, 2);
imshow(negative_gray_img);
hold on;
rectangle('Position', [x_start-0.5, y_start-0.5, grid_size,
grid_size], 'EdgeColor', 'r', 'LineWidth', 2);
title('Negative Grayscale Image with Grid');
% Grayscale grid
subplot(2, 2, 3);
imshow(gray_grid);
title('Grayscale Grid');
% Negative grayscale grid
subplot(2, 2, 4);
imshow(negative_gray_grid);
title('Negative Grayscale Grid');

Output:

5
3. Interpolation (Nearest Neighbour)

Code:
% Read the original image
original_img = imread('/MATLAB Drive/DIP/images/ave2.jpg');
% Display the original image
figure;
subplot(1, 2, 1);
imshow(original_img);
title('Original Image');
% Get original image resolution
[height_original, width_original, ~] = size(original_img);
disp(['Original Image Resolution: ', num2str(width_original), ' x ',
num2str(height_original)]);
% Define the scale factor for resizing
scale_factor = 2; % Enlarge the image by a factor of 2
% Perform nearest neighbor interpolation
resized_img = imresize(original_img, scale_factor, 'nearest');
% Display the resized image
subplot(1, 2, 2);
imshow(resized_img);
title('Nearest Neighbor Interpolation');
% Get resized image resolution
[height_resized, width_resized, ~] = size(resized_img);
disp(['Resized Image Resolution: ', num2str(width_resized), ' x ',
num2str(height_resized)]);

6
 Output:

Interpolation ( Bilinear)

Code:
% Read the original image
original_img = imread('peppers.png');
% Display the original image
figure;
subplot(1, 2, 1);
imshow(original_img);
title('Original Image');
% Get original image resolution
[height_original, width_original, ~] = size(original_img);
disp(['Original Image Resolution: ', num2str(width_original), ' x ',
num2str(height_original)]);
% Define the scale factor for resizing
scale_factor = 2; % Enlarge the image by a factor of 2
% Perform bilinear interpolation
resized_img = imresize(original_img, scale_factor, 'bilinear');
% Display the resized image
subplot(1, 2, 2);
imshow(resized_img);
title('Bilinear Interpolation');
% Get resized image resolution
[height_resized, width_resized, ~] = size(resized_img);
disp(['Resized Image Resolution: ', num2str(width_resized), ' x ',
num2str(height_resized)]);

7
Output:

4. Flipping an image

Code:
% Read the image
img = imread('/MATLAB Drive/DIP/images/city.jpeg');
% Display the original image
figure;
subplot(2, 2, 1);
imshow(img);
title('Original Image');
% Flip the image horizontally
flipped_horizontal = fliplr(img);
% Display the horizontally flipped image
subplot(2, 2, 2);
imshow(flipped_horizontal);
title('Horizontally Flipped Image');
% Flip the image vertically
flipped_vertical = flipud(img);
% Display the vertically flipped image
subplot(2, 2, 3);
imshow(flipped_vertical);
title('Vertically Flipped Image');
% Flip the image both horizontally and vertically (equivalent to
rotating 180 degrees)
flipped_both = flipud(fliplr(img));
% Display the image flipped both horizontally and vertically
subplot(2, 2, 4);
imshow(flipped_both);
title('Horizontally and Vertically Flipped Image');

8
Output:

Result: Hence we have successfully observed all the changes and understood
the image processing techniques successfully.

Verification:

9
 Lab Experiment -2

Digital Image Processing

Name: Vadde Surya Teja
REG number: 21BEC1484

Aim: To perform given transformations on images using matlab and observe the result.

Software Required: MATLAB software

1. Histogram calculation

Algorithm:

1. Take the input image using imread.

2. If the image is in RGB convert it into gray scale image.
3. Using imhist function calculate the histogram values as count and graylevels.
4. Plot the histogram as a bar plot using these values and specify the labels accordingly.

Code:

% Read the input image

imageFileName = '/MATLAB Drive/DIP/images/ave.jpg'; % Replace with your image file name

img = imread(imageFileName);

% Convert the image to grayscale if it is not already

if size(img, 3) == 3
img = rgb2gray(img);
end

% Calculate the histogram

[counts, grayLevels] = imhist(img);

% Plot the histogram

figure; % Create a new figure window
bar(grayLevels, counts); % Plot the histogram as a bar chart
xlabel('Pixel Intensity'); % Label for the x-axis
ylabel('Frequency'); % Label for the y-axis
title('Histogram of Grayscale Image'); % Title of the plot

% Display the counts and gray levels

disp('Counts:');
disp(counts);
disp('Gray Levels:');
disp(grayLevels);

10
 Output:

2. Histogram Equalisation

Algorithm:
1. Take the input image using imread.
2. If the image is in RGB convert it into gray scale image.
3. Using imhist function calculate the histogram values as count and graylevels.
4. Convert the image into equalized hist using histeq function.
5. Plot the histogram as a bar plot using these values and specify the labels accordingly.

Code:
% Read the input image
imageFileName = '/MATLAB Drive/DIP/images/vibrant.jpg'; % Replace with your image file name
img = imread(imageFileName);

% Convert the image to grayscale if it is not already

if size(img, 3) == 3
img = rgb2gray(img);
end

% Calculate the histogram of the original image

[counts, grayLevels] = imhist(img);

% Perform histogram equalization

equalizedImg = histeq(img);

% Calculate the histogram of the equalized image

[countsEq, grayLevelsEq] = imhist(equalizedImg);

11
 % Plot the histogram of the original image
figure;
subplot(2, 2, 1); % Create a 2x2 grid of plots and select the first
bar(grayLevels, counts);
xlabel('Pixel Intensity');
ylabel('Frequency');
title('Histogram of Original Image');

% Plot the histogram of the equalized image

subplot(2, 2, 2); % Select the second plot
bar(grayLevelsEq, countsEq);
xlabel('Pixel Intensity');
ylabel('Frequency');
title('Histogram of Equalized Image');

% Display the original and equalized images

subplot(2, 2, [3 4]); % Select the third and fourth plots
imshowpair(img, equalizedImg, 'montage');
title('Original Image (Left) and Equalized Image (Right)');

% Display counts and gray levels for original and equalized histograms
disp('Original Image Counts:');
disp(counts);
disp('Original Image Gray Levels:');
disp(grayLevels);

disp('Equalized Image Counts:');

disp(countsEq);
disp('Equalized Image Gray Levels:');
disp(grayLevelsEq);

Output:

12
 3. Logarithmic nd inverse log transformation

Algorithm:
Read Input Image:

 a = imread('/MATLAB Drive/DIP/images/vibrant.jpg');

Convert to Grayscale:

 b = rgb2gray(a);

Normalize the Grayscale Image:

 b = double(b) / 255;

Apply Logarithmic Transformation:

 c = log(1 + b);
 c = mat2gray(c);

Apply Inverse Logarithmic Transformation:

 d = exp(c) - 1;
 d = mat2gray(d);

Display Original, Log Transformed, and Inverse Transformed Images with Histograms:

 Plot original image and its histogram:

o subplot(3,2,1); imshow(b); title('Original Grayscale Image');
o subplot(3,2,2); imhist(b); title('Histogram of Original Image');
 Plot log-transformed image and its histogram:
o subplot(3,2,3); imshow(c); title('Logarithmically Transformed Image');
o subplot(3,2,4); imhist(c); title('Histogram of Transformed Image');
 Plot inverse log-transformed image and its histogram:
o subplot(3,2,5); imshow(d); title('Inverse Logarithmically Transformed Image');
o subplot(3,2,6); imhist(d); title('Histogram of Inverse Transformed Image');

Code:

clc;
clear all;
close all;

a = imread('/MATLAB Drive/DIP/images/vibrant.jpg');
b = rgb2gray(a);
b = double(b) / 255;
c = log(1 + b);
c = mat2gray(c);
d = exp(c) - 1;
d = mat2gray(d);

figure;
subplot(3,2,1);
imshow(b);

13
 title('Original Grayscale Image');

subplot(3,2,2);
imhist(b);
title('Histogram of Original Image');
xlabel('Intensity Level');
ylabel('Frequency');

subplot(3,2,3);
imshow(c);
title('Logarithmically Transformed Image');

subplot(3,2,4);
imhist(c);
title('Histogram of Transformed Image');
xlabel('Intensity Level');
ylabel('Frequency');

subplot(3,2,5);
imshow(d);
title('Inverse Logarithmically Transformed Image');

subplot(3,2,6);
imhist(d);
title('Histogram of Inverse Transformed Image');
xlabel('Intensity Level');
ylabel('Frequency');

Output:

14
 4. Power law transformation
Algorithm:

Read and Preprocess the Image:

 a = imread('/MATLAB Drive/DIP/images/city.jpeg');
 b = rgb2gray(a);
 b = double(b) / 255; % Normalize to range [0, 1]

Apply Power Law Transformation:

 Set gamma = 2; % Adjust gamma value as needed

 c = b .^ gamma;
 Normalize: c = mat2gray(c);

Display Original Image and Histogram:

 subplot(2,2,1); imshow(b); title('Original Grayscale Image');

 subplot(2,2,2); imhist(b); title('Histogram of Original Image');

Display Power Law Transformed Image and Histogram:

 subplot(2,2,3); imshow(c); title('Power Law Transformed Image');

 subplot(2,2,4); imhist(c); title('Histogram of Transformed Image');

Define the Grid Size and Location:

 Set gridSize = 3; % 3x3 pixels grid

 Calculate starting row and column:
o rowStart = floor((rows - gridSize) / 2) + 1;
o colStart = floor((cols - gridSize) / 2) + 1;

Extract 3x3 Grids:

 Extract grid from original image: originalGrid = b(rowStart:rowStart + gridSize - 1, colStart:colStart + gridSize - 1);
 Extract grid from transformed image: powerLawGrid = c(rowStart:rowStart + gridSize - 1, colStart:colStart + gridSize -
1);

Display 3x3 Grids:

 subplot(2, 2, 1); imshow(originalGrid, []); title('Original Image Grid (3x3)');

 subplot(2, 2, 2); imshow(powerLawGrid, []); title('Power Law Transformed Grid (3x3)');

Print Grid Pixel Values:

 Display original grid pixel values: disp('Original 3x3 Grid Pixel Values:'); disp(originalGrid);
 Display transformed grid pixel values: disp('Power Law Transformed 3x3 Grid Pixel Values:'); disp(powerLawGrid);

15
 Code:

clc;
clear all;
close all;

% Read and preprocess the image

a = imread('/MATLAB Drive/DIP/images/city.jpeg');
b = rgb2gray(a);
b = double(b) / 255; % Normalize to range [0, 1]

% Power Law Transformation (Gamma Correction)

gamma = 2; % You can adjust the gamma value as needed
c = b .^ gamma;

% Normalize the transformed image to [0, 1]

c = mat2gray(c);

% Display images and histograms

figure;

% Original Image
subplot(2,2,1);
imshow(b);
title('Original Grayscale Image');

subplot(2,2,2);
imhist(b);
title('Histogram of Original Image');
xlabel('Intensity Level');
ylabel('Frequency');

% Power Law Transformed Image

subplot(2,2,3);
imshow(c);
title('Power Law Transformed Image');

subplot(2,2,4);
imhist(c);
title('Histogram of Transformed Image');
xlabel('Intensity Level');
ylabel('Frequency');

% Define the grid size and location

[rows, cols] = size(b);
gridSize = 3; % Size of the grid (3x3 pixels)
rowStart = floor((rows - gridSize) / 2) + 1;
colStart = floor((cols - gridSize) / 2) + 1;

% Extract the 3x3 grid from the original and power-law transformed images
originalGrid = b(rowStart:rowStart + gridSize - 1, colStart:colStart + gridSize - 1);
powerLawGrid = c(rowStart:rowStart + gridSize - 1, colStart:colStart + gridSize - 1);

% Display the 3x3 grids and pixel values

figure;

% Original image grid

subplot(2, 2, 1);
imshow(originalGrid, []);

16
 title('Original Image Grid (3x3)');

% Power-law transformed image grid

subplot(2, 2, 2);
imshow(powerLawGrid, []);
title('Power Law Transformed Grid (3x3)');

% Display the pixel values

disp('Original 3x3 Grid Pixel Values:');
disp(originalGrid);

disp('Power Law Transformed 3x3 Grid Pixel Values:');

disp(powerLawGrid);

Output:
gamma: 2

17
 Gamma scale =0.5

18
 Output Verification:

Result: Hence we have successfully observed the use and effect of different transformations on the input
images and observed their effect on them.

19
 LAB-3
DIGITAL IMAGE PROCESSING
Name: V Surya Teja
REG number: 21BEC1484

Aim: To perform different actions and apply filters on input images and observe the changes
accordingly.

Software used: Matlab Software

1. Bit Plane Splicing

Algorithm:

 Read the Image:

 Use imread to load the image into MATLAB. Ensure the image is in grayscale (e.g.,
using 'coins.png').

 Extract and Display Bit Planes:

 Loop through each bit plane (from 1 to 8).

 Use the bitget function to extract the specified bit plane from the image.

 Convert Bit Plane to Logical Image:

 Convert the extracted bit plane to a logical image using logical function, which
helps in visualizing the bit plane.

 Display the Bit Plane Images:

 Create a new figure window.

 Use subplot to arrange the bit plane images in a 2x4 grid.
 Display each bit plane with imshow and add a title indicating the bit plane number.

 Repeat for Remaining Bit Planes:

 If the image has more than 8 bits per pixel (e.g., 16-bit image), repeat the above steps
for the remaining bit planes.

20
Code:
A=imread('coins.png');

B=bitget(A,1);
figure,
subplot(2,2,1);imshow(logical(B));title('Bit plane 1');
B=bitget(A,2);
subplot(2,2,2);imshow(logical(B));title('Bit plane 2');

B=bitget(A,3);
subplot(2,2,3);imshow(logical(B));title('Bit plane 3');

B=bitget(A,4);
subplot(2,2,4);imshow(logical(B));title('Bit plane 4');
B=bitget(A,5);
figure,
subplot(2,2,1);imshow(logical(B));title('Bit plane 5');
B=bitget(A,6);
subplot(2,2,2);imshow(logical(B));title('Bit plane 6');
B=bitget(A,7);
subplot(2,2,3);imshow(logical(B));title('Bit plane 7');
B=bitget(A,8);
subplot(2,2,4);imshow(logical(B));title('Bit plane 8');

Output:

21
 2. Smoothening image

Algorithm:
 Read and Convert Image:

 Load the color image using imread.

 Convert the image to grayscale with rgb2gray.

 Apply Gaussian Filters:

 Apply Gaussian filters with different standard deviations (2, 4, and 8) using
imgaussfilt.

 Add Gaussian Noise:

 Add Gaussian noise to the grayscale image using imnoise for demonstration
purposes.

 Apply Filters to Noisy Image:

 Apply an averaging filter using fspecial and imfilter.

 Apply a Gaussian filter using fspecial and imfilter.

 Display Results:

 Create a figure with subplots to show the original grayscale image, noisy image,
averaging-filtered image, and Gaussian-filtered image.
 Create another figure to display the smoothed images with different Gaussian filter
parameters.

 Optional: Display Histograms:

 Create a figure with subplots to show histograms for the original image, noisy image,
averaging-filtered image, and Gaussian-filtered image.

Code:

clc;

clc;

clear all;

close all;

% Read the grayscale image

I = imread('/MATLAB Drive/DIP/images/feather.jpg');

I_gray = rgb2gray(I);

22
%gaussian filter applu

Iblur1 = imgaussfilt(I_gray,2);

Iblur2 = imgaussfilt(I_gray,4);

Iblur3 = imgaussfilt(I_gray,8);

% Add Gaussian noise to the grayscale image for demonstration purposes

I_noisy = imnoise(I_gray, 'gaussian', 0, 0.01);

% Apply an averaging filter (mean filter)

kernel_size = 200; % Size of the filter kernel

avg_filter = fspecial('average', kernel_size);

I_avg_filtered = imfilter(I_noisy, avg_filter, 'replicate');

% Apply a Gaussian filter

sigma = 1.0; % Standard deviation of the Gaussian function

gaussian_filter = fspecial('gaussian', [kernel_size kernel_size], sigma);

I_gaussian_filtered = imfilter(I_noisy, gaussian_filter, 'replicate');

% Display the results

figure;

subplot(2, 2, 1); imshow(I_gray); title('Original Grayscale Image');

subplot(2, 2, 2); imshow(I_noisy); title('Noisy Grayscale Image');

subplot(2, 2, 3); imshow(I_avg_filtered); title('Averaging Filter');

subplot(2, 2, 4); imshow(I_gaussian_filtered); title('Gaussian Filter');

%smoohening results

figure

subplot(2,2,1);imshow(Iblur1);title('Smoothed image, \sigma = 2');

23
subplot(2,2,2);imshow(Iblur2);title('Smoothed image, \sigma = 4');

subplot(2,2,3);imshow(Iblur3);title('Smoothed image, \sigma = 8');

% Optional: Display histograms

figure;

subplot(2, 2, 1); imhist(I_gray); title('Histogram of Original Image');

subplot(2, 2, 2); imhist(I_noisy); title('Histogram of Noisy Image');

subplot(2, 2, 3); imhist(I_avg_filtered); title('Histogram of Averaging Filtered Image');

subplot(2, 2, 4); imhist(I_gaussian_filtered); title('Histogram of Gaussian Filtered Image');

Outputs:

24
25
 3. Sharpening

Algorithm:
 Load and Convert Image:

 Read the image using imread.

 Convert to grayscale if the image is in RGB format using rgb2gray.

 Apply Laplacian Filter for Sharpening:

 Define the Laplacian filter matrix.

 Apply the Laplacian filter to the grayscale image using imfilter.
 Add the original grayscale image to the filtered result.
 Ensure pixel values are clipped within the valid range [0, 255].

 Apply High-Pass Filter:

 Define the high-pass filter matrix.

 Apply the high-pass filter to the grayscale image using imfilter.
 Add the original grayscale image to the filtered result.
 Ensure pixel values are clipped within the valid range [0, 255].

 Display Images:

 Create a figure with subplots to show the original grayscale image, sharpened image,
and high-pass filtered image.

 Display Histograms:

 Create a new figure with subplots to show the histograms for the original grayscale
image, sharpened image, and high-pass filtered image.

Code:

inputImage = imread('/MATLAB Drive/DIP/images/free.jpg');

% Convert the image to grayscale if it's RGB

if size(inputImage, 3) == 3

grayImage = rgb2gray(inputImage);

else

grayImage = inputImage;

end

% Define the Laplacian filter for sharpening

laplacianFilter = [0 -1 0; -1 4 -1; 0 -1 0];

26
% Apply the Laplacian filter to the grayscale image

sharpenedImage = imfilter(grayImage, laplacianFilter, 'replicate');

% Add the original grayscale image to the sharpened image

sharpenedImage = grayImage + sharpenedImage;

% Enure the sharpened image values are within valid range [0, 255]

sharpenedImage = min(max(sharpenedImage, 0), 255);

% Define a high-pass filter (simple example)

highPassFilter = [-1 -1 -1; -1 8 -1; -1 -1 -1];

% Apply the high-pass filter to the grayscale image

highPassFilteredImage = imfilter(grayImage, highPassFilter, 'replicate');

% Add the original grayscale image to the high-pass filtered image

highPassFilteredImage = grayImage + highPassFilteredImage;

% Ensure the high-pass filtered image values are within valid range [0, 255]

highPassFilteredImage = min(max(highPassFilteredImage, 0), 255);

% Display the original, sharpened, and high-pass filtered images in one figure

figure;

subplot(1, 3, 1);

imshow(grayImage);

title('Original Image');

subplot(1, 3, 2);

imshow(sharpenedImage);

title('Sharpened Image');

subplot(1, 3, 3);

imshow(highPassFilteredImage);

title('High-Pass Filtered Image');

27
% Display the histograms of the original, sharpened, and high-pass filtered images in another figure

figure;

subplot(1, 3, 1);

imhist(grayImage);

title('Histogram of Original Image');

subplot(1, 3, 2);

imhist(sharpenedImage);

title('Histogram of Sharpened Image');

subplot(1, 3, 3);

imhist(highPassFilteredImage);

title('Histogram of High-Pass Filtered Image');

Output:

28
Output Verification:

Result: Hence we have successfully observed the changes in the input and output images accordingly.

29
 Lab 4

DIGITAL IMAGE PROCESSING

Name: V Surya Teja
REG number: 21BEC1484

Aim: To perform smoothening and sharpening of input image using different

filters and observe the outputs accordingly.

I. Smootheing

1. Using Guassian filter:

Code:
% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Apply Gaussian filters with different sizes and sigma values

sigma3x3 = 0.5; % Standard deviation for 3x3 filter
sigma5x5 = 1.0; % Standard deviation for 5x5 filter
sigma7x7 = 1.5; % Standard deviation for 7x7 filter

% Create Gaussian filters

h_gaussian3x3 = fspecial('gaussian', [3 3], sigma3x3);
h_gaussian5x5 = fspecial('gaussian', [5 5], sigma5x5);
h_gaussian7x7 = fspecial('gaussian', [7 7], sigma7x7);

% Apply Gaussian filters

smoothed_image_gaussian3x3 = imfilter(image, h_gaussian3x3);
smoothed_image_gaussian5x5 = imfilter(image, h_gaussian5x5);
smoothed_image_gaussian7x7 = imfilter(image, h_gaussian7x7);

% Display images
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(smoothed_image_gaussian3x3);
title('Gaussian Filter 3x3');

subplot(2, 2, 3);
imshow(smoothed_image_gaussian5x5);
title('Gaussian Filter 5x5');

subplot(2, 2, 4);

30
imshow(smoothed_image_gaussian7x7);
title('Gaussian Filter 7x7');

output:

2. Using mean filter

code:
% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Apply mean filters with different sizes

h_mean3x3 = fspecial('average', [3 3]);
h_mean5x5 = fspecial('average', [5 5]);
h_mean7x7 = fspecial('average', [7 7]);

smoothed_image_mean3x3 = imfilter(image, h_mean3x3);

smoothed_image_mean5x5 = imfilter(image, h_mean5x5);
smoothed_image_mean7x7 = imfilter(image, h_mean7x7);

% Display images

31
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(smoothed_image_mean3x3);
title('Mean Filter 3x3');

subplot(2, 2, 3);
imshow(smoothed_image_mean5x5);
title('Mean Filter 5x5');

subplot(2, 2, 4);
imshow(smoothed_image_mean7x7);
title('Mean Filter 7x7');

32
3. Using laplacian filter
code:

% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Apply Gaussian filters with different sizes and sigma values

sigma3x3 = 0.5; % Standard deviation for 3x3 filter
sigma5x5 = 1.0; % Standard deviation for 5x5 filter
sigma7x7 = 1.5; % Standard deviation for 7x7 filter

% Create Gaussian filters

h_gaussian3x3 = fspecial('gaussian', [3 3], sigma3x3);
h_gaussian5x5 = fspecial('gaussian', [5 5], sigma5x5);
h_gaussian7x7 = fspecial('gaussian', [7 7], sigma7x7);

% Apply Gaussian filters

smoothed_image_gaussian3x3 = imfilter(image, h_gaussian3x3);
smoothed_image_gaussian5x5 = imfilter(image, h_gaussian5x5);
smoothed_image_gaussian7x7 = imfilter(image, h_gaussian7x7);

% Display images
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(smoothed_image_gaussian3x3);
title('Gaussian Filter 3x3');

subplot(2, 2, 3);
imshow(smoothed_image_gaussian5x5);
title('Gaussian Filter 5x5');

subplot(2, 2, 4);
imshow(smoothed_image_gaussian7x7);
title('Gaussian Filter 7x7');

33
II. SHARPENING

1. Using Guassian
code:
% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Define Gaussian filter sizes and standard deviations

sigma3x3 = 0.5; % Standard deviation for 3x3 filter
sigma5x5 = 1.0; % Standard deviation for 5x5 filter
sigma7x7 = 1.5; % Standard deviation for 7x7 filter

% Create Gaussian filters

h_gaussian3x3 = fspecial('gaussian', [3 3], sigma3x3);
h_gaussian5x5 = fspecial('gaussian', [5 5], sigma5x5);
h_gaussian7x7 = fspecial('gaussian', [7 7], sigma7x7);

34
% Apply Gaussian blurs
blurred_image3x3 = imfilter(image, h_gaussian3x3, 'replicate');
blurred_image5x5 = imfilter(image, h_gaussian5x5, 'replicate');
blurred_image7x7 = imfilter(image, h_gaussian7x7, 'replicate');

% Perform sharpening by subtracting the blurred image from the original

sharpened_image3x3 = image - blurred_image3x3;
sharpened_image5x5 = image - blurred_image5x5;
sharpened_image7x7 = image - blurred_image7x7;

% Normalize the results to the range [0, 255]

sharpened_image3x3 = uint8(mat2gray(sharpened_image3x3) * 255);
sharpened_image5x5 = uint8(mat2gray(sharpened_image5x5) * 255);
sharpened_image7x7 = uint8(mat2gray(sharpened_image7x7) * 255);

% Display images
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(sharpened_image3x3);
title('Sharpened 3x3');

subplot(2, 2, 3);
imshow(sharpened_image5x5);
title('Sharpened 5x5');

subplot(2, 2, 4);
imshow(sharpened_image7x7);
title('Sharpened 7x7');

35
2. Laplace
code:
% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Create Laplacian filters with different sizes

% For demonstration, we will use the 3x3 Laplacian filter. Larger filters can be approximated.
alpha = 0.2; % Parameter for the Laplacian filter

% Create Laplacian filters (fspecial('laplacian') only creates a 3x3 filter)

h_laplacian = fspecial('laplacian', alpha);

% Apply Laplacian filter

laplacian_image = imfilter(image, h_laplacian, 'replicate');

% Sharpening by subtracting the Laplacian-filtered image from the original

sharpened_image = image - laplacian_image;

% Normalize the result to the range [0, 255]

sharpened_image = uint8(mat2gray(sharpened_image) * 255);

% Display images
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(laplacian_image, []);
title('Laplacian Filtered Image');

subplot(2, 2, 3);
imshow(sharpened_image);
title('Sharpened Image');

% Note: For larger Laplacian filters, custom design would be needed.

36
3. mean filter
code:
% Read an example image

image = imread('/MATLAB Drive/DIP/images/mine.jpg'); % Replace with your image file

% Convert to grayscale if it's a color image

if size(image, 3) == 3
image = rgb2gray(image);
end

% Create mean filters with different sizes

h_mean3x3 = fspecial('average', [3 3]);
h_mean5x5 = fspecial('average', [5 5]);
h_mean7x7 = fspecial('average', [7 7]);

% Apply mean filters to blur the image

blurred_image3x3 = imfilter(image, h_mean3x3, 'replicate');
blurred_image5x5 = imfilter(image, h_mean5x5, 'replicate');
blurred_image7x7 = imfilter(image, h_mean7x7, 'replicate');

% Perform sharpening by subtracting the blurred image from the original

sharpened_image3x3 = image - blurred_image3x3;
sharpened_image5x5 = image - blurred_image5x5;
sharpened_image7x7 = image - blurred_image7x7;

% Normalize the results to the range [0, 255]

37
sharpened_image3x3 = uint8(mat2gray(sharpened_image3x3) * 255);
sharpened_image5x5 = uint8(mat2gray(sharpened_image5x5) * 255);
sharpened_image7x7 = uint8(mat2gray(sharpened_image7x7) * 255);

% Display images
figure;

subplot(2, 2, 1);
imshow(image);
title('Original Image');

subplot(2, 2, 2);
imshow(sharpened_image3x3);
title('Sharpened 3x3 Mean Filter');

subplot(2, 2, 3);
imshow(sharpened_image5x5);
title('Sharpened 5x5 Mean Filter');

subplot(2, 2, 4);
imshow(sharpened_image7x7);
title('Sharpened 7x7 Mean Filter');

38
Output Verification :

Inference:
Applying smoothing and sharpening processes using Gaussian, Laplace, and Mean filters of
various sizes (3x3, 5x5, 7x7) revealed that larger kernels produced stronger blurring effects in
smoothing, with Gaussian effectively reducing noise while preserving details. The Mean
filter uniformly smoothed the image, but larger kernels caused more blur. In sharpening, the
Laplace filter enhanced edges by emphasizing regions of rapid intensity change, though
larger kernels could also amplify noise. The filter choice and size determined the balance
between noise reduction, detail preservation, and edge enhancement.

Result:
Hence we have successfully performed smoothening and sharpening of input images using
different filters and observed the result accordingly.

39
 LAB-5
Digital image processing

Name: V.Surya Teja

REG number: 21BEC1484

Aim: To perform DCT on input images using different grid sizes as well as perform inverse
DCT and analyze the errors using different techniques.

Software required: MATLAB Software

1.2D-DCT

Code:
% Read the input image

input_image = imread('/MATLAB Drive/DIP/images/saaho.png');

% Convert the image to grayscale if it's not already

if size(input_image, 3) == 3
gray_image = rgb2gray(input_image);
else
gray_image = input_image;
end

% Apply 2D DCT
dct_image = dct2(double(gray_image));

% Display the original and DCT images

figure;

% Display Original Image

subplot(1, 3, 1);
imshow(gray_image, []);
title('Original Image');

% Display DCT Image without Log Transformation

subplot(1, 3, 2);
imshow(dct_image, []);
title('DCT Image (Raw)');

% Display DCT Image with Log Transformation

subplot(1, 3, 3);
imshow(log(abs(dct_image) + 1), []); % Added 1 to avoid log(0) issue

40
title('DCT Image (Log Scale)');

% Optionally, you can display the DCT coefficients with a colormap for better visibility
figure;
imshow(log(abs(dct_image) + 1), []); % Added 1 to avoid log(0) issue
colormap(jet);
colorbar;
title('DCT Coefficients (Log Scale with Colormap)');

Output:

Inference: We can observe that the output image after applying the transformation has lost
all the frequency contents and is hence without any clarity. Seeing the log scale image it is a
little better than the RAW image as it helps to enhance the details by a little.

41
2. Applying using 8x8 grid

Code:
% Read the input image

input_image = imread('/MATLAB Drive/DIP/images/feather.jpg');

% Convert the image to grayscale if it's not already

if size(input_image, 3) == 3
gray_image = rgb2gray(input_image);
else
gray_image = input_image;
end

% Get the size of the image

[rows, cols] = size(gray_image);

% Preallocate the matrix for the DCT-transformed image

dct_image = zeros(rows, cols);

% Define the block size (8x8)

block_size = 8;

% Apply 2D DCT to each 8x8 block

for i = 1:block_size:rows
for j = 1:block_size:cols
% Extract the current block
current_block = double(gray_image(i:i+block_size-1, j:j+block_size-1));

% Apply the 2D DCT

dct_block = dct2(current_block);

% Store the DCT coefficients in the corresponding location in the output image
dct_image(i:i+block_size-1, j:j+block_size-1) = dct_block;
end
end

% Display the original and DCT images

figure;

subplot(1, 2, 1);
imshow(gray_image);
title('Original Image');

subplot(1, 2, 2);
imshow(log(abs(dct_image)), []);
title('DCT Image (8x8 block, log scale)');

% Optionally, you can display the DCT coefficients in a more visible way
figure;

42
imshow(log(abs(dct_image)), []);
colormap(jet);
colorbar;
title('DCT Coefficients (8x8 block, log scale, with colormap)');

Outputs:

Inference: Here we can observe the details in the output images after applying the 8x8 block
DCT. The respective color map also shows the detail orientation and distribution in the given
picture.

43
3. Using 16x16 grid:
code:
% Read the input image

input_image = imread('/MATLAB Drive/DIP/images/feather.jpg');

% Convert the image to grayscale if it's not already

if size(input_image, 3) == 3
gray_image = rgb2gray(input_image);
else
gray_image = input_image;
end

% Get the size of the image

[rows, cols] = size(gray_image);

% Preallocate the matrix for the DCT-transformed image

dct_image = zeros(rows, cols);

% Define the block size (16x16)

block_size = 16;

% Apply 2D DCT to each 16x16 block

for i = 1:block_size:rows
for j = 1:block_size:cols
% Extract the current block
current_block = double(gray_image(i:i+block_size-1, j:j+block_size-1));

% Apply the 2D DCT

dct_block = dct2(current_block);

% Store the DCT coefficients in the corresponding location in the output image
dct_image(i:i+block_size-1, j:j+block_size-1) = dct_block;
end
end

% Display the original and DCT images

figure;

subplot(1, 2, 1);
imshow(gray_image);
title('Original Image');

subplot(1, 2, 2);
imshow(log(abs(dct_image)), []);
title('DCT Image (16x16 block, log scale)');

% Optionally, you can display the DCT coefficients in a more visible way
figure;
imshow(log(abs(dct_image)), []);

44
colormap(jet);
colorbar;
title('DCT Coefficients (16x16 block, log scale, with colormap)');

Output:

Inference: As we can see here similar to the 8x8 block the 16x16 also gave us the
transformed image accordingly but if we observe keenly the 16x16 is less detailed than the
8x8 because the 16x16 gets lesser number of blocks with the analyzing and hence lesser
frequencies get transformed .The same thing can be observed with the colormap as well.

45
4. Inverse DCT:
Code:
% Read the input image

input_image = imread('/MATLAB Drive/DIP/images/feather.jpg');

% Convert the image to grayscale if it's not already

if size(input_image, 3) == 3
gray_image = rgb2gray(input_image);
else
gray_image = input_image;
end

% Get the size of the image

[rows, cols] = size(gray_image);

% Preallocate the matrix for the DCT-transformed image

dct_image = zeros(rows, cols);

% Preallocate the matrix for the reconstructed image after IDCT

reconstructed_image = zeros(rows, cols);

% Define the block size (8x8)

block_size = 8;

% Apply 2D DCT to each 8x8 block

for i = 1:block_size:rows
for j = 1:block_size:cols
% Extract the current block
current_block = double(gray_image(i:i+block_size-1, j:j+block_size-1));

% Apply the 2D DCT

dct_block = dct2(current_block);

% Store the DCT coefficients in the corresponding location in the output image
dct_image(i:i+block_size-1, j:j+block_size-1) = dct_block;

% Apply the inverse 2D DCT to reconstruct the image

idct_block = idct2(dct_block);

% Store the reconstructed block in the corresponding location in the reconstructed image
reconstructed_image(i:i+block_size-1, j:j+block_size-1) = idct_block;
end
end

% Convert the reconstructed image back to uint8

reconstructed_image = uint8(reconstructed_image);

% Display the original, DCT, and reconstructed images

figure;

subplot(1, 3, 1);
imshow(gray_image);
title('Original Image');

46
subplot(1, 3, 2);
imshow(log(abs(dct_image)), []);
title('DCT Image (8x8 block, log scale)');

subplot(1, 3, 3);
imshow(reconstructed_image);
title('Reconstructed Image (after IDCT)');

% Optionally, you can display the DCT coefficients in a more visible way
figure;
imshow(log(abs(dct_image)), []);
colormap(jet);
colorbar;
title('DCT Coefficients (8x8 block, log scale, with colormap)');

Output:

Inference: We have successfully applied the DCT using the 8x8 grid and also we have
applied the inverse DCT after every grid is done with the DCT, this finally gives us the
reconstructed image which is same to the original.

47
5. Error analysis
Code:
-mean square error
-root mean square error
-psnr

Code:
% Read the input image

input_image = imread('/MATLAB Drive/DIP/images/ave2.jpg');

% Convert the image to grayscale if it's not already

if size(input_image, 3) == 3
gray_image = rgb2gray(input_image);
else
gray_image = input_image;
end

% Get the size of the image

[rows, cols] = size(gray_image);

% Preallocate the matrix for the DCT-transformed image

dct_image = zeros(rows, cols);

% Preallocate the matrix for the reconstructed image after IDCT

reconstructed_image = zeros(rows, cols);

% Define the block size (8x8)

block_size = 8;

% Apply 2D DCT to each 8x8 block

for i = 1:block_size:rows
for j = 1:block_size:cols
% Extract the current block
current_block = double(gray_image(i:i+block_size-1, j:j+block_size-1));

% Apply the 2D DCT

dct_block = dct2(current_block);

% Store the DCT coefficients in the corresponding location in the output image
dct_image(i:i+block_size-1, j:j+block_size-1) = dct_block;

% Apply the inverse 2D DCT to reconstruct the image

idct_block = idct2(dct_block);

% Store the reconstructed block in the corresponding location in the reconstructed image
reconstructed_image(i:i+block_size-1, j:j+block_size-1) = idct_block;
end
end

% Convert the reconstructed image back to uint8

reconstructed_image = uint8(reconstructed_image);

48
% Calculate the Mean Square Error (MSE)
mse = mean((double(gray_image) - double(reconstructed_image)).^2, 'all');

% Calculate the Root Mean Square Error (RMSE)

rmse = sqrt(mse);

% Calculate the Peak Signal-to-Noise Ratio (PSNR)

psnr_value = 10 * log10(255^2 / mse);

% Display the original, DCT, and reconstructed images

figure;

subplot(1, 3, 1);
imshow(gray_image);
title('Original Image');

subplot(1, 3, 2);
imshow(log(abs(dct_image)), []);
title('DCT Image (8x8 block, log scale)');

subplot(1, 3, 3);
imshow(reconstructed_image);
title('Reconstructed Image (after IDCT)');

% Display the error analysis results

fprintf('Error Analysis Results:\n');
fprintf('Mean Square Error (MSE): %.4f\n', mse);
fprintf('Root Mean Square Error (RMSE): %.4f\n', rmse);
fprintf('Peak Signal-to-Noise Ratio (PSNR): %.4f dB\n', psnr_value);

% Optionally, you can display the DCT coefficients in a more visible way
figure;
imshow(log(abs(dct_image)), []);
colormap(jet);
colorbar;
title('DCT Coefficients (8x8 block, log scale, with colormap)');

Output:

49
Inference: Hence we have successfully also calculated the errors for the taken input and the
transformed image accordingly, the error and the psnr values also can be viewed accordingly.

Output Verification:

Result: Hence we have successfully completed the DCT transformations on input image and
observed the results accordingly.

50
 LAB EXPERIMENT -6

DIGITAL IMAGE PROCESSING

Name: V.Surya Teja

REG number: 21BEC1484

Aim: To perform Smoothing using Fast Fourier Transform on input image in frequency domain using
different mask’s size and observe the result.

Software required: MATLAB Software

1.Smoothening

Algorithm:

 Load and Convert Image:

 Read an image from a file and convert it to grayscale.

 Display the grayscale image.

 Prepare for Frequency Domain Processing:

 Convert the grayscale image to a double precision format for processing.

 Compute the 2D Fast Fourier Transform (FFT) of the image.
 Shift the zero-frequency component to the center of the frequency domain.

 Create Gaussian Low-Pass Filter:

 Generate a meshgrid for the image dimensions.

 Define the center of the frequency domain.
 Create a Gaussian low-pass filter based on the distance from the center and a specified
cutoff frequency D0D0D0.

 Apply Filter in Frequency Domain:

 Multiply the shifted FFT of the image by the Gaussian filter to attenuate high
frequencies.
 Shift the zero-frequency component back to the original position.

 Transform Back to Spatial Domain:

 Compute the inverse FFT to get the filtered image back in the spatial domain.
 Convert the result to an 8-bit unsigned integer format.

 Display the Result:

 Display the smoothed image and provide a title.

51
Code:
img = imread('/MATLAB Drive/DIP/images/feather.jpg');

img_gray = rgb2gray(img);
imshow(img_gray);
title('Original Image');

img_double = double(img_gray);

F = fft2(img_double);
F_shifted = fftshift(F);

[M, N] = size(img_double);
[X, Y] = meshgrid(1:N, 1:M);
centerX = N / 2;
centerY = M / 2;
D0 = 30;
H = exp(-((X - centerX).^2 + (Y - centerY).^2) / (2 * D0^2));

G_shifted = F_shifted .* H;

G = ifftshift(G_shifted);
img_smooth = ifft2(G);

img_smooth = uint8(real(img_smooth));

figure;
imshow(img_smooth);
title('Smoothened Image');

Output:

52
2. Smoothening with mask

Algorithm:

 Read and Prepare the Image:

 Load an image file and convert it to grayscale.

 Convert the grayscale image to a double precision format.

 Compute the 2D FFT of the Image:

 Calculate the 2D Fast Fourier Transform (FFT) of the image.

 Shift the zero-frequency component to the center of the frequency domain.

 Iterate Over Different Mask Sizes:

 Define a list of different mask sizes.

 For each mask size:
o Generate a binary low-pass filter mask with a radius equal to the current mask
size.

 Apply the Filter and Compute Inverse FFT:

 Multiply the shifted FFT of the image by the current filter mask.
 Shift the zero-frequency component back to the original position and perform the
inverse FFT to obtain the filtered image.
 Convert the resulting image to an 8-bit unsigned integer format.

 Display the Results:

 Display the original image and each filtered image in separate figures, providing a
title indicating the mask size used.

Code:

% Read and Display the Image

img = imread('/MATLAB Drive/DIP/images/feather.jpg');
img_gray = rgb2gray(img);
img_double = double(img_gray);

% Compute the 2D FFT of the Image

F = fft2(img_double);
F_shifted = fftshift(F);

% Define mask sizes and create masks

sizes = [10, 20, 30, 40]; % Example mask sizes

53
% Display the Original Image
figure;
imshow(img_gray);
title('Original Image');

for i = 1:length(sizes)
D0 = sizes(i); % Mask size

% Create a Low-Pass Filter Mask

[M, N] = size(img_double);
[X, Y] = meshgrid(1:N, 1:M);
centerX = N / 2;
centerY = M / 2;
H = double(sqrt((X - centerX).^2 + (Y - centerY).^2) <= D0);

% Apply the Mask

G_shifted = F_shifted .* H;

% Compute the Inverse FFT

G = ifftshift(G_shifted);
img_smooth = ifft2(G);
img_smooth = uint8(real(img_smooth));

% Display the Result in a New Figure

figure;
imshow(img_smooth);
title(['Smoothened Image with Mask Size ', num2str(D0)]);
end

Output:

54
55
3. Inverse fft on masked image

Algorithm:

 Read and Prepare the Image:

 Load the image file and convert it to grayscale.

 Convert the grayscale image to double precision.

 Compute the 2D FFT and Shift:

 Perform the 2D Fast Fourier Transform (FFT) on the image.

 Shift the zero-frequency component to the center of the frequency domain.

 Create and Apply the Low-Pass Filter Mask:

 Define a low-pass filter mask with a specified radius D0D0D0 (e.g., 40).
 Generate a binary mask in the frequency domain based on the distance from the
center.
 Apply this mask by multiplying it with the shifted FFT of the image.

 Inverse FFT and Prepare Image for Display:

 Reverse the FFT shift and compute the inverse FFT to obtain the filtered image.
 Convert the result to an 8-bit unsigned integer format.

 Display the Results:

 Display the original grayscale image.

 Show the original FFT magnitude (with log scaling) to visualize the frequency
components.
 Display the low-pass filter mask.
 Show the masked FFT magnitude (with log scaling) after applying the filter.
 Display the image obtained after performing the inverse FFT.

Code:

% Read and Display the Image

img = imread('/MATLAB Drive/DIP/images/feather.jpg');
img_gray = rgb2gray(img);
img_double = double(img_gray);

% Compute the 2D FFT of the Image

F = fft2(img_double);
F_shifted = fftshift(F);

% Define Mask Size

D0 = 40; % Mask size

% Create a Low-Pass Filter Mask

56
[M, N] = size(img_double);
[X, Y] = meshgrid(1:N, 1:M);
centerX = N / 2;
centerY = M / 2;
H = double(sqrt((X - centerX).^2 + (Y - centerY).^2) <= D0);

% Apply the Mask

G_shifted = F_shifted .* H;

% Compute the Inverse FFT

G = ifftshift(G_shifted); % Reverse the FFT shift
img_smooth = ifft2(G);
img_smooth = uint8(real(img_smooth));

% Display the Original Image

figure;
imshow(img_gray);
title('Original Image');

% Display the Original Frequency Domain Image

figure;
imshow(log(abs(F_shifted) + 1), []); % Display magnitude of original FFT with log
scaling
title('Original Frequency Domain Image');

% Display the Mask Image in Spatial Domain

figure;
imshow(H, []); % Display mask in spatial domain
title('Low-Pass Filter Mask (Size 40)');

% Display the Masked Frequency Domain Image

figure;
imshow(log(abs(G_shifted) + 1), []); % Display magnitude of masked FFT with log
scaling
title('Masked Frequency Domain Image (Size 40)');

% Display the Image After IFFT

figure;
imshow(img_smooth);
title('Image After IFFT ');

Output:

57
58
Verification:

Inference: Frequency domain filtering effectively smooths images by attenuating high-frequency

components, with filter size directly influencing the degree of smoothing. Visualization of both the
spatial and frequency domains provides clear insights into the filtering effects.

59
 Lab Experiment -7
DIGITAL IMAGE PROCESSING
Name: Vadde Surya Teja
REG number: 21BEC1484

Aim: To perform sharpening using Fast Fourier transform on input images in

frequency domain with different mask sizes and observe the output.
Software Required: MATLAB software

1. Sharpening using FFT and different mask sizes.

Algorithm:

Read and Preprocess Image:

 Read the input image and convert it to grayscale if it is a color image. Convert the
image to double precision for processing.

Compute FFT:

 Perform the Fast Fourier Transform (FFT) on the image and shift the zero frequency
component to the center.

Create High-Pass Filter Masks:

 Define a range of mask sizes and create high-pass filter masks to block low
frequencies while retaining high frequencies.

Apply Filter and Inverse FFT:

 For each mask size, apply the high-pass filter mask in the frequency domain, then
compute the inverse FFT to obtain the sharpened image.

Display Results:

 Display the original image and the sharpened images for different mask sizes.

60
Code:
inputImage = imread('/MATLAB Drive/DIP/images/free.jpg');
if size(inputImage, 3) == 3
inputImage = rgb2gray(inputImage);
end
inputImage = im2double(inputImage);
F = fft2(inputImage);
Fshift = fftshift(F);
[rows, cols] = size(inputImage);
centerX = round(rows / 2);
centerY = round(cols / 2);
maskSizes = [5, 9, 13, 17, 21];
figure;
subplot(2, 3, 1);
imshow(inputImage);
title('Original Image');
for i = 1:length(maskSizes)
maskSize = maskSizes(i);
mask = ones(rows, cols);
mask(centerX - maskSize:centerX + maskSize, centerY - maskSize:centerY +
maskSize) = 0;
F_filtered = Fshift .* mask;
F_ishift = ifftshift(F_filtered);
sharpenedImage = real(ifft2(F_ishift));
subplot(2, 3, i + 1);
imshow(sharpenedImage, []);
title(['Sharpened Image (Mask Size: ', num2str(maskSize), ')']);
end

61
Output:

2. Inverse fft

Algorithm:

1. Read and Preprocess Image:

o Load the input image. If it is in color, convert it to grayscale. Convert the
image to double precision for accurate processing.
2. Compute FFT of the Image:
o Perform the Fast Fourier Transform (FFT) on the image to obtain its frequency
domain representation. Shift the zero frequency component to the center for
visualization.
3. Visualize Magnitude Spectrum:
o Compute the magnitude spectrum of the FFT result to visualize the frequency
content of the image.
4. Apply Inverse FFT:
o Perform the inverse FFT on the frequency domain representation without
applying any filters or modifications. Shift the frequency components back
before computing the inverse.
5. Display Results:

62
 o Display the original image, the magnitude spectrum, and the reconstructed
image to verify that the original image is accurately recovered after applying
FFT and inverse FFT.

Code:
% Read the input image
inputImage = imread('/MATLAB Drive/DIP/images/free.jpg');
if size(inputImage, 3) == 3
inputImage = rgb2gray(inputImage);
end

% Convert image to double precision for processing

inputImage = im2double(inputImage);

% Perform FFT of the input image

F = fft2(inputImage);
Fshift = fftshift(F);

% Display the magnitude spectrum for visualization

magnitudeSpectrum = log(1 + abs(Fshift));

% Apply inverse FFT without any modification to reconstruct the original image
reconstructedImage = real(ifft2(ifftshift(Fshift)));

% Display the original, FFT magnitude spectrum, and reconstructed images

figure;
subplot(1, 3, 1);
imshow(inputImage);
title('Original Image');

subplot(1, 3, 2);
imshow(magnitudeSpectrum, []);
title('Magnitude Spectrum (FFT)');

subplot(1, 3, 3);
imshow(reconstructedImage, []);
title('Reconstructed Image (Inverse FFT)');

63
Output:

Inference :
When sharpening an image using high-pass filters of different mask sizes in the
frequency domain, the clarity and quality of the image are significantly affected.
Smaller mask sizes result in subtle sharpening, enhancing edges while
maintaining the overall structure. As the mask size increases, more low-
frequency components are removed, leading to stronger sharpening but also
increased noise and a loss of fine details, which can make the image appear
unnatural. When applying the inverse FFT to reconstruct the image after
filtering, the original image cannot be perfectly recovered due to the loss of
these low-frequency components. Thus, the larger the mask size, the greater the
difference between the original and reconstructed images. This demonstrates
that while sharpening can enhance details, it must be balanced to avoid
degrading the image's natural appearance.
Result: Hence, we have successfully performed the sharpening of image using
different mask sizes and also applied inverse to get back the original image.

64
 LAB ASSIGNMENT-8

Name:V. Surya Teja

Reg No.21BEC1484

Aim: To apply HomoMorphic filter on low contrast image using MATLAB code.

Apparatus Required: MATLAB

Code:

clc;
clear all;
close all;
% Read the input image
I = imread('/MATLAB Drive/DIP/Images/pic_contrast.jpeg');
I = im2double(I);
I = rgb2gray(I);
% Display the original image in a separate figure
figure;
imshow(I);
title('Original Image');
% Convert the image to log domain
I_log = log(1 + I);
% Perform Fourier Transform
I_fft = fft2(I_log);
% Shift zero-frequency component to the center
I_fft_shifted = fftshift(I_fft);
% Get the size of the image
[M, N, C] = size(I); % Assume the image may have 3 color channels
u = 0:(M-1);
v = 0:(N-1);
u = u - M/2;

65
v = v - N/2;
[V, U] = meshgrid(v, u);
D = sqrt(U.^2 + V.^2);
% Define parameter sets for gammaH, gammaL, and D0
gammaH_values = [2.0, 2.5]; % Different values for higher gamma
gammaL_values = [0.5, 0.9]; % Different values for lower gamma
D0_values = [20, 30]; % Different cutoff frequencies
% Calculate the number of subplots needed
num_combinations = length(gammaH_values) * length(gammaL_values) *
length(D0_values);
rows = ceil(sqrt(num_combinations));
cols = ceil(num_combinations / rows);
% Create a figure for subplots
figure;
count = 1;
for gammaH = gammaH_values
for gammaL = gammaL_values
for D0 = D0_values

% Gaussian High-Pass Filter for current parameters

H = (gammaH - gammaL) * (1 - exp(-(D.^2) / (2 * D0^2))) + gammaL;

% Apply the filter in the frequency domain

I_fft_filtered = I_fft_shifted .* H;

% Perform inverse Fourier Transform

I_ifft_shifted = ifftshift(I_fft_filtered); % Shift back before inverse FFT
I_filtered = real(ifft2(I_ifft_shifted));

% Convert back from log domain

I_exp = exp(I_filtered) - 1;

% Normalize the output image for better visibility

I_exp = mat2gray(I_exp);

66
 % Adjust the intensity for better visibility
I_exp = imadjust(I_exp, stretchlim(I_exp, [0.01, 0.99]), []);

% Display the result in a subplot

subplot(rows, cols, count);
imshow(I_exp);
title(sprintf('\\gamma_H=%.1f, \\gamma_L=%.1f, D_0=%d', gammaH,
gammaL, D0));

count = count + 1;
end
end
end
% Adjust the layout of the subplots for better visibility
sgtitle('Filtered Images with Various Parameters'); % Add a super title

Algorithm:
1. Read and convert the input image to grayscale.
2. Apply log transformation to the image to separate illumination and reflectance.
3. Compute the 2D Fourier Transform of the log-transformed image.
4. Design a Gaussian high-pass filter using parameters \( \gamma_H \), \(
\gamma_L \), and cutoff frequency \( D_0 \).
5. Apply the filter in the frequency domain and perform the inverse Fourier
Transform.
6. Convert back from the log domain, normalize, and display the enhanced image.

Output:

67
Result: Applied Homomorphic filter on images using MATLAB code

68
 LAB-9
DIGITAL IMAGE PROCESSING
Name: V. Surya Teja
REG number: 21BEC1484

Aim: Colour Space Conversion of RGB Images to YIQ and CMY Models and
Reconstruction using MATLAB.

Software required: MATLAB software

Algorithm:
 Input and Conversion:

 Load an RGB image.

 Convert the RGB image into YIQ and CMY color spaces.

 Back Conversion:

 Convert the YIQ image back to RGB.

 Convert the CMY image back to RGB.

 Image Display:

 Display the original RGB image, the YIQ image, the converted RGB image from
YIQ, the CMY image, and the converted RGB image from CMY.

 Color Planes Extraction:

 Extract and display the red, green, and blue planes from the original RGB image.

 Plotting:

 Organize all images in a 3x3 subplot format for easy comparison and visualization.

Code:
function color_conversion_example()
img = imread('/MATLAB Drive/DIP/images/city.jpeg');
yiq = rgb2yiq(img);
rgb_converted = yiq2rgb(yiq);
cmy = rgb2cmy(img);

69
 rgb_from_cmy = cmy2rgb(cmy);

figure;
subplot(3, 3, 1), imshow(img), title('Original RGB Image');
subplot(3, 3, 2), imshow(yiq), title('YIQ Image');
subplot(3, 3, 3), imshow(rgb_converted), title('Converted RGB from YIQ');
subplot(3, 3, 4), imshow(cmy), title('CMY Image');
subplot(3, 3, 5), imshow(rgb_from_cmy), title('Converted RGB from CMY');

displayColorPlanes(img);
end

function rgb = yiq2rgb(yiq)

R = yiq(:,:,1) + 0.956 * yiq(:,:,2) + 0.621 * yiq(:,:,3);
G = yiq(:,:,1) - 0.272 * yiq(:,:,2) - 0.647 * yiq(:,:,3);
B = yiq(:,:,1) - 1.106 * yiq(:,:,2) + 1.703 * yiq(:,:,3);
rgb = cat(3, R, G, B);
end

function yiq = rgb2yiq(rgb)

Y = 0.299 * rgb(:,:,1) + 0.587 * rgb(:,:,2) + 0.114 * rgb(:,:,3);
I = 0.596 * rgb(:,:,1) - 0.274 * rgb(:,:,2) - 0.321 * rgb(:,:,3);
Q = 0.211 * rgb(:,:,1) - 0.522 * rgb(:,:,2) + 0.311 * rgb(:,:,3);
yiq = cat(3, Y, I, Q);
end

function cmy = rgb2cmy(rgb)

70
 C = 1 - rgb(:,:,1) / 255;
M = 1 - rgb(:,:,2) / 255;
Y = 1 - rgb(:,:,3) / 255;
cmy = cat(3, C, M, Y);
end

function rgb = cmy2rgb(cmy)

R = (1 - cmy(:,:,1)) * 255;
G = (1 - cmy(:,:,2)) * 255;
B = (1 - cmy(:,:,3)) * 255;
rgb = cat(3, R, G, B);
end

function displayColorPlanes(rgb)
R = rgb;
R(:,:,2) = 0;
R(:,:,3) = 0;
G = rgb;
G(:,:,1) = 0;
G(:,:,3) = 0;
B = rgb;
B(:,:,1) = 0;
B(:,:,2) = 0;
subplot(3, 3, 6), imshow(R), title('Red Plane');
subplot(3, 3, 7), imshow(G), title('Green Plane');
subplot(3, 3, 8), imshow(B), title('Blue Plane');
end

71
 Output:

Output verification:

Result: Hence we have successfully observed the required result performing the
colour space conversion.

72
 LAB-10

DIGITAL IMAGE PROCESSING

Name: V. Surya Teja

REG number: 21BEC1484

Aim: To perform Pseudo color image processing on input image and observe
the output accordingly.

Software Required: Matlab Software

Code1:
% Read the input image
inputImage = imread('/MATLAB Drive/DIP/images/city.jpeg');

% Convert the image to grayscale

grayImage = rgb2gray(inputImage);

% Create a pseudo-color image using a colormap (e.g., 'jet')

pseudoColorImage = ind2rgb(gray2ind(grayImage, 256), jet(256));

% Display the original and pseudo-color images

figure;

subplot(1, 2, 1);
imshow(inputImage);
title('Original Image');

subplot(1, 2, 2);
imshow(pseudoColorImage);
title('Pseudo Color Image');

Output:

73
 Code2 : with specific ranges
% Read the input image
inputImage = imread('/MATLAB Drive/DIP/images/feather.jpg');

% Convert the image to grayscale

grayImage = rgb2gray(inputImage);

% Initialize a pseudo-color image

[m, n] = size(grayImage);
pseudoColorImage = zeros(m, n, 3);

% Define color ranges

% Adjust these ranges and colors as needed
for i = 1:m
for j = 1:n
intensity = grayImage(i, j);
if intensity < 85
pseudoColorImage(i, j, :) = [0, 0, 255]; % Blue for low intensities
elseif intensity < 170
pseudoColorImage(i, j, :) = [0, 255, 0]; % Green for mid intensities
else
pseudoColorImage(i, j, :) = [255, 0, 0]; % Red for high intensities
end
end
end

% Display the original and pseudo-color images

figure;

subplot(1, 2, 1);
imshow(inputImage);
title('Original Image');

subplot(1, 2, 2);
imshow(uint8(pseudoColorImage)); % Convert to uint8 for display
title('Pseudo Color Image');

Output:

74
 Code 3: with highlighting only reds, only blues, only greens

Algorithm:

 Read the Input Image: Load the image file into memory using an appropriate function
(e.g., imread in MATLAB).

 Convert to RGB Format: Ensure the image is in RGB format, as this algorithm works
with individual color channels.

 Initialize Highlighted Images: Create copies of the original image for each color channel
you want to highlight (e.g., red, green, blue, magenta, cyan, yellow).

 Define Intensity Ranges: Set lower and upper intensity thresholds for highlighting the
desired colors.

 Iterate Through Pixels: Loop through each pixel of the image and perform the following
checks:

 For Red: If the red channel intensity is within the specified range, set green and blue
channels to zero in the highlighted red image.
 For Green: If the green channel intensity is within the specified range, set red and
blue channels to zero in the highlighted green image.
 For Blue: If the blue channel intensity is within the specified range, set red and green
channels to zero in the highlighted blue image.
 For Magenta: If both red and blue intensities are above the threshold, set the green
channel to zero.
 For Cyan: If both green and blue intensities are above the threshold, set the red
channel to zero.
 For Yellow: If both red and green intensities are above the threshold, set the blue
channel to zero.

 Display Results: Use a suitable function (e.g., imshow in MATLAB) to display the
original image alongside the highlighted images for each color.

 Adjust Parameters (if needed): Based on the output, fine-tune the intensity thresholds to
achieve the desired highlighting effect.

Code:
% Read the input image
inputImage = imread('/MATLAB Drive/DIP/images/city.jpeg');

% Initialize copies for highlighting each color

highlightedRed = inputImage;
highlightedGreen = inputImage;
highlightedBlue = inputImage;

% Define the intensity range for highlighting (adjust as needed)

lowerThreshold = 170; % Lower threshold for highlighting
upperThreshold = 255; % Upper threshold for highlighting

75
 % Iterate through the image
for i = 1:size(inputImage, 1)
for j = 1:size(inputImage, 2)
% Get the channel intensities
redIntensity = inputImage(i, j, 1);
greenIntensity = inputImage(i, j, 2);
blueIntensity = inputImage(i, j, 3);

% Highlight red
if redIntensity >= lowerThreshold && redIntensity <= upperThreshold
highlightedGreen(i, j, 1) = 0; % Zero out green channel
highlightedGreen(i, j, 3) = 0; % Zero out blue channel
else
highlightedGreen(i, j, :) = inputImage(i, j, :); % Keep original
end

% Highlight green
if greenIntensity >= lowerThreshold && greenIntensity <= upperThreshold
highlightedRed(i, j, 2) = 0; % Zero out red channel
highlightedRed(i, j, 3) = 0; % Zero out blue channel
else
highlightedRed(i, j, :) = inputImage(i, j, :); % Keep original
end

% Highlight blue
if blueIntensity >= lowerThreshold && blueIntensity <= upperThreshold
highlightedBlue(i, j, 1) = 0; % Zero out red channel
highlightedBlue(i, j, 2) = 0; % Zero out green channel
else
highlightedBlue(i, j, :) = inputImage(i, j, :); % Keep original
end
end
end

% Display the images

figure;

subplot(2, 2, 1);
imshow(inputImage);
title('Original Image');

subplot(2, 2, 2);
imshow(highlightedRed);
title('Highlighted Red');

subplot(2, 2, 3);
imshow(highlightedGreen);
title('Highlighted Green');

subplot(2, 2, 4);
imshow(highlightedBlue);
title('Highlighted Blue');

76
 Output:

Code 4: highlighting cyan, magenta and yellow colours

% Read the input image
inputImage = imread('/MATLAB Drive/DIP/images/city.jpeg');

% Initialize copies for highlighting each color

highlightedMagenta = inputImage;
highlightedCyan = inputImage;
highlightedYellow = inputImage;

% Define the intensity range for highlighting (adjust as needed)

lowerThreshold = 170; % Lower threshold for highlighting
upperThreshold = 255; % Upper threshold for highlighting

% Iterate through the image

for i = 1:size(inputImage, 1)
for j = 1:size(inputImage, 2)
% Get the channel intensities
redIntensity = inputImage(i, j, 1);
greenIntensity = inputImage(i, j, 2);
blueIntensity = inputImage(i, j, 3);

% Highlight magenta
if redIntensity >= lowerThreshold && blueIntensity >= lowerThreshold
highlightedMagenta(i, j, 2) = 0; % Zero out green channel
else
highlightedMagenta(i, j, :) = inputImage(i, j, :); % Keep original
end

% Highlight cyan

77
 if greenIntensity >= lowerThreshold && blueIntensity >= lowerThreshold
highlightedCyan(i, j, 1) = 0; % Zero out red channel
else
highlightedCyan(i, j, :) = inputImage(i, j, :); % Keep original
end

% Highlight yellow
if redIntensity >= lowerThreshold && greenIntensity >= lowerThreshold
highlightedYellow(i, j, 3) = 0; % Zero out blue channel
else
highlightedYellow(i, j, :) = inputImage(i, j, :); % Keep original
end
end
end

% Display the images

figure;

subplot(2, 2, 1);
imshow(inputImage);
title('Original Image');

subplot(2, 2, 2);
imshow(highlightedMagenta);
title('Highlighted Magenta');

subplot(2, 2, 3);
imshow(highlightedCyan);
title('Highlighted Cyan');

subplot(2, 2, 4);
imshow(highlightedYellow);
title('Highlighted Yellow');

Output:

78
 Observation:
We can observe that the effectiveness of highlighting relies on the chosen
intensity thresholds, as low thresholds may capture noise while high thresholds
may miss subtle shades. It's crucial to maintain image quality, as excessive
manipulation can lead to loss of detail. Understanding color combinations (e.g.,
red + blue = magenta) enhances isolation efforts. Lighting conditions also affect
color representation, impacting the highlighting process. While color maps can
improve visibility, they may alter the original image. Computational efficiency
is essential, particularly for larger images, and optimizing the algorithm can
improve speed. Highlighting specific colors serves various applications,
including object detection and medical imaging, each requiring tailored
approaches.

Output verification:

Result: Hence we have successfully completed the pseudo color image

processing and observed the different scenarios outputs.

79
 LAB EXPERIMENT – 11
Digital Image Processing
Name: V. Surya Teja
REG number: 21BEC1484

Aim: To complete the different tasks on input image like quantization, Non DC
components elimination, and MSE calculation on the taken input images and
observe the output accordingly.

Software required: Matlab software

1. Divide and quantization

Code:
% Read the input image
img = imread('/MATLAB Drive/DIP/images/feather.jpg'); % Replace with your image
file
img = rgb2gray(img); % Convert to grayscale if it's a color image
img = imresize(img, [256 256]); % Ensure the image is 256x256

% Initialize variables
blockSize = 8;
quantMatrix = [16 11 10 16 24 40 51 61;
12 12 14 19 26 58 60 55;
14 13 16 24 40 57 69 56;
14 17 22 29 51 87 80 62;
18 22 37 56 68 109 103 77;
24 35 55 64 81 104 113 92;
49 64 78 87 103 121 120 101;
72 92 95 98 112 100 103 99]; % Example quantization matrix

% Get the size of the image

[rows, cols] = size(img);

% Prepare the output

quantizedImg = zeros(rows, cols); % Initialize quantized image
reconstructedImg = zeros(rows, cols); % Initialize reconstructed image

% Loop through each block for quantization and reconstruction

for row = 1:blockSize:rows
for col = 1:blockSize:cols
% Extract the 8x8 block
block = double(img(row:row+blockSize-1, col:col+blockSize-1));

80
 % Perform DCT (Discrete Cosine Transform)
dctBlock = dct2(block);

% Quantize the DCT coefficients

quantizedBlock = round(dctBlock ./ quantMatrix);

% Store the quantized block back into the output image

quantizedImg(row:row+blockSize-1, col:col+blockSize-1) = quantizedBlock;

% Reconstruct the DCT coefficients

dctBlockReconstructed = quantizedBlock .* quantMatrix;

% Perform inverse DCT

reconstructedBlock = idct2(dctBlockReconstructed);

% Store the reconstructed block

reconstructedImg(row:row+blockSize-1, col:col+blockSize-1) =
reconstructedBlock;
end
end

% Display the original and quantized images

figure;
subplot(1, 3, 1);
imshow(img);
title('Original Image');

subplot(1, 3, 2);
imshow(uint8(quantizedImg)); % Display quantized image (in uint8 format)
title('Quantized Image');

subplot(1, 3, 3);
imshow(uint8(reconstructedImg)); % Display reconstructed image (in uint8 format)
title('Reconstructed Image');

Output:

81
 Decreased quantization values
quantMatrix = [4 3 3 4 6 10 13 15;
3 3 4 5 7 14 15 14;
4 3 4 6 10 14 17 14;
4 4 6 8 13 22 20 15;
5 6 9 14 17 27 26 19;
6 8 13 16 20 26 28 22;
12 16 20 22 26 30 30 25;
18 23 24 25 29 25 26 25];

2. To remove all Non- DC components and get only DC components

Code:
% Read the input image
img = imread('/MATLAB Drive/DIP/images/feather.jpg'); % Replace with your image
file
img = rgb2gray(img); % Convert to grayscale if it's a color image
img = imresize(img, [256 256]); % Ensure the image is 256x256

% Initialize variables
blockSize = 8;

% Get the size of the image

[rows, cols] = size(img);

% Prepare the output

dcImg = zeros(rows, cols); % Initialize image for DC components
reconstructedImg = zeros(rows, cols); % Initialize reconstructed image

% Loop through each block for processing

for row = 1:blockSize:rows
for col = 1:blockSize:cols
% Extract the 8x8 block
block = double(img(row:row+blockSize-1, col:col+blockSize-1));

% Perform DCT (Discrete Cosine Transform)

dctBlock = dct2(block);

% Retain only the DC component (top-left corner)

dcBlock = zeros(size(dctBlock)); % Create a zero matrix

82
 dcBlock(1, 1) = dctBlock(1, 1); % Keep only the DC component

% Store the DC component block back into the output image

dcImg(row:row+blockSize-1, col:col+blockSize-1) = dcBlock;

% Reconstruct the DCT coefficients (with only DC)

reconstructedBlock = idct2(dcBlock); % Inverse DCT of the DC-only block

% Store the reconstructed block

reconstructedImg(row:row+blockSize-1, col:col+blockSize-1) =
reconstructedBlock;
end
end

% Display the original and DC component images

figure;
subplot(1, 3, 1);
imshow(img);
title('Original Image');

subplot(1, 3, 2);
imshow(uint8(dcImg)); % Display image with only DC components
title('DC Components Image');

subplot(1, 3, 3);
imshow(uint8(reconstructedImg)); % Display reconstructed image
title('Reconstructed Image');

Output:

3. Performance measurement using MSE taking input of desired

number of components to get

Code:
% Read the input image
img = imread('/MATLAB Drive/DIP/images/feather.jpg'); % Replace with your image
file
img = rgb2gray(img); % Convert to grayscale if it's a color image
img = imresize(img, [256 256]); % Ensure the image is 256x256

83
 % Initialize variables
blockSize = 8;

% Get the size of the image

[rows, cols] = size(img);

% Prompt user for how many components to retain

numComponents = input('Enter the number of components to retain (1-64): ');

% Ensure the input is within valid range

if numComponents < 1 || numComponents > 64
error('Invalid number of components. Please enter a value between 1 and 64.');
end

% Prepare the output

modifiedImg = zeros(rows, cols); % Initialize image for selected components
reconstructedImg = zeros(rows, cols); % Initialize reconstructed image

% Loop through each block for processing

for row = 1:blockSize:rows
for col = 1:blockSize:cols
% Extract the 8x8 block
block = double(img(row:row+blockSize-1, col:col+blockSize-1));

% Perform DCT (Discrete Cosine Transform)

dctBlock = dct2(block);

% Create a new block to retain selected components

modifiedBlock = zeros(size(dctBlock));

% Retain specified number of components

for i = 1:min(numComponents, 8)
for j = 1:min(numComponents, 8)
if i <= 8 && j <= 8
modifiedBlock(i, j) = dctBlock(i, j); % Retain specified
components
end
end
end

% Store the modified block back into the output image

modifiedImg(row:row+blockSize-1, col:col+blockSize-1) = modifiedBlock;

% Reconstruct the DCT coefficients (with retained components)

reconstructedBlock = idct2(modifiedBlock); % Inverse DCT of the modified
block

% Store the reconstructed block

reconstructedImg(row:row+blockSize-1, col:col+blockSize-1) =
reconstructedBlock;
end
end

% Convert the original image to double for MSE calculation

img_double = double(img);

% Calculate MSE
mse = mean((img_double(:) - reconstructedImg(:)).^2);

84
 % Display the original and modified images
figure;
subplot(1, 3, 1);
imshow(img);
title('Original Image');
subplot(1, 3, 2);
imshow(uint8(modifiedImg)); % Display image with selected components
title(['Selected Components: ', num2str(numComponents)]);
subplot(1, 3, 3);
imshow(uint8(reconstructedImg)); % Display reconstructed image
title('Reconstructed Image');
fprintf('Mean Squared Error (MSE): %.2f\n', mse);

Output:

Number of components: 1

Number of components: 5

85
 Number of components: 20

Output verification:

86
 Inference:

In this analysis, we examined the impact of retaining varying numbers of

Discrete Cosine Transform (DCT) coefficients on image compression through
three key tasks. The fundamental principle is that lower-frequency components
capture essential features, while higher frequencies often represent noise.
Retaining only the DC component resulted in a significantly blurred image,
demonstrating the loss of critical information, whereas keeping all coefficients
produced a reconstruction nearly identical to the original. The Mean Squared
Error (MSE) served as a quantitative measure of this loss, with lower MSE
values indicating better approximation to the original image. This exploration
highlighted the trade-off between compression efficiency and visual quality,
emphasizing the importance of selecting an appropriate number of coefficients
based on desired outcomes in image processing.

Result:
Hence we have successfully completed the tasks and got the outputs
accordingly.

87
 LAB-12
DIGITAL IMAGE PROCESSING

Name: Vadde SuryaTeja

Reg.No: 21BEC1484

AIM: The aim of this project is to implement and analyze Huffman Coding and Arithmetic
Coding techniques for data compression in MATLAB. The goal is to compare their
performance in terms of compression ratio, efficiency, and computational complexity, and
determine which method offers better performance for different types of data.

Software Used: MATLAB

Arithmetic Coding:
Algorithm: -

Read the image using `imread` and convert it to grayscale with `rgb2gray`. - Flatten the
grayscale image into a 1D array using `image(:)`. - Calculate pixel intensity probabilities using
`histcounts` and normalize them. - Compute cumulative probabilities for each pixel
intensity. - Remove zero-probability values for optimization by filtering out them. - Identify
unique pixel values (symbols) that appear in the image. - Initialize the interval range for
arithmetic coding (low = 0, high = 1). - Loop through each pixel in the image and update the
coding interval based on its probability. - For each pixel, find its corresponding symbol's
cumulative probability range. - Update the `low` and `high` values based on the cumulative
probabilities of the symbol. - Calculate the final encoded value as the midpoint between
`low` and `high`. - Display the final arithmetic coded value.

TASK1:
Code:

% Read or generate a sample 256x256 grayscale image

image = imread('/MATLAB Drive/DIP/Images/FEATHER.jpg'); % Replace
withyour 256x256 image
if size(image, 3) == 3
image = rgb2gray(image); % Convert to grayscale if needed
end

% Ensure the image is in uint8 format

image = uint8(image); % In case it's in another format like double
or int16

% Initialize output image

output_image = zeros(size(image));

88
 % Define a stronger 8x8 quantization matrix to increase blocky
effect
Q = [
32 22 20 32 48 80 102 122;
24 24 28 38 52 116 120 110;
28 26 32 48 80 114 138 112;
28 34 44 58 102 174 160 124;
36 44 74 112 136 218 206 154;
48 70 110 128 162 208 226 184;
98 128 156 174 206 242 240 202;
144 184 190 196 224 200 206 198
];

% Process the image in 8x8 blocks

for i = 1:8:size(image, 1)-7
for j = 1:8:size(image, 2)-7
% Extract the 8x8 block
block = double(image(i:i+7, j:j+7));

% Apply DCT to the block

dct_block = dct2(block);

% Quantize by dividing by the quantization matrix and

rounding
quantized_block = round(dct_block ./ Q);

% Reconstruct the block by dequantizing

dequantized_block = quantized_block .* Q;

% Apply Inverse DCT to reconstruct the block

reconstructed_block = idct2(dequantized_block);

% Place the reconstructed block in the output image

output_image(i:i+7, j:j+7) = reconstructed_block;
end
end

% Ensure the output image is in the correct uint8 format for display
output_image = uint8(output_image);

% Display original and processed images with enhanced contrast for

visibility
figure;
subplot(1, 2, 1), imshow(image, []), title('Original Image');
subplot(1, 2, 2), imshow(output_image), title('Quantized Image');

% Calculate the Mean Squared Error (MSE)

% Compute MSE

89
 mse = mean((double(image) - double(output_image)).^2, 'all');

% Display MSE
disp(['Mean Squared Error (MSE): ', num2str(mse)]);

Huffman Coding:
Read the image and convert it to grayscale. - Compute the histogram of the
image to get pixel intensity counts. - Normalize the counts to calculate pixel
probabilities. - Remove zero probabilities for intensity levels not present in the
image. - Generate a Huffman dictionary based on the pixel probabilities. -
Flatten the image into a 1D array. - Encode the flattened image using the
Huffman dictionary. - Calculate the original size in bits and the compressed size
in bits. - Compute the compression ratio. - Decode the encoded image using
the Huffman dictionary. - Reshape the decoded vector back to the original
image size. - Display both the original and decoded images side by side. - Check
if the original and decoded images are identical.

Task2:
Code:
90
 % Read or generate a sample 256x256 grayscale image
image = imread('/MATLAB Drive/DIP/Images/pic9.jpg'); % Replace with
your 256x256 image
if size(image, 3) == 3
image = rgb2gray(image); % Convert to grayscale if needed
end

% Initialize output image

output_image = zeros(size(image));

% Define a stronger 8x8 quantization matrix to increase blocky

effect
Q = [
32 22 20 32 48 80 102 122;
24 24 28 38 52 116 120 110;
28 26 32 48 80 114 138 112;
28 34 44 58 102 174 160 124;
36 44 74 112 136 218 206 154;
48 70 110 128 162 208 226 184;
98 128 156 174 206 242 240 202;
144 184 190 196 224 200 206 198
];

% Process the image in 8x8 blocks

for i = 1:8:size(image, 1)-7
for j = 1:8:size(image, 2)-7
% Extract the 8x8 block
block = double(image(i:i+7, j:j+7));

% Apply DCT to the block

dct_block = dct2(block);

% Set all components to zero except for the DC component

(dct_block(1,1))
dct_block(2:end, :) = 0; % Set all rows except the first row
to zero
dct_block(:, 2:end) = 0; % Set all columns except the first
column to zero

% Reconstruct the block by applying inverse DCT to the

modified DCT coefficients
reconstructed_block = idct2(dct_block);

% Place the reconstructed block in the output image

output_image(i:i+7, j:j+7) = reconstructed_block;
end
end

91
 % Display original and processed images with enhanced contrast for
visibility
figure;
subplot(1, 2, 1), imshow(image, []), title('Original Image');
subplot(1, 2, 2), imshow(uint8(output_image * 1.5)), title('Image
with Only DC Component');

% Calculate the Mean Squared Error (MSE) between the original and
processed images
MSE = mean((double(image) - output_image).^2, 'all');
disp(['Mean Squared Error (MSE): ', num2str(MSE)]);

Task3:
Code:

% Read the grayscale image img =

imread("C:\Users\rushe\Downloads\saaho.jpg"); % Replace with your image
path img = rgb2gray(img); % Convert to grayscale if the image is RGB % Get the
histogram of the image (probabilities for Huffman coding)
[counts, intensity_levels] = imhist(img); total_pixels = numel(img); %
Normalize counts to get the probabilities

92
 probabilities = counts / total_pixels; % Remove zero probabilities (intensity
levels that do not appear in the image)
probabilities = probabilities(probabilities > 0);
intensity_levels = intensity_levels(counts > 0); % Generate Huffman dictionary
based on probabilities
[dict, avg_len] = huffmandict(intensity_levels, probabilities); % Flatten the
image into a 1D array and encode it using the Huffman dictionary img_vector =
img(:); % Flatten image into a column vector
encoded_img = huffmanenco(img_vector, dict); % Display the compression
ratio original_size = numel(img_vector) * 8; % Original size in bits (8 bits per
pixel)
compressed_size = numel(encoded_img); % Compressed size in bits
compression_ratio = original_size / compressed_size; disp(['Original size (bits):
', num2str(original_size)]); disp(['Compressed size (bits): ',
num2str(compressed_size)]); disp(['Compression Ratio: ',
num2str(compression_ratio)]); % Decoding the Huffman encoded image
decoded_img_vector = huffmandeco(encoded_img, dict); % Reshape the
decoded vector back to the original image size decoded_img =
reshape(decoded_img_vector, size(img)); % Create a single figure to display
both images (original and decoded) side by side figure; % Display the original
image in the first subplot (1st position) subplot(1, 2, 1); % 1 row, 2 columns, 1st
subplot imshow(img); title('Original Image'); % Display the decoded image in
the second subplot (2nd position) subplot(1, 2, 2);
imshow(decoded_img, []);
title('Decoded Image (After Huffman Decoding)'); % Verify if the original and
decoded images are identical if
isequal(img, decoded_img) disp('The original and decoded images are
identical.');
else disp('The original and decoded images are not identical.');
end

93
 Inference:
The code demonstrates Huffman coding for image compression and
decompression. It begins by reading and converting the image to grayscale,
then calculates the pixel intensity distribution to generate probabilities. Using
these probabilities, a Huffman codebook is created, which is then used to
encode the image, reducing its size. The compression ratio is computed to
show the effectiveness of the encoding process. Afterward, the encoded image
is decoded using the same codebook, and the original and decoded images are
compared to ensure they are identical. This method effectively reduces image
file size while preserving the original content, showcasing the efficiency of
Huffman coding in lossless image compression.

94
 LAB-13
DIGITAL IMAGE PROCESSING
Name: Surya teja

REG number: 21BEC1484

Aim: To find the threshold image of the input image by setting a threshold
value and observing the histograms before and after effect.

Software required: MATLAB software

Algorithm:

1. Load Image: Read the input image and convert it to grayscale if it’s RGB.
2. Set Threshold: Define a threshold value for classification (e.g., 10).
3. Select Segment: Extract a 40% region of the image (e.g., starting at 30
of height and width).
4. Apply Thresholding: Set pixel values above the threshold to 255 (white)
and below or equal to it to 0 (black) for the segment.
5. Reinsert Segment: Place the thresholded segment back into the original
image.
6. Plot Histograms:
• Plot histograms of the original and thresholded images.
• Plot histograms of the original and thresholded segment.
7. Display Images: Show side-by-side comparison of the original and
thresholded images.

Code:

% Step 1: Read the input image

inputImage = imread('/MATLAB Drive/DIP/images/feather.jpg'); % Replace with the
path to your image file
% Step 2: Convert to grayscale if the image is RGB (optional, depending on input)
if size(inputImage, 3) == 3
inputImage = rgb2gray(inputImage); % Convert RGB to grayscale
end
% Step 3: Set the threshold value
threshold = 10; % Choose an arbitrary threshold value (adjust as needed)

% Step 4: Select a 40% segment of the image (you can choose the segment as needed)
[imageHeight, imageWidth] = size(inputImage);
segmentHeight = round(0.4 * imageHeight); % 40% of the image height
segmentWidth = round(0.4 * imageWidth); % 40% of the image width

95
% Define the top-left corner of the segment (choose an arbitrary starting
position)
segmentStartRow = round(0.3 * imageHeight); % Starting row for the segment
segmentStartCol = round(0.3 * imageWidth); % Starting column for the segment

% Extract the segment from the image

segment = inputImage(segmentStartRow:segmentStartRow + segmentHeight - 1, ...
segmentStartCol:segmentStartCol + segmentWidth - 1);

% Step 5: Apply thresholding to the selected segment

thresholdedSegment = segment > threshold; % Values above threshold become 1,
others become 0

% Convert the binary thresholded segment into a grayscale image (0 or 255)

thresholdedSegment = uint8(thresholdedSegment) * 255;

% Step 6: Reinsert the thresholded segment back into the original image (for
visualization)
outputImage = inputImage; % Copy the original image
outputImage(segmentStartRow:segmentStartRow + segmentHeight - 1, ...
segmentStartCol:segmentStartCol + segmentWidth - 1) =
thresholdedSegment;
% Step 7: Plot histograms for the whole image (before and after thresholding)
figure;
subplot(2, 1, 1);
imhist(inputImage);
title('Histogram of Original Image');
xlabel('Pixel Intensity');
ylabel('Frequency');

subplot(2, 1, 2);
imhist(outputImage);
title('Histogram of Image After Thresholding');
xlabel('Pixel Intensity');
ylabel('Frequency');
%Step 8: Plot histograms for the segment (before and after thresholding)
figure;
subplot(2, 1, 1);
imhist(segment);
title('Histogram of Original Segment');
xlabel('Pixel Intensity');
ylabel('Frequency');

subplot(2, 1, 2);
imhist(thresholdedSegment);
title('Histogram of Thresholded Segment');
xlabel('Pixel Intensity');
ylabel('Frequency');

% Step 9: Show the images for comparison (Original image and Thresholded image)
figure;
subplot(1, 2, 1);
imshow(inputImage);
title('Original Image');

subplot(1, 2, 2);
imshow(outputImage);
title('Image After Thresholding');

96
Output:

97
Output Verification

98
Inference:
As the threshold value increases, fewer pixels in the image exceed the threshold and are set
to 1 (white), resulting in more black pixels (0) and a greater portion of the image being
classified as background. The thresholded image appears darker, with a histogram showing a
higher peak at 0 (black) and a lower peak at 255 (white). On the other hand, decreasing the
threshold allows more pixels to exceed the threshold and be set to 1 (white), which increases
the number of white pixels, making the image appear brighter with a larger foreground. The
histogram for this thresholded image shows a higher peak at 255 (white) and a lower peak
at 0 (black). Essentially, higher thresholds emphasize brighter regions of the image, while
lower thresholds highlight darker areas.

Result:

Hence we have successfully applied the threshold on the input image and got the output
accordingly.

99