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.