IVP Lab

i. Image Negation:

import cv2

import numpy as np

# Load an image from file

image = cv2.imread('food.jpg')

# Ensure the image is not None

if image is not None:

    # Negate the image

    negated_image = 255 - image

    # Display the original and negated images (optional)

    cv2.imshow('Original Image', image)

    cv2.imshow('Negated Image', negated_image)

    # Save the negated image

    cv2.imwrite('negated_image.jpg', negated_image)

    # Wait for a key press and close windows

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("Error loading the image.")

ii. Thresholding:

import cv2

import numpy as np

# Load an image from file in grayscale

image = cv2.imread('cameraman.jpg', cv2.IMREAD_GRAYSCALE)

# Ensure the image is not None

if image is not None:

    # Set a threshold value (you may need to adjust this based on your image)

    threshold_value = 127

    # Apply thresholding

    _, thresholded_image = cv2.threshold(image, threshold_value, 255, cv2.THRESH_BINARY)

    # Display the original and thresholded images (optional)

    cv2.imshow('Original Image', image)

    cv2.imshow('Thresholded Image', thresholded_image)

    # Save the thresholded image

    cv2.imwrite('thresholded_image.jpg', thresholded_image)

    # Wait for a key press and close windows

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("Error loading the image.")

iii. Gray level slicing:

import cv2

# Load an image from file

image = cv2.imread('food.jpg')

# Convert the image to grayscale

gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

# Save the grayscale image

cv2.imwrite('grayscale_image.jpg', gray_image)

# Display the original and grayscale images (optional)

cv2.imshow('Original Image', image)

cv2.imshow('Grayscale Image', gray_image)

cv2.waitKey(0)

cv2.destroyAllWindows()

iv. Bit plane slicing:

import cv2

import numpy as np

# Load an image from file in grayscale

image = cv2.imread('cameraman.jpg', cv2.IMREAD_GRAYSCALE)

# Ensure the image is not None

if image is not None:

    # Get the height and width of the image

    height, width = image.shape

    # Initialize an array to store the bit planes

    bit_planes = np.zeros((8, height, width), dtype=np.uint8)

    # Iterate through each bit position (from 0 to 7)

    for bit_position in range(8):

        # Extract the bit plane by masking with 2^bit_position

        bit_planes[bit_position] = (image >> bit_position) & 1

        # Convert the bit plane to a 0-255 range for visualization

        bit_planes[bit_position] *= 255

        # Display the bit plane (optional)

        cv2.imshow(f'Bit Plane {bit_position}', bit_planes[bit_position])

    # Wait for a key press and close windows

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("Error loading the image.")

v. Darkening and Lightning of image:

import cv2

import numpy as np

# Load an image from file

image = cv2.imread('cameraman1.jpg')

# Ensure the image is not None

if image is not None:

    # Define a constant value for darkening or lightening

    brightness_change = 50  # You can adjust this value based on your needs

    # Darken the image

    darkened_image = np.clip(image - brightness_change, 0, 255)

    # Lighten the image

    lightened_image = np.clip(image + brightness_change, 0, 255)

    # Display the original, darkened, and lightened images (optional)

    cv2.imshow('Original Image', image)

    cv2.imshow('Darkened Image', darkened_image.astype(np.uint8))

    cv2.imshow('Lightened Image', lightened_image.astype(np.uint8))

    # Save the darkened and lightened images

    cv2.imwrite('darkened_image.jpg', darkened_image.astype(np.uint8))

    cv2.imwrite('lightened_image.jpg', lightened_image.astype(np.uint8))

    # Wait for a key press and close windows

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("Error loading the image.")

import cv2

import numpy as np

# Read the input image

image = cv2.imread('F:/PCET/TY B.Tech/Image and Video Processing/IVP_Lab/cameraman.jpg')

# Ensure the image is not None

if image is not None:

    # Apply the average filter with a kernel size of 5x5

    average_filter = cv2.blur(image, (5, 5))

    median_filter = cv2.medianBlur(image, 5)

    gaussian_image = cv2.GaussianBlur(image, (5, 5), 0)

    # Apply Laplacian filter

    laplacian = cv2.Laplacian(image, cv2.CV_64F)

    # Convert the result to uint8 and normalize

    laplacian = cv2.convertScaleAbs(laplacian)

    kernel = np.array(  [[-1, -1, -1],

                        [-1,  8, -1],

                        [-1, -1, -1]]   )

    # Apply the high boost filter

    high_boost_image = cv2.filter2D(image, -1, kernel)

    # Display the original and filtered images

    cv2.imshow('Original Image', image)

    cv2.imshow('Average_filter', average_filter)

    cv2.imshow('Median_filter', median_filter)

    cv2.imshow('Gaussian_image', gaussian_image)

    cv2.imshow('Laplacian_image', laplacian)

    cv2.imshow('High Boost Filtered Image', high_boost_image)

    cv2.waitKey(0)

    cv2.destroyAllWindows()

else:

    print("Error loading the image.")

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load the image

image = cv2.imread('F:/PCET/TY B.Tech/Sem2/Image and Video Processing/IVP_Lab/cameraman.jpg', cv2.IMREAD_GRAYSCALE)

# Perform histogram equalization

equalized_image = cv2.equalizeHist(image)

# Plot histograms

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

plt.subplot(1, 2, 1)

plt.hist(image.flatten(), 256, [0, 256], color='b')

plt.title('Original Image Histogram')

plt.subplot(1, 2, 2)

plt.hist(equalized_image.flatten(), 256, [0, 256], color='r')

plt.title('Equalized Image Histogram')

plt.show()

# Display original and equalized images

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

plt.subplot(1, 2, 1)

plt.imshow(image, cmap='gray')

plt.title('Original Image')

plt.axis('off')

plt.subplot(1, 2, 2)

plt.imshow(equalized_image, cmap='gray')

plt.title('Equalized Image')

plt.axis('off')

plt.show()

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Load the image

image = cv2.imread('F:/PCET/TY B.Tech/Sem2/Image and Video Processing/IVP_Lab/cameraman.jpg', cv2.IMREAD_GRAYSCALE)

# Apply Sobel operator

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

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

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

# Apply Prewitt operator

prewitt_x = cv2.filter2D(image, -1, np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]))

prewitt_y = cv2.filter2D(image, -1, np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]]))

prewitt = np.sqrt(prewitt_x**2 + prewitt_y**2)

# Apply Roberts operator

roberts_x = cv2.filter2D(image, -1, np.array([[1, 0], [0, -1]]))

roberts_y = cv2.filter2D(image, -1, np.array([[0, 1], [-1, 0]]))

roberts = np.sqrt(roberts_x**2 + roberts_y**2)

# Plotting the results

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

plt.subplot(2, 2, 1)

plt.imshow(image, cmap='gray')

plt.title('Original Image')

plt.axis('off')

plt.subplot(2, 2, 2)

plt.imshow(sobel, cmap='gray')

plt.title('Sobel Edge Detection')

plt.axis('off')

plt.subplot(2, 2, 3)

plt.imshow(prewitt, cmap='gray')

plt.title('Prewitt Edge Detection')

plt.axis('off')

plt.subplot(2, 2, 4)

plt.imshow(roberts, cmap='gray')

plt.title('Roberts Edge Detection')

plt.axis('off')

plt.show()

import cv2

import numpy as np

def compress_image(img, block_size=8, quality=50):

    # Convert image to grayscale

    if len(img.shape) == 3:

        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Pad image to make its dimensions multiples of block size

    h, w = img.shape

    padded_h = ((h + block_size - 1) // block_size) * block_size

    padded_w = ((w + block_size - 1) // block_size) * block_size

    padded_img = np.zeros((padded_h, padded_w), dtype=np.uint8)

    padded_img[:h, :w] = img

    # Apply DCT to each block

    dct_img = np.zeros_like(padded_img, dtype=np.float32)

    for y in range(0, padded_h, block_size):

        for x in range(0, padded_w, block_size):

            block = padded_img[y:y+block_size, x:x+block_size].astype(np.float32)

            dct_block = cv2.dct(block)

            dct_img[y:y+block_size, x:x+block_size] = dct_block

    # Quantization

    quantization_matrix = np.array([[16, 11, 10, 16, 24, 40, 51, 61],

                                    [12, 12, 14, 19, 26, 58, 60, 55],

                                    [14, 13, 16, 24, 40, 57, 69, 56],

                                    [14, 17, 22, 29, 51, 87, 80, 62],

                                    [18, 22, 37, 56, 68, 109, 103, 77],

                                    [24, 35, 55, 64, 81, 104, 113, 92],

                                    [49, 64, 78, 87, 103, 121, 120, 101],

                                    [72, 92, 95, 98, 112, 100, 103, 99]])

    quantized_img = np.zeros_like(dct_img, dtype=np.float32)

    for y in range(0, padded_h, block_size):

        for x in range(0, padded_w, block_size):

            dct_block = dct_img[y:y+block_size, x:x+block_size]

            quantized_block = np.round(dct_block / (quantization_matrix * (float(quality) / 100)))

            quantized_img[y:y+block_size, x:x+block_size] = quantized_block

    # Compression: Store only significant coefficients

    # Reconstruction

    reconstructed_img = np.zeros_like(quantized_img, dtype=np.uint8)

    for y in range(0, padded_h, block_size):

        for x in range(0, padded_w, block_size):

            quantized_block = quantized_img[y:y+block_size, x:x+block_size]

            idct_block = cv2.idct(quantized_block)

            reconstructed_img[y:y+block_size, x:x+block_size] = idct_block

    return reconstructed_img[:h, :w]

# Load image

image = cv2.imread("F:/PCET/TY B.Tech/Sem2/Image and Video Processing/IVP_Lab/cameraman.jpg")

# Compress image

compressed_image = compress_image(image)

# Normalize pixel values to [0, 255]

compressed_image_normalized = cv2.normalize(compressed_image, None, 0, 255, cv2.NORM_MINMAX)

# Display original and compressed images

cv2.imshow("Original Image", image)

cv2.imshow("Compressed Image", compressed_image_normalized)

cv2.waitKey(0)

cv2.destroyAllWindows()

import cv2

# Function to apply point processing method to a frame

def point_processing(frame):

    # Example: Convert to grayscale

    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Apply additional point processing methods as needed

    return gray_frame

# Input and output video filenames

input_video_filename = "F:/PCET/TY B.Tech/Sem2/Image and Video Processing/IVP_Lab/input_video1.mp4"

output_video_filename = "output_video.mp4"

# Open the video file

video_capture = cv2.VideoCapture(input_video_filename)

# Get video properties

frame_width = int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH))

frame_height = int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT))

frame_rate = int(video_capture.get(cv2.CAP_PROP_FPS))

frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))

# Define the codec and create VideoWriter object

fourcc = cv2.VideoWriter_fourcc(*'mp4v')

output_video = cv2.VideoWriter(output_video_filename, fourcc, frame_rate, (frame_width, frame_height))

# Process each frame in the video

while True:

    # Read a frame from the video

    ret, frame = video_capture.read()

    # If no frame is retrieved, break the loop

    if not ret:

        break

    # Apply point processing method to the frame

    processed_frame = point_processing(frame)

    # Write the processed frame to the output video

    output_video.write(processed_frame)

    # Display the processed frame (optional)

    cv2.imshow('Processed Frame', processed_frame)

    if cv2.waitKey(10) & 0xFF == ord('q'):

        break

# Release video objects

video_capture.release()

output_video.release()

cv2.destroyAllWindows()