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

## Læsning og visning af et billede
Før du udfører transformationer, skal vi først indlæse og vise et billede ved hjælp af OpenCV. Vi har allerede importeret billedet. Men på din lokale computer skal du for simpel læsning og visning af billedet bruge:

## Ændring af billedstørrelse

Ændring af størrelse er nyttigt til at skalere billeder op eller ned, mens billedets **forhold** (`fx` og `fy` parametre) bevares,
hvor `fx` og `fy` definerer skaleringsfaktoren for bredde og højde.

Du kan også angive **præcise pixeldimensioner** (`dsize` parameter),
hvor `dsize` er `(new_y, new_x)` outputform.

## Rotering af et billede
For at rotere et billede med en bestemt vinkel anvendes `cv2.getRotationMatrix2D()` og `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` definerer rotationsmatricen;
- `cv2.warpAffine(image, matrix, output_size)` anvender transformationen.


## Beskæring af et billede
Beskæring udtrækker et specifikt område fra et billede. Dette udføres ved hjælp af NumPy-slicing.
Syntaksen `image[start_y:end_y, start_x:end_x]` vælger et interesseområde.


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

Omfattende introduktion til computer vision med fokus på maskinopfattelse og fortolkning af visuelle data. Dækker billedforbehandling, feature-ekstraktion, objektdetektion og dybdelæringsteknikker anvendt i moderne visionssystemer.

Computer vision gør det muligt for maskiner at fortolke og analysere visuelle data ved at efterligne menneskelig perception. Dette afsnit dækker grundlæggende billedrepræsentation, farvemodeller og matematiske fundamenter, der er essentielle for at forstå, hvordan computere behandler billeder. Du vil udforske virkelige anvendelser, fra autonome køretøjer til medicinsk billedbehandling, og se, hvordan computer vision integreres med AI og maskinlæring.

OpenCV er et kraftfuldt bibliotek til billedmanipulation og computer vision-opgaver. Dette afsnit dækker essentielle teknikker såsom billedfiltrering, transformationer, kantdetektion og segmentering. Du lærer at udføre sløring, tærskling, konturdetektion og feature-ekstraktion for effektivt at forbedre og analysere billeder.

CNN'er behandler visuelle data ved hjælp af konvolution, pooling og aktiveringslag for at udtrække funktioner til opgaver som billedklassificering og objektdetektion. Centrale komponenter omfatter padding, konvolution til feature-ekstraktion, pooling til reduktion af kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver AI inden for sundhedspleje, autonomi og sikkerhed.

Objektdetektion er en grundlæggende opgave inden for computer vision, der omfatter identifikation og lokalisering af objekter i et billede. I modsætning til billedklassificering, som tildeler en enkelt etiket til et helt billede, klassificerer objektdetektion ikke kun objekter, men bestemmer også deres positioner ved hjælp af afgrænsningsbokse. Dette afsnit dækker centrale teknikker og algoritmer anvendt i objektdetektion, fra traditionelle metoder til dybdelæringsbaserede tilgange som YOLO og U-Net.

Computervision har udviklet sig markant gennem årene, fra grundlæggende billedbehandlingsmetoder til avancerede dybdelæringsteknikker. Dette afsnit undersøger de nyeste innovationer inden for computervision med fokus på transfer learning, ansigtsgenkendelse og billedgenerering. Vi udforsker fordelene ved prætrænede modeller for ydeevne, principperne bag ansigtsgenkendelsesteknologi samt hvordan AI skaber billeder gennem dyb læring.

Grundlæggende Transformationer

Læsning og visning af et billede

Ændring af billedstørrelse

Rotering af et billede

Beskæring af et billede