Summary  
This chapter demonstrates how to implement Sobel and Canny edge detection to compute image gradients, suppress noise, and extract object boundaries.  

General domain of usage  
Image processing

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

### Sobel-reunantunnistus

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

Huomio

### Canny-reunantunnistus

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.	Kaksoiskynnysarvojen ja reunojen jäljitys.

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

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

Huomautus

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

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

Reunojen Tunnistus

Sobel-reunantunnistus

Canny-reunantunnistus

Reunantunnistusmenetelmien vertailu:

Ratkaisu