Reconhecimento facial em tempo real:um projeto de ponta a ponta
Aprenderemos passo a passo como usar uma PiCam para reconhecer rostos em tempo real. Em meu último tutorial explorando OpenCV, aprendemos RASTREAMENTO AUTOMÁTICO DE OBJETOS DE VISÃO.
Agora usaremos nossa PiCam para reconhecer rostos em tempo real, como você pode ver abaixo:
Este projeto foi feito com esta fantástica “Biblioteca Open Source Computer Vision”, a OpenCV. Neste tutorial, vamos nos concentrar no Raspberry Pi (portanto, Raspbian como OS) e Python, mas também testei o código no Meu Mac e também funciona bem. O OpenCV foi projetado para eficiência computacional e com um forte foco em aplicativos de tempo real. Portanto, é perfeito para reconhecimento de rosto em tempo real usando uma câmera.
3 fases
Para criar um projeto completo de Reconhecimento Facial, devemos trabalhar em 3 fases bem distintas:
- Detecção de rostos e coleta de dados
- Treine o reconhecedor
- Reconhecimento facial
O diagrama de blocos abaixo resume essas fases:
Etapa 1:BoM - Lista de materiais
Partes principais:
- Raspberry Pi V3 - US $ 32,00
- Módulo de vídeo da mini câmera OV5647 com sensor 1080p de 5 megapixels - US $ 13,00
Etapa 2:Instalação do pacote OpenCV 3
Estou usando um Raspberry Pi V3 atualizado para a última versão do Raspbian (Stretch), então a melhor maneira de instalar o OpenCV é seguir o excelente tutorial desenvolvido por Adrian Rosebrock:Raspbian Stretch:Instalar OpenCV 3 + Python em seu Raspberry Pi.
Tentei vários guias diferentes para instalar o OpenCV no meu Pi. O tutorial de Adrian é o melhor. Aconselho você a fazer o mesmo, seguindo passo a passo sua orientação.
Depois de terminar o tutorial de Adrian, você deve ter um ambiente virtual OpenCV pronto para executar nossos experimentos em seu Pi.
Vamos para nosso ambiente virtual e confirme se o OpenCV 3 está instalado corretamente.
Adrian recomenda executar o comando “source” cada vez que abrir um novo terminal para garantir que as variáveis do sistema tenham sido configuradas corretamente.
fonte ~ / .profile
A seguir, vamos entrar em nosso ambiente virtual:
workon cv
Se vir o texto (cv) antes do prompt, você está no cv virtual ambiente:
(cv) pi @ framboesa:~ $
Adrian chama a atenção de que o ambiente virtual cv Python é totalmente independente e sequestrado da versão padrão do Python incluída no download do Raspbian Stretch. Portanto, quaisquer pacotes Python no diretório global de pacotes de sites não estarão disponíveis para o ambiente virtual cv. Da mesma forma, quaisquer pacotes Python instalados em pacotes de sites do cv não estarão disponíveis para a instalação global do Python.
Agora, digite seu interpretador Python:
Pitão
e confirme se você está executando a versão 3.5 (ou superior).
Dentro do intérprete (o “>>>” aparecerá), importe a biblioteca OpenCV:
import cv2
Se nenhuma mensagem de erro for exibida, o OpenCV está instalado corretamente NO SEU AMBIENTE VIRTUAL PYTHON.
Você também pode verificar a versão do OpenCV instalada:
cv2 .__ version__
O 3.3.0 deve aparecer (ou uma versão superior que pode ser lançada no futuro).
O Terminal PrintScreen acima mostra as etapas anteriores.
Etapa 3:Testar sua câmera
Depois de instalar o OpenCV em seu RPi, vamos testar para confirmar se sua câmera está funcionando corretamente.
Presumo que você já tenha uma PiCam instalada em seu Raspberry Pi.
Você deve ter a câmera ativada ao executar o tutorial de Adrian, caso contrário, os drivers não serão instalados corretamente.
Caso você receba um erro como: Erro de OpenCV:Falha na declaração , você pode tentar resolver o problema, usando o comando:
sudo modprobe bcm2835-v4l2
Depois de instalar todos os drivers corretamente, insira o código Python abaixo em seu IDE:
importar numpy como np
importar cv2
cap =cv2.VideoCapture (0)
cap.set (3.640) # definir Largura
cap.set (4.480) # definir Altura
enquanto (Verdadeiro):
ret, frame =cap.read ()
frame =cv2.flip (frame, -1) # Inverte a câmera verticalmente
cinza =cv2.cvtColor (frame , cv2.COLOR_BGR2GRAY)
cv2.imshow (‘frame’, frame)
cv2.imshow (‘gray’, gray)
k =cv2.waitKey (30) &0xff
if k ==27:# pressione ‘ESC’ para sair
break
cap.release ()
cv2.destroyAllWindows ()
O código acima irá capturar o stream de vídeo que será gerado por sua PiCam, exibindo ambos, na cor BGR e no modo Cinza.
Observe que girei minha câmera verticalmente devido à forma como ela está montada. Se não for o seu caso, comente ou exclua a linha de comando “flip”.
Você também pode baixar o código do meu GitHub:simpleCamTest.py
Para executar, digite o comando:
python simpleCamTest.py
Para finalizar o programa, você deve pressionar a tecla [ESC] em seu teclado. Clique com o mouse na janela do vídeo, antes de pressionar [ESC].
A imagem acima mostra o resultado.
Alguns fabricantes encontraram problemas ao tentar abrir a câmera (mensagens de erro “Falha na declaração”). Isso poderia acontecer se a câmera não fosse habilitada durante a instalação do OpenCv e, portanto, os drivers da câmera não fossem instalados corretamente. Para corrigir, use o comando:
sudo modprobe bcm2835-v4l2
Você também pode adicionar bcm2835-v4l2 à última linha do arquivo / etc / modules para que o driver carregue na inicialização.
Para saber mais sobre OpenCV, você pode seguir o tutorial:loading -video-python-opencv-tutorial
Etapa 4:detecção de rosto
A tarefa mais básica no reconhecimento de rosto é, obviamente, “Detecção de rosto”. Antes de mais nada, você deve “capturar” um rosto (Fase 1) para reconhecê-lo, quando comparado com um novo rosto capturado no futuro (Fase 3).
A maneira mais comum de detectar um rosto (ou qualquer objeto) é usando o “classificador Haar Cascade“
Detecção de objeto usando classificadores em cascata baseados em recursos Haar é um método de detecção de objeto eficaz proposto por Paul Viola e Michael Jones em seu artigo, "Detecção rápida de objeto usando uma cascata impulsionada de recursos simples" em 2001. É é uma abordagem baseada em aprendizado de máquina em que uma função em cascata é treinada a partir de muitas imagens positivas e negativas. Em seguida, é usado para detectar objetos em outras imagens.
Aqui, trabalharemos com a detecção de rosto. Inicialmente, o algoritmo precisa de muitas imagens positivas (imagens de rostos) e imagens negativas (imagens sem rostos) para treinar o classificador. Então, precisamos extrair recursos dele. A boa notícia é que o OpenCV vem com um treinador, além de um detector. Se você deseja treinar seu próprio classificador para qualquer objeto como carro, avião, etc., você pode usar o OpenCV para criar um. Todos os detalhes são fornecidos aqui:Cascade Classifier Training.
Se você não quiser criar seu próprio classificador, o OpenCV já contém muitos classificadores pré-treinados para rosto, olhos, sorriso, etc. Esses arquivos XML podem ser baixados do diretório haarcascades.
Chega de teoria, vamos criar um detector de rosto com OpenCV!
Baixe o arquivo:faceDetection.py do meu GitHub.
importar numpy como np
importar cv2
faceCascade =cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml')
cap =cv2.VideoCapture (0)
cap.set (3.640) # set Width
cap.set (4.480) # set Height
enquanto True:
ret, img =cap.read ()
img =cv2.flip (img, –1 )
cinza =cv2.cvtColor (img, cv2.COLOR_BGR2GRAY)
faces =faceCascade.detectMultiScale (
cinza,
scaleFactor =1,2,
minNeighbors =5,
minSize =(20, 20)
)
para (x, y, w, h) nas faces:
cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2)
roi_gray =cinza [y:y + h, x:x + w]
roi_color =img [y:y + h, x:x + w]
cv2.imshow ('video', img)
k =cv2.waitKey (30) &0xff
se k ==27:# pressione 'ESC 'para sair
break
cap.release ()
cv2.destroyAllWindows ()
Acredite ou não, as poucas linhas de código acima são tudo que você precisa para detectar um rosto, usando Python e OpenCV.
Ao comparar com o último código usado para testar a câmera, você perceberá que poucas partes foram adicionadas a ele. Observe a linha abaixo:
faceCascade =cv2.CascadeClassifier (‘Cascades / haarcascade_frontalface_default.xml’)
Esta é a linha que carrega o “classificador” (que deve estar em um diretório chamado “Cascades /”, no diretório do seu projeto).
Em seguida, definiremos nossa câmera e, dentro do loop, carregaremos nosso vídeo de entrada em modo de escala de cinza (o mesmo que vimos antes).
Agora devemos chamar nossa função classificadora, passando alguns parâmetros muito importantes, como fator de escala, número de vizinhos e tamanho mínimo da face detectada.
faces =faceCascade.detectMultiScale (
cinza,
scaleFactor =1,2,
minNeighbors =5,
minSize =(20, 20)
)
Onde,
- cinza é a imagem em tons de cinza de entrada.
- scaleFactor é o parâmetro que especifica o quanto o tamanho da imagem é reduzido em cada escala de imagem. É usado para criar a pirâmide de escala.
- minNeighbours é um parâmetro que especifica quantos vizinhos cada retângulo candidato deve ter para retê-lo. Um número mais alto resulta em falsos positivos mais baixos.
- minSize é o tamanho mínimo do retângulo para ser considerado um rosto.
A função detectará rostos na imagem. A seguir, devemos “marcar” as faces da imagem, usando, por exemplo, um retângulo azul. Isso é feito com esta parte do código:
para (x, y, w, h) nas faces:
cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2)
roi_gray =cinza [y:y + h, x:x + w]
roi_color =img [y:y + h, x:x + w]
Se faces forem encontradas, ele retorna as posições das faces detectadas como um retângulo com o canto superior esquerdo (x, y) e tendo “w” como sua largura e “h” como sua altura ==> (x, y, w, h). Por favor, veja a foto.
Depois de obter esses locais, podemos criar um “ROI” (retângulo desenhado) para o rosto e apresentar o resultado com imshow () função.
Execute o script python acima em seu ambiente python, usando o terminal Rpi:
python faceDetection.py
O resultado:
Você também pode incluir classificadores para “detecção de olhos” ou mesmo “detecção de sorriso”. Nesses casos, você incluirá a função classificadora e o retângulo desenhado dentro do loop de rosto, pois não faria sentido detectar um olho ou um sorriso fora de um rosto.
Note que em um Pi, ter vários classificadores no mesmo código tornará o processamento lento, uma vez que este método de detecção (HaarCascades) usa uma grande quantidade de poder computacional. Em um desktop, é mais fácil executá-lo.
Exemplos
No meu GitHub, você encontrará outros exemplos:
- faceEyeDetection.py
- faceSmileDetection.py
- faceSmileEyeDetection.py
E na imagem, você pode ver o resultado.
Você também pode seguir o tutorial abaixo para entender melhor a detecção de rosto:
Tutorial de detecção de objetos em cascata de Haar em OpenCV Python
Etapa 5:coleta de dados
Em primeiro lugar, devo agradecer a Ramiz Raja por seu excelente trabalho em Reconhecimento facial em fotos:
RECONHECIMENTO DE ROSTO USANDO OPENCV E PYTHON:UM GUIA PARA INICIANTES
e também Anirban Kar, que desenvolveu um tutorial muito abrangente usando vídeo:
RECONHECIMENTO DE ROSTO - 3 partes
Eu realmente recomendo que você dê uma olhada em ambos os tutoriais.
Dizendo isso, vamos começar a primeira fase do nosso projeto. O que faremos aqui, é partindo da última etapa (Detecção de Rosto), vamos simplesmente criar um conjunto de dados, onde armazenaremos para cada id, um grupo de fotos em cinza com a parte que foi usada para detecção de rosto.
Primeiro, crie um diretório onde você desenvolve seu projeto, por exemplo, FacialRecognitionProject:
mkdir FacialRecognitionProject
Neste diretório, além dos 3 scripts python que criaremos para nosso projeto, devemos ter salvo nele o Classificador Facial. Você pode baixá-lo do meu GitHub:haarcascade_frontalface_default.xml
Em seguida, crie um subdiretório onde armazenaremos nossas amostras faciais e o nomearemos “conjunto de dados”:
conjunto de dados mkdir
E baixe o código do meu GitHub:01_face_dataset.py O código é muito semelhante ao código que vimos para detecção de rosto. O que adicionamos foi um "comando de entrada" para capturar uma id do usuário, que deve ser um número inteiro (1, 2, 3, etc) E para cada um dos frames capturados, devemos salvá-lo como um arquivo em um diretório “dataset”: Observe que para salvar o arquivo acima, você deve ter importado a biblioteca “os”. O nome de cada arquivo seguirá a estrutura: Por exemplo, para um usuário com face_id =1, o quarto arquivo de amostra no conjunto de dados / diretório será algo como: conforme mostrado na foto do meu Pi: No meu código, estou capturando 30 amostras de cada id. Você pode alterá-lo no último “elif”. O número de amostras é usado para quebrar o loop onde as amostras de rosto são capturadas. Execute o script Python e capture alguns Ids. Você deve executar o script sempre que desejar agregar um novo usuário (ou trocar as fotos por uma já existente). Nesta segunda fase, devemos pegar todos os dados do usuário de nosso conjunto de dados e “treinar” o reconhecedor OpenCV. Isso é feito diretamente por uma função específica do OpenCV. O resultado será um arquivo .yml que será salvo em um diretório “trainer /”.
import cv2
import os
cam =cv2.VideoCapture (0)
cam.set (3, 640) # definir a largura do vídeo
cam.set (4, 480) # set altura do vídeo
face_detector =cv2.CascadeClassifier ('haarcascade_frontalface_default.xml')
# Para cada pessoa, insira um id de rosto numérico
face_id =input ('\ n insira o id do usuário e pressione
print (“\ n [INFO] Inicializando a captura de rosto. Olhe para a câmera e espere ...”)
# Inicializar contagem de face de amostragem individual
contagem =0
enquanto (Verdadeiro):
ret, img =cam.read ()
img =cv2.flip (img, -1) # inverte a imagem do vídeo verticalmente
cinza =cv2.cvtColor (img , cv2.COLOR_BGR2GRAY)
faces =face_detector.detectMultiScale (cinza, 1,3, 5)
para (x, y, w, h) nas faces:
cv2.rectangle (img, (x , y), (x + w, y + h), (255,0,0), 2)
contagem + =1
# Salve a imagem capturada na pasta de conjuntos de dados
cv2 .imwrite (“dataset / User.” + str (face_id) + '.' + str (contagem) + “.jpg”, cinza [y:y + h, x:x + w])
cv2. imshow ('imagem', img)
k =cv2.waitKey (100) &0x ff # Pressione 'ESC' para sair do vídeo
if k ==27:
pausa
contagem elif> =30:# Pegue uma amostra de 30 rosto e pare o vídeo
pausa
# Faça uma pequena limpeza
print (“\ n [INFO] Saindo do programa e coisas de limpeza”)
cam.release ()
cv2.destroyAllWindows ()
face_id =input (‘\ n insira o id do usuário e pressione ==>‘)
cv2.imwrite (“conjunto de dados / usuário.” + str (face_id) + ‘.’ + str (contagem) + “.jpg”, cinza [y:y + h, x:x + w])
User.face_id.count.jpg
User.1.4.jpg
Etapa 6:instrutor
Leia mais detalhes:Reconhecimento facial em tempo real:um projeto de ponta a ponta
Processo de manufatura