DESENVOLVIMENTO DE UMA SIMULAÇÃO DO TESTE DE APTIDÃO
“BOX AND BLOCKS”
Relatório do Projeto 30/06/2017
José Guilherme Freitas Gomes Nº 2034613
Orientado por Drª Mónica Cameirão
Integrado no NeuRehabLab
1
Este relatório aborda todas as fases de desenvolvimento de um projeto final de Licenciatura de
Engenharia Informática, que teve como principal objetivo a simulação do teste “Box and
Blocks”, que por sua vez tem por objetivo a asserção da destreza manual do
paciente/indivíduo a ser testado.
É exposta a problemática presente no teste a ser simulado e a motivação da escolha do
hardware e projeto.
É apresentado todo o processo, desde o workshop de Unity, passando pelo estudo e
aprendizagem da ferramenta “Leap Motion” bem como o estudo do teste real, até a
implementação final.
É explicada toda a implementação. Funcionalidades, scripts e objetos têm a sua função e
disposição explicada.
Finalmente é feita a ponderação de todo o trabalho feito até agora. Vantagens e
desvantagens, dificuldades e barreiras no projeto e avaliação do cumprimento dos objetivos
serão discutidos, tendo em conta o estado presente do projeto.
2
Índice 1. Introdução....................................................................................................................3
2. Etapas de desenvolvimento ...........................................................................................4
a. Workshop de Unity .................................................................................................4
b. Leap Motion ...........................................................................................................4
c. Box and Blocks ........................................................................................................4
d. Mecânica principal ..................................................................................................5
e. Scripts e funções .....................................................................................................5
f. Design e GUI ...........................................................................................................5
3. Projeto .........................................................................................................................6
a. Scripts ....................................................................................................................8
i. Box Collision List.................................................................................................8
ii. Data Logging ......................................................................................................8
iii. Show End Panel..................................................................................................8
iv. Timer Script .......................................................................................................9
v. Scripts Secundários.............................................................................................9
b. Objetos ..................................................................................................................9
c. Produto final......................................................................................................... 11
4. Conclusão ................................................................................................................... 15
Índice de ilustrações Figura 1 - Caixa e blocos do teste...........................................................................................5
Figura 2 - Execução do teste..................................................................................................5
Figura 3 - Mão detetada pelo LM...........................................................................................6
Figura 4 - Fase intermédia do projeto com interação e caixa básica .........................................6
Figura 5 - Fase final do projeto com caixa realista e melhor interação......................................6
Figura 6 - Menu principal .................................................................................................... 11
Figura 7 - Menu de info do utilizador após iniciar a simulação ............................................... 11
Figura 8 - Caixa final ........................................................................................................... 12
Figura 9 - Menu de opções do utilizador .............................................................................. 12
Figura 10 - Modo de configuração da câmara. Semelhante ao normal mas sem tempo........... 13
Figura 11 - Execução do teste .............................................................................................. 13
Figura 12- Utilização da simulação com a Leap Motion ......................................................... 14
3
1. Introdução
O projeto abordado neste relatório irá ser realizado no âmbito de projeto final de Licenciatura
em Engenharia Informática. Foi desenvolvido pelo discente Guilherme Gomes durante o ano
letivo 2016/2017, orientado pela professora Mónica Cameirão, integrado no grupo de
investigação NeuroRehabLab, presente no M-ITI.
O projeto tem como contexto o fulcro do grupo da qual se integra; a neuro reabilitação, mais
especificamente, as vítimas de um Acidente Vascular Cerebral (AVC).
O AVC, sendo isquémico ou hemorrágico, ocorre quando existe um problema de irrigação ao
cérebro, fazendo com que células morram e certas funções deixem de ser possíveis ou sejam
seriamente prejudicadas. A zona de afetação mais comum é a dos membros superiores, pelo
que o paciente de AVC costuma ter problemas com o agarrar ou beliscar. Torna-se necessário
asserir a capacidade motora do indivíduo enquanto este recupera. É aqui que entra o teste
real, o “Box and Blocks”. Testa com fiabilidade a destreza física dos membros superiores do
paciente, mas a informação capturada é limitada. A simulação ataca este problema.
Esta premissa é tornada possível com a utilização do hardware Leap Motion que captura o
movimento da mão de forma precisa, movimento este que é registado no motor de jogo Unity,
graças à integração entre ambos. Os modelos simulados aproximam-se à escala real dos
objetos, bem como a física e regras do teste real. Coordenadas, resultados e tempos podem
ser facilmente registados nesta simulação, permitindo uma melhor análise dos movimentos
em causa. A simulação necessita apenas de um computador e do hardware Leap Motion para
ser executada.
Neste relatório vão ser descritas todas as fases de desenvolvimento, bem como todos os
scripts e objetos principais presentes no projeto. Irá ser feita uma análise das funcionalidades
relacionadas com estes. Finalmente será apresentada uma crítica ao projeto.
Todo o desenvolvimento será realizado utilizado o software principal, o motor de jogo Unity,
todos os scripts escritos na linguagem de programação C# e a câmara Leap Motion.
4
2. Etapas de desenvolvimento
a. Workshop de Unity O workshop serviu como motivação e forma ideal de iniciar-me nesta ferramenta, até a altura
conhecida, mas nunca trabalhada.
O tutorial simples, mas completo, com explicação detalhada sobre cada passo, serviu para me
iniciar na linguagem C# e na plataforma. Criámos um minijogo em que foram trabalhados
todos os aspetos geralmente envolvidos, de forma muito básica. As bases de programação
orientada a objetos adquiridas na licenciatura e o facto de ter sido familiarizado desta forma
ajudou imenso a quebrar esta barreira inicial.
No final do workshop também houve a oportunidade de trabalhar com ferramentas
disponíveis no laboratório, uma destas sendo a câmara Leap Motion, pela qual foi despertada
curiosidade partindo desta fase.
b. Leap Motion O projeto tem por base este dispositivo. É um sensor ótico que tem por base 3 infravermelhos
que detetam a posição da mão, reconhecendo a sua forma e processando estes dados via
software de forma a ter uma leitura mais fiável. Integrando-a com o Unity, obtém-se uma
representação fiável da mão do utilizador e movimentos deste.
A integração é feita através do Leap Motion Orion , o software que permite integrar o
hardware com o sistema operativo. Em seguida foi importado o Leap Motion Interaction
Engine, bem como os Core Assets presentes, pacotes que permitem a introdução do
controlador e do Interaction Manager, podendo introduzir as mãos e detetar as interações das
mesmas com os objetos em cena, respetivamente.
Sendo este um hardware recente e que não se encontra extensamente publicado, a
introdução ao dispositivo tornou-se um pouco difícil, acumulando à já dificuldade existente
consequente da inexperiência em Unity. A assistência de um colega de grupo provou-se
essencial, podendo eu progredir no restante desenvolvimento da aplicação.
c. Box and Blocks Este é teste que vai ser simulado. Consiste em algo muito simples: transpor cubos do lado da
mão dominante da caixa para o lado oposto. Os cubos medem 2.5 cm de lado e encontram-se
150 do lado da mão dominante. A caixa é de madeira, tal como os cubos, mede 53.7 x 8.5 x
17.2 (C-A-L) e encontra-se divida em duas divisórias de igual tamanho por uma parede central
Workshop Unity
• Plataforma
• C#
Leap Motion
• Módulos
• Integração
Box and Blocks
• Regras
• Especificações
Projeto
• Mecânica
• Scripts• Design e GUI
5
de 15 cm de altura. Podem ser adicionados 2 orifícios a esta parede de modo a melhorar o
transporte. O teste tem duração de 60 segundos e são contados os cubos transpostos.
As principais regras são:
• Apenas um cubo por transporte será contabilizado
• A mão tem que ultrapassar completamente a barreira
Figura 1 - Caixa e blocos do teste
Figura 2 - Execução do teste
O teste é fiável, mas não regista muita informação. A medida de cubos/minuto não mede com
precisão a qualidade do movimento. O cubo precisa apenas de ser transposto com uma mão
para ser contabilizado, pelo que um paciente cujo os membros superiores tenham sido
afetados poderá ter uma qualidade de movimento não muito boa, mas consiga transpor o
cubo e ser válido. Através de tratamento software é possível determinar com maior precisão a
posição dos membros e dígitos, melhor avaliando a sua qualidade.
d. Mecânica principal De movo a aproximar-se de maneira realista ao teste real, a mecânica principal e o foco do
projeto é a interação da mão com o cubo, detetada com o Leap Motion.
Com física simulada e motor de interação fornecido pela câmara, o movimento de agarrar e
beliscar é detetado e simulado, permitindo imitar o movimento que é executado no teste real.
e. Scripts e funções As regras, recolha de informação e funções dos menus foram programados e implementados
por código e adicionados aos objetos devidos. Após terem sido identificadas as funções e
funcionalidades necessárias, foram escritos scripts que executassem o requisitado. Todos os
scripts foram escritos em C#.
f. Design e GUI Por fim desenharam-se menus e painéis que assistam à utilização pela parte do utilizador.
Como principal existe o menu inicial que guia o utilizador para as opções, ajuda, configuração
da câmara ou início da simulação. Considera-se também importante o menu das opções. Como
secundário existem os painéis de ajuda, o painel de controlos da configuração, o painel de
introdução de dados e o final.
No fim redesenhou-se o design do jogo (até esta fase a modelação era muito básica). A caixa
da simulação final encontra-se com tamanho à escala real e textura/cor realista, visto ter sido
6
modelada com as indicações oficiais. O cubo encontra-se com tamanho, textura e física
realista.
3. Projeto
Visto que a parte fulcral do teste “Box and Blocks” é a interação com os membros superiores,
decidi começar por integrar um modelo simples de interação.
Figura 3 - Mão detetada pelo LM
Estudei os exemplos dados pelo Leap Motion e importei o Interaction Engine Module para o
projeto. Este módulo fornecido permite, como já referi, a interação simulada do utilizador com
objetos na cena de jogo.
Após corretamente integrada, desenhei uma superfície muito simples, sem tamanho nem
aparência aproximada ao real e um cubo que fosse interativo.
Figura 4 - Fase intermédia do projeto com interação e caixa básica
Foram implementadas todas as funções requeridas, desenhei os menus e paneis e no fim
redesenhei a caixa e redimensionei todos os objetos (inclusive mãos) para tamanho realista.
Figura 5 - Fase final do projeto com caixa realista e melhor interação
7
A simulação segue o mesmo procedimento que o teste real, com o número de cubos e tempo
configuráveis. A completa transposição da mão não é verificada, nem o número de cubos por
movimento, visto estes serem contabilizados por contacto.
8
a. Scripts
Nesta parte do relatório serão descritos os principais scripts e funções destes. Scripts
secundários ou pertencentes ao pacote Leap Motion não serão incluídos.
i. Box Collision List
Awake Lê a informação da mão dominante e move o plano de destino e de geração de cubos para o lado pretendido.
Start Inicia a contagem de cubos e o texto do mesmo a 0. Lê a informação do número de cubos pretendidos e gera o mesmo no plano de geração.
OnCollisionEnter Quando o cubo colide com a base é adicionado a uma lista de colisões e incrementado o resultado. É gerado um cubo no lado de geração
OnCollisionExit Quando o cubo deixa de colidir com a base é removido da lista, decrementado o contador e atualizado o texto. Necessário, pois o cubo ressalta com a queda e isso causa várias contagens que necessitam de ser corrigidas.
UpdateBoxCount Atualiza o texto do resultado
SpawnCube Instancia um cubo (pré feito) , após lida a posição da mão dominante, no lado de geração de cubos com uma cor aleatória.
ii. Data Logging
Start Inicia o cabeçalho do ficheiro
Update Atualiza a informação e escreve-a no ficheiro
UpdateData Atualiza cada elemento do cabeçalho (tempo, resultado e posições)
LogInit Cria o ficheiro com os cabeçalhos indicados e inicia a stream de escrita
CsvWrite Escreve os ficheiros da matriz de informação para a stream que escreve no ficheiro
CloseLog Fecha a stream e o ficheiro
iii. Show End Panel
Start Inicia o End Panel inactivo
Update Quando o tempo chegar a 0, o End Panel torna-se ativo e os painéis ativos de jogo e controlador Leap tornam-se inactivos.
UpdatePanelText É mostrado o nome do jogador e o seu resultado final.
9
iv. Timer Script
Start Recebe o valor das preferências de jogador e atualiza o texto com o valor
Update Decrementa o tempo e caso este chegue a 0, desliga o temporizador Atualiza o contador truncando o valor à centésima.
TurnTimerOff Desliga o contador, inactivando o objeto
v. Scripts Secundários
GetInfo Guarda e retorna o nome e idade do utilizador ao iniciar a simulação.
LoadCameraConfig Caso exista uma preferência na posição da câmara, carrega-a e modifica a câmara principal.
LoadSceneOnly/OnClick Carrega a cena pelo seu índice ou Carrega a cena sem destruir um objeto.
MoveCamera Conforme a tecla modifica a posição da câmara ao longo dos 3 eixos e ângulo. Também pode reiniciar a posição da câmara e a velocidade com que a altera.
QuitOnClick Fecha o programa
SaveCamera Salva a posição atual da câmara para as preferências do utilizador
SaveCurrOptions Salva as preferências do utilizador em relação ao número de cubos, tempo de simulação e mão dominante.
SubnBack Desativa o Data Logging, inactiva o Manager, destrói o InfoHolder e volta para o Menu principal.
WriteSliderValue Escreve o valor do slider numa label
b. Objetos Aqui exponho a hierarquia dos objetos e explico o propósito dos principais.
• LeapHandController - Controlador do Leap Motion que
permite integrar e controlar as mãos na cena de jogo. Integra os
modelos de mão físicos (Brush) e gráficos (PepperBase).
• Camera – A câmara principal de jogo.
• Board – A caixa de jogo.
• Canvas – Inclui os elementos das GUI. O Simulation Panel inclui
as informações disponíveis no jogo. O End Panel é mostrado no final
com o resultado e nome. O EventSystem é incluído na Canvas.
• Manager – Objeto vazio que incluí o TimerScript, DataLogging
e ShowEndPanel.
• InteractionManager – Objeto vazio do Leap Motion que
administra a interação com os objetos
10
• GameCube(Prefab) – Cubo 2.5cm de lado com física do Unity e script de interação do
Leap Motion
A cena CamConfigScene é semelhante, alterando alguns elementos na GUI
Na cena MainMenu apresenta-se apenas uma Canvas
que guarda todos os elementos do menu principal e um
InfoHolder , objeto que não é destruído na transição de
cenas e que guarda a informação do utilizador ao iniciar
a simulação
11
c. Produto final
Figura 6 - Menu principal
Figura 7 - Menu de info do utilizador após iniciar a simulação
12
Figura 8 - Caixa final
Figura 9 - Menu de opções do utilizador
13
Figura 10 - Modo de configuração da câmara. Semelhante ao normal mas sem tempo
Figura 11 - Execução do teste
14
Figura 12- Utilização da simulação com a Leap Motion
15
4. Conclusão
Nesta fase final sinto-me razoavelmente satisfeito com o trabalho. Os objetivos foram
alcançados e sinto que realizei um bom trabalho, mas talvez mais poderia ter sido feito.
O trabalho final encontra-se bom, mas não muito bom. Cumpre o objetivo do teste real, mede
informações úteis e aparenta ser um bom teste. Mas as regras principais foram apenas
parcialmente integradas. Apenas 1 cubo é considerado para a interação de agarrar pelo que o
utilizador não consegue agarrar em múltiplos cubos ao mesmo tempo. Mas a verificação da
transposição total da mão pela parede central não se encontra implementada, apesar de que
não parece ser algo impossível ou desafiante. O código final é simples, eficiente e bem
comentado, pelo que utilizadores ou desenvolvedores futuros poderão adaptar este teste (ou
modificá-lo) facilmente.
Agradeço imenso ao NeuroRehabLab pelo workshop disponibilizado. Conhecia a ferramenta,
mas nunca tinha desenvolvido nada com esta, pelo que as bases fornecidas no workshop
foram essenciais. Com apenas as bases de programação ensinadas na Licenciatura,
principalmente nas cadeiras de Estruturas de Dados e Algoritmos e Programação Orientada a
Objetos, consegui compreender a ferramenta e a Linguagem C# o suficiente para iniciar o
projeto. Foi também neste projeto que passei a conhecer a Leap Motion, hardware bastante
interessante que ficou como escolha para a base do meu projeto. Agradeço também a
disponibilização da câmara.
Com a escolha do Leap Motion feita e workshop concluído, foi -me sugerido iniciar a simulação
de ou 9 hole Peg Test ou Box and Blocks, sendo que escolhi este segundo pois o Leap é um
pouco limitado quanto a agarrar objetos cilíndricos (estes presentes no primeiro teste). Aqui
começaram as dificuldades. O Leap Motion fornece dois módulos principais relativos a
interação: O Interaction Engine e um módulo atualmente deprecado. Por azar escolhi este
segundo, muito mais complexo de ser trabalhado e muito limitado. O início do
desenvolvimento atrasou-se e fiquei desmotivado pois pouca coisa funcionava. Agradeço
imenso ao colega Henrique que me demonstrou como trabalhar com o Interaction Engine,
momento que me “iluminou” e motivou-me imenso.
Pelo meio apareci às Group Meetings. Ajudaram-me a compreender o foco do grupo e o
trabalho de todos os elementos. Não me senti 100% integrado, inclusive faltei a algumas
reuniões, visto que não apresentei o trabalho de forma igual aos demais e não compreendia
alguns dos trabalhos apresentados, mas tive todo o feedback e ajuda que pedi de todos os
elementos do grupo, principalmente dos professores Sergi e Mónica, aos quais agradeço
imenso.
Também fiz uma apresentação intermediária do projeto. Achei uma excelente iniciativa pela
parte do professor Eduardo Marques. Volto a agradecer à minha orientadora prof. Mónica e
ao prof. Sergi pela ajuda fornecida na apresentação, que correu muito bem.
Após o workshop ainda fiz alguns tutoriais oferecidos pelo Unity, muito bons de facto. Aprendi
aí algumas funcionalidades que me foram úteis no restante projeto. Principalmente como
desenhar Menus, algo que considero que tenho que melhorar.
A partir dai o desenvolvimento foi regular, agradeço aqui também à Teresa que me ajudou a
resolver alguns problemas pelo meio. Reformulei a caixa quase no fim, pois descobri que
16
modificando cubos, e não planos, consegui modula-la de forma a torná-la muito mais realista,
o que ajudou de forma direta na interação pelo que já conseguia atingir os extremos da caixa
com as mãos (algo não possível anteriormente, facto problemático).
No fim talvez fique algumas coisas por melhorar no projeto. A interação com o Leap Motion é
um pouco limitada. Acontecem algumas falhas na deteção, devido ou à iluminação ou ao raio
de deteção da mesma, e como é óbvio, interação simulada não é tão fácil de compreender
como a física, em que o feedback é muito melhor. Também poderia ter sido adicionado som ao
projeto. Mas fico satisfeito com o trabalho. Evolui imenso tanto a nível técnico como pessoal.
Espero que no futuro me encontre mais evoluído na área de desenvolvimento de jogos e talvez
colabore novamente num projeto de neuro reabilitação.