Q.

1 Write a program to perform arithmetic operations on image

import cv2 “import numpy as np “from google.colab.patches import

cv2_imshow “import matplotlib.pyplot as plt “from io import BytesIO “from
PIL import Image from google.colab import files “figsize = (10, 10)

“uploaded = files.upload () “img1=cv2. imread( 'saad.bmp')“img11=cv2.

imread ('saad-1.bmp ') “cV2_imshow(img1) “cv2_imshow(img11) “plt.
figure(figsize=figsize)

“plt. imshow(img1, cmap='gray', vmin=0, vmax=256) “plt. title('color

image-1') “plt. show()

“plt. figure(figsize=figsize) “img2=cv2.cvtColor(img1,

cv2.COLOR_BGR2GRAY) “plt.subplot(1,2,1)

“plt.imshow(img2, cmap='gray', vmin=0, vmax=256) “plt.title('grayscale

image-1')

“plt.show() “img12=cv2.cvtColor(img11, cv2.COLOR_BGR2GRAY) “plt.

subplot (1,2,2)

“plt.imshow(img12, cmap='gray', vmin=0, vmax=256) “plt.title('grayscale

image-2')

“plt. show() “img3=cv2.resize(img2, (256,256))

img4=cv2.resize(img12, (256,256))

img5=img3+img4

plt.figure(figsize=figsize)

plt. imshow(img5, cmap='gray', vmin=0, vmax=256)

plt.title('Add image of 2')

plt. show()

img122=cv2.rotate(img12, cv2.ROTATE_90_CLOCKWISE)

plt.figure(figsize=figsize)

plt.imshow(img122, cmap='gray', vmin=0, vmax=256)

plt.title('rotate image')

plt. show()
row=img2. shape[0]

col=img2.shape[1]

print(row, col)

344 344

img6=np.zeros ((row, col))

for i in range(1, row): for j in range(1, col):

img6［i,j］= img211,j］+50

plt. figure(figsize=figsize)

plt.imshow(img6, cmap='gray', vmin=0, vmax=256)

plt. title( 'Brighter image')

plt. show()

R= img1[:,: ,0]

G= img1l:,:,1]

B= img1[:,:, 2]

gray = 0.299*R + 0.587*G + 0.114*B

Average = (R+G+B)/3

plt.subplot (1,2,2)

plt. imshow(gray, cmap='gray', vmin=0, vmax=256)

plt.title('gray image')

plt.show()

Red=img1.copy()

Green=img1. copy ()

Blue=img1. copy ()

Red[:, :, (1,2)] = 0

Green[ :, :, (0,2)] = 0

Blue[:,:, (0,1)] = 0
plt. subplot (1,2,2)

plt. imshow(Red, cmap='gray', vmin=0, vmax=256)

plt.title('Red Image')

plt.show()

plt.subplot (1,2,2)

plt.imshow(Blue, cma='gray', vmin=0, vmax=256)

plt.title( 'Blue Image')

plt.show()

plt. subplot (1,2,2) plt. imshow(Green,

cmap='gray', vmin=0, vmax=256)

plt. title('Green Image')

plt. show)

plt.subplot (1,2,2)

plt. imshow(Average, cmap= 'gray' , vmin=0, vmax=256)

plt. title('Average Image') plt.show()

Exp-2: WAP to perform image enhancement using point processing

techniques.

import cv2

import numpy as np from google.colab.patches import cv2_imshow import

matplotlib.pyplot as plt from io import BytesIO from PIL import Image from
google.colab import files

figsize = (10, 10)

uploaded = files.upload()

S1=cv2. imread ('Lion.bmp')

cv2_imshow (S1)

S2=cv2.cvtColor (S1, cv2.COLOR_BGR2GRAY)

plt.figure(figsize=(5,5))
plt. imshow(S2, cmap='gray', vmin=0, vmax=255)

plt.title( 'Grayscale Image')

plt.show()

S2=cv2. cvtColor (S1, cv2.COLOR_BGR2GRAY)

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

plt.imshow(S2, cmap='gray', vmin=0, vmax=255)

plt. title('Grayscale Image')

plt.show()

#Negation operation r, c =52. shape

Neg_S=np.zeros([r,c])

for i in range(r): for j in range(c):

Neg_S［i,j］=255-S2［i,j］

plt.figure(figsize=figsize)

plt.subplot (121)

plt. imshow(S2, cmap='gray', vmin=0, vmax=255)

plt. title('Original Image')

plt.axis('off')

plt.subplot (122)

plt. imshow(Neg_s, cmap='gray', vmin=0, vmax=256)

plt.title( 'Negative Image')

plt.axis('off')

plt.show()

#Log transformation

S2=np.array(S2,dtype=np.uint16)

c1=255/np.10g(1+пp.max(S2))

10g_S=c1*(np.1og(1+S2))

1og_S=np.array(log_S,dtype=np.uint8)
plt.figure(figsize=figsize)

plt. subplot(121)

plt.imshow(S2, cmap='gray'

, vmin=0, vmax=255)

plt. title( 'Original Image')

plt.axis('off')

plt. subplot (122)

plt. imshow(log_S,cmap='gray', vmin=0, vmax=255)

plt.title('Log Image')

plt.axis('off')

plt. show)

def power_im(S, gamma) :

c2=2 power_S=np.zeros([r,c])

for i in range(r): for j in range(c):

power_S[i, j]=c2*(S[i,j])**gamma

return power_S

gamma=0.65

c2=2 power_img=np.zeros([r,c])

for i in range(r): for j in range(c):

power_img[i, j]=c2*(S2[i,j]) **gamma

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

plt. imshow(power_img, cmap='gray', vmin=0, vmax=255)

plt.title( 'Power Img-Gamma=0.65')

plt.axis('off')

plt.show()

S3=power_im(S2,0.7)

S4=power_im(S2,0.9)
S5=power_im(S2,1.0)

S6=power_im(S2,1.1)

plt.figure(figsize=(15,15))

plt.subplot (151)

plt.imshow(S2,cmap='gray', vmin=0, vmax=255)

plt.title('Original Image')

plt.axis('off')

plt.subplot (152)

plt.imshow(S3, cmap='gray', vmin=0, vmax=255)

plt.title('gamma=0.7')

plt.axis('off')

plt.subplot(153)

plt. imshow(S4, cmap='gray'

, vmin=0, vmax=255)

plt.title('gamma=0.9')

plt.axis('off')

plt.subplot (154)

plt. imshow(S5,cmap='gray', vmin=0, vmax=255)

plt.title('gamma=1.0')

plt.axis('off')

plt. subplot (155)

plt.imshow(S6, cmap='gray', vmin=0, vmax=255)

plt.title('gamma=1.1')

plt.axis('off')

plt.show()

ht, wd= S2. shape

I1=np.zeros ((ht,wd))
I2=np. zeros ((ht,wd))

I3=np.zeros ((ht,wd))

I4=np.zeros ((ht,wd))

I5=np. zeros ((ht,wd))

I6=np. zeros ((ht,wd) )

17=np.zeros ((ht,wd))

I8=np.zeros((ht,wd))

for i in range(ht): for j in range(wd):

temp=format(S2[i][j],'08b')

I1[i][j]=int(temp[0])

12[i][j]=int(temp[1])

I3[i][j]=int(temp[2])

I4[i][j]=int(temp[3])

I5[i][j]=int(temp[4])

16[1][j]=int (temp[5])

17[i][j]=int(temp[6])

I8[i][j]=int(temp[7])

plt.figure(figsize=figsize)

plt.subplot (241)

plt.imshow(I1,cmap='gray', vmin=0, vmax=1)

plt.title('Bit 1')

plt.axis('off')

plt.subplot (242)

plt. imshow(I2, cmap='gray', vmin=0, vmax=1)

plt. title('Bit 2') plt.axis('off')

plt. subplot (243)

plt. imshow(I3, cmap='gray', vmin=0, vmax=1)

plt. title ('Bit 3') plt.axis('off')

plt.subplot (244)

plt. imshow(I4, cmap='gray', vmin=0, vmax=1)

plt. title ('Bit 4') plt.axis('off')

plt. subplot (245)

plt. imshow(I5, cmap='gray', vmin=0, vmax=1)

plt. title( 'Bit 5') plt.axis('off')

plt. subplot (246)

plt. imshow(I6, cmap='gray', vmin=0, vmax=1)

plt. title('Bit 6') plt.axis('off')

plt. subplot (247)

plt. imshow(I7, cmap= 'gray', vmin=0, vmax=1)

plt. title('Bit 7') plt.axis('off')

plt. subplot (248)

plt. imshow(I8, cmap='gray', vmin=0, vmax=1)

plt. title( 'Bit 8') plt.axis('off')

plt. show()

Contr_strech=np.zeros([r, c])

t1=30

s1=30

t2=100

s2=200

alpha=0.3

beta=2

Gamma=0.45

for r1 in range(r): for c1 in range(c):

if (S2[r1, c1]>=0 and S2[r1, c1]<t1):

Contr_strech[r1, c1]=alpha*52[r1, c1]

else:

if (S2[r1, c1]>=t1) and (S2[r1,c1]<t2):

Contr_strech[r1, c1]=(beta*(I2[r1,c1]-t1)+s1);

else:

Contr_strech[r1, c1]=(Gamma*(I2[r1, c1]-t2)+52);

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

plt.subplot (1,2,1)

plt. imshow(52, cmap='gray')

plt. title( 'Original Image')

plt.axis('off')

plt. subplot (1,2,2)

plt.imshow(Contr_strech, cmap='gray'

, vmin=0, vmax=256)

plt. title('Contrast Stretching') plt.axis('off')

plt. show()

Exp-3: WAP to perform Histogram Equalisation on Grayscale Image import

cv2….

import numpy as np from google.colab.patches import cv2_imshow import

matplotlib.pyplot as plt from io import BytesIO from PIL import Image from
google.colab import files from skimage import color from skimage import io
from PIL import ImageDraw from PIL import ImageFont from skimage.util
import random_noise figsize=(8,8)

uploaded=files.upload()

S1=cv2. imread ('HO.bmp')

S2=cv2. cvtColor (S1, cv2.COLOR_BGR2GRAY)

row, col= S2. shape

I3= np.zeros((256),np.int32)

for i in range(row): for j in range (col):

p= S2[i,j]

I3[p]= I3[p]+1

plt.figure(figsize=figsize)

plt. plot (13)

plt. show()

def draw_hist(x_axis, input):

fig,ax=plt.subplots(figsize=figsize)

plt.barx_axis, input, 256/(x_axis[-1]-x_axis[0]+1))

return fig, ax

bins_edges_min_max=[0,256]

nums bins=256

bin_count1, bins_edges1=np.histogram(52,nums_bins,bins_edges_min_max)

bins_start1=bins_edges1[:-1]

plt.figure(figsize=figsize)

draw_hist(bins_start1,bin_count1)

plt.title('Histogram of given image') plt.plot()

plt.show()

pdf=np.zeros (256) for k in range (256) : pdf[k]=I3[k]/(row*col)

150

200

cdf=np. cumsum(pdf)

f_eq=np.round ((cdf*256)).astype(int)

S3=np. zeros ((row,col),dtype=np.uint8) for i in range(row): for j in

range(col): p1=S2[i,j]

S3[i,j]=f_eq[p1]
plt.figure(figsize=figsize)

plt.subplot (1,2,1)

plt.imshow(S2, cmap='gray',vmin=0,vmax=255)

plt. title('Original Image') plt.axis('off')

plt. subplot (1,2,2)

plt.imshow(S3, cmap='gray',vmin=0,vmax=255) plt.title('Equalized

Histogram Image') plt.axis('off') plt.show()

Exp:4

import cv2

import numpy as np import random

from google.colab.patches import cv2_imshow import matplotlib.pyplot as plt

from io import BytesIO from PIL import Image from google.colab import files
from skimage import color from skimage import io #uploaded=files.upload()
from PIL import ImageDraw from PIL import ImageFont from skimage.util
import random_noise

from

scipy.stats.kde import gaussian_kde

from skimage.filters import gaussian from scipy.ndimage import

gaussian_filter figsize=(10,10)

uploaded = files.upload()

#Colour Image

img1=cv2.imread ('LO.bmp')

CV2_imshow(img1)

img2=cv2.cvtColor (img1, cv2.COLOR_BGR2GRAY)

plt. figure(figsize=figsize)

plt. imshow(img2, cmap='gray', vmin=0, vmax=255)

plt. title( 'Grayscale Image')

plt. show()
m,n=img2. shape

gauss_noise=np.zeros((m,n) ,dtype=np.uint8)

cv2. randn (gauss_noise,120,28)

gauss_noise=(gauss_noise*0.5).astype(np.uint8)

img3=cv2. add (img2, gauss_noise)

plt. figure(figsize=figsize)

plt.subplot (1,2,1)

plt. imshow(img2, cmap='gray', vmin=0, vmax=255)

plt. title( 'Grayscale Image')

plt. axis('off')

plt. subplot (1,2,2)

plt. imshow(img3, cmap='gray'

, vmin=0, vmax=255)

plt. title( 'Gaussian Noise Image')

plt. axis('off')

plt. show ()

#Convolution Mask img_new=np.zeros ((m,n) ,dtype=np.uint8)

mask=np.ones ([3,3],dtype=int)

mask=mask/9

print (mask)

[[0.11111111 0.11111111 0.11111111]

[0.11111111 0.11111111 0.11111111]

[0.11111111 0.11111111 0.11111111]]

#Convolution Process def conv_img(img, mask):

img3 = img

img_new = np. zeros ([m, n])

for i in range(1, m-1): for j in range(1, n-1):

temp = img3[1-1, j-1] * mask[0, 0] + img3[1-1, j] * mask[0, 1] + img3[1-1,
j+1] * mask[0, 2] + 1

img3[1, j-1] * mask[1, 0] + img3[1, j] * mask[1, 1] + img3(1, j+1] * mask [1,

2] + | img3[1+1, j-1] * mask[2, 0] + img3[1t1, j] * mask[2, 1] + img3[1+1,
j+1] * mask[2, 2]

img _new[i, j] = temp

img_new = img_new.astype(np.uint8)

return img_new

img_ new=conv_img (img3, mask)

plt. figure (figsize=figsize)

plt. subplot (1,2,1)

plt. imshow(img3, cmap='gray', vmin=0, vmax=255)

plt.title( 'Gaussian Noise Image')

plt.axis('off')

plt. subplot (1,2,2)

plt. imshow(img_new, cmap= 'gray', vmin=0, vmax=255)

plt. title( 'Convolution')

plt.axis('off')

plt. show()

mask3=np.array([[0,2,01,[2,8,21,[0,2,011)

mask3=mask3/16

GFI_img=conv_img (img2, mask3)

plt. figure(figsize=figsize)

plt. subplot (1,2,1)

plt. imshow(img2, cmap='gray', vmin=0, vmax=255)

plt. title( 'Grayscale Image')

plt.axis('off')

plt. subplot (1,2,2)

plt.imshow(GFI_img, cmap='gray', vmin=0, vmax=255)

plt.title('Gaussian Filtered Image')

plt.axis('off')

plt. show()

#High Pass Filter

mask2=np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])

mask2=mask2/9

HPF

_img=conv_img (img2, mask2)

plt.figure(figsize=figsize)

plt. subplot (1,2,1)

plt.imshow(img2, cmap='gray', vmin=0, vmax=255)

plt. title( 'Grayscale Image') plt.axis('off')

plt. subplot (1,2,2)

plt. imshow(HPF_img, cmap='gray', vmin=0, vmax=255)

plt. title( 'High Pass Filter')

plt.axis('off')

plt. show)

#High Boost Filter

mask4=np.array([[-1,-1, -1], [-1,8.2, -1], [-1,-1,-1]])

mask4=mask4/9

HBF_img=conv_img (img2, mask4)

plt.figure(figsize=figsize)

plt. subplot (1,2,1)

plt. imshow(img2, cmap='gray', vmin=0, vmax=255)

plt. title('Grayscale Image')

plt.axis('off')
plt. subplot (1,2,2)

plt. imshow(HBF_img, cmap='gray', vmin=0, vmax=255)

plt.title( 'High Boost Filter')

plt.axis('off')

plt.show()

#Salt and Pepper Noise def sp_noise (image, prob):

output=np.zeros(image.shape,np.uint8)

thres=1-prob

for i in range (image.shape[0]): for j in range (image.shape [1]):

rdn=random. random ()

if ran<prob:

output [i][j]=0

elif rdn>thres:

output [i][j]=255

else:

output [i][j]=image[i][j]

return output

img_new121=sp_noise(img2,0.03)

cv2_ imshow(img_new121)

#Median Filter

img_noisy1=img_new121

Med_new2=np.zeros([m,n]) for i in range(1,m-1): for j in range(1,n-1):

temp=［img_noisy1［ュー 1，ゴ-1］，img_noisy1［ュ-1,51,img_noisy1［ュ-1,3+1］，

img_noisy1[i,j-1], img_noisy1[i,j], img_noisy1[i,j+1], img_noisy1[i+1,j-1],

img_noisy1[i+1,jl, img_noisy1[i+1,j+1]];

temp1=sorted(temp)
Med_new2[i,j]=temp1[5]

Med_new2=Med_new2.astype(np.uint8)

plt.figure(figsize=figsize)

plt.subplot(1,2,1)

plt. imshow(img_noisy1, cmap='gray'

', vmin=0, vmax=255)

plt.title('Grayscale Image with S&P Nois') plt.axis('off')

plt.subplot (1,2,2)

plt.imshow(Med_new2, cmap='gray', vmin=0, vmax=255) plt.title('Median

Filtered Image') plt.axis('off') plt.show()

Exp-5: WAP to Perform image enhancement in frequency domain.

“import cv2

Import numpy as np import random

From google.colab.patches import cv2_imshow import matplotlib.pyplot as

plt from io import BytesIO from PIL import Image from google.colab import
files figsize=(5,5)

Import scipy as sp from scipy import fft from skimage.color import rgb2gray

Uploaded=files.upload()

S1=CV2. Imread (‘Ship.bmp’)

Cv2_imshow(S1)

S2=cv2. cvtColor(S1, Cv2.COLOR_BGR2GRAY) plt.figure(figsize=(5,5))

Plt.imshow(S2, cmap=’gray’, vmin=0, vmax=255) plt.title(‘Grayscale

Image’) plt.axis(‘off’) plt.show()

S3=S2

S4=(S3-np.min(S3))/(np.max(S3)-np.min(S3))

#Normalization fft_img=sp.fft.fft2(54) real_fft_img=np.abs(fft_img)

cv2_imshow(real_fft_img)
Dft = cv2.dft(np.float32(S2), flags=cv2.DFT_COMPLEX_OUTPUT)

Dft_shift = np. Fft. Fftshift(dft)

Magnitude_ spectrum = 20 * np. 10g/cv2.magnitude(dft_shift[:, :, 0],

dft_shift[:, :, 1]))

Plt. Figure(figsize=(5,5))

pIt. Imshow(magnitude_spectrum, cmap=’gray’)

plt. Title(‘Magnitude Spectrum’)

plt.axis(‘off’)

plt.show()

r, c = S2. Shape

row, col = int(r/2), int(c/2)

y, x = np.ogridl-row:r-row, -col:c-col]

distance = np.sqrt (x**2 + y**2)

r1= 80

# Create mask with a centered circle as 1’s

Mask1 = np.zeros ((r, c, 2), np.uint8)

Mask1[distance <= r1] = 1

# Create mask with a centered circle as 0’s

Mask2 = np.ones ((r, c, 2), np.uint8)

Mask2 [distance <= r1] = 0

M1 = mask1[:, :, 01

M2 = mask2[:, :, 0]

Plt. Subplot (1, 2, 1)

Plt. Imshow(M1, cmap= ‘gray’

, vmin=0, vmax=1)

Plt.title( ‘Ideal LPF Image’)

Plt.axis(‘off’)
Plt. Subplot (1, 2, 2)

Plt. Imshow(M2, cmap=’gray’, vmin=0, vmax=1)

Plt. Title(‘Ideal HPF Image’)

Plt.axis(‘off’)

Plt.show()

#LPF Image

Fft_shift1=dft_shift*mask1

Fft_ifft_ishift1=np.fft.ifftshift(fft_shift1)

SAThenl=cv2.idft(fft_ifft_ishift1)

#Calculate the magnitude of Inverse DFT

SAThen1=cv2. Magnitude(SAThen1[:,:,0],SAThenl[:,: ,1])

#Visualize the original img & magnitude spectrum plt.figure(figsize=(10,10))

Plt.subplot(1,2,1)

Plt. Imshow(S2, cmap=’gray’)

Plt. Title( ‘Input Image’)

Plt.axis(‘off’)

pIt.subplot (1,2,2)

plt. Imshow(SAThenl, cmap=’gray’)

plt.title(‘LPF’)

plt.axis(‘off’)

plt.show()

#HPF Image

Fft_shifth=dft_shift*mask2

Fft_ifft_ishifth=np.fft.ifftshift(fft_shifth)

SAThenh=cv2.idft(fft_ifft_ishifth)

#Calculate the magnitude of Inverse DFT

SAThenh=cv2. Magnitude(SAThenh[:,: ,0], SAThenh[:,: ,1])

#Visualize the original img & magnitude spectrum plt.
Figure(figsize=(10,10))

Plt. Subplot (1,2,1)

Plt. Imshow(S2, cmap=’gray’)

Plt. Title(‘Input Image’)

Plt.axis(‘off’)

Plt. Subplot (1,2,2)

Plt. Imshow(SAThenh, cmap=’gray’)

Plt. Title(‘HPF’)

Plt. Axis(‘off’)

Plt. Show

F1=np. Fft.fft2(S2)

F_im=np. Sort (np.abs f1.reshape(-1)))

For k in (0.5,0.1,0.05,0.02,0.01): th=f_im[int(np. Floor ((1-k)*len(f_im)))]

I=np.abs (f1) ›th

I=np.fft. ifft2(f1*i).real

I=np.abs(i)

I=np.uint8(i)

Plt. Figure)

Plt. Imshow(I, cmap= ‘gray’)

Plt.title( ‘Magnitude Spectrum: ‘+str(k*100)+’%’)

Plt. Axis(‘off’)