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 gør det muligt for os at transformere et billede fra **rumdomænet** (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**:


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

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

For at visualisere **magnitudspektret**:

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

Funktionen `np.log` forbedrer synligheden, da de rå størrelsesværdier varierer betydeligt 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å maskinopfattelse 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, der er essentielle for at forstå, hvordan computere behandler billeder. Du vil udforske virkelige anvendelser, fra autonome køretøjer til medicinsk billedbehandling, og se, hvordan computer vision integreres med AI og maskinlæring.

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

CNN'er behandler visuelle data ved hjælp af konvolution, pooling og aktiveringslag for at udtrække funktioner til opgaver som billedklassificering og objektdetektion. Centrale komponenter omfatter padding, konvolution til feature-ekstraktion, 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.

Computervision har udviklet sig markant gennem årene, fra grundlæggende billedbehandlingsmetoder til avancerede dybdelæringsteknikker. Dette afsnit undersøger de nyeste innovationer inden for computervision 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 gennem dyb læring.

Fourier-transformering

Løsning

Awesome!

Fourier-transformering

Løsning