ASSIGNMENT - 2
19ECE455 – BIOMEDICAL SIGNAL PROCESSING
IMAGE PROCESSING USING PYTHON
Daejuswaram G
[Link].U4ECE22115
Daejuswaram G, [Link].U4ECE22115
19ECE455
BIOMEDICAL SIGNAL PROCESSING – ASSIGNMENT - 2
Question 1: Write a python program to apply suitable spatial
filtering to remove the noise for the below various noisy images
and write the inference.
a) Rician noise
CODE:
import cv2
import numpy as np
from [Link] import denoise_nl_means, estimate_sigma
import [Link] as plt
def remove_rician_noise(input_path, output_path_prefix='denoised_rician_image',
show_results=True):
image = [Link](input_path)
if image is None:
raise ValueError("Image not found at the specified path")
gray_image = [Link](image, cv2.COLOR_BGR2GRAY)
normalized_image = gray_image.astype(np.float32) / 255.0
sigma_est = [Link](estimate_sigma(normalized_image, channel_axis=None))
h_values = [0.8 * sigma_est, 1.2 * sigma_est, 1.8 * sigma_est]
denoised_images = []
for i, h in enumerate(h_values):
denoised_image = denoise_nl_means(
1|Page
Daejuswaram G, [Link].U4ECE22115
normalized_image,
h=h,
fast_mode=True,
patch_size=5,
patch_distance=3,
channel_axis=None
)
denoised_image = (denoised_image * 255).astype(np.uint8)
denoised_images.append(denoised_image)
output_path = f"{output_path_prefix}_h{i+1}.jpg"
[Link](output_path, denoised_image)
if show_results:
[Link](figsize=(15, 5))
[Link](141), [Link](gray_image, cmap='gray'), [Link]('Noisy Image')
for i, (denoised, h) in enumerate(zip(denoised_images, h_values)):
[Link](1, 4, i+2), [Link](denoised, cmap='gray'), [Link](f'Denoised
(h={h:.2f})')
[Link]()
if __name__ == "__main__":
input_image_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
remove_rician_noise(input_image_path)
OUTPUT:
2|Page
Daejuswaram G, [Link].U4ECE22115
b) Salt and Pepper noise
CODE:
import cv2
import [Link] as plt
def remove_salt_pepper_noise(image_path, kernel_sizes=[3, 5, 7]):
noisy_image = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if noisy_image is None:
raise FileNotFoundError(f"Image not found at {image_path}")
denoised_images = [[Link](noisy_image, k) for k in kernel_sizes]
return noisy_image, denoised_images, kernel_sizes
if __name__ == "__main__":
input_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
noisy_img, clean_imgs, kernel_sizes = remove_salt_pepper_noise(input_path,
kernel_sizes=[3, 5, 7])
[Link](figsize=(15, 5))
[Link](1, 4, 1), [Link](noisy_img, cmap='gray'), [Link]("Noisy Image")
for i, (clean_img, k) in enumerate(zip(clean_imgs, kernel_sizes)):
[Link](1, 4, i+2), [Link](clean_img, cmap='gray'), [Link](f"Denoised
(k={k})")
[Link]()
for i, (clean_img, k) in enumerate(zip(clean_imgs, kernel_sizes)):
[Link](f"denoised_result_k{k}.png", clean_img)
3|Page
Daejuswaram G, [Link].U4ECE22115
OUTPUT:
c) Gaussian noise
CODE:
import cv2
import [Link] as plt
def remove_gaussian_noise(image_path, kernel_sizes=[3, 5, 7], sigmas=[1.0, 2.0, 3.0]):
noisy_image = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if noisy_image is None:
raise FileNotFoundError(f"Image not found at {image_path}")
denoised_images = [[Link](noisy_image, (k, k), s) for k, s in zip(kernel_sizes,
sigmas)]
return noisy_image, denoised_images, kernel_sizes, sigmas
if __name__ == "__main__":
input_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
noisy_img, clean_imgs, kernel_sizes, sigmas = remove_gaussian_noise(input_path,
kernel_sizes=[3, 5, 7], sigmas=[1.0, 2.0, 3.0])
[Link](figsize=(15, 5))
[Link](1, 4, 1), [Link](noisy_img, cmap='gray'), [Link]("Noisy Image")
4|Page
Daejuswaram G, [Link].U4ECE22115
for i, (clean_img, k, s) in enumerate(zip(clean_imgs, kernel_sizes, sigmas)):
[Link](1, 4, i+2), [Link](clean_img, cmap='gray'), [Link](f"Denoised (k={k},
σ={s})")
[Link]()
for i, (clean_img, k, s) in enumerate(zip(clean_imgs, kernel_sizes, sigmas)):
[Link](f"gaussian_denoised_k{k}_sigma{s}.png", clean_img)
OUTPUT:
d) Periodic noise
CODE:
import cv2
import numpy as np
import [Link] as plt
def remove_periodic_noise(image_path, visualize=True, threshold=220, radius_factor=1.2):
img = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if img is None:
raise FileNotFoundError(f"Image not found at {image_path}")
5|Page
Daejuswaram G, [Link].U4ECE22115
rows, cols = [Link]
nrows = [Link](rows)
ncols = [Link](cols)
padded = [Link](img, 0, nrows-rows, 0, ncols-cols,
cv2.BORDER_CONSTANT, value=0)
dft = [Link](np.float32(padded), flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift = [Link](dft)
magnitude = [Link](dft_shift[:,:,0], dft_shift[:,:,1])
log_spectrum = [Link](1 + magnitude)
spectrum_normalized = [Link](log_spectrum, None, 0, 255,
cv2.NORM_MINMAX)
_, noise_mask = [Link](np.uint8(spectrum_normalized), threshold, 255,
cv2.THRESH_BINARY)
center = (ncols//2, nrows//2)
mask = [Link]((nrows, ncols, 2), np.float32)
contours, _ = [Link](noise_mask, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if len(cnt) > 5:
(x,y), radius = [Link](cnt)
if radius > 5 and radius < 100: # Valid noise component range
[Link](mask, (int(x),int(y)), int(radius * radius_factor), (0,0), -1)
filtered = dft_shift * mask
idft = [Link](filtered)
reconstructed = [Link](idft)
denoised = [Link](reconstructed[:,:,0], reconstructed[:,:,1])
denoised = [Link](denoised, None, 0, 255, cv2.NORM_MINMAX)[:rows, :cols]
return np.uint8(denoised)
if __name__ == "__main__":
input_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
params = [(220, 1.2), (200, 1.5), (240, 1.0)]
6|Page
Daejuswaram G, [Link].U4ECE22115
results = [remove_periodic_noise(input_path, threshold=t, radius_factor=r) for t, r in
params]
[Link](figsize=(15, 5))
[Link](141), [Link]([Link](input_path, cv2.IMREAD_GRAYSCALE),
cmap='gray'), [Link]("Original")
for i, (res, (t, r)) in enumerate(zip(results, params), start=2):
[Link](1, 4, i), [Link](res, cmap='gray'), [Link](f"Threshold: {t}, Factor: {r}")
[Link]()
for i, (res, (t, r)) in enumerate(zip(results, params)):
[Link](f"denoised_threshold{t}_factor{r}.png", res)
OUTPUT:
e) Speckle noise
CODE:
import cv2
import numpy as np
import [Link] as plt
7|Page
Daejuswaram G, [Link].U4ECE22115
def remove_speckle_noise(image_path, median_ksize=5, gaussian_ksize=5,
bilateral_diameter=9, sigma_color=75, sigma_space=75):
print(f"Loading image: {image_path}") # Debug: Checking file path
img = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if img is None:
print("Error: Could not load image. Check path and format.")
return None, None, None
print("Applying filters...")
median_filtered = [Link](img, median_ksize)
gaussian_filtered = [Link](img, (gaussian_ksize, gaussian_ksize), 0)
bilateral_filtered = [Link](img, bilateral_diameter, sigma_color, sigma_space)
print("Filters applied successfully.")
return median_filtered, gaussian_filtered, bilateral_filtered
if __name__ == "__main__":
image_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
param_sets = [
(3, 3, 7, 50, 50),
(5, 5, 9, 75, 75),
(7, 7, 11, 100, 100)
]
results = [remove_speckle_noise(image_path, *params) for params in param_sets]
[Link](figsize=(12, 8))
[Link](3, 3, 1)
original_img = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if original_img is None:
print("Error: Could not load original image for display.")
else:
8|Page
Daejuswaram G, [Link].U4ECE22115
[Link](original_img, cmap='gray')
[Link]('Original Image')
[Link]('off')
for i, (median, gaussian, bilateral) in enumerate(results, start=1):
if median is None or gaussian is None or bilateral is None:
print(f"Skipping set {i} due to error in filtering.")
continue
try:
[Link](3, 3, 3 * (i - 1) + 2)
[Link](median, cmap='gray')
[Link](f'Median {param_sets[i-1][0]}')
[Link]('off')
[Link](3, 3, 3 * (i - 1) + 3)
[Link](gaussian, cmap='gray')
[Link](f'Gaussian {param_sets[i-1][1]}')
[Link]('off')
[Link](3, 3, 3 * (i - 1) + 4)
[Link](bilateral, cmap='gray')
[Link](f'Bilateral {param_sets[i-1][2]}')
[Link]('off')
except Exception as e:
print(f"Error while plotting set {i}: {e}")
plt.tight_layout()
[Link]()
for i, (median, gaussian, bilateral) in enumerate(results):
if median is not None and gaussian is not None and bilateral is not None:
success_m = [Link](f'median_filtered_{i}.jpg', median)
9|Page
Daejuswaram G, [Link].U4ECE22115
success_g = [Link](f'gaussian_filtered_{i}.jpg', gaussian)
success_b = [Link](f'bilateral_filtered_{i}.jpg', bilateral)
if success_m and success_g and success_b:
print(f"Successfully saved results for set {i}.")
else:
print(f"Failed to save some images for set {i}.")
OUTPUT:
10 | P a g e
Daejuswaram G, [Link].U4ECE22115
Question 2: Write a program in Python to explore different
methods for improving the visual quality of the below medical
images.
I. Point Processing
a. Image Negative
CODE:
import numpy as np
import cv2
import [Link] as plt
def image_negative(image):
negative_image = 255 - image
return negative_image
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
negative_image = image_negative(image)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(negative_image, cmap='gray')
axes[1].set_title("Negative Image")
for ax in axes:
11 | P a g e
Daejuswaram G, [Link].U4ECE22115
[Link]("off")
[Link]()
OUTPUT:
b. Image Thresholding
CODE:
import numpy as np
import cv2
import [Link] as plt
def image_thresholding(image, threshold=128):
binary_image = [Link](image >= threshold, 255, 0).astype(np.uint8)
return binary_image
12 | P a g e
Daejuswaram G, [Link].U4ECE22115
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
threshold = 30
binary_image = image_thresholding(image, threshold)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(binary_image, cmap='gray')
axes[1].set_title(f"Thresholded Image (T={threshold})")
for ax in axes:
[Link]("off")
[Link]()
OUTPUT:
c. Image Grey Level Slicing with Background
CODE:
13 | P a g e
Daejuswaram G, [Link].U4ECE22115
import numpy as np
import cv2
import [Link] as plt
def grey_level_slicing(image, min_range, max_range, slice_value=255):
sliced_image = [Link]((image >= min_range) & (image <= max_range), slice_value,
image)
return sliced_image.astype(np.uint8)
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
min_range = 125
max_range = 190
slice_value = 200
sliced_image = grey_level_slicing(image, min_range, max_range, slice_value)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(sliced_image, cmap='gray')
axes[1].set_title(f"Gray Level Sliced Image ({min_range}-{max_range})")
for ax in axes:
[Link]("off")
[Link]()
OUTPUT:
14 | P a g e
Daejuswaram G, [Link].U4ECE22115
d. Contrast Stretching
CODE:
import cv2
import numpy as np
import [Link] as plt
def contrast_stretching(image_path):
img = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if img is None:
print("Error: Could not load image")
return
a = [Link](img)
b = [Link](img)
c = 50
d = 255
stretched = c + ((img - a) * (d - c) / (b - a))
stretched = [Link](stretched, 0, 255).astype(np.uint8)
15 | P a g e
Daejuswaram G, [Link].U4ECE22115
[Link](figsize=(10, 5))
[Link](1, 2, 1)
[Link](img, cmap='gray')
[Link]('Original Image')
[Link]('off')
[Link](1, 2, 2)
[Link](stretched, cmap='gray')
[Link]('Contrast Stretched Image')
[Link]('off')
plt.tight_layout()
[Link]()
[Link](figsize=(10, 4))
[Link](1, 2, 1)
[Link]([Link](), 256, [0,256])
[Link]('Original Histogram')
[Link](1, 2, 2)
[Link]([Link](), 256, [0,256])
[Link]('Stretched Histogram')
plt.tight_layout()
[Link]()
return stretched
if __name__ == "__main__":
image_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
result = contrast_stretching(image_path)
OUTPUT:
16 | P a g e
Daejuswaram G, [Link].U4ECE22115
II. Histogram Processing
CODE:
import numpy as np
import cv2
import [Link] as plt
def histogram_equalization(image):
hist, bins = [Link]([Link](), 256, [0, 256])
cdf = [Link]()
17 | P a g e
Daejuswaram G, [Link].U4ECE22115
cdf_normalized = cdf * 255 / cdf[-1]
equalized_image = [Link]([Link](), bins[:-1],
cdf_normalized).reshape([Link])
return equalized_image.astype(np.uint8)
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
equalized_image = histogram_equalization(image)
hist_original, _ = [Link]([Link](), 256, [0, 256])
hist_equalized, _ = [Link](equalized_image.flatten(), 256, [0, 256])
fig, axes = [Link](2, 2, figsize=(10, 8))
axes[0, 0].imshow(image, cmap='gray')
axes[0, 0].set_title("Original Image")
axes[0, 1].imshow(equalized_image, cmap='gray')
axes[0, 1].set_title("Histogram Equalized Image")
axes[1, 0].plot(hist_original, color='black')
axes[1, 0].set_title("Original Histogram")
axes[1, 1].plot(hist_equalized, color='black')
axes[1, 1].set_title("Equalized Histogram")
for ax in [Link]():
[Link]("off") if len([Link]) > 0 else ax.set_xticks([]), ax.set_yticks([])
[Link]()
18 | P a g e
Daejuswaram G, [Link].U4ECE22115
OUTPUT:
III. Intensity Transformation Operations
a. Log transformation
CODE:
import numpy as np
import cv2
import [Link] as plt
19 | P a g e
Daejuswaram G, [Link].U4ECE22115
def log_transformation(image, c=1):
image = [Link](np.float32) + 1
log_image = c * [Link](image)
log_image = (log_image / [Link](log_image)) * 255
return log_image.astype(np.uint8)
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
c = 255 / [Link](1 + [Link](image)) # Compute scaling factor
enhanced_image = log_transformation(image, c)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(enhanced_image, cmap='gray')
axes[1].set_title("Log Transformed Image")
for ax in axes:
[Link]("off")
[Link]()
OUTPUT:
20 | P a g e
Daejuswaram G, [Link].U4ECE22115
b. Inverse log
CODE:
import numpy as np
import cv2
import [Link] as plt
def inverse_log_transformation(image, c=1):
image = [Link](np.float32)
inv_log_image = [Link](image / c) - 1
inv_log_image = (inv_log_image / [Link](inv_log_image)) * 255 # Normalize to 0-255
return inv_log_image.astype(np.uint8)
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
c = 255 / [Link](1 + [Link](image)) # Compute scaling factor
enhanced_image = inverse_log_transformation(image, c)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(enhanced_image, cmap='gray')
axes[1].set_title("Inverse Log Transformed Image")
for ax in axes:
[Link]("off")
[Link]()
21 | P a g e
Daejuswaram G, [Link].U4ECE22115
OUTPUT:
c. Power-law (gamma) transformation
CODE:
import numpy as np
import cv2
import [Link] as plt
def gamma_transformation(image, gamma=1.0, c=1):
image = [Link](np.float32) / 255.0 # Normalize to range [0,1]
gamma_image = c * (image ** gamma)
gamma_image = (gamma_image * 255).astype(np.uint8) # Scale back to [0,255]
return gamma_image
image = [Link](r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]",
cv2.IMREAD_GRAYSCALE)
gamma = 0.8
enhanced_image = gamma_transformation(image, gamma)
fig, axes = [Link](1, 2, figsize=(8, 4))
axes[0].imshow(image, cmap='gray')
axes[0].set_title("Original Image")
axes[1].imshow(enhanced_image, cmap='gray')
22 | P a g e
Daejuswaram G, [Link].U4ECE22115
axes[1].set_title(f"Gamma Transformed Image (γ={gamma})")
for ax in axes:
[Link]("off")
[Link]()
OUTPUT:
IV. Bit-Plane Slicing
CODE:
import cv2
import numpy as np
import [Link] as plt
def bit_plane_slicing(image_path):
img = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if img is None:
print("Error: Could not load image")
23 | P a g e
Daejuswaram G, [Link].U4ECE22115
return
height, width = [Link]
bit_planes = [Link]((height, width, 8), dtype=np.uint8)
for i in range(8):
mask = 1 << i
bit_planes[:,:,i] = cv2.bitwise_and(img, mask)
bit_planes[:,:,i] = [Link](bit_planes[:,:,i] > 0, 255, 0)
[Link](figsize=(12, 6))
[Link](3, 3, 1)
[Link](img, cmap='gray')
[Link]('Original Image')
[Link]('off')
for i in range(8):
[Link](3, 3, i + 2)
[Link](bit_planes[:,:,i], cmap='gray')
[Link](f'Bit Plane {i}')
[Link]('off')
plt.tight_layout()
[Link]()
return bit_planes
if __name__ == "__main__":
image_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
bit_planes = bit_plane_slicing(image_path)
24 | P a g e
Daejuswaram G, [Link].U4ECE22115
OUTPUT:
V. Image Masking
a. Laplacian of the image
b. Sharpen image adding original image and output of a
c. Sobel of original image
d. Smoothing of output of c
e. Mask image formed by product of c and d
f. Sharpen the image by sum of original and f
25 | P a g e
Daejuswaram G, [Link].U4ECE22115
CODE:
import cv2
import numpy as np
import [Link] as plt
def process_image(image_path):
image = [Link](image_path, cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Unable to read the image.")
return
laplacian = [Link](image, cv2.CV_64F)
laplacian = np.uint8([Link](laplacian))
sharpened_laplacian = [Link](image, 1.5, laplacian, -0.5, 0)
sobel_x = [Link](image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = [Link](image, cv2.CV_64F, 0, 1, ksize=3)
sobel_magnitude = [Link](sobel_x**2 + sobel_y**2)
sobel_magnitude = np.uint8([Link](sobel_magnitude))
smoothed_sobel = [Link](sobel_magnitude, (5, 5), 0)
mask_image = [Link](sobel_magnitude, smoothed_sobel)
final_sharpened = [Link](image, 1.5, mask_image, -0.5, 0)
[Link](figsize=(15, 10))
[Link](2, 3, 1)
[Link]("Original Image")
[Link](image, cmap='gray')
[Link]("off")
[Link](2, 3, 2)
[Link]("Laplacian Image")
26 | P a g e
Daejuswaram G, [Link].U4ECE22115
[Link](laplacian, cmap='gray')
[Link]("off")
[Link](2, 3, 3)
[Link]("Sharpened (Laplacian)")
[Link](sharpened_laplacian, cmap='gray')
[Link]("off")
[Link](2, 3, 4)
[Link]("Sobel Magnitude")
[Link](sobel_magnitude, cmap='gray')
[Link]("off")
[Link](2, 3, 5)
[Link]("Smoothed Sobel")
[Link](smoothed_sobel, cmap='gray')
[Link]("off")
[Link](2, 3, 6)
[Link]("Final Sharpened Image")
[Link](final_sharpened, cmap='gray')
[Link]("off")
[Link]()
image_path = r"C:\Users\Daejuswaram Gopinath\Desktop\Q1 (BSP)\[Link]"
process_image(image_path)
27 | P a g e
Daejuswaram G, [Link].U4ECE22115
OUTPUT:
28 | P a g e
