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

Kanten stellen plötzliche Ä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 Graustufenbild sein);
- `ddepth`: Tiefe des Ausgabebildes (z. B. `cv2.CV_64F`);
- `dx`: Ordnung der Ableitung in X-Richtung (auf `1` setzen für horizontale Kanten);
- `dy`: Ordnung der Ableitung 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 mittels 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): Verwendung einer genaueren L2-Norm-Gradientenberechnung (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

Tauchen Sie tief in das Gebiet des Computer Vision ein, indem Sie Convolutional Neural Networks (CNNs) mit TensorFlow und Keras beherrschen. Dieser fortgeschrittene Kurs behandelt grundlegende Konzepte und praktische Fähigkeiten, einschließlich Bildvorverarbeitung, Faltungs- und Pooling-Operationen, Aufbau und Training von CNN-Architekturen, Implementierung von Objekterkennung sowie Anwendung von Transfer Learning zur Lösung realer visueller Herausforderungen. Sammeln Sie praktische Erfahrungen bei der Lösung komplexer Vision-Probleme mit branchenüblichen Werkzeugen und Techniken.