Summary  
The chapter explains how to compute a 2D Fourier transform of array data using NumPy’s fft2 and fftshift functions, then derive and scale the magnitude spectrum via abs and log for visualization.  

General domain of usage  
Image processing

Elle permet de transformer une image du **domaine spatial** (où les valeurs des pixels sont représentées directement) vers le **domaine fréquentiel** (où l’on analyse les motifs et structures selon leur fréquence). Ceci est utile pour des tâches telles que le **filtrage d’image, la détection de contours et la réduction du bruit**.

Tout d’abord, il faut convertir l’image en **niveaux de gris** :


Pour calculer la **transformée de Fourier 2D** :

Ici, `fft2()` convertit l’image du **domaine spatial** au **domaine fréquentiel**, et `fftshift()` déplace les composantes basses fréquences vers le centre.

Pour visualiser le **spectre de magnitude** :

Étant donné que la transformée de Fourier produit des **nombres complexes**, il est nécessaire de prendre les **valeurs absolues (`np.abs()`)** pour obtenir une visualisation significative.

La fonction `np.log` améliore la visibilité, car les valeurs de magnitude brutes varient fortement en échelle.


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

Introduction complète à la vision par ordinateur, axée sur la perception et l'interprétation automatique des données visuelles. Couvre le prétraitement d'images, l'extraction de caractéristiques, la détection d'objets et les techniques d'apprentissage profond utilisées dans les systèmes de vision modernes.

La vision par ordinateur permet aux machines d'interpréter et d'analyser des données visuelles, en imitant la perception humaine. Cette section aborde les bases de la représentation des images, les modèles de couleur et les fondements mathématiques essentiels pour comprendre comment les ordinateurs traitent les images. Vous découvrirez des applications concrètes, allant des véhicules autonomes à l'imagerie médicale, et comprendrez comment la vision par ordinateur s'intègre à l'IA et à l'apprentissage automatique.

OpenCV est une bibliothèque puissante pour la manipulation d'images et les tâches de vision par ordinateur. Cette section couvre des techniques essentielles telles que le filtrage d'images, les transformations, la détection de contours et la segmentation. Vous apprendrez à effectuer le floutage, le seuillage, la détection de contours et l'extraction de caractéristiques afin d'améliorer et d'analyser efficacement les images.

Les CNN traitent les données visuelles à l'aide de couches de convolution, de regroupement et d'activation afin d'extraire des caractéristiques pour des tâches telles que la classification d'images et la détection d'objets. Les éléments clés comprennent le remplissage, la convolution pour l'extraction de caractéristiques, le regroupement pour la réduction de la complexité et l'activation pour l'introduction de la non-linéarité. Des architectures populaires telles qu'AlexNet, VGG et ResNet alimentent l'IA dans les domaines de la santé, de l'autonomie et de la sécurité.

La détection d'objets est une tâche fondamentale de la vision par ordinateur qui consiste à identifier et localiser des objets dans une image. Contrairement à la classification d'images, qui attribue une seule étiquette à une image entière, la détection d'objets permet non seulement de classifier les objets, mais aussi de déterminer leur position à l'aide de boîtes englobantes. Cette section aborde les principales techniques et algorithmes utilisés en détection d'objets, allant des méthodes traditionnelles aux approches basées sur l'apprentissage profond telles que YOLO et U-Net.

La vision par ordinateur a considérablement progressé au fil des années, passant de méthodes de traitement d'image basiques à des techniques complexes d'apprentissage profond. Cette section examine les dernières innovations en vision par ordinateur, en mettant l'accent sur l'apprentissage par transfert, la reconnaissance faciale et la génération d'images. Nous explorerons les avantages des modèles pré-entraînés sur les performances, les principes de la technologie de reconnaissance faciale et la manière dont l'IA crée des images grâce à l'apprentissage profond.

Transformée de Fourier

Solution

Awesome!

Transformée de Fourier

Solution