Neste vídeo, apresento os resultados obtidos no experimento de detecção e contagem de piscadas com a webcam.

Para realizar este experimento, foi necessário coletar o contorno dos olhos através da detecção de pontos faciais do rosto e criar um pequeno controlador que verifica a proporção do olho aberto e fechado.  Este controlador verifica se o olho foi fechado e depois verifica se o olho voltou a estar aberto, ao realizar finalizar este processo contabiliza uma piscada.

A coleta dos pontos faciais foi realizada com a biblioteca OpenCV e Dlib, que por padrão informa 6 referências para cada olho. Os posts “Detecção de pontos faciais com OpenCV” e “Detecção de pontos faciais com Dlib“, detalham melhor esta coleta.

A proporção de olho aberto é calculada apenas dividindo a altura do olho pela largura do olho, conforme ilustrado na Fig 1. abaixo.

Caso você esteja se perguntando, “mas por que ele não utiliza apenas a informação da altura olho?”. Na imagem abaixo (Fig 2.) espero responder esta pergunta. Note, nesta imagem, que existem diversos tamanhos de olhos, se for considerado apenas a altura do olho aberto, para saber se o olho está fechando ou não, o controlador irá identificar piscadas apenas com um único tamanho de imagem de olho, e não para qualquer tamanho de olho encontrado.

Para calcular a largura do olho, basta calcular a distância euclidiana entre os pontos da lateral esquerda e lateral direita do olho. A Fig 3. ilustra o cálculo da distância euclidiana.

E para calcular a altura dos olhos é preciso coletar o centro da parte superior e o centro da parte inferior do olho. O centro da parte superior é obtido somando os X e Y das posições 38 e 39 do olho e dividindo por 2, conforme Fig 1. E o centro da parte inferior é obtido da mesma forma, porém utilizando as posições 42 e 41. A Fig 4. ilustra todo o cálculo realizado para calcular a proporção do olho e a condicional para verificar se o olho está aberto e fechado.

Todo o código fonte do projeto está disponível para replicação do experimento no link abaixo. Caso tenham dúvidas e sugestões de melhorias no post, deixe seu comentário abaixo.

Source:
https://github.com/visaocomputacionalexemplos/experimentos_faciais/tree/main/identificar_piscada

The post Experimento – Detecção de piscadas e contador de piscadas com OpenCV e Dlib appeared first on Visão Computacional.

Neste post, é apresentado como realizar a detecção de pontos faciais com o algoritmo de Kazemi, implementado na biblioteca Dlib utilizando Shape Predictor. Na primeira parte deste tutorial, é apresentado o conceito de shape predictor (preditor de forma/ponto de referência) e como ele pode se usado para prever localizações específicas em objetos estruturais.

Este conteúdo é continuação do post Detecção de pontos faciais (Facemark) com OpenCV, recomendo a leitura dele primeiro, para melhor entender os conceitos básicos aqui apresentados.

Revisão de Conteúdo

Caso você não queira ler o post anterior, segue uma rápida revisão do conteúdo.

Os pontos faciais, em visão computacional, como o próprio nome diz, são pequenas regiões faciais identificadas por uma numeração, conforme ilustra a Fig 1.. Estas regiões, são identificadas por um ponto e uma numeração que pode variar de técnica para técnica utilizada.

Para realizar a detecção de pontos faciais, são necessárias as seguintes etapas antecessoras à coleta dos pontos na imagem: (1) identificar os rostos na imagem; (2) rotacionar o rosto caso necessário e (3) identificar os pontos faciais A Fig 2. Ilustra estas etapas..

Algoritmo Shape Predictor de Kazemi

“Shape Predictor” são utilizados para localizar coordenadas (x, y) específicas a partir de uma forma de entrada. O termo “Shape” é arbitrário, mas presume-se que a forma seja de natureza estrutural, como: rostos; mãos; dedos; etc [R].

Por exemplo, os rostos têm formas e tamanhos diversos, e todos eles compartilham características estruturais comuns: os olhos estão acima do nariz, o nariz está acima da boca, etc. O objetivo dos preditores de forma/ponto de referência, é explorar esse conhecimento estrutural e, com dados de treinamento suficientes, aprender como prever automaticamente a localização dessas estruturas [R].

Existem vários algoritmos preditores de forma. O algoritmo do preditor de forma implementado na biblioteca Dlib vem do artigo CVPR de Kazemi e Sullivan de 2014, One Millisecond Face Alignment with an Ensemble of Regression Trees  [KJ1].

Código e Experimentos

A seguir, são apresentados partes do código criado para realizar os experimentos de detecção de pontos faciais. Caso queira replicar estes experimentos, basta baixar o código fonte disponível no github (link na seção “Source” no final deste post).

Neste primeiro bloco, são inicializados todos os detectores do sistema, o detector facial e o detector de pontos faciais. Para iniciar todos estes detectores é muito simples, basta instanciar a classe dlib::frontal_face_detector, instanciar a classe dlib::shape_predictor e carregar o modelo treinado para a classe shape_predictor.

...
#include < dlib/image_processing/frontal_face_detector.h >
#include < dlib/image_processing.h >
dlib::frontal_face_detector detector;
dlib::shape_predictor shapePredictor;

main() {
...
    // Inicia Detector faciauk
    detector = dlib::get_frontal_face_detector();
    //Carrega o modelo treinado do shape predictor
    iniciarDetectorPontosFacialSP(shapePredictor);
...
}
void iniciarDetectorPontosFacialSP(dlib::shape_predictor &sp)
{
    dlib::deserialize("../../extra/shape_predictor_68_face_landmarks.dat") >> sp;
}

Para carregar o modelo de dados com Dlib, basta utilizar a função de dlib::deserialize e informar o caminho do arquivo. Esta função carrega o modelo treinado e transfere os dados carregados para a classe de predição com o operador “>>”  conforme trecho de código “>> sp”.

Com os detectores/preditores carregados, agora precisamos carregar a imagem com os rostos a serem detectados. Neste experimento, utilizamos a webcam para este fim e para carregar as imagens da webcam, utilizamos a biblioteca OpenCV, que é de fácil instalação.

Para capturar a câmera do vídeo com o OpenCV, basta instanciar a classe “cv::VideoCapturecap” e coletar a imagem do vídeo com o operador “>>” conforme trecho de código “cap>>img”.

main() {
  ...
  //Inicia captura dos vídeos
  cv::VideoCapturecap cap(0);
  if (!cap.isOpened()) {
    std::cout<<"Video Capture Fail"<<std::endl; return1; } cv::Mat img; cap>>img;
    return 1;
  }
  //Calcula nova dimensão da imagem para 320 pixels
  auto showSize = cv::Size(320, ((float)320 / img.cols) * img.rows);
  for (;;)
  {
    //Coleta a imagem da camera
    cap>>img;
    //Reescala a imagem para uma largura de 320 pixels
    cv::resize(img, img, showSize, 0, 0, cv::INTER_LINEAR_EXACT);
    coletarPontosFaciais(img);

    cv::imshow("Origem", img);
    cv::waitKey(5);
  }
}

Por fim, no último trecho de código, é apresentado como coletar os pontos faciais com o OpenCV.

dlib::image_window win, win_faces;
std::vector< dlib::rectangle > rostosDetectados;
void coletarPontosFaciais(const dlib::array2d& imagemOriginal)
{
    //Detecta os pontos faciais e retorna a lista de rostos detectados
    rostosDetectados = detector(imagemOriginal);
    //Percorre os rostos detectados e coloca os pontos faciais
    std::vector< dlib::full_object_detection > pontosFaciais;
    for (unsigned long j = 0; j < rostosDetectados.size(); ++j)
    {
        //Coleta os pontos faciais de um único rosto
        dlib::full_object_detection shape = shapePredictor(imagemOriginal, rostosDetectados[j]);
        pontosFaciais.push_back(shape);
    }
    // Exibe a imagem com o contorno dos pontos.
    win.clear_overlay();
    win.set_image(imagemOriginal);
    win.add_overlay(render_face_detections(pontosFaciais));
    // Recorta o rosto da imagem original e a exibe.
    dlib::array rostosRecortados;
    extract_image_chips(imagemOriginal, get_face_chip_details(pontosFaciais), rostosRecortados);
    win_faces.set_image(tile_images(rostosRecortados));
}

Observe que para detectar os rostos faciais com a classe dlib::frontal_face_detector, basta utilizar a variável detector como fosse uma função, passando a imagem como parâmetro. Ao utilizar o detector como função, serão detectados os rostos e retorna uma lista de retângulos com sua localização.

Com os rostos detectados, basta percorrer cada região dos rostos e chamar a função do shapePredictor, para coletar os pontos faciais. Esta função retorna uma lista com todos pontos localizados.

A classe dlib::image_window é utilizada para criar uma janela para exibição das imagens. A função render_face_detections é disponibilizada pela própria Dlib a fim de demarcar as regiões do rosto na imagem. E as funções extract_image_chips e get_face_chip_details recortam o rosto a partir dos pontos faciais. Como resultado deste projeto, foi realizado o experimento ilustrado pela Fig 3. 

Espero que esse conteúdo os ajudem na tarefa de identificação de pontos faciais. 
Caso tenham dúvidas e sugestões de melhorias no post, deixe seu comentário abaixo.

Source:

https://github.com/visaocomputacionalexemplos/experimentos_faciais/tree/main/detectar_pontos_faciais_dlib

Referencias:

Huber, Patrik. (2018). Real-time 3D morphable shape model fitting to monocular in-the-wild videos.

[R] Rosebrock, A, Training a custom dlib shape predictor, 2019, acessado em: 18/10/2101

[KJ1] V. Kazemi and J. Sullivan, “One millisecond face alignment with an ensemble of regression trees,” 2014 IEEE Conference on Computer Vision and Pattern Recognition, 2014, pp. 1867-1874, doi: 10.1109/CVPR.2014.241.

The post Detecção de pontos faciais (Facemark) com Dlib appeared first on Visão Computacional.

Neste tutorial, irei apresentar como detectar pontos faciais, quais as regiões importantes a serem utilizadas na detecção e apresentar resultados de experimentos realizados com as bibliotecas OpenCV.

Os pontos faciais podem ser utilizados para diversas finalidades e são uma grande área de estudo científico. As principais áreas e utilidades são: o reconhecimento de expressões e emoções, identificação de rosto cansado e sonolência, identificação de direção do rosto e alinhamento facial,  detecção de piscadas e no auxílio do reconhecimento facial.

Podendo serem utilizados para vários fins, os algoritmos de detecção possuem um único objetivo, detectar pontos faciais.

O que são pontos faciais

Os pontos faciais, em visão computacional, como o próprio nome diz, são pequenas regiões faciais identificadas por uma numeração. Estas regiões, são identificadas por um ponto e uma numeração que pode variar de técnica para técnica utilizada.

Estes pontos têm como objetivo identificar os contornos dos olhos, nariz, boca e os arredores do rosto, iniciando na parte superior, pelas sobrancelhas, terminando na parte inferior no queixo. As orelhas, geralmente, não são identificadas ao coletar os pontos faciais, porém, caso seja necessário detectar estas regiões, os algoritmos disponibilizados pelo OpenCV (utilizados nos experimentos apresentados mais abaixo) estão preparados para serem treinados a fim de detectar estas regiões.

Os algoritmos de detecção facial, comumente, identificam 68 pontos faciais. Na Fig.1 são ilustrados estes pontos faciais e abaixo estão descritos as localizações destes pontos:

• Contorno do rosto: inicia no ponto 1 e termina no ponto 17;
• Sobrancelha esquerda: inicia no ponto 18 e termina no ponto 22;
• Sobrancelha direita: inicia no ponto 23 e termina no ponto 27;
• Nariz: inicia no ponto 28 e termina no ponto 36;
• Olho esquerdo: inicia no ponto 37 e termina no ponto 42;
• Olho direito: inicia no ponto 43 e termina no ponto 46;
• Contorno externo da boca: inicia no ponto 49 e termina no ponto 60;
• Contorno interno da boca: inicia no ponto 61 e termina no ponto 68.

Identificando pontos faciais

Existem diversas formas de identificar pontos faciais, desde a utilização de morfologia matemática até redes neurais. Para se ter ideia, em uma rápida busca pelos termos “face” “landmark” “detection” só na biblioteca digital IEEE, foram encontrados 846 artigos publicados em revistas e conferências. É muito provável que boa parte destes artigos estejam relacionados a experimentos e muitos deles possuem técnicas semelhantes, porém, ilustra a variedades de trabalhos para tentar identificar pontos faciais.

Apesar de existirem diversos trabalhos com o objetivo de identificar pontos faciais, existe uma grande semelhança em todos eles, os pontos são detectados em imagens com apenas a região do rosto, no máximo um fundo ao redor do rosto, ou seja, para identificar os pontos faciais, antes é preciso coletar apenas o rosto da(s) pessoa(s) na imagem. Em alguns casos também é preciso rotacionar o rosto, a fim de deixar os olhos o mais alinhado possível. Todo este processo é necessário, porque estes algoritmos possuem um único objeto, encontrar os pontos faciais em rostos, e são treinados para identificá-los em rostos verticalmente alinhados ou pouco inclinados.

Com isto, podemos presumir, as seguintes etapas antecessoras à coleta dos pontos faciais na imagem: (1) identificar os rostos na imagem; (2) rotacionar o rosto caso necessário  e (3) identificar os pontos faciais. A imagem da Fig.2 ilustra este processo.

Algoritmos AAM, LBF e Kazemi

Dos diversos algoritmos existentes, 3 deles estão disponibilizados na biblioteca OpenCV: o algoritmo de detecção por Active Appearance Model (AAM) ou modelo de aparência ativa,  o algoritmo de detecção por Local Binary Features (LBF) ou recursos binários locais e o algoritmo de Kazemi. Estes 3 algoritmos estão prontos para serem treinados e utilizados na detecção de pontos faciais. São esses algoritmos que são testados e apresentados neste post.

O algoritmo AAM foi apresentado pela primeira vez por Edwards, Cootes e Taylor no contexto da análise facial na 3ª Conferência Internacional sobre Reconhecimento de Rostos e Gestos, 1998 [CET1][CET2]. O segundo algoritmo LBF, proposto por Shaoqing Ren et al. realiza a deteção dos pontos por meio de regração [RCWS]. E o terceiro algoritmo de Kazemi,  desenvolvido em 2014 por Vahid Kazemi e Josephine Sullivan realiza a detecção por meio de um conjunto de árvores de regressão [KJ1].

Os autores do algoritmo AAM relatam, na  European Conference, que a abordagem deste método pode ser utilizada para propósitos gerais (não só na detecção de pontos faciais) em visão computacional. [CET3][CET4].

Código e Experimentos

A seguir, são apresentados partes do código criado para realizar os experimentos de detecção de pontos faciais. Caso queira replicar estes experimentos, basta baixar o código fonte disponível no github, link na seção “Source” no final deste post.

Neste primeiro bloco, são inicializados todos os detectores do sistema, o detector facial, o detector de olhos e os algoritmos de detecção de pontos faciais. Para iniciar todos estes detectores é muito simples, basta instanciar a classe cv::CascadeClassifier e informar o modelo treinado, para os detectores faciais e de olhos, e chamar a função create das classes FacemarkLBF, FacemarkAMM e FacemarkKazemi para iniciar os detectores de pontos faciais.

...
cv::Ptr< cv::CascadeClassifier > faceDetector;
cv::Ptr< cv::CascadeClassifier > eyeDetector;
cv::Ptr< cv::face::Facemark > facemark;
main() {
...
  //Inicia o detector de rostos por haarcascade
  faceDetector = iniciarDetectorFacial();
  //Inicia o detector de olhos por haarcascade
  eyeDetector = iniciarDetectorOlhos();
  //Inicia o detector de pontos faciais
  facemark = iniciarDetectorPontosFacialLBF();
  //facemark = iniciarDetectorPontosFacialAAM();
  //facemark = iniciarDetectorPontosFacialKazemi();
...
}
cv::Ptr iniciarDetectorFacial() {
 cv::Ptr faceDetector = new CascadeClassifier;
 faceDetector->load("../../extra/haarcascade_frontalface_alt2.xml");
 return faceDetector;
}
cv::Ptr initSimpleEyeDetector() {
  cv::Ptr faceDetector = new CascadeClassifier;
  faceDetector->load("../../extra/haarcascade_eye.xml");
  return faceDetector;
}
cv::Ptr iniciarDetectorPontosFacialLBF() {
  cv::Ptr facemark = cv::face::FacemarkLBF::create();
  facemark->loadModel("../../extra/lbfmodel.yaml");
  return facemark;
}
cv::Ptr iniciarDetectorPontosFacialKazemi() {
  cv::Ptr facemark = cv::face::FacemarkKazemi::create();
  facemark->loadModel("../../extra/kazemi_model.dat");
  return facemark;
}
cv::Ptr iniciarDetectorPontosFacialAAM()
{
  cv::Ptr facemark = cv::face::FacemarkAAM::create();
  facemark->loadModel("../../extra/aam_model.yaml");
  return facemark;
}

Observe que todos os detectores utilizam a função “load” e “loadModel” para carregar os modelos de dados treinados. Estes detectores não funcionam caso não seja informada a base de dados treinada. Junto com o código fonte, deste projeto, encontra-se a base de dados utilizada nos experimentos. Esta base de dados é extremamente simples e não é útil para projetos mais robustos e aplicações finais.

Note, que foi utilizado o detector facial e de olhos por Haarcascade, porém, nada impede de serem utilizados outros detectores faciais e olhos para este tipo de projeto, como técnica de pré-processamento. 

No próximo bloco, abaixo, é capturado o vídeo para detecção dos pontos faciais, alterando a resolução da imagem para 320 pixels, a fim de facilitar o processamento dos detectores. Para capturar a câmera do vídeo com o OpenCV, basta instanciar a classe “cv::VideoCapturecap” e coletar a imagem do vídeo com o operador “>>” conforme trecho de código “cap>>img”.

main() {
  ...
  //Inicia captura dos vídeos
  cv::VideoCapturecap cap(0);
  if (!cap.isOpened()) {
    std::cout<<"Video Capture Fail"<<std::endl; return1; } cv::Mat img; cap>>img;
    return 1;
  }
  //Calcula nova dimensão da imagem para 320 pixels
  auto showSize = cv::Size(320, ((float)320 / img.cols) * img.rows);
  for (;;)
  {
    //Coleta a imagem da camera
    cap>>img;
    //Reescala a imagem para uma largura de 320 pixels
    cv::resize(img, img, showSize, 0, 0, cv::INTER_LINEAR_EXACT);
    coletarPontosFaciais(img);

    cv::imshow("Origem", img);
    cv::waitKey(5);
  }
}

E no último trecho de código, é apresentado como coletar os pontos faciais com o OpenCV.

...
void coletarPontosFaciais(cv::Mat imagemOriginal)
{
    cv::Mat imagemOriginalCinza;
    std::vector< cv::Rect > rostosDetectados;
    std::vector< std::vector< cv::Point2f > > pontosFaciais;
    cv::Mat imagemComPontosFaciais;
    {
        //Converte em tons de cinza e equaliza a imagem
        //Detecção por haarcascade funcionam bem com imagens equalizadas
        cvtColor(imagemOriginal, imagemOriginalCinza, cv::COLOR_BGR2GRAY);
        equalizeHist(imagemOriginalCinza, imagemOriginalCinza);
        //Detecta os rostos na imagem
        faceDetector->detectMultiScale(imagemOriginal, rostosDetectados);
    }
    if (rostosDetectados.size() != 0)
    {
        imagemComPontosFaciais = imagemOriginal.clone();
        //Demarca rosto na imagem original
        for (auto &&rostoDetec : rostosDetectados)
        {
            demarcarRostoDetectado(imagemOriginal, rostoDetec);
        }
        if (requerDetecaoDosOlhos) {
            //Detecta os pontos faciais com código personalizado para o algorítmo AAM
            facemarkAAMFit(static_cast< cv::face::FacemarkAAM* >(facemark.get()), eyeDetector,
                fitEmTonsDeCinza
                    ? imagemOriginalCinza
                    : imagemOriginal,
                rostosDetectados, 
                pontosFaciais);
        } else {
            //Detecta os pontos faciais
            pontosDetectados = facemark->fit(fitEmTonsDeCinza
                              ? imagemOriginalCinza
                              : imagemOriginal,
                          rostosDetectados, pontosFaciais);
        }
        if (pontosDetectados)
        {
            demarcarPontosFaciais(imagemComPontosFaciais, rostosDetectados, pontosFaciais);
            imshow("Pontos faciais", imagemComPontosFaciais);
        }
    }
    escreverQtdPiscadas(imagemOriginal, piscadas);
}

Observe que, a primeira etapa realizada é a detecção dos rostos através da função “faceDetector->detectMultiScale“, onde é informada uma imagem de entrada, e como resposta desta função, é devolvido um vetor de retângulos, com as regiões dos rostos encontrados. Mais abaixo, na função “facemark->fit”,  é chamada a função que detecta os pontos faciais, esta função deve receber a imagem que contém os rostos e o vetor de retângulos, com as posições dos rostos encontrados. Por fim, a função fit, devolve todos os pontos faciais encontrados, de todos os rostos informados à ela.

Neste mesmo bloco de códigos, mencionado acima, encontrasse a função “facemarkAAMFit“, ela possui um código personalizado para realizar a coleta dos pontos faciais, com o algoritmo AAM. Esta personalização coleta informações de rotação e translação da imagem, a fim de rotacionar e ajustar a posição do rosto, etapa necessária para o algoritmo AMM. Esta função, está disponível no código fonte do github e foi copiada do próprio tutorial da OpenCV. 

As funções demarcarRostoDetectado e demarcarPontosFaciais, não são funções do OpenCV e foram criadas apenas para demarcarem as regiões do rosto e os pontos faciais detectados.  Estas funções, também estão disponíveis no código fonte do projeto.

Como resultado deste projeto, foi realizado o experimento ilustrado pela Fig 3.  Observe que o detector facial (etapa de pré-processamento) encontrou uma segunda face, que na verdade eram 3 potes. Por consequência desta falha, na detecção facial, o detector de pontos também tentou identificar os pontos faciais.

Espero que esse conteúdo os ajudem na tarefa de identificação de pontos faciais. 
Caso tenham dúvidas e sugestões de melhorias no post, deixe seu comentário abaixo.

Source:

https://github.com/visaocomputacionalexemplos/experimentos_faciais/tree/main/detectar_pontos_faciais_opencv

Referencias:

Huber, Patrik. (2018). Real-time 3D morphable shape model fitting to monocular in-the-wild videos.

[CET1] Edwards, G. J.; Taylor, C. J.; Cootes, T. F. (1998). “Interpreting face images using active appearance models”. Proceedings Third IEEE International Conference on Automatic Face and Gesture Recognition. p. 300[CET2] Cootes, T.F.; Edwards, G.J.; Taylor, C.J. Active Appearance Models. Wolfson Image Analysis Unit,. Department of Medical Biophysics,[CET3] Cootes, T. F.; Edwards, G. J.; Taylor, C. J. (1998). “Active appearance models”. Computer Vision — ECCV’98. Lecture Notes in Computer Science. 1407. p. 484.[CET4] Cootes, T. F.; Edwards, G. J.; Taylor, C. J. (2001). “Active appearance models”. IEEE Transactions on Pattern Analysis and Machine Intelligence. 23 (6): 681.  [KJ1] V. Kazemi and J. Sullivan, “One millisecond face alignment with an ensemble of regression trees,” 2014 IEEE Conference on Computer Vision and Pattern Recognition, 2014, pp. 1867-1874, doi: 10.1109/CVPR.2014.241. [RCWS] S. Ren, X. Cao, Y. Wei and J. Sun, “Face Alignment at 3000 FPS via Regressing Local Binary Features,” 2014 IEEE Conference on Computer Vision and Pattern Recognition, 2014, pp. 1685-1692, doi: 10.1109/CVPR.2014.218.

The post Detecção de pontos faciais (Facemark) com OpenCV appeared first on Visão Computacional.