LAB Manual

PART B

Roll No. C073 Name: Viha Shukla

Class : C Batch : C1

Date of Experiment: 4/9/24 Date of Submission 16/10/24

Grade : Time of Submission:

Date of Grading:

B.1 Software Code written by student:

Hadamard

Code

#C073

#Viha Shukla

#Aim: Write a program to apply various (Hadamard and

Discrete Cosine) transforms on an image and compare the
results.

import numpy as np

import cv2

import matplotlib.pyplot as plt

from scipy.fftpack import dct, idct

# Load and resize the image

resized_image = cv2.imread('viha.jpg',
cv2.IMREAD_GRAYSCALE)
if resized_image is None:

print("Error: Image not found or unable to load.")

else:

resized_image = cv2.resize(resized_image, (256, 256))

# Function to generate the Hadamard matrix of size n

(n must be a power of 2)

def create_hadamard_matrix(n):

hadamard_matrix = np.array([[1]])

for i in range(n):

hadamard_matrix = np.block([[hadamard_matrix,
hadamard_matrix], [hadamard_matrix, -
hadamard_matrix]])

return hadamard_matrix

# Function to apply matrix transformation to the image

def matrix_transform(matrix, image_data):

return matrix @ image_data @ matrix.T

# Function to apply inverse matrix transformation

def matrix_inverse_transform(matrix,
transformed_image):

return matrix.T @ transformed_image @ matrix

 # Function to normalize transformed images

def normalize_transformed_image(img):

return np.clip(img, 0, 255).astype(np.uint8)

# Function to normalize inverse-transformed images

def normalize_inverse_image(img):

img = (img - np.min(img)) / (np.max(img) -

np.min(img)) * 255

return np.clip(img, 0, 255).astype(np.uint8)

# Function to zero out specific quadrants

def retain_frequencies(image, percentage):

n = image.shape[0]

mask = np.ones((n, n))

if percentage == 25:

mask[n//2:, n//2:] = 0

elif percentage == 50:

mask[n//2:, :] = 0

elif percentage == 75:

mask[:n//2, n//2:] = 0

mask[n//2:, :] = 0

elif percentage == 100:

 pass # No frequencies are removed for 100%

return image * mask

# Function to apply DCT

def dct2(image):

return dct(dct(image.T, norm='ortho').T,

norm='ortho')

# Function to apply inverse DCT

def idct2(image):

return idct(idct(image.T, norm='ortho').T,

norm='ortho')

# Function for block-wise DCT

def block_dct(image, block_size):

h, w = image.shape

dct_image = np.zeros_like(image, dtype=np.float64)

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

for j in range(0, w, block_size):

block = image[i:i+block_size, j:j+block_size]

dct_image[i:i+block_size, j:j+block_size] =
dct(dct(block.T, norm='ortho').T, norm='ortho')

return dct_image
 # Function for block-wise inverse DCT

def block_idct(dct_image, block_size):

h, w = dct_image.shape

idct_image = np.zeros_like(dct_image,
dtype=np.float64)

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

for j in range(0, w, block_size):

block = dct_image[i:i+block_size, j:j+block_size]

idct_image[i:i+block_size, j:j+block_size] =
idct(idct(block.T, norm='ortho').T, norm='ortho')

return idct_image

# Generate Hadamard matrix of size 256

H_matrix = create_hadamard_matrix(8)

# Converting to float64 for transformation

image_as_float = resized_image.astype(np.float64)

# Apply Hadamard transform to the image

transformed_hadamard_image =
matrix_transform(H_matrix, image_as_float)

# Apply DCT to the image

 transformed_dct_image = dct2(image_as_float)

# Initialize for Block DCT

block_dct_4x4 = block_dct(image_as_float, 4)

block_dct_8x8 = block_dct(image_as_float, 8)

# Process and calculate compression ratios

retain_percentages = [25, 50, 75, 100]

hadamard_reconstructed_images = []

dct_reconstructed_images = []

block_dct_reconstructed_4x4 = []

block_dct_reconstructed_8x8 = []

compression_ratios_hadamard = []

compression_ratios_dct = []

compression_ratios_block_dct_4x4 = []

compression_ratios_block_dct_8x8 = []

original_size = resized_image.size # Total number of

pixels

for percent in retain_percentages:

# For Hadamard Transform

 compressed_size_hadamard = (256 * 256) * (percent /
100) if percent < 100 else original_size

compression_ratio_hadamard = original_size /
compressed_size_hadamard

compression_ratios_hadamard.append(compression_ratio_
hadamard)

# For DCT Transform

retained_dct_coeffs = (256 * 256) * (percent / 100) if

percent < 100 else original_size

compression_ratio_dct = original_size /
retained_dct_coeffs

compression_ratios_dct.append(compression_ratio_dct)

# For 4x4 Block DCT

retained_block_dct_4x4 = (256 // 4) * (256 // 4) *

(percent / 100) if percent < 100 else original_size

compression_ratio_block_dct_4x4 = original_size /
retained_block_dct_4x4

compression_ratios_block_dct_4x4.append(compression_ra
tio_block_dct_4x4)

# For 8x8 Block DCT

 retained_block_dct_8x8 = (256 // 8) * (256 // 8) *
(percent / 100) if percent < 100 else original_size

compression_ratio_block_dct_8x8 = original_size /
retained_block_dct_8x8

compression_ratios_block_dct_8x8.append(compression_ra
tio_block_dct_8x8)

# Inverse transformations

# Inverse Hadamard

modified_hadamard_image =
retain_frequencies(transformed_hadamard_image,
percent)

reconstructed_hadamard_image =
matrix_inverse_transform(H_matrix,
modified_hadamard_image)

hadamard_reconstructed_images.append(normalize_invers
e_image(reconstructed_hadamard_image))

# Inverse DCT

modified_dct_image =
retain_frequencies(transformed_dct_image, percent)

reconstructed_dct_image = idct2(modified_dct_image)

dct_reconstructed_images.append(normalize_inverse_imag
e(reconstructed_dct_image))
 # Inverse 4x4 Block DCT

modified_block_dct_4x4 =
retain_frequencies(block_dct_4x4, percent)

reconstructed_block_dct_4x4 =
block_idct(modified_block_dct_4x4, 4)

block_dct_reconstructed_4x4.append(normalize_inverse_im
age(reconstructed_block_dct_4x4))

# Inverse 8x8 Block DCT

modified_block_dct_8x8 =
retain_frequencies(block_dct_8x8, percent)

reconstructed_block_dct_8x8 =
block_idct(modified_block_dct_8x8, 8)

block_dct_reconstructed_8x8.append(normalize_inverse_im
age(reconstructed_block_dct_8x8))

# Print compression ratios

print("Compression Ratios for Hadamard:",

compression_ratios_hadamard)

print("Compression Ratios for DCT:",

compression_ratios_dct)

print("Compression Ratios for 4x4 Block DCT:",

compression_ratios_block_dct_4x4)

print("Compression Ratios for 8x8 Block DCT:",

compression_ratios_block_dct_8x8)
 # Plot and display results

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

# Display Hadamard transform results

for i, percentage in enumerate(retain_percentages):

plt.subplot(4, 4, i + 1)

plt.imshow(normalize_transformed_image(retain_frequenci
es(transformed_hadamard_image, percentage)),
cmap='gray')

plt.title(f'Hadamard {percentage}%')

plt.axis('off')

plt.subplot(4, 4, i + 5)

plt.imshow(hadamard_reconstructed_images[i],
cmap='gray')

plt.title(f'Inverse Hadamard {percentage}%')

plt.axis('off')

# Display DCT transform results

for i, percentage in enumerate(retain_percentages):

plt.subplot(4, 4, i + 9)
plt.imshow(normalize_transformed_image(retain_frequenci
es(transformed_dct_image, percentage)), cmap='gray')

plt.title(f'DCT {percentage}%')

plt.axis('off')

plt.subplot(4, 4, i + 13)

plt.imshow(dct_reconstructed_images[i],
cmap='gray')

plt.title(f'Inverse DCT {percentage}%')

plt.axis('off')

# Display Block DCT 4x4 results

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

for i, percentage in enumerate(retain_percentages):

plt.subplot(4, 4, i + 1)

plt.imshow(normalize_transformed_image(retain_frequenci
es(block_dct_4x4, percentage)), cmap='gray')

plt.title(f'4x4 Block DCT {percentage}%')

plt.axis('off')

plt.subplot(4, 4, i + 5)

plt.imshow(block_dct_reconstructed_4x4[i],
cmap='gray')
 plt.title(f'Inverse 4x4 Block DCT {percentage}%')

plt.axis('off')

# Display Block DCT 8x8 results

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

for i, percentage in enumerate(retain_percentages):

plt.subplot(4, 4, i + 1)

plt.imshow(normalize_transformed_image(retain_frequenci
es(block_dct_8x8, percentage)), cmap='gray')

plt.title(f'8x8 Block DCT {percentage}%')

plt.axis('off')

plt.subplot(4, 4, i + 5)

plt.imshow(block_dct_reconstructed_8x8[i],
cmap='gray')

plt.title(f'Inverse 8x8 Block DCT {percentage}%')

plt.axis('off')

plt.tight_layout()

plt.show()

B.2 Input and Output:

Input Images:
Output Images:

1. For each Transform as per the procedure discussed in

section A.5.
B.3 Observations and learning:
 1. Transform Types:
a. Hadamard Transform: Efficient for computations but
may lose quality in compression.
b. DCT: Better for image compression, retaining more
visual quality.
2. Performance:
a. DCT generally offers higher compression efficiency and
better image quality compared to Hadamard.
3. Complexity: Both transforms have similar computational
complexities, making them efficient for image processing
tasks.

B.4 Conclusion:

The study demonstrated that both Hadamard and DCT transforms are
valuable tools for image processing, each with unique strengths. However,
DCT is generally preferable for high-quality compression, as it better
preserves visual fidelity while minimizing data size. The Hadamard transform
can still be useful in specific applications, particularly where computational
efficiency is critical. Future work could investigate the potential benefits of
combining both methods to leverage their respective advantages for
improved image processing outcomes.

Method Subjective quality * Compression Ratio

Hadamard (100%) Maximum difference 0.98

Hadamard (50%) Maximum difference 0.75

Hadamard (75%) Maximum difference 0.50

Hadamard (25%) Maximum difference 0.15

Full DCT (100%) Less difference 0.99

Full DCT (75%) Less difference 0.83

Full DCT (50%) Less difference 0.6

 Full DCT (25%) Maximum difference 0.4

4x4 Block DCT(100%) Maximum difference 0.97

4x4 Block DCT(75%) Maximum difference 0.78

4x4 Block DCT(50%) Maximum difference 0.55

4x4 Block DCT(25%) Maximum difference 0.3

8x8 Block DCT (100%) Maximum difference 0.98

8x8 Block DCT (75%) Maximum difference 0.82

8x8 Block DCT (50%) Maximum difference 0.65

8x8 Block DCT (25%) Maximum difference 0.45

B.5 Question of Curiosity

Q1: What are the applications of each of these transforms you have studied
in Expt No. 8?
Hadamard Transform: Commonly used in signal processing, image
compression, and error correction codes. It is particularly beneficial in
applications where fast computations are required, such as in image
reconstruction and data transmission.
Discrete Cosine Transform (DCT): Widely used in image compression
algorithms, especially in JPEG compression. DCT is also applied in video
compression standards like MPEG, as it helps in reducing the redundancy in
spatial frequency

Q2: Compare the performance of all transforms you have studied in

Expt No. 8.

· Hadamard Transform: While it is efficient for certain applications, its

compression performance in this study was suboptimal, yielding high
compression ratios that do not favor image quality.

· DCT: Typically offers better performance in image compression, especially

for natural images, due to its focus on reducing perceptual redundancy.
However, in this analysis, it also resulted in less-than-ideal compression
ratios compared to expectations. Overall, DCT tends to be favored for
practical applications despite the challenges faced in this investigation.

************************