Detección de carril curvo

Historia

Introducción

En cualquier escenario de conducción, las líneas de carril son un componente esencial para indicar el flujo de tráfico y dónde debe conducir un vehículo. ¡También es un buen punto de partida para desarrollar un automóvil autónomo! Sobre la base de mi proyecto anterior de detección de carriles, he implementado un sistema de detección de carriles curvos que funciona mucho mejor y es más robusto para entornos desafiantes.

El sistema de detección de carriles fue escrito en Python usando la biblioteca OpenCV. Aquí está la canalización actual de procesamiento de imágenes:

• Corrección de distorsión

• Deformación de perspectiva

• Filtrado Sobel

• Detección de picos de histograma

• Búsqueda de ventana deslizante

• Ajuste de curva

• Superposición de carril detectado

• Aplicar al video

Limitaciones del sistema anterior

En mi proyecto anterior de detección de carriles, había desarrollado un sistema de detección de carriles muy simple que podía detectar líneas rectas de carriles en una imagen. Funcionaba decentemente en perfectas condiciones, sin embargo, no detectaba con precisión los carriles con curvas y no era resistente a obstrucciones y sombras. Esta versión mejora estas dos limitaciones.

Corrección de distorsión

Las lentes de la cámara distorsionan la luz entrante para enfocarla en el sensor de la cámara. Aunque esto es muy útil para permitirnos capturar imágenes de nuestro entorno, a menudo terminan distorsionando la luz de manera ligeramente inexacta. Esto puede resultar en mediciones inexactas en aplicaciones de visión por computadora. Sin embargo, podemos corregir fácilmente esta distorsión.

¿Cómo harías esto? Puede calibrar su imagen contra un objeto conocido y generar un modelo de distorsión que tenga en cuenta las distorsiones de la lente.

Este objeto suele ser un tablero de ajedrez asimétrico, similar al siguiente:

tablero de ajedrez de calibración (OpenCV Docs)

La cámara utilizada en el video de prueba se utilizó para tomar 20 fotografías de un tablero de ajedrez, que se utilizaron para generar el modelo de distorsión. Comenzamos por convertir la imagen a escala de grises y luego aplicamos la función cv2.findChessboardCorners (). Ya sabemos que este tablero de ajedrez es un objeto bidimensional con líneas exclusivamente rectas, por lo que podemos aplicar algunas transformaciones a las esquinas detectadas para alinearlas correctamente. Usé cv2.CalibrateCamera () para obtener los coeficientes de distorsión y la matriz de la cámara. ¡La cámara ha sido calibrada!

Luego puede usar cv2.undistort () para corregir el resto de sus datos de entrada. Puede ver la diferencia entre la imagen original del tablero de ajedrez y la imagen corregida a continuación:

Corrección de distorsión aplicada a una imagen que contiene un tablero de ajedrez de calibración.

Aquí está el código exacto que usé para esto:

def undistort_img ():
# Preparar puntos de objeto 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)
# Almacena todos los puntos de objeto y puntos img de todas las imágenes
objpoints =[]
imgpoints =[]
# Obtener directorio para todas las imágenes de calibración
images =glob.glob ('camera_cal / *. jpg')
para indx, fname en enumerate (imágenes):
img =cv2.imread (fname)
gris =cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)
ret, esquinas =cv2.findChessboardCorners (gris, (9,6 ), Ninguno)
si ret ==Verdadero:
objpoints.append (obj_pts)
imgpoints.append (esquinas)
# Prueba de distorsión en img
img_size =( img.shape [1], img.shape [0])
# Calibrar cámara
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera (objpoints, imgpoints, img_size, None, None)
dst =cv2.undistort (img, mtx, dist, None, mtx)
# Guarde la calibración de la cámara para su uso posterior
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)
con open (cal_dir, mode =' rb ') as f:
file =pickle.load (f) mtx =file ['mtx']
dist =archivo ['dist']
dst =cv2.undistort (img, mtx, dist, None, mtx)
return dst
undistort_img ()
img =cv2.imread ('camera_cal / Calibration1.jpg')
dst =undistort (img) # Imagen sin distorsión

Las funciones utilizadas para estos también se pueden encontrar en el Cuaderno de Jupyter en Código sección.

Aquí está la corrección de distorsión aplicada a una imagen de la carretera. Es posible que no note la ligera diferencia, pero puede tener un gran impacto en el procesamiento de imágenes.

Corrección de distorsión aplicada a una escena de conducción

Deformación de perspectiva

Detectar carriles curvos en el espacio de la cámara no es muy fácil. ¿Y si pudiéramos tener una vista panorámica de los carriles? Eso se puede hacer aplicando una transformación de perspectiva en la imagen. Así es como se ve:

Imagen deformada en perspectiva

¿Notaste algo? Suponiendo que el carril está en una superficie plana 2D, podemos ajustar un polinomio que puede representar con precisión el carril en el espacio del carril. ¿No es genial?

Puede aplicar estas transformaciones a cualquier imagen usando la función cv2.getPerspectiveTransform () para obtener la matriz de transformación y cv2.warpPerspective () para aplicarla a una imagen. Aquí está el código que usé para esto:

def deformación_perspectiva (img,
tamaño_dst =(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
# Para los puntos de destino, estoy eligiendo arbitrariamente algunos puntos para que sean
# un buen ajuste para mostrar nuestro resultado deformado
# nuevamente, no exacto, pero lo suficientemente cercano para nuestros propósitos
dst =dst * np.float32 (dst_size)
# Dados los puntos src y dst , calcula la matriz de transformación de perspectiva
M =cv2.getPerspectiveTransform (src, dst)
# Deforma la imagen usando OpenCV warpPerspective ()
warped =cv2.warpPerspective (img, M, dst_size)
volver deformado

Filtrado Sobel

En la versión anterior, había filtrado las líneas de carril usando color. Sin embargo, esta no siempre es la mejor opción. Si el camino usa concreto de color claro en lugar de asfalto, el camino pasa fácilmente a través del filtro de color y la tubería lo percibirá como una línea de carril blanca. No es bueno.

En su lugar, podemos usar un método similar a nuestro detector de bordes, esta vez para filtrar la carretera. Las líneas de carril suelen tener un alto contraste con la carretera, por lo que podemos usar esto a nuestro favor. El astuto El detector de bordes utilizado anteriormente en la versión 1 hace uso de Sobel Operator para obtener el gradiente de una función de imagen. La documentación de OpenCV tiene una explicación fantástica sobre cómo funciona. Usaremos esto para detectar áreas de alto contraste para filtrar las marcas de los carriles e ignorar la carretera.

Seguiremos usando HLS Colorspace nuevamente, esta vez para detectar cambios en Saturación y Luminosidad. Los operadores de sobel se aplican a estos dos canales, y extraemos el gradiente con respecto al eje x, y agregamos los píxeles que pasan nuestro umbral de gradiente a una matriz binaria que representa los píxeles de nuestra imagen. Así es como se ve en el espacio de la cámara y el espacio del carril:

Tenga en cuenta que las partes de la imagen que estaban más alejadas de la cámara no conservan muy bien su calidad. Debido a las limitaciones de resolución de la cámara, los datos de los objetos más lejanos son muy borrosos y ruidosos. No es necesario que nos centremos en la imagen completa, por lo que solo podemos usar una parte. Así es como se verá la imagen que usaremos:

Detección de picos de histograma

Aplicaremos un algoritmo especial llamado Deslizamiento Ventana Algoritmo para detectar nuestras líneas de carril. Sin embargo, antes de que podamos aplicarlo, debemos determinar un buen punto de partida para el algoritmo. Funciona bien si comienza en un lugar donde hay píxeles de carril presentes, pero ¿cómo podemos detectar la ubicación de estos píxeles de carril en primer lugar? ¡Es realmente muy simple!

Obtendremos un histograma de la imagen con respecto al eje X. Cada parte del histograma a continuación muestra cuántos píxeles blancos hay en cada columna de la imagen. Luego tomamos los picos más altos de cada lado de la imagen, uno para cada línea de carril. Así es como se ve el histograma, junto a la imagen binaria:

Búsqueda de ventana deslizante

El algoritmo de la ventana deslizante se utilizará para diferenciar entre los límites del carril izquierdo y derecho de modo que podamos ajustar dos curvas diferentes que representen los límites del carril.

Leer más detalles:detección de carriles curvos