1. Point-to-point transformation.

This laboratory experiment provides for thresholding an image

Ans. Certainly! The point-to-point transformation, thresholding, and histogram equalization are
fundamental image processing techniques that can be implemented using various programming
languages and libraries. I'll provide examples using Python and the OpenCV library.

### 1. Point-to-Point Transformation:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply point-to-point transformation (example: contrast adjustment)

alpha = 1.5 # Scaling factor

beta = 30 # Brightness offset

transformed_image = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)

# Display the original and transformed images

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

plt.subplot(1, 2, 2), plt.imshow(transformed_image, cmap='gray'), plt.title('Transformed Image')

plt.show()

```

Replace 'path/to/your/image.jpg' with the actual path to your image file. This example adjusts the
contrast and brightness using the point-to-point transformation.

### 2. Thresholding and Histogram:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image
image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply thresholding

_, binary_image = cv2.threshold(image, 128, 255, cv2.THRESH_BINARY)

# Compute and plot the histogram

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

plt.plot(hist)

plt.title('Original Image Histogram')

plt.show()

# Display the original and binary images

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

plt.subplot(1, 2, 2), plt.imshow(binary_image, cmap='gray'), plt.title('Binary Image (Thresholded)')

plt.show()

```

Replace 'path/to/your/image.jpg' with the actual path to your image file. This example applies a simple
binary thresholding technique.

### 3. Histogram Equalization:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply histogram equalization

equalized_image = cv2.equalizeHist(image)

# Compute and plot the histograms

hist_original = cv2.calcHist([image], [0], None, [256], [0, 256])

hist_equalized = cv2.calcHist([equalized_image], [0], None, [256], [0, 256])

# Display the original and equalized images

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

plt.subplot(2, 2, 3), plt.imshow(equalized_image, cmap='gray'), plt.title('Equalized Image')

plt.subplot(2, 2, 4), plt.plot(hist_equalized), plt.title('Equalized Image Histogram')

plt.show()

```

Replace 'path/to/your/image.jpg' with the actual path to your image file. This example applies histogram
equalization to enhance the contrast of the image.

These examples use the OpenCV library for image processing. Ensure you have OpenCV installed:

```bash

pip install opencv-python

```

Feel free to adjust the parameters and explore more sophisticated image processing techniques based
on your specific needs.
 2. Geometric transformations. This experiment shows image rotation, scaling, and translation. Two-
dimensional Fourier transform.

Ans. Certainly! Geometric transformations, including rotation, scaling, and translation, are common
operations in image processing. Additionally, the two-dimensional Fourier transform is a powerful tool
for analyzing the frequency components of an image. I'll provide examples using Python and the OpenCV
library.

### 1. Image Rotation, Scaling, and Translation:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg')

# Rotation

rows, cols = image.shape[:2]

rotation_matrix = cv2.getRotationMatrix2D((cols/2, rows/2), 45, 1) # Rotate by 45 degrees

rotated_image = cv2.warpAffine(image, rotation_matrix, (cols, rows))

# Scaling

scaling_factor = 1.5

scaled_image = cv2.resize(image, None, fx=scaling_factor, fy=scaling_factor)

# Translation

translation_matrix = np.float32([[1, 0, 50], [0, 1, 30]]) # Translate by (50, 30) pixels

translated_image = cv2.warpAffine(image, translation_matrix, (cols, rows))

# Display the original and transformed images

plt.subplot(2, 2, 1), plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)), plt.title('Original Image')

plt.subplot(2, 2, 2), plt.imshow(cv2.cvtColor(rotated_image, cv2.COLOR_BGR2RGB)), plt.title('Rotated

plt.subplot(2, 2, 3), plt.imshow(cv2.cvtColor(scaled_image, cv2.COLOR_BGR2RGB)), plt.title('Scaled

plt.subplot(2, 2, 4), plt.imshow(cv2.cvtColor(translated_image, cv2.COLOR_BGR2RGB)),

```

Replace 'path/to/your/image.jpg' with the actual path to your image file. This example demonstrates
rotation by 45 degrees, scaling by a factor of 1.5, and translation by (50, 30) pixels.

### 2. Two-Dimensional Fourier Transform:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Compute the 2D Fourier Transform

fourier_transform = np.fft.fft2(image)

magnitude_spectrum = np.log(np.abs(fourier_transform) + 1) # Log transform for better visualization

# Display the original image and its magnitude spectrum

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.show()

```

Replace 'path/to/your/image.jpg' with the actual path to your grayscale image file. This example
computes the 2D Fourier Transform and displays the original image and its magnitude spectrum.

These examples use the OpenCV library for image processing. Ensure you have OpenCV installed:

```bash

pip install opencv-python

```

Feel free to modify the parameters and explore further geometric transformations and Fourier
transform-based analyses based on your specific requirements.
 3. Linear filtering using convolution. Highly selective filters.

Ans. Linear filtering using convolution is a common technique in image processing. Highly selective filters
are filters designed to enhance or suppress specific features in an image. Let's implement linear filtering
with selective filters using Python and the OpenCV library.

### Linear Filtering with Convolution:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Define a Gaussian filter (Example: Highly selective filter for blurring)

gaussian_filter = np.array([[1, 4, 6, 4, 1],

[4, 16, 24, 16, 4],

[6, 24, 36, 24, 6],

[4, 16, 24, 16, 4],

[1, 4, 6, 4, 1]]) / 256

# Apply convolution with the Gaussian filter

filtered_image = cv2.filter2D(image, -1, gaussian_filter)

# Display the original and filtered images

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.show()

```
Replace 'path/to/your/image.jpg' with the actual path to your image file. This example uses a Gaussian
filter for blurring, which is a commonly used highly selective filter.

You can design different filters for various purposes, such as edge detection, sharpening, or smoothing,
based on the specific features you want to enhance or suppress.

### Highly Selective Filter Example: Edge Detection (Sobel Filter):

```python
import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply Sobel filter for edge detection

sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)

sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)

magnitude = np.sqrt(sobel_x**2 + sobel_y**2)

# Display the original and edge-detected images

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

plt.subplot(1, 2, 2), plt.imshow(magnitude, cmap='gray'), plt.title('Edge-Detected Image')

plt.show()

```

This example uses the Sobel filter for edge detection. You can adjust the filter parameters based on your
requirements.

Feel free to experiment with different filters and their parameters to achieve the desired effects.
 4. Ideal filters in the frequency domain. Non Linear filtering using convolutional masks. Edge
detection. This experiment enables students to understand the concept of edge detectors
and their operation in noisy images.

Ans. Certainly! Edge detection is a crucial task in image processing, and ideal filters in the frequency
domain can be used for this purpose. Additionally, non-linear filtering using convolutional masks can
enhance the results, especially in the presence of noise. I'll provide examples using Python and the
OpenCV library.

### Ideal Filters in the Frequency Domain:

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Compute the 2D Fourier Transform

fourier_transform = np.fft.fft2(image)

frequencies = np.fft.fftshift(fourier_transform)

# Create an ideal high-pass filter

rows, cols = image.shape

center_row, center_col = rows // 2, cols // 2

radius = 30 # Adjust the radius based on your requirements

mask = np.ones((rows, cols), np.uint8)

cv2.circle(mask, (center_col, center_row), radius, 0, -1)

# Apply the ideal high-pass filter

frequencies_high_pass = frequencies * mask

filtered_image_high_pass = np.fft.ifft2(np.fft.ifftshift(frequencies_high_pass)).real

# Display the original and filtered images

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

plt.subplot(1, 2, 2), plt.imshow(filtered_image_high_pass, cmap='gray'), plt.title('Filtered Image (High

plt.show()
```

Replace 'path/to/your/image.jpg' with the actual path to your image file. This example demonstrates the
application of an ideal high-pass filter in the frequency domain for edge enhancement.

### Non-Linear Filtering for Edge Detection (Using Laplacian Mask):

```python

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load an image

image = cv2.imread('path/to/your/image.jpg', cv2.IMREAD_GRAYSCALE)

# Apply a Laplacian mask for edge detection

laplacian_mask = np.array([[0, 1, 0],

[1, -4, 1],

[0, 1, 0]])

filtered_image_laplacian = cv2.filter2D(image, -1, laplacian_mask)

# Display the original and filtered images

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

plt.subplot(1, 2, 2), plt.imshow(filtered_image_laplacian, cmap='gray'), plt.title('Edge-Detected Image

plt.show()

```

This example applies a Laplacian mask using convolution for edge detection. You can experiment with
other non-linear filters such as the Sobel operator, Prewitt operator, etc.

Feel free to adjust parameters, experiment with different masks, and explore more non-linear filters to
understand their effects on edge detection in noisy images.