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

Dette gjør det mulig å transformere et bilde fra **romdomenet** (der pikselverdier er representert direkte) til **frekvensdomenet** (der vi analyserer mønstre og strukturer basert på deres frekvens). Dette er nyttig for oppgaver som **bildefiltrering, kantdeteksjon og støyreduksjon**.

Først må vi konvertere bildet til **gråtoner**:


For å beregne **2D Fourier-transformasjonen**:

Her konverterer `fft2()` bildet fra **romdomenet** til **frekvensdomenet**, og `fftshift()` flytter lavfrekvente komponenter til sentrum.

For å visualisere **magnitudespesktret**:

Siden Fourier-transformasjonen gir **komplekse tall**, tar vi **absoluttverdiene (`np.abs()`)** for en meningsfull visualisering.

Funksjonen `np.log` forbedrer synligheten, ettersom råverdiene for størrelsen varierer mye 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 introduksjon til datamaskinsyn, med fokus på maskinell persepsjon og tolkning av visuelle data. Dekker bilde-forbehandling, funksjonsekstraksjon, objektdeteksjon og dyp læring-teknikker brukt i moderne synssystemer.

Datamaskinsyn gjør det mulig for maskiner å tolke og analysere visuelle data, og etterligner menneskelig persepsjon. Denne delen dekker grunnleggende bilderepresentasjon, fargemodeller og matematiske grunnprinsipper som er essensielle for å forstå hvordan datamaskiner behandler bilder. Du vil utforske virkelige anvendelser, fra autonome kjøretøy til medisinsk bildediagnostikk, og lære hvordan datamaskinsyn integreres med KI og maskinlæring.

OpenCV er et kraftig bibliotek for bildebehandling og oppgaver innen datamaskinsyn. Denne delen dekker grunnleggende teknikker som bildefiltrering, transformasjoner, kantdeteksjon og segmentering. Du vil lære hvordan man utfører uskarphet, terskling, konturdeteksjon og funksjonsekstraksjon for å forbedre og analysere bilder effektivt.

CNN-er behandler visuelle data ved hjelp av konvolusjon, pooling og aktiveringslag for å trekke ut egenskaper til oppgaver som bildeklassifisering og objektdeteksjon. Viktige komponenter inkluderer padding, konvolusjon for egenskapsuttrekking, pooling for reduksjon av kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver KI innen helsevesen, autonomi og sikkerhet.

Objektdeteksjon er en grunnleggende oppgave innen datamaskinsyn som innebærer å identifisere og lokalisere objekter i et bilde. I motsetning til bildeklassifisering, som tilordner én enkelt etikett til et helt bilde, klassifiserer objektdeteksjon ikke bare objekter, men bestemmer også deres posisjoner ved hjelp av avgrensningsbokser. Denne delen dekker sentrale teknikker og algoritmer brukt i objektdeteksjon, fra tradisjonelle metoder til dyp læringsbaserte tilnærminger som YOLO og U-Net.

Datamaskinsyn har utviklet seg betydelig over tid, fra grunnleggende bildebehandlingsmetoder til avanserte dyp læring-teknikker. Denne delen tar for seg de nyeste innovasjonene innen datamaskinsyn, med fokus på overføringslæring, ansiktsgjenkjenning og bildegenerering. Vi utforsker fordelene med forhåndstrente modeller for ytelse, prinsippene bak ansiktsgjenkjenningsteknologi og hvordan KI skaper bilder gjennom dyp læring.

Fourier-transformasjon

Løsning

Awesome!

Fourier-transformasjon

Løsning