Détection de voie courbe

Histoire

Introduction

Dans tout scénario de conduite, les lignes de voie sont un élément essentiel pour indiquer le flux de circulation et l'endroit où un véhicule doit conduire. C'est aussi un bon point de départ pour développer une voiture autonome ! Sur la base de mon projet de détection de voie précédent, j'ai mis en place un système de détection de voie incurvée qui fonctionne beaucoup mieux et est plus robuste pour les environnements difficiles.

Le système de détection de voie a été écrit en Python à l'aide de la bibliothèque OpenCV. Voici le pipeline de traitement d'image actuel :

• Correction de la distorsion

• Déformation en perspective

• Filtrage Sobel

• Détection de pic d'histogramme

• Recherche par fenêtre coulissante

• Ajustement de courbe

• Superposition de voie détectée

• Appliquer à la vidéo

Limitations du système précédent

Dans mon précédent projet de détection de voie, j'avais développé un système de détection de voie très simple qui pouvait détecter des lignes de voie droites dans une image. Il fonctionnait correctement dans des conditions parfaites, mais il ne parviendrait pas à détecter avec précision les voies courbes et n'était pas résistant aux obstacles et aux ombres. Cette version améliore ces deux limitations.

Correction de la distorsion

Les objectifs de la caméra déforment la lumière entrante pour la focaliser sur le capteur de la caméra. Bien que cela soit très utile pour nous permettre de capturer des images de notre environnement, elles finissent souvent par déformer légèrement la lumière de manière imprécise. Cela peut entraîner des mesures inexactes dans les applications de vision par ordinateur. Cependant, nous pouvons facilement corriger cette distorsion.

Comment feriez-vous cela ? Vous pouvez calibrer votre image par rapport à un objet connu et générer un modèle de distorsion qui tient compte des distorsions de l'objectif.

Cet objet est souvent un damier asymétrique, similaire à celui ci-dessous :

damier d'étalonnage (OpenCV Docs)

La caméra utilisée dans la vidéo de test a été utilisée pour prendre 20 photos d'un damier, qui ont été utilisées pour générer le modèle de distorsion. Nous commençons par convertir l'image en niveaux de gris, puis appliquons la fonction cv2.findChessboardCorners() . Nous savons déjà que cet échiquier est un objet en 2 dimensions avec exclusivement des lignes droites, nous pouvons donc appliquer quelques transformations aux coins détectés pour les aligner correctement. J'ai utilisé le cv2.CalibrateCamera() pour obtenir les coefficients de distorsion et la matrice de la caméra. L'appareil photo a été calibré !

Vous pouvez ensuite utiliser cv2.undistort() pour corriger le reste de vos données d'entrée. Vous pouvez voir la différence entre l'image originale du damier et l'image corrigée ci-dessous :

Correction de la distorsion appliquée à une image contenant un damier de calibrage.

Voici le code exact que j'ai utilisé pour cela :

def undistort_img() :
# Préparer les points d'objet 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)
# Stocke tous les points d'objet et les points d'img de toutes les images
objpoints =[]
imgpoints =[]
# Obtenir le répertoire pour toutes les images de calibrage
images =glob.glob('camera_cal/*.jpg')
pour indx, fname dans énumérer (images) :
img =cv2.imread(fname)
gris =cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, coins =cv2.findChessboardCorners(gris, (9,6 ), None)
if ret ==True :
objpoints.append(obj_pts)
imgpoints.append(corners)
# Tester la non-distorsion sur img
img_size =( img.shape[1], img.shape[0])
# Calibrer la caméra
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)
dst =cv2.undistort(img, mtx, dist, None, mtx)
# Enregistrer le calibrage de la caméra pour une utilisation ultérieure
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)
avec open(cal_dir, mode='rb') comme f:
file =pickle.load(f) mtx =fichier ['mtx']
dist =file['dist']
dst =cv2.undistort(img, mtx, dist, None, mtx)
retourner dst
undistort_img()
img =cv2.imread('camera_cal/calibration1.jpg')
dst =undistort(img) # Image non déformée

Les fonctions utilisées pour celles-ci peuvent également être trouvées dans le Jupyter Notebook sous le Code rubrique.

Voici la correction de distorsion appliquée à une image de la route. Vous ne remarquerez peut-être pas la légère différence, mais cela peut avoir un impact énorme sur le traitement de l'image.

Correction de distorsion appliquée à une scène de conduite

Déformation de perspective

La détection de voies courbes dans l'espace de la caméra n'est pas très facile. Et si nous pouvions avoir une vue plongeante sur les ruelles ? Cela peut être fait en appliquant une transformation de perspective sur l'image. Voici à quoi cela ressemble :

Image déformée en perspective

Vous remarquez quelque chose ? En supposant que la voie se trouve sur une surface 2D plane, nous pouvons ajuster un polynôme qui peut représenter avec précision la voie dans l'espace des voies ! N'est-ce pas cool ?

Vous pouvez appliquer ces transformations à n'importe quelle image à l'aide de la fonction cv2.getPerspectiveTransform() pour obtenir la matrice de transformation et cv2.warpPerspective() pour l'appliquer à une image. Voici le code que j'ai utilisé pour cela :

def perspective_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
# Pour les points de destination, je choisis arbitrairement certains points à être
# un bon ajustement pour afficher à nouveau notre résultat déformé
#, pas exact, mais assez proche pour nos besoins
dst =dst * np.float32(dst_size)
# Étant donné les points src et dst , calculez la matrice de transformation de perspective
M =cv2.getPerspectiveTransform(src, dst)
# Déformez l'image en utilisant OpenCV warpPerspective()
warped =cv2.warpPerspective(img, M, dst_size)
retour déformé

Filtrage Sobel

Dans la version précédente, j'avais filtré les lignes de voie en utilisant la couleur. Cependant, ce n'est pas toujours la meilleure option. Si la route utilise du béton de couleur claire au lieu de l'asphalte, la route passe facilement à travers le filtre de couleur et le pipeline le percevra comme une ligne de voie blanche. Pas bon.

À la place, nous pouvons utiliser une méthode similaire à notre détecteur de bord, cette fois pour filtrer la route. Les lignes de voie ont généralement un contraste élevé avec la route, nous pouvons donc l'utiliser à notre avantage. Le Bonjour le détecteur de bord précédemment utilisé dans la version 1 utilise Sobel Operator pour obtenir le gradient d'une fonction d'image. La documentation d'OpenCV a une explication fantastique sur son fonctionnement. Nous l'utiliserons pour détecter les zones à fort contraste afin de filtrer les marquages ​​au sol et d'ignorer la route.

Nous utiliserons à nouveau l'espace colorimétrique HLS, cette fois pour détecter les changements de saturation et de luminosité. Les opérateurs sobel sont appliqués à ces deux canaux, et nous extrayons le gradient par rapport à l'axe x, et ajoutons les pixels qui passent notre seuil de gradient à une matrice binaire représentant les pixels de notre image. Voici à quoi cela ressemble dans l'espace de la caméra et dans l'espace des voies :

Notez que les parties de l'image les plus éloignées de la caméra ne conservent pas très bien leur qualité. En raison des limitations de résolution de la caméra, les données provenant d'objets plus éloignés sont fortement floues et bruyantes. Nous n'avons pas besoin de nous concentrer sur l'image entière, nous pouvons donc en utiliser seulement une partie. Voici à quoi ressemblera l'image que nous utiliserons :

Détection de pic d'histogramme

Nous appliquerons un algorithme spécial appelé le Sliding Fenêtre Algorithme pour détecter nos lignes de voie. Cependant, avant de pouvoir l'appliquer, nous devons déterminer un bon point de départ pour l'algorithme. Cela fonctionne bien s'il démarre à un endroit où des pixels de voie sont présents, mais comment pouvons-nous détecter l'emplacement de ces pixels de voie en premier lieu ? C'est en fait très simple !

Nous obtiendrons un histogramme de l'image par rapport à l'axe X. Chaque partie de l'histogramme ci-dessous affiche le nombre de pixels blancs dans chaque colonne de l'image. Nous prenons ensuite les pics les plus élevés de chaque côté de l'image, un pour chaque ligne de voie. Voici à quoi ressemble l'histogramme, à côté de l'image binaire :

Recherche de fenêtre coulissante

L'algorithme de fenêtre glissante sera utilisé pour différencier les limites des voies gauche et droite afin que nous puissions ajuster deux courbes différentes représentant les limites des voies.

En savoir plus sur les détails :détection des voies courbes