5 Best Ways to Find Discrete Cosine Transform of an Image using OpenCV Python

by

💡 Problem Formulation: The Discrete Cosine Transform (DCT) is a technique used to convert spatial domain data into frequency domain data. This is particularly useful in image processing for tasks such as image compression. We assume the reader has an input image and wants to apply DCT to obtain the transformed image data. The expected output is a transformed image represented in the frequency domain.

Method 1: Using OpenCV’s dct() Function

The first method involves utilizing the dct() function provided by the OpenCV library. This function takes a single- or multi-channel array and performs a forward or inverse discrete cosine transform on every individual channel. The image needs to be converted to a floating-point type before the transform since the DCT operation requires this.

Here’s an example:

import cv2
import numpy as np

# Load image in grayscale
image = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)

# Convert image to float32
f_image = np.float32(image)

# Perform the DCT
dct_image = cv2.dct(f_image)

# Display the DCT
cv2.imshow('DCT', dct_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output should be the visual representation of the frequency domain for the given image.

This code snippet reads an image in grayscale, converts it to float32, and performs the DCT using OpenCV’s dct() function. Finally, it shows the resulting image, which is a visual representation of the DCT output. Remember to handle the window display properly using OpenCV’s window management functions.

Method 2: Applying DCT on Blocks

To avoid artifacts at the edges in block processing, this method computes the DCT on blocks (tiles) of the image and is great for JPEG compression simulation. The dct() operation is applied on each block separately to better handle local variations in the image.

Here’s an example:

import cv2
import numpy as np

# Definition for block-wise DCT
def blockwise_dct(image, block_size=8):
    h, w = image.shape[:2]
    dct_blocks = np.zeros_like(image, dtype=np.float32)
    for i in range(0, h, block_size):
        for j in range(0, w, block_size):
            block = image[i:i+block_size, j:j+block_size]
            f_block = np.float32(block)
            dct_blocks[i:i+block_size, j:j+block_size] = cv2.dct(f_block)
    return dct_blocks

# Load and apply blockwise DCT
image = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
dct_image = blockwise_dct(image)

# Show result
cv2.imshow('DCT', dct_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output should be the DCT-transformed blocks of the grayscale image.

This code defines a function to take an image and perform DCT on each block of a specified size, which is useful when localized frequency components are needed. This technique mimics the process used in JPEG compression where images are transformed in 8×8 blocks.

Method 3: Using DCT for Image Compression

This method uses the DCT to simulate an image compression. It transforms the image with the DCT, zeros out small coefficients which are less significant, and then performs the inverse DCT to retrieve a compressed version of the image, albeit with some loss of detail.

Here’s an example:

import cv2
import numpy as np

# Load image as grayscale and convert to float32
image = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
f_image = np.float32(image)

# Perform DCT
dct_image = cv2.dct(f_image)

# Zero out small DCT coefficients
threshold = 0.01
dct_image[np.abs(dct_image) < threshold] = 0

# Perform inverse DCT to get the compressed image
comp_image = cv2.idct(dct_image)

# Display the compressed image
cv2.imshow('Compressed Image', comp_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is a compressed version of the original grayscale image with some detail loss.

The code does a forward DCT transform, zeroes out coefficients smaller than a threshold (to simulate compression), then performs an inverse DCT to get the compressed image. The compression quality can be adjusted by changing the threshold value.

Method 4: DCT to Enhance High-Frequency Details

DCT can also be used to enhance high-frequency details by amplifying the high-frequency components of the DCT transformed image. This method is particularly useful in improving the sharpness of images.

Here’s an example:

import cv2
import numpy as np

# Load the image as grayscale and convert to float32
image = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
f_image = np.float32(image)

# Perform DCT
dct_image = cv2.dct(f_image)

# Amplify high-frequency components
dct_image *= 2

# Perform inverse DCT
enhanced_image = cv2.idct(dct_image)

# Display the enhanced image
cv2.imshow('Enhanced Image', enhanced_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is an image with sharpened high-frequency details.

By amplifying the high-frequency components after performing the DCT, this code effectively sharpens the image. An inverse DCT is applied to obtain the enhanced image, which will have more prominent high-frequency details compared to the original.

Bonus One-Liner Method 5: Discrete Cosine Transformation in a Nutshell

This method showcases a one-liner to perform a DCT on an image using NumPy’s built-in DCT function. It’s quick and efficient but lacks the flexibility of the OpenCV-based methods.

Here’s an example:

import cv2
from scipy.fftpack import dct

# Load the image, convert to float32 and apply DCT in one line
dct_image = dct(dct(cv2.imread('input.jpg',cv2.IMREAD_GRAYSCALE).astype(np.float32).T, norm='ortho').T, norm='ortho')

# Output the result
print(dct_image)

The output is a 2D array representing the DCT of the image.

This code reads the image in grayscale, converts it to float32, and applies a two-dimensional DCT using scipy’s dct() function. It’s a succinct method for getting a quick DCT; however, this method will not easily allow for partial or inverse transformations as OpenCV methods do.

Summary/Discussion

  • Method 1: Using OpenCV’s dct() Function. Strengths: Simple and straightforward. Weaknesses: May be less efficient than block processing for large images due to edge effects.
  • Method 2: Applying DCT on Blocks. Strengths: Mimics JPEG-like processing and is good for localized frequency analysis. Weaknesses: More complex implementation and may require additional computations.
  • Method 3: Using DCT for Image Compression. Strengths: Demonstrates DCT’s application for compression with adjustable quality. Weaknesses: Lossy compression may not be suitable for all applications.
  • Method 4: DCT to Enhance High-Frequency Details. Strengths: Enhances image details and sharpness. Weaknesses: Amplification of noise and potential for artifacts.
  • Method 5: One-Liner Method. Strengths: Quick and concise. Weaknesses: Less control and requires additional library (scipy).