Summary
This chapter demonstrates how to compute and manipulate the 2D Fourier transform of a data array using library routines, including centering frequency components and deriving a log-scaled magnitude spectrum from complex outputs.

General domain of usage
Image processing

The **Fourier transform (FT)** is a fundamental mathematical tool used in image processing to analyze the frequency components of an image.

Definition

It allows us to transform an image from the **spatial domain** (where pixel values are represented directly) to the **frequency domain** (where we analyze patterns and structures based on their frequency). This is useful for tasks like **image filtering, edge detection, and noise reduction**.

First, we need to convert the image to **grayscale**:

```
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
```


We used `COLOR_BGR2GRAY` because images are primarily read in BGR format, which is the reverse of RGB.

Note

To compute the **2D Fourier transform**:

```
dft = np.fft.fft2(image)
dft_shift = np.fft.fftshift(dft)
```

Here, `fft2()` converts the image from the **spatial domain** to the **frequency domain**, and `fftshift()` moves low-frequency components to the center.

To visualize the **magnitude spectrum**:

```
magnitude_spectrum = 20 * np.log(np.abs(dft_shift))
```

Since Fourier transform outputs **complex numbers**, we take the **absolute values (`np.abs()`)** for a meaningful visualization.

The `np.log` function enhances visibility, as raw magnitude values vary greatly in scale.


import unittest
import numpy as np
import cv2
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestImageProcessing(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")
    
    def test_variables_existence_and_types(self):
        """Check all necessary variables are declared and have correct types."""

        variables_to_check = {
            'gray_image': np.ndarray,
            'dft': np.ndarray,
            'dft_shift': np.ndarray,
            'magnitude_spectrum': np.ndarray
        }

        for var_name, expected_type in variables_to_check.items():
            with self.subTest(variable=var_name):
                var = getattr(user_code, var_name, None)
                condition = var is not None and isinstance(var, expected_type)
                if var is None:
                    failure_message = f"The variable `{var_name}` is not declared."
                elif not isinstance(var, expected_type):
                    failure_message = f"The variable `{var_name}` should be of type `{expected_type.__name__}`, but got `{type(var).__name__}`."
                else:
                    failure_message = ""
                _dynamic_test(
                    self,
                    condition,
                    f"The variable `{var_name}` exists and has the correct type `{expected_type.__name__}`.",
                    failure_message
                )

    def test_grayscale_conversion(self):
        """Check if the image is correctly converted to grayscale."""
        condition = len(user_code.gray_image.shape) == 2
        _dynamic_test(
            self,
            condition,
            "Grayscale image has 2 dimensions.",
            "Grayscale image should have 2 dimensions."
        )
    
    def test_dft_computation(self):
        """Check if the DFT is computed and has the correct shape."""
        condition = user_code.dft.shape == user_code.gray_image.shape
        _dynamic_test(
            self,
            condition,
            "DFT has the same shape as the grayscale image.",
            "DFT should have the same shape as the grayscale image."
        )
    
    def test_dft_shift_computation(self):
        """Check if the DFT shift is correctly computed."""
        condition = user_code.dft_shift.shape == user_code.dft.shape
        _dynamic_test(
            self,
            condition,
            "DFT shift has the same shape as the DFT.",
            "DFT shift should have the same shape as the DFT."
        )
    
    def test_magnitude_spectrum_computation(self):
        """Check if the magnitude spectrum is computed correctly."""
        condition = user_code.magnitude_spectrum.shape == user_code.gray_image.shape
        _dynamic_test(
            self,
            condition,
            "Magnitude spectrum has the same shape as the grayscale image.",
            "Magnitude spectrum should have the same shape as the grayscale image."
        )
    
    def test_magnitude_spectrum_values(self):
        """Ensure the magnitude spectrum contains valid values."""
        condition = np.all(user_code.magnitude_spectrum >= 0)
        _dynamic_test(
            self,
            condition,
            "Magnitude spectrum contains non-negative values.",
            "Magnitude spectrum should contain non-negative values."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Comprehensive introduction to Computer Vision, focusing on machine perception and interpretation of visual data. Covers image preprocessing, feature extraction, object detection, and deep learning techniques used in modern vision systems.

Computer vision enables machines to interpret and analyze visual data, mimicking human perception. This section covers the basics of image representation, color models, and mathematical foundations essential for understanding how computers process images. You'll explore real-world applications, from autonomous vehicles to medical imaging, and learn how Computer vision integrates with AI and machine learning. 

OpenCV is a powerful library for image manipulation and computer vision tasks. This section covers essential techniques like image filtering, transformations, edge detection, and segmentation. You'll learn how to perform blurring, thresholding, contour detection, and feature extraction to enhance and analyze images efficiently.

CNNs process visual data using convolution, pooling, and activation layers to extract features for tasks like image classification and object detection. Key components include padding, convolution for feature extraction, pooling for complexity reduction, and activation for non-linearity. Popular architectures like AlexNet, VGG, and ResNet power AI in healthcare, autonomy, and security.

Object detection is a fundamental task in computer vision that involves identifying and localizing objects within an image. Unlike image classification, which assigns a single label to an entire image, object detection not only classifies objects but also determines their positions using bounding boxes. This section covers key techniques and algorithms used in object detection, ranging from traditional methods to deep learning-based approaches like YOLO and U-Net.

Computer vision has significantly advanced over the years, shifting from basic image processing methods to complex deep learning techniques. This section delves into the latest innovations in computer vision, focusing on transfer learning, facial recognition, and image generation. We will explore the benefits of pre-trained models on performance, the principles of facial recognition technology, and the way AI creates images through deep learning.

Fourier Transform

Solution

Awesome!

Fourier Transform

Solution