Reconhecimento de rosto com opencv

A complexidade das máquinas aumentou ao longo dos anos e os computadores não são uma exceção. Os computadores ajudaram a humanidade a resolver muitos problemas e concluir muitas tarefas difíceis. Longe vão os dias em que todos os computadores fizeram operações aritméticas simples, os computadores agora dirigem o mundo.

Os computadores se tornaram tão complexos que estão sendo treinados para pensar como humanos.
Sim!

Vamos fazer algo dessa natureza neste artigo. Como seres humanos, reconhecer os rostos de outras pessoas é uma tarefa simples e, apesar das habilidades dos computadores de hoje, não é tão fácil para o computador, por isso temos que treiná -lo para poder fazer o mesmo.

Muitos artigos que você veria por aí para parar na detecção de rosto simples, mas neste artigo cobriria não apenas a detecção de rosto, mas também o reconhecimento de rosto.

Isso significa que, se o computador for apresentado com duas fotos minhas, não apenas reconheceria que parte da imagem é o meu rosto, mas também reconheceria que eu sou eu a única nas duas fotos.

Para começar, teríamos que instalar primeiro o OpenCV em nossas máquinas, o que só pode ser feito se você tiver o Python instalado. A instalação do Python não é o objetivo deste artigo; portanto, se você ainda não o possui em sua máquina, poderá instalar o Python no site do Python.

Para instalar o CV aberto, podemos fazer isso usando o comando pip.

Instalação do PIP OpenCV-Python

Também estaremos usando o pacote Numpy neste artigo, que deve ser instalado ao lado do OpenCV usando o comando acima.

Se Numpy não foi instalado, você pode fazê -lo facilmente usando o comando abaixo:

pip install numpy

Para confirmar que seu OpenCV está instalado, quando você ativa o ambiente interativo do Python, tente importá -lo usando:

importar CV2

Se não receber um erro, você pode prosseguir.

Para realizar o reconhecimento facial, estaríamos escrevendo três scripts. Um para criar um conjunto de dados de imagens, outro para treinar essas imagens e depois o último a reconhecer os rostos com base nos resultados do treinamento pelo qual o computador passa.

Estaríamos precisando da cascata Haar fornecida pelo Open CV. Este arquivo pode ser obtido no diretório OpenCV, que é CV2/Data/Haarcascade_frontalface_default.XML na minha máquina, também deve ser o mesmo em sua máquina. Copie o arquivo na pasta onde deseja fazer o reconhecimento de rosto.

Agora vamos entrar no meio das coisas.
Tentávamos fazer com que nossa web cam obtenha as fotos, necessárias para o conjunto de dados.

importar CV2
vid_cam = cv2.Videocapture (0)
FACE_DETECTOR = CV2.CascadeClassifier ('Haarcascade_frontalface_default.xml ')
face_id = 1
contagem = 0
while (vid_cam.está aberto()):
ret, imagem_frame = vid_cam.ler()
cinza = cv2.cvtcolor (image_frame, cv2.Color_bgr2gray)
FACES = FACE_DETECTOR.DetectMultiscale (Gray, 1.3, 5)
para (x, y, w, h) em rostos:
cv2.retângulo (image_frame, (x, y), (x+w, y+h), (255,0,0), 2)
contagem += 1
cv2.Imwrite ("DataSet/Usuário." + str (face_id) + '.' + str (contagem) + ".jpg ", cinza [y: y+h, x: x+w])
cv2.imshow ('quadro', image_frame)
se cv2.WaitKey (100) e 0xff == ord ('q'):
quebrar
Elif contagem> 100:
quebrar
vid_cam.liberar()
cv2.DestroyAllWindows ()

Então, para explicar o que cada linha de código faz:

importar CV2

Aqui está o comando que diz a Python para incluir uma biblioteca externa a ser usada neste código; neste caso, está aberto CV.

vid_cam = cv2.Videocapture (0)

Este código chama a biblioteca CV aberta importada para começar a capturar e a webcam é iniciada neste momento. Se o CV aberto não suportar sua webcam, o código falhará aqui.

FACE_DETECTOR = CV2.CascadeClassifier ('Haarcascade_frontalface_default.xml ')

Para que possamos realizar a detecção de imagem, esse código é necessário. Open CV usa o 'haarcascade_frontalface_default.xml 'para classificação em cascata. O objeto resultante é então armazenado na variável FACE_DETECTOR.

face_id = 1

Aqui está um caso de definir o número de identificação do rosto, então o primeiro rosto recebe um ID de 1.

contagem = 0

Vamos tirar algumas imagens, pois o CV aberto precisa treinar imagens para poder reconhecer rostos, a variável de contagem serve como uma contagem de imagens.

while (vid_cam.está aberto()):

Isso permite que as seguintes operações prossiga desde que a câmera de vídeo seja aberta. O método isopened () retorna verdadeiro ou falso.

ret, imagem_frame = vid_cam.ler()

Aqui, o vid_cam.Leia () analisa a captura de vídeo e depois captura o quadro que é armazenado na variável image_frame, se a operação for bem -sucedida, o booleano true será retornado e armazenado na variável RET

cinza = cv2.cvtcolor (image_frame, cv2.Color_bgr2gray)

O método cvtcolor () é usado para converter o quadro da imagem no tipo de cor desejado. Nesse caso, convertemos em escala de cinza.

FACES = FACE_DETECTOR.DetectMultiscale (Gray, 1.3, 5)

Isso verifica os quadros de tamanhos diferentes e tenta defini -los para escalar, é aplicado na variável à qual a cascata de Haar foi aplicada.

para (x, y, w, h) em rostos:

Aqui, percorremos os rostos e suas dimensões, onde X e Y representam as coordenadas e W e H representam largura e altura, respectivamente.

cv2.retângulo (image_frame, (x, y), (x+w, y+h), (255,0,0), 2)

Lembre -se de que ainda estamos trabalhando com a câmera de vídeo, a câmera de vídeo e depois a necessidade da imagem de acordo com as dimensões acima.

contagem += 1

Imediatamente isso é feito, a variável de contagem que permanece como um contador e depois incrementos.

cv2.Imwrite ("DataSet/Usuário." + str (face_id) + '.' + str (contagem) + ".jpg ", cinza [y: y+h, x: x+w])

A imagem cortada é a salva com o nome de usuário (face_id).(contar).JPG e coloque em uma pasta chamada conjunto de dados.

cv2.imshow ('quadro', image_frame)

Após o salvamento, esse código garante que a imagem seja exibida com um retângulo no rosto do indivíduo após a detecção de face.

se cv2.WaitKey (100) e 0xff == ord ('q'):
quebrar

Após a foto, o usuário pode impedir que o programa tire mais fotos, o que pode ser feito pressionando o 'q' no teclado para pelo menos 100ms.

Elif contagem> 100:
quebrar

O que esse código faz é impedir que o vídeo funcione no momento 100 fotos foram tiradas, independentemente de o usuário querer levar mais ou não.

vid_cam.liberar()

Aqui, a web cam está fechada e não apenas impediu de tirar fotos.

cv2.DestroyAllWindows ()

Então todo o Windows OpenEncv foi aberto e o código é concedido para a conclusão.

Agora que terminamos com isso, podemos treinar o conjunto de dados da imagem:

importar CV2, OS
importar numpy como np
da imagem de importação do PIL
Reconhecimento = CV2.face.CreateLbPhfaceRecognizer ()
Detector = CV2.Cascadeclassifier ("Haarcascade_frontalface_default.xml ");
def getImagesandlabels (caminho):
ImagePaths = [OS.caminho.Junte -se (Path, F) para F em OS.ListDir (Path)]
Facesamples = []
ids = []
Para o ImagePath em ImagePaths:
Pil_img = imagem.Open (ImagePath).converter ('l')
img_numpy = np.Array (pil_img, 'uint8')
id = int (OS.caminho.Split (ImagePath) [-1].dividir(".") [1])
FACES = Detector.DetectMultiscale (img_numpy)
para (x, y, w, h) em rostos:
Facesamples.Anexe (img_numpy [y: y+h, x: x+w])
ids.Anexar (ID)
Retornar as amostras de faces, IDs
rostos, ids = getImagesandlabels ('conjunto de dados')
Reconhecedor.Trem (rostos, NP.Array (IDS))
Reconhecedor.salvar ('treinador/treinador.yml ')

Vamos em frente e explicar este código também:

importar CV2, OS

Assim como o outro código, aqui estamos importando o OpenCV e OS, que precisaríamos para o caminho do arquivo.

importar numpy como np

Também estamos importando a biblioteca Numpy, que seria usada para o cálculo da matriz (uma matriz é apenas um arranjo de matrizes).

da imagem de importação do PIL

Estamos importando a biblioteca de imagens Python e depois também estamos recebendo a biblioteca de imagens deste pacote.

Reconhecimento = CV2.face.CreateLbPhfaceRecognizer ()

O que isso faz é aplicar o método CreateLBPhfaceRecognizer () ao CV2.Face Object, isso ajudaria a facilitar o reconhecimento de rostos, pois não precisamos criar nosso próprio conjunto de algoritmos.

Detector = CV2.Cascadeclassifier ("Haarcascade_frontalface_default.xml ");

Se você seguiu o tutorial, você já se depararia antes. Ajuda na detecção de rosto usando o “Haarcascade_frontalface_default.XML ”para a classificação em cascata.

def getImagesandlabels (caminho):

Agora, estamos prestes a começar o treinamento de imagem adequado, por isso criamos uma função.

ImagePaths = [OS.caminho.Junte -se (Path, F) para F em OS.ListDir (Path)]

Este código verifica no diretório atual do arquivo e verifica os arquivos da imagem e depois os adiciona a esta lista.

Facesamples = []

Isso inicializa uma lista de amostras, está vazia neste momento, mas as faces serão adicionadas à medida que o código é executado.

ids = []

Inicialize uma lista de IDs, que está inicialmente vazio.

Para o ImagePath em ImagePaths:

Lembre -se do código que verificou os arquivos de imagem no diretório? Sim? Agora, vamos percorrer cada um desses arquivos e realizar operações.

Pil_img = imagem.Open (ImagePath).converter ('l')

Agora, a primeira coisa que fazemos com a imagem é convertê -la em escala de cinza, e este código faz isso.

img_numpy = np.Array (pil_img, 'uint8')

A imagem em cinza é apenas uma série de números, tudo em um só lugar, por isso criamos uma matriz numpy a partir deles e a designamos a uma variável.

id = int (OS.caminho.Split (ImagePath) [-1].dividir(".") [1])

Se você se lembra do arquivo que recebe as imagens, lembraria que nomeamos o usuário do arquivo (FACE_ID).contar.jpg. Então aqui estamos dividindo os nomes com o “.”E então extraímos o FACE_ID e atribuímos a uma variável aqui. Precisaríamos do ID para reconhecimento.

FACES = Detector.DetectMultiscale (img_numpy)

Da matriz Numpy, o método DetectMultisCale () tentará detectar as faces do padrão encontrado na matriz Numpy. Em seguida, atribui os valores na variável faces.

para (x, y, w, h) em rostos:

Aqui, estamos percorrendo os valores atribuídos à variável. Os valores aqui são as coordenadas X e Y que poderíamos tomar como origem e, em seguida.

Facesamples.Anexe (img_numpy [y: y+h, x: x+w])

Antes, criamos uma lista de amostras de rosto, mas estava vazio. Aqui podemos adicionar rostos a essa lista, e estamos adicionando o y a h para obter os dois valores das coordenadas y e o mesmo é feito para x.

ids.Anexar (ID)

Agora temos um rosto na lista de amostras de rosto, então obtemos seu ID e o anexamos à lista de IDs também.

Retornar as amostras de faces, IDs

Depois de tudo, retornamos a lista de amostras de rosto e a lista de IDs.

rostos, ids = getImagesandlabels ('conjunto de dados')

Lembre -se de que getImagesAndlabels () é apenas uma função. Então, podemos chamar a função aqui, e os valores de retorno são salvos nas variáveis ​​de faces e IDs.

Reconhecedor.Trem (rostos, NP.Array (IDS))

Aqui é onde acontece o treinamento real. Aplicamos o método CreateLBPhFaceRecognizer () algum tempo antes e atribuído a uma variável de reconhecimento. É hora de treinamento!

Reconhecedor.salvar ('treinador/treinador.yml ')

Após o treinamento, economizamos os resultados do treinamento.
Depois de executar o código, ele cria um arquivo chamado treinador.YML, que seria então usado pelo código de reconhecimento de rosto.

Aqui está o código de reconhecimento de rosto:

importar CV2
importar numpy como np
Reconhecimento = CV2.face.CreateLbPhfaceRecognizer ()
Reconhecedor.carregamento ('treinador/treinador.yml ')
cascadepath = "Haarcascade_frontalface_default.xml "
facecasCade = cv2.CascadeClassifier (Cascadepath)
Fonte = CV2.FONT_HERSHEY_SIMPLEX
CAM = CV2.Videocapture (0)
enquanto é verdade:
ret, im = cam.ler()
cinza = cv2.cvtcolor (IM, CV2.Color_bgr2gray)
FACES = FACECASCADE.DetectMultiscale (Gray, 1.2,5)
para (x, y, w, h) em rostos:
cv2.retângulo (im, (x-20, y-20), (x+w+20, y+h+20), (0,255,0), 4)
Id = reconhecedor.prever (cinza [y: y+h, x: x+w])
if (id == 1):
Id = "nazmi"
outro:
Id = "desconhecido"
cv2.retângulo (im, (x-22, y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.puttext (im, str (id), (x, y-40), fonte, 2, (255.255.255), 3)
cv2.imshow ('im', im)
se cv2.WaitKey (10) e 0xff == ord ('q'):
quebrar
Cam.liberar()
cv2.DestroyAllWindows ()

Se você está acompanhando o artigo desde o início, já fizemos isso antes. Se você não faz gentilmente.

Reconhecedor.carregamento ('treinador/treinador.yml ')

Lembre -se de que treinamos o reconhecedor e salvamos um arquivo? Sim? Estamos carregando esse arquivo agora.

cascadepath = "Haarcascade_frontalface_default.xml "

Estaríamos trabalhando com o arquivo HaarcaScade, e aqui atribuímos o nome do arquivo a uma variável.

# Crie classificador a partir do modelo pré -construído
facecasCade = cv2.CascadeClassifier (Cascadepath)

Aqui podemos realizar a classificação em cascata no arquivo Haarcascade.

Fonte = CV2.FONT_HERSHEY_SIMPLEX

Definimos o tipo de fonte que seria usado quando o código reconhecer o rosto em uma imagem e exibir o nome.

CAM = CV2.Videocapture (0)

Já estivemos aqui antes, mas desta vez é hora de reconhecer os rostos. Se você não souber o que esse código faz, ele inicia a webcam.

enquanto é verdade:
ret, im = cam.ler()
cinza = cv2.cvtcolor (IM, CV2.Color_bgr2gray)
FACES = FACECASCADE.DetectMultiscale (Gray, 1.2,5)
para (x, y, w, h) em rostos:

Tudo isso já foi feito antes, verifique o código que foi usado para salvar imagens se você não souber o que o código faz.

cv2.retângulo (im, (x-20, y-20), (x+w+20, y+h+20), (0,255,0), 4)

Portanto, isso ajuda a webcam a detectar onde estão os rostos e coloca um retângulo para indicar um rosto.

Id = reconhecedor.prever (cinza [y: y+h, x: x+w])

Alrerady carregamos o arquivo de trem no reconhecedor, para que seja capaz de reconhecer o rosto agora.

if (id == 1):
Id = "eu mesmo"
outro:
Id = "desconhecido"

Depois de tentar reconhecer o que é a cara, ele verifica o ID e vê se existe. Aqui, o valor do ID seria o nome de quem era de propriedade de esse ID quando o conjunto de dados da imagem estava sendo criado.

cv2.retângulo (im, (x-22, y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.puttext (im, str (id), (x, y-40), fonte, 2, (255.255.255), 3)

O código depois de encontrar o proprietário do ID, atrai um retângulo em volta do rosto e coloca o nome do proprietário do rosto. Rosto reconhecido!

cv2.imshow ('im', im)

Aqui, o quadro de vídeo é exibido com o retângulo limitado.

se cv2.WaitKey (10) e 0xff == ord ('q'):
quebrar
Cam.liberar()
cv2.DestroyAllWindows ()

Então, quando terminar, você pode parar o programa pressionando a tecla 'q' e interrompe a webcam e a fecha.

Lá está você, sua webcam agora pode reconhecer rostos e você pode usá -lo sempre que desejar. Além disso, usando a webcam, você também pode carregar uma imagem, no entanto, isso requer outras etapas além daquelas que foram tomadas neste artigo.