Detecção de pista curva

História

Introdução

Em qualquer cenário de direção, as linhas de faixa são um componente essencial para indicar o fluxo de tráfego e onde um veículo deve dirigir. Também é um bom ponto de partida ao desenvolver um carro autônomo! Com base no meu projeto anterior de detecção de faixa, implementei um sistema de detecção de faixa curva que funciona muito melhor e é mais robusto para ambientes desafiadores.

O sistema de detecção de pistas foi escrito em Python usando a biblioteca OpenCV. Este é o canal de processamento de imagem atual:

• Correção de distorção

• Perspectiva Warp

• Filtragem Sobel

• Detecção de pico do histograma

• Pesquisa em janela deslizante

• Ajuste de curva

• Pista de sobreposição detectada

• Inscreva-se no vídeo

Limitações do sistema anterior

Em meu projeto anterior de detecção de faixa, desenvolvi um sistema de detecção de faixa muito simples que pode detectar linhas retas de faixa em uma imagem. Funcionou decentemente em condições perfeitas, no entanto, não conseguiria detectar pistas curvas com precisão e não era resistente a obstruções e sombras. Esta versão melhora essas duas limitações.

Correção de distorção

As lentes da câmera distorcem a luz que entra para focalizá-la no sensor da câmera. Embora isso seja muito útil para nos permitir capturar imagens do nosso ambiente, muitas vezes elas acabam distorcendo a luz de maneira ligeiramente imprecisa. Isso pode resultar em medições imprecisas em aplicativos de visão computacional. No entanto, podemos corrigir facilmente essa distorção.

Como você faria isso? Você pode calibrar sua imagem em relação a um objeto conhecido e gerar um modelo de distorção que leva em conta as distorções da lente.

Este objeto é geralmente um tabuleiro de damas assimétrico, semelhante ao que está abaixo:


checkerboard de calibração (OpenCV Docs)

A câmera usada no vídeo de teste foi usada para tirar 20 fotos de um tabuleiro de damas, que foi usado para gerar o modelo de distorção. Começamos convertendo a imagem em tons de cinza e, em seguida, aplicando a função cv2.findChessboardCorners (). Já sabemos que este tabuleiro é um objeto bidimensional com linhas exclusivamente retas, portanto podemos aplicar algumas transformações nos cantos detectados para alinhá-los adequadamente. Usei cv2.CalibrateCamera () para obter os coeficientes de distorção e a matriz da câmera. A câmera foi calibrada!

Você pode então usar cv2.undistort () para corrigir o restante de seus dados de entrada. Você pode ver a diferença entre a imagem original do tabuleiro de damas e a imagem corrigida abaixo:


Correção de distorção aplicada a uma imagem que contém um tabuleiro de damas de calibração.

Aqui está o código exato que usei para isso:

def undistort_img ():
# Prepare os pontos do 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)
# Armazena todos os pontos de objeto e pontos de img de todas as imagens
objpoints =[]
imgpoints =[]
# Obter diretório para todas as imagens de calibração
images =glob.glob ('camera_cal / *. jpg')
para indx, fname em enumerar (imagens):
img =cv2.imread (fname)
cinza =cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)
ret, corners =cv2.findChessboardCorners (cinza, (9,6 ), Nenhum)
if ret ==Verdadeiro:
objpoints.append (obj_pts)
imgpoints.append (cantos)
# Testar a não distorção em img
img_size =( img.shape [1], img.shape [0])
# Calibrar câmera
ret, mtx, dist, rvecs, tvecs =cv2.calibrateCamera (objpoints, imgpoints, img_size, None, None)
dst =cv2.undistort (img, mtx, dist, None, mtx)
# Salvar calibração da câmera para 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)
com aberto (cal_dir, mode =' rb ') como f:
arquivo =pickle.load (f) mtx =arquivo ['mtx']
dist =arquivo ['dist']
dst =cv2.undistort (img, mtx, dist, Nenhum, mtx)
return dst
undistort_img ()
img =cv2.imread ('camera_cal / calibração1.jpg')
dst =sem distorção (img) # imagem não distorcida

As funções usadas para eles também podem ser encontradas no Jupyter Notebook sob o Código seção.

Aqui está a correção de distorção aplicada a uma imagem da estrada. Você pode não notar a ligeira diferença, mas pode ter um grande impacto no processamento da imagem.


Correção de distorção aplicada a um cenário de direção

Perspective Warp

Detectar pistas curvas no espaço da câmera não é muito fácil. E se pudéssemos ter uma visão panorâmica das pistas? Isso pode ser feito aplicando uma transformação de perspectiva na imagem. Isso é o que parece:


Perspectiva distorcida imagem

Notou alguma coisa? Ao assumir que a pista está em uma superfície 2D plana, podemos ajustar um polinômio que pode representar com precisão a pista no espaço da pista! Não é legal?

Você pode aplicar essas transformações a qualquer imagem usando a função cv2.getPerspectiveTransform () para obter a matriz de transformação e cv2.warpPerspective () para aplicá-la a uma imagem. Aqui está o código que usei para isso:

def perspectiva_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
# Para pontos de destino, estou escolhendo arbitrariamente alguns pontos como
# um bom ajuste para exibir nosso resultado distorcido
# novamente, não exato, mas próximo o suficiente para nossos propósitos
dst =dst * np.float32 (dst_size)
# Dados pontos src e dst , calcule a matriz de transformação de perspectiva
M =cv2.getPerspectiveTransform (src, dst)
# Warp a imagem usando OpenCV warpPerspective ()
warped =cv2.warpPerspective (img, M, dst_size)
retorno distorcido

Filtragem Sobel

Na versão anterior, eu havia filtrado as linhas da pista usando cores. No entanto, nem sempre essa é a melhor opção. Se a estrada usar concreto de cor clara em vez de asfalto, a estrada passa facilmente pelo filtro colorido e o oleoduto a perceberá como uma linha de faixa branca. Não é bom.

Em vez disso, podemos usar um método semelhante ao nosso detector de bordas, desta vez para filtrar a estrada. As linhas da pista normalmente têm um alto contraste com a estrada, então podemos usar isso a nosso favor. O Canny detector de borda usado anteriormente na versão 1 faz uso do Operador Sobel para obter o gradiente de uma função de imagem. A documentação do OpenCV tem uma explicação fantástica sobre como funciona. Usaremos isso para detectar áreas de alto contraste para filtrar marcações de pista e ignorar a estrada.

Ainda usaremos o HLS Colorspace novamente, desta vez para detectar mudanças na saturação e no brilho. Os operadores sobel são aplicados a esses dois canais, e extraímos o gradiente em relação ao eixo x, e adicionamos os pixels que passam nosso limite de gradiente a uma matriz binária que representa os pixels em nossa imagem. Aqui está o que parece no espaço da câmera e espaço da pista:

Observe que as partes da imagem que estavam mais longe da câmera não retêm sua qualidade muito bem. Devido às limitações de resolução da câmera, os dados de objetos mais distantes são muito borrados e barulhentos. Não precisamos nos concentrar na imagem inteira, então podemos usar apenas uma parte dela. Esta é a aparência da imagem que usaremos:

Detecção de pico do histograma

Aplicaremos um algoritmo especial denominado Deslizamento Janela Algoritmo para detectar nossas linhas de faixa. No entanto, antes de aplicá-lo, precisamos determinar um bom ponto de partida para o algoritmo. Funciona bem se começar em um ponto onde há pixels de pista presentes, mas como podemos detectar a localização desses pixels de pista em primeiro lugar? Na verdade, é muito simples!

Estaremos obtendo um histograma da imagem em relação ao eixo X. Cada parte do histograma abaixo exibe quantos pixels brancos existem em cada coluna da imagem. Em seguida, pegamos os picos mais altos de cada lado da imagem, um para cada linha de pista. Esta é a aparência do histograma, ao lado da imagem binária:

Pesquisa em janela deslizante

O algoritmo da janela deslizante será usado para diferenciar entre os limites da faixa esquerda e direita para que possamos ajustar duas curvas diferentes que representam os limites da faixa.

Leia mais detalhes:detecção de pista curva