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

## Lese og vise et bilde
Før du utfører transformasjoner, må vi først laste inn og vise et bilde ved hjelp av OpenCV. Vi har allerede importert bildet. Men på din lokale datamaskin, for enkel lesing og visning av bildet, bør du bruke:

## Endre størrelse på et bilde

Endring av størrelse er nyttig for å skalere bilder opp eller ned samtidig som **forholdet** (`fx` og `fy` parametere) opprettholdes,
hvor `fx` og `fy` definerer skaleringsfaktoren for bredde og høyde.

Du kan også angi **eksakte piksel-dimensjoner** (`dsize` parameter),
hvor `dsize` er `(new_y, new_x)` utdataform.

## Rotere et bilde
For å rotere et bilde med en bestemt vinkel, brukes `cv2.getRotationMatrix2D()` og `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` definerer rotasjonsmatrisen;
- `cv2.warpAffine(image, matrix, output_size)` utfører transformasjonen.


## Beskjære et bilde
Beskjæring henter ut et spesifikt område fra et bilde. Dette gjøres med NumPy-slicing.
Syntaksen `image[start_y:end_y, start_x:end_x]` velger 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 introduksjon til datamaskinsyn, med fokus på maskinell persepsjon og tolkning av visuelle data. Dekker bilde-forbehandling, funksjonsekstraksjon, objektdeteksjon og dyp læring-teknikker brukt i moderne synssystemer.

Datamaskinsyn gjør det mulig for maskiner å tolke og analysere visuelle data, og etterligner menneskelig persepsjon. Denne delen dekker grunnleggende bilderepresentasjon, fargemodeller og matematiske grunnprinsipper som er essensielle for å forstå hvordan datamaskiner behandler bilder. Du vil utforske virkelige anvendelser, fra autonome kjøretøy til medisinsk bildediagnostikk, og lære hvordan datamaskinsyn integreres med KI og maskinlæring.

OpenCV er et kraftig bibliotek for bildebehandling og oppgaver innen datamaskinsyn. Denne delen dekker grunnleggende teknikker som bildefiltrering, transformasjoner, kantdeteksjon og segmentering. Du vil lære hvordan man utfører uskarphet, terskling, konturdeteksjon og funksjonsekstraksjon for å forbedre og analysere bilder effektivt.

CNN-er behandler visuelle data ved hjelp av konvolusjon, pooling og aktiveringslag for å trekke ut egenskaper til oppgaver som bildeklassifisering og objektdeteksjon. Viktige komponenter inkluderer padding, konvolusjon for egenskapsuttrekking, pooling for reduksjon av kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver KI innen helsevesen, autonomi og sikkerhet.

Objektdeteksjon er en grunnleggende oppgave innen datamaskinsyn som innebærer å identifisere og lokalisere objekter i et bilde. I motsetning til bildeklassifisering, som tilordner én enkelt etikett til et helt bilde, klassifiserer objektdeteksjon ikke bare objekter, men bestemmer også deres posisjoner ved hjelp av avgrensningsbokser. Denne delen dekker sentrale teknikker og algoritmer brukt i objektdeteksjon, fra tradisjonelle metoder til dyp læringsbaserte tilnærminger som YOLO og U-Net.

Datamaskinsyn har utviklet seg betydelig over tid, fra grunnleggende bildebehandlingsmetoder til avanserte dyp læring-teknikker. Denne delen tar for seg de nyeste innovasjonene innen datamaskinsyn, med fokus på overføringslæring, ansiktsgjenkjenning og bildegenerering. Vi utforsker fordelene med forhåndstrente modeller for ytelse, prinsippene bak ansiktsgjenkjenningsteknologi og hvordan KI skaper bilder gjennom dyp læring.

Grunnleggende Transformasjoner

Lese og vise et bilde

Endre størrelse på et bilde

Rotere et bilde

Beskjære et bilde