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)** on tehokas avoimen lähdekoodin kirjasto, joka on suunniteltu reaaliaikaiseen konenäköön ja kuvankäsittelyyn. Se tarjoaa työkaluja kuvien muokkaamiseen, objektien tunnistamiseen sekä syväoppimismallien kanssa työskentelyyn.

Määritelmä

## Kuvan lukeminen ja näyttäminen
Ennen muunnosten suorittamista ladataan ja näytetään kuva OpenCV:llä. Olemme jo tuoneet valokuvan. Paikallisella tietokoneellasi yksinkertaista lukemista ja näyttämistä varten käytä:

```
import cv2

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

## Kuvan koon muuttaminen

Koon muuttaminen on hyödyllistä, kun halutaan skaalata kuvia ylös- tai alaspäin säilyttäen **kuvasuhde** (`fx` ja `fy` -parametrit),
missä `fx` ja `fy` määrittävät leveyden ja korkeuden skaalauskertoimen.

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

Voit myös määrittää **tarkat pikselimitat** (`dsize`-parametri),
missä `dsize` on `(new_y, new_x)` tulosteen koko.

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

## Kuvan kierto
Kuvan kiertämiseen tietyn kulman verran käytetään funktioita `cv2.getRotationMatrix2D()` ja `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` määrittää kiertomatriisin;
- `cv2.warpAffine(image, matrix, output_size)` suorittaa muunnoksen.

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


## Kuvan rajaaminen
Rajaaminen poimii tietyn alueen kuvasta. Tämä tehdään NumPy-leikkauksella.
Syntaksi `image[start_y:end_y, start_x:end_x]` valitsee kiinnostusalueen.

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

Syvenny tietokonenäön maailmaan hallitsemalla konvoluutioneuroverkot (CNN:t) TensorFlow'n ja Kerasin avulla. Tämä edistynyt kurssi kattaa keskeiset käsitteet ja käytännön taidot, kuten kuvien esikäsittelyn, konvoluutio- ja poolausoperaatiot, CNN-arkkitehtuurien rakentamisen ja kouluttamisen, objektintunnistuksen toteuttamisen sekä siirto-oppimisen soveltamisen todellisiin visuaalisiin haasteisiin. Saat käytännön kokemusta monimutkaisten näköongelmien ratkaisemisesta alan standardityökaluilla ja -menetelmillä.

Perusmuunnokset

Kuvan lukeminen ja näyttäminen

Kuvan koon muuttaminen

Kuvan kierto

Kuvan rajaaminen

Ratkaisu