Summary  
This chapter covers implementing gradient-based edge detection using Sobel operators and a multi-stage Canny algorithm to locate sudden changes in pixel intensity.  

General domain of usage  
Computer vision

## Reunojen tunnistus

Reunat edustavat äkillisiä muutoksia pikselin intensiteetissä, jotka yleensä vastaavat objektien rajoja. Reunojen tunnistaminen auttaa muotojen tunnistuksessa ja segmentoinnissa.

### Sobel-reunojen tunnistus

Sobel-operaattori laskee gradientit (intensiteetin muutokset) sekä **X- että Y-suunnassa**, mikä auttaa tunnistamaan vaaka- ja pystysuorat reunat.

```
# Convert to grayscale
image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)

# Apply Sobel filter
sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)  # Detects vertical edges
sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)  # Detects horizontal edges
sobel_combined = cv2.magnitude(sobel_x, sobel_y)  # Combines both directions
```

Keskeiset parametrit:
- `src`: syötekuva (oltava harmaasävykuva);
- `ddepth`: tuloskuvan bittisyvyys (esim. `cv2.CV_64F`);
- `dx`: derivaatan aste X-suunnassa (aseta `1` vaakareunoille);
- `dy`: derivaatan aste Y-suunnassa (aseta `1` pystyreunoille);
- `ksize`: ytimen koko (oltava pariton, esim. `3`, `5`, `7`).

Huom

### Canny-reunojen tunnistus

Canny-reunantunnistin on monivaiheinen algoritmi, joka **tuottaa tarkemmat reunat** seuraavasti:
1.	Kohinan poisto Gaussin suodatuksella.
2.	Intensiteettigradienttien etsiminen Sobel-suodattimilla.
3.	Heikkojen reunojen vaimennus.
4.	Kaksoiskynnyksen ja reunojen jäljityksen käyttö.

```
# Apply Canny Edge Detector 
canny_image = cv2.Canny(image, threshold1, threshold2, apertureSize, L2gradient)  
```

- `image`: syöteharmaasävykuva;
- `threshold1`: reunanilmaisun alempi kynnysarvo (esim. `50`);
- `threshold2`: reunanilmaisun ylempi kynnysarvo (esim. `150`);
- `apertureSize` (valinnainen): Sobel-ytimen koko (oletus: `3`, oltava pariton);
- `L2gradient` (valinnainen): käytä tarkempaa L2-normin gradienttilaskentaa (oletus: `False`).

Huomio

import unittest
import numpy as np
import importlib
import cv2

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 TestEdgeDetection(unittest.TestCase):

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

    def test_output_types(self):
        gray = getattr(user_code, "gray_image", None)
        sobel = getattr(user_code, "sobel_img", None)
        canny = getattr(user_code, "canny_img", None)
        _dynamic_test(
            self,
            all(isinstance(x, np.ndarray) for x in [gray, sobel, canny]),
            "All edge detection outputs are NumPy arrays.",
            "Grayscale, Sobel, and Canny images should all be NumPy arrays."
        )

    def test_sobel_kernel_parameters(self):
        gray = user_code.gray_image
        sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
        sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
        combined = cv2.magnitude(sobel_x, sobel_y)
        student = user_code.sobel_img

        similarity = np.allclose(student, combined, atol=1e-5)
        _dynamic_test(
            self,
            similarity,
            "Sobel image matches expected output with kernel size of 3 and depth as cv2.CV_64F.",
            "Sobel image does not match expected output using correct parameters (kernel size of 3, depth as cv2.CV_64F)."
        )

    def test_canny_thresholds(self):
        gray = user_code.gray_image
        expected = cv2.Canny(gray, 200, 300)
        student = user_code.canny_img

        similarity = np.array_equal(student, expected)
        _dynamic_test(
            self,
            similarity,
            "Canny edge output matches thresholds 200-300.",
            "Canny edge image should be computed with thresholds 200 and 300."
        )

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.

Reunojen Tunnistus

Reunojen tunnistus

Sobel-reunojen tunnistus

Canny-reunojen tunnistus

Reunanilmaisumenetelmien vertailu:

Ratkaisu