Detectie van gebogen rijstroken

Verhaal

Inleiding

In elk rijscenario zijn rijstrooklijnen een essentieel onderdeel om de verkeersstroom aan te geven en waar een voertuig moet rijden. Het is ook een goed startpunt bij het ontwikkelen van een zelfrijdende auto! Voortbouwend op mijn vorige baandetectieproject, heb ik een systeem voor het detecteren van gebogen rijstroken geïmplementeerd dat veel beter werkt en robuuster is voor uitdagende omgevingen.

Het rijstrookdetectiesysteem is geschreven in Python met behulp van de OpenCV-bibliotheek. Dit is de huidige pijplijn voor beeldverwerking:

• Vervormingscorrectie

• Perspectief verdraaien

• Sobel-filtering

• Histogram piekdetectie

• Zoeken met schuifvenster

• Curve-aanpassing

• Overlay gedetecteerde rijstrook

• Toepassen op video

Beperkingen van het vorige systeem

In mijn vorige rijstrookdetectieproject had ik een heel eenvoudig rijstrookdetectiesysteem ontwikkeld dat rechte rijstrooklijnen in een afbeelding kon detecteren. Het werkte behoorlijk onder perfecte omstandigheden, maar het zou bochten niet nauwkeurig detecteren en was niet bestand tegen obstakels en schaduwen. Deze versie verbetert beide beperkingen.

Vervormingscorrectie

Cameralenzen vervormen binnenkomend licht om het op de camerasensor te focussen. Hoewel dit erg handig is om ons in staat te stellen beelden van onze omgeving vast te leggen, vervormen ze het licht vaak enigszins onnauwkeurig. Dit kan resulteren in onnauwkeurige metingen in computer vision-toepassingen. We kunnen deze vervorming echter gemakkelijk corrigeren.

Hoe zou je dit doen? U kunt uw afbeelding kalibreren ten opzichte van een bekend object en een vervormingsmodel genereren dat rekening houdt met lensvervormingen.

Dit object is vaak een asymmetrisch dambord, vergelijkbaar met het onderstaande:

kalibratie-dambord (OpenCV Docs)

De camera die in de testvideo werd gebruikt, werd gebruikt om 20 foto's van een dambord te maken, die werden gebruikt om het vervormingsmodel te genereren. We beginnen met het converteren van de afbeelding naar grijswaarden en passen vervolgens de functie cv2.findChessboardCorners() toe. We weten al dat dit schaakbord een tweedimensionaal object is met uitsluitend rechte lijnen, dus we kunnen enkele transformaties toepassen op de gedetecteerde hoeken om ze goed uit te lijnen. Ik heb de cv2.CalibrateCamera() gebruikt om de vervormingscoëfficiënten en de cameramatrix te krijgen. De camera is gekalibreerd!

U kunt vervolgens cv2.undistort() gebruiken om de rest van uw invoergegevens te corrigeren. Je kunt het verschil zien tussen de originele afbeelding van het dambord en de gecorrigeerde afbeelding hieronder:

Vervormingscorrectie toegepast op een afbeelding met een kalibratiedambord.

Dit is de exacte code die ik hiervoor heb gebruikt:

def undistort_img():
# Objectpunten voorbereiden 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)
# Slaat alle objectpunten en img-punten van alle afbeeldingen op
objpoints =[]
imgpoints =[]
# Haal de directory op voor alle kalibratie-afbeeldingen
images =glob.glob('camera_cal/*.jpg')
voor indx, fname in enumerate (afbeeldingen):
img =cv2.imread(fname)
grijs =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, hoeken =cv2.findChessboardCorners(grijs, (9,6 ), Geen)
if ret ==True:
objpoints.append(obj_pts)
imgpoints.append(corners)
# Test onvervormdheid op img
img_size =( img.shape[1], img.shape[0])
# Kalibreer camera
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera(objpoints, imgpoints, img_size, None,None)
dst =cv2.undistort(img, mtx, dist, Geen, mtx)
# Camerakalibratie opslaan voor later gebruik
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)
met open(cal_dir, mode='rb') als f:
file =pickle.load(f) mtx =bestand ['mtx']
dist =bestand['dist']
dst =cv2.undistort(img, mtx, dist, Geen, mtx)
return dst
undistort_img()
img =cv2.imread('camera_cal/calibration1.jpg')
dst =undistort(img) # Niet-vervormde afbeelding

De functies die hiervoor worden gebruikt, zijn ook te vinden in de Jupyter Notebook onder de Code sectie.

Dit is de vervormingscorrectie die is toegepast op een afbeelding van de weg. Je merkt misschien het kleine verschil niet, maar het kan een enorme impact hebben op de beeldverwerking.

Vervormingscorrectie toegepast op een rijscène

Perspectief verdraaien

Het detecteren van gebogen rijstroken in de cameraruimte is niet erg eenvoudig. Wat als we een vogelperspectief van de rijstroken zouden kunnen krijgen? Dat kan door een perspectieftransformatie op het beeld toe te passen. Zo ziet het eruit:

Perspectief vervormd beeld

Is iets opgevallen? Door aan te nemen dat de baan zich op een vlak 2D-oppervlak bevindt, kunnen we een polynoom plaatsen dat de baan nauwkeurig in de baanruimte kan weergeven! Is dat niet cool?

Je kunt deze transformaties toepassen op elke afbeelding met de functie cv2.getPerspectiveTransform() om de transformatiematrix te krijgen, en cv2.warpPerspective() om deze op een afbeelding toe te passen. Dit is de code die ik hiervoor heb gebruikt:

def perspectief_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
# Voor bestemmingspunten kies ik willekeurig enkele punten om te worden
# past goed bij het weergeven van ons kromgetrokken resultaat
# nogmaals, niet exact, maar dichtbij genoeg voor onze doeleinden
dst =dst * np.float32(dst_size)
# Gegeven src- en dst-punten , bereken de perspectieftransformatiematrix
M =cv2.getPerspectiveTransform(src, dst)
# Warp de afbeelding met OpenCV warpPerspective()
warped =cv2.warpPerspective(img, M, dst_size)
retour kromgetrokken

Sobel-filtering

In de vorige versie had ik de rijstrooklijnen uitgefilterd met kleur. Dit is echter niet altijd de beste optie. Als de weg lichtgekleurd beton gebruikt in plaats van asfalt, gaat de weg gemakkelijk door het kleurenfilter en zal de pijpleiding het als een witte rijstrook waarnemen. Niet goed.

In plaats daarvan kunnen we een methode gebruiken die vergelijkbaar is met onze randdetector, deze keer om de weg uit te filteren. Rijstrooklijnen hebben meestal een hoog contrast met de weg, dus we kunnen dit in ons voordeel gebruiken. De Canny randdetector die eerder in versie 1 werd gebruikt, maakt gebruik van Sobel Operator om het verloop van een afbeeldingsfunctie te krijgen. De OpenCV-documentatie heeft een fantastische uitleg over hoe het werkt. We gebruiken dit om gebieden met een hoog contrast te detecteren om rijstrookmarkeringen te filteren en de weg te negeren.

We gebruiken de HLS-kleurruimte nog steeds, deze keer om veranderingen in verzadiging en lichtheid te detecteren. De sobel-operators worden toegepast op deze twee kanalen, en we extraheren de gradiënt ten opzichte van de x-as, en voegen de pixels die onze gradiëntdrempel overschrijden toe aan een binaire matrix die de pixels in onze afbeelding voorstelt. Zo ziet het eruit in cameraruimte en rijstrookruimte:

Houd er rekening mee dat de delen van de afbeelding die verder van de camera verwijderd waren, hun kwaliteit niet goed behouden. Vanwege de resolutiebeperkingen van de camera zijn gegevens van verder weg gelegen objecten erg wazig en luidruchtig. We hoeven ons niet op de hele afbeelding te concentreren, dus we kunnen er maar een deel van gebruiken. Dit is hoe de afbeelding die we zullen gebruiken eruit zal zien:

Histogram Piekdetectie

We passen een speciaal algoritme toe genaamd de Sliding Venster Algoritme om onze rijstroken te detecteren. Voordat we het echter kunnen toepassen, moeten we een goed startpunt voor het algoritme bepalen. Het werkt goed als het begint op een plek waar rijstrookpixels aanwezig zijn, maar hoe kunnen we de locatie van deze rijstrookpixels überhaupt detecteren? Het is eigenlijk heel eenvoudig!

We krijgen een histogram van de afbeelding ten opzichte van de X-as. Elk deel van het onderstaande histogram geeft aan hoeveel witte pixels zich in elke kolom van de afbeelding bevinden. We nemen dan de hoogste toppen van elke kant van het beeld, één voor elke rijstrook. Zo ziet het histogram eruit, naast de binaire afbeelding:

Zoeken in schuifvenster

Het schuifvensteralgoritme wordt gebruikt om onderscheid te maken tussen de linker- en rechterrijstrookgrenzen, zodat we twee verschillende curven kunnen plaatsen die de rijstrookgrenzen vertegenwoordigen.

Lees meer details:detectie van gebogen rijstroken