DSB18: Ampelphasenerkennung

Autor: John Kneib
Betreuer: Prof. Schneider

Motivation

Autonome Fahrzeuge müssen in der Lage sein Ampelphasen zu erkennen.

Ziel

Die Ampelphase in verschiedenen Videosequenzen sollen von der Bildverarbeitung korrekt erkannt werden.

Anforderungen

Ein Testvideo mit verschiedenen Ampeln wird mit Matlab eingelesen und ausgewertet.
Matlab analysiert das Video in Echttzeit.
Erkennung von Farben bei unterschiedlichen Tageszeiten
Berechnen, welche Phase die Ampel aktuell hat
Die aktuelle Ampelphase wird im Video dargestellt.
Bewerten Sie Ihr Ergebnis.
Wissenschaftliche Dokumentation als HSHL-Wiki Artikel
Softwareentwicklung nach SDE Standard in SVN
Funktionsnachweis als YouTube-Video (vgl. Veranstaltungsregeln)

Lösungen

Einleitung

Die Lösung in Matlab wurde mit hilfe der gelernten Grundlagen aus der Vorlesung Digitale Bild und Signalvearbeitung an der HSHL im sechsten Semester MEchatronik erstellt. In der Lösung finden diverse morphologische Operationen und die Hough Transformation ihren Einsatz. Diese ermöglichen im Zusammenspiel die Erkennung der Ampelphase.

Programm

Im Folgeden sollen die wichtigsten Bildverarbeitungsschritte einmal beschrieben werden. Da es in diesem Programm vorwigend um die Bildverabeitung geht, werden die einfachen Programmfunktion für die Framezerlegung, der Videowriter und die Debugging Ausgaben nicht weiter beschrieben. Als erstes wird das eingans Video(1080P) der Actioncam in einer For-Schleife in einzelne Frames zerlegt und diese abgespeichert.

Anlegen von Binärbildern für die einzelnen Ampelhasen

Mittels der colorThresholder Funktion von Matlab wurden einzelne Ampel Frames mit verschiedenen Ampelphasen analysiert und ein Filter angelegt. Dieser Filter arbeitet im HSV Farbraum, in diesem Farbraum ist im Gegensatz zum RGB Farbraum jeder Farbe ein Winkel (Hue), die Sättigung (Satuation) und die Stärke (Value) zugeordnet. Dies hat den Vorteil, dass sich der Farbwinkel unter verschiedenen Lichteinflüssen nicht verändert. So kann einfach nach der passenden Farbe gefiltert werden. Trotzdem ist es nicht ganz einfach Rot und Gelb zu trennen.

%% Finden der Pixel mit der richtigen Farbe für grünes/gelbes/rotes Ampellicht, anschließend speichern in Binärbild

Bin_rot = zeros(1080,1920);
Bin_gr  = zeros(1080,1920);
Bin_gel = zeros(1080,1920);

for x = 1: 1920
     for y = 1:1080
         
      if  (hsv_Ampel(y,x,1) < 0.053 ||  hsv_Ampel(y,x,1) > 0.99 ) && hsv_Ampel(y,x,2) > 0.65 && hsv_Ampel(y,x,3) > 0.57   % Rot
      Bin_rot(y,x)= 255;
      Bin_gr(y,x) = 0;
      Bin_gel(y,x) = 0;
      
      elseif  hsv_Ampel(y,x,1) > 0.053  && hsv_Ampel(y,x,1) < 0.168 && hsv_Ampel(y,x,2) > 0.54  % Gelb
      Bin_rot(y,x)= 0;
      Bin_gr(y,x) = 0;
      Bin_gel(y,x) = 255;
      
      elseif  hsv_Ampel(y,x,1) > 0.39  && hsv_Ampel(y,x,1) < 0.5 && hsv_Ampel(y,x,2) > 0.4      % Grün
      Bin_rot(y,x)= 0;
      Bin_gr(y,x) = 255;
      Bin_gel(y,x) = 0;  
      
      end
     end
end

Die Frames werden einzeln geöfnnet und jedes Pixel wird geprüft, ob es das Filter Kriterium erfüllt. Wernn die Bedingungen für die jeweilige Farbe erfüllt sind wird das Pixel mit dem Wert 255 beschrieben. So ensteht ein Binärbild, welches später einfach verarbeitet werden kann.

Morphologische Operationen

Nachdem der Eingangsframe in ein Binärbild zerlegt wurde können verschiedene morphologische Operationen durchgeführt werden, um die spätere Erkennung mittels Hough Transformation zu erleichtern. Als erstes werden Objekte entfernt, welche kleiner als 120 Pixel sind. Als nächstes werden potenzielle Pixel am Rand des Bildes entfernt. Die letzte Operation füllt verbleibende Elemente mit Pixeln auf. So enstehen gefüllte Kreise.

%% Morphologische Operationen

open_rot = bwareaopen(Bin_rot,120);
open_gel = bwareaopen(Bin_gel,120);
open_gr  = bwareaopen(Bin_gr,120);  
  

clear_rot = imclearborder(open_rot);
clear_gel = imclearborder(open_gel);
clear_gr = imclearborder(open_gr);

filled_rot = imfill(clear_rot,'holes');
filled_gel = imfill(clear_gel,'holes');
filled_gr  = imfill(clear_gr,'holes');

Suche nach Kreisen mittels Hough Transformation

Nachdem das Binärbild morphologisch beabreitet wurde kann es in den Hough Raum transfomiert werden. Im dreidiminisonalen Houghraum enstehen Pixel anhäufungen bei den Mittelpunkten von Kreisen. Diese Mittelpunkte werden in x,y Koordinaten angelegt zusätlich wird in der dritten Dimension der Radius abgelegt. Um also Kreise finden zu können muss der enstsprechende Radius als a priori Wissen vorrausgesetzt werden.

%% Hough Transformation zur Suche nach Kreisen im binär Bild - anschließend den gefunden Kreis markieren

[centers_r,radi_r] = imfindcircles(filled_rot,[20 70],'Sensitivity',0.8);
centersStrong_r = centers_r(:,:,:); 
radiStrong_r = radi_r(:,:);



[centers_gel, radi_gel] = imfindcircles(filled_gel,[20 70],'Sensitivity',0.75);
centersStrong_gel = centers_gel(:,:,:); 
radiStrong_gel = radi_gel(:,:);



[centers_gr, radi_gr] = imfindcircles(filled_gr,[20 70],'Sensitivity',0.85);
centersStrong_gr = centers_gr(:,:,:); 
radiStrong_gr = radi_gr(:,:);

Einblenden des Textes im original Frame

Nachdem die Hough Transformation auf den drei Binärbildern ausgeführt wurde, kann durch eine entsprechende logische Abfrage der Matritzen in denen die Kreisgrößen abgelegt werden auf die Ampelphase geschlossen werden. Der Text wird mittels der computervision Toolbox von Matlab im Bild eingeblendet.

%% Einblenden des Textes welche Ampelphase vorherscht
 
if (size(radiStrong_r) >= 1) & (size(radiStrong_gel)  < 1 )
fin_Frame =   insertText(A,[960 980],'Es ist Rot','FontSize',100,'BoxColor','red','AnchorPoint','CenterBottom');

elseif (size(radiStrong_r) >= 1) &  size(radiStrong_gel) >= 1
fin_Frame =   insertText(A,[960 980],'Es ist Gelb Rot','FontSize',100,'BoxColor','yellow','AnchorPoint','CenterBottom');

elseif size(radiStrong_gel) >= 1
fin_Frame =   insertText(A,[960 980],'Es ist Gelb','FontSize',100,'BoxColor','yellow','AnchorPoint','CenterBottom');

elseif size(radiStrong_gr) >= 1
fin_Frame =   insertText(A,[960 980],'Es ist Grün','FontSize',100,'BoxColor','green','AnchorPoint','CenterBottom');

else
fin_Frame=A;


end

Fazit

Die Ampelerkennung funktioniert sehr solide, das Problem ist allerdings, dass die Hough Transformation einen sehr hohen Rechenaufwand aufweist. Da diese drei mal pro Durchlauf angewendet wird ensteht eine relativ hohe Zyklusszeit. Dies ist sicher auch eleganter zu lösen. Als Beispiel könnte man abfragen, ob überhaupt genug weiße Pixel in einem Binärbild vorhanden sind um einen Kreis darzustellen. Wenn dies nicht der Fall ist kann die Hough Transformation für diesen Binärbild eingespart werden. Zusätzlich ist zu sehen, dass manchmal bei Rot/Gelb Phasen die Ausgabe zwischen Rot und Rot/Gelb hin und her springt. Hier könnte durch eine mindest Detektionszeit verhindert werden, dass die Ampelhasen bei kurzem nicht erkennen hin und her springen. Dies beiden Ansätze sind als mögliches Verbesserungspotential in späteren Projekten einfach zu implementieren und sollten die Zykluszeit sowie die Ausgabe verbessern.

Videobeweis

Zur veranschaulichung der Funktion des Matlab Skriptes wurde ein kurzes Video auf Youtube erstellt. Hiermit lade ich Sie auf eine kleine Fahrt durch meinen Heimatort Neheim ein. https://youtu.be/7I4QyxJXmeQ

Weblinks

BSD-Lizenzbedingung BSD-Lizenz

→ zurück zum Hauptartikel: Digitale Signal- und Bildverarbeitung SoSe2018