## Kantenerkennung

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) sowohl in **X- als auch Y-Richtung** und hilft so, horizontale und vertikale Kanten zu erkennen.


### Canny-Kantenerkennung

Der Canny-Kantendetektor ist ein mehrstufiger Algorithmus, der **präzisere Kanten liefert**, indem er:
1.	Einen Gaußschen Weichzeichner zur Rauschreduzierung anwendet.
2.	Intensitätsgradienten mit Sobel-Filtern ermittelt.
3.	Schwache Kanten unterdrückt.
4.	Doppelschwellenwert und Kantennachverfolgung verwendet.

## Ein Vergleich von Kantenerkennungsmethoden:

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 hin 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. Sie lernen, wie man Weichzeichnung, Schwellenwertbildung, Konturenerkennung und Merkmalsextraktion durchführt, um Bilder effizient zu verbessern und zu analysieren.

CNNs verarbeiten visuelle Daten mithilfe von Faltungs-, 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, die einem gesamten Bild ein einzelnes Label zuweist, 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 konzentriert sich auf Transfer Learning, Gesichtserkennung und Bildgenerierung. Es werden die Vorteile vortrainierter Modelle für die Leistung, die Prinzipien der Gesichtserkennungstechnologie und die Bildgenerierung durch KI mittels Deep Learning untersucht.

Kantenerkennung