Projektlabor Robotik MINTgrün

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
=====Straßenschilder=====

<color #008000>**Einleitung**</color>

Das Programm zur Straßenschilderkennung soll genau das tun, was der Name sagt: Straßenschilder erkennen. Die Schilder sollen dabei über Video oder über ein eingegebenes Bild erkannt werden. Um diese Aufgabe zu bewältigen, habe Ich sie in mehrere untergeordnete Aufgaben unterteilt, um diese einzeln lösen zu können und am Ende die Aufgabe wieder zusammgeführt, um so Schilder erkennen zu können. Die Aufgaben sind dabei folgende: Kantenerkennung, Linienerkennung, Zusammenfügen von Linien, Erkennung geometrischer Formen und Farberkennung. Die ersten beiden Teilaufgaben wurden schon durch bereits vorhandene Algorithmen aus der Bildverarbeitung gelöst und somit werden Ich den Fokus auf die anderen drei Aufgaben legen. Zusätzlich sollte das ganze Programm auf einem Handy laufen, sodass bei einer wirklichen Fahrt Schilder erkannt und ausgegeben werden. Dieser Teil wurde weggelassen, da mein Gruppenmitglied leider nicht mehr an diesem Projekt arbeiten konnte.


<color #008000>**Umsetzung**</color>

In diesem Flussdiagramm sieht man einen Überblick, wie mein Programm funktioniert. Dabei wird gezeigt welche Teilaufgabe von welchem Baustein erledigt wird und wie die einzelnen Komponenten aufeinander zugreifen. Die bereits genannten Aufgaben werden jeweils von unterschiedlichen Klassen gelöst. Die Klassen Schild, Form und Verbindung habe Ich selbst implementiert. Der [[https://docs.opencv.org/2.4/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.html|Canny Algorithmus]] und die [[https://docs.opencv.org/3.4/d9/db0/tutorial_hough_lines.html|Hough Linienerkennung]] stammen aus der öffentlichen Bibliothek OpenCV.
<figure mosfet>
{{ :projektesose20:strassenschilder:flussdiagramm-strassenschilder.png?nolink |Abbildung 1: Flussdiagramm zum Ablauf des Programms}}
<caption>Flussdiagramm zum Ablauf des Programms </caption>
</figure>



Wie die einzelnen Aufgaben umgesetzt werden, werde Ich im folgenden im Detail darstellen.

__Kantenerkennung und Linienerkennung__

Für die Kantenerkennung habe Ich den [[https://de.wikipedia.org/wiki/Canny-Algorithmus|Canny-Algorithmus]] benutzt und anschließend die [[https://de.wikipedia.org/wiki/Hough-Transformation|Hough-Transformation]] zur Geradenerkennung angewendet. Das Ergebnis sieht dabei folgendermaßen aus (Links das originale Bild, in der Mitte das Ergebnis des Canny-Algorithmus und rechts das Ergebnis der Geradenerkennung):

<figure mosfet>
{{ :projektesose20:strassenschilder:darstellung-canny-geradenerkennung.png?nolink |Abbildung 2: Darstellung des Canny-Algorithmus und der Geradenerkennung}}
<caption>Darstellung des Canny-Algorithmus und der Geradenerkennung </caption>
</figure>

__Zusammenfügen von Linien__

Diese Aufgabe wird von der Klasse Verbindung übernommen. Hier sollen die zuvor erkannten Linien zu Verbindungen zusammengefasst werden. Dies funktioniert folgendermaßen:
Als erstes wird eine Linie einer leeren Verbindung hinzugefügt. Wenn eine weitere Linie hinzugefügt wird, wird geprüft, ob sich die Linie nah genug an der schon vorhandenen Linie befindet, indem jeweils die Abstände zwischen den Punkten an den Enden der Linien berechnet wird. Zusätzlich wird überprüft, ob die Linien parallel sind. Wenn dies nicht der Fall ist, wird die kürzere Linie so angepasst, dass die beiden Linien direkt verbunden sind. Dies wird dann solange wiederholt bis alle Linien einer Verbindung zugehören.
Anschließend werden dann die einzelnen Verbindungen zusammengefügt, indem jeweils die Enden von zwei Verbindungen nach dem zuvor dargestellten Prinzip verbunden werden. <figure mosfet>
{{:projektesose20:strassenschilder:darstellung_verbindung.png?nolink&200|Abbildung 3: Funktionalität der Klasse Verbindung}}
<caption>Funktionalität der Klasse Verbindung</caption>
</figure>
So entstehen am Ende komplette und unvollständige Verbindungen. Die kompletten Verbindungen werden dann von der Klasse Form auf geometrische Formen hin untersucht. 

Die Winkelberechnung wird durch grundlegende Vektorrechnung umgesetzt. Da der Winkel zwischen zwei Linien bestimmt werden soll, wird das Skalarprodukt der Richtungsvektoren duch das Produkt der Normen der Richtungsverktoren gerechnet, was dem Cosinus des gesuchten Winkels entspricht.

Im Beispiel rechts soll die rote Linie der blauen Verbindung zugefügt werden. Zunächst wird der Abstand zwischen den Endpunkten berechnet und anschließend der Winkel. In diesem Fall sind die Linien nah genug aneinader und der Winkel groß geug, sodass beide Linien verbunden werden. In diesem Fall wird die blaue Linie, da sie kürzer ist, bis zum Endpunkt der grünen Linie hin verlängert. Wenn die rote Linie zur Grünen Linie hinzu gefügt wird, funktioniert dies nicht, da die Linien parallel zueinander sind und somt der Winkel zwischen den Linien nicht ausreichend groß ist.

Das folgende Beispiel verdeutlicht die Vorgensweise: Gegeben sind zwei Linien, die jeweils eine Länge von 100 Pixeln, einen Abstand von 10 Pixeln und einen Winkel von π/4 (entspricht 45°) zueinander haben. Nun wird der Abstand durch die Länge der Linien geteilt: 10 / 100 = 0.1. Wenn dieser Wert kleiner als der Schwellenwert 0.3 ist, werden die Linien verbunden, sofern das Winkelkriterium auch stimmt. Bei einem Abstand von 50 (50 / 100 = 0.5) wäre der Wert größer als der Schwellenwert und die Linien würden nicht verbunden werden. Der Schwellenwert für den Winkel beträft π/16. Da π/4 größer ist, werden die Linien verbunden.


__Erkennung geometrischer Formen__

Die kompletten Verbindungen werden nun auf folgende Art und Weise untersucht: Zunächst wird die Anzahl der Ecken der Verbindungen gezählt und anschließend wird geprüft, ob die Kanten der Verbindungen jeweils ein ausreichendes Seitenverhältnis haben, um zu einer geometrischen Form zu zählen. Dafür untersuchen dann verschiedene Methoden ob die komplette Verbindung entweder ein Dreieck, ein Quadrat, ein Quader, ein Achteck oder ein größeres Polygon ist. Diese Formen werden dann jeweils der Klasse Schild übergeben, um zu prüfen, ob es sich bei den erkannten Formen tatsächlich auch um Straßenschilder handelt. Ein Quader habe Ich so definiert, dass tatsächliche Quader eingeschlossen, aber Quadrate ausgeschlossen sind. Die anderen Formen werden hauptsächlich durch die Anzahl der dazugehörigen Kanten unterschieden. Da für Straßenchilder nur regelmäßige Formen relevant sind, werden jedoch nur regelmäßige Achtecke und Dreiecke berücksichtigt.

Der Seitenverhätnis wird folgendermaßen bestimmt: Für ein Quadrat muss jede Kante möglichst gleich lang sein. Um auch perspektivische Verzerrungen zu berücksichtigen, wird auch hier mit einem Schwellenwert (in diesem Fall 0,1) gearbeitet. So muss alle Kanten das Kriterium erfüllen, dass die folgende Bedingung für alle Kanten erfüllt ist. Kante k <= kante k2 * 1,1 und Kante k >= k2*0,9. 

Wenn zwei zu vergleichende Kanten die Längen 100 und 105 Pixel haben, ist das Kriterium erfüllt, da 100 * 1,1 = 110 und 100*0,9 = 90 ist und somit beide Bedingungen wahr sind.


__Farberkennung__

Für die Erkennung einer Farbe habe Ich den RGB-Farbraum benutzt. Eine Farbe wird durch den RGB-Farbraum dargestellt, indem jeweils der Anteil von Rot, Grün und Blau angegeben wird. Zum Vergleich habe Ich einige Farben definiert. Nun wird der euklidische Abstand zwischen der vordefinierten Farbe und der Farbe eines Pixels bestimmt, umso zu bestimmen ob der Pixel dieser Farbe entspricht. Dieser Farbvergleich wird für eine Form anhand von zwei Linien, die quer durch die Form verlaufen, dann jeweils 40 Mal gemacht. 
<figure mosfet>
{{:projektesose20:strassenschilder:darstellung_farberkennung.png?nolink&200|Abbildung 4: Darstellung der Farberkennung}}
<caption>Darstellung der Farberkennung</caption>
</figure>Dabei wird dar Farbvergleich zu jeweils möglichen Farben und zu zwingend notwenigen Farben gemacht. Wenn entlang der Linie ein Pixel nicht den möglichen Farben entspricht oder eine notwendige Farbe auf der Linie nicht vorkommt, ist die Form nicht das gesuchte Straßenschild. 

In dem Beispiel rechts sind man, wie die untersuchten Linien durch ein Schild verlaufen. Die zu untersuchenden Farbpixel wurden jeweils zu einem Kreis vergrößert. Für ein Stoppschild sind die notwendigen Farben rot und weiß, die jeweils auf beiden Linien zu finden sind. Die erlaubten Farben sind rot, weiß, blassrot und hellrot. Andere Farben sind auf den Linien nicht erhalten. Somit wird das Schild als Stoppschild klassifiziert. Wenn ein Pixel eine andere Farbe oder eine notwendige Farbe nicht auf einer Linier gewesen wäre, würde das Schild dementsprechend trotz der achteckigen Form nicht als Stoppschild klassifiziert werden.


<color #008000>**Ergebnis**</color>

Aktuell können bereits folgende Schilder erkannt werden: Vorfahrtsstraße, Spielstraße, Warnzeichen, Stopschild und Vorfahrt gewähren. Das Programm hat große Probleme, wenn Bilder unscharf oder Schilder abgerundet sind. In beiden Fällen funktioniert die Kantenerkennung entsprechend nur sehr schlecht, wodurch es sehr schwierig für mein Programm ist Formen zu erkennen. Zur Verbessung sollten noch einige Parameter und Fehlerbereiche verändert werden. Zudem können als Erweiterung noch andere Schilder hinzugefügt werden, um eine größere Anzahl unterschiedlicher Schilder erkennen zu können. Zurzeit können nur Bilder mit hoher Auflösung und Graphiken ausgewertet werden. Für eine Videoauswertung wäre es sinnvoll nicht das ganze Bild auszuwerten, sondern nur der Teil des Bildes in dem sich normalerweise Schilder befinden.



<color #008000>**Code**</color>

Aktueller Code (Stand: 26.07.2020)

{{:projektesose20:strassenschilder:strassenschilder-ben.zip|Vollständiger Code}}
Projektlabor Robotik MINTgrün

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
