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

Det möjliggör att vi kan transformera en bild från **rumsdomänen** (där pixelvärden representeras direkt) till **frekvensdomänen** (där vi analyserar mönster och strukturer baserat på deras frekvens). Detta är användbart för uppgifter som **bildfiltrering, kantdetektion och brusreducering**.

Först behöver vi konvertera bilden till **gråskala**:


För att beräkna **2D-Fouriertransformen**:

Här konverterar `fft2()` bilden från **rumsdomänen** till **frekvensdomänen**, och `fftshift()` flyttar lågfrekventa komponenter till mitten.

För att visualisera **magnitudspektrumet**:

Eftersom Fouriertransformen ger **komplexa tal** tar vi **absolutvärdena (`np.abs()`)** för en meningsfull visualisering.

Funktionen `np.log` förbättrar synligheten, eftersom de ursprungliga magnitudvärdena varierar kraftigt i skala.


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

Omfattande introduktion till datorseende med fokus på maskinell perception och tolkning av visuella data. Täcker bildförbehandling, funktionsutvinning, objektdetektering samt djupinlärningstekniker som används i moderna seendesystem.

Datorseende möjliggör för maskiner att tolka och analysera visuell data, vilket efterliknar mänsklig perception. Detta avsnitt behandlar grunderna i bildrepresentation, färgmodeller och matematiska grunder som är nödvändiga för att förstå hur datorer bearbetar bilder. Du kommer att utforska verkliga tillämpningar, från autonoma fordon till medicinsk bildbehandling, samt hur datorseende integreras med AI och maskininlärning.

OpenCV är ett kraftfullt bibliotek för bildmanipulation och datorseendeuppgifter. Detta avsnitt behandlar grundläggande tekniker såsom bildfiltrering, transformationer, kantdetektion och segmentering. Du får kunskap om hur man utför suddning, tröskling, konturdetektion och funktionsutvinning för att effektivt förbättra och analysera bilder.

CNN bearbetar visuella data med hjälp av konvolution, pooling och aktiveringslager för att extrahera egenskaper för uppgifter som bildklassificering och objektigenkänning. Viktiga komponenter inkluderar padding, konvolution för egenskapsutvinning, pooling för komplexitetsreduktion och aktivering för icke-linjäritet. Populära arkitekturer som AlexNet, VGG och ResNet driver AI inom hälso- och sjukvård, autonomi och säkerhet.

Objektdetektering är en grundläggande uppgift inom datorseende som innebär att identifiera och lokalisera objekt i en bild. Till skillnad från bildklassificering, som tilldelar en enda etikett till en hel bild, klassificerar objektdetektering inte bara objekt utan bestämmer även deras positioner med hjälp av avgränsningsrutor. Detta avsnitt behandlar centrala tekniker och algoritmer som används vid objektdetektering, från traditionella metoder till djupinlärningsbaserade tillvägagångssätt såsom YOLO och U-Net.

Datorseende har utvecklats avsevärt under åren, från grundläggande bildbehandlingsmetoder till avancerade djupinlärningstekniker. Detta avsnitt behandlar de senaste innovationerna inom datorseende, med fokus på transferinlärning, ansiktsigenkänning och bildgenerering. Vi undersöker fördelarna med förtränade modeller för prestanda, principerna bakom ansiktsigenkänningsteknik samt hur AI skapar bilder med hjälp av djupinlärning.

Fouriertransform

Lösning

Awesome!

Fouriertransform

Lösning