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

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

## Kuvan koon muuttaminen

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

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

## Kuvan kiertäminen
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.


## 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.


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

Kattava johdatus konenäköön, keskittyen koneiden kykyyn havaita ja tulkita visuaalista dataa. Kattaa kuvien esikäsittelyn, piirteiden tunnistamisen, objektien havaitsemisen sekä syväoppimistekniikat, joita käytetään nykyaikaisissa näköjärjestelmissä.

Tietokonenäkö mahdollistaa koneiden visuaalisen datan tulkinnan ja analysoinnin ihmisen havainnointia jäljitellen. Tässä osiossa käsitellään kuvan esitystapojen, väritilojen ja matemaattisten perusteiden perusteita, jotka ovat olennaisia kuvankäsittelyn ymmärtämiseksi. Tutustutaan käytännön sovelluksiin, kuten autonomisiin ajoneuvoihin ja lääketieteelliseen kuvantamiseen, sekä siihen, miten tietokonenäkö yhdistyy tekoälyyn ja koneoppimiseen.

OpenCV on tehokas kirjasto kuvankäsittelyyn ja tietokonenäön tehtäviin. Tässä osiossa käsitellään keskeisiä tekniikoita, kuten kuvafiltteröintiä, muunnoksia, reunojen tunnistusta ja segmentointia. Opit suorittamaan kuvan sumentamista, kynnysarvojen asettamista, ääriviivojen tunnistusta ja piirteiden poimintaa kuvien parantamiseksi ja analysoimiseksi tehokkaasti.

CNN:t käsittelevät visuaalista dataa konvoluutio-, poolaus- ja aktivointikerrosten avulla piirteiden erottamiseksi tehtäviin, kuten kuvien luokitteluun ja objektien tunnistukseen. Keskeisiä osia ovat täydennys, konvoluutio piirteiden erottamiseen, poolaus monimutkaisuuden vähentämiseen ja aktivointi epälineaarisuuden tuomiseksi. Suositut arkkitehtuurit, kuten AlexNet, VGG ja ResNet, mahdollistavat tekoälyn käytön terveydenhuollossa, autonomiassa ja turvallisuudessa.

Esineentunnistus on tietokonenäön keskeinen tehtävä, jossa tunnistetaan ja paikannetaan esineitä kuvassa. Toisin kuin kuvien luokittelu, jossa koko kuvalle annetaan yksi luokka, esineentunnistus sekä luokittelee esineet että määrittää niiden sijainnit rajaavien laatikoiden avulla. Tässä osiossa käsitellään esineentunnistuksen keskeisiä tekniikoita ja algoritmeja, perinteisistä menetelmistä syväoppimiseen perustuviin lähestymistapoihin, kuten YOLO ja U-Net.

Konenäkö on kehittynyt merkittävästi vuosien varrella, siirtyen peruskuvankäsittelymenetelmistä monimutkaisiin syväoppimistekniikoihin. Tässä osiossa perehdytään konenäön viimeisimpiin innovaatioihin, keskittyen siirto-oppimiseen, kasvojentunnistukseen ja kuvien generointiin. Tarkastellaan esikoulutettujen mallien vaikutusta suorituskykyyn, kasvojentunnistusteknologian periaatteita sekä tapoja, joilla tekoäly luo kuvia syväoppimisen avulla.

Perusmuunnokset

Kuvan lukeminen ja näyttäminen

Kuvan koon muuttaminen

Kuvan kiertäminen

Kuvan rajaaminen