Summary  
This chapter explains how to apply Gaussian and median filters to smooth images and reduce noise while preserving important details and edges.

General domain of usage  
Computer vision

Kohina kuvissa ilmenee ei-toivottuna rakeisuutena tai vääristymänä, jonka syynä voivat olla esimerkiksi heikko valaistus, pakkausartefaktit tai anturin rajoitukset. Sumentamistekniikat auttavat **vähentämään kohinaa säilyttäen samalla tärkeät yksityiskohdat kuvassa**.


## Gauss-sumennus (Kohinan suodatus)
`cv2.GaussianBlur`-funktio käyttää **Gauss-sumennusta**, joka pehmentää kuvaa laskemalla pikseliarvojen keskiarvon Gaussin ytimen avulla (painotettu keskiarvo, jossa keskimmäisillä pikseleillä on suurempi merkitys):

- `cv2.GaussianBlur(src, ksize, sigmaX)`:  
  - `src`: sumennettava lähdekuva;
  - `ksize`: ytimen koko muodossa `(leveys, korkeus)`, molempien arvojen tulee olla parittomia (esim. `(5, 5)`);
  - `sigmaX`: keskihajonta X-suunnassa; määrittää sumennuksen määrän.  
- Funktio vähentää kuvan kohinaa ja yksityiskohtia konvoloimalla kuvan Gaussin funktiolla, mikä on hyödyllistä esimerkiksi reunojen tunnistuksessa tai esikäsittelyssä ennen kynnysarvojen asettamista.

```
blurred = cv2.GaussianBlur(image, ksize, sigmaX)
```

Funktion `cv2.GaussianBlur()` parametri `sigmaX` on Gaussin ytimen **keskiarvopoikkeama X-suunnassa**, ja sama parametri Y-suunnassa (`sigmaY`) on oletuksena **0**. Kun sekä `sigmaX` että `sigmaY` ovat arvoltaan 0, **keskiarvopoikkeama lasketaan ytimen koosta**.

Lisätietoa

## Mediaanisumennus (Salt-and-Pepper-melun poisto)
`cv2.medianBlur`-funktio käyttää **mediaanisuodatinta**, joka korvaa jokaisen pikselin arvon ytimen ikkunan naapuripikseleiden mediaaniarvolla:

- `cv2.medianBlur(src, ksize)`:  
  - `src`: suodatettava lähdekuva;
  - `ksize`: neliöytimen koko (täytyy olla pariton kokonaisluku, esim. `3`, `5`, `7`).  
- Mediaanisumennus on erityisen tehokas **salt-and-pepper-melun** poistossa, sillä se säilyttää reunat mutta poistaa yksittäiset häiriöpikselit.

```
median_blurred = cv2.medianBlur(image, ksize)
```

import unittest
import numpy as np
import importlib

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestBlurFilters(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")

    def test_gaussian_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Gaussian blurred image has correct shape and type.",
            f"The variable `gaussian_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_median_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Median blurred image has correct shape and type.",
            f"The variable `median_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_gaussian_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Gaussian blur changes image content.",
            "The variable `gaussian_blurred` should be a NumPy array and differ from `image`."
        )

    def test_median_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Median blur changes image content.",
            "The variable `median_blurred` should be a NumPy array and differ from `image`."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Kattava johdatus tietokonenäköön, keskittyen koneelliseen havainnointiin ja visuaalisen datan tulkintaan. Kattaa kuvien esikäsittelyn, piirteiden erottelun, objektien tunnistuksen sekä syväoppimistekniikat, joita käytetään nykyaikaisissa näköjärjestelmissä.

Konenäkö mahdollistaa koneiden tulkita ja analysoida visuaalista dataa, jäljitellen ihmisen havainnointia. Tässä osiossa käsitellään kuvan esitystapojen, väritilojen ja matemaattisten perusteiden perusteita, jotka ovat olennaisia kuvankäsittelyn ymmärtämiseksi. Tutustut käytännön sovelluksiin, kuten autonomisiin ajoneuvoihin ja lääketieteelliseen kuvantamiseen, sekä siihen, miten konenäkö yhdistyy tekoälyyn ja koneoppimiseen.

OpenCV on tehokas kirjasto kuvankäsittelyyn ja konenäön tehtäviin. Tässä osiossa käsitellään keskeisiä tekniikoita, kuten kuvien suodatus, muunnokset, reunojen tunnistus ja segmentointi. Opit suorittamaan kuvan sumentamista, kynnysarvotusta, ää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 tuottamiseen. 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ämä osio käsittelee konenäön viimeisimpiä innovaatioita, keskittyen siirto-oppimiseen, kasvojentunnistukseen ja kuvien generointiin. Tarkastelemme esikoulutettujen mallien vaikutusta suorituskykyyn, kasvojentunnistusteknologian periaatteita sekä tapoja, joilla tekoäly luo kuvia syväoppimisen avulla.

Kohinan Vähentäminen ja Tasoitus

Gauss-sumennus (Kohinan suodatus)

Mediaanisumennus (Salt-and-Pepper-melun poisto)

Ratkaisu