Detecção de rosto e movimento usando visão computacional

OpenCV (Biblioteca de Visão Computacional de código aberto) é um módulo Python usado para visão computacional. É um módulo imenso com recursos excepcionais. Podemos fazer muitas coisas com visão computacional, e algumas das maiores são o reconhecimento de rosto e a detecção de movimento.

Neste tutorial, você aprenderá a escrever código para detectar rostos em imagens, vídeos e movimento.

Para evitar todos os tipos de erros e problemas, baixaremos o arquivo OpenCV do GitHub em https: // github.com/opencv/opencv. Usaremos alguns dos arquivos para concluir o código.

Detecção de rosto usando imagens

Dentro do arquivo GitHub OpenCV, há um subdiretório (OpenCV-Mestre \ Somemples \ Data) chamado Data, onde as imagens e vídeos de amostra para trabalhar estão disponíveis. Estaremos usando fotos e vídeos encontrados neste diretório. Em particular, estarei usando o Lena.arquivo jpg. Vou copiar e colá -lo no meu diretório de trabalho Pycharm (no meu caso, é C: \ Usuários \ Never \ PyCharmProjects \ PythonProject). Agora, vamos começar a detecção de rosto nesta imagem.

Primeiro, vamos carregar os módulos de que precisamos:

importar numpy como np
importar CV2

O arquivo que usaremos está localizado no OpenCV-MASTER \ DATA \ HAARCASCADES \ haarcascade_frontalface_default.XML do arquivo baixado do github. Precisamos colocar um link para o arquivo Haarcascade da seguinte maneira:

FACE_CASCADE = CV2.Cascadeclassifier ('C: \\ Users \\ Never \\ Downloads \\ OpenCV-MASTER \\ DATA \\ HAARCASCADES \\ haarcascade_frontalface_default.xml ')

Carregue a foto para realizar a detecção de rosto usando o CV2.Método imread ().

imagem = cv2.imread ('lena.jpg ')

Nosso próximo objetivo é transformar a foto em escala de cinza. O último é feito usando o CV2.método cvtcolor (). Este método leva dois argumentos. O primeiro argumento é o nome do arquivo a ser convertido, e o segundo argumento é o formato de conversão. Nesse caso, usaremos CV2.Color_bgr2gray para convertê -lo em um formato em escala de cinza.

cinza = cv2.cvtcolor (imagem, CV2.Color_bgr2gray)

Em seguida, usamos a função detectMultisCale () para detectar objetos ou, neste caso, enfrentar. Aqui, vamos contar ao Python FACE_CASCADE.DetectMultisCale (), que detectará faces, pois é isso que no parâmetro FACE_CASCADE. A função detectMultisCale () leva alguns argumentos, a imagem, um fator de escala, o número mínimo de vizinhos, bandeiras, tamanho mínimo e tamanho máximo.

FACES = FACE_CASCADE.DetectMultiscale (Gray, 1.5, 5)

Para colocar uma caixa retangular ao redor do rosto, precisamos usar o CV2.Método Rectangle (). Usando este método, precisamos dar alguns argumentos. O primeiro argumento é a imagem em que você deseja, o segundo argumento é o ponto de partida do retângulo, o terceiro argumento é o ponto final do retângulo, o quarto argumento é a cor do retângulo e o quinto argumento é a espessura de a linha. Nesse caso, w é para largura, h é para altura e x e y são o ponto de partida.

para (x, y, w, h) em rostos:
cv2.retângulo (imagem, (x, y), (x+w, y+h), (0,255,0), 3)

Por fim, mostramos a imagem usando o CV2.Método imshow (). Também usamos o CV2.WaitKey (0) para definir um tempo de espera infinito e usar o CV2.Método DestroyAllWindows () para fechar a janela.

cv2.imshow ('imagem', imagem)
cv2.WaitKey (0)
cv2.DestroyAllWindows ()

Detecção de rosto usando vídeos/webcam

Nesse caso, vamos detectar rostos em tempo real usando uma webcam ou um vídeo. Mais uma vez, começamos importando os módulos necessários.

importar numpy como np
importar CV2

Em seguida, precisamos especificar a localização dos arquivos Haarcascade. Fazemos isso o seguinte (exatamente como para a imagem):

FACE_CASCADE = CV2.Cascadeclassifier ('C: \\ Users \\ Never \\ Downloads \\ OpenCV-MASTER \\ DATA \\ HAARCASCADES \\ haarcascade_frontalface_default.xml ')

Agora, precisamos especificar o vídeo com o qual queremos lidar usando o CV2.Método Videocapture (). No meu caso, escolhi lidar com um vídeo que tive e inseri o nome do vídeo. Se você quiser lidar com webcams, você colocaria um 0 em vez do nome do arquivo de vídeo.

vídeo = cv2.Videocapture ("vídeo.mp4 ")

Nós começamos um pouco o tempo. No momento em que é verdade, pedimos ao programa que detecte os rostos até que paremos nele. Em primeira instância, lemos o arquivo de vídeo usando a função read ().

enquanto é verdade:
ret, imagem = vídeo.ler()

Assim como na seção anterior, precisamos transformar as imagens ou quadros para escala de cinza para facilitar a detecção. Usamos o CV2.método cvtcolor () para alterar os quadros para cinza.

cinza = cv2.cvtcolor (imagem, CV2.Color_bgr2gray)

Para detectar os rostos, usamos a função DetectMultisCale (). Mais uma vez, leva os mesmos parâmetros que na seção anterior.

FACES = FACE_CASCADE.DetectMultiscale (Gray, 1.1, 4)

Para colocar retângulos ao redor dos rostos, usamos o CV2.Método Rectangle (). Isso é semelhante à seção anterior.

para (x, y, w, h) em rostos:
cv2.retângulo (imagem, (x, y), (x+w, y+h), (255, 0, 0), 2)

Em seguida, mostramos os quadros usando o CV2.Método imshow (). Este método leva dois argumentos, o primeiro é o nome do quadro, e o segundo é o quadro a ser exibido.

cv2.imshow ('imagem', imagem)

Em seguida, colocamos uma cláusula, se o usuário pressionar a tecla ESC (ou 27), o código será interrompido do loop.

se cv2.WaitKey (0) e 0xff == 27:
quebrar

Finalmente, lançamos o vídeo usando a função Release ().

vídeo.liberar()

Detector de movimento

A detecção de movimento é ótima! O que isso significa é que, com Python e uma boa webcam, podemos criar nossa própria câmera de segurança! Então, vamos começar.

importar numpy como np
importar CV2

Estarei escolhendo um vídeo das amostras (OpenCV-Mestre \ Amostras \ Data) do arquivo github.

vídeo = cv2.Videocapture ("Vtest.Avi ")

Para detectar movimento, o que basicamente confiamos é a diferença nos valores de pixel de duas imagens, uma imagem de referência e uma segunda imagem ou quadro. Então, criamos duas imagens, Frame1 e Frame2.

ret, frame1 = vídeo.ler()
ret, frame2 = vídeo.ler()

Enquanto o vídeo é aberto ou usando a função isopened (), começamos um loop.

enquanto vídeo.está aberto():

Primeiro calculamos a diferença absoluta entre o quadro1 e o quadro2 usando o CV2.Método absdiff (). Obviamente, são necessários dois argumentos, o primeiro e o segundo quadros.

diferença = cv2.Absdiff (Frame1, Frame2)

Como as coisas são mais fáceis em preto e branco, transformaremos a diferença em escala de cinza usando o CV2.método cvtcolor (). O cv2.O método cvtcolor () leva dois argumentos, o primeiro é o quadro ou a imagem, e o segundo é a transformação. Nesse caso, usaremos CV2.Color_bgr2gray.

cinza = cv2.cvtcolor (diferença, cv2.Color_bgr2gray)

Uma vez que a imagem estiver em escala de cinza, precisamos embaçar a imagem para remover o ruído usando o CV2.Método GaussianBlur (). O cv2.O método GaussianBlur () leva alguns argumentos-a imagem de origem para desfocar, a imagem de saída, o tamanho do kernel gaussiano, o desvio padrão do kernel ao longo do eixo x, o desvio padrão do kernel ao longo do eixo y e o tipo de borda.

Blur = CV2.Gaussianblur (Gray, (5,5), 0)

Em seguida, colocamos um valor limite usando o CV2.Método limiar (). Esta técnica isolará o movimento segmentando o fundo e o primeiro plano (ou movimento). O cv2.Método limhold () leva quatro argumentos: a imagem, o valor limite, o valor máximo para usar com thresh_binary e thresh_binary_inv e o tipo de limite.

_, limite = cv2.limiar (Blur, 20, 255, CV2.Thresh_binary)

Em seguida, dilatamos usando o CV2.Método Dilate () que leva 6 argumentos no máximo: a imagem, o kernel, a âncora, as iterações, o tipo de borda e o valor da borda.

dilata = cv2.dilata (limiar, nenhum, iterações = 3)

O cv2.O método findContours () faz exatamente o que significa, encontra contornos. São necessários três argumentos: a imagem de origem, o modo de recuperação e o método de aproximação de contorno.

contorno, _ = cv2.FindContours (dilata, CV2.Ret_tree, v2.Chain_Approx_simple)

O cv2.O método de drawcontours () é usado para desenhar os contornos. São necessários alguns argumentos: a imagem, os contornos, o contouridx (esse valor é negativo se todos os contornos forem desenhados), a cor, espessura, tipo de linha, hierarquia, nível máximo e deslocamento.

cv2.DrawContours (Frame1, Contour, -1, (0, 0, 255), 2)

Por fim, mostramos a imagem usando o CV2.Método imshow ().

cv2.imshow ("imagem", quadro1)

Agora, definimos o quadro inicial 2 como o primeiro quadro e lemos o vídeo para um novo quadro que colocamos no parâmetro Frame2.

Frame1 = Frame2
ret, frame2 = vídeo.ler()

Se a tecla "Q" for pressionada, saia do loop:

se cv2.WaitKey (40) == ord ('q'):
quebrar
vídeo.liberar()

O código como um todo para detecção de movimento seria algo assim:

importar numpy como np
importar CV2
vídeo = cv2.Videocapture ("Vtest.Avi ")
ret, frame1 = vídeo.ler()
ret, frame2 = vídeo.ler()
enquanto vídeo.está aberto():
diferença = cv2.Absdiff (Frame1, Frame2)
cinza = cv2.cvtcolor (diferença, cv2.Color_bgr2gray)
Blur = CV2.Gaussianblur (Gray, (5,5), 0)
_, limite = cv2.limiar (Blur, 20, 255, CV2.Thresh_binary)
dilata = cv2.dilata (limiar, nenhum, iterações = 3)
contorno, _ = cv2.FindContours (dilata, CV2.Ret_tree, cv2.Chain_Approx_simple)
cv2.DrawContours (Frame1, Contour, -1, (0, 0, 255), 2)
cv2.imshow ("imagem", quadro1)
Frame1 = Frame2
ret, frame2 = vídeo.ler()
se cv2.WaitKey (40) == ord ('q'):
quebrar
vídeo.liberar()

É tão simples tão simples! Algumas linhas de código, e podemos fazer nossos próprios programas de reconhecimento de rosto e detecção de movimento. Algumas linhas adicionais, e podemos até convencê -las (digamos, usando PTTSX3) e criar nossas próprias câmeras de segurança!

Codificação feliz!