Hiermee kunnen we een afbeelding transformeren van het **ruimtelijk domein** (waar pixelwaarden direct worden weergegeven) naar het **frequentiedomein** (waar we patronen en structuren analyseren op basis van hun frequentie). Dit is nuttig voor taken zoals **beeldfiltering, randdetectie en ruisonderdrukking**.

Eerst moeten we de afbeelding omzetten naar **grijswaarden**:


Om de **2D Fourier-transformatie** te berekenen:

Hier zet `fft2()` de afbeelding om van het **ruimtelijk domein** naar het **frequentiedomein**, en verplaatst `fftshift()` de laagfrequente componenten naar het midden.

Om het **amplitudespectrum** te visualiseren:

Aangezien de Fourier-transformatie **complexe getallen** oplevert, nemen we de **absolute waarden (`np.abs()`)** voor een zinvolle visualisatie.

De functie `np.log` verbetert de zichtbaarheid, omdat de ruwe magnitudewaarden sterk in schaal variëren.


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

Uitgebreide introductie tot computervisie, met nadruk op machineperceptie en interpretatie van visuele data. Behandelt beeldvoorbewerking, kenmerkextractie, objectdetectie en deep learning-technieken die worden gebruikt in moderne visiesystemen.

Computer vision stelt machines in staat om visuele gegevens te interpreteren en analyseren, vergelijkbaar met menselijke waarneming. Deze sectie behandelt de basisprincipes van beeldrepresentatie, kleurmodellen en wiskundige fundamenten die essentieel zijn voor het begrijpen van hoe computers beelden verwerken. U verkent toepassingen in de praktijk, van autonome voertuigen tot medische beeldvorming, en ontdekt hoe computer vision integreert met AI en machine learning.

OpenCV is een krachtige bibliotheek voor beeldmanipulatie en computervisie-taken. Deze sectie behandelt essentiële technieken zoals beeldfiltering, transformaties, randdetectie en segmentatie. U leert hoe u vervaging, drempelbepaling, contourdetectie en kenmerkextractie uitvoert om beelden efficiënt te verbeteren en te analyseren.

CNN's verwerken visuele data met behulp van convolutie-, pooling- en activatielagen om kenmerken te extraheren voor taken zoals beeldclassificatie en objectdetectie. Belangrijke componenten zijn padding, convolutie voor kenmerkextractie, pooling voor complexiteitsreductie en activatie voor niet-lineariteit. Populaire architecturen zoals AlexNet, VGG en ResNet ondersteunen AI in de gezondheidszorg, autonomie en beveiliging.

Objectdetectie is een fundamentele taak binnen computer vision waarbij objecten in een afbeelding worden geïdentificeerd en gelokaliseerd. In tegenstelling tot beeldclassificatie, waarbij één label aan een volledige afbeelding wordt toegekend, classificeert objectdetectie niet alleen objecten, maar bepaalt ook hun posities met behulp van begrenzingskaders. Deze sectie behandelt belangrijke technieken en algoritmen die worden gebruikt bij objectdetectie, variërend van traditionele methoden tot deep learning-gebaseerde benaderingen zoals YOLO en U-Net.

Computer vision heeft zich in de loop der jaren aanzienlijk ontwikkeld, van eenvoudige beeldverwerkingstechnieken tot complexe deep learning-methoden. Deze sectie behandelt de nieuwste innovaties binnen computer vision, met de nadruk op transfer learning, gezichtsherkenning en beeldgeneratie. We onderzoeken de voordelen van voorgetrainde modellen voor de prestaties, de principes van gezichtsherkenningstechnologie en de wijze waarop AI beelden genereert via deep learning.

Fouriertransformatie

Oplossing

Fouriertransformatie

Oplossing