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

Kanter repræsenterer pludselige ændringer i pixelintensitet, hvilket typisk svarer til objektgrænser. Detektering af kanter hjælper med genkendelse af former og segmentering.

### Sobel-kantdetektion

Sobel-operatoren beregner gradienter (ændringer i intensitet) i både **X- og Y-retningen**, hvilket hjælper med at detektere 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
```

Vigtige parametre:
- `src`: inputbillede (skal være gråtone);
- `ddepth`: dybde for outputbilledet (f.eks. `cv2.CV_64F`);
- `dx`: orden af afledt i X-retningen (sæt `1` for horisontale kanter);
- `dy`: orden af afledt i Y-retningen (sæt `1` for vertikale kanter);
- `ksize`: kernelstørrelse (skal være ulige, f.eks. `3`, `5`, `7`).

Bemærk

### Canny-kantdetektion

Canny Edge Detector er en flertrinsalgoritme, der **giver mere præcise kanter** ved at:
1.	Anvende Gaussisk sløring for at fjerne støj.
2.	Finde intensitetsgradienter ved hjælp af Sobel-filtre.
3.	Undertrykke svage kanter.
4.	Bruge dobbelt tærskelværdi og kantsporing.

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

- `image`: input gråtonebillede;
- `threshold1`: nedre tærskelværdi for kantdetektion (f.eks. `50`);
- `threshold2`: øvre tærskelværdi for kantdetektion (f.eks. `150`);
- `apertureSize` (valgfri): størrelse på Sobel-kernen (standard: `3`, skal være ulige);
- `L2gradient` (valgfri): brug mere præcis L2-norm gradientberegning (standard: `False`).

## En sammenligning af kantdetektionsmetoder:

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

Omfattende introduktion til Computer Vision med fokus på maskinens opfattelse og fortolkning af visuelle data. Dækker billedforbehandling, feature-ekstraktion, objektdetektion og dybdelæringsteknikker anvendt i moderne visionssystemer.

Computer vision gør det muligt for maskiner at fortolke og analysere visuelle data ved at efterligne menneskelig perception. Dette afsnit dækker grundlæggende billedrepræsentation, farvemodeller og matematiske fundamenter, som er essentielle for at forstå, hvordan computere behandler billeder. Du vil udforske virkelige anvendelser, fra autonome køretøjer til medicinsk billedbehandling, og få indsigt i, hvordan computer vision integreres med AI og maskinlæring.

OpenCV er et kraftfuldt bibliotek til billedmanipulation og computer vision-opgaver. Dette afsnit dækker væsentlige teknikker såsom billedfiltrering, transformationer, kantdetektion og segmentering. Du lærer at udføre sløring, tærskling, konturdetektion og feature-ekstraktion for at forbedre og analysere billeder effektivt.

CNN'er behandler visuelle data ved hjælp af konvolution, pooling og aktiveringslag for at udtrække træk til opgaver som billedklassificering og objektdetektion. Centrale komponenter omfatter padding, konvolution til trækudtrækning, pooling til reduktion af kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver AI inden for sundhedspleje, autonomi og sikkerhed.

Objektdetektion er en grundlæggende opgave inden for computer vision, der omfatter identifikation og lokalisering af objekter i et billede. I modsætning til billedklassificering, som tildeler en enkelt etiket til et helt billede, klassificerer objektdetektion ikke kun objekter, men bestemmer også deres positioner ved hjælp af afgrænsningsbokse. Dette afsnit dækker centrale teknikker og algoritmer anvendt i objektdetektion, fra traditionelle metoder til dybdelæringsbaserede tilgange som YOLO og U-Net.

Computer vision har gennemgået betydelige fremskridt gennem årene, fra grundlæggende billedbehandlingsmetoder til avancerede deep learning-teknikker. Dette afsnit undersøger de nyeste innovationer inden for computer vision med fokus på transfer learning, ansigtsgenkendelse og billedgenerering. Vi udforsker fordelene ved prætrænede modeller for ydeevne, principperne bag ansigtsgenkendelsesteknologi samt hvordan AI skaber billeder ved hjælp af deep learning.

Kantdetektion

Kantdetektion

Sobel-kantdetektion

Canny-kantdetektion

En sammenligning af kantdetektionsmetoder:

Løsning