Publicado el 22 de Enero del 2017
1.030 visualizaciones desde el 22 de Enero del 2017
1,4 MB
22 paginas
Creado hace 9a (05/10/2015)
TESINA PARA LA
OBTENCIÓN DEL TÍTULO DE:
Máster en Desarrollo de
Aplicaciones sobre Dispositivos
Móviles
Título del
Proyecto:
Laberinto
Autor:
Gasulla Mestre,
Javier
Director:
Albiol Colomer,
Antonio
Septiembre de 2015
Proyecto: Laberinto
Alumno: Javier Gasulla Mestre
Contenido
Introducción .................................................................................................................................. 3
Descripción de la aplicación ...................................................................................................... 3
Objetivos ................................................................................................................................... 3
Motivación ................................................................................................................................ 3
Arquitectura de la aplicación ........................................................................................................ 4
Esquema del diseño .................................................................................................................. 4
Código Java ................................................................................................................................ 5
Código nativo ............................................................................................................................ 9
Librerías generadas ................................................................................................................. 10
Recursos .................................................................................................................................. 10
Modelo de datos ..................................................................................................................... 10
Vistas ....................................................................................................................................... 11
Conclusiones ............................................................................................................................... 19
Anexos ......................................................................................................................................... 20
Listado de fuentes entregadas ................................................................................................ 20
Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles
2
Proyecto: Laberinto
Alumno: Javier Gasulla Mestre
Introducción
Descripción de la aplicación
El proyecto consiste en el desarrollo de una aplicación en Android, utilizando Eclipse.
La aplicación constituye un juego en el que hay que mover una pelota por un laberinto para
recoger monedas y dirigirse a la meta. Al llegar a la meta pasamos al siguiente nivel, en el que
aparece otro laberinto diferente. En total la aplicación consta de dos niveles.
La pelota puede moverse de tres maneras diferentes a elegir en preferencias:
- Detección de cara. Se utiliza para ello la funcionalidad proporcionada por OpenCV,
así como implementación de funcionalidad en código nativo.
-
-
Pantalla táctil.
Sensores de aceleración.
Objetivos
El principal objetivo de la aplicación es utilizar OpenCV para procesar el movimiento de
la cara del usuario (captado por la cámara del dispositivo) y en consecuencia ejecutar acciones
sobre otros elementos (en este caso desplazar una pelota por un laberinto).
La implementación del juego constituye una excusa para plasmar el objetivo buscado.
Motivación
La motivación de este proyecto ha sido integrar el tratamiento de imagen con otros
aspectos vistos a lo largo del curso (código nativo, threads, acelerómetros, pantalla táctil,
ajuste del tamaño de imágenes, layouts para diferentes tipos de pantalla, multiidioma, etc.),
en una aplicación que pueda servir de base para futuras aplicaciones de uso tanto lúdico como
profesional.
Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles
3
Proyecto: Laberinto
Alumno: Javier Gasulla Mestre
Arquitectura de la aplicación
En los apartados siguientes se va a detallar los principales elementos que forman la
aplicación (clases Java, código nativo, librerías, recursos), describiendo su funcionalidad para
mostrar el funcionamiento de la aplicación.
Por otra parte, en la librería externa “OpenCV Library – 2.4.10”, utilizada por la
aplicación, hay que modificar la clase org.opencv.android.AsyncServiceHelper para convertir el
intent implícito existente en explícito. De este modo la aplicación puede usarse para
terminales con nivel de API 21 o superior.
Esquema del diseño
En el esquema siguiente se muestra la relación de las diferentes clases entre sí.
Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles
4
Proyecto: Laberinto
Alumno: Javier Gasulla Mestre
Código Java
A continuación se relaciona, por orden alfabético, las diferentes clases que forman la
aplicación, detallando la función de cada una de ellas.
- AcercaDe.java
Lanza el Dialog con los créditos de la aplicación.
- AdaptadorCursor.java
Adaptador del ListView que contiene las puntuaciones.
- AjustesDrawables.java
Implementa el código necesario para ajustar el drawable indicado al tamaño
deseado. Se utiliza en las clases MainActivity, VistaJuego y TabInstruccionesManejo
para dimensionar los drawables en función del tamaño de pantalla del dispositivo. De
este modo, independientemente del tamaño de dicha pantalla, las vistas mostradas
mantendrán el mismo aspecto.
- AlmacenPuntuaciones.java
Interfaz que
indica
los métodos para guardar una puntuación o mostrar
puntuaciones, que debe implementar la clase AlmacenPuntuacionesSQLite.
- AlmacenPuntuacionesSQLite.java
Se encarga de crear la base de datos que contiene las puntuaciones de los
jugadores y gestionar los accesos a la misma (para guardar una nueva puntuación u
obtener la relación de puntuaciones).
- Bloque.java
Extiende de la clase Grafico. A esta clase pertenecen los bloques que forman las
paredes del laberinto. Contiene características particulares de los bloques, como por
ejemplo los diferentes tipos de bloque.
El aspecto de los bloques es el mismo, pero se les asigna un tipo distinto en
función de los lados del bloque con los que puede chocar la pelota (los lados contiguos
a otro bloque no son susceptibles de que la pelota choque con ellos).
El tipo de cada bloque, junto con la posición relativa de pelota y bloque, se utilizará
para determinar si la pelota ha chocado con el bloque. Se determina también que
parte de la pelota (inferior, superior, derecha o izquierda) es la que ha chocado con el
bloque. La detección de colisiones implementada en la clase Grafico sirve para
detectar colisiones entre objetos de forma redondeada. Al ser los bloques cuadrados y
querer determinar el sentido del choque, se implementa una función particularizada
en esta clase.
Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles
5
Proyecto: Laberinto
Alumno: Javier Gasulla Mestre
- DetectionBasedTracker.java
Utilizada para la detección de caras en modo “nativo”. Proporcionada en el
ejemplo face-detection de OpenCV.
- Grafico.java
Implementa los métodos necesarios para dibujar, posicionar y mover objetos de
esta clase creados a partir de drawables. También detecta colisiones con otro objeto
de la clase Grafico (se utiliza para detectar colisiones de pelota con moneda, o pelota
con la meta).
Se utiliza en la clase VistaJuego ya que la pelota, monedas y meta allí creados son
objetos de la clase Grafico. También derivan de esta clase los objetos de tipo bloque
que forman las paredes del laberinto.
-
Instrucciones.java
FragmentActivity que muestra los dos tabs que contienen las instrucciones para
utilizar la aplicación, definidos en TabInstrucciones.java y TabInstruccionesMix.java.
-
JuegoyFaceDetect.java
Esta clase es llamada por MainActivity.java cuando se elige la opción de jugar una
partida. Se encarga de inicializar OpenCV, cargar las librerías, realizar la detección cara,
lanzar la pantalla del juego (gestionando el thread que maneja el juego, definido en el
fichero VistaJuego.java), establecer la dirección y sentido del movimiento de la pelota
(si se ha elegido la detección de cara como modo de manejo de la misma) y activar o
desactivar los sensores de aceleración (en caso de que sea el modo elegido para
manejar la pelota). También gestiona la pulsación de los botones existentes en la
pantalla del juego, descritos en el apartado de vistas.
Para realizar la detección de cara se ha utilizado el método descrito en el ejemplo
face-detection de OpenCV. Para ello se utiliza un fichero LBPCascade optimizado para
detección frontal de cara. Este tipo de ficheros contienen los patrones que permiten
realizar la detección de cara en una imagen. Los dos tipos más utilizados son
LBPCascade y HaarCascade. En nuestro caso es LBPCascade el idóneo, ya que siendo
algo menos preciso, es más rápido. Esta última característica resulta fundamental, al
tratarse de una aplicación que realiza el tratamiento de una imagen de video para
obtener una respuesta en tiempo real (el movimiento de la pelota).
De entre las diferentes caras detectadas, nos queda
Comentarios de: Tesis: Gasulla Mestre - Máster en Desarrollo de Aplicaciones sobre Dispositivos Móviles - Laberinto (0)
No hay comentarios