Detecção de faces com Python usando OpenCV

Introdução aos classificadores Haar Cascade

Esse método foi apresentado pela primeira vez no artigo Rapid Object Detection Using a Boosted Cascade of Simple Features, escrito por Paul Viola e Michael Jones.

A ideia por trás dessa técnica envolve o uso de uma cascata de classificadores para detectar diferentes recursos em uma imagem. Esses classificadores são então combinados em um classificador forte que pode distinguir com precisão entre amostras que contêm um rosto humano e aquelas que não contêm.

O classificador Haar Cascade incorporado ao OpenCV já foi treinado em um grande conjunto de dados de rostos humanos, portanto, não é necessário treinamento adicional. Você só precisa carregar o classificador da biblioteca e usá-lo para fazer a detecção de faces em uma imagem de entrada.

Instalação do OpenCV para Python

Para instalar a biblioteca OpenCV, basta abrir o prompt de comando ou a janela do terminal e executar o seguinte comando:

pip install opencv-python

Esse comando só funcionará se você já tiver o pip instalado em seu dispositivo. Se quiser saber mais sobre o gerenciador de pacotes pip, você pode ler nosso Tutorial do PIP Python.

OpenCV para detecção de faces em imagens

Criaremos um detector para identificar o rosto humano em uma foto do Unsplash. Certifique-se de salvar a imagem no diretório de trabalho e renomeá-la para input_image antes de continuar a codificação.

Etapa 1: Importar o pacote OpenCV

Agora, vamos importar o OpenCV e inserir o caminho da imagem de entrada com as seguintes linhas de código:

import cv2

imagePath = 'input_image.jpg'

Etapa 2: Leia a imagem

Em seguida, precisamos ler a imagem com a função imread() do OpenCV:

img = cv2.imread(imagePath)

Isso carregará a imagem do caminho do arquivo especificado e a retornará na forma de uma matriz Numpy. 

Vamos imprimir as dimensões dessa matriz:

img.shape

(4000, 2667, 3)

Observe que essa é uma matriz tridimensional. Os valores da matriz representam a altura, a largura e os canais da imagem, respectivamente. Como essa é uma imagem colorida, há três canais usados para representá-la: azul, verde e vermelho (BGR). 

Observe que, embora a sequência convencional usada para representar imagens seja RGB (vermelho, azul, verde), a biblioteca OpenCV usa o layout oposto (azul, verde, vermelho).

Etapa 3: Converter a imagem em tons de cinza

Para aumentar a eficiência computacional, primeiro precisamos converter essa imagem em escala de cinza antes de executar a detecção de faces nela:

gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Agora vamos examinar as dimensões dessa imagem em escala de cinza:

gray_image.shape

(4000, 2667)

Observe que essa matriz tem apenas dois valores, pois a imagem está em escala de cinza e não tem mais o terceiro canal de cor.

Etapa 4: Carregar o classificador

Vamos carregar o classificador Haar Cascade pré-treinado que está integrado ao OpenCV:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Observe que estamos usando um arquivo chamado haarcascade_frontalface_default.xml. Esse classificador foi projetado especificamente para detectar faces frontais na entrada visual. 

O OpenCV também oferece outros modelos pré-treinados para detectar diferentes objetos em uma imagem, como os olhos, o sorriso, a parte superior do corpo de uma pessoa e até mesmo a placa de um veículo. Você pode saber mais sobre os diferentes classificadores incorporados ao OpenCV examinando o repositório GitHub da biblioteca.

Etapa 5: Executar a detecção de face

Agora podemos fazer a detecção de rostos na imagem em escala de cinza usando o classificador que acabamos de carregar:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)

Vamos detalhar os métodos e parâmetros especificados no código acima:

1. detectMultiScale():

O método detectMultiScale() é usado para identificar rostos de tamanhos diferentes na imagem de entrada.

1. grey_image:

O primeiro parâmetro desse método é chamado grey_image, que é a imagem em escala de cinza que criamos anteriormente.

1. scaleFactor:

Esse parâmetro é usado para reduzir o tamanho da imagem de entrada para facilitar a detecção de rostos maiores pelo algoritmo. Nesse caso, especificamos um fator de escala de 1,1, indicando que queremos reduzir o tamanho da imagem em 10%.

1. minNeighbors:

O classificador em cascata aplica uma janela deslizante na imagem para detectar rostos nela. Você pode pensar nessas janelas como retângulos. 

Inicialmente, o classificador capturará um grande número de falsos positivos. Eles são eliminados usando o parâmetro minNeighbors, que especifica o número de retângulos vizinhos que precisam ser identificados para que um objeto seja considerado uma detecção válida.

Para resumir, passar um valor pequeno, como 0 ou 1, para esse parâmetro resultaria em um número alto de falsos positivos, enquanto um número grande poderia fazer com que você perdesse muitos positivos verdadeiros.

O truque aqui é encontrar uma compensação que nos permita eliminar os falsos positivos e, ao mesmo tempo, identificar com precisão os verdadeiros positivos.

1. minSize:

Por fim, o parâmetro minSize define o tamanho mínimo do objeto a ser detectado. O modelo ignorará as faces que forem menores do que o tamanho mínimo especificado.

Etapa 6: Desenho de uma caixa delimitadora

Agora que o modelo detectou os rostos dentro da imagem, vamos executar as seguintes linhas de código para criar uma caixa delimitadora em torno desses rostos:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)

A variável face é uma matriz com quatro valores: os eixos x e y nos quais as faces foram detectadas e sua largura e altura. O código acima itera sobre as faces identificadas e cria uma caixa delimitadora que abrange essas medidas.

O parâmetro 0,255,0 representa a cor da caixa delimitadora, que é verde, e 4 indica sua espessura.

Etapa 7: Exibindo a imagem

Para exibir a imagem com os rostos detectados, primeiro precisamos converter a imagem do formato BGR para RGB:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Agora, vamos usar a biblioteca Matplotlib para exibir a imagem:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')

O código acima deve gerar o seguinte resultado: 

Ótimo!

O modelo detectou com sucesso o rosto humano nessa imagem e criou uma caixa delimitadora em torno dele. 

Detecção de faces em tempo real com OpenCV

Agora que realizamos com sucesso a detecção de faces em uma imagem estática com o OpenCV, vamos ver como fazer o mesmo em uma transmissão de vídeo ao vivo. 

Etapa 1: Pré-requisitos

Primeiro, vamos importar a biblioteca OpenCV e carregar o modelo Haar Cascade, como fizemos na seção anterior. Você pode ignorar esse bloco de código se já o tiver executado anteriormente:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Etapa 2: Acesse a webcam

Agora, precisamos acessar a câmera do nosso dispositivo para ler uma transmissão ao vivo de dados de vídeo. Isso pode ser feito com o seguinte código:

video_capture = cv2.VideoCapture(0)

Observe que passamos o parâmetro 0 para a função VideoCapture(). Isso diz ao OpenCV para usar a câmera padrão do nosso dispositivo. Se você tiver várias câmeras conectadas ao seu dispositivo, poderá alterar o valor desse parâmetro de acordo.

Etapa 3: Identificação de rostos no fluxo de vídeo

Agora, vamos criar uma função para detectar faces no fluxo de vídeo e desenhar uma caixa delimitadora ao redor delas:

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return faces

A função detect_bounding_box usa o quadro de vídeo como entrada.

Nessa função, estamos usando os mesmos códigos que usamos anteriormente para converter o quadro em escala de cinza antes de realizar a detecção de rosto.

Em seguida, também estamos detectando o rosto nessa imagem usando os mesmos valores de parâmetro para scaleFactor, minNeighbors e minSize que fizemos anteriormente.

Por fim, desenhamos uma caixa delimitadora verde de espessura 4 ao redor do quadro.

Etapa 4: Criação de um loop para detecção de faces em tempo real

Agora, precisamos criar um loop while indefinido que capturará o quadro de vídeo da nossa webcam e aplicará a função de detecção de rosto a ele:

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()

Depois de executar o código acima, você verá uma janela chamada My Face Detection Project aparecer na tela:

O algoritmo deve rastrear seu rosto e criar uma caixa delimitadora verde ao redor dele, independentemente de onde você se mova dentro do quadro.

No quadro acima, a modelo reconhece meu rosto e minha foto na carteira de motorista que estou segurando.

Você também pode testar a eficácia desse modelo segurando várias fotos ou fazendo com que diferentes pessoas fiquem em vários ângulos atrás da câmera. O modelo deve ser capaz de identificar todos os rostos humanos em diferentes fundos ou configurações de iluminação.

Se quiser sair do programa, você pode pressionar a tecla "q" no teclado para sair do loop.

Detecção de faces com OpenCV - Próximas etapas

Agora que você aprendeu a detectar com sucesso rostos humanos em imagens e vídeos em tempo real usando a biblioteca OpenCV, aqui estão algumas etapas que você pode seguir para elevar seu conhecimento ao próximo nível:

Crie seu próprio projeto

Você pode usar o código fornecido neste tutorial como ponto de partida para seu próprio projeto de detecção de faces.

Uma maneira de expandir esse projeto é identificar rostos humanos em diferentes tipos de dados de entrada, como arquivos PDF ou imagens de vigilância. Você pode até mesmo configurar sua própria câmera de segurança e realizar a detecção de rostos nos dados capturados em tempo real.

Além disso, você pode criar um modelo de detecção de faces em grandes conjuntos de dados ou ir além e executar tarefas como detectar se uma pessoa está usando máscaras em conjuntos de dados de imagens.

Os conjuntos de dados Face Detection in Images e Face Mask Detection no Kaggle são bons pontos de partida para um projeto de portfólio nessa área.

Criar um modelo de reconhecimento facial

Enquanto a detecção de face é usada para detectar um rosto humano em uma entrada visual, o reconhecimento facial vai um pouco além. Essa tecnologia é usada para verificar a identidade de uma pessoa, comparando seu rosto com um banco de dados existente.

Você pode tentar criar um modelo de reconhecimento facial que identifique um rosto específico (talvez até o seu) em meio a uma multidão de outras pessoas. 

Essa tarefa será um pouco mais desafiadora do que a detecção de faces, pois o modelo deve ser treinado em muitas amostras de dados antes de poder distinguir as pessoas.

Antes de criar um modelo de reconhecimento facial, talvez você também precise executar técnicas de pré-processamento, como redução de ruído e transformação de imagens. 

Se esses conceitos parecerem estranhos para você, não se preocupe! Você pode aprender tudo sobre processamento de imagens fazendo nosso curso Processamento de imagens em Python.

Obter experiência no domínio

O processamento de imagens e vídeos tem aplicações em uma ampla gama de setores, incluindo segurança, varejo, saúde e manufatura.

Se você deseja conseguir um emprego como especialista em visão computacional, primeiro precisa entender os tipos de dados usados nesses setores. A experiência no domínio tornará mais fácil para você rotular, transformar e treinar conjuntos de dados em cenários do mundo real.

Para começar, você pode fazer nosso curso Biomedical Image Analysis in Python. Este programa ensinará a você como processar imagens de tomografia computadorizada, segmentar uma série temporal de ressonância magnética cardíaca e determinar se a doença de Alzheimer altera a estrutura do cérebro. 

Esses conceitos equiparão você com as habilidades necessárias para entrar no campo da imagem biomédica.