|
|
| (202 dazwischenliegende Versionen von 16 Benutzern werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| = Spurerkennung =
| | <!-- Kopieren Sie diesen Header in Ihren Artikel, damit er aufgelistet wird. --> |
| ==Workflow und Vorgehen ==
| | '''Autoren:''' Hendrik Steffen, Sven Posner <br/> |
| Um schnellere Ergebnisse zu erzielen und ein leichteres Umsetzen der eigenen Ansätze zu ermöglichen wurde entschieden, die Algorithmen in Matlab zu entwickeln und auf Funktionalität zu prüfen.
| | '''Betreuer:''' [[Benutzer:Ulrich_Schneider| Prof. Schneider]]<br/> |
| Anschließend wurden diese dann in C/C++ Code umgesetzt und in das Projekt mit eingebunden. Die folgenden Abschnitte beschreiben welche Voraussetzungen geschaffen wurden, um diesen Entwicklungsansatz umzusetzen.
| | <br> |
| === Modellbasierte Entwicklung in Matlab===
| | → zurück zum Hauptartikel: [[Praktikum SDE]] <br> |
| | <br> |
|
| |
|
| Matlab stellt mit seinen Toolboxen eine große Funktionsvielfalt im Bereich der Bildverarbeitung zur Verfügung.
| | = Aufbau dieser Seite= |
| Diese erleichtern das Umsetzen von eigenen Ansetzen. Einfache Darstellung und Visualisierung vereinfachen insbesondere die Fehlersuche.
| |
| Um auf der späteren Zielhardware zu funktionieren, werden die Algorithmen mit Hilfe Videos entwickelt, das mit einer Kamera aufgenommen wurde, die baugleich mit am Auto verbauten ist.
| |
|
| |
|
| Die fertigen Algorithmen, die der Bildverarbeitung dienen, müssen so aufgebaut sein, dass sie auf Datenbasis eines S/W Kantenbildes arbeiten.
| | Dieser Artikel ist eine Übersichtsseite, in der auf alle relevanten Artikel zur Objekt und Spurerkennung verwiesen wird. <br> |
| Alle Funktionen, die der Umformung des Bildes dienen, müssen ausgelagert werden.
| | Diese Seite soll, insbesondere einem neuen Jahrgang als Einstieg und Orientierung dienen und die hier beschriebenen Softwarestände sollen mit denen im SVN Archiv übereinstimmen. <br> |
|
| | ''' Alle Links und Informationen auf dieser Seite bitte aktuell halten''' <br> |
| Um die in Matlab entworfenen Algorithmen in das C++ Projekt zu übernehmen, gibt es die Möglichkeit den Embedded Coder zu nutzen.
| |
| Dieser ermöglicht es aus Matlab Code C / C++ Code zu generieren. Eine Anleitung zum Generieren von C Code findet sich in dem Artikel "''[[Von Matlab zu C Code|Von Matlab zu C Code]]''"
| |
| Um den Code im "Objekt_Spurerkennung" Projekt zu verwenden, muss unter dem Punkt "''Dateien ins Projekt übernehmen''" des Artikels "''[[Von Matlab zu C Code|Von Matlab zu C Code]]''"
| |
| "''C/C++ Dynamic Libary''" statt "''C/C++ Static Libary''" gewählt werden.
| |
| <br/> | |
|
| |
|
| Bestimmte Matlab Funktionen lassen sich nicht generieren. Hier müssen eigene Funktionen in Matlab programmiert werden um diese zu ersetzen. Eine andere Möglichkeit ist das Einsetzen von Dummyfunktionen in Matlab Code.
| | = '''OSE Softwareumgebung'''= |
| Diese Dummyfunktionen enthalten keine Funktionalität sondern dienen nur als Platzhalter deren Funktionsaufruf im C/C++ Projekt dann durch den Aufruf der jeweiligen in C / C++ umgesetzten Funktion ersetzt wird.
| | In diesem Artikel wird der aktuelle Softwarestand detailliert beschrieben |
| <br/>
| | <br> |
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]] [https://wiki.hshl.de/wiki/index.php/OSE_Softwareumgebung Aktuelle Softwareumgebung für das OSE-Programm] |
|
| |
|
| === Umsetzung in C Code === | | = VRmagic Kamera einrichten = |
| | In diesem Artikel befinden sich Erläuterungen wie die VRmagic Kamera auf dem Fahrzeug benutzt werden kann.<br> |
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]] [https://wiki.hshl.de/wiki/index.php/Inbetriebnahme_der_VRmagic_Kamera Inbetriebnahme der VRmagic Kamera] |
|
| |
|
| ==== Vorausetzungen zum übernehmen der Matlab Algorithmen ==== | | = Open CV installation = |
| Die Grundlage des hier vorgestellten Vorgehens ist, dass die Datenbasis für beide Entwicklungsschritte gleich ist.
| | In diesem Artikel wird die Einbindung der OpenCV Bibliotheken in ein Visual Studio Programm beschrieben. |
| So muss gewährleistet sein, dass die Bilder der Kamera und die aus dem in Matlab verwendeten Video einer Rundfahrt,
| | <br> |
| vor dem Verwenden durch die Algorithmen zur Spur- und Stoplinienerkennung in ein einheitliches Bildformat konvertiert werden.
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]] [https://wiki.hshl.de/wiki/index.php/Einrichten_von_OpenCV_in_Visual_Studio Installation von OpenCV in Visual Studio] |
| <br/> | | = Objekterkennung mit dem Hokuyo LiDAR vom WS2022/2023= |
| [[Datei:Workflow C++ Matlab.png|mini|zentriert|500px| Schaffen gleicher Datenbasis]] | | In diesem Artikel befinden sich Erläuterungen und Dokumentationen für die Verwendung des Hokuyo LiDARs.<br> |
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]] [https://wiki.hshl.de/wiki/index.php/OSE_Hokuyo-Lidar_Objekterkennung OSE Hokuyo-LiDAR Objekterkennung] |
|
| |
|
| In der Matlab Umgebung werden die Video Frames mit der Auflösung 752*478 eingelesen und in die Matrix Frame gespeichert.
| | = Test = |
| Das in Frame gespeicherte Bild wird erst in ein Grau- und anschließend in ein S/W Bild umgewandelt. Auf dieses wird Sobel Operator angewendet.
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]][[OSE - Objekt - und Spurerkennung: Test der Spurparameter-Ermittlung in der Simulation]] |
| Das Ergebnis wird in Frame_bw gespeichert. Frame_bw dient allen in Matlab entwickelten Algorithmen als Datengrundlage und muss bei deren Übersetzung als uint8 Array gespeichert werden.
| |
|
| |
|
| <source lang="matlab">
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]][[OSE - Objekt - und Spurerkennung: Test der Spurparameter-Ermittlung am Fahrzeug]] |
| % Frame lesen
| |
| Frame = imread(Frame_Name,'PNG');
| |
| Frame = rgb2gray(Frame); | |
|
| |
|
|
| |
| % Vorverarbeitung
| |
| Frame_bw = Gray2BW( Frame , 752, 478 );
| |
| Frame_bw = edge(Frame_bw,'sobel','nothinning');
| |
|
| |
|
| </source> | | <br><br><br><br><br><br><br> |
|
| |
|
| Im C++ Projekt werden die Bilder von der auf dem Auto verbauten VRmagic Kamera aufgenommen. Um diese mit den Matlab Algorithmen zu bearbeiten sind noch weiter Schritte nötig.Die Abbildung "''für die Bildverarbeitung relevanten Schritte''" zeigt die Schritte aus der Software "''Objekt_Spurerkennung''" die zur Bildverarbeitung nötig sind.
| | = Veraltete Softwarestände und Artikel = |
|
| |
| [[Datei:Ablaufplan_Objekt_Spurerkennung_Kamera.png|mini|zentriert|350px|für die Bildverarbeitung relevanten Schritte]]
| |
|
| |
|
| Im linken Teil des Bildes sind die Initialisierungsschritte dargestellt. Zuerst muss die Verbindung zur Kamera aufgebaut und Einstellungen wie z.B. die Belichtungszeit gesetzt werden.
| | In diesem Abschnitt folgen veraltete Wiki Artikel zu Softwareständen, die nicht mehr existieren. <br> |
| Anschließend werden Bildcontainer für das Quell- (''p_gray_src_img'') und das Ausgabebild(''p_out_img'') angelegt. Das Quellbild wird im Bildfromat "''VRM_GRAY_8''" gespeichert. Somit kann die Umwandlung von RGB zu Grau entfallen.
| | Die Softwarestände wurden mit Revison 6746 aus dem SVN Archiv gelöscht |
|
| |
|
| <source lang="cpp"> | | <div class="mw-collapsible mw-collapsed"> |
| VRmImage* p_gray_src_img = 0;
| |
| VRmImageFormat gray_format;
| |
| gray_format.m_width = 752;
| |
| gray_format.m_height = 478;
| |
| gray_format.m_color_format = VRM_GRAY_8;
| |
| gray_format.m_image_modifier = 0;
| |
|
| |
|
| // allocation of gray level source image, use VRmUsbCamFreeImage to free images allocated with VRmUsbCam Lib | | == Alter LiDAR-Wiki Artikel == |
| if(!VRmUsbCamNewImage(&p_gray_src_img, gray_format))
| | '''Hier gehts zu Artikel''' [[Datei:Ezgif-3-aa149494be25.gif]] [https://wiki.hshl.de/wiki/index.php/Objekterkennung_mit_Laserscanner Hokuyo LiDAR Objekterkennung (alt)] |
| LogExit();
| |
|
| |
| </source>
| |
|
| |
|
| Das Ausgabebild muss in einem mit der Ausgabe auf dem Bildschirm durch die "SDL Bibliothek" kompatiblem Bildformat vorliegen. Es wird im Format "VRM_ARGB_4X8" gespeichert. Weiter Informationen über die verwendbaren Formate finden sich in der Datei "''vrmusbcam2.h''".
| | == Kamerakalibrierung == |
|
| |
|
| <source lang="cpp">
| | '''Neuer Ansatz incl. extrinsische Kalibrierung''' |
| // allocation of gray level image for output in SDL window, use VRmUsbCamFreeImage to free images allocated with VRmUsbCam Lib
| |
| VRmImage* p_out_img = 0;
| |
| VRmImageFormat bgr888_format;
| |
| bgr888_format.m_width = 752;
| |
| bgr888_format.m_height = 478;
| |
| bgr888_format.m_color_format = VRM_ARGB_4X8;
| |
| bgr888_format.m_image_modifier = 0;
| |
|
| |
|
| if(!VRmUsbCamNewImage(&p_out_img, bgr888_format))
| | In diesem Artikel wird die intrinsische und extrinsische Kalibrierung der Kamera beschrieben. Dazu wird die OpenCV Bibliothek in einem C/C++ Programm verwendet.<br> |
| LogExit();
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Kalibrierung_der_Kamera Kalibrierung der Kamera] |
| </source>
| |
|
| |
|
| Nach dem Anlegen der Bildcontainer wird der Framecounter der Kamera zurückgesetzt und der "Grabber" zum holen der Bilder gestartet.
| | '''Alter Ansatz''' |
| Im Anschluss wird die Main Loop gestartet und zyklisch ausgeführt. Zu Beginn jedes Zyklus wird ein neues Bild von der Kamera geladen und anschließend in ''p_gray_src_img'' konvertiert.
| |
| Um es später auszugeben wird ''p_gray_src_img'' in das Output Bildformat konvertiert und als ''p_out_img'' gespeichert.
| |
| <source lang="cpp">
| |
| // lock next (raw) image for read access
| |
| VRmImage* p_source_img = 0;
| |
| VRmDWORD frames_dropped = 0;
| |
| if(!VRmUsbCamLockNextImageEx(device, port, &p_source_img, &frames_dropped))
| |
| LogExit();
| |
|
| |
|
| | In diesem Artikel findet sich die Beschreibung wie die Kameraparameter bestimmt werden können. Als Tool wird hier die Camera Calibrator Toolbox von Matlab verwendet. |
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Kameraparametrierung Kameraparametrierung] |
|
| |
|
| // convert source image into gray image for further processing with VM_LIB
| | == Draufsichterstellung == |
| if(!VRmUsbCamConvertImage(p_source_img, p_gray_src_img))
| | In diesem Artikel wird die Draufsichterstellung für das Fahrzeug erläutert. |
| LogExit();
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Draufsichterstellung Draufsicht] |
|
| |
|
| // ... and copy the source image to the output image
| | == Fahrspurerkennung == |
| CopyGrayToOutRGB(p_gray_src_img, p_out_img);
| | In diesem Artikel ist die Fahrspurerkennung dokumentiert, welche momentan auf dem Fahrzeug implementiert ist. |
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Fahrspurerkennung Fahrspurerkennung] |
|
| |
|
| </source> | | == Berechnung des Spurpolynoms == |
| Anschließend wird die Funktion "''objekt_und_spurerkennung''" mit dem Bilder als Parameter aufgerufen. Diese Funktion erlaubt es die aus Matlab generierten Funktionen einzubinden.
| | Dieser beschreibt die Berechnung des Spurpolynoms in Matlab und den Aufruf des in C/C++ generierten Codes. |
| <source lang="cpp">
| | <br> |
| // Kantenerkennung für die entsprechenden Zeilen
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Berechnung_des_Spurpolynoms#Link_zum_Quelltext_und_zum_Komponententest_in_SVN Berechnung des Spurpolynoms] |
| sobel_und_bw(p_gray_src_img, p_gray_out_img, gx, gy, temp_PoI, PoI_size , on_jump );
| |
|
| |
|
| // Umwandeln in Bw Typ um einfache überführung von Matlab zuermöglichen
| | == Übertragen des Spurpolynoms == |
| umwandeln_bw_bild_hin(p_gray_out_img->mp_buffer, Frame_bw_einzeilig);
| | In diesem Artikel ist die Kommunikation zwischen dSpace Karte und Computer über die RS232, zur Übertragung des Spurpolynoms, dargestellt. |
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Übertragen_des_Spurpolynoms#Link_zum_Quelltext_und_zum_Komponententest_in_SVN Übertragen des Spurpolynoms] |
|
| |
|
| // Finde die Spurkoordinaten im ROI
| | == Simulationsumgebung für die Objekt- und Spurerkennung == |
| spur_finden(p_gray_src_img, Frame_bw_einzeilig, x, y, index, temp_PoI, PoI_size, on_jump,PoI_default,gx,gy);
| | In diesem Artikel wird die Simulationsumgebung für die Objekt- und Spurerkennung vorgestellt. |
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Simulationsumgebung_für_die_Objekt-_und_Spurerkennung Simulationsumgebung für die Objekt- und Spurerkennung] |
|
| |
|
| // Berechnung und Filterung des Schwerpunktes in X-Richtung des POI
| | == Stopplinienerkennung == |
| kalmanfilter(index, iterator, temp_PoI, PoI_default);
| | In diesem Artikel wird die Stopplinienerkennung vorgestellt. |
| | <br> |
| | '''Hier gehts zu Artikel''' [https://wiki.hshl.de/wiki/index.php/Stopplinienerkennung_mit_Hough-Transformation Stopplinienerkennung] |
|
| |
|
| | </div> |
|
| |
|
| Entfernung=finde_stoplinie(Frame_bw_einzeilig,&Stoplinie,&Trefferzeile);
| | =Archiv bisheriger Arbeit (sehr alte Artikel) = |
|
| | <div class="mw-collapsible mw-collapsed"> |
| //Transformiere die Bildkoordinaten in Weltkoordinaten
| | == [[Alter Ansatz OSE-Objekt- und Spurerkennung]] == |
| koordinatentransformation(index, x, y, Kanten_Spur_x, Kanten_Spur_y, Kanten_Spur_g);
| | == [[Zentralperspektive "Umrechnung von Bild- zu Weltkoordinaten"]] (aktuell verwendeter Ansatz) == |
|
| |
|
| //Bestimme aus den Weltkoordinaten ein Polynom und verschiebe auf Sollspur
| |
| valide_funktion = polynombestimmung(index, temp_koeff, Kanten_Spur_g ,verschiebung[iterator]);
| |
|
| |
| // Zurück Umwandeln aus Bw Typ zur Darstellung
| |
| umwandeln_bw_bild_zurueck(p_gray_out_img->mp_buffer, Frame_bw_einzeilig);
| |
| </source>
| |
|
| |
| Zuerst wird mit Hilfe der Funktion "''sobel_und_bw''" der Sobel Operator auf die relevanten Zeilen des entsprechenden ROIs angewendet und ein Kantenbild erstellt. Anschließend wird durch eine Schwellwertentscheidung das Kantenbild in ein S/W Bild umgerechnet und in dem ''VRM_ARGB_4X8'' Format des Output Bildcontainers gespeichert. Zu beachten ist hierbei der unterschiedliche "pitch" der Bildformate.Dieser gibt an wie viele Bytes einen Pixel repräsentieren. Das ''VRM_GRAY_8'' ist ein 8 Bit Format; jeder Pixel wird durch ein Byte dargestellt. Das ''VRM_ARGB_4X8'' ist ein 32 Bit Format; hier wird jeder Pixel durch 4 Bytes beschrieben. Dieses setzt sich aus 4 Kanälen (jeder entspricht einem Byte pro Pixel) : dem Alphakanal, dieser gibt die Transparenz an, und den 3 Farbkanälen Rot, Grün und Blau. Um das ''VRM_GRAY_8'' in das ''VRM_ARGB_4X8'' Format umzuwandeln, werden Daten des einen Kanals in alle 3 Farbkanäle des neuen Formats geschrieben. Da das Bild keine Transparenz besitzen soll, wird der Alphakanal auf sein Maximum gesetzt.
| |
|
| |
| <source lang="cpp">
| |
| p_gray_out_img->mp_buffer[(r) * p_gray_out_img->m_pitch + x * 4 + 0] = (unsigned char)grad;
| |
| p_gray_out_img->mp_buffer[(r) * p_gray_out_img->m_pitch + x * 4 + 1] = (unsigned char)grad;
| |
| p_gray_out_img->mp_buffer[(r) * p_gray_out_img->m_pitch + x * 4 + 2] = (unsigned char)grad;
| |
| // Alphakanal hoch setzen --> Transparenz
| |
| p_gray_out_img->mp_buffer[(r) * p_gray_out_img->m_pitch + x * 4 + 3] = 255;
| |
| </source>
| |
|
| |
| Mit der Funktion "''umwandeln_bw_bild_hin''" ist es möglich das Bild aus dem ''VRM_ARGB_4X8'' Format in ein für die mit Matlab generierten Funktionen kompatibles Bildformat umzuwandeln.
| |
|
| |
| Die Funktion "''spur_finden''" ermittelt dann anschließend alle Spurpunkte, die sich in dem ROI befinden. Hier ist zu beachten das zu Beginn die Zeilen noch oben hin untersucht werden. Wenn die oberste Zeile des ROIs erreicht wurde, spring der Algorithmus in die erste Zeile des ROIs zurück und sucht dann den Teil unterhalb des ROIs nach möglichen Spurpunkten ab. Dieser letzte Schritt ist notwendig, da die Punkte nahe des Fahrzeuges als besonders bedeutend einzustufen sind.
| |
|
| |
| Nachdem dann alle Spurpunkte ermittelt wurden, wird mittels des Funktion "''kalmanfilter''" der neue Schwerpunkt des ROIs aus den gefundenen Spurpunkten berechnet und anschließend mit dem Kalmanfilters gefiltert. Denn so wandert der jeweilige ROI mit dem Spurverlauf mit und das Risiko keine Spur zu finden wird minimiert.
| |
|
| |
| Die Koordinatentransformation der Bildpunkte in die Kamerakoordinaten führt die Funktion "''koordinatentransformation''" durch. Anschließend wird aus den realen Spurpunkten eine Polynom interpoliert mittels der Funktion "''valide_funktion''". Dieses Polynom wird schlussendlich noch in das Sollpolynom linksverschoben von der rechten Fahrbahnmarkierung umgerechnet.
| |
|
| |
| Die Umkehrung der Funktion "''umwandeln_bw_bild_hin''" erlaubt die Funktion "''umwandeln_bw_bild_zurueck''". Um diese Funktionen nutzen zu können, muss das Bild als S/W Kantenbild im ''VRM_ARGB_4X8'' Format bereitgestellt werden.
| |
| Nach dem Umwandeln in das Ausgabeformat werden in das Bild gefundene Spurpixel Rot gekennzeichnet und das Bild ausgegeben.
| |
|
| |
| ====Übernahme der Matlab Algorithmen====
| |
| Die Struktur des C++ Projektes ermöglicht es einfach neue Module hinzuzufügen. Dies gilt sowohl für Matlab-generierte Module als auch für handgeschriebe Module wie z.B. Komunikation. Dieser Teil zeigt wie ein zuvor nach dem Artikel "''[[Von Matlab zu C Code|Von Matlab zu C Code]]''" erzeugtes Modul integriert wird. Nach dem Generieren liegt in dem zum generieren angelegten Projektordner der Ordner "codegen" vor. Dieser beinhaltet den Ordner "dll". Dies steht für Dynamic Link Library. Ist dies nicht der Fall muss der Code erneut als "''C/C++ Dynamic Libary''" generiert werden. Ist er vorhanden, enthält er den Ordner mit dem gewählten Modulnamen. Dieser wird in die in Abbildung "''Projekt Struktur''" gezeigten Struktur in den Ordner Module hinzugefügt.
| |
| [[Datei:Projekt Struktur Obejekt Spurerkennung.png|mini|zentriert|800px|Projekt Struktur]]
| |
| Anschließend müssen entweder alle Dateien aus dem Ordner bis auf "''Modulname''.c", "''Modulname''.h" und "''Modulname_''types.h" gelöscht werden. Oder es werden alle Dateien zur Nachvollziehbarkeit gespeichert.
| |
| In das Visual Studio Projekt werden nur "''Modulname''.c", "''Modulname''.h" und "''Modulname_''types.h" hinzugefügt da alle anderen Daten entweder nicht relevant sind oder bereits existieren. Da das Projekt als C++ Projekt angelegt ist, muss die ".c" in eine ".cpp" Datei umbenannt werden.
| |
| In Visual Studio ist das Projekt in dieselbe Struktur geteilt in der es auch im Ordner abgelegt ist. Es wird jedoch zwischen ".h" und".c"
| |
| Dateien unterschieden. Dementsprechend muss der Modulordner sowohl unter Headerdatein als auch unter Quelldateien hinzugefügt werden. [[Datei:Visual Studio Projektstruktur.png|mini|zentriert|800px|Visual Studio Projektstruktur]]
| |
| Anschließend muss der Modulordner als zusätzliches Inventarverzeichnis hinzugefügt werden. Dies wird in dem Menü Projekteigenschaften vorgenommen. Nach einem Rechtsklick auf Objekt_Spurerkennung (siehe Abb. Visual Studio Projektstruktur)
| |
| öffnet sich ein Kontextmenü in dem der letzte Punkt "Eigenschaften" gewählt werden muss. Anschließend öffnet sich das gesuchte Menü.
| |
| [[Datei:Objekt_Spurerkennung-Eigenschaftenseiten.png|mini|zentriert|500px|Objekt_Spurerkennung-Eigenschaftenseiten]]
| |
| In diesem muss unter zusätzliche Inventarverzeichnisse der Modulordner hinzugefügt werden.
| |
| Nachdem das Modul erfolgreich in das Projekt eingefügt wurde, müssen nun noch Code-Anpassungen vorgenommen werden. Falls in Matlab Dummyfunktionen für in C++ bereits vorhandene Funktionen eingebaut wurden, müssen diese jetzt durch ihre C++ Funktionen ersetzt werden. Ebenso müssen die Includes der Header "Modulname_initialize.h" und "Modulname_terminate.h" entfernt werden. Da bestimmte Matlab Funktionen nicht generierbar sind, kann es zu weiteren Änderungen im Code kommen. Es empfiehlt sich dies gut hervorzuheben und durch Kommentare zu rechtfertigen.
| |
|
| |
| == Umsetzung ==
| |
| === Spur finden und auswerten ===
| |
| Damit das Fahrzeug innerhalb einer Fahrbahn geregelt fahren kann, muss in irgendeiner Form der Verlauf der Strecke wahrgenommen werden. Dies funktioniert kameragestützt. Der Ansatz zur Spurerkennung orientiert sich an den sogenannten "regions of interest" (ROI). Diese ROIs sind definierte, aber auch dynamsiche Bildauschnitte, in denen die jeweiligen Fahrbahnmarkierungen gesucht werden. Momentan ist ein ROI für die rechte und die linke Fahrbahnmarkierung implementiert. Die Mittellinie wird nicht berücksichtigt, weil sie lediglich aus unterbrochenen Abschnitten besteht. Der allgemeine Algorithmus weist folgenden Ablauf auf:
| |
|
| |
|
| |
| [[Datei:Spurpolynomberechnung.png|mini|zentriert|300px| PAP ROI-Auswahl]]
| |
|
| |
|
| |
| Innerhalb jedes ROIs werden dann die relevanten Punkte der Fahrbahnmarkierung bestimmt. Hierzu startet der Spurerkennungsalgorithmus mittig in der untersten Zeile. Je nach Parametrierung werden die Zeilen dann nach rechts oder links auf mögliche Spurpunkte untersucht. Ein valider Spurpunkt muss zwei Bedingungen erfüllen. Zum einen müssen in der Zeile zwei Kantenübergänge gefunden werden, die auch einen maximalen Abstand voneinander nicht überschreiten dürfen. Ist dies erfüllt wird die Mitte als vorläufiger Spurpunkt angenommen. In der darauf anschließenden Bedingung darf der Winkel zwischen dem aktuellen und dem alten Richtungsvektor nicht mehr als 45° betragen. Ist der linke bzw.rechten Rand des ROIs überschritten oder ist ein valider Spurpunkt gefunden, springt der der Algorithmus um den aktuellen Richtungsvektor verschoben intervallmäßig mittig in die nächste zu untersuchende Zeile.
| |
|
| |
| [[Datei:Fahrspur.png|mini|links|300px| Spurpunktverifizierung]]
| |
|
| |
|
| |
|
| |
| [[Datei:Spurerkennungsalgorithmus.png|mini|mittig|400px| PAP Spurpunktfindung]]
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
|
| |
| === Kalman Filter ===
| |
| Da die Fahrbahnmarkierungen dynamisch im Kamerbild wandern, ist es sinnvoll auch die ROIs in X-Richtung des Bildes zu verschieben. Daher wird der Mittelwert aller X-Koordinaten der Fahrbahnspurpunkte eines ROIs ermittelt. Anschließend wird dieser Schwerpunkt noch mit einem Kalmanfilter gefiltert, um Sprünge und hochfrequente Verschiebungen zu dämpfen. Der Vorteil des Kalmanfilters liegt darin, dass er nicht immer den realen Werten "hinterherläuft".
| |
|
| |
| Das Kalmanfilter muss für diese Anwendung nur noch parametrisiert werden, da die einzelnen Berechnungsschritte stets dieselben sind. Es wurde der Ansatz über 4 Systemzustände gewählt:
| |
| - x-Position des Schwerpunkts
| |
| - Geschwindigkeit in x-Richtung
| |
| - y-Position des Schwerpunkts
| |
| - Geschwindigkeit in y-Richtung
| |
| Die Positionen können hierbei gemessen während die Geschwindigkeiten lediglich aufgrund der Positionsänderung geschätzt werden. Dies entspricht also einem einfachen physikalischem Modell, sodass sich die Systemmatrix wie folgt gewählt wurde:
| |
| <source lang="matlab">
| |
| A = [ 1 dt 0 0
| |
| 0 1 0 0
| |
| 0 0 1 dt
| |
| 0 0 0 1 ];
| |
| </source>
| |
| Dies soll als physikalische Grundlage genügen. Da somit eine Dynamik im Modell entfällt, kann die Matrix B zu Null gewählt werden. Die Messmatrix ergibt sich für die einzelnen Systemzustände zu 1 für direkt gemessene Elemente und zu 0 für lediglich indirekt beobachtete Komponenten. Um mit dem Filter gute Ergebnisse zu erzielen, muss schließlich noch betrachtet werden wie sehr das Filter den Messwerten bzw. dem System vertrauen soll. Hierbei haben diverse Versuche zu der Erkenntnis geführt, dass die folgenden Einstellungen das Filter befähigen, die Schwerpunkte auch bei schlechten Werten noch gut zu tracken und trotzdem relativ schnell auf Änderungen zu reagieren, sodass das Filter nicht den Daten "hinterhängt":
| |
| <source lang="matlab">
| |
| Q = 0.01*eye(4);
| |
| R = 0.5*[ 10 0; 0 10 ];
| |
| </source>
| |
| Der Startwert wird geschätzt. Da keine Informationen darüber vorliegen wo die Schwerpunkte zu Beginn liegen, wurde dieser Vektor zu Null gewählt. Aufgrund der oben beschriebenen guten Reaktionsfähigkeit des Filters nähert sich dieses innerhalb weniger Zyklen den wahren Werten sehr gut an.
| |
|
| |
|
| |
| [[Datei:Kalmanfilterung.jpg|mini|links|400px| Kalmanfilterung der ROI Mittelpunkte]]
| |
|
| |
|
| |
|
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
| <br />
| |
|
| |
| === Polynom berechnen ===
| |
|
| |
| Die gefundenen Fahrbahnpunkte werden durch ein Polynom zweiten Grades interpoliert. Dabei kommt die Methode der kleinsten Fehlerquadrate zu Einsatz.
| |
|
| |
| Das Spurpolynom, das durch die Kamera ermittelt wird, beschreibt den Verlauf der rechten oder linken äußeren Fahrspur. Das Fahrzeug selbst soll aber in der Mitte der rechten Fahrbahn geregelt fahren. Dafür müsste das Polynom den Verlauf der Fahrbahnmitte beschreiben. Da dort jedoch keine Daten zu ermitteln sind, muss das gefundene Polynom umgerechnet werden.
| |
|
| |
| Ein sehr simpler Ansatz wäre das Polynom einfach um 20cm nach links bzw. 60 cm nach rechts zu verschieben, weil dies exakt die Hälfte der Fahrbahnbreite ist. In der Implementierung würde dies bedeuten, dass lediglich der Wert C (ax²+bx+c) um diese bestimmten cm korrigiert werden muss. Auf gerader Strecke ist diese Umformung sogar fehlerfrei. In Kurven würde dies aber Ungenauigkeiten bedeuten, da sich hier auch die Krümmungen der Parabeln für die Fahrbahnmitte und die Außenlinie unterscheiden.
| |
|
| |
| Um dieses Problem zu lösen muss ein anderer Ansatz gewählt werden. Ziel ist es nun zu jedem Punkt auf der ursprünglichen Parabel den entsprechenden Punkt auf dem neuen Polynom bestimmen zu können. Dabei wird die Straßengeometrie ausgenutzt.
| |
|
| |
| Zunächst wird ein Wert in das ursprüngliche Polynom eingesetzt. Dieser Wert sollte sinnvollerweise in dem Bereich liegen in dem das Polynom auch die Fahrspur beschreibt. Es ergibt sich also ein Punkt mit den Werten X und Y auf der Außenlinie. Über den korrelierenden Punkt des Zielpolynoms ist nun bekannt das er in einer euklidischen Distanz von 20cm bzw 60 cm zum Ausgangspunkt liegt. Als nächstes wird die Ableitung in diesem zuvor eingesetzten Punkt berechnet. Am Beispiel des Steigungsdreieckes zur Bestimmung von Ableitungen lassen sich die folgenden Schritte leicht erklären. Es teilt die Steigung in diesem Punkt in eine Strecke in X- und Y-Richtung ein. Da diese rechtwinkling aufeinander stehen, lassen sich die Wikelfunktionen hier anwenden. Die Strecken in X- und Y-Richtung stellen die Katheten in diesem Dreieck dar und ihr Quotient (Tangens) entspricht der Steigung, die zuvor durch Ableiten bereits ermittelt wurde. Es ist also möglich aus der Ableitung wieder die Anteile in X- und Y-Richtung zu bestimmen, indem der Arcustangens angewedet wird. Der Sinus bzw. Cosinus des hieraus resultierenden Winkels ergibt entsprechend die relative Steigung in X- bzw. Y-Richtung. Jeweils mit 20cm oder 60cm multipiziert erhält man die Werte um die der Ausgangspunkt zu verschieben ist, damit er auf dem Zielpolynom liegt.
| |
|
| |
| Wiederholt man diesen Vorgang für mehrere Punkte und interpoliert durch diese anschließend eine neue Parabel, so beschreibt diese den Verlauf der Fahrbahnmitte der rechten Fahrspur.
| |
|
| |
| === Stoplinie finden ===
| |
| Damit das Fahrzeug sich gemäß geltender Verkehrsregeln verhalten kann und dementsprechend an Kreuzungen mit Stopplinien anhält, muss es in der Lage sein solche zu erkennen und zu tracken.
| |
|
| |
| Diese Funktionalität wird mit Hilfe der am Fahrzeug montierten VR Magic Kamera umgesetzt. Der Code der Stopplinienerkennung soll dabei in das Programm zur Spurerkennung integriert werden, da die Performance auf diese Weise erheblich gesteigert werden kann. Schließlich müssten andersfalls bildvorverarbeitende Maßnahmen wie z.B. das Sobeln erneuet ausgeführt werden.
| |
|
| |
| Für das Erstellen des Quellcodes zur Stoplinienerkennung wurde zunächst die Annahme getroffen, dass Stoplinien stets eine horizontale weiße und wenige Pixel breite Linie im gesobelten Bildausschnitt darstellen. Darüber hinaus kann davon ausgegangen werden, dass sich diese Linie etwa in der Mitte des Bildes befinden muss, da das Fahrzeug schließlich die Spur halten soll.
| |
|
| |
| Der Algorithmus unterscheidet grundsätzlich zwei Fälle:
| |
| - Es liegen aktuell keien Daten zu einer Stoplinie vor
| |
| - Es wird aufgrund vorangegangener Frames eine Stoplinie getrackt
| |
| Wird keine Linie getrackt, wird eine 18 Elemente lange Spalte in der Bildmitte beginnend an der oberen Kante der gesobelten ROI abgefragt. Stößt man dabei auf einen weißen Pixel, könnte es sich um eine Stoplinie handeln. Um dies zu verifizieren, wird ausgenutzt, dass diese Stoplinie ja horizontal verlaufen müsste. Der Vorgang wird also einige Pixel links und rechts neben diesem ersten Treffer wiederholt. Ist die Suche auch in diesen Fällen erfolgreich, wird fortan davon ausgegangen, dass es sich um eine Stoplinie handelt. Mit Hilfe der Bild_zu_Welt-Funktion, die auch bei der Spurerkennung eingesetzt wird, lässt sich berechnen, wie weit die Stoplinie vom aktuellen Standpunkt noch entfernt ist. Aufgrund der dabei verwendeten Zentralperskektive die in der Bildmitte am genausten ist, wird von den drei Treffern, die bei der Abfrage erzielt wurden, der mittlere genutzt. Dieser Ansatzt nutzt zudem die Tatsache aus, dass bei einer Geradeausfahrt die Stoplinie von oben in das Bild hinein rücken muss. Eine auf diese Weise gefundene Stoplinie ist abhängig davon welches der 18 Elemente der Treffer war noch etwa 1,3m entfernt.
| |
|
| |
| Die Entfernung in Metern wird neben den Spurdaten an die Regelung übermittelt. Intern wird zusätlich die Trefferzeile gespeichert, da mit Hilfe dieser ein Tracking der gefundenen Linie im folgenden Frame möglich ist. Im nächsten Zyklus wird anstatt am oberen Rand der ROI in der Bildzeile gestartet, die im letzten Durchlauf gespeichert wurde. Da das Fahrzug sich zwischen den Bildern etwas nach vorne bewegt hat, sollte die Stoplinie nun etwas weiter unten im Bild zu finden sein. Durch das erneute Abfragen der nächsten 18 Bildzeilen ist relativ sicher, dass die Linie wiedergefunden wird, wenn es sich wirklich um eine Stoplinie gehandelt hat, da dieser Wert sehr wohlwollend gewählt wurde. Auf diese Weise ergibt sich eine neue Trefferzeile für den nächsten Zyklus und damit auch ein neuer Abstand in Metern. Es ist somit möglich die Linie bis etwa 30cm vor das Auto selbst zu tracken, da bei geringeren Abständen das Fahzeug sebst die Linie verdeckt und ein Erkennen so unmöglich macht.
| |
|
| |
| Ist die Suche nach weißen Pixeln einmal nicht erfolgreich bedeutet das entweder, dass in den nächsten ca. 130cm keine Stoplinie ist oder die bisher getrackten Daten nicht zu einer Stoplinie gehören. Der Track wird nach nur einmaligem Fehlschlagen der Suche gelöscht, da dies vorrausetzt, dass er nicht in den folgenden 18 Bildzeilen wiedergefunden werden konnte und dies schließlich ein sehr kulanter Wert ist.
| |
|
| |
| == Weitere Ansätze ==
| |
| === Kalman Filter ===
| |
| Die bisherige Spurerkennung ist stark fehleranfällig für fehlende Spurelemente. Diese können aufgrund von Lichtreflexen oder Lücken in der Fahrspur entstehen. Um die Spurerkennung robust gegenüber solchen Störungen zu gestalten, wird im folgenden ein Ansatz beschrieben, der die gefundenen Punkte einer Spur auf einen Schwerpunkt reduziert, diesen Mithilfe des Kalman Filters trackt und im nächsten Zyklus nur im Bereich des geschätzten Schwerpunktes sucht. Sollte keine Spurinformation in diesem Bereich vorhanden sein, wird der Wert durch den Kalman Filter bereitgestellt.
| |
| ==== Vorbereitung der Bilddaten ====
| |
|
| |
| Der neue Ansatz der Spurerkennung soll nicht nur robuster sein, sondern auch einen Spurwechsel ermöglichen. Aus diesem Grund wird nicht nur die rechte Fahrbahnbegrenzung sondern auch die Mittellinie getrackt. Im Falle eines Spurwechsels würde die linke und die mittlere Linie verfolgt werden.
| |
| Zuerst wird das Bild vor verarbeitet. Es wird in ein S/W Bild umgewandelt, mithilfe des Sobel Operators in ein Kantenbild umgewandelt und auf zwei Regionen reduziert. In der Abbildung "links Graubild,mitte ROI,rechts Kantenbild" wurde die Reihenfolge aus Darstellungsgründen vertauscht. Das auf der rechten Seite zu sehende Bild entspricht dem beschrieben Stand.
| |
| [[Datei:Roi Kalman Spurerkennung.png|mini|zentriert|600px|links Graubild,mitte ROI,rechts Kantenbild ]]
| |
| Aus der mittleren Bildspalte heraus, werden 8 Zeilen in den zwei Regionen auf Schwarz/Weiß- Übergänge geprüft. Die linke Region von rechts nach links und die rechte Region von links nach rechts. Unter der Annahme, dass sich das Auto auf einer Fahrspur befindet sind die ersten Übergänge die Begrenzungslinien. Diese gefundenen Punkte werden anhand des Abstandes im Weltkoordinaten zum Mittelpunkt der Autofront verifiziert. Diese werden je Region zu einem Schwerpunkt zusammengefasst und mithilfe des im nächsten Abschnitts beschriebenen Kalman Filters getrackt. Im nächsten Zyklus werden die Regionen abhängig von dem geschätzten Schwerpunkt aufgespannt.
| |
|
| |
| ==== Schwerpunkte tracken ====
| |
| Der Schwerpunkt liegt in Form eines Koordinatenpaares (x/y) vor und soll nun getrackt werden. Dies wird mit Hilfe eines Kalman Filters umgesetzt. Dieses muss für diese Anwendung nur noch parametrisiert werden, da die einzelnen Berechnungsschritte stets dieselben sind. Wir wählen also den Ansatz das unser System über 4 Zustände verfügt:
| |
| - x-Position des Schwerpunkts
| |
| - Geschwindigkeit in x-Richtung
| |
| - y-Position des Schwerpunkts
| |
| - Geschwindigkeit in y-Richtung
| |
| Die Positionen können hierbei gemessen werden während die Geschwindigkeiten lediglich aufgrund der Positionsänderung geschätzt werden. Dies entspricht also einem einfachen physikalischem Modell, sodass sich die Systemmatrix wie folgt erstellen lässt:
| |
| <source lang="matlab">
| |
| A = [ 1 dt 0 0
| |
| 0 1 0 0
| |
| 0 0 1 dt
| |
| 0 0 0 1 ];
| |
| </source>
| |
| Dies soll als physikalische Grundlage genügen. Da somit eine Dynamik im Modell entfällt, kann die Matrix B zu Null gewählt werden. Die Messmatrix ergibt sich für die einzelnen Systemzustände zu 1 für direkt gemessene Elemente und zu 0 für lediglich indirekt beobachtete Komponenten. Um mit dem Filter gute Ergebnisse zu erzielen, muss schließlich noch betrachtet werden wie sehr das Filter den Messwerten bzw. dem System vertrauen soll. Hierbei haben diverse Versuche zu der Erkenntnis geführt, dass die folgenden Einstellungen das Filter befähigen, die Schwerpunkte auch bei schlechten Werten noch gut zu tracken und trotzdem relativ schnell auf Änderungen zu reagieren, sodass das Filter nicht den Daten "hinterhängt":
| |
| <source lang="matlab">
| |
| Q = 0.01*eye(4);
| |
| R = 0.5*[ 10 0; 0 10 ];
| |
| </source>
| |
| Der Startwert kann nun geschätzt werden. Da keine Informationen darüber vorliegen wo die Schwerpunkte zu Beginn liegen, wurde dieser Vektor zu Null gewählt. Aufgrund der oben beschriebenen guten Reaktionsfähigkeit des Filters nähert sich dieses innerhalb weniger Zyklen den wahren Werten sehr gut an.
| |
|
| |
| === Maske Für das Auto ===
| |
| Durch die Position der Kamera auf dem Auto, ist ein Teil des Autos auch im Kamerabild sichtbar. Diese Informationen können sich im laufe der Bildverarbeitung als störend erweisen und ein Spur oder Start/Stopp Linien erkennen erschweren.
| |
| Um eine Fehlinterpretation der Daten zu verhindern und die Spur oder Start/Stopp Linien Erkennung zu erleichtern ist es Sinnvoll diese Bildinformationen zu entfernen. Ein Ansatz der in Matlab bereits erfolgreich getestet wurde ist das Verwenden einer passenden Maske. Eine Binärmatrix die im Bereich des Autos mit Nullen und sonst mit Einsen besetzt ist und die Dimension der Bild Matrix besitzt. Nach einer Multiplikation der Matrizen sind alle Bildinformationen über das Auto entfernt.
| |
| [[Datei:Kamerabild mit Maske.png|mini|zentriert|600px|Kamerabild, Maske, Kamerabild mit Maske]]
| |
|
| |
| =Inverse Perspective Mapping=
| |
| Bei der Verwendung einer Kamera zur Fahrspurerkennung ergibt sich immer das Problem der perspektischen Verzerrung. Grund dafür ist, dass bei der Projektion aus dem 3D-Weltkoordinatensystem in das 2D-Koordinatensystem des Bildes Information verloren gehen. Das Inverse Perspective Mapping (IPM) bietet eine Möglichkeit die verloren gegangenen Daten zu rekonstruieren und das Bild in entzerrter Vogelperspektive darzustellen.
| |
|
| |
| [[Datei:SDE IPM.png|left]]
| |
|
| |
| Dabei wird das Bild unter Verwendung von geometrischen Beziehungen aus dem Weltkoodinatensystem W = {(x,y,z)} in ein volgelperspektivisches Bild I = {(u,v)} transformiert. Dabei ist die die y-Komponente, wie auch in der Abbildung zu sehen ist, stets 0. Das liegt daran das eindeutige Zuordnung der Punkte nicht ohne Weiteres möglich, da schließlich Informationen verloren gegangen sind. Da hierbei Straßenlinien gefunden werden sollen, kann die Annahme getroffen, dass alle Punkte auf dem Boden und damit auf y = 0 liegen müssen.
| |
| Im Fall nicht ebenen Straßen gilt diese Annahme nicht und fürht daher zu Fehlern. Das bedeutet, dass das IPM beispielsweise bei Straßen in Gebirgen nicht geeignet ist. Auch möglicherweise vor einem fahrende andere Fahrzeuge liegen nicht in der Bodenebene und sind in der Vogelperspektive verzerrt dargestellt. Der Abstand zu ihnen kann aber bestimmt werden.
| |
| Außerdem müssen damit das IPM fehlerfrei funktioniert noch andere Anforderungen erfüllt sein. Position und Ausrichtung der Kamera müssen bekannt sein und es muss der Punkt auf dem Horizont fokussiert werden in dem sich die Fahrspuren zu schneiden scheinen, was wiederum erfordert, dass die Straße in der Mitte des Bildes liegt. Ist das nicht der Fall erhält man keine einwandfreien Ergebnisse, da die Straße immer noch eine perspektivische Verzerrung aufweist.
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
|
| |
| Ein Beispiel für gutes Ergebnis des IPM ist in Abbildung 1 zu sehen. [1]
| |
| [[Datei:SED IPM2.png|mini|400px|center|Abbildung 1: Straße aus Vogelperspektive]]
| |
|
| |
| =Operatoren zur Kantenerkennung im Vergleich=
| |
|
| |
| [[Datei:Kantenerkennung operatoren.png]]
| |
|
| |
| =Quellen weiterführende Links=
| |
| [1] SVN\SDE_Praktikum\Literatur\Inverse Perspective Transformation: ipm_paper_direkt<br />
| |
| "Decomposing and composing a 3×3 rotation matrix" [http://nghiaho.com/?page_id=846]<br />
| |
| "Grundlegende mathematische Verfahren der 3D-Visualisierung"[http://www.3dsource.de/deutsch/3Dmathe.htm]<br />
| |
| "Caltech Lane Detection Software"[http://vision.caltech.edu/malaa/software/research/caltech-lane-detection/]<br />
| |
| "Rekonstruktion 3D - Koordinaten aus Kamerabild"[http://www.gomatlab.de/rekonstruktion-3d-koordinaten-aus-kamerabild-mit-nebenbed-t24440.html]<br />
| |
|
| |
| = Fazit & Ausblick =
| |
| Das Carolo-Cup Fahrzeug ist nun in der Lage die Fahrspur zu erkennen und ihr auch zu folgen. Dies funktioniert sowohl auf der Geraden als auch in Kurven relativ genau, wobei in Kurven noch stellenweise mit bis zu zwei Rädern die Spur leicht überfahren wird. Das Spurpolynom wurde von der rechten äußeren Fahrspur in die Mitte der Fahrbahn verlagert, sodass eine Regelung ohne weitere Umrechnung möglich ist.
| |
| Außerdem können nun Stopplinien erkannt werden. Dabei stehen der Regelung ein Stoplinien-Bit und im Falle einer nahenden Stoplinie auch die Entfernung in Metern zur Verfügung. Mit dem vorbereiteten Ansatz zur Spurerkennung mit Hilfe des Kalman-Filters existieren auch Aufgaben die in folgenden Semesters aufgegriffen werden können.
| |
| Damit lassen sich möglicherweise auch Schwächen des bisherigen Ergebnisses ausmerzen. Diese bestehen an der Kreuzung und in S-Kurven. Kreuzungen erfordern das überfahren einer Spurlinie. Diese darf dabei zu keinem Zeitpunkt als Spur erkannt und verfolgt werden. S-Kurven hingegen besitzen im Verlauf 2 lokale Extrema, die mit einem Polynom 2. Grades nicht abgebildet werden können. Ein Ansatz wäre hier einfach ein Polynom höheren Grades zu interpolieren. Dies würde aber zulasten der Rechenzeit pro Fram gehen und ist daher im Vorfeld abzuwägen.
| |
|
| |
|
| |
|
| |
| == Feedback zum Artikel ==
| |
|
| |
|
| |
| --[[Benutzer:Mirekgoebel|Prof. Dr. Mirek Göbel]] ([[Benutzer Diskussion:Mirekgoebel|Diskussion]]) 13:54, 8. Aug. 2014 (CEST)
| |
| * Projektplan etc. nichts ins Wiki!
| |
| * Originaldaten der Bilder fehlen (zum ggf. Nacharbeiten)
| |
|
| |
| =Archiv bisheriger Arbeit =
| |
| == [[Zentralperspektive "Umrechnung von Bild- zu Weltkoordinaten"]] (akktuel verwendeter Ansatz) ==
| |
| == [[Spurerkennung]] (vorheriger Ansatz) == | | == [[Spurerkennung]] (vorheriger Ansatz) == |
| == [[Objekterkennung mit Laserscanner]] == | | == [[Objekterkennung mit Laserscanner]] == |
| | == [http://193.175.248.52/wiki/index.php/Objekterkennung_mit_RP_Lidar_A1M8 Objekterkennung mit RP Lidar A1M8] == |
|
| |
|
| == [[Objekterkennung mit Kamera]] == | | == [[Objekterkennung mit Kamera]] == |
|
| |
|
| | </div> |
|
| |
|
| | = Einzelnachweise = |
| | <references/> |
|
| |
|
| ---- | | ---- |
| → zurück zum Hauptartikel: [[Praktikum_SDE|Praktikum SDE]] | | → zurück zum Hauptartikel: [[Praktikum_SDE|Praktikum SDE]] |
Aktuelle Softwareumgebung für das OSE-Programm