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

Die **Fourier-Transformation (FT)** ist ein grundlegendes mathematisches Werkzeug, das in der Bildverarbeitung verwendet wird, um die Frequenzkomponenten eines Bildes zu analysieren.

Definition

Sie ermöglicht die Umwandlung eines Bildes vom **Ortsbereich** (in dem die Pixelwerte direkt dargestellt werden) in den **Frequenzbereich** (in dem Muster und Strukturen anhand ihrer Frequenz analysiert werden). Dies ist nützlich für Aufgaben wie **Bildfilterung, Kantenerkennung und Rauschunterdrückung**.

Zunächst muss das Bild in **Graustufen** umgewandelt werden:

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


Wir verwenden `COLOR_BGR2GRAY`, da Bilder hauptsächlich im BGR-Format eingelesen werden, was die umgekehrte Reihenfolge von RGB ist.

Hinweis

Berechnung der **2D-Fourier-Transformation**:

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

Hier wandelt `fft2()` das Bild vom **Ortsbereich** in den **Frequenzbereich** um, und `fftshift()` verschiebt die niederfrequenten Komponenten in das Zentrum.

Visualisierung des **Betragsspektrums**:

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

Da die Fourier-Transformation **komplexe Zahlen** liefert, werden für eine sinnvolle Visualisierung die **Betragswerte (`np.abs()`)** verwendet.

Die Funktion `np.log` verbessert die Sichtbarkeit, da die Rohwerte des Betrags stark variieren können.


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

Tauchen Sie tief in das Gebiet des Computer Vision ein, indem Sie Convolutional Neural Networks (CNNs) mit TensorFlow und Keras beherrschen. Dieser fortgeschrittene Kurs behandelt grundlegende Konzepte und praktische Fähigkeiten, einschließlich Bildvorverarbeitung, Faltungs- und Pooling-Operationen, Aufbau und Training von CNN-Architekturen, Implementierung von Objekterkennung sowie Anwendung von Transfer Learning zur Lösung realer visueller Herausforderungen. Sammeln Sie praktische Erfahrungen bei der Lösung komplexer Vision-Probleme mit branchenüblichen Werkzeugen und Techniken.