Este artigo demonstra como programar a extração de fronteiras internas e externas, e esqueletização de imagens binárias apresentadas em Morfologia Matemática – Esqueletização de imagem e Morfologia Matemática – Extração de Fronteiras / Detecção de Bordas. A programação foi realizada na linguagem javascript, utilizando a biblioteca opencv.js e as imagens produzidas com a IDE OpenCV-Flow.

OpenCV

A biblioteca opencv.js disponibiliza diversas funcionalidade prontas para o processamento de imagens e visão computacional. Para utilizá-la, basta incluí-la no script da página conforme descrito em Using OpenCV.js.

Extração de Fronteira Interna

A fronteira interna, como apresentado no outro post citado, é o contorno da imagem binarizada. O cálculo consiste em subtrair da imagem o resultado da erosão da própria imagem, por um elemento estruturante.

A primeira etapa que iremos realizar é criar o núcleo de operação com o formato de quadrado. O elemento estruturante deve ser uma imagem binarizada (preto e branco). Como não temos imagens binárias no OpenCV, criaremos uma imagem em tons de cinza.

Na função nucleoFormatoCruz abaixo, é criada uma matriz de tamanho 3×3, com um canal de cor do tipo uint8, com valores entre 0 e 255:

function nucleoFormatoCruz() {
  return new cv.matFromArray(3, 3, cv.CV_8UC1, [
    0, 1, 0,
    1, 1, 1,
    0, 1, 0
  ]);
}

Com o núcleo criado, basta realiza a erosão da imagem binarizada e depois subtrair a imagem original pelo resultado desta operação. A função abaixo realiza este processo com a biblioteca OpenCV.js:

function extrairFronteiraInterna(imagem, imagemSaida, nucleo) {
  let imgTemporaria = new cv.Mat(imagem.rows, imagem.cols, imagem.type(), new cv.Scalar(0));

  // Realiza a erosão com biblioteca opencv.
  cv.erode(imagem, imgTemporaria, nucleo);
  
  // Realiza a subtração da imagem pela mesma erodida
  cv.subtract(imagem, imgTemporaria, imagemSaida);
}

A primeira operação realizada com a função cv.erode, recebe uma imagem de entrada, uma imagem que receberá o resultado da operação de erosão e o núcleo para a operação.

A segunda e última operação realizada é a subtração com a função cv.subtract, que recebe uma imagem de entrada, uma segunda imagem com os valores das subtrações a serem realizadas, e por fim uma imagem de saída que receberá o resultado desta operação.

É possível simplificar esta função conforme abaixo:

function extrairFronteiraInterna(imagem, imagemSaida, nucleo) {
  // Realiza a erosão com biblioteca opencv.
  cv.erode(imagem, imagemSaida, nucleo);
  
  // Realiza a subtração da imagem pela mesma erodida
  cv.subtract(imagem, imagemSaida, imagemSaida);
}

Note que, foi informada a variável imagemSaida como segundo e terceiro parâmetro, da segunda operação. Foi realizado isto, pois a variável imagemSaida contém o resultado da erosão, que é preciso para subtrair os valores e para não precisarmos criar uma terceira variável, simplificando a função. Não há problemas em utilizar a mesma variável na operação cv.subtract, pois ela é uma operação não convolucional, que realiza apenas operações que utilizam um único pixel de cada vez.

Extração de Fronteiras Externas

A fronteira externa, na imagem binarizada, cria uma camada como uma vestimenta que cobre toda a imagem. O cálculo consiste em dilatar a imagem por um elemento estruturante e subtrair pela imagem original. De certa forma, o inverso da operação para extração da fronteira interna.

A primeira etapa para realizar esta operação, também consiste em criar um núcleo para a operação de dilatação. Utilizaremos o mesmo da seção anterior. Com o núcleo criado basta realizar as operações conforme a função abaixo:

function extrairFronteiraExterna(imagem, imagemSaida, nucleo) {
  let imgTemporaria = new cv.Mat(imagem.rows, imagem.cols, imagem.type(), new cv.Scalar(0));

  // Realiza a erosão com biblioteca opencv.
  cv.dilate(imagem, imgTemporaria, nucleo);
  
  // Realiza a subtração da imagem pela mesma erodida
  cv.subtract(imgTemporaria, imagem, imagemSaida);
}

Observe que para extração da fronteira externa, foi trocada a operação de erosão pela dilatação com a função cv.dilate, e alterada a ordem dos parâmetros durante a subtração com a função cv.subtract.

Esqueletização de Imagem Binarizada

Pare realizar a esqueletização com morfologia, conforme apresentado em Morfologia Matemática – Esqueletização de imagem, basta realizar quatro operações, dentro de um laço de repetição, e realizar a inicialização de algumas variáveis para este processamento.

Observe na função abaixo, que nas primeiras linhas, antes do laço while, foram inicializados variáveis para o processamento da esqueletização, criando uma imagem temporária chamada clone, com as mesmas informações da imagem original e um núcleo que é utilizado para reduzir a estrutura da imagem original.

function extrairEsqueleto(imagem, imagemSaida) {
  // Inicializa as matrizes
  const erosao = new cv.Mat(imagem.rows, imagem.cols, src.type());
  const abertura = new cv.Mat(imagem.rows, imagem.cols, src.type());
  const subtracao = new cv.Mat(imagem.rows, imagem.cols, src.type());

  // Clona a imagem original
  let clone = imagem.clone();
  // Cria o núcleo(3x3) em formato de cruz
  const nucleo = cv.getStructuringElement(cv.MORPH_CROSS, new cv.Size(3, 3), new cv.Point(-1, -1));

  while (cv.countNonZero(clone) !== 0) {
    cv.erode(clone, erosao, nucleo); 
    cv.dilate(erosao, abertura, nucleo);

    cv.subtract(clone, abertura, subtracao);

    cv.bitwise_or(imagemSaida, subtracao, imagemSaida);

    clone = erosao.clone();
    GCStore.add(clone);
  }

  // Deleta as variáveis temporárias
  delete erosao;
  delete abertura;
  delete subtracao;
  delete clone;
}

Após a inicialização das variáveis, é realizado um laço que verifica se a imagem clone está vazia (só com valores zero), caso não esteja, o laço fica realizando as seguintes operações:

• As duas primeiras operações realizadas, dentro do laço, consistem em realizar uma erosão, seguida de uma dilatação.
  • Como resultado é criado uma abertura da imagem, pelo elemento estruturante em formato cruz;
  • Esta abertura remove os pontos das extremidades da imagem clone.
• A terceiraça operação, realiza a subtração da imagem clone pela imagem de abertura.
  • Como resultado, na matriz subtração, estão apenas os pontos com as extremidades da imagem clone.
• Por fim, os pontos da extremidades, são salvos na imagem de saída.

O processo é repetido até que a imagem clone seja zerada, durante o processo de erosão.

Note que, em cada laço realizado, é coletado os pontos da extremidades da imagem clone e salvo na imagem de saída, e em cada laço a imagem é diminuída de tamanho. Este processo resulta na criação do esqueleto da imagem.

Cuidados

Caso você vá utilizar a biblioteca opencv, saiba que as funções morfológicas dela também realizam morfologia matemática em imagens em tons de cinza e coloridas, que possuem resultados muito diferentes das operações morfológicas em imagens binarizadas. Lembre-se de converter a imagem em preto e branco, para realizar os experimentos aqui apresentados.

Considerações

As funções programadas neste post possuem caráter de estudo, afim de entender as etapas e os processos morfológicos, pois não foram pensadas em questões como desempenho nestes exemplos. Caso você precise utilizar este tipo de operação, é recomendado que utilize uma biblioteca preparada para isso, como o OpenCV ou similar.

O código aqui apresentado esta disponível no link abaixo:

Source code: https://github.com/visaocomputacionalexemplos/morfologia/blob/main/javascript/base/esqueletizacao.html

The post Programando Esqueletização e Extração de Fronteiras Morfológica com Javascript appeared first on Visão Computacional.

Este artigo trata de como programar as operações morfológicas binárias apresentadas no post Morfologia Matemática para Processamento de Imagens. A programação foi realizada na linguagem javascript, utilizando a biblioteca opencv.js e as imagens produzidas com a IDE OpenCV-Flow.

OpenCV

A biblioteca opencv.js disponibiliza diversas funcionalidade prontas para o processamento de imagens e visão computacional. Para utilizá-la, basta incluí-la no script da página conforme descrito em Using OpenCV.js.

Utilizaremos a classe Mat do OpenCV para realizar a manipulação da imagem, com esta classe conseguimos construir de forma fácil imagens (coloridas e binárias) e manipular seus pixels.

Erosão

A erosão como apresentado no outro post citado, consiste em testar se o elemento estruturante (núcleo) se encaixa na imagem de origem, gerando uma nova imagem de destino, onde cada teste realizado com sucesso, é identificado na imagem de destino com o valor 1 e identificado com o valor 0 caso a estrutura não tenha sido localizada. 

A primeira etapa que iremos realizar é criar o núcleo de operação com o formato de quadrado. O elemento estruturante deve ser uma imagem binárizada (preto e branco), como não temos imagens binárias no OpenCV, criaremos uma imagem em tons de cinza.

Na função nucleoFormatoCruz, abaixo, é criada uma matriz de tamanho 3×3, com um canal de cor do tipo uint8, com valores entre 0 e 255:

function nucleoFormatoCruz() {
  return new cv.matFromArray(3, 3, cv.CV_8UC1, [
    1, 1, 1,
    1, 1, 1,
    1, 1, 1
  ]);
}

Além do núcleo das operações, vamos precisar da posição central das operações, sendo que no OpenCV é utilizada a classe cv.Point para indicar posições específicas, com o objetivo de seguir o padrão, nosso código também ira utilizá-la. Para inicializar a classe, é preciso apenas informar as posições das coordenadas x e y, conforme abaixo:

const centro = new cv.Point(1, 1);

Agora que temos nosso núcleo e sua posição, nossa função de erosão foi programada com as seguintes etapas:

• Percorre todas as posições dos pixels da imagem;
• Para cara pixel da imagem, percorre todos os elementos do elemento estruturante e testa a estrutura na imagem conforme as etapas:
  • Verifica-se se o elemento do núcleo possui valor e:
    • Se o elemento possuir valor, verifica a posição correspondente na imagem também possui valor e:
      • Se o pixel possuir valor, verifica o próximo elemento;
      • Se o pixel não possuir, marca o teste como negado;
  • Se o elemento não possui valor, verifica o próximo elemento;
  • Ao finalizar todos os testes dos elementos, do núcleo na região do pixel, e caso nenhum for negado, marca na imagem de destino o valor 255, do contrário marca como 0;

function erosao(nucleo, centro, imagem, imagemSaida) {
  //Percorre a imagem
  for (let x = centro.x; x < imagem.cols; x++) {
    for (let y = centro.y; y < imagem.rows; y++) {

      let hasNucleo = true;
      //Percorre o elemento estruturante (núcleo)
      for (let j = 0; j < nucleo.cols; j++) {
        for (let k = 0; k < nucleo.rows; k++) {
          
          //Verifica-se se o elemento do núcleo deve ser checado
          const nucleoTemValor = nucleo.ucharPtr(k, j)[0] > 0;
          if (nucleoTemValor) {
            const col = x + j - centro.x;
            const row = y + k - centro.y;

            //Verifica-se se a imagem tem valor na mesma posição do núcleo
            const imagemTemValor = imagem.ucharPtr(row, col)[0] > 0;
            if (!imagemTemValor) {
              hasNucleo = false;
              break;
            }
          }
        }
      }

      imagemSaida.ucharPtr(y, x)[0] = hasNucleo ? 255 : 0;
    }
  }
}

Dilatação

A dilatação consiste em testar cada elemento da imagem de origem e verificar se possui valor 1, caso exista na imagem de destino, então é adicionado os valores do elemento estruturante a partir da posição central do elemento estruturante.

A programação da dilatação é menos complexa que a da erosão, nossa função realiza apenas as seguintes etapas:

• Percorre todas as posições dos pixeis da imagem;
• Para cara pixel da imagem:
  • Verifica-se se o pixel possui valor e:
    • Caso possuir, percorre os elementos do núcleo e os projeta na imagem de destino;
    • Caso não possuir, não realiza nenhuma operação;

function dilatacao(nucleo, centro, imagem, imagemSaida) {
  //Percorre a imagem
  for (let x = centro.x; x < imagem.cols; x++) {
    for (let y = centro.y; y < imagem.rows; y++) {

      //Verifica-se se o pixel da imagem possui valor positivo
      const pixelComValor = imagem.ucharPtr(y, x)[0] > 0;
      if (pixelComValor) {

        //Percorre o elemento estruturante (núcleo)
        for (let j = 0; j < nucleo.cols; j++) {
          for (let k = 0; k < nucleo.rows; k++) {
            
            //Verifica-se se o elemento do núcleo tem valor positivo
            const nucleoTemValor = nucleo.ucharPtr(k, j)[0] > 0;
            if (nucleoTemValor) {
              const col = x + j - centro.x;
              const row = y + k - centro.y;

              imagemSaida.ucharPtr(row, col)[0] = 255;
            }
          }
        }
      }
    }
  }
}

Abertura

A abertura de uma imagem A, por um elemento estruturante B, é simplesmente a operação de erosão de A por B, seguida da dilatação de A por B. Como a abertura é apenas o encadeamento de duas operações, nosso código de exemplo faz apenas isto.

function abertura(nucleo, centro, imagem, imagemSaida) {
  let imgTemporaria = new cv.Mat( imagem.rows, imagem.cols, imagem.type(), new cv.Scalar(0));
  
  erosao(nucleo, centro, imagem, imgTemporaria);
  dilatacao(nucleo, centro, imgTemporaria, imagemSaida);

  imgTemporaria.delete();
}

Fechamento

O fechamento de uma imagem A, por um elemento estruturante B, é simplesmente a operação de dilatação de A por B, seguida da erosão de A por B. Como o fechamento também é apenas o encadeamento de duas operações, nosso código de exemplo faz apenas isto também.

function fechamento(nucleo, centro, imagem, imagemSaida) {
  let imgTemporaria = new cv.Mat( imagem.rows, imagem.cols, imagem.type(), new cv.Scalar(0));

  dilatacao(nucleo, centro, imagem, imgTemporaria);
  erosao(nucleo, centro, imgTemporaria, imagemSaida);

  imgTemporaria.delete();
}

Considerações

As funções programadas neste post possuem caráter de estudo, afim de entender as etapas e os processos morfológicos, pois não foram pensadas em questões como desempenho nestes exemplos. Caso você precise utilizar este tipo de operação, é recomendado que utilize uma biblioteca preparada para isso, como o OpenCV ou similar.

O código aqui apresentado esta disponível no link abaixo:

Source code: https://github.com/visaocomputacionalexemplos/morfologia/blob/main/javascript/base/morfologia.html

The post Programando Erosão, Dilatação, Abertura e Fechamento Morfológica com Javascript. appeared first on Visão Computacional.

Neste experimento, vamos demostrar a aplicação das técnicas NDWI e NDVI, capazes de identificar água e a saúde da vegetação, por meio de imagens públicas de satélites com o Google Earth Engine. Essas técnicas foram apresentadas no post “Índice de Vegetação e Índice de Água”.

A técnica NDVI – Índice de vegetação por diferença normalizada, identifica a saúde da planta, calculando a diferença de refletância entre o infravermelho-próximo e o vermelho, com a fórmula:

Fórmula: NDVI = (Infravermelho Próximo - Vermelho) / (Infravermelho Próximo + Vermelho).

A técnica NDWI – Índice de vegetação por diferença normalizada identifica água, inundações, mar, etc. Calculando a diferença de refletância entre o infravermelho-próximo e o verde, com a fórmula:

Fórmula: NDWI = (Verde – Infravermelho Próximo) / (Verde + Infravermelho Próximo).

Estas duas técnicas diferentes, podem ser aplicadas em imagens de satélite ou através de câmeras infravermelho de forma muito simples. Neste post, iremos demonstrar como aplicá-las com a ferramenta Google Earth Engine utilizando uma base de dados geoespaciais pública, para pesquisa.

Google Earth Engine

É uma ferramenta desenvolvida pela Google que combina um catálogo de várias de imagens de satélite e conjuntos de dados geoespaciais com recursos de análise em escala planetária. Com o objetivo, de que cientistas, pesquisadores e desenvolvedores usam o Earth Engine para detectar mudanças, mapear tendências e quantificar diferenças na superfície da Terra.

A ferramenta está disponível para uso comercial e é gratuito para uso acadêmico e de pesquisa. Para utilizar o Code Editor, basta acessar o link “code”, realizar o login com sua conta do Google e de um navegador web desktop. A ferramenta contém os seguintes 4 painéis:

• O Editor, de código onde serão adicionados todos os procedimentos e script;
• O Painel de status, que exibem as saídas dos procedimentos executados, como exibição de logs e erros;
• O Painel de navegação, semelhante ao Explorer do Windows;
• O Mapa, onde serão exibidos todos os resultados e análises feitas pelos scripts criado.

Catálogos de Dados do Google Earth

Pare aplicar as técnicas de análise de dados geoespaciais, com o Earth Engine, primeiro é preciso selecionar qual ou quais coleções de dados/imagens deseja-se utilizar. Existe uma grande variedade de base de dados e para diversas finalidades, porém, para nosso agrado, o Google disponibiliza um buscador (Clique aqui para acessar) que nos facilita a encontrá-la.

Neste experimento, iremos utilizar a base USGS Landsat 8 Collection 1 Tier 1 TOA Reflectance. Base de dados com informações de refletância do espectro de luz magnético, que possui imagens com as cores e o infravermelho, necessário para aplicar as fórmulas NDVI e NDWI.

Esta base de dados, possui imagens coletadas entre o período de 2013 à 2022. As informações da base de dados são divididas em bandas, cada banda representa uma faixa do espectro eletromagnético. No experimento iremos utilizar as bandas B3, B4 e B5, que representam respectivamente o verde, vermelho e infravermelho próximo.

Experimento

Coletar NDVI e NDWI com o Earth Engine é muito fácil, para testes rápidos precisamos apenas realizar 4 etapas: selecionar a coleção de dados; selecionar as bandas; aplicar as fórmulas e exibir o resultado no mapa.

Selecionar Coleção de dados

Na primeira etapa, é preciso selecionar a região de interesse no mapa, o local que se deseja extrair as imagens, no experimento foi selecionado a região de Florianópolis – SC. Esta região foi selecionada por meio da função ee.Geometry.Point que criar uma variável com as informações da coordenada desejada.

Também é necessário coletar a base de imagens ou coleção de dados, por meio da função ee.ImageCollection. Com a coleção de dados indicada, agora precisamos indicar 2 filtros, o filtro da região de interesse e o filtro de período de busca de imagens. Estes filtros são aplicados por meio das funções filterBounds e filterDate.

//Coleta as posições do mapa na região de Florianópolis - SC
var imagePoint = ee.Geometry.Point([-49, -27.6935391]);
var viewPoint = ee.Geometry.Point([-48.5449963, -27.5930994]);

//Base de imagens geoespaciais utilizada
var l8 = ee.ImageCollection('LANDSAT/LC08/C01/T1_SR');
//Informa o período de busca das imagens
var l8Query =  l8
    .filterBounds(imagePoint)
    .filterDate('2021-01-01', '2021-12-31')
    .sort('CLOUD_COVER');

//Coleta a primeira imagem identificada para o período informado
var image = ee.Image(l8Query.first());

//Centraliza o mapa
Map.centerObject(viewPoint, 13);

Com os filtros e a região de interesse informada, basta solicitar os registros com a função l8Query.first. Com os registros coletados, devemos convertê-los em dados de imagens que podemos trabalhar com a função ee.Image que retorna uma classe com diversas funcionalidade.

Observe que, além dos filtros foi informada para ordenar a coleção de dados por meio da função sort, com base na ordem de dados do atributo CLOUD_COVER da coleção de dados. Este atributo indica o quanto da região esta coberta por nuvens, e como não queremos realizar a analise dos dados com nuvens, então indicamos para trazer a primeira imagem com o menor número de nuvens identificadas. Também é possível realizar filtros por este atributo, porém isso pode fazer com que não venha nenhuma imagem da região devido o filtro aplicado.

Selecionar Bandas

Na segunda etapa, basta extrairmos da imagem as bandas B3, B4 e B5 da coleção de dados que correspondem ao verde, vermelho e infravermelho-próximo do espectro eletromagnético, conforme código abaixo:

//Coleta as bandas de cores NIR, Vermelho e Verde 
var green = image.select('B3');
var red = image.select('B4');
var nir = image.select('B5');

Aplicar e visualizar Fórmulas

Por fim, basta realizar os cálculos e adicionar a camada (Layer) com a imagem do NDVi gerada pelo Earth Engine ao mapa. Para adicionar ao mapa basta chamar a função Map.addLayer. Note que ao adicionar a camada NDVI, foram adicionados 2 parâmetros adicionais, o primeiro parâmetro (ndviParams), indica quais cores representarão cada extremo do cálculo NDVI, utilizamos a cores vermelha pra representar o valor -1, verde +1 e branco valores próximo ao zero. O segundo parâmetro “NDVI imagem” indica o nome do botão que ativa e inativa a visualização da camada no visualizador do mapa.

// Computa o Índice de Vegetação de Diferença Normalizada (NDVI).
var ndvi = nir.subtract(red).divide(nir.add(red)).rename('NDVI');
var ndviParams = {min: -1, max: 1, palette: ['red', 'white', 'green']};
Map.addLayer(ndvi, ndviParams, 'NDVI image');

Para calcular o NDWI basta realizar as mesmas operações do NDVI, porém ajustando o cálculo para utilizar o infravermelho e o verde.

// Computa o Índice de Água de Diferença Normalizada (NDWI).
var ndwi = green.subtract(nir).divide(green.add(nir)).rename('NDVI');
var ndwiParams = {min: -1, max: 1, palette: ['red', 'white', 'blue']};
Map.addLayer(ndwi, ndwiParams, 'NDWI image');

Também é possível realizar todo o cálculo do NDVI e NDWI de uma forma bem mais simples. Como essas duas formulas são cálculos de normalização, basta utilizar os seguintes códigos abaixo que o próprio Earth Engine converte para as fórmulas descritas acima.

//Formas resumidas de coletar a informação
var ndvi = image.normalizedDifference(['B5', 'B4']).rename('NDVI');
var ndwi = image.normalizedDifference(['B3', 'B5']).rename('NDVI');
Map.addLayer(ndvi);
Map.addLayer(ndwi);

Com este experimento e o código acima foram geradas as seguintes imagens:

Na primeira imagem, na parte esquerda, visualizamos em verde a refletância de áreas cobertas por vegetação e em vermelho áreas com nenhuma refletância de vegetação segundo a fórmula do NDVI. Quanto mais escuro o verde é indicativo de maior concentração de vegetação ou vegetações mais saudáveis.

Observar que nem toda vegetação saudável possui um alto nível de NDVI, cada vegetação possui uma característica especifica de saúde, que requerem estudos específicos para saber identificar sua saúde através do NDVI. Porém para identificar regiões de mata, floresta ou de cultivo, o NDVI é ideal ideal.

Na segunda imagem, na parte esquerde, visualizamos em azul todas as regiões com superfície coberta por água, inundações e em vermelho a ausência d’água. O interessante nesta segunda imagem é que ela consegue identificar a Lagoa da Conceição, uma lagoa situada no meio de Florianópolis e se olharmos a mesma imagem, na parte direita, não é possível identificar a lagoa pela imagem de satélite.

Para visualizar esta aplicação, basta acessar o link Teste NDVI NDWI. Todo este experimento foi criado, com base no tutorial criado pelo próprio Google (clique aqui para acessar o tutorial).

Plataforma MapBiomas

Uma ferramenta muito mais elabora, que esta criada neste post, é a plataforma MapBiomas que disponibilizam diversas análises sensoriais do Brasil com scripts criados por meio do Google Earth Engine.

Clique aqui para acessar a ferramenta ou clique aqui para visualizar uma análise sensorial e temporal da superfície d’água no Brasil.

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

Source:

https://github.com/visaocomputacionalexemplos/espectroeletromagnetico/tree/main/google_earth_ndvi_ndwi

Referências:

Iporã Brito Possantti via MasAbertos, O Google Earth Engine. Acessado em 04 mar 2022.

Google, NDVI, Mapping a Function over a Collection, Quality Mosaicking . Acessado em 04 mar 2022.

The post Experimento – NDVI e NDWI com o Google Earth Engine appeared first on Visão Computacional.

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.