Interface Homem-Máquina Através do Movimento dos - Cefet-MG

1005
Interface Homem-Máquina Através do
Movimento dos Olhos
Gabriel de Oliveira Machado, Larissa Ferreira do Carmo, Thaís de Souza Marins, Jeronimo Costa
Penha (Orientador), Maicon Stihler (Coorientador)
Centro Federal de Educação Tecnológica de Minas Gerais – Unidade Leopoldina, Leopoldina - MG

Resumo – Com o aumento do número de sistemas
computacionais presentes no cotidiano e a necessidade do
aumento da acessibilidade para pessoas com necessidades
especiais, vários dispositivos que visam a melhoria da utilização
destes sistemas vêm sendo criados, tais como telas sensíveis ao
toque e sistemas que reconhecem comandos de voz. No entanto, a
maioria destas tecnologias possui um custo elevado e algumas
dificuldades na sua utilização, o que impede que sejam
produzidas em grande escala. O objetivo deste trabalho é
desenvolver um dispositivo de entrada capaz de detectar a
direção dos olhos através de uma câmera de vídeo, com o objetivo
de controlar diversos tipos de sistemas. O processo de tratamento
das imagens coletadas é feito por meio de algoritmos
disponibilizados pela biblioteca OpenCV, enquanto a
classificação destas é realizada por uma rede neural, de forma a
evitar o uso de algoritmos mais complexos e que exijam uma
maior capacidade de processamento. Observa-se ainda que este
dispositivo deva possuir baixo custo e apresentar uma interface
para uma fácil implementação em sistemas já existentes.
Palavras Chave: Visão Computacional; Redes Neurais;
Automação;
I. INTRODUÇÃO
N
os últimos anos, houve um grande aumento no número
de novas tecnologias que visam a melhoria da utilização
dos sistemas computacionais em geral, com a criação de
vários dispositivos de entrada e saída, tais como telas sensíveis
ao toque, óculos de realidade virtual, reconhecimento de voz,
dentre outros. Com isso, várias destas tecnologias vêm sendo
utilizadas para proporcionar uma maior acessibilidade,
visando a integração de pessoas com determinadas
necessidades especiais.
No entanto, a maioria das tecnologias que facilitam a
utilização de sistemas computacionais possuem um custo
muito elevado, o que impossibilita a implementação em
grande escala destas. Outro fator que impede a utilização
destas tecnologias é a dificuldade na sua implementação
(BAUER, 2005), uma vez que seriam necessárias várias
modificações em aparelhos e sistemas já existentes, o que
acaba gerando mais custos e desmotivando os responsáveis
por estabelecimentos a realizar tal implementação.
Uma característica importante para este trabalho é a
utilização de método não intrusivo para a coleta de dados,
permitindo maior facilidade para a utilização do dispositivo a
ser desenvolvido. O método adotado é a captura e análise de
imagens, que pode ser feita a distância por meio de uma
câmera de vídeo simples, fato que evita um alto custo para o
projeto como um todo.
É interessante notar que a interface a ser criada não deve
compreender apenas um conjunto de dispositivos, e sim
qualquer sistema que possa ser controlado por meio de
dispositivos de entrada comuns. Desta forma, pretende-se
aumentar o número de possíveis utilizações de tal interface,
sendo assim possível atingir o maior número de pessoas.
II. OBJETIVO E QUESTÃO PROBLEMA
Apresentadas as características do cenário atual,
compreende-se a necessidade do desenvolvimento de
tecnologias que, além de proporcionarem uma maior
acessibilidade, sejam de baixo custo e fácil implementação,
visando alcançar o maior número de pessoas (BAUER, 2005).
Tendo isso em vista, decidiu-se criar um dispositivo de
entrada para sistemas computacionais baseada apenas no
movimento executado pelos olhos, de forma a permitir a quase
qualquer pessoa o operar, possuindo ou não necessidades
especiais.
O objetivo deste projeto é desenvolver um dispositivo de
entrada para sistemas computacionais em geral utilizando a
detecção da direção do olhar, de forma a permitir o uso destes
últimos de forma mais fácil e intuitiva, possibilitando ainda
que pessoas com graves dificuldades motoras operem tais
sistemas sem qualquer auxílio externo. O referido dispositivo
deve possuir baixo custo e fácil implementação em qualquer
sistema, ou seja, ser compatível com as tecnologias já
existentes.
Em vista da restrição de custo do sistema e, com isso, da
capacidade de processamento do mesmo, optou-se por utilizar
redes neurais, que são um modelo matemático relativamente
simples e de processamento extremamente rápido.
Um ponto que vale ser ressaltado é a necessidade do
sistema de ser o mais geral o possível, de forma a garantir que
uma maior variedade de futuras aplicações venham a ser
desenvolvidas para o mesmo. Assim, como será melhor
esclarecido, o foco deste trabalho é a criação da interface
1005
homem-máquina capaz de interpretar a imagem do usuário e
apresentar como saída a direção na qual este está olhando de
uma forma que possa ser interpretada por sistemas
computacionais e, desta forma, permita aos usuários exercer
controle sobre uma série de aplicações.
principais processos, sendo eles o tratamento de imagens, a
comunicação entre os programas, a coleta de amostras e o
processamento pela RNA, como é mostrado de forma
simplificada pela Figura 2.
III. DESCRIÇÃO DE MATEIRIAS E MÉTODOS
Para o desenvolvimento de um sistema que seja capaz de
ser utilizado como interface dentro dos requisitos já descritos,
são necessários uma série de processos, que incluem desde a
captura de dados do usuário até a execução da tarefa
propriamente dita. Inicialmente, os processos necessários
foram divididos em dois grandes grupos, sendo estes o
controle e o acionamento, como pode ser observado na Figura
1.
Figura 2: Esquema representativo dos processos necessários.
Fonte: Arquivo do projeto
Figura 1: Representação da arquitetura geral do sistema.
Fonte: Arquivo do projeto
Em geral, os processos de controle são responsáveis por
realizar o processamento das entradas e apresentar como saída
a interpretação dos dados recebidos, que, neste caso, indicará a
direção na qual o usuário está olhando. Os processos de
acionamento são responsáveis por executar a ação pretendida
pelo usuário efetivamente, independente de qual o tipo desta
(física ou virtual). Por estar relacionada com as possíveis
aplicações, a parte de acionamento não será aprofundada, visto
que o objetivo deste trabalho é estabelecer uma interface geral,
que possa ser utilizada em diversos tipos de aplicações.
Vale ressaltar ainda que a decisão de realizar tal divisão de
tarefas, além de aumentar a segurança do sistema, como um
todo, impedindo que uma falha grave em uma das partes afete
a outra, também possibilita que qualquer uma das partes seja
substituída por outra que execute função similar, sem que
sejam necessárias maiores alterações no sistema. Isso significa
dizer que pode existir mais de um dispositivo capaz de realizar
as funções de controle, assim como podem existir diversos
dispositivos de acionamento para executar diferentes funções.
A. Metodologia para a obtenção das saídas
Para que, partindo da captura da imagem do usuário,
obtenha-se a direção na qual este está olhando, é necessária
uma série de processos com diferentes níveis de complexidade
e de igual importância para o funcionamento do sistema. Em
linhas gerais, são utilizadas técnicas de visão computacional
para que se faça o processamento inicial da imagem capturada
e, em seguida, essa imagem é usada como entrada para uma
RNA (Rede Neural Artificial). Pode-se identificar quatro
O primeiro passo para o funcionamento do sistema é a
obtenção e tratamento das imagens obtidas da câmera de
vídeo. A princípio, tal captura é feita com a resolução máxima
da câmera, em cores (se disponível), e então convertida para
escala de cinza, onde cada pixel da imagem é representado por
um byte, que representa a intensidade do cinza naquele ponto.
Só então a imagem é submetida à função da biblioteca para a
detecção dos olhos presentes na imagem. Essa detecção é
realizada através do método HAAR Cascade, que é capaz de
detectar formas características em uma imagem, tais como
faces, olhos, dentre outras, realizando comparações com
modelos
pré-definidos
pela
biblioteca
OpenCV
(KOMOGORTSEV, 2010).
Após a execução do algoritmo, um vetor com os retângulos
que representam os olhos encontrados na imagem é obtido. A
partir de tais formas é possível fazer os tratamentos
necessários para que se obtenha apenas a imagem do olho. O
primeiro dos tratamentos é o corte da imagem delimitada pelo
retângulo. Observe ainda que é necessário selecionar qual dos
olhos será utilizado, caso haja mais de um presente na
imagem, podendo essa escolha ser realizada de várias formas.
Atualmente, o algoritmo opta pelo olho que se localize mais à
direita (mais à esquerda na imagem).
Uma vez obtida a imagem do primeiro corte, é necessário
realizar outra redução na imagem obtida. Desta vez, o corte é
ajustável por meio de parâmetros definidos em tempo de
compilação, e visa remover partes irrelevantes da imagem do
olho, uma vez que a captura inicial engloba regiões acima e
abaixo do olho do usuário do sistema.
Por fim, a imagem deve ser redimensionada para que seja
processada pela rede neural da forma mais rápida possível.
Essa redução é essencialmente importante, dado que, quanto
maior o número de entradas de uma rede neural, maior o
número de neurônios necessários para que se faça o
processamento destas (SILVA, 2010), e, com isso, maior o
tempo gasto para tal processamento, uma vez que um dos
pontos críticos para o sistema aqui apresentado é a capacidade
1005
de processamento limitada. Deve-se considerar ainda que esta
redução da resolução da imagem não deve ser muito grande,
de forma que não reduza a precisão do sistema ou
impossibilite o funcionamento do mesmo.
Faz-se então uma comunicação entre o programa que
realiza a captura e tratamento de imagens, e os programas que
fazem a utilização de dados. Caso consiga estabelecer a
ligação entre o socket e o programa responsável pela análise
de imagens, o programa executa sua parte de captura e
treinamento de imagem e aguardará o recebimento do byte de
confirmação de envio. Para que o frame seja enviado, este
byte deve ter o valor zero, do contrário o programa finalizará
sua execução.
Enquanto todo esse processo é realizado, os programas,
desenvolvidos em Java, que utilizam os dados, ficam à espera.
No momento que recebe o retorno do outro programa inicia-se
o processamento dos dados.
Para a coleta e armazenamento de amostras foi
desenvolvido um programa em linguagem Java. A coleta
acontece quando é solicitado ao usuário que olhe para uma
direção específica, neste momento é recolhido um número de
amostras ajustável. No final de cada frame é colocado um byte
que indica a direção representada por tal, a afim de que o
programa que executa a rede neural possa interpretá-las.
Após isso as amostras são embaralhadas e salvas em um
arquivo de texto, para que possa ser utilizada pelo programa
encarregado do processamento das mesmas. Programa este
que diferencia as entradas, os bytes que representam a
imagem, e as saídas da RNA, bytes que representam as
direções, que no caso atual são os N últimos bytes das
amostras, sendo N é o número de neurônios de saída da rede.
Uma vez que os dados necessários para o treinamento
estejam devidamente armazenados em um arquivo próprio, é
possível criar a rede neural e iniciar o seu treinamento. Para a
criação da rede, são utilizadas as informações definidas via
código (número de neurônios na camada de entrada e o tipo
dos neurônios) e as informações obtidas do arquivo contendo
as amostras para treinamento (número de neurônios na camada
de saída). Feito isso, o arquivo é lido para que se obtenha as
amostras para treino, que são carregadas para um vetor e
passados como parâmetro para a função de treinamento da
rede neural.
Após o treinamento, os pesos sinápticos dos neurônios da
rede treinada são gravados em um arquivo de texto com um
formato específico (armazenando dados das camadas), de
forma que o programa possa, em execuções posteriores,
reconstruir a rede neural. Desta forma, o treinamento realizado
não é perdido, e é apenas necessário carregar os valores dos
pesos sinápticos para que a rede possa iniciar o
funcionamento.
Uma vez que os pesos tenham sido devidamente carregados,
a execução do programa principal se baseia em um laço de
repetição no qual é feita a requisição do frame de vídeo,
recebimento dos dados, passagem de tais dados como
parâmetro para a rede neural através de um método, que
retorna as saídas da mesma. Em outra versão do código, é
definida uma função para que se faça a requisição e análise de
apenas um frame. Por meio desta função, é possível realizar a
implementação em diversas aplicações desenvolvidas na
linguagem Java, tal como a interface gráfica do sistema, que
permite visualizar as saídas do sistema de forma mais clara.
B. Tecnologias aplicadas
Para que seja possível a implementação da metodologia
apresentada, é necessária a utilização de várias tecnologias
diferentes. Sendo assim, é válido apresentar melhor cada uma
e a forma como é aplicada no sistema para que fique clara sua
necessidade.
A primeira e talvez mais crucial tecnologia aplicada são as
Redes Neurais Artificiais. Uma RNA pode ser definida como
um modelo matemático que tem como inspiração os
neurônios, células nervosas presentes nos seres vivos
inteligentes, responsáveis por permitir o processamento dos
impulsos recebidos do mundo exterior, possibilitando uma
tomada de decisão com relação a estes, assim como na forma
como estes neurônios estão conectados entre si.
Desta forma, assim como uma rede neural existente em um
ser vivo, as redes neurais artificiais são capazes de adquirir
conhecimento através da experiência. No caso das RNAs, o
processo de adquirir conhecimento se dá através de um
treinamento realizado para que a rede passa a reconhecer
determinado padrão.
Cada neurônio é responsável por receber um número de
entradas e realizar a soma algébrica destas, uma vez
multiplicadas pelo seu respectivo peso sináptico. Estes pesos
sinápticos são os responsáveis por permitir que a rede se
adapte e reconheça novos padrões. Em seguida, o resultado
dessa soma é aplicado à função de ativação, que dará a saída
daquele neurônio para as entradas aplicadas. A representação
de um neurônio é apresentada pela Figura 3
Figura 3.
Figura 3: Representação de um neurônio artificial. Fonte:
(SILVA, 2010).
Desta forma, a soma das entradas pode ser representada
pela equação (1), sendo este valor aplicado na equação (2)
para que se obtenha a saída do neurônio, onde f é a função de
ativação do neurônio.
(1)
1005
Onde uk é o valor da soma das entradas do neurônio k, m é o
número de entradas, wkj é o peso da entrada j do neurônio k e
xj é o valor da entrada j (HAYKIN, 2005).
(2)
Onde yk é a saída do neurônio k e bk é o valor do BIAS já
multiplicado pelo seu peso. Como, usualmente, o valor do
BIAS é definido como 1 (ou ainda -1), bk assume o valor de
seu peso (wk0) (HAYKIN, 2005).
Neste projeto, o tipo de rede utilizada é a Perceptron
Multicamadas, que conta com neurônios que possuem a
função de ativação (f) a degrau, definida pela equação (3).
(3)
Nesta arquitetura de RNA os neurônios são dispostos em
múltiplas camadas, de forma que as saídas dos neurônios de
uma dada camada servem de entrada para os neurônios da
camada posterior, conforme pode ser visualizado na Figura 4.
Figura 4: Representação geral das
Multicamadas. Fonte: (SILVA, 2010).
redes
Perceptron
Para realizar o treinamento da RNA, isto é, definir os pesos
sinápticos dos neurônios de forma que esta apresente as saídas
desejadas para um determinado conjunto de entradas, utilizase o algoritmo Backpropagation que, de forma geral, aplica
uma correção nos pesos sinápticos dos neurônios através da
retro propagação do erro, isto é, atribuindo a cada um a
responsabilidade pelo erro apresentado na saída, partindo da
camada de saída até a primeira camada de neurônios.
Outra tecnologia de igual importância trata da visão
computacional, mais especificamente representada pela
biblioteca OpenCV. Tal biblioteca, desenvolvida pela Intel em
2000, permite manipulação de dados de imagens, manipulação
de matrizes e vetores, desenvolvimento de rotinas de álgebra
linear, estruturas de dados dinâmicas, desenvolvimento de
algoritmos de processamento de imagem, análise estrutural,
calibração de câmera, análise de movimento (tracking),
reconhecimento de objetos, GUI Básica, e rotulagem de
imagem. Sua principal vantagem é o fato de poder ser usada
para programar em várias plataformas, como C/C++, Python,
Visual Basic, Ruby, permitindo uma integração mais fácil com
outros programas, evitando problemas de integração e
facilitando no caso de desenvolvimento de softwares
embarcados.
Os processos de visão computacional, muitas vezes,
necessitam de uma etapa de pré-processamento envolvendo o
processamento de imagens. As imagens de onde queremos
extrair alguma informação em alguns casos precisam ser
convertidas para um determinado formato ou tamanho e
precisam ainda ser filtradas para remover ruídos provenientes
do processo de aquisição da imagem.
Os ruídos podem aparecer de diversas fontes, como por
exemplo, o tipo de sensor utilizado, a iluminação do ambiente,
as condições climáticas no momento da aquisição da imagem,
a posição relativa entre o objeto de interesse e a câmera. Os
filtros são as ferramentas básicas para remover ruídos de
imagens, neste caso, o ruído é aquele que aparece no processo
de aquisição da imagem.
Embora tenham sido utilizadas diversas linguagens de
programação durante o desenvolvimento deste projeto, devese destacar o uso da linguagem Java, levando em conta que se
trata de uma tecnologia bem estruturada. A tecnologia Java é
usada para desenvolver aplicativos para uma ampla variedade
de ambientes, de dispositivos consumidores a sistemas
corporativos heterogêneos. Como qualquer linguagem de
programação, a linguagem Java tem sua própria estrutura,
regras de sintaxe e paradigma de programação. O paradigma
de programação da linguagem Java baseia-se no conceito de
OOP (Programação Orientada a Objetos), que os recursos da
linguagem suportam. Estruturalmente, a linguagem Java
começa com pacotes, que são mecanismos de namespace da
linguagem Java. Dentro deles estão as classes e dentro das
classes estão métodos, variáveis, constantes e mais.
Quando se programa na plataforma Java, o código-fonte é
escrito em arquivos .java e depois são compilados. O
compilador verifica o código nas regras de sintaxe da
linguagem e depois grava bytecode, conjunto de instruções
destinadas a executar em uma Java Virtual Machine (JVM),
em arquivos .class. A JVM é uma parte do software escrita
especificamente para uma determinada plataforma.
No tempo de execução, a JVM lê e interpreta arquivos
.class e executa as instruções do programa na plataforma de
hardware nativa para qual a JVM foi escrita. A JVM interpreta
o bytecode como uma CPU interpretaria instruções de
linguagem assembly. Desta forma, não é necessário recompilar
o mesmo projeto para cada sistema operacional, basta que este
sistema possua a JVM instalada. Isso garante que o sistema
poderá ser executado em uma série de diferentes sistemas
operacionais sem que haja maiores problemas de
compatibilidade.
C. Desenvolvimento do sistema
Uma vez apresentados os processos pelos quais o sistema
deve executar sua função, assim como as tecnologias que
serão aplicadas na implementação deste propriamente dita,
devemos definir como cada uma das tarefas será executada
dentro do sistema. Para garantir uma melhor performance,
capacidade de alteração da arquitetura e em função de algumas
limitações físicas, o sistema é composto de vários programas
distintos, com tarefas específicas, que se comunicam de forma
a se comportarem como um único programa.
1005
O primeiro passo para o funcionamento do sistema é a
captura e o devido tratamento das imagens através de uma
câmera de vídeo, o que realizado pela biblioteca OpenCV para
a linguagem C++, como já citado. Tal biblioteca define um
tipo próprio para o armazenamento de imagens, que se
assemelha a uma matriz multidimensional. As funcionalidades
disponíveis são acessíveis por meio de funções também
definidas. Sendo assim, foi desenvolvido um programa que faz
uso de todas as funções necessárias para executar o tratamento
sobre a imagem do usuário. Por não ser desenvolvido na
linguagem Java, diferentemente da maioria do sistema, este
módulo é composto de um executável independente, que se
comunica através do protocolo TCP com o programa principal.
De forma feral, o programa é responsável por capturar a
imagem da câmera de vídeo e apresentar como saída os bytes
que compõem apenas a imagem do olho direito do usuário
(caso ambos os olhos estejam visíveis), já transformada em
escala de cinza. É interessante notar que não há necessidade de
especificar a câmera que será utilizada, caso o sistema possua
mais de uma, ou caso esta seja substituída por outra, pois o
método de captura procura escolher aquela definida por
padrão. Além disso, não é necessário que a câmera possua
uma resolução muito alta, não havendo grandes alterações no
funcionamento em caso de troca da mesma por outra similar.
Embora tenhamos citado apenas a comunicação entre o
programa que realiza a captura de imagens e o que realiza o
processamento da RNA, existem outros programas que
compõem o sistema e que necessitam obter dados deste
primeiro. Sendo assim, para que o programa que faz o
tratamento da imagem possa se comunicar com os demais, foi
estabelecido um protocolo de comunicação entre os dois
programas, isto é, o que realiza a captura e o tratamento de
imagens e o que fará uso dos dados de tais imagens. Essa
forma de comunicação não é só necessária pelo uso de
linguagens diferentes nos programas que compõem o sistema,
mas também possibilita que exista um dispositivo apenas para
a captura e tratamento das imagens, enquanto outro dispositivo
realiza o processamento da RNA.
A estrutura do programa que faz a captura das imagens foi,
visando definir o protocolo de comunicação, definida de forma
que este apenas realize o processamento do próximo frame de
vídeo caso lhe seja requisitado. Para tanto, este fica à espera
do recebimento de um byte. Caso o byte recebido tenha valor
0, o programa procede com a captura do frame de vídeo. Caso
o valor seja diferente de 0, o programa é encerrado. Ao
terminar o tratamento das imagens, o programa envia os dados
pelo socket aberto ao programa que fez a requisição.
Para que a rede neural possa realizar seu treinamento, é
necessário que se obtenha amostras dos possíveis casos a
serem identificados. Sendo assim, foi desenvolvido um
programa, utilizando-se a linguagem JAVA, com o objetivo de
realizar a coleta das amostras necessárias e armazená-las, de
forma que o programa que processa a RNA possa fazer uso
dessas amostras para o treinamento da rede. Basicamente, o
programa pede ao usuário que olhe para uma das direções
possíveis (esquerda, direita, cima, baixo ou centro) e então
realiza sucessivas capturas através do programa de captura,
enviando o byte 0 e aguardando até que exista o número
determinado (o número de entradas para a RNA) de bytes
disponíveis para a leitura no buffer do socket. Então o
processo é repetido para todas as direções definidas,
armazenando todos as amostras coletadas em uma sequência
de vetores, adicionando N bytes ao final de cada um, onde N é
o número se saídas da rede neural, indicando a saída esperada
para as entradas neste vetor.
Por fim, o processamento por parte da RNA deve ocorrer
em duas fases, sendo a primeira de treinamento e a segunda de
execução. Estes dos procedimentos ocorrem em uma mesma
aplicação. No entanto, foi desenvolvida uma versão do
programa que apenas executa a RNA. Essa versão visa
dispositivos que não poderão realizar o treinamento, em
função de sua baixa capacidade de processamento.
Para uma melhor estruturação e desenvolvimento, a
implementação da RNA foi realizada na linguagem Java,
através da criação de três classes básicas: Neurônio, Camada e
Rede. Cada classe armazena as informações da estrutura que
representa e possui a implementação das funções que devem
ser desempenhadas pela mesma através de métodos. Desta
forma, a classe Camada faz uso da camada Neurônio e a classe
Rede faz uso da classe Camada para desempenhar suas
funções.
O treinamento da RNA é realizado antes do início do
funcionamento do sistema em si, uma vez que é necessário
utilizar vários conjuntos de amostras para que se faça o
treinamento, e não apenas do usuário do sistema. Isso é
necessário para que a identificação seja a mais geral possível,
sendo funcional com o maior número de pessoas. Caso a rede
seja treinada com apenas uma pessoa, é possível que esta não
reconheça corretamente a direção em que outra pessoa está
olhando. Neste caso, a rede apenas decora as posições para
uma determinada pessoa e não aprende de fato a reconhecer a
direção em que uma pessoa está olhando (SILVA, 2010).
Como esta é a parte mais que demanda maior número de
cálculos, é necessária a execução em um sistema com grande
capacidade de processamento, tal como um computador
pessoal de médio porte. Desta forma, faz-se essencial que o
sistema seja configurado previamente com a rede treinada, e,
em função disso, que a rede seja capaz de realizar o
reconhecimento com o maior número de pessoas possível.
Como forma de contornar essa necessidade de processamento,
foi adicionada uma funcionalidade que possibilita ao usuário
realizar um treinamento específico para o mesmo, caso o
sistema não o reconheça corretamente. Este último tipo de
treinamento possui maior velocidade por utilizar um menor
números de neurônios na RNA, visto que não é necessário
processar uma quantidade grande de amostras, apenas as do
usuário.
Uma vez que a RNA esteja devidamente treinada, basta
realizar uma chamada ao método de execução passando o
vetor que representa a imagem do olho do usuário para que
este retorne a direção identificada. Embora na prática seja
utilizada apenas uma direção, é possível que seja identificada
mais de uma (como cima e esquerda simultaneamente), o que
geralmente ocorre se o usuário olhar em uma direção
intermediária, entre as duas identificadas.
IV. RESULTADOS E DISCUSSÃO DOS RESULTADOS
Para melhor observar os resultados do funcionamento da
interface, foi desenvolvida uma interface gráfica, que
1005
apresenta a direção na qual o usuário está olhando de acordo
com a última leitura realizada. A interface em questão, em sua
versão de quatro posições, é apresentada pela Figura 5.
comunicar com a aplicação que processa a RNA através de
comunicação Serial, esteja a aplicação sendo executada em
qualquer tipo de hardware (computador pessoal ou Raspberry
Pi, por exemplo).
Foi ainda desenvolvida uma versão do sistema
especialmente para que fosse executada em um Raspberry Pi,
eliminando a necessidade do uso de um computador pessoal.
Neste caso, a interface apresentada anteriormente foi
substituída por um display de LED simples, que apresenta as
informações de forma simplificada, como mostrado na Figura
7.
Figura 5: Tela inicial da interface gráfica desenvolvida. Fonte:
Arquivo do projeto
Como é possível observar pela figura anterior, a interface já
está configurada para trabalhar com uma aplicação de
automação residencial, na qual o usuário seria capaz de
controlar, de forma básica, os dispositivos de sua casa, o que
inclui ações como ligar e desligar uma lâmpada ou controlar
seu aparelho de televisão. Para a operação desta aplicação, o
usuário deveria olhar para a esquerda ou direita para
selecionar o dispositivo que deseja controlar e então, olhando
para o quadrado inferior, seria capaz de alterar o estado em
que se encontra o dispositivo selecionado, executando a ação
que deseja.
Para proporcionar uma visualização ainda melhor da
aplicação de automação residencial, foi construída uma
representação física em escala reduzida de uma residência
comum, com diversos dispositivos instalados, sendo
representados por LEDs e motores, como mostra a Figura 6.
Figura 7: Display LCD em funcionamento. Fonte: Arquivo do
projeto
Embora tenha sido constatado que o Raspberry Pi é capaz
de controlar a aplicação, atuando como dispositivo para os
processos de controle, ficou claro que este apresenta uma
performance muito inferior ao do computador pessoal, isto é,
considerando a versão Raspberry Pi 1 Model B. Para uma
melhor performance, é recomendado o uso de versões mais
avançadas ou ainda de dispositivos similares, com maior
capacidade de processamento.
Complementarmente, foi desenvolvida um aplicação
simples, na linguagem Java, capaz de se comunicar com o
programa principal de controle do sistema, de forma a receber
a informação sobre a direção na qual o usuário está olhando e
a transformar em uma simulação de comando do teclado, mais
especificamente da tecla direcional (“setas”) correspondente
àquela direção. Esta aplicação permite ao usuário controlar, de
forma primitiva, seu computador pessoal, possibilitando
executar algumas ações básicas, como jogar um jogo simples,
por exemplo. Acredita-se que, com certo nível de adaptação
do ambiente do sistema operacional, seja possível realizar
tarefas mais complexas, tais como digitar através de um
teclado virtual e controlar o cursor do mouse.
V. CONCLUSÕES
Figura 6: Representação de residência desenvolvida. Fonte:
Arquivo do projeto
Neste caso, como dispositivo acionador da aplicação, foi
utilizado uma placa Arduino, previamente programada para se
Dados os objetivos estabelecidos e os requisitos para a
interface em questão, é possível afirmar que o sistema
desenvolvido pode ser utilizado por um usuário comum, se
consideradas as limitações gerais do sistema, tais como
disponibilidade de luz no ambiente e a eventual necessidade
de um novo treinamento no primeiro uso da interface.
Após a realização dos principais testes, foi possível ter uma
dimensão das dificuldades que impedem um maior
1005
aprimoramento da eficiência do sistema como um todo. Em
suma, é necessário estabelecer um equilíbrio entre uma RNA
mais geral, capaz de identificar vários usuários e, com isso,
demandar maior capacidade de processamento e perda de
eficiência para cada usuário individualmente, ou uma RNA
mais específica, que é capaz de identificar de forma muito
eficiente e utilizando poucos recursos computacionais, poucos
ou apenas um usuário.
Com estes resultados em mãos, é possível adequar a
capacidade de identificação de interface ao tipo de aplicação
para a qual se deseja utilizá-la, seja alterando o tamanho e
complexidade da RNA utilizada, ou ainda o número ou tipo de
amostras utilizadas no treinamento desta.
Por fim, ainda se faz necessário o desenvolvimento de
novas aplicações para serem utilizadas em conjunto com a
interface. Este desenvolvimento pode ainda, até certo ponto,
colaborar para o aprimoramento dos parâmetros utilizados no
sistema, uma vez que será possível observar melhor as
verdadeiras necessidades (como agilidade, precisão e
segurança) requeridas para uma interface deste tipo.
VI. REFERÊNCIAS
BALUJA, S; POMERLEAU, D. Non-Intrusive Gaze
Tracking Using Artificial Neural Networks. School of
Computer Science Carnegie Mellon University. Pittsburg, PA,
1994.
BARBOZA, D, P, S. Estudo da Biblioteca OpenCV.
Disponível em: < http://monografias.poli.ufrj.br/monografias/
monopoli10001999.pdf> Acesso: 18 de maio de 2016.
BAUER, S. M. Assistive technology Training Online
Project. University at Buffalo, Center for Assistive
Technology,
2005.
Disponível
em:
http://atto.buffalo.edu/registered/ATBasics/foundation/intro/int
rotrends.php. Acesso em: 04 abr. 2016.
HAYKIN, S. Neural Networks: A Comprehensive
Foundation. Pearson Prentice Hall, Singapura, 2005. 2°
edição.
IBM. Introdução à programação Java, Parte 1:
Fundamentos da linguagem Java. Disponível em:
http://www.ibm.com/developerworks/br/java/tutorials/jintrotojava1/. Acesso em: 16 mai. 2016.
JAVA. Obtenha informações sobre a Tecnologia Java.
Disponível em: <https://www.java.com/pt_BR/about/> Acesso
em: 16 mai. 2016.
KOMOGORTSEV, O; SEWELL, W. Real-Time Eye Gaze
Tracking With an Unmodified Commodity Webcam Employing
a Neural Network. Texas State University-San Marcos
Department of Computer Science. San Marcos, TX. ACM
Conference on Human Factors in Computing Systems 2010.
MARENGONI, M; STRINGHINI, D. Tutorial: Introdução
à Visão Computacional usando OpenCV. Disponível em:
<https://www.dropbox.com/s/em6e7jv6zavijrb/Tutorial%20Op
encv.pdf?dl=0+> Acesso em: 18 mai. 2016.
OPENCV. OpenCV Documentation. Disponível em:
http://docs.opencv.org/. Acesso em: 17 jan. 2016.
RASPBERRY.
Raspberry
Pi.
Disponível
em:
<https://www.usinainfo.com.br/raspberry-pi-395>. Acesso em
14 de maio de 2016.