Summary  
This chapter demonstrates how to load and display image data and apply fundamental geometric transformations—resizing (by scale factors or explicit dimensions), rotating (using affine matrices), and cropping (via array slicing).  

General domain of usage  
Computer vision

## Een afbeelding lezen en weergeven
Voordat we transformaties uitvoeren, laden en tonen we eerst een afbeelding met OpenCV. We hebben de foto al geïmporteerd. Maar op je lokale computer gebruik je voor het eenvoudig lezen en weergeven van de foto het volgende:

## Een afbeelding schalen

Schalen is handig om afbeeldingen te vergroten of te verkleinen met behoud van de **beeldverhouding** (`fx` en `fy` parameters),
waarbij `fx` en `fy` de schaalfactoren voor breedte en hoogte bepalen.

Je kunt ook **exacte pixeldimensies** opgeven (`dsize` parameter),
waarbij `dsize` de uitvoervorm `(new_y, new_x)` is.

## Een afbeelding roteren
Om een afbeelding met een specifieke hoek te roteren, gebruiken we `cv2.getRotationMatrix2D()` en `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` definieert de rotatiematrix;
- `cv2.warpAffine(image, matrix, output_size)` past de transformatie toe.


## Een afbeelding bijsnijden
Bijsnijden haalt een specifiek gebied uit een afbeelding. Dit gebeurt met NumPy-slicing.
De syntaxis `image[start_y:end_y, start_x:end_x]` selecteert een interessegebied.


import unittest
import importlib
import numpy as np
import cv2

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 = {
            'image': np.ndarray,
            'resized': np.ndarray,
            'rotation_matrix': np.ndarray,
            'rotated': np.ndarray,
            'cropped': 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_resized_image_shape(self):
        """Check that the resized image has the correct shape (100, 100)."""
        expected_shape = (100, 100)
        actual_shape = user_code.resized.shape[:2]

        _dynamic_test(
            self,
            actual_shape == expected_shape,
            f"The resized image has the correct shape {expected_shape}.",
            f"Expected resized image shape {expected_shape}, but got {actual_shape}."
        )

    def test_rotation_matrix_correctness(self):
        """Check that the rotation matrix is correctly computed."""
        height, width = user_code.image.shape[:2]
        expected_matrix = cv2.getRotationMatrix2D((width // 2, height // 2), 90, 1)

        try:
            np.testing.assert_array_almost_equal(user_code.rotation_matrix, expected_matrix, decimal=5)
            condition = True
            success_message = "The rotation matrix matches the expected values."
            failure_message = "Rotation matrix mismatch (values differ)."
        except AssertionError:
            condition = False
            success_message = "Rotation matrix check unexpectedly passed."  # needed to avoid UnboundLocalError
            failure_message = "Rotation matrix mismatch (values differ)."

        _dynamic_test(
            self,
            condition,
            success_message,
            failure_message
        )

    def test_rotated_image_shape_matches_original(self):
        """Check that the rotated image shape matches the original image shape."""
        original_shape = user_code.image.shape
        rotated_shape = user_code.rotated.shape

        _dynamic_test(
            self,
            original_shape == rotated_shape,
            "The rotated image shape matches the original image shape.",
            f"Expected rotated image shape {original_shape}, but got {rotated_shape}."
        )

    def test_cropped_image_shape_correctness(self):
        """Check that the cropped image has the correct dimensions."""
        cropped_height, cropped_width = user_code.cropped.shape[:2]
        expected_shape = (450 - 100, 600 - 250)

        _dynamic_test(
            self,
            (cropped_height, cropped_width) == expected_shape,
            f"The cropped image has the correct dimensions {expected_shape}.",
            f"Expected cropped image dimensions {expected_shape}, but got {(cropped_height, cropped_width)}."
        )

    def test_cropped_image_pixel_values(self):
        """Check that the cropped image matches the expected pixel values."""
        expected_cropped = user_code.image[100:450, 250:600]

        try:
            np.testing.assert_array_equal(user_code.cropped, expected_cropped)
            condition = True
            success_message = "The cropped image contains the correct pixel values."
            failure_message = "Cropped pixel values mismatch (values differ)."
        except AssertionError:
            condition = False
            success_message = "Cropped pixel values check unexpectedly passed."
            failure_message = "Cropped pixel values mismatch (values differ)."

        _dynamic_test(
            self,
            condition,
            success_message,
            failure_message
        )

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.

Basistransformaties

Een afbeelding lezen en weergeven

Een afbeelding schalen

Een afbeelding roteren

Een afbeelding bijsnijden