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

Kanter representerer plutselige endringer i pikselintensitet, som vanligvis tilsvarer objektsgrenser. Deteksjon av kanter hjelper med gjenkjenning av former og segmentering.

### Sobel kantdeteksjon

Sobel-operatoren beregner gradienter (endringer i intensitet) i både **X- og Y-retning**, og hjelper med å oppdage horisontale og vertikale kanter.

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

Viktige parametere:
- `src`: inputbilde (må være gråtonet);
- `ddepth`: dybde på utgangsbildet (f.eks. `cv2.CV_64F`);
- `dx`: orden på deriveringen i X-retning (sett `1` for horisontale kanter);
- `dy`: orden på deriveringen i Y-retning (sett `1` for vertikale kanter);
- `ksize`: kjernestørrelse (må være oddetall, f.eks. `3`, `5`, `7`).

Merk

### Canny kantdeteksjon

Canny Edge Detector er en flertrinns algoritme som **gir mer nøyaktige kanter** ved å:
1.	Bruke Gaussisk uskarphet for å fjerne støy.
2.	Finne intensitetsgradienter ved hjelp av Sobel-filtre.
3.	Undertrykke svake kanter.
4.	Bruke dobbel terskel og kantsporing.

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

- `image`: input grayscale image;
- `threshold1`: lower threshold for edge detection (e.g., `50`);
- `threshold2`: upper threshold for edge detection (e.g., `150`);
- `apertureSize` (optional): size of the Sobel kernel (default: `3`, must be odd);
- `L2gradient` (optional): use more accurate L2 norm gradient calculation (default: `False`).

## En sammenligning av kantdeteksjonsmetoder:

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

Fordyp deg i datamaskinsyn ved å mestre konvolusjonsnevrale nettverk (CNN) med TensorFlow og Keras. Dette avanserte kurset dekker sentrale konsepter og praktiske ferdigheter, inkludert bilde-forbehandling, konvolusjons- og pooling-operasjoner, bygging og trening av CNN-arkitekturer, implementering av objektdeteksjon og bruk av transfer learning for å løse reelle visuelle utfordringer. Få praktisk erfaring med å løse komplekse synsproblemer ved hjelp av bransjestandard verktøy og teknikker.

Kantdeteksjon

Sobel kantdeteksjon

Canny kantdeteksjon

En sammenligning av kantdeteksjonsmetoder:

Løsning