Visão Computacional: análise facial

MediaPipe - Apresentação

Já pensou em criar uma aplicação de visão computacional analisando os pontos faciais?

Quer aprender como? Então, vamos aprender juntas(os)!!

Olá! Meu nome é Mirla Costa, sou instrutora da Alura.

Autodescrição: Eu sou uma mulher branca, de cabelos cacheados, pretos, na altura do ombro. Uso óculos de grau com armação redonda, uma blusa verde escura e, ao meu fundo, há uma parede verde.

Te acompanharei no curso de Visão Computacional. Neste treinamento, vamos desenvolver um detector de sonolência com Python, OpenCV e MediaPipe. Nós faremos essa detecção através de uma análise de coordenadas faciais de um vídeo de captura ao vivo do nosso rosto.

Para conseguir aproveitar bem esse conteúdo, recomendo que você tenha um bom conhecimento de Python e conhecimentos básicos da biblioteca NumPy e da biblioteca OpenCV. Então, vamos criar essa aplicação?

MediaPipe - Configurando o ambiente

Com a atuação da detecção de face, através da visão computacional, conseguimos identificar, prever e até prevenir algumas situações que podem prejudicar alguém. É exatamente sobre isso que discutiremos no nosso curso.

Nós fomos contratados como cientistas de dados por uma empresa que busca soluções inteligentes para motoristas de carro.

Sabemos que as pessoas podem ter cansaço, esgotamento físico e precisar de descanso. O problema é quando esse esgotamento físico acontece durante a condução de um veículo, por exemplo, quando alguém está dirigindo um carro.

Não é permitido, por lei, dirigir em estado de esgotamento físico. É necessário estar bem de saúde. Para evitar acidentes, nossa missão nesta empresa será:

Criar um algoritmo para detectar estado de sonolência em motoristas de carro.

No caso do nosso projeto, esse algoritmo servirá como um protótipo e depois poderá ser utilizado pela empresa em outros setores, onde será aprimorado e integrado com outras partes.

A ideia é ampliar o projeto de modo que seja usado por motoristas, usando a detecção de sonolência para evitar acidentes. Para isso, contaremos com alguns programas, o VSCode (Visual Studio Code) e o Anaconda. Se precisar instalá-los, recomendo que você retorne à atividade que antecede o vídeo. Nessa atividade, você encontrará as orientações necessárias para realizar as instalações.

Vamos começar abrindo o VSCode. Nele, já aparece a pasta "VISAO_COMPUTACIONAL", que é onde salvaremos o projeto.

Configurando o VSCOde

Nosso primeiro passo no VSCode é configurá-lo para iniciarmos o projeto. Para configurar o interpretador, vamos selecionar a opção "Ver" na barra superior do VSCode, seguida de "Paleta de Comandos". Também é possível acessar essa aplicação com o atalho "Ctrl + Shift + P".

Selecionada a paleta de comandos, aparecerá um campo de texto com algumas alternativas de seleção. Nós a preencheremos com o comando: "Python: Selecionar Interpretador".

No meu caso, ele aparece primeiro, porque utilizo bastante, mas, é muito simples pesquisá-lo. Basta escrever "selecionar interpretador" no campo. Ao selecionar essa opção, visualizaremos alguns tipos de interpretadores que podem ser escolhidos.

Nós precisaremos do Anaconda para utilizarmos o interpretador base do Anaconda. Esse interpretador fornecerá bibliotecas bases já instaladas, com foco em Data Science, por isso é vantajoso utilizá-lo.

Então, vamos selecionar "Python 3.9.12('base')". Temos o nosso interpretador configurado! Agora, criaremos um novo arquivo, que será o arquivo do nosso projeto, na pasta "VISAO_COMPUTACIONAL".

Para isso, pressionaremos o botão "Novo Arquivo". Aparecerá um campo, onde nomearemos esse arquivo. Vamos chamá-lo de "projeto.ipynb", porque ele será um notebook. Basta dar "Enter" e, pronto! O notebook foi criado no VSCode!

Instalando pacotes essenciais

Para terminar a configuração, vamos instalar três pacotes essenciais para o nosso projeto:

• OpenCV.

• Media Pipe.

• Numpy.

Vamos instalá-los juntas(os), assim evitamos incompatibilidades de versão. Então, na mesma célula, passaremos o pip install de todos os pacotes.

!pip install opencv-python==4.6.0.66
!pip install mediapipe==0.8.11
!pip install numpy==1.22.3

A primeira biblioteca que instalamos é a opencv-python. Para garantir que ela será instalada na mesma versão que a minha, basta escrever == seguido da versão 4.6.0.66 e apertar "Enter". Agora é só repetir o processo para a mediapipe e para a numpy.

Por fim, pressionamos "Shift + Enter" e esperamos a instalação. Com a instalação finalizada, podemos iniciar o projeto, pois o VSCode já estará configurado.

MediaPipe - Captura ao vivo

Para ajudarmos os motoristas da melhor forma possível, precisamos que o algoritmo detecte a sonolência em tempo real, para isso, o nosso algoritmo deve realizar a coleta e captura do rosto do motorista em tempo real também. Para isso, utilizamos o pacote do OpenCV.

OpenCV

O OpenCV é uma biblioteca multiplataforma desenvolvida pela Intel. Para importá-lo, passaremos o seguinte comando no VSCode:

import cv2

0.1s

Para realizar a captura ao vivo, precisamos ativar essa video-captura. Usaremos um método do OpenCV chamado VideoCapture.

cv2.VideoCapture()

Dentro dos parênteses, passaremos o número de referência à câmera que será utilizada na captura. Eu tenho duas câmeras: a que eu uso para gravar e a integrada ao computador, que estou utilizando na construção do programa. É essa segunda câmera que utilizarei no projeto. Se você tem apenas uma, deve usar o número zero.

Para uma câmera só: utilizar o número 0.

No meu caso, passarei o número 1, porque ele corresponde à câmera do computador. Já o zero, corresponde à câmera que estou usando para gravar.

cv2.VideoCapture(1)

Se você tiver mais câmeras, precisa colocar o número correspondente a elas. Agora, armazenaremos a saída dessa captura a uma variável, que chamaremos de cap (referente a "captura").

cap = cv2.VideoCapture(1)

Com isso, receberemos a primeira captura. Para que ela aconteça ao vivo, adicionaremos um laço de repetição: while.

cap = cv2.VideoCapture(1)

while

Sobre a condição para a repetição do while: enquanto a captura, cap, estiver aberta, acontecendo, o whilecontinuará rodando.

cap = cv2.VideoCapture(1)

while cap.isOpened():

Nossa primeira especificação será a leitura do vídeo que será feita a partir da câmera. Para isso, utilizaremos duas variáveis: sucesso e frame.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame

Variável sucesso

A variável sucesso verifica se os dados estão sendo coletados. Ela é boleana, significa que se identificar algum vídeo ou frame, retornará verdadeiro. Se não identificar nenhum vídeo, retornará falso.

Variável frame

O frame é a captura coletada pela câmera. Utilizaremos o método cap.read() para a leitura.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()

Em seguida, usaremos uma condicional, if, para verificar se existe ou não captura acontecendo.

Se não tivermos sucesso (lembrando que sucesso é um valor boleano), queremos a impressão de uma mensagem na tela: Ignorando o frame vazio da câmera. Essa mensagem é um aviso de que o frame está vazio, logo, nada está sendo lido no nosso projeto.

Enquanto sucesso estiver dizendo que não existe o frame, pediremos que ele continue e a execução volte para o começo.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue

Depois disso, saímos do bloco condicional e podemos visualizar a captura e conferir o que está acontecendo. Podemos contar com o método imshow para isso.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue
         cv2.imshow()

Dentro dos parênteses de cv2.imshow(), passaremos um nome para a nossa janela em formato de string: 'Camera'. Ainda nos parênteses, definiremos o que deve ser mostrado, o nosso próprio frame.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue
         cv2.imshow('Camera', frame)

Com isso, conseguiremos mostrar a imagem, mas não temos uma opção de controle para fechar a câmera em tempo real. Para isso, usaremos um condicional if. Ele vai parar o laço de repetição quando apertarmos teclas específicas. Como a intenção é fechar, podemos usar "C" de "Close".

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue
         cv2.imshow('Camera', frame)
         if cv2.waitKey(10) & 0xFF == ord('c'):
            break

A estrutura da nossa condicional, é: passamos um if, espaço, cv2.waitKey(10), que vai esperar uma chave e verificar se essa chave será o c. Para isso, passamos & 0xFF == ord('c') e, dentro dos parênteses, uma string, o "c" minúsculo, referente a "close" ou "fechar".

Com isso, estamos dizendo que, ao apertarmos a tecla c, é para "quebrar", break, o nosso laço de repetição e finalizar a captura de tela. Construímos um controle para o nosso laço, desta maneira, se quisermos, podemos fechar a amostragem de tela.

Para fechar definitivamente a captura, vamos liberar o objeto de captura com cap.release().

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue
         cv2.imshow('Camera', frame)
         if cv2.waitKey(10) & 0xFF == ord('c'):
            break
cap.release()

Também vamos destruir todas as janelas/pop-ups, pois o método imshow() vai abrir um pop-up, mostrando um frame. Então, na última linha, escreveremos cv2.destroyAllWindows(), sendo o "A" e o "W" escritos em letras maiúsculas.

cap = cv2.VideoCapture(1)

while cap.isOpened():
    sucesso, frame = cap.read()
         if not sucesso:
            print('Ignorando o frame vazio da câmera.')
                        continue
         cv2.imshow('Camera', frame)
         if cv2.waitKey(10) & 0xFF == ord('c'):
            break
cap.release()
cv2.destroyAllWindows()

Por fim, apertaremos "Shift + Enter". Basta aguardar um pouco e aparecerá a nossa captura de vídeo em tempo real. No meu caso, a imagem vem de uma câmera integrada ao computador que estou utilizando para essa aula.

Agora temos acesso ao nosso pop-up, resultado da visualização. O que está sendo capturado na câmera é exatamente o que está sendo mostrado na janela. Para finalizarmos essa visualização na janela, basta apertar "c". Pronto! Está finalizada a execução da captura ao vivo.

Aprendemos a fazer a captura ao vivo. Falta entender como detectar a face para identificar a sonolência.

Sobre o curso Visão Computacional: análise facial

O curso Visão Computacional: análise facial possui 164 minutos de vídeos, em um total de 45 atividades. Gostou? Conheça nossos outros cursos de Machine Learning em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• MediaPipe
• Mapeando os olhos
• Identificando a boca
• Detecção de sono