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

## Kantenerkennung

Kanten stellen abrupte Änderungen der Pixelintensität dar, die in der Regel Objektgrenzen entsprechen. Die Erkennung von Kanten unterstützt die Formerkennung und Segmentierung.

### Sobel-Kantenerkennung

Der Sobel-Operator berechnet Gradienten (Intensitätsänderungen) in **X- und Y-Richtung** und ermöglicht so die Erkennung von horizontalen und vertikalen Kanten.

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

Wichtige Parameter:
- `src`: Eingabebild (muss in Graustufen vorliegen);
- `ddepth`: Tiefe des Ausgabebildes (z. B. `cv2.CV_64F`);
- `dx`: Ableitungsordnung in X-Richtung (auf `1` setzen für horizontale Kanten);
- `dy`: Ableitungsordnung in Y-Richtung (auf `1` setzen für vertikale Kanten);
- `ksize`: Kernelgröße (muss ungerade sein, z. B. `3`, `5`, `7`).

Hinweis

### Canny-Kantenerkennung

Der Canny-Kantendetektor ist ein mehrstufiger Algorithmus, der **präzisere Kanten liefert** durch:
1.	Anwendung eines Gaußschen Weichzeichners zur Rauschreduzierung.
2.	Bestimmung von Intensitätsgradienten mit Sobel-Filtern.
3.	Unterdrückung schwacher Kanten.
4.	Verwendung von doppelter Schwellenwertsetzung und Kantennachverfolgung.

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

- `image`: Eingabebild in Graustufen;
- `threshold1`: untere Schwelle für die Kantenerkennung (z. B. `50`);
- `threshold2`: obere Schwelle für die Kantenerkennung (z. B. `150`);
- `apertureSize` (optional): Größe des Sobel-Kernels (Standard: `3`, muss ungerade sein);
- `L2gradient` (optional): genauere Berechnung des Gradienten mit L2-Norm verwenden (Standard: `False`).

## Ein Vergleich von Kantenerkennungsverfahren:

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

Umfassende Einführung in Computer Vision mit Schwerpunkt auf maschineller Wahrnehmung und Interpretation visueller Daten. Behandelt Bildvorverarbeitung, Merkmalsextraktion, Objekterkennung und Deep-Learning-Techniken, die in modernen Vision-Systemen verwendet werden.

Computer Vision ermöglicht es Maschinen, visuelle Daten zu interpretieren und zu analysieren, indem sie die menschliche Wahrnehmung nachahmen. Dieser Abschnitt behandelt die Grundlagen der Bilddarstellung, Farbmodelle und mathematischen Grundlagen, die für das Verständnis der Bildverarbeitung durch Computer wesentlich sind. Es werden praxisnahe Anwendungen vorgestellt, von autonomen Fahrzeugen bis zur medizinischen Bildgebung, sowie die Integration von Computer Vision mit KI und maschinellem Lernen erläutert.

OpenCV ist eine leistungsstarke Bibliothek für Bildmanipulation und Aufgaben der Computer Vision. Dieser Abschnitt behandelt grundlegende Techniken wie Bildfilterung, Transformationen, Kantenerkennung und Segmentierung. Es werden Methoden wie Weichzeichnung, Thresholding, Konturenerkennung und Merkmalsextraktion vorgestellt, um Bilder effizient zu verbessern und zu analysieren.

CNNs verarbeiten visuelle Daten mithilfe von Faltung, Pooling und Aktivierungsschichten, um Merkmale für Aufgaben wie Bildklassifikation und Objekterkennung zu extrahieren. Zentrale Komponenten sind Padding, Faltung zur Merkmalsextraktion, Pooling zur Komplexitätsreduktion und Aktivierung für Nichtlinearität. Bekannte Architekturen wie AlexNet, VGG und ResNet treiben KI in Bereichen wie Gesundheitswesen, Autonomie und Sicherheit an.

Objekterkennung ist eine grundlegende Aufgabe im Bereich Computer Vision, bei der Objekte innerhalb eines Bildes identifiziert und lokalisiert werden. Im Gegensatz zur Bildklassifikation, bei der einem gesamten Bild ein einzelnes Label zugewiesen wird, klassifiziert die Objekterkennung nicht nur Objekte, sondern bestimmt auch deren Positionen mithilfe von Begrenzungsrahmen. Dieser Abschnitt behandelt zentrale Techniken und Algorithmen der Objekterkennung, von traditionellen Methoden bis hin zu Deep-Learning-basierten Ansätzen wie YOLO und U-Net.

Die Computer Vision hat sich im Laufe der Jahre erheblich weiterentwickelt und ist von grundlegenden Bildverarbeitungsmethoden zu komplexen Deep-Learning-Techniken übergegangen. Dieser Abschnitt befasst sich mit den neuesten Innovationen im Bereich Computer Vision und legt den Schwerpunkt auf Transfer Learning, Gesichtserkennung und Bildgenerierung. Es werden die Vorteile vortrainierter Modelle für die Leistungsfähigkeit, die Prinzipien der Gesichtserkennungstechnologie sowie die Bildgenerierung durch KI mittels Deep Learning untersucht.

Kantenerkennung

Kantenerkennung

Sobel-Kantenerkennung

Canny-Kantenerkennung

Ein Vergleich von Kantenerkennungsverfahren:

Lösung