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)** ist eine leistungsstarke Open-Source-Bibliothek, die für Echtzeit-Computer Vision und Bildverarbeitung entwickelt wurde. Sie bietet Werkzeuge zur Bildmanipulation, Objekterkennung und sogar zur Arbeit mit Deep-Learning-Modellen.

Definition

## Einlesen und Anzeigen eines Bildes
Bevor Transformationen durchgeführt werden, muss zunächst ein Bild mit OpenCV geladen und angezeigt werden. Das Foto wurde bereits importiert. Auf Ihrem lokalen Computer sollten Sie zum einfachen Einlesen und Anzeigen des Fotos Folgendes verwenden:

```
import cv2

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

## Skalieren eines Bildes

Das Skalieren ist nützlich, um Bilder zu vergrößern oder zu verkleinern, während das Seitenverhältnis (**ratio**) beibehalten wird (`fx`- und `fy`-Parameter),
wobei `fx` und `fy` den Skalierungsfaktor für Breite und Höhe definieren.

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

Es können auch **exakte Pixelabmessungen** (Parameter `dsize`) angegeben werden,
wobei `dsize` die Ausgabedimensionen `(new_y, new_x)` festlegt.

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

## Bildrotation
Um ein Bild um einen bestimmten Winkel zu drehen, werden `cv2.getRotationMatrix2D()` und `cv2.warpAffine()` verwendet.

- `cv2.getRotationMatrix2D(center, angle, scale)` definiert die Rotationsmatrix;
- `cv2.warpAffine(image, matrix, output_size)` wendet die Transformation an.

```
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))
```


## Bildausschnitt (Cropping)
Das Zuschneiden extrahiert einen bestimmten Bereich aus einem Bild. Dies erfolgt mittels NumPy-Slicing.
Die Syntax `image[start_y:end_y, start_x:end_x]` wählt einen gewünschten Bereich aus.

```
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

Tauchen Sie tief in das Gebiet des Computer Vision ein, indem Sie Convolutional Neural Networks (CNNs) mit TensorFlow und Keras beherrschen. Dieser fortgeschrittene Kurs behandelt grundlegende Konzepte und praktische Fähigkeiten, einschließlich Bildvorverarbeitung, Faltungs- und Pooling-Operationen, Aufbau und Training von CNN-Architekturen, Implementierung von Objekterkennung sowie Anwendung von Transfer Learning zur Lösung realer visueller Herausforderungen. Sammeln Sie praktische Erfahrungen bei der Lösung komplexer Vision-Probleme mit branchenüblichen Werkzeugen und Techniken.

Grundlegende Transformationen

Einlesen und Anzeigen eines Bildes

Skalieren eines Bildes

Bildrotation

Bildausschnitt (Cropping)

Lösung