Digital Image Processing

LAB Report

Name Vikash yadav

Section : S

Roll number : 68

University Roll No. : 2215001958

Subject : Digital Iamge Procrssing Lab

Subject Code: BCSE0 0131

Submitted to : Dear Bondita Paul

 Practical No. 1

Aim:
Introduction to the MATLAB commands

Software use: R 2021 (MATLAB) Program code:

• clc :Clears command window

• clear : Removes the variables from memory

• cd :Changes the current directory

• date :Displays current date

• delete :Deletes a file

• find Finds the indices of nonzero elements

• max Returns the largest element

• min Returns the smallest element

• plot Generates xy plot

• title Puts title at the top of the plot

• linspace : creates regularly spaced vector

• zeros :Creates a matrix or array filled with zeros of size m-by-n.

• Ones :Creates a matrix or array filled with ones of size m-by-n.

• reshape : Reshapes a matrix or array into a new size specified by m and n.

• subplot :Creates plots in subwindows.

• hold :Hold the current graph, see also figure

Analysis: This set of commands provides foundational tools for working in MATLAB,
from basic window management (clc, clear) to more advanced plotting and matrix
manipulations (plot, reshape). The subplot and hold commands allow detailed visual
analysis by combining multiple plots, while linspace, zeros, and ones help with creating
and managing data sets.
 Practical No. 2

Aim:Write a program to represent arrays in different ways

Software use: R 2021 (MATLAB) Theory:

• Matrix representation: a is a 3x3 matrix, commonly used for data storage and
matrix operations.
• Range creation: b and t are arrays generated by np.arange() with evenly spaced
values.
• Step size in arrays: k is an array with a negative step size, showing flexibility in
array generation.
• 2D arrays: x is a 2x4 matrix, storing data in rows and columns.
• 1D array: y is a simple sequence of numbers in a 1D array.

Program code:

1. x=[1 2 3; 4 5 6; 7 8 9] 2. s=[3 :6]

3. v =1:15

y = [1 2 5 1] o= [1:4; 5:8]

Conclusion:

This practical demonstrates MATLAB's versatility in creating arrays with different

notations. The colon syntax simplifies sequence generation, making matrix and vector
creation more efficient for data manipulation.
 Practical No. 3

Aim: Write a program to perform various matrices arithmetic operation

Software use: R 2021 (MATLAB) Theory:

• Matrix Addition: Adds corresponding elements of two matrices element-

wise.
• Matrix Subtraction: Subtracts corresponding elements of the matrices.
• Element-wise Multiplication: Multiplies each element in one matrix with the
corresponding element in another.

Program code:

• a=[1 2 3; 4 5 6; 7 8 9]
• b=[10 11 12; 13 14 15; 16 17
18]

sub=a-b;
• sum= a+b;

mult= a*b;
Analysis:

This practical demonstrates basic matrix operations: addition, subtraction, and

element-wise multiplication. These operations are crucial for mathematical
modeling and data processing.

Conclusion:

The practical covers fundamental matrix operations in MATLAB, essential for

linear algebra and system simulations.
 Practical No. 4

Aim:
Write a program to prints out Pascal’s triangle

Software use: R 2021 (MATLAB)

Theory:

Pascal's Triangle is a triangular array of binomial coefficients. Each number in the

triangle is the sum of the two numbers directly above it in the previous row. The
triangle starts with a single '1' at the top, and subsequent rows contain numbers that are
constructed based on the previous row.

Program code:
•
b=1
• while length(a) <
15
• b = [0 b] +
[b 0]

• end

Analysis:

Pascal's Triangle is constructed by summing adjacent numbers from the previous row.
Each row starts and ends with 1, and the internal elements are derived from the sum of
two elements above.

Conclusion:

The program generates Pascal's Triangle up to 10 rows using an iterative approach,

demonstrating efficient list operations in Python
 Practical No. 5
Aim: Write a program Plot the function sin(x) between

0≤x≤4π using linspace Software use: R 2021

(MATLAB) Theory:

1. linspace: np.linspace(0, 4 * np.pi, 100) generates 100 evenly spaced values

between 0 and 4π for the x-axis.

2. Sine Function: np.sin(x) computes sine values for each x, forming the y-axis
data.

3. Plotting: plt.plot(x, y) creates the sine wave plot.

4. Labels and Title: plt.title(), plt.xlabel(), and plt.ylabel() add labels for clarity.

5. Visualization: plt.show() displays the plot, visualizing the sine wave over
two cycles.

Program code:

•a=linspace(0,4*pi,100);

• b=sin(x);

• plot(y);

Analysis:

The sine function completes two cycles over 0 to 4π, with peaks at y=1 and troughs
at y=-1, showing its periodic behavior.

Conclusion:

The sine function's periodicity is demonstrated, completing two cycles between 0

and 4π, highlighting the nature of trigonometric functions.
 Practical No. 6

Aim: Write a program Plot the function sin(x) between

0≤x≤4π using stem function Software use: R 2021
(MATLAB) Theory:

In this practical, we will plot the sine function using a stem plot. A stem plot is a
graphical representation that displays data as vertical lines (or "stems") with markers
at the top of each line. It is useful for visualizing discrete data points

Program code:

• x=linspace(0,4*pi,100);

• y=sin(x);

• stem(y);

• stem(x,y);

Analysis: The stem plot of sin(x)\sin(x)sin(x) from 0 to 4π4\pi4π shows periodic

oscillations between -1 and 1, with peaks, troughs, and zeros at regular intervals.

Conclusion: The stem plot clearly visualizes the sine wave's periodicity, offering a
discrete representation of its behavior over the interval 0≤x≤4π0 \leq x \leq
4\pi0≤x≤4π.
 Practical No. 7
Aim: Write a program to import Digital Images and convert the class of
image into gray, and binary, also adjust the intensity levels
Software use: R 2021 (MATLAB) Theory:

This practical demonstrates basic image processing: converting an image to grayscale,

binary format, and adjusting intensity levels.

• Original Image: Loaded with imread and displayed.

• Grayscale Image: Converted with rgb2gray, retaining intensity.
• Binary Image: Converted using im2bw, turning pixels black (0)or white(1)
• Intensity Adjustment: Enhanced with imadjust, improving contrast and
brightness.

Program code:
a = imread('peppers.png');
subplot(1,4,1);
imshow(a); title(‘Original
Imae’); b = rgb2gray(a);
subplot(1,4,2);
imshow(b); title(‘Gray
Image’);
c = im2bw(a);
subplot(1,4,3);
imshow(c);
title(‘Binary Image’); d = imadjust(b);
subplot(1,4,4);
imshow(d);
title(‘Intensity Adjust’);

Analysis:

1. Grayscale Conversion: Simplifies the image to a single intensity channel,

aiding analysis.
2. Binary Conversion: Useful for thresholding operations like edge detection
or segmentation.
3. Intensity Adjustment: Enhances image contrast, improving visual clarity.

Conclusion: The program demonstrates essential image processing operations,

preparing images for further analysis or tasks like segmentation and feature extraction.
 Practical No. 8
Aim:Write a program to import Digital Images and reduce the size of the image
(50%)

Software use: R 2021 (MATLAB)

Theory:

This practical demonstrates importing and resizing a digital image by 50%. Image
resizing is useful for reducing computational load or adjusting dimensions.

• Original Image: Loaded and displayed using imread and imshow.

• Resized Image: Resized to 50% using imresize.
• Displaying Images: Both images are shown side by side for comparison.
• Size Calculation: Sizes of original and resized images are computed with size to
confirm the reduction.

Program code:

• I = imread('peppers.png’);
• J = imresize(I, 0.5);
• Subplot(1,2,1);
• imshow(I);
• title('Original Image’);
• Subplot(1,2,2);
• imshow(J);
• title(‘Resize Image’);
• sz1=size(I);

Analysis:

The image is successfully resized to 50% of its original dimensions, reducing both
file size and resolution.

Conclusion: The program efficiently resizes an image,

demonstrating a basic yet essential image processing technique. The comparison of
image sizes confirms the reduction in dimensions.
 Practical No. 9
Write a program to import Digital Images and

perform arithmetic operations Software use: R2021 (MATLAB)

Theory:

This practical demonstrates how to perform basic arithmetic operations on digital

images. Image arithmetic operations, such as addition, subtraction, and
multiplication, are useful for tasks like image blending, enhancement, and
analysis.

• Addition: Pixel values of two images are added together.

• Subtraction: Pixel values of one image are subtracted from another.
• Multiplication: Pixel values of two images are multiplied element-wise.

Program code:

a=imread('cameraman.tif');
b=imread('rice.png');
c=a+b; % addition
subplot(1,3,1); imshow(c);
title(‘ADD. of Image 1 & 2’);
d=a-b; % subtraction
subplot(1,3,2); imshow(d);
title(‘SUB. of Image 1 & 2’);
e=a.*b; % multiplication
subplot(1,3,3); imshow(e);
title(‘Mult. of Image 1 & 2’);

Analysis:

1. Addition: Blends images, potentially brightening the result.

2. Subtraction: Highlights differences and creates contrast.
3. Multiplication: Combines images, darkening the result.

Conclusion: The program demonstrates key image arithmetic operations, essential

for image fusion, enhancement, and difference detection in image processing.
 Practical No. 10
Write a program to import Digital Images and

perform logical AND operations Software use: R 2021

(MATLAB)
Theory:
This practical demonstrates the application of a logical AND operation on two binary
images.
• Binary Conversion: The images are converted to binary format using im2bw,
where pixel values are either 0 (black) or 1 (white).
• AND Operation: The AND operation compares corresponding pixels from
two images. If both pixels are 1 (white), the result is 1; otherwise, it’s 0
(black).

Program code:

• a= imread('cameraman.tif’);
• b= imread 'rice.png’);
• a1=im2bw(a);
• Subplot(1,3,1);
• imshow(a1);
• title(‘Binary Image a’);
• b1=im2bw(b);
• Subplot(1,3,2);
• imshow(b1);
title(‘Binary Image b’);
• C=and(a1,b1);
• Subplot(1,3,3);
• imshow(c);

Analysis:
Binary Conversion: Both input images are converted into binary, simplifying the
image to two intensity levels.

Conclusion: The program demonstrates the use of a logical AND operation on

binary images. This technique is useful for finding common features or regions
between two images, and is widely used in image processing tasks such as masking
and segmentation.
 Practical No. 11
To import Digital Images and perform logical OR operations

Software use: R 2021 (MATLAB)

Theory:

This practical demonstrates the application of the logical OR operation on two

binary images. Logical operations like OR are essential in image processing for
tasks such as merging regions or combining masks.

• Binary Conversion: Both images are converted into binary format using
im2bw, reducing them to two intensity levels (0 for black and 1 for white).
• OR Operation: The OR operation compares corresponding pixels from two
images. If at least one of the pixels is 1 (white), the resulting pixel is 1;
otherwise, it’s 0 (black).

Program code:
• a= imread('cameraman.tif’);
• b= imread(‘'rice.png’);
• a1=im2bw(a);
• Subplot(1,3,1);
• imshow(a1);
• title(‘Binary Image a’);
• b1=im2bw(b);
• Subplot(1,4,2);
• imshow(b1);
• title(‘Binary Image b’);
• C=or(a1,b1);
• Subplot(1,3,2);
• imshow(c);
• title(‘OR Image‘);

Analysis:

1. Binary Conversion: Both input images are transformed into binary images,
making them simpler for logical operations.

2. OR Operation: The logical OR operation produces a result where any white

pixel in either of the two input images remains white in the output.
 Practical No. 12

AIM: To import Digital Images and perform logical NOT operations

Software use: R 2021 (MATLAB)

Theory:

This practical demonstrates the application of the logical NOT operation on a

binary image. The NOT operation inverts the pixel values: turning white pixels (1)
to black (0) and black pixels (0) to white (1). This is commonly used for image
negation, highlighting background or non-foreground regions.

•
Binary Conversion: The image is first converted into binary format using
im2bw, simplifying it to two levels (black and white).
•
NOT Operation: The logical NOT operation inverts the binary image,
swapping the black and white regions.

Program code:
•
a= imread('cameraman.tif’);
•
a1=im2bw(a);
•subplot(1,2,1);
imshow(a1);

• title(‘Binary Image a’);

• C=not(a1);
subplot(1,2,2);
imshow(C); title(‘NOT Image‘);

Analysis:
Binary Conversion: The image is transformed into binary, making the pixels
either black or white.

Conclusion:

The program successfully demonstrates the logical NOT operation on a binary image.
By inverting the pixel values, this operation highlights the negative of the image,
which can be useful in tasks like segmentation and background enhancement.
 PracticalNo. 13

AIM: To Select a Digital Image and perform Basic

Intensity Transformation “Image Negative”

Software use: R 2021 (MATLAB)

Theory:

The Image Negative transformation inverts pixel intensities by subtracting each

pixel value from 255. This reverses the brightness, making dark areas light and
light areas dark.

Program code:

a=imread('cameraman.tif');
subplot(1,2,1); imshow(a);
a2=a; for r=1:256 for
c=1:256 a2(r,c)=255-
a2(r,c); end end
subplot(1,2,2);
imshow(a2);

Analysis:

The original image is displayed, and then its negative is generated by inverting pixel
values. The result shows an opposite intensity pattern.

Conclusion:

The program successfully creates an image negative, highlighting details in dark

areas and enhancing contrast for better image analysis.
 Practical No. 14

AIM: To Select a Digital Image and perform Basic

Intensity Transformation “Logarithmic Transformation”
Software use: R 2021 (MATLAB)

Theory:
The Logarithmic Transformation enhances the details in the darker regions of an
image by compressing the dynamic range of pixel intensities. The transformation is
given by S=C⋅log (1+r)S = C \cdot \log(1 + r)S=C⋅log(1+r), where rrr is the pixel
intensity and CCC is a constant to scale the result.

Program code:

img=imread('peppers.png');
subplot(1,2,1); imshow(img);
r=double(img);
g=2.69; % change g to increse/decrease intensity >0 image will
be bright and <0 image will be dark c=1; s=c*(r.^g);
t=255/(c*(255.^g)); o=uint8(t*s); subplot(1,2,2); imshow(o);
title("Power Law Transformation");

Analysis:
The transformation expands darker pixels and compresses brighter ones, revealing
more detail in dark regions.

Conclusion:
The program effectively applies the Logarithmic
Transformation, enhancing details in the darker parts of the image for better visual
clarity
 Practical No. 15

AIM: To Select a Digital Image and perform Basic

Intensity Transformation “Power Law Transformation”

Software use: R 2021 (MATLAB)

Theory:

The Power Law Transformation (Gamma correction) is used to enhance images by

adjusting brightness and contrast. The transformation is defined as S=C rγS = C \cdot
r^\gammaS=C rγ,

where rrr is the pixel intensity and γ\gammaγ is a constant. It brightens images
when γ<1\gamma < 1γ<1 and darkens them when γ>1\gamma > 1γ>1.

Program code:

a=imread('Gear 5.jpg');
subplot(1,2,1);
imshow(a);
title("Original Image");
r=double(a); c=1;
s=c*log(1+r);
t=255/(c*log(256));
b=uint8(t*s);
subplot(1,2,2);
imshow(b);
title("Log Transformation");

Analysis:
The image undergoes a transformation with γ=0.6\gamma =
0.6γ=0.6, enhancing brightness. This method adjusts contrast and helps bring out
details in specific intensity ranges.

Conclusion:
The program successfully applies Power Law Transformation, improving the
brightness and contrast of the image, making it useful for image enhancement in
various lighting conditions.