Gekrümmte Fahrspurerkennung

Geschichte

Einführung

In jedem Fahrszenario sind Fahrspurlinien ein wesentlicher Bestandteil, um den Verkehrsfluss anzuzeigen und anzuzeigen, wohin ein Fahrzeug fahren sollte. Es ist auch ein guter Ausgangspunkt für die Entwicklung eines selbstfahrenden Autos! Aufbauend auf meinem vorherigen Spurerkennungsprojekt habe ich ein System zur Erkennung gekrümmter Fahrspuren implementiert, das viel besser funktioniert und robuster in schwierigen Umgebungen ist.

Das Spurerkennungssystem wurde in Python unter Verwendung der OpenCV-Bibliothek geschrieben. Hier ist die aktuelle Bildverarbeitungspipeline:

• Verzerrungskorrektur

• Perspektivischer Warp

• Sobel-Filterung

• Histogramm-Peak-Erkennung

• Sliding Window Search

• Kurvenanpassung

• Erkannte Spur überlagern

• Bei Video bewerben

Einschränkungen des Vorgängersystems

In meinem vorherigen Spurerkennungsprojekt hatte ich ein sehr einfaches Spurerkennungssystem entwickelt, das gerade Spurlinien in einem Bild erkennen konnte. Es funktionierte unter perfekten Bedingungen anständig, konnte jedoch gekrümmte Fahrspuren nicht genau erkennen und war nicht robust gegenüber Hindernissen und Schatten. Diese Version verbessert diese beiden Einschränkungen.

Verzerrungskorrektur

Kameraobjektive verzerren einfallendes Licht, um es auf den Kamerasensor zu fokussieren. Obwohl dies sehr nützlich ist, um Bilder unserer Umgebung aufzunehmen, verzerren sie das Licht oft etwas ungenau. Dies kann in Computer-Vision-Anwendungen zu ungenauen Messungen führen. Wir können diese Verzerrung jedoch leicht korrigieren.

Wie würden Sie das tun? Sie können Ihr Bild gegen ein bekanntes Objekt kalibrieren und ein Verzerrungsmodell erstellen, das Linsenverzerrungen berücksichtigt.

Dieses Objekt ist oft ein asymmetrisches Schachbrett, ähnlich dem untenstehenden:

Kalibrierungsschachbrett (OpenCV Docs)

Mit der im Testvideo verwendeten Kamera wurden 20 Bilder eines Schachbretts aufgenommen, die zur Generierung des Verzerrungsmodells verwendet wurden. Wir beginnen mit der Konvertierung des Bildes in Graustufen und wenden dann die Funktion cv2.findChessboardCorners() an. Wir wissen bereits, dass dieses Schachbrett ein zweidimensionales Objekt mit ausschließlich geraden Linien ist, daher können wir einige Transformationen auf die erkannten Ecken anwenden, um sie richtig auszurichten. Ich habe cv2.CalibrateCamera() verwendet, um die Verzerrungskoeffizienten und die Kameramatrix zu erhalten. Die Kamera wurde kalibriert!

Sie können dann cv2.undistort() verwenden, um die restlichen Eingabedaten zu korrigieren. Sie können den Unterschied zwischen dem Originalbild des Schachbretts und dem korrigierten Bild unten sehen:

Verzerrungskorrektur, die auf ein Bild angewendet wurde, das ein Kalibrierungsschachbrett enthält.

Hier ist der genaue Code, den ich dafür verwendet habe:

def undistort_img():
# Objektpunkte vorbereiten 0,0,0 … 8,5,0
obj_pts =np.zeros((6*9,3), np.float32)
obj_pts[:,:2] =np.mgrid[0:9, 0:6].T.reshape(-1,2)
# Speichert alle Objektpunkte &Bildpunkte aus allen Bildern
objpoints =[]
imgpoints =[]
# Verzeichnis für alle Kalibrierungsbilder abrufen
images =glob.glob('camera_cal/*.jpg')
für indx, fname in enumerate (Bilder):
img =cv2.imread(fname)
gray =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, corners =cv2.findChessboardCorners(gray, (9,6 ), Keine)
if ret ==True:
objpoints.append(obj_pts)
imgpoints.append(corners)
# Test-Verzerrung auf img
img_size =( img.shape[1], img.shape[0])
# Kamera kalibrieren
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera(objpoints, imgpoints, img_size, None,None)
dst =cv2.undistort(img, mtx, dist, None, mtx)
# Kamerakalibrierung zur späteren Verwendung speichern
dist_pickle ={}
dist_pickle['mtx'] =mtx
dist_pickle['dist' ] =dist
pickle.dump( dist_pickle, open('camera_cal/cal_pickle.p', 'wb') )
def undistort(img, cal_dir='camera_cal/cal_pickle.p'):
#cv2.imwrite('camera_cal/test_cal.jpg', dst)
with open(cal_dir, mode='rb') as f:
file =pickle.load(f) mtx =file ['mtx']
dist =file['dist']
dst =cv2.undistort(img, mtx, dist, None, mtx)
return dst
undistort_img()
img =cv2.imread('camera_cal/calibration1.jpg')
dst =undistort(img) # Unverzerrtes Bild

Die dafür verwendeten Funktionen finden Sie auch im Jupyter Notebook unter dem Code Abschnitt.

Hier ist die auf ein Straßenbild angewendete Verzerrungskorrektur. Sie können den kleinen Unterschied vielleicht nicht bemerken, aber er kann einen großen Einfluss auf die Bildverarbeitung haben.

Auf eine Fahrszene angewendete Verzerrungskorrektur

Perspektivische Verzerrung

Gebogene Fahrspuren im Kameraraum zu erkennen ist nicht ganz einfach. Was wäre, wenn wir die Gassen aus der Vogelperspektive sehen könnten? Dies kann durch Anwenden einer perspektivischen Transformation auf das Bild erfolgen. So sieht es aus:

Perspektivisch verzerrtes Bild

Bemerken Sie etwas? Wenn wir annehmen, dass sich die Fahrspur auf einer flachen 2D-Oberfläche befindet, können wir ein Polynom anpassen, das die Fahrspur im Fahrspurraum genau darstellen kann! Ist das nicht cool?

Sie können diese Transformationen auf jedes Bild anwenden, indem Sie die Funktion cv2.getPerspectiveTransform() zum Abrufen der Transformationsmatrix und cv2.warpPerspective() zum Anwenden auf ein Bild verwenden. Hier ist der Code, den ich dafür verwendet habe:

def perspektivische_warp(img,
dst_size=(1280,720),
src=np.float32([(0.43,0.65),(0.58,0.65),(0.1,1),(1,1 )]),
dst=np.float32([(0,0), (1, 0), (0,1), (1,1)])):
img_size =np. float32([(img.shape[1],img.shape[0])])
src =src* img_size
# Als Zielpunkte wähle ich willkürlich einige Punkte aus
# passt gut, um unser verzerrtes Ergebnis anzuzeigen
# wieder, nicht genau, aber nah genug für unsere Zwecke
dst =dst * np.float32(dst_size)
# Gegebene src- und dst-Punkte , berechnen Sie die perspektivische Transformationsmatrix
M =cv2.getPerspectiveTransform(src, dst)
# Verzerren Sie das Bild mit OpenCV warpPerspective()
warped =cv2.warpPerspective(img, M, dst_size)
Rücklauf verzogen

Sobel-Filterung

In der vorherigen Version hatte ich die Fahrspurlinien farblich herausgefiltert. Dies ist jedoch nicht immer die beste Option. Wenn für die Straße heller Beton anstelle von Asphalt verwendet wird, passiert die Straße leicht den Farbfilter und wird von der Pipeline als weiße Fahrbahnlinie wahrgenommen. Nicht gut.

Stattdessen können wir eine ähnliche Methode wie unser Kantendetektor verwenden, um diesmal die Straße herauszufiltern. Spurlinien haben typischerweise einen hohen Kontrast zur Straße, das können wir zu unserem Vorteil nutzen. Der Kluge Der zuvor in Version 1 verwendete Kantendetektor verwendet Sobel Operator um den Gradienten einer Bildfunktion zu erhalten. Die OpenCV-Dokumentation enthält eine fantastische Erklärung zur Funktionsweise. Wir verwenden dies, um Bereiche mit hohem Kontrast zu erkennen, um Fahrbahnmarkierungen zu filtern und die Straße zu ignorieren.

Wir werden weiterhin den HLS-Farbraum verwenden, diesmal um Änderungen in Sättigung und Helligkeit zu erkennen. Die Sobel-Operatoren werden auf diese beiden Kanäle angewendet, und wir extrahieren den Gradienten in Bezug auf die x-Achse und fügen die Pixel, die unsere Gradientenschwelle passieren, zu einer binären Matrix hinzu, die die Pixel in unserem Bild darstellt. So sieht es im Kamera- und Fahrspurbereich aus:

Beachten Sie, dass die Bildteile, die weiter von der Kamera entfernt waren, ihre Qualität nicht sehr gut behalten. Aufgrund der Auflösungsbeschränkungen der Kamera sind Daten von weiter entfernten Objekten stark unscharf und verrauscht. Wir müssen uns nicht auf das gesamte Bild konzentrieren, sondern können nur einen Teil davon verwenden. So sieht das von uns verwendete Bild aus:

Histogramm-Peak-Erkennung

Wir wenden einen speziellen Algorithmus namens Sliding an Fenster Algorithmus um unsere Fahrspurlinien zu erkennen. Bevor wir ihn jedoch anwenden können, müssen wir einen guten Ausgangspunkt für den Algorithmus bestimmen. Es funktioniert gut, wenn es an einer Stelle beginnt, an der Fahrspurpixel vorhanden sind, aber wie können wir die Position dieser Fahrspurpixel überhaupt erkennen? Es ist eigentlich ganz einfach!

Wir erhalten ein Histogramm des Bildes in Bezug auf die X-Achse. Jeder Teil des Histogramms unten zeigt an, wie viele weiße Pixel sich in jeder Spalte des Bildes befinden. Wir nehmen dann die höchsten Spitzen jeder Seite des Bildes, einen für jede Fahrspurlinie. So sieht das Histogramm neben dem Binärbild aus:

Sliding Window Search

Der Schiebefensteralgorithmus wird verwendet, um zwischen den linken und rechten Fahrspurgrenzen zu unterscheiden, sodass wir zwei verschiedene Kurven anpassen können, die die Fahrspurgrenzen darstellen.

Lesen Sie mehr Details:Erkennung gekrümmter Fahrspuren