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

## Kantdetektion

Kanterna representerar plötsliga förändringar i pixelintensitet, vilket vanligtvis motsvarar objektgränser. Att detektera kanter underlättar formigenkänning och segmentering.

### Sobel-kantdetektion

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`: ordningen av derivatan i X-riktning (ange `1` för horisontella kanter);
- `dy`: ordningen av derivatan i Y-riktning (ange `1` för vertikala kanter);
- `ksize`: kärnstorlek (måste vara udda, t.ex. `3`, `5`, `7`).

Notering

### Canny-kantdetektion

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`: inmatad gråskalebild;
- `threshold1`: lägre tröskelvärde för kantdetektion (t.ex. `50`);
- `threshold2`: övre tröskelvärde för kantdetektion (t.ex. `150`);
- `apertureSize` (valfritt): storlek på Sobel-kärnan (standard: `3`, måste vara udda);
- `L2gradient` (valfritt): använd mer exakt L2-norm gradientberäkning (standard: `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

Omfattande introduktion till datorseende med fokus på maskinell perception och tolkning av visuella data. Täcker bildförbehandling, funktionsutvinning, objektdetektering och djupinlärningstekniker som används i moderna visionssystem.

Datorseende möjliggör för maskiner att tolka och analysera visuella data, vilket efterliknar mänsklig perception. Detta avsnitt behandlar grunderna i bildrepresentation, färgmodeller och matematiska grunder som är nödvändiga för att förstå hur datorer bearbetar bilder. Du får utforska tillämpningar i verkliga världen, från autonoma fordon till medicinsk bildbehandling, samt hur datorseende integreras med AI och maskininlärning.

OpenCV är ett kraftfullt bibliotek för bildmanipulation och datorseendeuppgifter. Detta avsnitt behandlar grundläggande tekniker såsom bildfiltrering, transformationer, kantdetektion och segmentering. Du får kunskap om hur man utför suddning, tröskling, konturdetektion och funktionsutvinning för att effektivt förbättra och analysera bilder.

CNN bearbetar visuella data med hjälp av konvolution, pooling och aktiveringslager för att extrahera egenskaper för uppgifter som bildklassificering och objektigenkänning. Viktiga komponenter inkluderar utfyllnad, konvolution för egenskapsutvinning, pooling för komplexitetsreduktion och aktivering för icke-linjäritet. Populära arkitekturer som AlexNet, VGG och ResNet driver AI inom hälso- och sjukvård, autonomi och säkerhet.

Objektdetektering är en grundläggande uppgift inom datorseende som innebär att identifiera och lokalisera objekt i en bild. Till skillnad från bildklassificering, som tilldelar en enda etikett till en hel bild, klassificerar objektdetektering inte bara objekt utan bestämmer även deras positioner med hjälp av avgränsningsrutor. Detta avsnitt behandlar centrala tekniker och algoritmer som används vid objektdetektering, från traditionella metoder till djupinlärningsbaserade tillvägagångssätt som YOLO och U-Net.

Datorseende har utvecklats avsevärt genom åren, från grundläggande bildbehandlingsmetoder till avancerade djupinlärningstekniker. Detta avsnitt behandlar de senaste innovationerna inom datorseende, med fokus på transferinlärning, ansiktsigenkänning och bildgenerering. Vi undersöker fördelarna med förtränade modeller för prestanda, principerna bakom ansiktsigenkänningsteknik samt hur AI skapar bilder med hjälp av djupinlärning.

Kantdetektering

Kantdetektion

Sobel-kantdetektion

Canny-kantdetektion

En jämförelse av kantdetekteringsmetoder:

Lösning