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

**Fourier-transformen (FT)** er et grundlæggende matematisk værktøj, der anvendes i billedbehandling til at analysere frekvenskomponenterne i et billede.

Definition

Den gør det muligt at transformere et billede fra **rummet** (hvor pixelværdier er repræsenteret direkte) til **frekvensdomænet** (hvor vi analyserer mønstre og strukturer baseret på deres frekvens). Dette er nyttigt til opgaver som **billedfiltrering, kantdetektion og støjreduktion**.

Først skal vi konvertere billedet til **gråtoner**:

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


Vi brugte `COLOR_BGR2GRAY`, fordi billeder primært læses i BGR-format, hvilket er omvendt af RGB.

Bemærk

For at beregne **2D Fourier-transformen**:

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

Her konverterer `fft2()` billedet fra **rumdomænet** til **frekvensdomænet**, og `fftshift()` flytter lavfrekvente komponenter til midten.

For at visualisere **magnitudespektret**:

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

Da Fourier-transformen giver **komplekse tal** som output, tages **absolutte værdier (`np.abs()`)** for en meningsfuld visualisering.

Funktionen `np.log` forbedrer synligheden, da rå magnitudværdier varierer meget 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

Omfattende introduktion til Computer Vision med fokus på maskinens opfattelse og fortolkning af visuelle data. Dækker billedforbehandling, feature-ekstraktion, objektdetektion og dybdelæringsteknikker anvendt i moderne visionssystemer.

Computer vision gør det muligt for maskiner at fortolke og analysere visuelle data ved at efterligne menneskelig perception. Dette afsnit dækker grundlæggende billedrepræsentation, farvemodeller og matematiske fundamenter, som er essentielle for at forstå, hvordan computere behandler billeder. Du vil udforske virkelige anvendelser, fra autonome køretøjer til medicinsk billedbehandling, og få indsigt i, hvordan computer vision integreres med AI og maskinlæring.

OpenCV er et kraftfuldt bibliotek til billedmanipulation og computer vision-opgaver. Dette afsnit dækker væsentlige teknikker såsom billedfiltrering, transformationer, kantdetektion og segmentering. Du lærer at udføre sløring, tærskling, konturdetektion og feature-ekstraktion for at forbedre og analysere billeder effektivt.

CNN'er behandler visuelle data ved hjælp af konvolution, pooling og aktiveringslag for at udtrække træk til opgaver som billedklassificering og objektdetektion. Centrale komponenter omfatter padding, konvolution til trækudtrækning, pooling til reduktion af kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver AI inden for sundhedspleje, autonomi og sikkerhed.

Objektdetektion er en grundlæggende opgave inden for computer vision, der omfatter identifikation og lokalisering af objekter i et billede. I modsætning til billedklassificering, som tildeler en enkelt etiket til et helt billede, klassificerer objektdetektion ikke kun objekter, men bestemmer også deres positioner ved hjælp af afgrænsningsbokse. Dette afsnit dækker centrale teknikker og algoritmer anvendt i objektdetektion, fra traditionelle metoder til dybdelæringsbaserede tilgange som YOLO og U-Net.

Computer vision har gennemgået betydelige fremskridt gennem årene, fra grundlæggende billedbehandlingsmetoder til avancerede deep learning-teknikker. Dette afsnit undersøger de nyeste innovationer inden for computer vision med fokus på transfer learning, ansigtsgenkendelse og billedgenerering. Vi udforsker fordelene ved prætrænede modeller for ydeevne, principperne bag ansigtsgenkendelsesteknologi samt hvordan AI skaber billeder ved hjælp af deep learning.

Fourier-transformering

Løsning

Awesome!

Fourier-transformering

Løsning