10

To create a program for segmentation of an image using watershed

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

# Load the image

img = cv2.imread('Coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Thresholding to find the markers

ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV +
cv2.THRESH_OTSU)

# Noise removal using morphological operations

kernel = np.ones((3,3), np.uint8)
opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations = 2)

# Background area determination

sure_bg = cv2.dilate(opening, kernel, iterations = 3)

# Foreground area determination

dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
ret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)

# Finding unknown region

sure_fg = np.uint8(sure_fg)
unknown = cv2.subtract(sure_bg, sure_fg)

# Marker labelling
ret, markers = cv2.connectedComponents(sure_fg)

# Add one to all labels so that sure background is not 0, but 1

markers = markers + 1

# Mark the region of unknown with zero

markers[unknown == 255] = 0

# Apply the watershed algorithm

markers = cv2.watershed(img, markers)
img[markers == -1] = [255, 0, 0]

# Display the result

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()
OUTPUT
9
To create a program performs discrete wavelet transform on image.
import pywt
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Function to perform DWT on an image

def discrete_wavelet_transform(image_path, wavelet='haar'):
# Read the image
img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

if img is None:
print("Error: Could not read the image. Please check the image path.")
return

# Perform Discrete Wavelet Transform

coeffs2 = pywt.dwt2(img, wavelet)
cA, (cH, cV, cD) = coeffs2

# Plot the results

fig = plt.figure(figsize=(12, 3))
titles = ['Approximation', ' Horizontal detail', 'Vertical detail', 'Diagonal
detail']
for i, a in enumerate([cA, cH, cV, cD]):
ax = fig.add_subplot(1, 4, i + 1)
ax.imshow(a, interpolation="nearest", cmap=plt.cm.gray)
ax.set_title(titles[i], fontsize=10)
ax.set_xticks([])
ax.set_yticks([])
fig.tight_layout()
plt.show()

# Path to the image file

image_path = '1.png' # Replace with the actual path to your image

# Perform DWT on the image

discrete_wavelet_transform(image_path)
OUTPUT
8
To obtain the R, B, G colour values and resolved colour values
from a colour box by choosing any colour.
import cv2
import numpy as np
from tkinter import Tk
from tkinter.colorchooser import askcolor

# Function to get RGB and resolved color values

def get_color_values():
# Open color chooser dialog
Tk().withdraw() # we don't want a full GUI, so keep the root window from
appearing
color_hex, color_rgb = askcolor()

if color_rgb is not None:

# Convert RGB to BGR for OpenCV
color_bgr = tuple(reversed(color_rgb))

# Create a 100x100 pixel BGR color box

color_box = np.zeros((100, 100, 3), dtype=np.uint8)
color_box[:] = color_bgr

# Display the color box

cv2.imshow('Color Box', color_box)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Print the RGB and resolved color values

print(f"Selected RGB Color: {color_rgb}")
print(f"Resolved Color (Hex): {color_hex}")
else:
print("No color was selected.")

# Call the function to get color values

get_color_values()
OUTPUT
2
To create a vision program to find histogram value and display
histograph of a grayscale and color image.
import cv2
import numpy as np
from matplotlib import pyplot as plt

# Function to calculate and plot histogram for grayscale image

def histogram_grayscale(image_path):
# Read the image in grayscale
gray_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Check if image is loaded correctly

if gray_image is None:
print("Error: Could not read the image. Please check the image path.")
return

# Calculate histogram using cv2.calcHist

hist = cv2.calcHist([gray_image], [0], None, [256], [0, 256])

# Plot histogram
plt.figure(figsize=(10, 4))
plt.title('Grayscale Histogram')
plt.xlabel('Bins')
plt.ylabel('# of Pixels')
plt.plot(hist)
plt.xlim([0, 256])
plt.show()

# Function to calculate and plot histogram for color image

def histogram_color(image_path):
# Read the image
image = cv2.imread(image_path)

# Check if image is loaded correctly

if image is None:
print("Error: Could not read the image. Please check the image path.")
return

# Convert to RGB
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
 # Calculate histograms for each channel
color = ('r', 'g', 'b')
for i, col in enumerate(color):
hist = cv2.calcHist([image], [i], None, [256], [0, 256])
plt.plot(hist, color=col)

# Plot histogram
plt.title('Color Histogram')
plt.xlabel('Bins')
plt.ylabel('# of Pixels')
plt.xlim([0, 256])
plt.show()

# Path to the grayscale image file

grayscale_image_path = 'Negative_image.jpg' # Replace with the actual path to
your grayscale image

# Path to the color image file

color_image_path = '1.png' # Replace with the actual path to your color image

# Calculate and plot histogram for grayscale image

histogram_grayscale(grayscale_image_path)

# Calculate and plot histogram for color image

histogram_color(color_image_path)
OUTPUT
7

To create a color image and perform read and write operation.

from PIL import Image
import matplotlib.pyplot as plt

# Create a new color image

width, height = 300, 200
color = (228, 150, 150) # RGB color tuple
img = Image.new('RGB', (width, height), color)

# Save the image to a file

img.save('color_image.png')

# Read the image back from the file

img_read = Image.open('color_image.png')

# Perform some operations (for example, rotate the image)

img_rotated = img_read.rotate(45)

# Save the rotated image to a file

img_rotated.save('color_image_rotated.png')

plt.subplot(1, 2, 1) # 1 row, 2 columns, 1st subplot

plt.imshow(img_read, cmap='gray')
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2) # 1 row, 2 columns, 2nd subplot

plt.imshow(img_rotated, cmap='gray')
plt.title('color_image_rotated')
plt.axis('off') # Hide axis labels and ticks

plt.show()
OUTPUT
4

To create a vision program to determine the edge detection of an

image using different operators.
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Load an image (replace "image.jpg" with the actual image file)

image_path = "1.png"
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Apply different edge detection operators

sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)
laplacian = cv2.Laplacian(image, cv2.CV_64F)
canny = cv2.Canny(image, 100, 200)

# Display the original image and edge-detected images

plt.figure(figsize=(12, 6))
plt.subplot(2, 3, 1), plt.imshow(image, cmap='gray'), plt.title('Original Image')
plt.subplot(2, 3, 2), plt.imshow(sobel_x, cmap='gray'), plt.title('Sobel X')
plt.subplot(2, 3, 3), plt.imshow(sobel_y, cmap='gray'), plt.title('Sobel Y')
plt.subplot(2, 3, 4), plt.imshow(laplacian, cmap='gray'), plt.title('Laplacian')
plt.subplot(2, 3, 5), plt.imshow(canny, cmap='gray'), plt.title('Canny')
plt.tight_layout()
plt.show()
OUTPUT
1

To create a program to display grayscale image using read and

write operation
import cv2

# Load a grayscale image (replace "image.jpg" with your image file)

image_path = "1.png"
gray_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Display the grayscale image

cv2.imshow("Grayscale Image", gray_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Save the grayscale image as "grayscale_output.jpg"

output_path = "grayscale_output.jpg"
cv2.imwrite(output_path, gray_image)
print(f"Grayscale image saved as {output_path}")
OUTPUT
3

To create a vision program for nonlinear filtering technique using

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

# Load a grayscale image (replace "image.jpg" with your image file)

image_path = "1.png"
gray_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Apply a median filter to reduce noise

filtered_image = cv2.medianBlur(gray_image, 5) # Use a 5x5 kernel size

# Display the original image and the filtered image

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1), plt.imshow(gray_image, cmap='gray'), plt.title('Original
Image')
plt.subplot(1, 2, 2), plt.imshow(filtered_image, cmap='gray'),
plt.title('Filtered Image')
plt.tight_layout()
plt.show()
OUTPUT
5

To create a program to discretize an image using Fourier

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

# Load an image (replace "image.jpg" with the actual image file)

image_path = "1.png"
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Perform 2D discrete Fourier transform

f_transform = np.fft.fft2(image)

# Shift the zero frequency component to the center

f_transform_shifted = np.fft.fftshift(f_transform)

# Compute the magnitude spectrum (log scale for visualization)

magnitude_spectrum = np.log(np.abs(f_transform_shifted) + 1)

# Display the original image and its magnitude spectrum

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1), plt.imshow(image, cmap='gray'), plt.title('Original Image')
plt.subplot(1, 2, 2), plt.imshow(magnitude_spectrum, cmap='gray'),
plt.title('Magnitude Spectrum')
plt.tight_layout()
plt.show()
OUTPUT
6

To create a program to eliminate the high frequency components of

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

# Load an image (replace "image.jpg" with the actual image file)

image_path = "1.png"
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Perform 2D discrete Fourier transform

f_transform = np.fft.fft2(image)

# Shift the zero frequency component to the center

f_transform_shifted = np.fft.fftshift(f_transform)

# Set a threshold to eliminate high-frequency components (e.g., keep only the

central region)
rows, cols = image.shape
center_row, center_col = rows // 2, cols // 2
radius = 30 # Adjust this value to control the amount of high-frequency removal

# Create a circular mask to keep the low-frequency components

mask = np.zeros((rows, cols), dtype=np.uint8)
mask[center_row - radius:center_row + radius, center_col - radius:center_col +
radius] = 1

# Apply the mask to the shifted Fourier transform

f_transform_filtered = f_transform_shifted * mask

# Shift the zero frequency component back to the corner

f_transform_filtered_shifted = np.fft.ifftshift(f_transform_filtered)

# Perform inverse 2D Fourier transform to get the filtered image

filtered_image = np.abs(np.fft.ifft2(f_transform_filtered_shifted))

# Display the original image and the filtered image

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1), plt.imshow(image, cmap='gray'), plt.title('Original Image')
plt.subplot(1, 2, 2), plt.imshow(filtered_image, cmap='gray'),
plt.title('Filtered Image')
plt.tight_layout()
plt.show()
OUTPUT