image_processing_exercises.py

# -*- coding: utf-8 -*-
"""image_processing_exercises

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1aQP0V-WGy-aBz21S8C9iBQolthk0uEnv
"""

# Import necessary libraries
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load the image
leaf_image = cv2.imread('/content/leaf.jpg')

# Convert to grayscale
leaf_gray = cv2.cvtColor(leaf_image, cv2.COLOR_BGR2GRAY)

# Apply thresholding
tau = 220
_, leaf_binary = cv2.threshold(leaf_gray, tau, 255, cv2.THRESH_BINARY)

# Display the grayscale and binary images
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.title('Grayscale Image')
plt.imshow(leaf_gray, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Binary Image')
plt.imshow(leaf_binary, cmap='gray')
plt.axis('off')

plt.show()

# Import necessary libraries
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load the image
leaf_image = cv2.imread('/content/leaf.jpg')

# Convert to grayscale
leaf_gray = cv2.cvtColor(leaf_image, cv2.COLOR_BGR2GRAY)

# Apply thresholding
tau = 220
_, leaf_binary = cv2.threshold(leaf_gray, tau, 255, cv2.THRESH_BINARY_INV)  # Use binary inverse to get white leaf on black background

# Display the binary image to ensure it's correct
plt.figure(figsize=(5, 5))
plt.title('Binary Image')
plt.imshow(leaf_binary, cmap='gray')
plt.axis('off')
plt.show()

# Extract the contours using the Moore boundary tracing algorithm
contours, _ = cv2.findContours(leaf_binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Find the largest contour based on the area
largest_contour = max(contours, key=cv2.contourArea)

# Draw the largest contour on the original image
contour_image = leaf_image.copy()
cv2.drawContours(contour_image, [largest_contour], -1, (255, 0, 0), 2)  # Red color for the contour

# Display the original image with the largest contour
plt.figure(figsize=(10, 5))
plt.title('Original Image with Contour')
plt.imshow(cv2.cvtColor(contour_image, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()

# Import necessary libraries
import numpy as np
import cv2

# Function to calculate Fourier Descriptors
def calculate_fourier_descriptors(contour, n_descriptors):
    # Flatten the contour array
    contour_array = contour[:, 0, :]
    complex_contour = contour_array[:, 0] + 1j * contour_array[:, 1]

    # Compute the Fourier transform
    fourier_result = np.fft.fft(complex_contour)

    # Zero out all but the first n_descriptors
    descriptors = np.zeros_like(fourier_result)
    descriptors[:n_descriptors] = fourier_result[:n_descriptors]

    return descriptors

# Get the largest contour
largest_contour = max(contours, key=cv2.contourArea)

# Number of descriptors to keep
n_descriptors = len(largest_contour)  # Keep all descriptors initially
fourier_descriptors = calculate_fourier_descriptors(largest_contour, n_descriptors)

# Function to reconstruct the contour from Fourier Descriptors
def reconstruct_contour(fourier_descriptors, n_points):
    # Compute the inverse Fourier transform
    reconstructed_complex = np.fft.ifft(fourier_descriptors)

    # Convert to (x, y) coordinates
    reconstructed_contour = np.vstack((reconstructed_complex.real, reconstructed_complex.imag)).T

    # Normalize coordinates to the original image size
    reconstructed_contour = np.int32(reconstructed_contour)

    return reconstructed_contour

# Function to draw reconstructed contour on the image
def draw_reconstructed_contour(image, reconstructed_contour, color=(255, 0, 0)):
    reconstructed_image = image.copy()
    cv2.polylines(reconstructed_image, [reconstructed_contour], isClosed=True, color=color, thickness=2)
    return reconstructed_image

# Reconstruct and display contours for different percentages of descriptors
percentages = [100, 50, 10, 1]
plt.figure(figsize=(20, 10))

for i, perc in enumerate(percentages):
    n_descriptors = int(len(fourier_descriptors) * perc / 100)
    reduced_descriptors = np.zeros_like(fourier_descriptors)
    reduced_descriptors[:n_descriptors] = fourier_descriptors[:n_descriptors]

    reconstructed_contour = reconstruct_contour(reduced_descriptors, len(largest_contour))
    contour_image = draw_reconstructed_contour(leaf_image, reconstructed_contour, color=(255, 0, 0))

    plt.subplot(1, 4, i + 1)
    plt.title(f'{perc}% Descriptors')
    plt.imshow(cv2.cvtColor(contour_image, cv2.COLOR_BGR2RGB))
    plt.axis('off')

plt.show()

# Rotate and translate the image
angle = 60
tx, ty = 100, 60

# Get the rotation matrix
(h, w) = leaf_image.shape[:2]
center = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(center, angle, 1.0)

# Perform the rotation
rotated_image = cv2.warpAffine(leaf_image, M, (w, h))

# Perform the translation
translated_image = cv2.warpAffine(rotated_image, np.float32([[1, 0, tx], [0, 1, ty]]), (w, h))

# Display the transformed image
plt.figure(figsize=(10, 5))
plt.title('Transformed Image')
plt.imshow(cv2.cvtColor(translated_image, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.show()

# Convert to grayscale and apply thresholding
leaf_gray_transformed = cv2.cvtColor(translated_image, cv2.COLOR_BGR2GRAY)
_, leaf_binary_transformed = cv2.threshold(leaf_gray_transformed, tau, 255, cv2.THRESH_BINARY_INV)

# Extract the contour using the Moore boundary tracing algorithm
contours_transformed, _ = cv2.findContours(leaf_binary_transformed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
largest_contour_transformed = max(contours_transformed, key=cv2.contourArea)

# Calculate the Fourier Descriptors for the transformed contour
fourier_descriptors_transformed = calculate_fourier_descriptors(largest_contour_transformed, len(largest_contour_transformed))

# Reconstruct and display contours for different percentages of descriptors
plt.figure(figsize=(20, 10))

for i, perc in enumerate(percentages):
    n_descriptors = int(len(fourier_descriptors_transformed) * perc / 100)
    reduced_descriptors = np.zeros_like(fourier_descriptors_transformed)
    reduced_descriptors[:n_descriptors] = fourier_descriptors_transformed[:n_descriptors]

    reconstructed_contour = reconstruct_contour(reduced_descriptors, len(largest_contour_transformed))
    contour_image_transformed = draw_reconstructed_contour(translated_image, reconstructed_contour, color=(255, 0, 0))

    plt.subplot(1, 4, i + 1)
    plt.title(f'{perc}% Descriptors')
    plt.imshow(cv2.cvtColor(contour_image_transformed, cv2.COLOR_BGR2RGB))
    plt.axis('off')

plt.show()

# Import necessary libraries
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load the image
lenna_image = cv2.imread('/content/lenna.jpg', cv2.IMREAD_GRAYSCALE)

# Display the original image
plt.figure(figsize=(5, 5))
plt.title('Original Image')
plt.imshow(lenna_image, cmap='gray')
plt.axis('off')
plt.show()

# Function to apply 2D-DCT to each block
def apply_dct(image, block_size=32):
    h, w = image.shape
    # Pad the image to make its dimensions divisible by the block size
    h_padded = (h // block_size + 1) * block_size if h % block_size != 0 else h
    w_padded = (w // block_size + 1) * block_size if w % block_size != 0 else w
    padded_image = np.zeros((h_padded, w_padded), dtype=np.float32)
    padded_image[:h, :w] = image

    dct_image = np.zeros_like(padded_image, dtype=np.float32)
    for i in range(0, h_padded, block_size):
        for j in range(0, w_padded, block_size):
            block = padded_image[i:i+block_size, j:j+block_size]
            dct_block = cv2.dct(np.float32(block))
            dct_image[i:i+block_size, j:j+block_size] = dct_block
    return dct_image, (h, w)

dct_image, original_shape = apply_dct(lenna_image)

# Function to retain DCT coefficients using the zonal method
def zonal_method(dct_image, block_size=32, retain_percentage=50):
    h, w = dct_image.shape
    retain_size = int(block_size * retain_percentage / 100)
    mask = np.zeros((block_size, block_size), dtype=np.float32)
    mask[:retain_size, :retain_size] = 1

    retained_dct = np.zeros_like(dct_image, dtype=np.float32)
    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]
            retained_dct[i:i+block_size, j:j+block_size] = block * mask
    return retained_dct

# Function to retain DCT coefficients using the threshold method
def threshold_method(dct_image, threshold):
    retained_dct = np.where(np.abs(dct_image) > threshold, dct_image, 0)
    return retained_dct

# Function to apply inverse 2D-DCT to each block
def apply_idct(dct_image, original_shape, block_size=32):
    h, w = original_shape
    h_padded, w_padded = dct_image.shape
    idct_image = np.zeros((h_padded, w_padded), dtype=np.float32)
    for i in range(0, h_padded, block_size):
        for j in range(0, w_padded, block_size):
            block = dct_image[i:i+block_size, j:j+block_size]
            idct_block = cv2.idct(block)
            idct_image[i:i+block_size, j:j+block_size] = idct_block
    # Crop the image to the original size
    idct_image_cropped = idct_image[:h, :w]
    return np.uint8(idct_image_cropped)

# Example usage for 50% coefficients retained using zonal method
zonal_dct_50 = zonal_method(dct_image, retain_percentage=50)
reconstructed_image_zonal_50 = apply_idct(zonal_dct_50, original_shape)

# Example usage for threshold method
threshold_dct = threshold_method(dct_image, threshold=10)
reconstructed_image_threshold = apply_idct(threshold_dct, original_shape)

# Display the reconstructed images
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.title('Reconstructed Image (Zonal Method, 50%)')
plt.imshow(reconstructed_image_zonal_50, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Reconstructed Image (Threshold Method)')
plt.imshow(reconstructed_image_threshold, cmap='gray')
plt.axis('off')

plt.show()

# Function to calculate MSE
def calculate_mse(original, reconstructed):
    return np.mean((original - reconstructed) ** 2)

# Retain percentages to evaluate
retain_percentages = [5, 10, 20, 30, 40, 50]

mse_zonal = []
mse_threshold = []

# Calculate MSE for each retain percentage using zonal method
for perc in retain_percentages:
    zonal_dct = zonal_method(dct_image, retain_percentage=perc)
    reconstructed_image = apply_idct(zonal_dct, original_shape)
    mse = calculate_mse(lenna_image, reconstructed_image)
    mse_zonal.append(mse)

# Calculate MSE for each retain percentage using threshold method
threshold_values = [5, 10, 20, 30, 40, 50]

for thresh in threshold_values:
    threshold_dct = threshold_method(dct_image, threshold=thresh)
    reconstructed_image = apply_idct(threshold_dct, original_shape)
    mse = calculate_mse(lenna_image, reconstructed_image)
    mse_threshold.append(mse)

# Plot the MSE results
plt.figure(figsize=(10, 5))
plt.plot(retain_percentages, mse_zonal, label='Zonal Method')
plt.plot(threshold_values, mse_threshold, label='Threshold Method')
plt.xlabel('Percentage of Retained Coefficients / Threshold Value')
plt.ylabel('Mean Squared Error')
plt.legend()
plt.title('MSE vs. Retained Coefficients / Threshold Value')
plt.show()

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

# Load the image
board_image = cv2.imread('/content/board.png', cv2.IMREAD_GRAYSCALE)

# Function to add Gaussian noise to an image
def add_gaussian_noise(image, snr_db):
    # Calculate the signal power
    signal_power = np.mean(image**2)

    # Calculate the noise power
    snr_linear = 10**(snr_db / 10)
    noise_power = signal_power / snr_linear

    # Generate Gaussian noise
    mean = 0
    std_dev = np.sqrt(noise_power)
    noise = np.random.normal(mean, std_dev, image.shape)

    # Add noise to the image
    noisy_image = image + noise
    noisy_image_clipped = np.clip(noisy_image, 0, 255).astype(np.uint8)

    return noisy_image_clipped

# Add Gaussian noise with SNR = 15 dB
snr_db = 15
noisy_image_gaussian = add_gaussian_noise(board_image, snr_db)

# Calculate the actual SNR to confirm
actual_snr = 10 * np.log10(np.mean(board_image**2) / np.mean((board_image - noisy_image_gaussian)**2))
print(f'Actual SNR: {actual_snr:.2f} dB')

# Display the original and noisy images
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(board_image, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Image with Gaussian Noise (SNR = 15 dB)')
plt.imshow(noisy_image_gaussian, cmap='gray')
plt.axis('off')

plt.show()

# Function to apply moving average filter
def apply_moving_average_filter(image, kernel_size):
    return cv2.blur(image, (kernel_size, kernel_size))

# Function to apply median filter
def apply_median_filter(image, kernel_size):
    return cv2.medianBlur(image, kernel_size)

# Define kernel sizes
kernel_sizes = [3, 5, 7, 9]

# Apply filters to the noisy image with Gaussian noise
plt.figure(figsize=(15, 10))
plt.subplot(2, 5, 1)
plt.title('Noisy Image (Gaussian)')
plt.imshow(noisy_image_gaussian, cmap='gray')
plt.axis('off')

for i, size in enumerate(kernel_sizes, start=2):
    avg_filtered = apply_moving_average_filter(noisy_image_gaussian, size)
    plt.subplot(2, 5, i)
    plt.title(f'Avg Filter {size}x{size}')
    plt.imshow(avg_filtered, cmap='gray')
    plt.axis('off')

    median_filtered = apply_median_filter(noisy_image_gaussian, size)
    plt.subplot(2, 5, i + 5)
    plt.title(f'Median Filter {size}x{size}')
    plt.imshow(median_filtered, cmap='gray')
    plt.axis('off')

plt.show()

# Function to add salt-and-pepper noise to an image
def add_salt_and_pepper_noise(image, density):
    noisy_image = image.copy()
    num_salt = np.ceil(density * image.size * 0.5).astype(int)
    num_pepper = np.ceil(density * image.size * 0.5).astype(int)

    # Add salt
    coords = [np.random.randint(0, i - 1, num_salt) for i in image.shape]
    noisy_image[coords[0], coords[1]] = 255

    # Add pepper
    coords = [np.random.randint(0, i - 1, num_pepper) for i in image.shape]
    noisy_image[coords[0], coords[1]] = 0

    return noisy_image

# Add salt-and-pepper noise with 30% density
density = 0.3
noisy_image_sp = add_salt_and_pepper_noise(board_image, density)

# Display the original and noisy images
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(board_image, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Image with Salt-and-Pepper Noise (30% density)')
plt.imshow(noisy_image_sp, cmap='gray')
plt.axis('off')

plt.show()

# Apply filters to the noisy image with salt-and-pepper noise
plt.figure(figsize=(15, 10))
plt.subplot(2, 5, 1)
plt.title('Noisy Image (Salt-and-Pepper)')
plt.imshow(noisy_image_sp, cmap='gray')
plt.axis('off')

for i, size in enumerate(kernel_sizes, start=2):
    avg_filtered_sp = apply_moving_average_filter(noisy_image_sp, size)
    plt.subplot(2, 5, i)
    plt.title(f'Avg Filter {size}x{size}')
    plt.imshow(avg_filtered_sp, cmap='gray')
    plt.axis('off')

    median_filtered_sp = apply_median_filter(noisy_image_sp, size)
    plt.subplot(2, 5, i + 5)
    plt.title(f'Median Filter {size}x{size}')
    plt.imshow(median_filtered_sp, cmap='gray')
    plt.axis('off')

plt.show()

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

# Load the images
dark_road_1 = cv2.imread('/content/dark_road_1.jpg', cv2.IMREAD_GRAYSCALE)
dark_road_2 = cv2.imread('/content/dark_road_2.jpg', cv2.IMREAD_GRAYSCALE)
dark_road_3 = cv2.imread('/content/dark_road_3.jpg', cv2.IMREAD_GRAYSCALE)

images = [dark_road_1, dark_road_2, dark_road_3]
titles = ['Dark Road 1', 'Dark Road 2', 'Dark Road 3']

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

for i, img in enumerate(images):
    plt.subplot(3, 2, 2*i + 1)
    plt.title(titles[i])
    plt.imshow(img, cmap='gray')
    plt.axis('off')

    plt.subplot(3, 2, 2*i + 2)
    plt.title(f'Histogram of {titles[i]}')
    plt.hist(img.ravel(), 256, [0, 256])

plt.show()

# Function to apply global histogram equalization
def global_histogram_equalization(image):
    return cv2.equalizeHist(image)

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

for i, img in enumerate(images):
    equalized_img = global_histogram_equalization(img)

    plt.subplot(3, 2, 2*i + 1)
    plt.title(f'Equalized {titles[i]}')
    plt.imshow(equalized_img, cmap='gray')
    plt.axis('off')

    plt.subplot(3, 2, 2*i + 2)
    plt.title(f'Histogram of Equalized {titles[i]}')
    plt.hist(equalized_img.ravel(), 256, [0, 256])

plt.show()

# Function to apply local histogram equalization (CLAHE)
def local_histogram_equalization(image, clip_limit=2.0, tile_grid_size=(8, 8)):
    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
    return clahe.apply(image)

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

for i, img in enumerate(images):
    clahe_img = local_histogram_equalization(img)

    plt.subplot(3, 2, 2*i + 1)
    plt.title(f'CLAHE {titles[i]}')
    plt.imshow(clahe_img, cmap='gray')
    plt.axis('off')

    plt.subplot(3, 2, 2*i + 2)
    plt.title(f'Histogram of CLAHE {titles[i]}')
    plt.hist(clahe_img.ravel(), 256, [0, 256])

plt.show()

import cv2
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import convolve2d, wiener

# Load the image
new_york_image = cv2.imread('/content/new_york.png', cv2.IMREAD_GRAYSCALE)

# Function to degrade the image using Gaussian blur and Gaussian noise
def degrade_image(image, std_dev, snr_db):
    # Create Gaussian blur kernel
    kernel_size = int(6 * std_dev + 1)
    gaussian_kernel = cv2.getGaussianKernel(kernel_size, std_dev)
    gaussian_kernel_2d = gaussian_kernel @ gaussian_kernel.T

    # Apply Gaussian blur
    blurred_image = convolve2d(image, gaussian_kernel_2d, mode='same', boundary='symm')

    # Calculate signal power and noise power
    signal_power = np.mean(blurred_image**2)
    snr_linear = 10**(snr_db / 10)
    noise_power = signal_power / snr_linear
    noise_std_dev = np.sqrt(noise_power)

    # Add Gaussian noise
    noise = np.random.normal(0, noise_std_dev, image.shape)
    noisy_blurred_image = blurred_image + noise

    return noisy_blurred_image, gaussian_kernel_2d

# Degrade the image
std_dev = 1.5  # Standard deviation for Gaussian blur
snr_db = 7  # Signal-to-noise ratio in dB
degraded_image, psf = degrade_image(new_york_image, std_dev, snr_db)

# Display the original and degraded images
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(new_york_image, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title('Degraded Image')
plt.imshow(degraded_image, cmap='gray')
plt.axis('off')

plt.show()

# Function to display the PSF and its frequency response
def display_psf_and_frequency_response(psf):
    psf_fft = np.fft.fftshift(np.fft.fft2(psf))
    psf_magnitude = np.abs(psf_fft)

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

    plt.subplot(1, 2, 1)
    plt.title('Point Spread Function (PSF)')
    plt.imshow(psf, cmap='gray')
    plt.axis('off')

    plt.subplot(1, 2, 2)
    plt.title('Frequency Response of PSF')
    plt.imshow(np.log1p(psf_magnitude), cmap='gray')
    plt.axis('off')

    plt.show()

# Display the PSF and its frequency response
display_psf_and_frequency_response(psf)

# Function to apply Wiener deconvolution
def wiener_deconvolution(image, psf, snr):
    # Compute the Fourier transforms
    image_fft = np.fft.fft2(image)
    psf_fft = np.fft.fft2(psf, s=image.shape)
    psf_fft_conj = np.conj(psf_fft)

    # Compute the Wiener filter
    H = psf_fft * psf_fft_conj
    G = psf_fft_conj * image_fft
    wiener_filter = G / (H + 1/snr)

    # Apply the Wiener filter and compute the inverse FFT
    restored_image_fft = wiener_filter
    restored_image = np.fft.ifft2(restored_image_fft)
    restored_image = np.abs(restored_image)

    return restored_image

# Known SNR
known_snr = 10**(snr_db / 10)

# Restore the image with known noise power
restored_image_known = wiener_deconvolution(degraded_image, psf, known_snr)

# Estimate noise power from the degraded image
estimated_noise_power = np.var(degraded_image - new_york_image)
estimated_snr = 10 * np.log10(np.mean(degraded_image**2) / estimated_noise_power)

# Restore the image with estimated noise power
restored_image_estimated = wiener_deconvolution(degraded_image, psf, 10**(estimated_snr / 10))

# Display the restored images
plt.figure(figsize=(15, 10))

plt.subplot(1, 3, 1)
plt.title('Degraded Image')
plt.imshow(degraded_image, cmap='gray')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.title('Restored Image (Known SNR)')
plt.imshow(restored_image_known, cmap='gray')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.title('Restored Image (Estimated SNR)')
plt.imshow(restored_image_estimated, cmap='gray')
plt.axis('off')

plt.show()

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

# Load the image
hallway_image = cv2.imread('/content/hallway.png', cv2.IMREAD_GRAYSCALE)

# Apply Sobel masks to estimate the gradient components
sobel_x = cv2.Sobel(hallway_image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(hallway_image, cv2.CV_64F, 0, 1, ksize=3)

# Compute the gradient magnitude
gradient_magnitude = np.sqrt(sobel_x**2 + sobel_y**2)
gradient_magnitude = cv2.convertScaleAbs(gradient_magnitude)

# Display the gradient components and the gradient magnitude
plt.figure(figsize=(15, 10))

plt.subplot(2, 2, 1)
plt.title('Original Image')
plt.imshow(hallway_image, cmap='gray')
plt.axis('off')

plt.subplot(2, 2, 2)
plt.title('Sobel X')
plt.imshow(cv2.convertScaleAbs(sobel_x), cmap='gray')
plt.axis('off')

plt.subplot(2, 2, 3)
plt.title('Sobel Y')
plt.imshow(cv2.convertScaleAbs(sobel_y), cmap='gray')
plt.axis('off')

plt.subplot(2, 2, 4)
plt.title('Gradient Magnitude')
plt.imshow(gradient_magnitude, cmap='gray')
plt.axis('off')

plt.show()

# Function to apply global thresholding
def global_thresholding(image, threshold_value):
    _, binary_image = cv2.threshold(image, threshold_value, 255, cv2.THRESH_BINARY)
    return binary_image

# Apply global thresholding
threshold_value = 50  # You can adjust this value
binary_edges = global_thresholding(gradient_magnitude, threshold_value)

# Display the binary edge image
plt.figure(figsize=(10, 5))

plt.subplot(1, 2, 1)
plt.title('Gradient Magnitude Histogram')
plt.hist(gradient_magnitude.ravel(), 256, [0, 256])
plt.axvline(x=threshold_value, color='r', linestyle='--')

plt.subplot(1, 2, 2)
plt.title('Binary Edge Image')
plt.imshow(binary_edges, cmap='gray')
plt.axis('off')

plt.show()

# Function to apply Hough transform
def hough_transform(image):
    lines = cv2.HoughLinesP(image, rho=1, theta=np.pi/180, threshold=80, minLineLength=30, maxLineGap=10)
    line_image = np.copy(hallway_image)
    if lines is not None:
        for line in lines:
            x1, y1, x2, y2 = line[0]
            cv2.line(line_image, (x1, y1), (x2, y2), (255, 0, 0), 2)
    return line_image

# Apply the Hough transform to detect straight lines
hough_lines_image = hough_transform(binary_edges)

# Display the result of the Hough transform
plt.figure(figsize=(10, 5))

plt.title('Hough Transform Result')
plt.imshow(hough_lines_image, cmap='gray')
plt.axis('off')

plt.show()

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

# Load the image
coins_image = cv2.imread('/content/coins.png', cv2.IMREAD_GRAYSCALE)

# Compute histogram and find optimal threshold using Otsu's method
def otsu_thresholding(image):
    blur = cv2.GaussianBlur(image, (5, 5), 0)
    _, binary_image = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    return binary_image

binary_coins = otsu_thresholding(coins_image)

# Display the histogram and the thresholded image
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.title('Histogram of Coins Image')
plt.hist(coins_image.ravel(), 256, [0, 256])
plt.axvline(x=binary_coins.mean(), color='r', linestyle='--')

plt.subplot(1, 2, 2)
plt.title('Binary Image (Otsu\'s Thresholding)')
plt.imshow(binary_coins, cmap='gray')
plt.axis('off')

plt.show()

# Display the segmented coins on a black background
segmented_coins = cv2.bitwise_and(coins_image, coins_image, mask=binary_coins)

plt.figure(figsize=(5, 5))
plt.title('Segmented Coins on Black Background')
plt.imshow(segmented_coins, cmap='gray')
plt.axis('off')
plt.show()

# Find contours of the coins
contours, _ = cv2.findContours(binary_coins, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Create an empty image to draw the contours
coins_contours = np.zeros_like(coins_image)

for i, contour in enumerate(contours):
    cv2.drawContours(coins_contours, [contour], -1, (255), thickness=cv2.FILLED)
    # Display each coin separately
    coin = cv2.bitwise_and(coins_image, coins_image, mask=coins_contours)
    plt.figure(figsize=(3, 3))
    plt.title(f'Coin {i+1}')
    plt.imshow(coin, cmap='gray')
    plt.axis('off')
    plt.show()

    # Clear the mask for the next coin
    coins_contours = np.zeros_like(coins_image)

# Create an empty image to draw the contours
coins_contours = np.zeros_like(coins_image)
coin_info = []

for i, contour in enumerate(contours):
    # Draw the contour
    cv2.drawContours(coins_contours, [contour], -1, (255), thickness=cv2.FILLED)
    # Compute center and diameter
    M = cv2.moments(contour)
    cX = int(M["m10"] / M["m00"])
    cY = int(M["m01"] / M["m00"])
    diameter = int(np.sqrt(4 * M["m00"] / np.pi))
    coin_info.append((cX, cY, diameter))
    # Display each coin with center and diameter
    coin = cv2.bitwise_and(coins_image, coins_image, mask=coins_contours)
    plt.figure(figsize=(3, 3))
    plt.title(f'Coin {i+1}')
    plt.imshow(coin, cmap='gray')
    plt.scatter([cX], [cY], color='red')
    plt.text(cX, cY, f'{diameter}', color='red')
    plt.axis('off')
    plt.show()
    # Clear the mask for the next coin
    coins_contours = np.zeros_like(coins_image)

ε# Load the image
football_image = cv2.imread('/content/football.jpg')

# Function to apply k-means clustering
def kmeans_segmentation(image, k):
    pixel_values = image.reshape((-1, 3))
    pixel_values = np.float32(pixel_values)

    # Define criteria and apply k-means
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.2)
    _, labels, centers = cv2.kmeans(pixel_values, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)

    centers = np.uint8(centers)
    segmented_image = centers[labels.flatten()]
    segmented_image = segmented_image.reshape(image.shape)

    return segmented_image

# Apply k-means clustering for k = [2, 3, 4]
k_values = [2, 3, 4]

for k in k_values:
    segmented_image = kmeans_segmentation(football_image, k)
    plt.figure(figsize=(5, 5))
    plt.title(f'Segmented Image with k={k}')
    plt.imshow(cv2.cvtColor(segmented_image, cv2.COLOR_BGR2RGB))
    plt.axis('off')
    plt.show()