Phenquestions
Raspberry Pi é um minicomputador de baixo custo que tornou a computação e a programação muito mais fácil para a maioria das pessoas, incluindo estudantes e amadores. Este minicomputador pode fazer tudo o que um computador desktop pode fazer, desde navegar na Internet até criar projetos e programas interessantes. E um desses projetos incríveis é fazer um reconhecimento facial de Raspberry Pi. Embora este projeto possa ser muito interessante, não é muito fácil de fazer. Então, eu recomendo que você siga o artigo passo a passo.
Raspberry Pi Face Recognition
Fazer um programa de reconhecimento de rosto pode ter sido uma coisa muito difícil e avançada uma vez. Mas com Raspberry Pi, nada é muito difícil! Neste artigo, usei a Open Source Computer Vision Library (OpenCV) para fazer o projeto.
Este repositório foi projetado para funcionar com eficiência computacional e aplicativos em tempo real. Portanto, é ideal para nosso programa de reconhecimento facial em tempo real. Este artigo irá guiá-lo passo a passo por todo o projeto. Então, atenha-se ao final para ter seu próprio reconhecimento facial de Raspberry Pi!
Requisitos
Você precisará dos seguintes itens para fazer um sistema de reconhecimento de rosto Raspberry Pi:
- Raspberry Pi V4
- Noir Camera
- OpenCV
Conexões Raspberry Pi
Certifique-se de criar as seguintes conexões antes de começar a codificar:
- Faça as conexões entre o Raspberry Pi e o cabo de fita do monitor
- Anexe o SDA ao pino SDA do seu Pi
- Coloque o SCL do monitor no pino SCL
- Conecte o cabo de fita da câmera ao Raspberry Pi
- Coloque o GND do display no Pi GND
- Conecte o Raspberry Pi 5V e o display de 5V
Etapa 1: instale o OpenCV no Raspberry Pi
O primeiro passo é instalar o OpenCV em seu dispositivo Pi. Para fazer isso, inicie o Raspberry Pi e abra uma conexão SSH. Para incluir todo o espaço disponível no cartão micro-SD, expanda seu sistema de arquivos.
$ sudo raspi-config
Em seguida, selecione "Opções avançadas" no menu e "Expandir sistema de arquivos" depois:
Depois disso, acerte o “
$ sudo reboot
Etapa 2: Confirme a instalação do OpenCV
Assim que terminar de reinicializar, deve haver um ambiente virtual OpenCV pronto em seu Pi. Agora, você deve confirmar se o OpenCV está instalado corretamente em seu Pi. Execute o comando “source” toda vez que você abrir um novo terminal para que as variáveis do sistema sejam configuradas corretamente.
fonte ~ /.perfil
Agora, entre em seu ambiente virtual:
workon cv
O texto (cv) significa que você está no ambiente virtual cv.
(cv) pi @ framboesa: ~ $
Para entrar em seu intérprete Python:
Pitão
Você verá um “>>>” aparecer no intérprete. Para importar a biblioteca OpenCV:
import cv2
Se não houver mensagens de erro, você pode ter certeza de que o OpenCV está instalado corretamente.
Etapa 3: Baixe o OpenCV
Agora, baixe o OpenCV instalado. Você terá que baixar o OpenCV e o OpenCV contrib. O contrib vem com módulos e funções de que você precisará neste experimento.
$ cd ~ $ wget -O opencv.zip https: // github.com / opencv / opencv / archive / 4.0.0.zip $ wget -O opencv_contrib.zip https: // github.com / opencv / opencv_contrib / archive / 4.0.0.fecho eclair
Agora, descompacte os arquivos:
$ unzip opencv.zip $ unzip opencv_contrib.fecho eclair
Etapa 4: instalar dependências
Agora, instale as dependências necessárias do OpenCV em seu Raspberry Pi para que funcione corretamente:
$ sudo apt-get update && sudo apt-get upgrade $ sudo apt-get install build-essencial cmake pkg-config $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev $ sudo apt-get install libavcodec -dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libgtk2.0-dev libgtk-3-dev $ sudo apt-get install libfontconfig1-dev libcairo2-dev $ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev $ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5 $ sudo apt-get install libatlas-base-dev gfortran $ sudo apt- obter instalar python2.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Etapa 5: instalar o pip
Nesta etapa, você terá que instalar um gerenciador de pacotes para python chamado “pip”.
$ wget https: // bootstrap.pypa.io / get-pip.py $ sudo python3 get-pip.py
Etapa 6: instalar o Numpy
Depois disso, instale uma biblioteca Python chamada “Numpy”.
$ Pip3 install numpy
Etapa 7: teste a câmera
Agora que você instalou todas as coisas necessárias, incluindo o OpenCV, é hora de verificar se sua câmera está funcionando corretamente. Você já deve ter um Picam instalado no seu Raspberry Pi. Insira o seguinte código em seu IDE Python:
import numpy como np import cv2 cap = cv2.Limite VideoCapture (0).set (3.640) # set Limite de largura.set (4.480) # set Height while (True): ret, frame = cap.read () frame = cv2.flip (frame, -1) # Flip câmera verticalmente cinza = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('cinza', cinza) k = cv2.waitKey (30) & 0xff if k == 27: # pressione 'ESC' para sair do limite de quebra.release () cv2.destroyAllWindows () Este código funciona capturando o fluxo de vídeo gerado por sua PiCam que exibe o modo cinza e o modo de cor BGR. Em seguida, execute o código com o seguinte comando:
python simpleCamTest.py
Agora, pressione a tecla [ESC] para finalizar o programa. Certifique-se de clicar na janela do vídeo antes de finalizá-lo. Agora você deve ver sua câmera funcionando corretamente e mostrando resultados. Se sua câmera mostrar mensagens de erro "Falha na declaração", use o seguinte comando para corrigir isso:
sudo modprobe bcm2835-v4l2
Etapa 8: detecção de rosto
Você deve saber que o primeiro passo para concluir nosso projeto de reconhecimento facial é fazer com que a PiCam capture um rosto. Certamente, ele deve detectar um rosto primeiro para reconhecê-lo no futuro.
O algoritmo de detecção de rosto requer imagens com o rosto, bem como sem o rosto para treinar o classificador e salvar estruturas daqueles. Felizmente, o OpenCV que você baixou anteriormente vem com um detector e treinador. Além disso, já possui alguns classificadores pré-treinados como rosto, olhos, mãos, etc. Para criar um detector facial com OpenCV, use os seguintes códigos:
import numpy como np import cv2 faceCascade = cv2.CascadeClassifier ('Cascades / haarcascade_frontalface_default.xml ') cap = cv2.Limite VideoCapture (0).set (3.640) # set Limite de largura.set (4.480) # set Height while True: ret, img = cap.read () img = cv2.flip (img, -1) cinza = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale (cinza, scaleFactor = 1.2, minNeighbours = 5, minSize = (20, 20)) para (x, y, w, h) nas faces: cv2.retângulo (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 if k == 27: # pressione 'ESC' para sair do limite de quebra.release () cv2.destroyAllWindows () Agora, você terá que chamar a função classificadora com alguns fatores de escala, parâmetros e um tamanho mínimo da face que detectará.
faces = faceCascade.detectMultiScale (cinza, scaleFactor = 1.2, minNeighbors = 5, minSize = (20, 20))
Este código funciona detectando rostos em uma imagem. Agora, você pode querer marcar os rostos usando uma forma como um retângulo. Use o seguinte código para fazer isso:
para (x, y, w, h) nas faces: cv2.retângulo (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]
Então é assim que funciona:
Se o classificador encontrar qualquer rosto na imagem, ele mostra as posições do rosto como um retângulo conforme comandado, onde usa "h" como sua altura e "w" como a largura e os cantos superiores esquerdos (x, y). Isso resume o nosso retângulo (x, y, w, h).
Agora que você concluiu os locais, crie um "ROI" para o rosto e mostre o resultado com a função imshow (). Execute-o no ambiente python usando o Terminal Raspberry Pi:
python faceDetection.py
E o resultado:
Etapa 9: salvando dados
Nesta parte, você deve criar um conjunto de dados onde seu programa salvará os dados coletados sobre os Ids do rosto que detectou. Para fazer isso, crie um diretório (estou usando FacialRecognition):
mkdir FacialRecognition
Agora, crie um subdiretório com o nome “dataset”.
conjunto de dados mkdir
Em seguida, use o seguinte código:
import cv2 import os cam = cv2.VideoCapture (0) cam.definir (3, 640) # definir câmera de largura de vídeo.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 = 0 enquanto (Verdadeiro): ret, img = cam.read () img = cv2.flip (img, -1) # flip 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.retângulo (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 ("conjunto de dados / Usuário."+ str (face_id) + '.'+ str (contagem) + ".jpg ", cinza [y: y + h, x: x + w]) cv2.imshow ('imagem', img) k = cv2.waitKey (100) & 0xff # Pressione 'ESC' para sair do vídeo se k == 27: break elif count> = 10: # Pegue uma amostra de 10 faces e pare a pausa do vídeo # Faça um pouco de limpeza de impressão ("\ n [INFO] Saindo do programa e coisas de limpeza ") cam.release () cv2.destroyAllWindows () Observe que vamos salvar cada um dos quadros capturados como um arquivo no subdiretório “dataset”:
cv2.imwrite ("conjunto de dados / Usuário."+ str (face_id) + '.'+ str (contagem) + ".jpg ", cinza [y: y + h, x: x + w]) Depois disso, você deve importar a biblioteca “os” para salvar o arquivo acima. O nome dos arquivos seguirá uma estrutura como esta:
Do utilizador.face_id.contar.jpg, / pre>
O código mencionado acima irá capturar apenas 10 imagens para cada id. Você certamente pode mudar isso se quiser.
Agora, tente executar o programa e capturar alguns ids. Certifique-se de executar o código sempre que alterar o usuário ou a foto existente.
Etapa 10: instrutor
Nesta etapa, você terá que usar uma função OpenCV para treinar o reconhecedor OpenCV com os dados do seu conjunto de dados. Comece criando um subdiretório para armazenar os dados treinados.
treinador mkdir
Em seguida, execute o seguinte código:
import cv2 import numpy as np de PIL import Image import os # Caminho para o banco de dados de imagens de rosto caminho = 'dataset' reconhecedor = cv2.Rosto.LBPHFaceRecognizer_create () detector = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml "); # função para obter as imagens e os dados do rótulo def getImagesAndLabels (path): imagePaths = [os.caminho.junte (caminho, f) para f em os.listdir (path)] faceSamples = [] ids = [] para imagePath em imagePaths: PIL_img = Image.abrir (imagePath).convert ('L') # converta para tons de cinza img_numpy = np.array (PIL_img, 'uint8') id = int (os.caminho.dividir (imagePath) [- 1].dividir(".") [1]) faces = detector.detectMultiScale (img_numpy) para (x, y, w, h) em faces: faceSamples.anexar (img_numpy [y: y + h, x: x + w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] Faces de treinamento. Vai demorar alguns segundos. Espere… ") faces, ids = getImagesAndLabels (path) reconhecedor.trem (rostos, np.array (ids)) # Salve o modelo no treinador / treinador.reconhecedor yml.escrever ('treinador / treinador.yml ') # reconhecedor.save () funcionou no Mac, mas não no Pi # Imprime o número de faces treinadas e finaliza a impressão do programa ("\ n [INFO] 0 faces treinadas. Saindo do programa ".formato (len (np.exclusivo (ids)))) Certifique-se de que instalou a biblioteca PIL no seu Raspberry Pi. Se você não tiver isso, execute o seguinte comando:
pip instalar travesseiro
Aqui, estou usando o reconhecedor de rosto LBPH que vem incluído com o pacote OpenCV. Agora, siga esta linha:
reconhecedor = cv2.Rosto.LBPHFaceRecognizer_create ()
Todas as suas fotos serão levadas para o diretório “dataset” pela função “getImagesAndLabels”. Ele retornará 2 matrizes chamadas "Ids" e "faces". Agora é hora de treinar o reconhecedor.
Reconhecedor.treinar (faces, ids)
Agora, você verá o “treinador.yml ”arquivo nomeado salvo no diretório do treinador.
Etapa 11: reconhecimento facial
É hora da ação final. Após esta etapa, seu reconhecedor pode adivinhar um id de retorno se o rosto foi capturado antes. Então, vamos escrever nosso código final:
import cv2 import numpy as np import os reconhecizer = cv2.Rosto.LBPHFaceRecognizer_create () reconhecedor.leia ('treinador / treinador.yml ') cascadePath = "haarcascade_frontalface_default.xml "faceCascade = cv2.CascadeClassifier (cascadePath); font = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # nomes relacionados a ids: example ==> Marcelo: id = 1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Inicializar e iniciar a captura de vídeo em tempo real cam = cv2.VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # set video height # Define o tamanho mínimo da janela a ser reconhecido como um rosto minW = 0.1 * cam.obter (3) minH = 0.1 * cam.get (4) enquanto True: ret, img = cam.read () img = cv2.flip (img, -1) # Flip verticalmente cinza = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale (cinza, scaleFactor = 1.2, minNeighbors = 5, minSize = (int (minW), int (minH)),) para (x, y, w, h) nas faces: cv2.retângulo (img, (x, y), (x + w, y + h), (0,255,0), 2) id, confiança = reconhecedor.prever (cinza [y: y + h, x: x + w]) # Verifique se a confiança é menor que 100 ==> "0" é uma correspondência perfeita se (confiança < 100): id = names[id] confidence = " 0%".format(round(100 - confidence)) else: id = "unknown" confidence = " 0%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print("\n [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() O programa funciona como um reconhecedor. A função Predict () pega diferentes partes da face capturada como parâmetros diferentes e retorna ao proprietário salvo enquanto mostra o id.
Se não reconhecer o rosto, aparecerá "desconhecido" na imagem.
Então, Voila!
Finalmente, Insights
Então, é assim que você faz um reconhecimento facial de Raspberry Pi. Certifique-se de seguir este artigo passo a passo para obter o melhor resultado! Agora, além deste classificador de reconhecimento de rosto, você também pode fazer reconhecimento de olhos ou sorriso usando diferentes classificadores e funções. Eu pesquisei todos os artigos relacionados na internet e descobri este. Então, eu realmente espero que este guia tenha ajudado você com os projetos. E espero que seja um sucesso para você. Não se esqueça de mencionar seus pensamentos na seção de comentários!
