Sistema 3D de interação gestual

Hoje vi esta notícia e fiquei feliz com os avanços na área de interação homem-máquina por gestos.

Este sistema é semelhante, em certos aspectos ao SIRENE (meu projeto de mestrado), porém bem mais elaborado.

Semelhante ao SIRENE, este sistema não necessita de luvas, o que gera maior independência do sistema com relação às condições de uso. Imagine o usuário não poder usar o sistema porque sua luva está suja ou desbotada (inadequada), por exemplo.

Outro sistema, já comercial, está sendo usado com sucesso em hospitais. Em casos específicos, como ambientes estéreis (hospitais e laboratórios), é importante evitar situações de contaminação por parte dos profissionais, tocar objetos pode contaminar as mãos do usuário deste objeto, principalmente quando se trata de um objeto eletrônico, difícil de ser higienizado e usado por várias pessoas.

Deixo então um incentivo aos pesquisadores e desenvolvedores da área de interação gestual por meios sem contato, por exemplo visão computacional. Vejamos onde podemos atuar e colaborar com a melhoria daquilo que já existe empregando nossos conhecimentos.

M.Sc Engenheiro

Bom dia a todos, eu gostaria de compartilhar da minha felicidade com os leitores do MultiSign.

Eu apresentei minha dissertação de mestrado na última semana e o meu trabalho foi aprovado, então, para todos os efeitos, eu sou engenheiro e mestre em engenharia.

Por estes dias eu estarei fazendo as correções no texto da minha dissertação, mas estarei sempre respondendo às questões que forem apresentadas e comentários nos posts.


Gostaria de agradecer a atenção de todos e que Deus nos abençoe.

Projeto SIRENE chega ao fim, por enquanto

Eu acredito que meus leitores saibem que eu estou fazendo mestrado.

Pois bem, finalmente eu o estou concluindo.

Para os que não conhecem o meu trabalho de mestrado, este trata-se de um sistema de reconhecimento de gestos por visão computacional.

A sigla do sistema é SIRENE (Sistema de Reconhecimento de Gestos por Redes Neurais e Visão Computacional), o nome é auto-esplicativo.

Durante o desenvolvimento do projeto, eu desenvolvi algumas coisas, como um protótipo, cujo vídeo é apresentado a seguir:



E dois artigos publicados em congresso, podem ser vistos aqui.

Espero que aqueles que conheceram meus trabalhos tenham apreciado e se motivado a também contribuir para a sociedade com o desenvolvimento tecnológico.


Obs.: A defesa da minha dissertação será nesta sexta-feira (23/04).

Protótipo do SIRENE em funcionamento

Como todos sabem, estou em São Paulo - SP participando do Interaction South-America'09.

Eu tive dois artigos aceitos, sendo que um deles consiste no resumo do meu mestrado.

Para este artigo, eu preparei um protótipo do SIRENE e gerei este vídeo.



Apesar do vídeo ser curto, ele demorou alguns minutos para ser gerado, quem tiver interesse em saber como está o protótipo é só entrar em contato.

Trabalhos acadêmicos no Interaction South-America

Aqui consta a lista de trabalhos acadêmicos que serão apresentados no Interaction South-America.

Seguem alguns títulos dos trabalhos:

• A Influência de Interfaces Gráficas na Narrativa e Imersão de Jogos Digitais;
• Inspeção semiótica do Wiki-STOA: uma análise a partir da teoria da complexidade;
• Desenvolvendo Interfaces de Usuário Multiplataformas utilizando MDA;
• A percepção das tecnologias;
• A personalização como estratégia para o gerenciamento da obsolescência de artefatos;
• Design de interface para questionário on-line do Censo Demográfico 2010;
• Método para Aplicações Web Focado em Usabilidade Aderente a um Processo de Software Convencional;
• New scenarios in the design education with dynamic of interaction;
• Levantamento de Heurísticas para Avaliação de Interfaces do Usuário Baseadas em Voz;
• Reconhecimento de Gestos da LIBRAS com Classificadores Neurais a partir dos Momentos Invariantes de Hu;
• Compreendendo dinâmicas de jogo: as esferas de interação dentro do framework Componentes-Dinâmicas-Experiências;
• Violent Video Games: Changes in non-verbal behavior and short-term effects on valence and arousal.
  

Os demais trabalhos podem ser encontrados no link da primeira palavra deste post.

Fazendo vídeos e fotos com webcam

Nos últimos dias eu estava precisando fazer uns vídeos para dar continuidade ao meu projeto de mestrado. Então eu procurei algum software que capturasse frames da webcam e fizesse o vídeo, nessa procura eu encontrei o Cheese.

O Cheese é um software simples de usar e que dá bons resultados.

Segue um vídeo da utilização do sistema:



Pena que a tela de exibição dos frames não foi capturada corretamente.

Mais uma etapa chegando ao fim...

Como os leitores já devem ter percebido, estou postando com baixa frequência.

O motivo é o meu mestrado que está chegando ao fim, e como todo final de curso que se preze estou com muito o que fazer.

Minha previsão é terminar o mestrado em julho (com a defesa da minha dissertação).

Enquanto estou ocultado com as atividades do mestrado, não poderei dar a devida atenção aos meus blogs.

Espero contar com a compreensão de todos e que Deus esteja conosco hoje e sempre.

Manipulação de iluminação pelo histograma

Eu fiz um post sobre segmentação em que eu citei uma equalização de histograma, mas como atualmente estou fazendo alguns testes com realce de imagens e usando técnicas que envolvem o histograma das imagens, vou apresentar algo aqui.

Para começar, tudo o que for apresentado aqui foi desenvolvido no Scilab com a biblioteca SIVP (informações podem ser encontradas facilmente nas tags do blog).

Pois bem, para começar vamos manipular apenas um offset do histograma que consiste em acrescentar ou subtrair um valor constante em todos os pixels da imagem.

Para ilustrar, vamos usar a imagem a seguir.


Segue o histograma desta imagem.
Obs.: Lembrando que o histograma é a incidência de pixels em cada nível (intensidade).

Observando este histograma, percebe-se que ele está muito consentrado nos valores altos, o que se reflete em uma imagem muito clara.

Vamos então reduzir 50 de cada pixel.

Obtemos a imagem (original | nova).

E o novo histograma.

Neste caso, já percebe-se alguma diferença na imagem.

Para fechar o post, faço 2 observações:

1. As imagens podem ser vistas em tamanho original apenas clicando em cima.
2. Novos posts sobre o assunto serão feitos caso os leitores mostrem interesse.
   

Técnicas clássicas de segmentação de pele humana

Enfim algum tempo livre... Vou aproveitar e fazer um post sobre uma das etapas do meu mestrado a segmentação da pele.

Vou apenas apresentar 3 formas de segmentação de pele e alguns resultados obtidos.

A imagem de teste é apresentada a seguir.



Espaço de cores RGB:

Um pixel pertence a pele se satisfizer as condições abaixo:

R > 95
G > 40
B > 20
max {R, G, B} − min {R, G, B} > 15
|R − G| > 15
R>G
R>B

Resultado da segmentação:



Espaço de cores YCbCr:

Um pixel pertence a pele se satisfizer as condições abaixo:

77 ≤ Cb ≤ 127
133 ≤ Cr ≤ 173

Resultado da segmentação:



Espaço de cores HSV:

Um pixel pertence a pele se satisfizer as condições abaixo:

0° ≤ H ≤ 50°
0, 23 ≤ S ≤ 0, 68

Resultado da segmentação:


Antes que alguém saia por aí dizendo que um método é melhor que outro, eu digo que depende da imagem a ser segmentada.

Os algoritmos apresentados são muito dependentes da iluminação do ambiente.

Para fechar, seguem os códigos do Scilab para segmentar imagens conforme apresentado.

/////////////////////////////////////////////////////////////////////////////////////////
// Algoritmos de segmentacao de pele em imagens baseados em limiarizacao
// Universidade Federal do Ceara
// Eng. Alex
//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//*//

//// parametros das imagens

Y = 2;
Cb = 1;
Cr = 3;

H = 1;
S = 2;
V = 3;

nL = 480; // numero de linhas da imagem
nC = 640; // numero de colunas da imagem


img = im2double(imread("imagem.jpg"));

////////////////////////////////////////
//parametros em RGB //
//////////////////////////////////////

img_s = zeros(nL, nC);

for l = 1:nL,
for c = 1:nC,
p = img(l,c,:);

ps = (p(1)>95/255).*(p(2)>40/255).*(p(3)>20/255).*(max(p) - min(p)>15/255).*(abs(p(1) - p(2))>15/255).*(p(1)==max(p));
img_s(l,c) = ps;
end;
end;

imwrite(img_s, "rgb-imagem.jpg");

///////////////////////////////////
//limiares em CbCr //
/////////////////////////////////

imgYCbCr = rgb2ycbcr(img);

img_s = double(((imgYCbCr(:,:,Cb)>76/255) .* (imgYCbCr(:,:,Cb)<128/255)).*((imgycbcr(:,:,cr)>132/255) .* (imgYCbCr(:,:,Cr)<174/255)));

imwrite(img_s, "cbcr-imagem.jpg");

///////////////////////////////
//limiares em HS //
/////////////////////////////

imgHSV = rgb2hsv(img);

img_s = double((imgHSV(:,:,H)<50/360).*((imghsv(:,:,s)>0.23) .* (imgHSV(:,:,S)<0.68)));

imwrite(img_s, "hs-imagem.jpg");

Qualification

I was told that I have 1 month to complete my mastering qualification.

Thus, I can't make posts frequently until the next month.

But, I want to thank to readers who visited the MultiSign (yesterday I had 37 visits, see here). I'm very happy too because I saw the first place with more than 10 visits out of Brazil and Portugual, look the picture.


See the west of United States (the left side).

So, it's all.

Qualificação

Esta semana eu descobri que tenho 1 mês para preparar toda a minha qualificação de mestrado.

Por isto eu não poderei manter o MultiSign atualizado com frequência.

Eu agradeço aos leitores que lêem o blog com frequência (ontem mesmo tive 37 visitas, olhem aqui) e algo que me deixou muito satisfeito foi o primeiro ponto com mais de 10 visitas fora do Brasil e Portugual, conforme a figura abaixo.


Olhem o oeste (lado esquerdo) dos Estados Unidos.

Enfim, é só isso mesmo.

Neural Segmentation of Hands

I developed an algorithm for segmentation of objects in digital images.

I maked this algorithm because I will need do segmentation of hand in my mastering project.

This a video whose I do for show the result.



The algorithm consists in build 2 clusters, the first for mapping the object and the second for mapping the ground.

I used Self-Organizing Maps for build the clusters.

I wrote the code in Scilab, using the SIVP toolbox.

Momentos centrados

Este é o primeiro post que faço sobre minhas pesquisas acerca do meu mestrado.

Para refrescar a memória dos que já sabem do que se trata o meu mestrado e para informar os leitores que vieram depois que parei de escrever sobre estas pesquisas:

Meu projeto de mestrado consiste em desenvolver um sistema de reconhecimento automático da Libras (Língua de Sinais Brasileira).

Este projeto tem as seguintes etapas:

1. Aquisição da(s) imagem(ns) por uma webcam;
2. Segmentação do objeto de interesse (mão);
3. Extração de atributos da imagem;
4. Classificação da imagem de acordo com os atributos.

Pois bem, como já coloquei em posts anteriores, a parte da segmentação está funcionando bem e eu já tenho os classificadores implementados (fiz-os na disciplina de reconhecimento de padrões).

Agora faltava apenas a parte de extração de atributos, mas eu estava estudando o livro de reconhecimento de padrões adotado na disciplina (quem quiser saber qual é o livro, pode pedir em comentário(s)) e vi algo sobre momentos centrados, e vi também que estes momentos são atributos extraídos dos objetos presentes em imagens para classificá-los.

Por fim, achei que seria interessante falar sobre os momentos centrados.

Os momentos centrados são provenientes da mecância clássica, pois consistem em momentos baseados no centro de massa dos corpos (objetos).

A equação abaixo mostra como são calculados os momentos centrados:
Em que f(x,y) é a imagem. Os termos p e q são ordens do momento, como fazemos em estatística nos momentos de 1ª (média), 2ª (variância), 3ª (curtosis), 4ª, etc.... ordem; podemos observar que estes momentos podem ser escritos até como termos de esperança matemática (olhe aqui).

Os centros de massa dos objetos (corpos) são dados pela equação abaixo:
Estes momentos centrados são descritores muito úteis, pois são invariantes a translação dos objetos, porém, observa-se que estes momentos são dependentes à rotação.

Para tornar obter descritores indendentes tanto a translação e a rotação, um pesquisador chamado M. Hu propôs as seguintes combinações dos momentos, gerando novas grandezas:


Com isto fecho o que espero ser pelo menos o material para minha qualificação de mestrado.

Morfologia matemática no OpenCV

Eu já fiz um post sobre morfologia matemática, em que abordava aspectos teóricos desta técnica.
Neste post, gostaria de apresentar as funções do OpenCV que implementam a questão do elemento estruturante e as operações morfológicas de erosão e dilatação.

Primeiramente a função que cria o elemento estruturante:

IplConvKernel* cvCreateStructuringElementEx( int cols,
                                            int rows,
                                            int anchor_x,
                                            int anchor_y,
                                            int shape,
                                            int* values=NULL );

cols: Número de colunas no elemento estruturante

rows: Número de linhas no elemento estruturante

anchor_x: Offset horizontal relativo do ponto de âncora, normalmente igual a 0 (zero)

anchor_y: Offset vertical relativo do ponto de âncora, normalmente igual a 0 (zero)

shape: Tipo de elemento estruturante, possíveis valores:

• CV_SHAPE_RECT, elemento retangular;
• CV_SHAPE_CROSS, elemento em disco;
  
• CV_SHAPE_ELLIPSE, elemento eliptico;
• CV_SHAPE_CUSTOM, elemento definido pelo usuário. Neste caso, o parâmetro values especifica a máscara, delimitando a vizinhança do pixel considerado.
  

values: Ponteiro para um elemento estruturante definido pelo usuário, este parâmetro é usado apenas quando shape =CV_SHAPE_CUSTOM.

Função de erosão

void cvErode( const CvArr* src, CvArr* dst,
             IplConvKernel* element=NULL, int iterations=1 );

Função de dilatação

void cvDilate( const CvArr* src, CvArr* dst,
              IplConvKernel* element=NULL, int iterations=1 );

src: Imagem original;

dst: Imagem de destino;

element: Elemento estruturante usado. Se for NULL, é definido um retângulo de 3x3;

iterations: Número vezes que a operação é aplicada.

As interfaces para desenvolvimento em Python é a mesma, com a vantagem que todas as funções são implementadas em C, o que torna a execussão da função extremamente rápida.

Fonte das informações: http://www.comp.leeds.ac.uk/vision/opencv/opencvref_cv.html

Qt Designer

Ontem comecei a estudar a criação de GUI's usando Qt e descobri uma ferramenta muito interessante: Qt Designer.Tela do Qt Designer com uma simples interface em desenvolvimento.

Além de elaborar o layout, o Qt Designer também é capaz de associar eventos a ações, por exemplo clicar em um botão e fechar a aplicação ou atualizar uma imagem (ou qualquer outro componente da tela).

Após fazer toda a interface, é gerado um arquivo nome_do_arquivo.ui e este pode ser convertido para um arquivo em python com o seguinte comando: pyuic nome_do_arquivo.ui > nome_do_arquivo.py e assim obter uma classe com todos os elementos e conexões entre os componentes para a aplicação.

Obs.: o Qt Designer pode ser baixado via apt-get ou qualquer sistema de gerenciamento de pacotes (synaptic, adept, yast, yum, etc.......)

Meu próximo passo é fazer a imagem da webcam aparecer em uma QImage ou QFrame ao clicar de um botão, ontem mesmo descobri que Qt tem algumas interfaces com elementos da biblioteca PIL (Python Imaging Library).

Migração do SIRENE

Essa semana eu comecei a traduzir o SIRENE para python.
Por enquanto, estou com a segmentação da pele pronta, mas ainda não validei.

As bibliotecas não nativas que estou usando: numpy, scipy e OpenCV.

A questão agora é como exibir os resultados, se usarei alguma biblioteca tipo Qt ou Tkinter, ou se usarei apenas as interfaces do OpenCV, que são interessantes também.

O ambiente de desenvolvimento que estou usando é o KDevelop.

Informações sobre o jogo "controle a bolinha com as mãos"

Este jogo foi um "sub-projeto" que apareceu com o andamento do SIRENE.
O objetivo do jogo é apenas não permitir que a bolinha chegue nas bordas da tela.
Como os leitores devem imaginar, fiz este protótipo no Scilab (detalhe: acho que não demorei 6 horas de implementação, pois já tinha as idéias em mente, e comecei tudo do zero), então pude ter um alto desempenho no desenvolvimento do programa, porém a execussão do mesmo fica comprometida.

O Scilab é um ambiente de simulação, muito indicado para o desenvolvimento de algoritmos de forma rápida, porém a execussão do programa é muito lenta.

No FISL irei fazer uma apresentação informal deste programa, porém não pretendo disponibilizá-lo antes de ver como fazer para colocá-lo sob as condições da GNU-GPL.

Segmentação neural com 3 neurônios

Nos últimos dias eu estive avaliando a segmentação usando a rede de Kohonen. Fiz algumas experiências com relação aos atributos, codificações de cor, quantidade de neurônios e outras coisas.
Nas figuras a seguir apresento resultados obtidos com 3 neurônios, em que cada cor representa os pontos pertencentes a um dado neurônio após o treinamento da rede.

Imagem 1.

Imagem 2.

Imagem 3.

Imagem 4.

Imagem 5.

Nas imagens 2 e 5 a rede não conseguiu segmentar a mão, porém em todas as outras observa-se que a mão ficou bem evidenciada na imagem segmentada.
Nestes casos, a codificação de cor usada foi RGB.

Segmentação neural das mãos

Ontem eu fechei um algoritmo de segmentação de pele usando uma rede neural muito interessante: a rede SOM.

Segue o vídeo que fiz.


Neste caso, basta separar o espaço de cores em 2 clusters: fundo e objeto. O que mais chama a atenção é a fase inicial em que observa-se a aprendizagem da rede.

Inserção de novas técnicas

Como a segmentação das mãos por limiarização não estava fornecendo resultados satisfatórios em casos suficientes, decidi por usar outras técnicas conjuntamente a limiarização.

A idéia que surgiu foi usar contornos ativos (snakes) para segmentar as mãos.

Neste caso surge alguns problemas:

1. determinar um ponto que pertença a mão para inicializar o algoritmo;
2. descobrir se existe alguma toolbox (ou similar) para o Scilab que faça a implementação do algoritmo;
3. o tempo de estudo, pois não conheço a fundo o algoritmo.

Pelo que tenho de conhecimento, Snakes tem um custo computacional elevado, então a otimização do código será crucial.

Segundo o que sei a respeito, Snakes é semelhante aos mapas de Kohonen (que eu tenho uma experiência considerável) em que os dados (neste caso, a imagem) guia a organização da estrutura, como na figura abaixo (fonte: http://www.uib.no/med/avd/miapr/arvid/MOD3_2002/Konturdeteksjon/)


Enfim, este fim de semana devo iniciar os estudos sobre os contornos ativos.