Summary  
This chapter covers how to load an image as a multidimensional array and perform basic geometric transformations—resizing with scaling factors or exact dimensions, rotating via affine matrices, and cropping through array slicing.  

General domain of usage  
Image processing

**OpenCV (Open Source Computer Vision Library)** is een krachtig open-source pakket ontworpen voor real-time computer vision en beeldverwerking. Het biedt hulpmiddelen voor het manipuleren van afbeeldingen, het detecteren van objecten en zelfs het werken met deep learning-modellen.

Definitie

## Een afbeelding lezen en weergeven
Voordat transformaties worden uitgevoerd, eerst een afbeelding laden en weergeven met OpenCV. De foto is al geïmporteerd. Maar op uw lokale computer gebruikt u voor het eenvoudig lezen en weergeven van de foto:

```
import cv2

image = cv2.imread('path/to/image.jpg')
cv2.imshow('Image title', image)
```

## Een afbeelding schalen

Schalen is nuttig voor het vergroten of verkleinen van afbeeldingen met behoud van de **verhouding** (`fx` en `fy` parameters),
waarbij `fx` en `fy` de schaalfactor voor breedte en hoogte bepalen.

```
resized_image = cv2.resize(image, fx=0.7, fy=0.5)
```

Het is ook mogelijk om **exacte pixeldimensies** op te geven (parameter `dsize`),
waarbij `dsize` de uitvoervorm `(new_y, new_x)` is.

```
resized = cv2.resize(image, (100, 100))
```

## Een afbeelding roteren
Voor het roteren van een afbeelding met een specifieke hoek wordt gebruikgemaakt van `cv2.getRotationMatrix2D()` en `cv2.warpAffine()`.

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

```
height, width = image.shape[:2]
centre = (width // 2, height // 2)

rotation_matrix = cv2.getRotationMatrix2D(centre, 180, 1)
rotated = cv2.warpAffine(image, rotation_matrix, (width, height))
```


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

```
cropped = image[450:500, 250:350]
```

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

Verdiep je in computer vision door het beheersen van convolutionele neurale netwerken (CNN's) met TensorFlow en Keras. Deze gevorderde cursus behandelt essentiële concepten en praktische vaardigheden, waaronder beeldvoorbewerking, convolutie- en poolingoperaties, het opbouwen en trainen van CNN-architecturen, het implementeren van objectdetectie en het toepassen van transfer learning om visuele uitdagingen uit de praktijk aan te pakken. Doe praktijkervaring op met het oplossen van complexe vision-problemen met behulp van industriestandaard tools en technieken.

Basistransformaties

Een afbeelding lezen en weergeven

Een afbeelding schalen

Een afbeelding roteren

Een afbeelding bijsnijden

Oplossing