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-muunnos (FT)** on keskeinen matemaattinen työkalu, jota käytetään kuvankäsittelyssä kuvan taajuuskomponenttien analysointiin.

Määritelmä

Fourier-muunnoksen avulla voidaan muuntaa kuva **avaruudellisesta esityksestä** (jossa pikseliarvot esitetään suoraan) **taajuusalueelle** (jossa analysoidaan rakenteita ja kuvioita niiden taajuuden perusteella). Tämä on hyödyllistä esimerkiksi **kuvasuodatuksessa, reunojen tunnistuksessa ja kohinan vähentämisessä**.

Ensin kuva muunnetaan **harmaasävykuvaksi**:

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


Käytimme `COLOR_BGR2GRAY`, koska kuvat luetaan pääasiassa BGR-muodossa, joka on RGB:n käänteinen järjestys.

Huomio

**2D Fourier-muunnoksen** laskeminen:

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

Tässä `fft2()` muuntaa kuvan **avaruustasosta** **taajuustasoon**, ja `fftshift()` siirtää matalataajuiset komponentit keskelle.

**Suuruusspektrin** visualisointi:

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

Koska Fourier-muunnos tuottaa **kompleksilukuja**, otetaan **itseisarvot (`np.abs()`)** merkityksellisen visualisoinnin saamiseksi.

`np.log`-funktio parantaa näkyvyyttä, koska alkuperäiset suuruusarvot vaihtelevat huomattavasti mittakaavassa.


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

Syvenny tietokonenäön maailmaan hallitsemalla konvoluutioneuroverkot (CNN:t) TensorFlow'n ja Kerasin avulla. Tämä edistynyt kurssi kattaa keskeiset käsitteet ja käytännön taidot, kuten kuvien esikäsittelyn, konvoluutio- ja poolausoperaatiot, CNN-arkkitehtuurien rakentamisen ja kouluttamisen, objektintunnistuksen toteuttamisen sekä siirto-oppimisen soveltamisen todellisiin visuaalisiin haasteisiin. Saat käytännön kokemusta monimutkaisten näköongelmien ratkaisemisesta alan standardityökaluilla ja -menetelmillä.

Fourier-muunnos

Ratkaisu