0% found this document useful (0 votes)
28 views27 pages

DIP Manual

The document contains multiple programs for image processing tasks using Python, including displaying images in different color formats, performing arithmetic and logical operations, executing grayscale transformations, and applying filters. It also covers techniques like histogram equalization, bit-plane slicing, and noise reduction using median filters. Each program includes code snippets and visualizations to demonstrate the effects of the operations performed on the images.

Uploaded by

Mystic Rotom
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
28 views27 pages

DIP Manual

The document contains multiple programs for image processing tasks using Python, including displaying images in different color formats, performing arithmetic and logical operations, executing grayscale transformations, and applying filters. It also covers techniques like histogram equalization, bit-plane slicing, and noise reduction using median filters. Each program includes code snippets and visualizations to demonstrate the effects of the operations performed on the images.

Uploaded by

Mystic Rotom
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 27

DIP_Manual

March 7, 2025

1.Program to display an image as grayscale image, RED, BLUE, GREEN image and also display
the 1D convolution and 2D convolution on an image.

[ ]: import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load image & convert to grayscale


image = cv2.imread(r'/content/uvce.jpeg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Split into RGB channels


b, g, r = cv2.split(image)

# Define convolution kernels


kernel_1d = np.array([1, 0, -1]) # Edge detection
kernel_2d = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]]) # Sharpening

# Apply convolutions
conv_1d = cv2.filter2D(gray, -1, kernel_1d)
conv_2d = cv2.filter2D(gray, -1, kernel_2d)

# Prepare images & titles for display


images = [cv2.cvtColor(image, cv2.COLOR_BGR2RGB), gray, r, g, b, conv_1d,␣
↪conv_2d]

titles = ['Original Image', 'Grayscale', 'Red Channel', 'Green Channel',


'Blue Channel', '1D Convolution', '2D Convolution']
cmaps = ['viridis', 'gray', 'OrRd', 'Greens', 'Blues', 'gray', 'gray'] #␣
↪Colormaps for display

# Display images
plt.figure(figsize=(10, 6))
for i, (img, title, cmap) in enumerate(zip(images, titles, cmaps), 1):
plt.subplot(3, 3, i) # Arrange in 3x3 grid
plt.imshow(img, cmap=cmap) # Apply respective colormap
plt.title(title), plt.axis('off') # Add title & remove axes

plt.tight_layout()

1
plt.show()

2.Program to perform the basic arithmetic and logical operations on the images.

[ ]: import cv2
import numpy as np
from matplotlib import pyplot as plt

# Load two images


img1 = cv2.imread('/content/uvce.jpeg')
img2 = cv2.imread('/content/dall_e_flower.webp')

# Check if images are loaded correctly


if img1 is None or img2 is None:
raise ValueError("One or both images could not be loaded. Check file paths.
↪")

# Resize img2 to match img1's dimensions


img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

# Ensure both images are in the same format


if len(img1.shape) == 2:
img1 = cv2.cvtColor(img1, cv2.COLOR_GRAY2BGR)
if len(img2.shape) == 2:
img2 = cv2.cvtColor(img2, cv2.COLOR_GRAY2BGR)

2
# Convert images to float32 for division operation
img1 = img1.astype(np.float32)
img2 = img2.astype(np.float32)

# Perform arithmetic operations


add = cv2.add(img1, img2)
subtract = cv2.subtract(img1, img2)
multiply = cv2.multiply(img1, img2)
divide = cv2.divide(img1, img2)

# Convert images back to uint8 for display


add = np.clip(add, 0, 255).astype(np.uint8)
subtract = np.clip(subtract, 0, 255).astype(np.uint8)
multiply = np.clip(multiply, 0, 255).astype(np.uint8)
divide = np.clip(divide, 0, 255).astype(np.uint8)

# Perform logical operations


bitwise_and = cv2.bitwise_and(img1.astype(np.uint8), img2.astype(np.uint8))
bitwise_or = cv2.bitwise_or(img1.astype(np.uint8), img2.astype(np.uint8))
bitwise_xor = cv2.bitwise_xor(img1.astype(np.uint8), img2.astype(np.uint8))
bitwise_not_img1 = cv2.bitwise_not(img1.astype(np.uint8))
bitwise_not_img2 = cv2.bitwise_not(img2.astype(np.uint8))

# Display results including original images


titles = ['Original Image 1', 'Original Image 2', 'Addition', 'Subtraction',
'Multiplication', 'Division', 'Bitwise AND', 'Bitwise OR',
'Bitwise XOR', 'Bitwise NOT (Image 1)', 'Bitwise NOT (Image 2)']
images = [img1.astype(np.uint8), img2.astype(np.uint8), add, subtract, multiply,
divide, bitwise_and, bitwise_or, bitwise_xor, bitwise_not_img1,␣
↪bitwise_not_img2]

plt.figure(figsize=(12, 12))
for i in range(len(images)):
plt.subplot(4, 3, i+1) # Changed grid to fit original images
plt.imshow(cv2.cvtColor(images[i], cv2.COLOR_BGR2RGB))
plt.title(titles[i])
plt.xticks([]), plt.yticks([])

plt.tight_layout()
plt.show()

<ipython-input-33-8249e7173349>:36: RuntimeWarning: invalid value encountered in


cast
divide = np.clip(divide, 0, 255).astype(np.uint8)

3
3.Execute the following Gray Scale Transformations on the given image:Negative Transformation,
Log Transformation,Power-Log Transformation and contraststrecting.

[78]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Load image in grayscale


image = cv2.imread('/content/dall_e_color.webp', cv2.IMREAD_GRAYSCALE)
if image is None:
raise ValueError("Error: Image could not be loaded. Check the file path.")

# Define transformations
c, gamma = 255 / np.log(1 + 255), 0.5 # Log and gamma correction constants
r_values = np.arange(256, dtype=np.uint8)

4
# Contrast Stretching - Piecewise Linear
r1, s1, r2, s2 = 50, 0, 200, 255
contrast_map = np.array([s1 / r1 * r if r < r1 else
(s2 - s1) / (r2 - r1) * (r - r1) + s1 if r <= r2 else
(255 - s2) / (255 - r2) * (r - r2) + s2 for r in␣
↪range(256)], dtype=np.uint8)

contrast_stretched = contrast_map[image]

# Define transformations with mappings


transformations = [
("Original", image, r"$s = r$", r_values),
("Negative", 255 - image, r"$s = 255 - r$", 255 - r_values),
("Log Transform", np.uint8(c * np.log1p(image)), r"$s = c \log(1 + r)$", np.
↪uint8(c * np.log1p(r_values))),

("Power Law(Gamma Correction)", np.uint8((image / 255.0) ** gamma * 255),␣


↪r"$s = c r^\gamma$", np.uint8((r_values / 255.0) ** gamma * 255)),

("Contrast Stretching", contrast_stretched, r"$s = \text{piecewise␣


↪stretch}(r)$", contrast_map)

# Plot images, histograms, and mappings


plt.figure(figsize=(15, 18))
for i, (name, img, formula, mapping) in enumerate(transformations):
plt.subplot(5, 3, 3 * i + 1), plt.imshow(img, cmap='gray'), plt.
↪title(f"{name}\n{formula}"), plt.axis('off')

plt.subplot(5, 3, 3 * i + 2), plt.hist(img.ravel(), bins=256, range=[0,␣


↪256], color='black'), plt.title(f"Histogram - {name}"), plt.xlim([0, 256])

plt.subplot(5, 3, 3 * i + 3), plt.plot(r_values, mapping, color='red'), plt.


↪title(f"Input vs Output - {name}"), plt.xlabel("Input Intensity (r)"), plt.

↪ylabel("Output Intensity (s)"), plt.grid()

plt.tight_layout()
plt.show()

5
4.Program to perform Bit-Plane Slicing.

[ ]: import cv2
import numpy as np
import matplotlib.pyplot as plt

6
# Load image & convert to grayscale
gray = cv2.cvtColor(cv2.imread('/content/uvce.jpeg'), cv2.COLOR_BGR2GRAY)

# Extract bit planes (0-7) using bitwise AND & normalize for visualization
bit_planes = [(np.bitwise_and(gray, 2**i) > 0) * 255 for i in range(8)] #␣
↪Convert bits to 0 or 255

# Prepare images & titles for display


images = [gray] + bit_planes # Include grayscale + all bit planes
titles = ['Grayscale Image'] + [f'Bit Plane {i}' for i in range(8)]

# Display grayscale & bit plane images


plt.figure(figsize=(10, 6))
for i, (img, title) in enumerate(zip(images, titles), 1):
plt.subplot(3, 3, i) # Arrange in 3x3 grid
plt.imshow(img, cmap='gray') # Show image in grayscale
plt.title(title), plt.axis('off') # Add title & remove axes

plt.tight_layout()
plt.show() # Display the images

5.Program for image Enhancement using Histogram Equalization.

7
[68]: import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load and convert to grayscale


gray = cv2.cvtColor(cv2.imread('/content/dall_e_dull.webp'), cv2.COLOR_BGR2GRAY)

# Apply histogram equalization


equalized_gray = cv2.equalizeHist(gray)

# Function to plot histogram


def plot_hist(img, title, pos):
plt.subplot(2, 2, pos)
plt.plot(cv2.calcHist([img], [0], None, [256], [0, 256]), color='black')
plt.title(title), plt.xlim([0, 256])

# Display images and histograms


titles = ['Original Image', 'Histogram Equalized Image']
images = [gray, equalized_gray]

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

for i, (img, title) in enumerate(zip(images, titles), 1):


plt.subplot(2, 2, i)
plt.imshow(img, cmap='gray'), plt.title(title), plt.axis('off')

plot_hist(gray, 'Histogram of Original', 3)


plot_hist(equalized_gray, 'Histogram of Equalized', 4)

plt.tight_layout()
plt.show()

8
6.Program for smoothing an image using low pass filter and high pass filter in frequency domain.

[81]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Apply frequency filter (Low/High-pass: Ideal, Gaussian, Butterworth)


def apply_filter(img, f_type, f_name, cutoff, order=4):
u, v = np.meshgrid(np.arange(img.shape[1]) - img.shape[1]//2,
np.arange(img.shape[0]) - img.shape[0]//2)
D = np.sqrt(u**2 + v**2) # Distance matrix

H = (D <= cutoff).astype(np.float32) if f_name == 'ideal' else \


np.exp(-(D**2) / (2 * cutoff**2)) if f_name == 'gaussian' else \

9
1 / (1 + (D / cutoff)**(2 * order)) # Butterworth

return np.abs(np.fft.ifft2(np.fft.ifftshift(np.fft.fftshift(np.fft.
↪fft2(img)) * (1 - H if f_type == 'highpass' else H))))

# Load grayscale image


img = cv2.imread('/content/sp_img_gray_noise_white.png', 0)
if img is None:
raise ValueError("Image not found.")

# Filter settings: (Filter Type, Name, Title, Cutoff)


filters = [
('lowpass', 'ideal', "Ideal Low Pass", 20),
('lowpass', 'gaussian', "Gaussian Low Pass", 40),
('lowpass', 'butterworth', "Butterworth Low Pass", 30),
('highpass', 'ideal', "Ideal High Pass", 20),
('highpass', 'gaussian', "Gaussian High Pass", 40),
('highpass', 'butterworth', "Butterworth High Pass", 30)
]

plt.figure(figsize=(12, 22))

# Display Original Image & Histogram


plt.subplot(len(filters) + 1, 2, 1), plt.imshow(img, cmap='gray'), plt.
↪title("Original Image"), plt.axis('off')

plt.subplot(len(filters) + 1, 2, 2), plt.hist(img.ravel(), bins=256, range=[0,␣


↪256], color='black'), plt.title("Histogram")

# Apply filters and plot images with histograms


for i, (f_type, f_name, title, cutoff) in enumerate(filters, start=2):
filtered = apply_filter(img, f_type, f_name, cutoff)
plt.subplot(len(filters) + 1, 4, 2 * i + 1), plt.imshow(filtered,␣
↪cmap='gray'), plt.title(title), plt.axis('off')

plt.subplot(len(filters) + 1, 4, 2 * i + 2), plt.hist(filtered.ravel(),␣


↪bins=100, range=[0, 256], color='black'), plt.title(f"Histogram - {title}")

plt.tight_layout()
plt.show()

10
7.Write a program to perform low pass filtering and high pass filtering on an image in spacial
domain.

[85]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Load grayscale image


img = cv2.imread('/content/sp_img_gray_noise_white.png', 0)
if img is None:
raise ValueError("Image not found. Check the file path.")

11
# Define filters
kernel = np.ones((3, 3), np.uint8)
filters = [
("Original", img),
("Mean Filter (AF/MF)", cv2.blur(img, (5, 5))),
("Weighted Avg Filter (WAF)", cv2.filter2D(img, -1, np.array([[1, 2, 1],␣
↪[2, 4, 2], [1, 2, 1]]) / 16)),

("Median Filter (MedF)", cv2.medianBlur(img, 5)),


("Min Filter (MinF)", cv2.erode(img, kernel)),
("Max Filter (MaxF)", cv2.dilate(img, kernel))
]

# Create figure (3 rows, 4 columns for 6 filters)


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

for i in range(6):
name, filtered = filters[i]

# Image
plt.subplot(3, 4, 2 * i + 1)
plt.imshow(filtered, cmap='gray')
plt.title(name)
plt.axis('off')

# Histogram
plt.subplot(3, 4, 2 * i + 2)
plt.hist(filtered.ravel(), bins=100, range=[0, 256], color='black')
plt.title(f"Histogram - {name}")
plt.xlim([0, 256])

plt.tight_layout()
plt.show()

12
8.Program to observe the effect of median filter on an image corrupted by salt and pepper.

[ ]: import cv2
import matplotlib.pyplot as plt

# Load grayscale image


img = cv2.imread("/content/sp_img_gray_noise_white.png", 0)
if img is None:
raise ValueError("Image not found. Check the file path.")

# Apply median filter to remove salt-and-pepper noise


denoised = cv2.medianBlur(img, 5)

# Titles and images


titles = ["Noisy Image", "Denoised Image"]
images = [img, denoised]

# Display images and histograms


for i in range(2):
plt.figure(figsize=(10, 4))

# Image
plt.subplot(1, 2, 1)
plt.imshow(images[i], cmap='gray')

13
plt.title(titles[i])
plt.axis('off')

# Histogram
plt.subplot(1, 2, 2)
plt.hist(images[i].ravel(), bins=256, range=[0, 256], color='black')
plt.title(f"Histogram of {titles[i]}")
plt.xlabel("Pixel Intensity")
plt.ylabel("Frequency")

plt.show()

14
9.Program to show image Enhancement using various filters like ‘SOBEL’, ‘PREWITT’ and
‘LAPLACIAN’.

[64]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Load grayscale image


image = cv2.imread('/content/images (1).png', cv2.IMREAD_GRAYSCALE)
if image is None:
raise ValueError("Error: Image not loaded. Check the file path.")

# Define Edge detection filters or Gradient Based Edge Detection Filters


filters = {
"Original": image,
"Sobel Horizontal Filter": cv2.convertScaleAbs(cv2.Sobel(image, cv2.CV_16S,␣
↪1, 0, ksize=3)), # Filters out Horizontal Lines
"Sobel Vertical Filter": cv2.convertScaleAbs(cv2.Sobel(image, cv2.CV_16S,␣
↪0, 1, ksize=3)), # Filters out Vertical Lines
"Prewitt Horizontal Filter": cv2.filter2D(image, -1, np.array([[-1, 0, 1],␣
↪[-1, 0, 1], [-1, 0, 1]])), # Filters out Horizontal Lines
"Prewitt Vertical Filter": cv2.filter2D(image, -1, np.array([[1, 1, 1], [0,␣
↪0, 0], [-1, -1, -1]])), # Filters out Vertical Lines
"Laplacian General": cv2.convertScaleAbs(cv2.Laplacian(image, cv2.CV_16S,␣
↪ksize=3)),

"Laplacian Horizontal Filter": cv2.convertScaleAbs(cv2.filter2D(image, cv2.


↪CV_16S, np.array([[0, 0, 0], [1, -2, 1], [0, 0, 0]]))),

"Laplacian Vertical Filter": cv2.convertScaleAbs(cv2.filter2D(image, cv2.


↪CV_16S, np.array([[0, 1, 0], [0, -2, 0], [0, 1, 0]]))),

"Laplacian Diagonal (+45° �)": cv2.convertScaleAbs(cv2.filter2D(image, cv2.


↪CV_16S, np.array([[1, 0, 0], [0, -2, 0], [0, 0, 1]]))),

"Laplacian Diagonal (-45° �)": cv2.convertScaleAbs(cv2.filter2D(image, cv2.


↪CV_16S, np.array([[0, 0, 1], [0, -2, 0], [1, 0, 0]]))),

# Display results using plt.figure()


plt.figure(figsize=(15, 45)) # Fixed height for 10 filters
for i, (title, img) in enumerate(filters.items()):
plt.subplot(10, 4, 2 * i + 1)
plt.imshow(img, cmap='gray')
plt.title(title, fontsize=12)
plt.axis('off')

plt.subplot(10, 4, 2 * i + 2)

15
plt.hist(img.ravel(), bins=50, range=(0, 255), color='black')
plt.title(f"Histogram of {title}", fontsize=10)
plt.xlim([0, 255])

plt.subplots_adjust(left=0.1, right=0.9, hspace=0.5) # Adjust spacing


plt.show()

16
17
10.Program to sharpen an image using 2D Laplacian high pass filter in spacial domain.

[36]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Load grayscale image


img = cv2.imread('/content/sp_img_gray_noise_white.png', 0)

# Apply 2D Laplacian filter (sharpening)


sharpened = cv2.filter2D(img, -1, np.array([[0, -1, 0], [-1, 5, -1], [0, -1,␣
↪0]]))

# Display Original and Sharpened images with histograms


images = [img, sharpened]
titles = ["Original Image", "Sharpened Image(2D Laplacian)"]

for i in range(2):
plt.figure(figsize=(10, 5))
for j, data in enumerate([images[i], images[i].ravel()]):
plt.subplot(1, 2, j + 1)
plt.imshow(data, cmap='gray') if j == 0 else plt.hist(data, bins=256,␣
↪color='black')

plt.axis('off') if j == 0 else None


plt.title(f"{'Histogram of' if j else ''} {titles[i]}")
plt.show()

18
11.Program for morphological image operations: erosion, dilation, opening and closing.

[ ]: #Output from Segmentation(image segments) is used as input for morphological␣


↪processing

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load grayscale image


image = cv2.imread('/content/gradient.png', 0)

# Define a cross-shaped structuring element


kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (5, 5))

# Apply morphological operations


erosion = cv2.erode(image, kernel)
dilation = cv2.dilate(image, kernel)
opening = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)

# Display images with titles


titles = ["Input Image", "Structuring Element", "Erosion", "Dilation",␣
↪"Opening", "Closing"]

images = [image, None, erosion, dilation, opening, closing] # Placeholder for␣


↪structuring element

plt.figure(figsize=(12, 6))

19
for i, (img, title) in enumerate(zip(images, titles), 1):
plt.subplot(2, 3, i)
if img is None: # Display structuring element as a table
plt.axis("off")
plt.table(cellText=kernel.tolist(), cellLoc='center', loc='center')
else:
plt.imshow(img, cmap='gray')
plt.axis("off")

plt.title(title)

plt.tight_layout()
plt.show()

12.Program for Image Segmentation.

[55]: import cv2


import numpy as np
import matplotlib.pyplot as plt

# Load grayscale image


image = cv2.imread("/content/images (1).png", cv2.IMREAD_GRAYSCALE)
if image is None:
raise ValueError("Error: Image not loaded. Check the file path.")

# 1. Thresholding Based Segmentation (Otsu Thresholding)


_, global_thresh = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.
↪THRESH_OTSU)

20
# 2. Discontinuities Based Segmentation (Point, Line & Edge Detection)
sobel_x = cv2.convertScaleAbs(cv2.Sobel(image, cv2.CV_16S, 1, 0, ksize=3))
sobel_y = cv2.convertScaleAbs(cv2.Sobel(image, cv2.CV_16S, 0, 1, ksize=3))
prewitt_x = cv2.filter2D(image, -1, np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0,␣
↪1]]))

prewitt_y = cv2.filter2D(image, -1, np.array([[-1, -1, -1], [0, 0, 0], [1, 1,␣
↪1]]))

laplacian = cv2.convertScaleAbs(cv2.Laplacian(image, cv2.CV_16S, ksize=3))

# Laplacian Edge Detection (Various Orientations)


laplacian_kernels = [
np.array([[0, 0, 0], [1, -2, 1], [0, 0, 0]]), #Horizontal Filter
np.array([[0, 1, 0], [0, -2, 0], [0, 1, 0]]), #Vertical Filter
np.array([[1, 0, 0], [0, -2, 0], [0, 0, 1]]), #+45 deg Filter
np.array([[0, 0, 1], [0, -2, 0], [1, 0, 0]]) #-45 deg Filter
]
laplacians = [cv2.convertScaleAbs(cv2.filter2D(image, cv2.CV_16S, k)) for k in␣
↪laplacian_kernels]

# Line & Point Detection


canny_edges = cv2.Canny(image, 50, 150)
harris_corners = np.where(cv2.dilate(cv2.cornerHarris(image, 2, 3, 0.04), None)␣
↪> 0.01 * cv2.cornerHarris(image, 2, 3, 0.04).max(), 255, image)

# 3. Region-Based Segmentation (Region Growing & Splitting)


flood_mask = np.zeros((image.shape[0] + 2, image.shape[1] + 2), np.uint8)
region_growing = cv2.bitwise_not(cv2.floodFill(image.copy(), flood_mask, (image.
↪shape[0]//2, image.shape[1]//2), 255, loDiff=10, upDiff=10)[1])

def region_split(img, x, y, w, h, threshold=10):


sub_img = img[y:y+h, x:x+w]
mean, stddev = cv2.meanStdDev(sub_img)
if stddev < threshold or w < 10 or h < 10:
return cv2.rectangle(img, (x, y), (x+w, y+h), int(mean), -1)
for nx, ny, nw, nh in [(x, y, w//2, h//2), (x+w//2, y, w//2, h//2), (x, y+h/
↪/2, w//2, h//2), (x+w//2, y+h//2, w//2, h//2)]:

region_split(img, nx, ny, nw, nh, threshold)


return img

region_splitting = region_split(image.copy(), 0, 0, image.shape[1], image.


↪shape[0])

# Image Titles & Data


titles = [
"Original Image", "Global Thresholding",

21
"Sobel Vertical Edges", "Sobel Horizontal Edges",
"Prewitt Vertical Edges", "Prewitt Horizontal Edges",
"Laplacian (All Edges)",
"Laplacian (Vertical Lines)", "Laplacian (Horizontal Lines)",
"Laplacian (Diagonal +45°)", "Laplacian (Diagonal -45°)",
"Canny Edge-Line Based", "Harris Corner-Point Based",
"Region Growing", "Region Splitting"
]
images = [image, global_thresh, sobel_x, sobel_y, prewitt_x, prewitt_y,␣
↪laplacian] + laplacians + [canny_edges, harris_corners, region_growing,␣

↪region_splitting]

# Display Results
plt.figure(figsize=(14, 45))
for i, (img, title) in enumerate(zip(images, titles)):
plt.subplot(len(images), 4, 2*i+1), plt.imshow(img, cmap="gray"), plt.
↪title(title), plt.axis("off")

plt.subplot(len(images), 4, 2*i+2), plt.hist(img.ravel(), bins=50,␣


↪range=(0, 255), color="black"), plt.title(f"Histogram of {title}")

plt.tight_layout()
plt.show()

<ipython-input-55-03f0c72dc864>:41: DeprecationWarning: Conversion of an array


with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you
extract a single element from your array before performing this operation.
(Deprecated NumPy 1.25.)
return cv2.rectangle(img, (x, y), (x+w, y+h), int(mean), -1)

22
23
13.Program for image Watermarking.

[44]: import cv2


import matplotlib.pyplot as plt

def add_text_watermark(file, out, mark, size=90, space=30):


img = cv2.imread(file) # Load image
if img is None: raise FileNotFoundError(f"Error: '{file}' not found.")

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # Convert for Matplotlib


h, w = img.shape[:2] # Get dimensions

# Apply repeating watermark (change size/space to adjust density)


for y in range(0, h, size + space):
for x in range(0, w, size * 3):
cv2.putText(img, mark, (x, y), cv2.FONT_HERSHEY_SIMPLEX, size / 75,
(255, 255, 0), max(2, size // 20), cv2.LINE_AA)

cv2.imwrite(out, cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) # Save result


plt.figure(figsize=(10,10))
plt.imshow(img), plt.axis('off') # Show output
plt.show()

# Example usage
add_text_watermark("/content/uvce.jpeg", "watermarked.jpeg", "UVCE")

24
14.Program for Image Restoration.

[ ]: import cv2
import matplotlib.pyplot as plt

def restore_image(image_path, ksize=3):


img = cv2.imread(image_path)
if img is None:
raise FileNotFoundError(f"Error: '{image_path}' not found.")

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Convert to grayscale


restored = cv2.medianBlur(gray, ksize) # Apply median filter to reduce␣
↪noise

# Display original & restored images


fig, ax = plt.subplots(1, 2, figsize=(10, 5))
for i, (im, title, cmap) in enumerate(zip([img, restored], ["Original",␣
↪"Restored"], [None, "gray"])):

ax[i].imshow(im if cmap is None else im, cmap=cmap)


ax[i].set_title(title), ax[i].axis("off")

plt.show()

# Example usage
restore_image("/content/sp_img_gray_noise_white.png", ksize=3)

15.Program for Image Compression using Block truncation Coding.

25
[ ]: import cv2
import numpy as np
import matplotlib.pyplot as plt

def btc_compress(img_path, block=8, scale=0.3):


img = cv2.resize(cv2.imread(img_path, 0), (0, 0), fx=scale, fy=scale,␣
↪interpolation=cv2.INTER_AREA)

h, w = img.shape
comp = np.zeros_like(img)

for i in range(0, h, block):


for j in range(0, w, block):
blk = img[i:i+block, j:j+block]
comp[i:i+block, j:j+block] = np.where(blk <= np.mean(blk), 0, 255)

# Compute actual file sizes


orig_size = img.nbytes / 1024 # Original size in KB
_, comp_encoded = cv2.imencode('.jpg', comp, [cv2.IMWRITE_JPEG_QUALITY, 10])
comp_size = len(comp_encoded) / 1024 # Compressed size in KB

# Display results
titles = [f"Original ({orig_size:.2f} KB)", f"BTC Compressed ({comp_size:.
↪2f} KB)"]

fig, ax = plt.subplots(1, 2, figsize=(10, 5))


for i, (im, title) in enumerate(zip([img, comp], titles)):
ax[i].imshow(im, cmap='gray'), ax[i].axis("off"), ax[i].set_title(title)
plt.tight_layout(), plt.show()

# Example Usage
btc_compress(r'/content/uvce.jpeg')

16.Program for Edge Detection.

[ ]: import cv2
import matplotlib.pyplot as plt

26
def edge_detection(image_path, low, high):
img = cv2.imread(image_path, 0) # Load the image in grayscale
edges = cv2.Canny(cv2.GaussianBlur(img, (5, 5), 1.4), low, high) # Apply␣
↪Gaussian blur & then Canny edge detection

# Display the original and edge-detected images


fig, ax = plt.subplots(1, 2, figsize=(10, 5))
for i, (im, title) in enumerate(zip([img, edges], ["Original Image",␣
↪"Edge-detected Image"])):

ax[i].imshow(im, cmap='gray') # Show image in grayscale


ax[i].axis("off") # Hide axis for cleaner display
ax[i].set_title(title) # Set the title

plt.show()

# Run the function with an example image and thresholds


edge_detection('/content/uvce.jpeg', 50, 150)

27

You might also like