Summary  
Applying a 2D Fast Fourier Transform to array data, shifting its zero-frequency components to the center, and computing a scaled magnitude spectrum using absolute values and logarithmic transformation.

General domain of usage  
Image processing

**Fourier-transformasjonen (FT)** er et grunnleggende matematisk verktøy som brukes i bildebehandling for å analysere frekvenskomponentene i et bilde.

Definisjon

Den lar oss 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**:

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


Vi brukte `COLOR_BGR2GRAY` fordi bilder hovedsakelig leses inn i BGR-format, som er motsatt av RGB.

Merk

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

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

Her konverterer `fft2()` bildet fra **romlig domene** til **frekvensdomene**, og `fftshift()` flytter lavfrekvente komponenter til sentrum.

For å visualisere **magnitudespesktret**:

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

Siden Fourier-transformasjonen gir **komplekse tall**, benyttes **absoluttverdier (`np.abs()`)** for meningsfull visualisering.

Funksjonen `np.log` forbedrer synligheten, ettersom rå magnitudeverdier 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

Fordyp deg i datamaskinsyn ved å mestre konvolusjonsnevrale nettverk (CNN) med TensorFlow og Keras. Dette avanserte kurset dekker sentrale konsepter og praktiske ferdigheter, inkludert bilde-forbehandling, konvolusjons- og pooling-operasjoner, bygging og trening av CNN-arkitekturer, implementering av objektdeteksjon og bruk av transfer learning for å løse reelle visuelle utfordringer. Få praktisk erfaring med å løse komplekse synsproblemer ved hjelp av bransjestandard verktøy og teknikker.

Fouriertransformasjon

Løsning