Version vom 7. Januar 2023, 12:07 Uhr

Autoren: Hendrik Steffen, Sven Posner
Bearbeitet von: Florian Brinkmann, Jan Müller
Betreuer: Prof. Schneider

→ zurück zum Hauptartikel: OSE - Objekt - und Spurerkennung
→ zurück zum Hauptartikel: Praktikum SDE

Quick Start

Visual Studio installieren Visual Studio Community 2019
In Visual Studio mit Studentenemail-Adresse Account erstellen und kostenlos anmelden
C++ Erweiterung herunterladen und installieren
Vr Cam Lab installieren um die Treiber zu erhalten Vr Cam Lab
Open Cv in der Version 3.0.0 installieren und auf der Festplatte D entpacken. Wichtig: Oberordner muss opencv heißen (D:\opencv\...)
Svn auschecken. Die aktuelle Software liegt unter dem Pfad: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Draufsicht_Spurpolynom_RS232
Videopfad in der Config.ini Datei auf den lokalen Speicherort ändern. Das Video für die Simulation befindet sich unter: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Draufsicht_Spurpolynom_RS232/Video/Rundkurs.mp4
Kamera mit LAN und Netzteil verbinden. Bis die Kamera gestartet hat kann über eine Minute vergehen.

Wichtig: Wenn in den Projekteinstellungen nichts verändert wird und alle oben genannten Punkte korrekt durchlaufen wurde, werden alle notwendigen Bibliotheken gefunden
Werden die Pfade geändert, und nur dann nach den folgenden Anleitungen vorgehen:
Einrichten von OpenCV in Visual Studio
Implementierung der Kamera in Visual Studio

Programmstruktur

Die Softwareumgebung ermöglicht es, in einer Umgebung die Simulation und das Livebild anzuzeigen und die Koeffizienten des Spurpolynoms auszugeben. Zusätzlich soll die Kalibrierung der Kamera auch möglich werden (im Aufbau). In der untenstehenden Abbildung ist die Struktur dieser Softwareumgebung dargestellt.

Zu Beginn kann zwischen der Simulation, dem Livebild oder dem Beenden des Programms ausgewählt werden. Wenn das Programm nicht beendet wurde, werden im nächsten Schritt die Variablen initialisiert. Je nach Auswahl der Bildquelle wird das Bild unterschiedlich eingelesen. Wichtig ist dass sich nur das Einlesen der Bilder unterscheidet danach verläuft die Auswertung wieder über den gleichen Code. Das ermöglicht die Optimierung der Spurerkennung in der Simulation und das Testen in der Live-Anwendung.

Struktur der Simulation

In der Simulation wird das Bild Frame für Frame ausgelesen und in ein Bild vom Datentyp Mat (openCV) konvertiert. Sobald das Video zu Ende ist, beendet sich das Programm selbstständig. Die So erzeugten Einzelbilder werden in dem gemeinsamen Programmzweig weiterverarbeitet. Die Weiterverarbeitung findet hauptsächlich in den Funktionen Bildtransformation und Spurerkennung statt. In der Bildtransformation wird das Bild entzerrt, in Schwarz/Weiß gewandelt und in die Vogelperspektive transformiert. In der Spurerkennung wird die rechte Spur durch regelmäßige Punkte erfasst und daraus das Spurpolynom berechnet.

Struktur des Live-Bildes

Bei dem Live-Bild wird die Kamera einmalig initialisiert. In diesem Schritt werden die wichtigsten Parameter eingestellt und eine Verbindung hergestellt. Nach dem erstmaligen Starten der Kamera kann es bis zu zwei Minuten dauern, bis der PC eine Verbindung mit der Kamera hergestellt hat. Erst dann kann diese Initialisierung erfolgreich ausgeführt werden.

Nach der Initialisierung wird zyklisch ein neues Bild aus dem Videopuffer gelesen in ein Alpha-RGB-Bild umgewandelt, da dies mit dem Mat-Format von openCV kompatibel ist. Am Ende eines Zyklus steht, genau wie in der Simulation ein Mat-Bild zur Verfügung. Dieses wird in der Bildtransformation und Spurerkennung weiterverarbeitet.

Simulationsumgebung

In der Simulationsumgebung wird ein vorher aufgezeichnetes Videobild genutzt, um das Kamerabild zu simulieren. Dazu wird im ersten Schritt, sobald die Simulation ausgewählt wurde, der Dateipfad des Videos eingelesen. In der config.ini kann eingestellt werden, welches Video für die Simulation verwendet werden soll. Es reicht dabei lediglich den Dateinamen zu ändern, das Standard Video ist "Rundkurs.mp4" und sollte auf jeden Fall im Ordner enthalten sein. Im SVN müssen die Videos unter: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/Simulation_Bildverarbeitung_und_Spurerkennung/Videos/Rundkurs.mp4 hinterlegt sein. Falls der Dateiname in der Config.ini falsch hinterlegt ist, wird in der Konsole kurz "Ungültige Eingabe!" angezeigt, bevor dann wieder die Auswahlseite für Simulation, das Live-Bild usw. angezeigt wird. Sobald der Dateipfad zum Video richtig hinterlegt wurde, sollte diese Fehlermeldung nicht mehr erscheinen und die Simulation starten.

Mit der Funktion FA_InitVideo werden die Ausgabefenster der Bilder angepasst. Welche Bilder Ausgegeben werden sollen, kann ebenfalls in der Config-Datei festgelegt werden.

FL_GetFrame() liest ein neues Frame aus der Videodatei aus und speichert es in der Matrix.

Live Bild

Kamera einrichten

Um einen ersten Funktionstest der Kamera durchzuführen, wurde die Kamera über einen Ethernetkabel mit dem Laborrechner verbunden und das zugehörige Netzteil für die Stromversorgung angeschlossen. Als Netzteil wird dabei ein 5V und 4A Netzteil von Phigong verwendet.
Das VRmagic Programm zum ausgeben des Kamerabildes "CamLab" ist auf allen Laborrechnern bereits installiert.
Falls es nicht installiert sein sollte, kann das Programm von der VRmagic Homepage heruntergeladen werden:
https://www.vrmagic-imaging.com/service/downloads/usb-platform-downloads/
Der richtige Typ der Software, für den entspechenden Rechner kann unter dem Punkt "USBPlattform/Software" ausgewählt und heruntergeladen werden, siehe Bild.
Nachdem das Programm heruntergeladen wurde, muss die ZIP-Datei entpackt werden und die "Setup"-Datei ausgeführt werden. Für nähere Informationen zur Installation, ist in der ZIP-Datei eine README-Dokument enthalten.
"WICHTIG: Admin-Rechte von Nöten!!!"
Nachdem die Installation erfolgreich abgeschlossen wurde, kann das Programm "CamLab" ausgeführt werden.

Nachdem das Programm geöffnet wurde kann die VRmagic Kamera mit dem CamLab kommunizieren. Die angeschlossene Kamera kann in dem Dropdown-Menü ausgewählt werden. Dies kann nach dem ersten mal anschließen etwas dauern, bis das Programm die Ethernetverbindung zur Kamera findet. Da ruhig 1-2 Minuten warten. Im Anschluss daran kann die Bildausgabe gestartet werden.

Wenn die Kamera ausgewählt wurde, öffnet sich ein erweiteretes Menü. In diesem Menü können alle möglichen Konfigurationen vorgenommen werden, die die VRmagic Kamera anbietet (Format, Timing, Sensor, Filter etc.). Mit einem Klick auf den Button "Grab" kann die Bildwiedergabe gestartet werden. Es können auch Snapshots erstellt werden, die auf dem Rechner gespeichert werden können.
Mit diesem Programm wurde ein erster Funktionstest der Kamera durchgeführt, welcher Grundlage für weitere Ansterungskonzepte mit Visual Studio ist.

Kamera in Softwareumgebung verwenden

Im Programm werden die notwendigen Schritte zum Starten der Kamera und der Bildausgabe durchlaufen. Dabei ist es ebenfalls wichtig, dass nach einem erneuten Anschließen der Kamera 1-2 Minuten gewartet werden muss, bis die Kamera tatsächlich die Ethernet Verbindung aufgebaut hat und verbunden ist. Dann stellt das Programm die Verbindung aber her und ein Live Bild der Kamera wird angezeigt, wenn Menüpunkt 2 ausgewählt wurde.
die wichtigen Schritte, die das Programm durchläuft, bis ein OpenCV Bild entsteht, dass dann für die Bildverarbeitung und Spurerkennung weiterverwendet werden kann sind die folgenden:

1. Anlegen eines neues Kameradevices mithilfe von OSE_device_st = Vrm_OpenDevice();
2. Belichtungszeit zuweisen mithilfe von: !VRmUsbCamSetPropertyValueF(OSE_device_st, VRM_PROPID_CAM_EXPOSURE_TIME_F, &OSE_belichtungszeit_s32)
3. Erstellen eines Bildformates, indem die Bildgröße und das Farbformat eingestellt wird.
4. Das erstellte Eingabebild dem neuen Format zuweisen mithilfe von VRmUsbCamNewImage(&OSE_ARGB_EingabeBild_st, OSE_ARGB_Format_st)
5. In der loop werden dann Schrittweise Bilder aufgenommen mithilfe von VRmUsbCamLockNextImageEx(OSE_device_st, port, &OSE_rawQellBild_st, &OSE_bilderAufgenommen_st)
6. Das aufgenommene Bild wird in ein Alpha RGB Bild gewandelt mithilfe von VRmUsbCamConvertImage(OSE_rawQellBild_st, OSE_ARGB_EingabeBild_st)
7. Die Belichtungszeit wird dem aufgenommenen Bild zugewiesen mithilfe von VRmUsbCamGetPropertyValueF(OSE_device_st, VRM_PROPID_CAM_EXPOSURE_TIME_F, &OSE_belichtungszeit_s32)
8. Das VRM Color Format wird erstellt, um es im nächsten Schitt für die Umwandlung zu nutzen
9. Das Bild wird in ein OpenCV Bild umgewandelt mithilfe von cv::Mat OSE_srcImage_st(cvSize(OSE_ARGB_EingabeBild_st->m_image_format.m_width, OSE_ARGB_EingabeBild_st->m_image_format.m_height), toCvType(OSE_colorFormatsrc_st), (void*)OSE_ARGB_EingabeBild_st->mp_buffer, OSE_ARGB_EingabeBild_st->m_pitch);

Bildverarbeitung

Nachdem das Bild sowohl von der Kamera als auch von dem eingelesenen Video als gleiches openCV Bild im Farbschema Alpha RGB vorliegt, werden die nun erläuterten Schritte mit de Bild durchlaufen, um am Ende die drei Spurparameter a,b, und c zu erhalten.

Schritt 1: Transformation

Die Transformation des Bildes findet in der Funktion cv::Mat BTF_ImgTransf(cv::Mat img_Mat, bool ausgabe_abit[]) statt. Diese befindet sich in der Datei Bildtransformation.cpp.

In dieser Funktion werden zunächst die intrinsischen Kameraparameter eingegeben, die mithilfe der Matlab Toolbox Camera Calibrator erstellt wurden. Dazu wurde ein Schachbrettmuster genutzt, dass in verschiedenen Perspektiven vor die Kamera gehalten wurde. Wie man an diese Parameter dann kommt ist in der Matlab Hilfe hier Camera Calibration oder im Wiki Artikel Kamerakalibrierung beschrieben.

Dann erfolgt die Umwandlung des Bildes in ein Graustufenbild, was in der Funktion binarisierung(img_Mat, ausgabe_abit[2], ausgabe_abit[3]); stattfindet. Rückgabewert ist dann ein schwarz weiß Bild der Kamera in der Ursprungsgröße.

Als nächster Schritt findet die Transformation in die Vogelperspektive statt. Dazu wird das Bild zunächst vom Fischaugeneffekt durch die Funktion cv::undistort(img_Mat, KalibriertesBild_st, OSE_IntrinsicMatrix_as32, OSE_dist_s32); befreit und wird anschließend durch die Opencv Funktion cv:: warpPerspective Transformiert. Wie die Punkte zur Kalibrierung zustandekommen ist in diesem Wiki Artikel Transformation beschrieben.

Abschließend wird das Bild noch mithilfe eines Kantenerkennungsalgorithmus durch die cv::Canny(OSE_zielBild_st, OSE_filterBild_st, 100, 200, 3); Funktion in ein Kantenbild überführt, dass zurückgegeben wird.

Für die weitere Verwendung der Vogelperspektive wird nur ein bestimmter Region of Interest (ROI) benötigt. Die nebenstehende Abbildung zeigt die Lage und Größe des ROI im Fahrzeug-Koordinatensystem. Gemessen wurde vom Ursprung des Fahrzeug-KOS aus, also ohne Berücksichtigung des vorderen Bumpers (siehe auch Fahrzeughardware). Somit beträgt der Abstand zwischen ROI und Fahrzeug $520 mm$ . Zur Umrechnung von (Bild-)Pixel (px) in mm ergeben sich folgende Faktoren:

x-Richtung (längs): $\frac{2710 mm}{1113 px} = 2,4 \frac{mm}{px}$
y-Richtung (quer): $\frac{1200 mm}{752 px} = 1,6 \frac{mm}{px}$

Schritt 2: Spurerkennung

Die Spurerkennung erfolgt durch den Funktionsaufruf Spurerkennung, diese Funktion ist in der Datei Spurerkennung.cpp implementiert.

Spurerkennung(imgT, OSE_SpurparamterA_f32, OSE_SpurparamterB_f32, OSE_SpurparamterC_f32, OSE_Spurzuordnung_bit); Die Parameter sind:

imgT: Gefiltertes Bild in der Vogelperspektive
OSE_SpurparamterA_f32: Spurparameter A (Wird beschrieben)
OSE_SpurparamterB_f32: Spurparameter B (Wird beschrieben)
OSE_SpurparamterC_f32: Spurparameter C (Wird beschrieben)
OSE_Spurzuordnung_bit: Noch keine Funktion

In der Spurerkenneung Wird im ersten Schritt ein Array für die gefundenen Punkte initialisierte. Dann wird die Funktion Berechnung Schnittpunkt Koordinaten aufgerufen. Dort werden die Koordinaten der Schnittpunkte berechnet. die Polynomberechnung erfolgt mit einer aus Matlab generierten Funktion. Deshalb muss das Array erst in einen kompatiblen Datentyp umgewandelt werden. Nach der Berechnung des Spurpolynoms wird dieses ausgegeben.

Berechnung Schnittpunkt Koordinaten

Die Berechnung der Schnittpunktkoordinaten erfolgt, wie in der Abbildung dargestellt. Nachdem die Variablen initialisiert wurden, wird das aktuelle Bild durchlaufen. Dabei wird von unten nach oben zeilenweise vorgegangen. Der Abstand der Zeilen erhöht sich mit zunehmender Bildhöhe, da die näheren Punkte relevanter sind. In dieser Schleife werden als erstes die nicht gefundenen Punkte aus dem vorherigen Zyklus eingezeichnet. Das ermöglicht eine bessere Analyse der Ergebnisse. Für jede Zeile wurde ein Gate festgelegt in dem der nächste Spurpunkt zu finden ist. Dieses Gate ergibt sich aus dem letzten gefundenen Punkt.

In diesem Gate wird ein Spurpunkt mittels der Funktion Spursuchen ermittelt. In dieser Funktion werden die Punkte im Gate durchgegangen. Wird eine Wechsel von Schwarz auf Weiß detektiert, werden die weißen Pixel gezählt. Stimmen diese mit einer festgelegten Toleranz mit der Spurbreite überein, gilt die Spur als gefunden. Die letzte gefundene Spur wird als rechte Spur gespeichert.

Wenn kein Spurpunkt gefunden wurde, wird nichts gespeichert, aber der letzte gefundene Punkt (vorheriger Zyklus) wird für das neue Gate verwendet. Gefundene Punkte werden gespeichert und eingezeichnet. Wenn es der erste Schnittpunkt des Bildes ist, wird dieser als Startpunkt für das nächste Bild gespeichert. Die Gefundenen Schnittpunkte werden gezählt. Sobald die Arraygröße überschritten wird oder das ende des Bilds erreicht wird, wird das Suchen abgebrochen. Die Anzahl der gefundenen Punkte wird übergeben, um nur daraus das Polynom zu berechnen.

Erweiterung um dynamische Spurzuordnung
Damit die Spurerkennung auch während Kurven zuverlässig (zumindest) eine Spur erkennen kann, wird u.U. ein Sprung von einer Fahrbahnmarkierung zu einer anderen benötigt. Um dies zu ermöglichen wurde der im folgende erläuterte Algorithmus an das Ende der Schnittpunktberechnung implementiert.

Das Vorgehen ist recht simpel und läuft gemäß dem abgebildeten PAP ab. Mit dem ersten Funktionsaufruf wird die eine statische Variable angelegt, welche die aktuelle Spur speichert. Initial wird hier von der rechten Spur ausgegangen, da diese auch überwiegend erkannt wird.
Mit jedem Frame wird die Funktion BerechneSchnittpunkt aufgerufen. In dieser Funktion werden alle gefundenen Schnittpunkte für das Frame gesammelt und gezählt. Wird ein vorher eingestellter Schwellenwert an gefundenen Schnittpunkte in einem Frame unterschritten, wird ein statischer Counter erhöht. Wurde ausreichend viele Schnittpunkte gefunden, so wird der Counter wieder auf 0 gesetzt. Überschreitet der Counter allerdings die vorher bestimmte maximale Anzahl an erlaubten Frames mit weniger Schnittpunkten, wird ein Spurwechsel ausgelöst. Der spur-Parameter wird also invertiert und das Gate wird neu bestimmt (es wird dabei um die Breite der Fahrbahn nach links oder rechts verschoben). Mit dem nächsten Frame wird nun nach der gegenüberliegenden Fahrbahn gesucht. Damit auch definitiv die äußere Markierung gefunden wird wird die for Schleife zum suchen der Spur entweder von rechts nach links im Bild (für die linke Markierung) oder von links nach rechts (für die rechte Markierung) durchlaufen. Der restliche Algorithmus bleibt von dieser Änderung unbetroffen, sodass auch mit geänderter Spur die Gate-Berechnung etc. einwandfrei funktioniert.

Schritt 3: Stopplinienerkennung

Autor: Florian Brinkmann

Die Beschreibugn der Stopplinienerkennung wurde aufgrund der Komplexität in einen eigenen Artikel ausgelagert.
Hier geht es zum Artikel OSE Stopplinienerkennung

Daten senden

Im letzten Teil nach Einlesen und Verarbeiten der Daten werden diese über die RS232 Schnittstelle gesendet. Dies ist aber nicht mehr Teil unserer Arbeit sondern ist im Wiki Artikel Kommunikation zwischen PC und dSpace-Karte via RS232 beschrieben.

Testkonzept

Das SDE-Team 2021/22 hat im Rahmen des Praktikums verschiedene Testfälle entwickelt, die fortlaufend genutzt und angepasst werden. Für die OSE Softwareumgebung sind die Testfälle auf den beiden folgenden Wiki-Seiten zu finden:

Alle anderen Wiki-Seiten sind auf der Teamseite verlinkt.

Literatur

→ zurück zum Hauptartikel: OSE - Objekt - und Spurerkennung
→ zurück zum Hauptartikel: Praktikum SDE

@@ Zeile 134: / Zeile 134: @@
 '''Autor:''' [[Benutzer:Florian Brinkmann|Florian Brinkmann]]
-Gemäß REQ10.2340 aus dem Lastenheft soll das autonome Fahrzeug an einer Stopp-Kreuzung anhalten. Dementsprechend muss die Stopplinie mittels Kamera detektiert werden. Dabei gilt es zu unterschieden, ob es sich um eine 40 mm breite Stopplinie oder eine schmalere Linie handelt, an der nicht gehalten werden muss. Zusätzlich enthält das Requirement den Hinweis, dass die Kreuzung rechtwinklig ist, sodass auch die Stopplinie in einem rechten Winkel zur Fahrbahnmarkierung liegt.  <ref> GÖBEL, M. und SCHNEIDER, U. Lastenheft für das Projekt „Autonomes Fahrzeug“. Lippstadt: 2019. Verfügbar unter: [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Anforderungsmanagement/Lastenheft/Lastenheft_Autonomes_Fahrzeug.pdf SVN-Link] </ref>
+Die Beschreibugn der Stopplinienerkennung wurde aufgrund der Komplexität in einen eigenen Artikel ausgelagert. <br>
+'''Hier geht es zum Artikel'''     [[Datei:Ezgif-3-aa149494be25.gif]] [[OSE Stopplinienerkennung]]
-Im [[SDE-Team 2022/23|Wintersemester 2022/23]] hat sich das [[SDE-Team_2022/23#Team_5_-_OSE:_Stopplinienerkennung_und_Querverkehr |Team OSE (Stopplinienerkennung)]] damit beschäftigt die Stopplinienerkennung in die aktuelle Software zu implementieren. Dabei wurde zunächst der [[Stopplinienerkennung mit Hough-Transformation |Lösungsansatz mittels Hough-Transformation]] von [[Benutzer:Kevin Hustedt| Kevin Hustedt]] und [[Benutzer:Moritz Oberg| Moritz Oberg]] verfolgt. Jedoch wurde hierbei festgestellt, dass die genutzte Hough-Transformation mit der eingesetzten OpenCV 3.0.0-Version zu Speicherzugriffsverletzungen führt. Aus diesem Grund wurde der im folgenden vorgestellte Ansatz verfolgt. Bevor der Ansatz mit Visual Studio umgesetzt wurde, ist der Ansatz mit MATLAB<sup>®</sup> validiert worden. Die Ergebnisse der Umsetzung des C-Codes sind zunächst im [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung Branch 2022_10_05_OSE_Stopplinienerkennung] gesichert worden.
-=== Ansatz ===
-==== Stopplinienerkennung ====
-[[Datei:Stopplinienerkennung Prinzip.gif|400px|thumb|left|Mathematisches Prinzip der Stopplinienerkennung]]
-[[Datei:Stopplinienerkennung PAP.png|200px|thumb|right|Ablauf der Stopplinienerkennung]]
-Der neue Ansatz basiert prinzipiell auf einer Zählung der weißen Pixel in jeder Bildzeile. Da allerdings in Kurven die Stopplinie nicht in einer einzelnen, sondern in mehreren Bildzeilen dargestellt wird, musste eine Möglichkeit gesucht werden, um auch schräge Stopplinien detektieren zu können. Dieses Problem kann gelöst werden, indem die Ergebnisse der zuvor erfolgten Spurerkennung eingesetzt werden. Aus den Koeffizienten der Fahrbahnmarkierung wird für jede Bildzeile der Richtungsvektor <math>\vec{r_1}</math> der Fahrbahnmarkierung bestimmt. Da eine Stopplinie senkrecht zur Fahrbahnmarkierung ist, kann der Richtungsvektor der Fahrbahnmarkierung um 90° gedreht werden, um den Richtungsvektor der Stopplinie <math>\vec{r_2}</math> zu berechnen. Mit Hilfe des Stopplinien-Richtungsvektors <math>\vec{r_2}</math> wird ein Punkt <math>P_3</math> auf der potentiellen Stopplinie bestimmt (siehe Abbildung). Dieser wird wiederum dazu genutzt, um die Koeffizienten einer Geraden zu bestimmen, auf der die potentielle Stopplinie liegt. Ausgehend von einem Punkt auf der Fahrbahnmarkierung werden mit Hilfe der Geradengleichung Koordinaten von einzelnen Pixeln bestimmt, auf denen die potentielle Stopplinie liegt. Anschließend werden die Pixelwerte der bestimmten Koordinaten ausgelesen und bei einem weißen Pixel eine Zählvariable erhöht. Erreicht diese Zählvariable einen Schwellwert, ist eine Stopplinie erkannt worden. Dieses Vorgehen ist auch in dem nebenstehenden PAP dargestellt.
-==== Abstandsberechnung ====
-Neben der Erkennung der Stopplinie ist es für den späteren Einsatz der Software notwendig, auch den Abstand <math>a</math> zwischen dem Fahrzeug und der Stopplinie zu bestimmen. Da die Stopplinie in einem ausgeschnittenen ROI der Vogelperspektive gesucht wird, muss die Lage des ROI im Fahrzeugkoordinaten bekannt sein. Die Ergebnisse der Bestimmung der Lage des ROI sind im oberen Abschnitt [[OSE_Softwareumgebung#Schritt_1:_Transformation|Transformation]] hinterlegt. Wie die nebenstehende Abbildung zeigt, basiert der Ansatz zur Bestimmung des Abstands zur Stopplinie auf zwei Teilen:
-[[Datei:PrinzipAbstandStopplinie.png|200px|thumb|right|Abstandberechnung zwischen Stopplinie und Fahrzeug]]
-# Der Abstand <math>s</math> zwischen Stopplinie und unterem Rand des ROI wird durch Bestimmung der Bogenlänge des Spurpolynoms ermittelt. Die berechnete Bogenlänge in Pixel muss noch in mm umgerechnet werden. Hierzu wird der oben beschriebene [[OSE_Softwareumgebung#Schritt_1:_Transformation|Umrechnungsfaktor]] in Längsrichtung verwendet.
-# Der Abstand zwischen dem unteren Rand des ROI und Fahrzeug wird als konstant angenommen, sodass hierfür die [[:Datei:OSE_ROI_Fahrzeug_1.png|Lage des ROI im Fahrzeug-KOS]] eingesetzt wird.
-Damit ergibt sich für die Abstandsberechnung folgende Formel: <math> a = s \cdot 2,4 \frac{mm}{px} + 520 mm</math>
-Die Bogenlänge <math> s </math> des Spurpolynoms  <math> x = f(y) = a \cdot y^2 + b \cdot y + c </math>  kann auf 2 Arten berechnet werden:
-# Das Spurpolynom kann in kleine Abschnitte unterteilt werden, für die dann jeweils die euklidische Distanz berechnet wird <ref name="papula1">[https://hshl.bsz-bw.de/cgi-bin/koha/opac-detail.pl?biblionumber=114006&query_desc=kw%2Cwrdl%3A%20Papula%20Band%201 PAPULA, L. Mathematik für Ingenieure und Naturwissenschaftler Band 1. Ein Lehr- und Arbeitsbuch für das Grundstudium. 15. Auflage. Wiesbaden: Springer Vieweg, 2018. ISBN 978-3-658-21746-4.]</ref>:  <math> ds = \sqrt{dx^2 + dy^2} </math>
-# Mit Hilfe der Integralrechnung kann die Formel aus 1. zu  <math> s = \int_{y_S}^{y_{max}} \sqrt{1 + [f'(y)]^2} dy </math>  umgestellt werden <ref name="papula1" />, wobei als Grenzen des Integrals die y-Bildkoordinate der Stopplinie <math> y_S </math> und der untere Rand des ROI <math> y_{max} = 1113 </math> eingesetzt werden.
-Die Berechnung der Bogenlänge wurde im MATLAB-Code für beide Verfahren implementiert ([https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/berechneStopplinienAbstand.m <code>berechneStopplinienAbstand.m</code> (Revision 8137)]). Da das erste Verfahren weniger Rechenzeit in Anspruch nimmt, ist dieses letztendlich in der Funktion [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/berechneStopplinienAbstand.m <code>berechneStopplinienAbstand.m</code>] umgesetzt worden. Detaillierte Ergebnisse des Vergleichs sind in der [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/_Semesterordner/WS2022/Sprint_2/Team_5_OSE_Stopplinie/Praesentation.pptx Meilensteinpräsentation] zu finden.
-===Umsetzung des Ansatzes mit MATLAB<sup>®</sup>===
-In einem ersten Schritt wurde der Ansatz der Stopplinienerkennung in dem MATLAB-Skript [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/_Semesterordner/WS2022/Sprint_1/Team_5_OSE_Stopplinie/stopplinienerkennung.m stopplinienerkennung.m (Revision 7857)] für einige Situationen erfolgreich validiert. Auf Anregung bei der Meilensteinpräsentation soll der Ansatz für die gesamte Strecke validiert werden, bevor der Ansatz endgültig in C-Code umgesetzt wird.
-[[Datei:Ezgif-3-aa149494be25.gif]] '''Ab dem Revisionsstand 8088 befinden sich alle notwendigen Dateien für die Stopplinienerkennung im Software-Ordner''' [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung OSE_Stopplinienerkennung]
-Zur Validierung sind folgende Vorbereitungsschritte notwendig:
-* Das transformierte Video muss aus Visual Studio heraus abgespeichert werden. Da Probleme mit den openCV-Funktionen <code>cv::imwrite</code> und <code>write</code> auftraten, wurde die Funktion [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/Stopplinienerkennung.cpp <code>saveImageData</code> (Revision 7967)] realisiert, die für jedes Frame alle Pixelwerte in je eine txt-Datei schreibt. Anschließend wurden die txt-Dateien mit dem MATLAB-Skript [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/txt2mat.m <code>txt2mat.m</code> (Revision 8088)] in mat-Dateien umgewandelt. Diese wurden im Ordner [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/Videoframes Videoframes (Revision 8088)] abgelegt.
-* Damit die Spurerkennung nicht mit MATLAB realisiert werden muss, wurden neben dem transformierten Video auch die zugehörigen Spurparameter in einer csv-Datei gesichert. Die zugehörige Funktion [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/Stopplinienerkennung.cpp <code>saveSpurparameter</code>] wurde mit der Revision 7927 ergänzt. Die [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/spurparameter.csv <code>spurparameter.csv</code>-Datei (Revision 8088)] besteht aus vier Spalten: In der ersten Spalte befindet sich die Nummer des Frames. Die weiteren drei Spalten beinhalten die Koeffizienten des Spurpolynoms (a, b und c).
-* Um die Stopplinienerkennung zu validieren, wurde das Framework [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/testStopplinienerkennung.m <code>testStopplinienerkennung.m</code>] erstellt, dass die Videoframes und die Spurparameter einliest und mit diesen Werten dann die Funktion [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/stopplinienerkennung.m <code>stopplinienerkennung.m</code>] aufruft.
-===Umsetzung der Stopplinienerkennung in Visual Studio===
-<!--Stopplinienerkennung(imgT, OSE_StopplinieErkannt, OSE_StopplinienAbstand);-->
-Die Umsetzung der Stopplinienerkennung in C++-Code besteht aus zwei Schritten. Zunächst wird mit Hilfe von MATLAB Coder der gewünschte C++-Code generiert, der dann wiederum im zweiten Schritt in den Code des vorhandenen Visual Studio Projekts eingebunden werden muss. Die beiden Schritte werden nachfolgend dokumentiert.
-====Code-Generation mit MATLAB Coder====
-Die Umsetzung der Stopplinienerkennung in Visual Studio wurde mit Hilfe des MATLAB Coders realisiert. Die entsprechende [https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Software/OSE_Stopplinienerkennung/stopplinienerkennung.prj Projektdatei] befindet sich im SVN. Zunächst wird der Nutzer durch die GUI von MATLAB Coder geführt. Dabei werden folgende Schritte durchlaufen:
-# Auswahl des Skriptes/der Funktion, für die Code generiert werden soll: <code>stopplinienerkennung</code>
-# Definition der Übergabeparameter:
-## <code>img</code>: double(1113 x 752)
-## <code>a</code>: double(1 x 1)
-## <code>b</code>: double(1 x 1)
-## <code>c</code>: double(1 x 1)
-# Suche nach Laufzeitproblemen (hier kann ein Check der Software durchgeführt werden=
-# Code-Generation: Mit einem Klick auf "Generate" wird der C++-Code erzeugt, wobei hier noch einige Einstellungen getroffen werden können:
-## Build type: <code>Source Code</code>
-## Language: <code>C++</code>
-## Interface style: <code>Functions</code>
-## More Settings → Path →
-### Working folder: <code>Project folder</code>
-### Build folder: <code>Specified folder</code>
-### Build folder name: '''Hier muss je nach lokalem Projektverzeichnis der vollständige lokale Dateipfad zum Ordner <code>...\OSE_Draufsicht_Spurpolynom_RS232\Bahnspurpolynom_verlinkt\MATLAB_Coder_Stopplinienerkennung</code> ([https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/MATLAB_Coder_Stopplinienerkennung SVN-Link]) eingefügt werden'''
-# Abschluss: Hier kann das Code-Package als *.zip-Datei heruntergeladen werden, muss es aber nicht!
-====Anpassung des Visual Studio Projekts====
-Nachdem nun der C++-Code generiert und bereits im Ordner [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/MATLAB_Coder_Stopplinienerkennung <code>MATLAB_Coder_Stopplinienerkennung</code>] abgelegt wurde, kann nun die Einbindung in das [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung VS-Projekt] beginnen.
-In einem ersten Schritt müssen die generierten Dateien mit dem Projekt verknüpft werden.
-* Die Header-Dateien können mit Hilfe zusätzlicher Include-Verzeichnisse eingebunden werden. Dies kann in Visual Studio im Projektmappen-Explorer unter OSE_Draufsicht_Spurpolynom_RS232 → Eigenschaften → Konfigurationseigenschaften → VC++-Verzeichnisse → Includeverzeichnisse → bearbeiten erfolgen. Hier muss nun eine neue Zeile mit dem Inhalt <code>$(ProjectDir)MATLAB_Coder_Stopplinienerkennung</code> eingefügt werden. Damit wird der Ordner mit den generierten Dateien inkludiert. <code>$(ProjectDir)</code> ermöglicht dabei, dass der Pfad unabhängig vom lokalen Verzeichnis ist. Wichtig ist allerdings, dass nach <code>$(ProjectDir)</code> '''kein''' <code>/</code> eingefügt wird, da dies automatisch ergänzt wird. Der erzeugte Dateipfad kann unten unter "Ausgewerteter Wert" kontrolliert werden.
-* Zwar befinden sich die *.cpp-Dateien auch in diesem Ordner, jedoch werden diese hierdurch nicht inkludiert. Hierzu muss im Projektmappen-Explorer in Visual Studio unter Quelldateien → Hinzufügen → Vorhandenes Element jede einzelne *.cpp-Datei hinzugefügt werden.
-Zusätzlich müssen in der <code>main.cpp</code>-Datei einige Anpassungen vorgenommen werden.
-* Wie in dem von MATLAB Coder generiertem [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/MATLAB_Coder_Stopplinienerkennung/examples Beispiel] müssen einige Header-Dateien inkludiert werden.
-* Die von MATLAB generierte Funktion nutzt nicht den Datentyp <code>cv::Mat</code>, sondern ein eindimensionales Array mit 836976 Elementen (<math>1113 \cdot 752 = 836976</math>). Daher müssen vor der Übergabe des aktuellen Frames die einzelnen Pixel in dem eindimensionalen Array <code>imgSLE</code> abgelegt werden. Die Ablage der einzelnen Pixel erfolgt dabei analog zu dem generierten [https://svn.hshl.de/svn/MTR_SDE_Praktikum/branches/2022_10_05_OSE_Stopplinienerkennung/Bahnspurpolynom_verlinkt/MATLAB_Coder_Stopplinienerkennung/examples Beispiel]. Da Probleme mit der Größe des Heaps auftraten, wurde das Array dynamisch angelegt. Wichtig ist dabei, dass das Array im Anschluss wieder gelöscht wird.
 = Daten senden =

OSE Softwareumgebung: Unterschied zwischen den Versionen