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

**Fouriertransformen (FT)** är ett grundläggande matematiskt verktyg som används inom bildbehandling för att analysera frekvenskomponenterna i en bild.

Definition

Den möjliggör omvandling av en bild från **rumsdomänen** (där pixelvärden representeras direkt) till **frekvensdomänen** (där mönster och strukturer analyseras 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**:

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


Vi använde `COLOR_BGR2GRAY` eftersom bilder huvudsakligen läses in i BGR-format, vilket är omvänt mot RGB.

Notering

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

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

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

För att visualisera **magnitudspektrumet**:

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

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

Funktionen `np.log` förbättrar synligheten, eftersom råa magnitudvärden 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 och djupinlärningstekniker som används i moderna visionssystem.

Datorseende möjliggör för maskiner att tolka och analysera visuella 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 får utforska tillämpningar i verkliga världen, 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 utfyllnad, 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 som YOLO och U-Net.

Datorseende har utvecklats avsevärt genom å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