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

Permette di trasformare un'immagine dal **dominio spaziale** (dove i valori dei pixel sono rappresentati direttamente) al **dominio delle frequenze** (dove analizziamo pattern e strutture in base alla loro frequenza). Questo è utile per attività come **filtraggio delle immagini, rilevamento dei bordi e riduzione del rumore**.

Per prima cosa, è necessario convertire l'immagine in **scala di grigi**:


Per calcolare la **trasformata di Fourier 2D**:

Qui, `fft2()` converte l'immagine dal **dominio spaziale** al **dominio delle frequenze**, e `fftshift()` sposta le componenti a bassa frequenza al centro.

Per visualizzare lo **spettro di magnitudine**:

Poiché la trasformata di Fourier restituisce **numeri complessi**, si utilizzano i **valori assoluti (`np.abs()`)** per una visualizzazione significativa.

La funzione `np.log` migliora la visibilità, poiché i valori di magnitudo grezzi variano notevolmente in scala.


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

Introduzione completa alla computer vision, con particolare attenzione alla percezione e interpretazione automatica dei dati visivi. Include la pre-elaborazione delle immagini, l'estrazione delle caratteristiche, il rilevamento degli oggetti e le tecniche di deep learning utilizzate nei sistemi di visione moderni.

La computer vision consente alle macchine di interpretare e analizzare dati visivi, imitando la percezione umana. Questa sezione tratta le basi della rappresentazione delle immagini, dei modelli di colore e delle fondamenta matematiche essenziali per comprendere come i computer elaborano le immagini. Verranno esplorate applicazioni reali, dai veicoli autonomi all'imaging medico, e verrà illustrato come la computer vision si integri con l'AI e il machine learning.

OpenCV è una potente libreria per la manipolazione delle immagini e le attività di computer vision. Questa sezione tratta tecniche essenziali come il filtraggio delle immagini, le trasformazioni, il rilevamento dei bordi e la segmentazione. Verranno illustrate operazioni di sfocatura, thresholding, rilevamento dei contorni ed estrazione delle caratteristiche per migliorare e analizzare le immagini in modo efficiente.

Le CNN elaborano dati visivi utilizzando strati di convoluzione, pooling e attivazione per estrarre caratteristiche utili in compiti come la classificazione delle immagini e il rilevamento degli oggetti. I componenti chiave includono il padding, la convoluzione per l'estrazione delle caratteristiche, il pooling per la riduzione della complessità e l'attivazione per introdurre non linearità. Architetture popolari come AlexNet, VGG e ResNet alimentano l'IA nei settori sanitario, dell'autonomia e della sicurezza.

Il rilevamento oggetti è un compito fondamentale nella computer vision che consiste nell'identificare e localizzare oggetti all'interno di un'immagine. A differenza della classificazione delle immagini, che assegna un'unica etichetta all'intera immagine, il rilevamento oggetti non solo classifica gli oggetti ma ne determina anche le posizioni utilizzando riquadri di delimitazione. Questa sezione tratta le principali tecniche e algoritmi utilizzati nel rilevamento oggetti, dai metodi tradizionali agli approcci basati su deep learning come YOLO e U-Net.

La computer vision ha compiuto notevoli progressi nel corso degli anni, passando da metodi di elaborazione delle immagini di base a tecniche complesse di deep learning. Questa sezione approfondisce le ultime innovazioni nella computer vision, concentrandosi su transfer learning, riconoscimento facciale e generazione di immagini. Verranno esaminati i vantaggi dei modelli pre-addestrati sulle prestazioni, i principi della tecnologia di riconoscimento facciale e il modo in cui l'IA crea immagini tramite deep learning.

Trasformata di Fourier

Soluzione

Awesome!

Trasformata di Fourier

Soluzione

Awesome!