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 representerar plötsliga förändringar i pixelintensitet, vilket vanligtvis motsvarar objektgränser. Att detektera kanter underlättar formigenkänning och segmentering.

### Sobel-kantdiktering

Sobeloperatorn beräknar gradienter (förändringar i intensitet) i både **X- och Y-riktning**, vilket hjälper till att identifiera horisontella och vertikala 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
```

Viktiga parametrar:
- `src`: inmatningsbild (måste vara gråskala);
- `ddepth`: djupet på utmatningsbilden (t.ex. `cv2.CV_64F`);
- `dx`: ordning av derivatan i X-riktning (ange `1` för horisontella kanter);
- `dy`: ordning av derivatan i Y-riktning (ange `1` för vertikala kanter);
- `ksize`: kernelstorlek (måste vara udda, t.ex. `3`, `5`, `7`).

Notering

### Canny-kantdiktering

Canny Edge Detector är en flerstegsalgoritm som **ger mer exakta kanter** genom att:
1.	Applicera Gaussisk oskärpa för att ta bort brus.
2.	Hitta intensitetsgradienter med Sobel-filter.
3.	Undertrycka svaga kanter.
4.	Använda dubbel tröskling och kantspårning.

```
# 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 jämförelse av kantdetekteringsmetoder:

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

Fördjupa dig i datorseende genom att bemästra konvolutionella neurala nätverk (CNN) med TensorFlow och Keras. Denna avancerade kurs täcker grundläggande begrepp och praktiska färdigheter, inklusive bildförbehandling, konvolutions- och poolningsoperationer, konstruktion och träning av CNN-arkitekturer, implementering av objektigenkänning samt tillämpning av transfer learning för att hantera verkliga visuella utmaningar. Få praktisk erfarenhet av att lösa komplexa seendeproblem med branschstandardiserade verktyg och tekniker.

Kantdetektion

Sobel-kantdiktering

Canny-kantdiktering

En jämförelse av kantdetekteringsmetoder:

Lösning