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

Sen avulla voidaan muuntaa kuva **avaruudellisesta alueesta** (jossa pikseliarvot esitetään suoraan) **taajuusalueelle** (jossa analysoidaan kuvioita ja rakenteita niiden taajuuden perusteella). Tämä on hyödyllistä tehtävissä kuten **kuvasuodatus, reunojen tunnistus ja kohinan vähentäminen**.

Ensiksi kuva täytyy muuntaa **harmaasävyksi**:


Tässä `fft2()` muuntaa kuvan **avaruudellisesta alueesta** **taajuusalueelle**, ja `fftshift()` siirtää matalataajuiset komponentit keskelle.

**Suuruusspektrin** visualisointi:

Koska Fourier-muunnos tuottaa **kompleksilukuja**, otetaan **itseisarvot (`np.abs()`)** mielekkään visualisoinnin saavuttamiseksi.

`np.log`-funktio parantaa näkyvyyttä, sillä alkuperäiset magnitudiarvot 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

Kattava johdatus konenäköön, keskittyen koneiden kykyyn havaita ja tulkita visuaalista dataa. Kattaa kuvien esikäsittelyn, piirteiden tunnistamisen, objektien havaitsemisen sekä syväoppimistekniikat, joita käytetään nykyaikaisissa näköjärjestelmissä.

Tietokonenäkö mahdollistaa koneiden visuaalisen datan tulkinnan ja analysoinnin ihmisen havainnointia jäljitellen. Tässä osiossa käsitellään kuvan esitystapojen, väritilojen ja matemaattisten perusteiden perusteita, jotka ovat olennaisia kuvankäsittelyn ymmärtämiseksi. Tutustutaan käytännön sovelluksiin, kuten autonomisiin ajoneuvoihin ja lääketieteelliseen kuvantamiseen, sekä siihen, miten tietokonenäkö yhdistyy tekoälyyn ja koneoppimiseen.

OpenCV on tehokas kirjasto kuvankäsittelyyn ja tietokonenäön tehtäviin. Tässä osiossa käsitellään keskeisiä tekniikoita, kuten kuvafiltteröintiä, muunnoksia, reunojen tunnistusta ja segmentointia. Opit suorittamaan kuvan sumentamista, kynnysarvojen asettamista, ääriviivojen tunnistusta ja piirteiden poimintaa kuvien parantamiseksi ja analysoimiseksi tehokkaasti.

CNN:t käsittelevät visuaalista dataa konvoluutio-, poolaus- ja aktivointikerrosten avulla piirteiden erottamiseksi tehtäviin, kuten kuvien luokitteluun ja objektien tunnistukseen. Keskeisiä osia ovat täydennys, konvoluutio piirteiden erottamiseen, poolaus monimutkaisuuden vähentämiseen ja aktivointi epälineaarisuuden tuomiseksi. Suositut arkkitehtuurit, kuten AlexNet, VGG ja ResNet, mahdollistavat tekoälyn käytön terveydenhuollossa, autonomiassa ja turvallisuudessa.

Esineentunnistus on tietokonenäön keskeinen tehtävä, jossa tunnistetaan ja paikannetaan esineitä kuvassa. Toisin kuin kuvien luokittelu, jossa koko kuvalle annetaan yksi luokka, esineentunnistus sekä luokittelee esineet että määrittää niiden sijainnit rajaavien laatikoiden avulla. Tässä osiossa käsitellään esineentunnistuksen keskeisiä tekniikoita ja algoritmeja, perinteisistä menetelmistä syväoppimiseen perustuviin lähestymistapoihin, kuten YOLO ja U-Net.

Konenäkö on kehittynyt merkittävästi vuosien varrella, siirtyen peruskuvankäsittelymenetelmistä monimutkaisiin syväoppimistekniikoihin. Tässä osiossa perehdytään konenäön viimeisimpiin innovaatioihin, keskittyen siirto-oppimiseen, kasvojentunnistukseen ja kuvien generointiin. Tarkastellaan esikoulutettujen mallien vaikutusta suorituskykyyn, kasvojentunnistusteknologian periaatteita sekä tapoja, joilla tekoäly luo kuvia syväoppimisen avulla.

Fourier-muunnos

Ratkaisu

Awesome!

Fourier-muunnos

Ratkaisu