Reconstrucción de objetos a partir de una malla de puntos

Titulación: Ingeniería Técnica Informática de Gestión

Autor: Joan Planas, Lluís Papió

Directora: Maria Ferré, Bergadà

Fecha: 06/10

Departament d’Enginyeria Informàtica i Matemàtiques

2

Índice

1. Introducción ................................................................................................................... 42. Objetivos ........................................................................................................................ 6

2.1 Objetivo Principal ............................................................................................................... 6

2.2 Objetivos Secundarios ........................................................................................................ 6

3. Especificaciones ............................................................................................................. 73.1 Obtención de los Puntos .................................................................................................... 7

3.2 Organización y Estructuración de los Puntos ..................................................................... 7

3.3 Triangulación ...................................................................................................................... 7

3.4 Visor en Tres Dimensiones ................................................................................................. 7

3.5 Guardado del Modelo ........................................................................................................ 7

3.6 Casos de Uso ...................................................................................................................... 8

4. Diseño ........................................................................................................................... 134.1 Elección del Lenguaje ...................................................................................................... 13

4.1.1 Portabilidad .............................................................................................................. 13

4.1.2 Facilidad .................................................................................................................... 13

4.1.3 Experiencia ............................................................................................................... 13

4.1.4 Librerías .................................................................................................................... 13

4.2 Librería Grafica ................................................................................................................. 14

4.2.1 Escenario Grafico ...................................................................................................... 14

4.2.2 Clases de Alto Nivel Java3D ...................................................................................... 16

4.2.3 Estructura Básica ...................................................................................................... 17

4.3 Elección de Algoritmos ..................................................................................................... 18

4.3.1 Ganapathy ................................................................................................................ 18

4.3.2 Delaunay ................................................................................................................... 25

4.4 Procesos Auxiliares ........................................................................................................... 27

4.4.1 Ordenación de los Puntos por Contornos ................................................................ 27

4.4.2 Calculo Normales ...................................................................................................... 27

4.4.3 Caras Interiores ........................................................................................................ 28

4.5 Estructura Ficheros ........................................................................................................... 29

4.6 Estructuras de Datos ........................................................................................................ 30

4.6.1 Punto ........................................................................................................................ 30

4.6.2 Contorno .................................................................................................................. 31

4.6.3 Triangulo ................................................................................................................... 32

3

4.6.4 Nodo ......................................................................................................................... 33

4.6.5 Polígono .................................................................................................................... 36

4.6.6 Ordena ...................................................................................................................... 38

4.6.7 LeerFichero ............................................................................................................... 38

4.6.8 MenúPrincipal .......................................................................................................... 39

5. Desarrollo ..................................................................................................................... 405.1 Primeros Pasos ................................................................................................................. 40

5.2 Pruebas Iniciales ............................................................................................................... 40

5.3 Carga Ficheros .................................................................................................................. 40

5.4 Visualización de Contornos .............................................................................................. 41

5.5 Triangulación Contornos .................................................................................................. 41

5.6 Visualización de Triángulos .............................................................................................. 42

5.7 Triangulación Puntos ........................................................................................................ 42

5.8 Obtención de las Caras Externas ...................................................................................... 42

5.9 Creación de la GUI ............................................................................................................ 43

5.10 Guardado Datos ............................................................................................................... 43

5.11 Carga de Datos ................................................................................................................. 43

6. Evaluación .................................................................................................................... 446.1 Phantom ........................................................................................................................... 44

6.2 Ruinas ............................................................................................................................... 46

6.3 Forma 1 ............................................................................................................................ 48

6.4 Forma 2 ............................................................................................................................ 50

6.5 Forma 3 ............................................................................................................................ 52

6.6 Forma 4 ............................................................................................................................ 53

6.7 Análisis de Resultados ...................................................................................................... 55

7. Conclusiones ................................................................................................................ 588. Recursos Utilizados ...................................................................................................... 599. Manual .......................................................................................................................... 60

9.1 Manual del Usuario .......................................................................................................... 60

9.2 Manual del Administrador ............................................................................................... 64

9.2.1 Recursos Necesarios ................................................................................................. 64

9.2.2 Instalación ................................................................................................................ 65

9.2.1 Manipulación de Ficheros ........................................................................................ 69

10. Agradecimientos ........................................................................................................... 70

4

1. Introducción

En el mundo real existen muchos problemas para resolver computacionalmente, algunos más complicados y otros no tanto. En este trabajo se trata el problema de la reconstrucción de edificios a partir de datos en forma de puntos, que son proporcionados por un escáner.

Para poner un punto de partida nos imaginamos una cantidad de puntos en el espacio, luego con dichos puntos detectamos sus caras exteriores y después obtenemos un triangulo para cada una de las caras exteriores detectadas. Esto es el principio de cualquier reconstrucción en tres dimensiones, no solo de edificios sino de cualquier objeto de cual se tenga su especificación formada por puntos en el espacio tridimensional.

Este es un campo bastante complicado ya que la mayoría de soluciones ofrecidas no están completas, es decir que casi nunca satisfacen por completo los requerimientos deseados. Esto ocurre porque la cantidad de información que se tiene que tratar es bastante abundante, con lo cual se necesitan maquinas muy potentes para poder hacer una buena reconstrucción, cuando hablamos de buena nos referimos a que contenga todos los detalles necesarios y que además se pueda utilizar con cualquier tipo de librearía 3D. También existen motivos más técnicos como pueden ser que la cantidad de triángulos no sea la adecuada como para obtener la calidad de imagen deseada, o que la cantidad de puntos no permita más calidad debido a la imprecisión del escáner y podría ser también el caso contrario donde haya un exceso de triángulos o de puntos. En este último es donde se originan los problemas, ya que si bien la triangulación de la estructura puede ser un proceso que se ejecute solo una vez, a la hora de poder visualizar el resultado se pueden originar las caídas de FPS frames per second.

Como todos sabemos los objetos que se mueven en una pantalla, no son más que una sucesión de imágenes que van pasando una detrás de otra a una velocidad elevada, con lo que se consigue el efecto de movimiento, aplicando así el mismo principio que en el cine. Los FPS son una variable obtenida a partir de contar el numero de imágenes que pasan por la pantalla durante un segundo, este baremo también se mide en el cine. Para que una película de la sensación de movimiento tiene que tener al menos 24,5 FPS, por esto cuando las antes comentadas caídas de FPS suceden obtenemos un movimiento tosco de nuestra reconstrucción que en algunos casos puede originar también el bloqueo del PC. Dichas caídas se producen cuando la cantidad de cálculos a realizar supera la capacidad de obtener resultados de nuestro CPU, un símil a esto sería un marinero sacando agua con un tobo a un barco que se hunde.

5

Para comenzar a comprender todas estas cuestiones técnicas se utilizo un programa diseñado y programado por un departamento de investigación. El programa en cuestión es el MeshLab, que como su nombre indica es un editor de mallas.

Una malla es un conjunto de triángulos que forman una superficie de un objeto. Con este programa pudimos observar la diferencia entre malla y colección de puntos. Una malla se suele guardar en un fichero con los triángulos ya asignados a los puntos, la colección de puntos como su nombre indica son los puntos sin triangulación. Este programa contiene diversas opciones de visualización, triángulos, caras etc. Con lo que se obtuvo una información ya más concreta de cómo funcionan estos entornos.

MeshLab es una herramienta muy potente, pero tiene algunos de los fallos antes comentados, el problema radica en que los modelos presentados contienen el cien por cien de los puntos facilitados por los ficheros .ply, que son un estándar en la representación de la información para reconstrucciones tridimensionales. Al contener tantos puntos se generan también una gran cantidad de triángulos, lo que ocasiona que en el momento de mostrar el modelo por pantalla con cualquier tipo de movimiento nuestro equipo tenga enormes problemas para mostrar algo que se vea bien y con soltura.

La solución de estos problemas radica en la simplificación de las mallas cosa que es bastante compleja. También existen otras soluciones que pasan por construir la malla de triángulos ya simplificada, en este proyecto tendremos la oportunidad las diferencias entre una solución que utiliza el cien por cien de los puntos y otra que solo se queda con el treinta o cuarenta por cien del total de puntos proporcionados. Evidentemente al eliminar puntos perdemos calidad, pero a la vez ganamos velocidad de ejecución, la solución está en encontrar un equilibrio entre velocidad y calidad.

6

2. Objetivos

Dentro del mundo de la reconstrucción de edificios, los que necesitamos es estudiar los algoritmos que nos permiten pasar de una nube de puntos a la reconstrucción tridimensional de dicho edificio.

Así pues se trata del diseño e implementación, de una aplicación capaz de hacer transformaciones sobre los puntos en el espacio, proporcionados a partir de un cierto tipo de escáner o reconstrucciones computacionales con el fin de obtener la figura que forma dichos puntos. Para ello se han tenido que aplicar diversos algoritmos de los cuales también se ha realizado un análisis, para poder evaluar la calidad de los resultados obtenidos. Dentro de dichos algoritmos podemos encontrar la Triangulación de Ganapathy y la de Delaunay, aparte de estos también se han tenido que diseñar soluciones que ayudan a la aplicación de los mismos. Dentro de estas funcionalidades se incluye toda la parte en la que se da el formato a los datos de entrada, así como también las herramientas de visualización.

2.1 Objetivo Principal

Diseñar e implementar una aplicación capaz de reconocer una nube de puntos para obtener su visualización en tres dimensiones.

2.2 Objetivos Secundarios

o Conocer el mundo de la reconstrucción en tres dimensiones. o Estudiar los algoritmos existentes sobre la obtención del cierre convexo o Aplicar conocimientos geométricos a la implementación de cada una de las

funciones. o Analizar los resultados de cada uno de los algoritmos por separado y establecer

las diferencias entre Ganaphaty y Delaunay. o Buscar la mayor simplificación de la figura resultante. o Aplicar los diversos conocimientos obtenidos durante toda la carrera, al diseño

desarrollo e implementación de este proyecto.

7

3. Especificaciones

Las características específicas de este proyecto se pueden identificar por fases bien definidas, las cuales se presentan a continuación:

3.1 Obtención de los Puntos

En esta fase se trata de obtener los puntos en tres dimensiones provenientes de un escáner o bien de una construcción geométrica computacional. Esto se hace mediante los ficheros proporcionados a partir de uno de estos dos métodos. Estos ficheros cabe destacar que son de tipo de texto plano en la implementación diseñada para el proyecto, donde cada una de las líneas representa un punto en el espacio, aunque en el resto de reconstrucciones los ficheros no tiene porque ser de este tipo, también podrían ser de tipo binario.

3.2 Organización y Estructuración de los Puntos

Como su nombre indica en esta etapa se buscara la mejor estrategia de organización de puntos, para que posteriormente los algoritmos aplicados funcionaran correctamente con el formato proporcionado.

3.3 Triangulación

En este punto se trata de escoger e implementar algoritmos que utilicen dicha nube de puntos para transformarla en una estructura formada por polígonos triangulares. De esta fase se obtiene la figura definida por triángulos.

3.4 Visor en Tres Dimensiones

Para que todo esto se pueda apreciar, se tendrá que realizar también un visor donde se podrán mostrar los modelos en 3D. Este visor debe incluir varias funcionalidades como pueden ser cambiar de punto de vista, rotar el objeto, acercar alejar etc. También debe permitir visualizar puntos, triángulos y la figura con la iluminación aplicada.

3.5 Guardado del Modelo

Se construirá también un fichero donde se guardara los datos del modelo ya triangulado, para así la próxima vez que se necesite observar dicho modelo no haga falta ejecutar todo el proceso desde el principio.

8

3.6 Casos de Uso

En este apartado presentamos el diagrama de casos de uso. Con este diagrama se representa la interacción entre el usuario y la maquina. Como es evidente dicha interacción se produce con la GUI. En la Figura 1 podemos observar el diagrama en cuestión, que partiremos en dos, el primero para la barra menú del programa y otro para el resto de opciones.

Figura 1. Caso de uso Barra Menú

9

En la Figura 2 podemos observar el caso de uso aplicado a las opciones de visualización.

Figura 2. Caso de uso Opciones Visualización

Para una mayor comprensión de las acciones realizadas en cada uno de los casos a continuación se presenta la especificación textual de cada uno de ellos.

i. El usuario hace clic sobre archivo y luego sobre Guardar.

Guardar

ii. El sistema responde llamando a la ventana de selección de archivo. iii. El usuario eligen un directorio y escribe el nombre del archivo, luego hace

clic en guardar. iv. El sistema crea un archivo con el nombre proporcionado con la terminación

.triángulos y con la información del objeto que se está visualizando actualmente.

i. El usuario hace clic sobre archivo y luego sobre Cargar.

Cargar

ii. El sistema responde llamando a la ventana de selección de archivo. iii. El usuario selecciona el archivo y presiona abrir. iv. El sistema inicializa las estructuras de puntos y muestra por la consola el

número de puntos cargados.

10

i. El usuario hace clic sobre archivo y luego sobre Leer.

Leer

ii. El sistema responde llamando a la ventana de selección de archivo. iii. El usuario selecciona el archivo y presiona abrir. iv. El sistema crea una estructura triangular a partir de la información obtenida

del fichero seleccionado. v. El sistema visualiza dicha estructura.

i. El usuario hace clic sobre archivo y luego sobre Salir.

Salir

ii. El sistema termina la ejecución del programa.

i. El usuario hace clic sobre Triangulación y luego sobre Delaunay.

Delaunay

ii. El sistema crea una figura nueva, ejecutando el código perteneciente al algoritmo escogido.

iii. Seguidamente el sistema muestra la figura por pantalla.

i. El usuario hace clic sobre Triangulación y luego sobre Ganapathy.

Ganapathy

ii. El sistema crea una figura nueva, ejecutando el código perteneciente al algoritmo escogido.

iii. Seguidamente el sistema muestra la figura por pantalla.

i. El usuario hace clic sobre Visualización y luego sobre Modelo.

Modelo

ii. El sistema comprueba la si la opción es posible en ese instante. iii. Seguidamente el sistema muestra la figura por pantalla con todos sus

características y opciones disponibles.

i. El usuario hace clic sobre Visualización y luego sobre Contornos.

Contornos

ii. El sistema comprueba que se trate de una figura triangulada por Ganapathy. iii. Seguidamente el sistema muestra únicamente los contornos que forman

dicha figura.

i. El usuario hace clic sobre Ayuda y luego sobre Instrucciones.

Instrucciones

ii. El sistema abre una ventana donde se muestra un pequeño manual de uso rápido.

iii. El usuario hace clic en aceptar. iv. El sistema cierra la ventana.

11

i. El usuario hace clic sobre Ayuda y luego sobre Sobre el Autor.

Sobre el Autor

ii. El sistema abre una ventana donde se muestra la información relativa al autor del proyecto.

iii. El usuario hace clic en aceptar. iv. El sistema cierra la ventana.

i. El usuario hace clic sobre Único.

Único

ii. El sistema realiza los cambios en la escena grafica para que la figura acabe pintada de blanco.

iii. El sistema muestra la figura con los cambios.

i. El usuario hace clic sobre Fondo.

Fondo

ii. El sistema realiza los cambios en la escena grafica para que la figura acabe pintada del color definido como fondo que en nuestro caso es verde.

iii. El sistema muestra la figura con los cambios.

i. El usuario hace clic sobre Iluminación.

Iluminación

ii. El sistema realiza los cambios en la escena grafica para que la luz definida inicialmente actúe sobre el objeto que se esta visualizando.

iii. El sistema muestra la figura con los cambios.

i. El usuario hace clic sobre Puntos.

Puntos

ii. El sistema realiza cambios sobre la apariencia de la figura que se visualiza, para visualizar únicamente los puntos de la misma.

iii. El sistema muestra la figura con los cambios.

i. El usuario hace clic sobre Líneas.

Líneas

ii. El sistema realiza cambios sobre la apariencia de la figura que se visualiza, para visualizar únicamente las líneas que unen los puntos de la misma.

iii. El sistema muestra la figura con los cambios.

i. El usuario hace clic sobre Único.

Polígono

ii. El sistema muestra los triángulos generados por nuestros algoritmos, la diferencia es que las caras están pintadas.

iii. El sistema muestra la figura con los cambios.

12

i. El usuario hace clic sobre Rotación.

Rotación

ii. El sistema comprueba si el botón ya estaba seleccionado, en caso afirmativo lo deselecciona y pone el Alpha de la rotación en pause, en el caso contrario selecciona el radiButton y pone el Alpha de la rotación en run.

iii. El sistema muestra la figura rotando o no.

i. El usuario hace clic sobre X.

X

ii. El sistema cambia la asignación de una variable hacia x, esta luego es comprobada a la hora de realizar la triangulación.

iii. El sistema muestra la figura rotando o no.

i. El usuario hace clic sobre Y.

Y

ii. El sistema cambia la asignación de una variable hacia y, esta luego es comprobada a la hora de realizar la triangulación.

iii. El sistema muestra la figura rotando o no.

i. El usuario hace clic sobre Z.

Z

ii. El sistema cambia la asignación de una variable hacia z, esta luego es comprobada a la hora de realizar la triangulación.

iii. El sistema muestra la figura rotando o no.

i. El usuario hace clic sobre Borrar.

Borrar

ii. El sistema elimina todas las figuras del marco de visualización. iii. El sistema se mantiene a la espera de la carga de otro archivo para poder

seguir mostrando figuras.

13

4. Diseño

En esta fase del proyecto se tuvieron que barajar unas cuantas posibilidades, ya que hay diversas maneras de implementar este sistema. A continuación se comentan las decisiones tomadas para cada problema presentado en el diseño.

4.1 Elección del Lenguaje No hubieron muchas dudas a lo hora de elegir el lenguaje de programación, ya que solo se presentaron como candidatos C y Java. Este proyecto se ha decidido implementar usando Java por varias razones entre las cuales encontramos:

4.1.1 Portabilidad Como todos sabemos hoy en día la portabilidad de una aplicación es muy importante ya que nos permite usarla en cualquier sistema informático incluso con sistema operativo diferente. Java es uno de los principales lenguajes de programación que permite portabilidad entre entornos como Windows, Linux o en móviles. Todo esto lo permite gracias a que todas las llamadas pasan primero por una maquina virtual que centraliza toda la ejecución del programa. Cosa que también conlleva a una pérdida de potencia.

4.1.2 Facilidad Se trata de un lenguaje de programación orientado a objetos proveniente del C que es bastante sencillo de codificar, así como también es fácilmente legible.

4.1.3 Experiencia A la hora de elegir un lenguaje de programación también se tiene que tener en cuenta en cuál de ellos nos desenvolvemos mejor, para así obtener resultados lo más rápido y eficiente posible. Por ello dado que la mayoría de las prácticas de materias de la carrera han sido implementadas en Java, existe una mayor relación y adaptación con este lenguaje.

4.1.4 Librerías Java posee sus propias librerías dedicadas a la representación visual en tres dimensiones Java3D, estas librerías utilizan OpenGl que es una librería grafica de las más conocidas junto con Direct3D. Presenta al usuario una idea clara e intuitiva de cómo tratar la información y como se representa en tres dimensiones.

14

4.2 Librería Grafica Como antes se ha mencionado la librería grafica es Java3D, la cual nos servirá para transformar a imágenes todos los cálculos realizados. A continuación se explica brevemente como funciona dicha librería.

Como todo programa, Java3D está al menos parcialmente instanciado por objetos del árbol de clases nativas. Esta colección de objetos representa el Universo Virtual que va a ser renderizado posteriormente. Dichas clases se encuentran disponibles en el paquete javax.media.j3d.También existen en Java3D las clases de utilidades que se encuentran en el paquete com.sun.j3d.utils, que al ser utilizadas podemos llegar a reducir considerablemente las líneas de código.

4.2.1 Escenario Grafico En el proceso de construcción de un escenario grafico que es una estructura de datos que está compuesta de componentes y arcos de relación, se pueden encontrar clases como Group que puede tener cualquier número de hijos, pero solo puede ser hijo de una padre, a esto se le llama relación de herencia. El otro tipo de relación son referencias a objetos como NodeComponent. Dichos objetos definen la geometría y los atributos de apariencia usados para renderizar los objetos visuales.

Un escenario grafico en Java3D está construido de objetos nodos con relaciones padre-hijo formando una estructura arbolar. En un árbol un nodo es la raíz, se puede acceder a otros nodos siguiendo los arcos desde la raíz.

Solo existe un camino desde la raíz de un árbol a cada una de las hojas; por lo tanto, solo hay un camino desde la raíz hasta el escenario grafico de cada nodo hoja. Existe un camino de escenario grafico por cada hoja del árbol. Dicho camino especifica completamente ola información del estado de su hoja, que puede ser la localización, la orientación y el tamaño del objeto visual.

Los escenarios gráficos se dibujan usando símbolos gráficos estándar como se ve en la Figura 3.

Figura 3. Símbolos gráficos estándar

15

Cada uno de los símbolos que se ven en el lado izquierdo de la Figura 1, representa un solo objeto cuando se usa en un escenario gráfico. Los dos primeros símbolos representan objetos de clases especificas: VirtualUniverse y Locale. Los siguientes 3 símbolos representan objetos de las clases Group, Leaf y NodeComponent. Estos tres símbolos normalmente tienen anotaciones para indicar la subclase del objeto específico. El último símbolo se utiliza para representar otras clases de objetos.

El símbolo de la flecha sólida representa una relación padre-hijo entre dos objetos, la flecha punteada es una referencia a otro objeto. Los objetos referenciados pueden ser compartidos entre diferentes ramas de un escenario grafico. Un ejemplo de escenario gráfico se presenta en la Figura 4.

Figura 4. Ejemplo escenario grafico

16

4.2.2 Clases de Alto Nivel Java3D

En la Figura 5 podemos ver los tres primeros niveles del árbol de clases de Java3D. Este árbol contiene las clases VirtualUniverse, Locale, Group y Leaf.

Figura 5. Clases de alto nivel Java3D

SceneGraphObject es la superclase de casi todas las clases centrales de utilidad. Contiene dos subclases Node y NodeComponent. Dichas subclases proporcionan la mayoría de los objetos de un escenario grafico. Un objeto nodo puede ser un objeto nodo Group o un objeto nodo Leaf

La clase Node es un superclase abstracta de las clase Group y Leaf. Esta clase define algunos métodos importantes de sus subclases. La subclases de esta componen lo que luego serán los escenarios gráficos.

La clase Group es la superclase usada en la especificación de localización y orientación de objetos visuales en el universo virtual. Dos de las subclases de Group son: BranchGroup y TransformGroup.

La clase Leaf es la superclase usada para especificar la forma sonido y comportamiento de los objetos visuales en el universo virtual. Algunas de las subclases de Leaf son: Shape3D (construcción geométrica), Light, Behavior y Sound. Dichas clases podrían o no tener hijos pero podrían referenciar a NodeComponents.

17

La clase NodeComponent es la superclase usada para especificar la geometría, la apariencia, la textura y las propiedades de material de un nodo Shape3D (Leaf). Los NodeComponents no forman parte del escenario grafico, pero son referenciados por él. Un NodeComponent podría ser referenciado por más de un objeto si se quiere que las figuras tengan todas o algunas el mismo aspecto.

4.2.3 Estructura Básica

Así pues una estructura básica de un programa con esta librería pasaría por seguir los siguientes pasos:

- Crear un objeto Canvas3D. - Crear un objeto VirtualUniverse. - Crear un objeto Locale, adjuntarlo al objeto VirtualUniverse. - Construir la rama de vista grafica que incluye:

o Crear un objeto View o Crear un objeto ViewPlatform o Crear un objeto ViewPlatform o Crear un objeto PhysicalEnviorment

- Adjuntar los objetos ViewPlatform , ViewPlatform, PhysicalEnviorment y Canvas3D al objeto View.

- Construir las ramas graficas de contenido. - Compilar las ramas graficas. - Insertar los subgráficos dentro del objeto Locale.

18

4.3 Elección de Algoritmos

Para la implementación de este proyecto existen una gran variedad de maneras de comprender el problema de traspasar una nube de puntos a un objeto en tres dimensiones, a continuación vamos a hacer un resumen y de dichas soluciones y características.

Básicamente se estudian dos maneras de hacer una triangulación de un conjunto de puntos en el espacio 3D, la primera se trata de obtener los puntos por contornos construir su cierre convexo y triangular por parejas de cierres convexos; La segunda manera de ver el problema sería haciendo la proyección de los puntos en 3D a un plano, en este plano hacer la triangulación en 2D y luego devolver la altura a los puntos triangulados.

Se han elegido los dos algoritmos más conocidos que realizan dichas tareas Ganapathy y Delaunay. Las características de los cuales presentamos a continuación.

4.3.1 Ganapathy Este algoritmo que consiste en obtener primeramente los puntos ordenados por contornos, es decir que la figura este fileteada en rodajas, donde cada rodaja represente una altura que puede ser en cualquiera de las tres coordenadas x y z. Entendemos por contorno al conjunto de puntos que comparten una de las tres coordenadas en el espacio un ejemplo de ello lo podemos apreciar en la Figura 6.

Figura 6. Ejemplo de contornos

19

A la obtención ordenada de los puntos, de forma de que el punto siguiente sea el que es mas exterior y a la vez el más cercano, se le llama Cierre Convexo. Un ejemplo de cierre convexo de la Figura 7 es el representado por la Figura 8.

Figura 7. Ejemplo de nube de puntos

Figura 8. Ejemplo de cierre convexo

20

Hay una gran cantidad de algoritmos que calculan el cierre convexo a continuación explicaremos algunos de ellos.

• Algoritmo de Jarvis: su cometido es encontrar el cierre convexo a través del cálculo de ángulos entre los puntos que conforman el conjunto de puntos de un plano. Un ejemplo de su ejecución lo podemos apreciar en la Figura 9. Como podemos observar la finalización del algoritmo viene dada por el hecho de volver a llegar al vértice de partida. Como se puede apreciar este algoritmo tendrá un coste de O (n2) donde la n representa el número de puntos que contiene el plano al cual se le quiere calcular el cierre convexo.

Figura 9. Algoritmo Jarvis

• Algoritmo QuickHull: con este método lo que se busca es asignar a cada punto una situación según la zona donde se encuentren (NE, SE, SW, NW) y luego ir recortando los puntos sobrantes. Primero se encuentran los puntos extremos encontrando también su cierre convexo lo cual es bastante sencillo ya que si un punto es el extremo de su lado no hay más que unirlo con los demás. A continuación se buscan los puntos extremos de cada lado del cierre, luego se unen los puntos con dichos extremos y así hasta quedarnos sin puntos que excluir. En la Figura 10 podemos ver como funcionaria este algoritmo. Podemos ver que el coste de este método es O (n2).

Figura 10. Algoritmo QuickHull

21

• Algoritmo de Graham: en este caso también se utilizan los ángulos pero se calculan en la inicialización del algoritmo, escogemos el vértice que sea lexicográficamente más pequeño y calculamos los ángulos hacia el resto de puntos. A partir de ahí escogemos el vértice en función de si es un giro a izquierda o a derecha, un ejemplo de ello lo podemos ver en la Figura 11. Como podemos apreciar el coste de este algoritmo de O (n logn) donde n es el número de puntos.

Figura 11. Algoritmo Graham

• Algoritmo Incremental: este proceso está basado en primeramente la obtención de tres puntos, a partir de los cuales se elijen aquellos que se encuentran exteriores al polígono que forma la unión de los mismos. En la Figura 12 encontramos la manera de actuar de dicho algoritmo. Podemos ver que el coste de este procedimiento se sitúa en O (n log n) donde n es el número de puntos.

Figura 12. Algoritmo Incremental

22

• Dividir para Vencer: se trata de una variante de todos estos algoritmos en la que se divide la figura en dos partes, en cada una de las cuales se calcula su cierre convexo especifico y luego se une calculando la tangente común exterior a dichos polígonos convexos, una vez hecho esto se eliminan las cadenas que han quedado en el interior del polígono. Apreciamos que este algoritmo tiene un coste de O (n log n), como se puede observar en la Figura 13.

Figura 13. Dividir para Vencer

Después de haber estudiado todos estos algoritmos se ha decido implementar primero un algoritmo recomendado por la tutora al cual citamos como ordenación por rectas. Y luego el algoritmo de Graham para realizar una ejecución un poco más rápida.

• Algoritmo Ordenación Rectas: este algoritmo consiste en encontrar a partir de un conjunto de puntos situados en plano, aquel que tenga la y mínima, en el caso de empate se escoge aquel que sea más exterior de todos. Una vez hecho esto se comprueba que la recta formada por este punto y otro cualquiera de la lista se la mas exterior. Esto se consigue a partir de la formula general de la recta Formula 1.

{(x-x1) / (x2-x1)}-{(y-y1) / (y2-y1)} (1)

A partir de la cual despejamos la Formula 2 para poder evitar los errores de división por cero.

{(x-x1)*(y2-y1)}-{(y-y1)*(x2-x1)} (2)

Donde el punto elegido como menor tiene por coordenadas x1 y1, el punto elegido de la lista de puntos tiene por coordenadas x2 y2, el punto x y son todo el resto de puntos que se prueban dentro de la formula, lo que da origen a un numero el cual denotaremos como calculo, a continuación se comprueba si dicho calculo es mayor o menor que cero, que sea menor que cero quiere decir que el punto de coordenadas x y esta por la parte izquierda de la recta y si por el contrario este cálculo es mayor que cero quiere decir que este punto está por la derecha de la recta .Si la recta que estamos probando consigue obtener todos los cálculos con el mismo resultado para la comparación quiere decir que es la más exterior, por tanto devolvemos el punto que consigue esto y volvemos a empezar desde este ultimo.

23

Una vez calculado el cierre convexo el algoritmo de Ganapathy nos dice que para construir el objeto en tres dimensiones debemos unir cada dos cierres de puntos con una hilera de triángulos como representa la Figura 14. Esto no es que se realice aleatoriamente, primero se empieza por cualquiera de los cierres ya que están obtenidos a partir del mismo algoritmo, ósea que están ordenados por igual.

Figura 14. Ejemplo de Cierres

Se escoge por ejemplo el punto P0 se une con el Q0 y con el P1 entonces formamos el triangulo formado por dichos vértices, el siguiente punto a escoger ya depende del largo abarcado por cada triangulo dividido por el perímetro del cierre, para una mejor ilustración de esto observar la Figura 15.

Figura 15. Triangulación Contornos

24

En la figura podemos que ɸ’h es la distancia acumulada por los triángulos formados en la parte superior así como ɸ’v es de la parte inferior, en este algoritmo se busca un equilibrio en la repartición de triángulos entre un lado y otro. Para ello se establece la condición de que el siguiente triangulo a formarse será el que posea la menor distancia calculada como en la Formula 3 y Formula 4.

Dh= (ɸ’v+ ɸv)-(ɸ’h / perimetroh) (3)

Dv= (ɸ’h+ ɸh)-(ɸ’v / perimetrov) (4)

Se establece que si Dh< Dv entonces el triangulo tendrá dos puntos hacia el lado h y si no será justamente lo contrario, volviendo al caso principal donde teníamos el triangulo P0-Q0-P1 aplicando estas formulas obtenemos que el siguiente triangulo debería estar formado por el trío de puntos Q0-Q1-P1.

25

4.3.2 Delaunay Dado un conjunto de puntos P en un plano de dos dimensiones como por ejemplo el de la Figura 16, tomaremos como triangulación de Delaunay al grafo rectilíneo formado por el diagrama de Voronoi como podemos observar en la Figura 17.

Figura 16. Conjunto de puntos 2D

Figura 17. Diagrama de Voronoi

26

Se definen también dos características primordiales, una pareja de puntos forman una arista de Delaunay si y solo si la circunferencia solamente incluye dichos puntos, también podemos decir entonces que tres puntos forman un triangulo de Delaunay si y solo si dichos puntos que forman una circunferencia no contienen ninguno mas de el conjunto P, como podemos observar en la Figura 18.

Figura 18. Caracterización de Delaunay

El algoritmo de Delaunay está diseñado especialmente para trabajar en 2D, entonces para poder utilizarlo en 3D hay que hacer la proyección de los puntos en 3D a 2D como podemos observar en la Figura 19, esto significa para este caso, quitar una de las coordenadas antes de pasarle la lista de puntos al algoritmo y el momento en que devuelva la lista de triángulos, a los puntos de los mismos volverles a añadir la tercera coordenada.

Figura 19. Proyección de puntos a 2D

27

4.4 Procesos Auxiliares

En este punto se expone el diseño de los métodos que ayudan a que el programa pueda funcionar correctamente, se más atractivo y complete su funcionalidad respectivamente.

4.4.1 Ordenación de los Puntos por Contornos

Esta ordenación se realiza de manera que si un fichero de puntos, no viene ordenado de ninguna manera se puedan extraer los contornos en cualquier coordenada elegida por el usuario. Para realizar esta ordenación se ha utilizado el método sort de java.list al cual solo hay que pasarle una instancia de la clase Comparator, que define como se va a realizar las comparaciones dentro de la lista. Gracias a esto podemos ejecutar con tranquilidad el algoritmo de Ganapathy ya que tiene como clausula que sus puntos vengan dados por contornos ordenados.

4.4.2 Calculo Normales

Una vez construida la estructura triangular, la intención es asignarle un color, pues bien al hacer esto nos damos cuenta de que no hay diferencias plausibles entre una esquina y un trazo horizontal de figura. Esto se debe a la iluminación del objeto, como todos sabemos que la luz nos permite apreciar el color en sus diferentes tonalidades, en función de la intensidad de la misma y asi conseguir el efecto de profundidad.

Para solucionar este problema hay que calcular el vector normal asociado a un plano, ya que la luz incide en un ángulo y con mayor o menor medida dependiendo del vector definido como normal. A través de Formula 5, Formula 6 y Formula 7 podemos realizar dicho calculo.

Nx=∑ (𝑦𝑦𝑖𝑖𝑛𝑛𝑖𝑖=1 − 𝑦𝑦𝑗𝑗 ) ∗ (𝑧𝑧𝑖𝑖 − 𝑧𝑧𝑗𝑗 ) (5)

Ny=∑ (𝑧𝑧𝑖𝑖𝑛𝑛𝑖𝑖=1 − 𝑧𝑧𝑗𝑗 ) ∗ (𝑥𝑥𝑖𝑖 − 𝑥𝑥𝑗𝑗 ) (6)

Nz=∑ (𝑥𝑥𝑖𝑖𝑛𝑛𝑖𝑖=1 − 𝑥𝑥𝑗𝑗 ) ∗ (𝑦𝑦𝑖𝑖 − 𝑦𝑦𝑗𝑗 ) (7)

Como podemos observar el subíndice i pertenece al número de puntos del plano, en nuestro caso utilizaremos los tres puntos del triangulo para generar el vector. Nótese también que el subíndice j hace referencia al siguiente punto después de i en la lista.

Con este cálculo conseguimos el vector normal a cada triangulo que seria a cada cara de nuestra figura, pero hay otro problema, cada una se ilumina

28

independientemente de la que esta contigua, por lo tanto el resultado no será el esperado. Para solucionar este problema es necesario calcular por cada uno de los puntos de nuestra figura la normal asociada, pero con la diferencia que esta normal será la media de las normales de los triángulos adyacentes que contengan dicho punto.

Para realizar este cálculo de normales medias, hubo que crear una estructura de datos donde apuntamos por cada punto que triángulos tiene contiguos, esto se realiza durante la creación de triángulos es decir en una de las dos triangulaciones, de esta manera en el momento que tengamos que calcular la normal podremos saber con qué vectores hacer la media.

Con este cálculo obtenemos la media de la normal para cada punto y así obtenemos que cada una de las caras de la figura se ilumine a partir del conjunto de iluminación de las caras adyacentes y así conseguir una imagen más realista.

4.4.3 Caras Interiores

Uno de los problemas presentados después de la triangulación, es el que lo triángulos mostraban sus caras hacia la parte interior de la figura. Esto pasa por que en el mundo de la representación en 3D existen unos estándares para el pintado de los triángulos. Si pintamos el triangulo en sentido anti horario veremos la cara superior de dicho triangulo, pero si por el contrario pintamos en sentido horario veremos la cara inferior del triangulo. Este problema se origina por el hecho de que en la triangulación no se toma en cuenta el sentido en que se añaden los puntos. Para solucionar esto y aprovechando el cálculo de la normal, se han tomado las coordenadas de la normal como las capitales A, B y C de la Formula 8 que es la formula elemental de un plano.

A*x+B*y+C*z+D (8)

Obtenemos D a partir de la Formula 8 y nos da como resultado la Formula9

D=-(A*x)-(B*y)-(C*z) (9)

Donde las coordenadas x y z vienen dadas por los puntos que forman cada uno de los triángulos.

Una vez tenemos este cálculo realizado basta con sustituir en la ecuación del plano del triangulo las tres coordenadas x y z de otro triangulo y analizar el resultado, que si es mayor que cero entonces dicho triangulo es interior y se debe de pintar en sentido contrario, además también debemos negar el vector normal para así conseguir que la luz alumbre por la parte visible de la cara.

29

4.5 Estructura Ficheros Para este proyecto se definen dos tipos de fichero .putos y .triángulos, en el caso del primero y como su nombre indica proporciona una lista de los puntos en 3D que forman un objeto concreto una estructura típica seria como la mostrada por la Figura 20.

Figura 20. Ejemplo fichero puntos

Cabe destacar que este fichero es el que proviene de un escáner que devuelve los puntos en altura de una superficie cualquiera, o bien de reconstrucciones geométricas computarizadas. Una vez este fichero este cargado, triangulado y renderizado no tiene porque volvernos a hacer falta, ya que la información pasara a fichero .triángulos el cual contendrá toda la estructura del objeto triangulada para así no tener que volver a cargar y perder el tiempo triangulando los puntos. Este fichero poseerá una copia exacta de los puntos del fichero de puntos, pero con la diferencia de que luego, una vez terminada la especificación de los puntos, vendrá la lista de triángulos, en la cual solamente habrá tres índices por cada triangulo donde cada índice será una posición de la lista que se formara nuevamente a la hora de cargar. Un ejemplo de este fichero seria como el de la Figura 21.

Figura 21. Ejemplo fichero triángulos

30

4.6 Estructuras de Datos

Para implementar todo lo que se expuesto anteriormente vamos a necesitar unas cuantas estructuras de datos, bien diferenciadas. A continuación presentamos una lista con todos las ED.

4.6.1 Punto

La primera y la principal de las estructuras es el punto, esta estructura nos sirve para almacenar otra estructura de datos llamada Point3d y un entero que será el índice donde se encuentra dicho punto dentro de una lista como podemos observar en la Figura 22. Con respecto a sus métodos todos son consultores, es decir simplemente devuelve el valor de los atributos contenidos.

Esta estructura se diseño con la intención de solucionar el problema de cómo exportar la información de una figura ya triangulada. El problema estaba en que si se imprimía un fichero con los puntos que forman los triangulo directamente, estaríamos repitiendo información y por lo tanto malbaratando recursos, lo cual en el mundo de la informática y en el real no tiene ningún sentido.

Una LinkedList es una estructura de datos proporcionada por java, la cual implementa una lista dinámica doblemente encadena, la cual nos permite recorrer uno a uno, así como también consultar el primero y el ultimo, así como utilizar los métodos de ordenación nativos sobre ella.

Un Point3d es una ED proporcionada por la librería grafica Java3D, que representa un punto en tres dimensiones, así pues contiene entre otros datos, las coordenadas x y z en formato de doublé para tener la mayor precisión posible. También incluye ciertos métodos bastante útiles como la distancia entre dos puntos etc. Con el uso de dicha estructura nos evitamos tener que implementar todas las estructuras de datos y así poder dedicar más tiempo en la implementación de código lógico.

Figura 22. ED Punto

31

4.6.2 Contorno

Se trata a de una estructura de datos que sirve únicamente para la encapsulación de Puntos. Como ya sabemos uno de los algoritmos utilizados trabaja con contornos, entonces se ha tenido que crear esta estructura que contiene una lista de Puntos para mantener la estructuración del código. También contiene una lista de puntos ordenada que es utilizada por el método ordenarRecta, una variable de tipo doublé perímetro y por cuestiones técnicas una seria de variables globales para hacer más fácil la programación. Podemos ver un ejemplo de la estructura en la Figura 23.

Con respecto a los métodos podemos decir que son todos consultores excepto los siguientes:

• odernarRecta: que se encarga de ordenar los puntos de manera que si trazamos una línea uniéndolos todos forme el cierre convexo la manera de actuar de este método esta explicada en el punto 4.3.1 es el ultimo algoritmo explicado de todos los que calculan el cierre convexo.

• calcularDestino: este método es llamado por el método ordenarRecta tantas veces como sea necesario mientras el punto retornado por este método sea diferente del punto inicial proporcionado por parámetro.

• perímetro: como ya sabemos para la otra parte del algoritmo de Ganapahthy necesitaremos el perímetro del contorno para saber si trazar de una manera u otra un triangulo entre los 2 contornos es cuestión.

Figura 23. ED Contorno

32

4.6.3 Triangulo

Es una estructura utilizada para almacenar los datos relativos a los triángulos generados por los diferentes algoritmos, como es normal incluye tres puntos de tipo Punto, donde se almacenan las coordenadas del triangulo. Contiene también las variables nx, ny y nz que son los valores de la normal que se calculan en el constructor del objeto justo después de inicializar los valores x y z con los que nos pasan por parámetro al crear el objeto. También almacenamos las variables A B C D que son las pertenecientes a las capitales de la ecuación del plano, que también se calcula en el constructor justo después de haber calculado las normales. Cabe destacar que la ecuación del plano la necesitamos para saber si el triangulo en cuestión es una cara interior o no. Posee un Vector3f normalVector que es una estructura proporcionada por la librería grafica para representar la normal a asociada a un objeto y así poder iluminarlo. Este vector también contiene la operación negate que es utilizada para cambiar la iluminación de una cara a su la do exterior o interior dependiendo de la posición inicial. Incluye también un bolean que nos ayudara en el momento de pintar las caras a saber si el triangulo mira hacia adentro o hacia fuera.

Con respecto a operaciones solo tenemos calcular normales, comprobar que la cara del triangulo sea interior o exterior y calcular plano, las demás son operaciones consultoras de los datos almacenados en cada una de las instancias de la clase triangulo.

La estructura del triangulo seria como la de la Figura 24.

Figura 24. ED Triangulo

33

4.6.4 Nodo

Es una estructura utilizada como solución al problema de la media de las normales en cada punto de una figura. Al calcular la normal asociada a un triangulo ósea una cara del objeto se produce un efecto bastante indeseado, ya que cada una se ilumina si tomar en cuenta la posición de las caras adyacentes como podemos observar en la Figura 25.

Figura 25. Iluminación Incorrecta

Como podemos observar en esta imagen cada triángulo tiene su propio vector normal a consecuencia de esto obtenemos una iluminación más bien poco realista. Para solucionar este problema se aplica una solución a la cual se la conoce como el alisado, que consiste en calcular la normal para cada uno de los puntos del polígono, haciendo la media de las normales adyacentes. Para hacer esto necesitamos saber por cada uno de los puntos que triángulos convergen en el mismo. Por ello se dio paso a la creación de esta estructura de datos en la que se almacena un punto y todos los triángulos donde se encuentra. El resultado a diferencia del anterior se puede ver en la Figura 26.

34

Figura 26. Iluminación Correcta

En esta imagen podemos observar que la iluminación del objeto es más realista ya que hemos hecho el suavizado por cada uno de los puntos.

Volviendo a la ED, podemos comentar que contiene dos estructuras complejas en su interior, una referencia a Punto y una lista de referencias a Triangulo, que están contenidas dentro de una LinkedList.

Todos los métodos que contiene esta estructura son para consultar la información contenida, excepto tres, addTriangulo, calcularNormal y esIgual.

• addTriangulo: se encarga de añadir en la lista de referencias una nueva hacia el triangulo que nos pasan por parámetro, siempre y cuando este no haya sido añadido aun.

• calcularNormal: el cálculo de la normal como antes ya se ha comentado se realiza consultado toda la lista de referencias a triángulos, extrayendo sus normales, calculando el sumatorio y dividiendo el por el numero de triángulos que hayan intervenido en el cálculo.

• esIgual: este método devuelve un bolean con el resultado de comprobar que el objeto en cuestión es igual al pasado por parámetro, en este caso para saber si un nodo es igual a otro comparamos el Punto.

35

Para hacernos una idea de cómo sería la estructura y lo que contendría podemos mirar la Figura 27.

Figura 27. Iluminación Correcta

Como podemos ver en la figura anterior el cuadro superior seria una cara de un cubo, o una pirámide vista desde arriba, que contiene seis triángulos. En los nodos podemos ver que es lo que se guarda realmente en cada una de las estructuras comentadas.

36

4.6.5 Polígono

En esta estructura de datos es donde se lleva a cabo casi toda la lógica del programa. Contiene una lista de puntos, la cual se la proporcionamos por parámetro a partir del constructor en la fase de instanciación del objeto. Incluye además una serie de listas, como son contornos para que cuando se ejecute Ganapathy lea de una variable global sin tener que utilizar el paso de parámetros, refPuntos que es una lista de nodos utilizada para solucionar el problema de la iluminación y la media de las normales, dos listas de triángulos una para cada algoritmo en las que se guardan instancias de Triangulo para luego poder traspasar dicha información a un fichero y por ultimo triangulosS que es de tipo TriangleArray. En la Figura 28 se muestra la estructura básica de un polígono.

Figura 28. ED Triangulo

Una TriangleArray es una estructura proporcionada por la librería grafica para formar lo que son las Shape3D, es decir las figuras en sí, que además de triángulos contiene una serie de atributos necesarios para poder obtener una buena visualización como por ejemplo los Vector3f para la iluminación. Por lo tanto en los métodos de construcción de triángulos tenemos un método que incluye el traspaso de una estructura a otra, calculando además las normales para cada unos de los puntos.

Para poder calcular las normales se ha tenido que crear una lista de nodos que guardan por cada punto en que triángulos se encuentra y así después poder calcular la media de las normales asociadas a dichos triángulos y obtener el suavizado en la iluminación.

37

En la siguiente lista analizaremos cada uno de los métodos de esta estructura:

• Guardar: este método devuelve un String con todos los datos que se van a escribir en el fichero de salida, esto se hace mediante un recorrido primero por la lista de puntos y añadiéndolos al String de retorno, luego te recorre una de las dos listas de triángulos en función de cual este inicializada y copian por cada uno los tres índices de la estructura Punto. Así conseguimos evitar el exceso de información.

• Leer: esta operación es justamente el caso contrario a guardar, simplemente nos pasan una lista de índices la cual recorremos leyendo de tres en tres ya que son los índices de los triángulos con que formaremos la figura.

• Ordenar: se encarga de organizar cada uno de los contornos por aquellos que forman el cierre convexo como ya se ha explicado en capítulos anteriores.

• Contornos: a partir del fichero de puntos, detectamos los contornos en función de la altura seleccionada por el usuario. Como ejemplo decir que si el usuario elije la z entonces este algoritmo ordena los puntos de menor a mayor en función del parámetro elegido y seguidamente realiza una lista con todos aquellos que coinciden en este, lo cual da origen a la estructura contorno, entonces la lista de contornos es actualizada.

• Ganapathy: se trata del método que implementa el algoritmo de triangulación de contornos, que se ha detallado en el punto 4.3.1. Únicamente añadir que en este método cada vez que acabamos el emparejamiento de dos contornos, ejecutamos el método comprobarCaras y seguidamente ejecutamos el pintarTriangulos.

• Delaunay: implementa la llamada a la librería Delaunay, y devuelve los puntos en dos dimensiones a los cuales se les añade la 3ra dimensión. Al igual que Ganapathy se llaman a sendos métodos, para conseguir la visualización.

• ComprovarCaras: es un método utilizado para saber si una cara es interior o exterior esto se consigue aplicando la teoría comentada en el punto 4.6.3. Con el único añadido que es llamado por los métodos Ganapathy y Delaunay, pasándole una lista de triángulos por parámetro. Dentro de este método hacemos un recorrido por dicha lista y encontrar cuales son o no interiores entonces marcamos el bolean cierto o falso.

• PintarTriangulos: utiliza una de las listas de triángulos para transformarlos en la TangleArray y aplicarle la normal a cada uno de ellos, comprobando el bolean que comentábamos en el apartado anterior, con esto se consigue escribir la variable triangulosS, que es precisamente la que consultamos desde el MenuPrincipal para crear el Shape3D utilizando el método getTriangulos.

• ActualizarRefPuntos: este método se ejecuta cada vez que se añade un triangulo al polígono, se encarga de mantener la lista de nodos actualizada para saber que triángulos tiene cada punto.

38

4.6.6 Ordena

Es una estructura de datos que se sirve para ser usada por el método sort, que es implementado por una clase interna de Java. Básicamente sirve para indicarle a java como tiene que ordenar los elementos que están dentro de una lista. Po ejemplo en nuestro caso las listas de puntos. La ordenación se realiza en función de una de las coordenadas, para ellos hay que indicarle las salidas en cada caso. Todo se implementa en el único método que posee la ED el compare, es precisamente el método que java llama a la hora de comparar un elemento con otro dentro de la operación de ordenación.

4.6.7 LeerFichero

Cuando instanciamos esta clase obtenemos un objeto que no contiene ningún tipo de datos, solo contiene un par de métodos que reciben un String por parámetro que es le path de un archivo. Los métodos son los presentados a continuación.

• LeerPuntos: se trata de una operación que devuelve una lista de tipo Punto, a partir de una dirección proporcionada por parámetro. La manera de leer es bastante sencilla, tenemos un FileReader y un bufferReader. El primero se utiliza para abrir el canal con el archivo en el dispositivo solido y el segundo lo utilizamos para ir guardando la información de cada una de las líneas del archivo. Luego se utiliza una estructura llamada StringTokenizer que nos sirve para separar el String que equivale a una línea del fichero en las partes que están separadas por espacio, que en este caso son las coordenadas x y z de uno de nuestros puntos. Una vez obtenemos los valores los normalizamos, ya que nuestro visualizador para tener una mayor precisión trabaja con números fraccionarios. Después se crea una estructura Point3d y otra Punto, al Punto se le asigna su Point3d y la posición que es el índice o altura de línea dentro del fichero.

• LeerTriangulos: funciona de manera similar el método leerPuntos, con la diferencia que cuando se recorre el fichero se comprueba si se ha llegado al carácter centinela, que no es más que un símbolo el elegido para que el programa pueda saber cómo actuar. En este caso el carácter centinela es “T” que nos sirve para saber donde comienzan los índices de los triángulos. El modo de funcionar es muy sencillo guardamos los índices de los mismos en una lista de enteros de tres en tres. Luego cuando tenemos los puntos y los índices creamos un polígono el cual construimos con los puntos obtenidos y luego le aplicamos el método leer, que se encarga de reconstruir la figura. Una vez echo esto devolvemos el polígono que será recibido por el programa principal para visualizarlo.

39

4.6.8 MenúPrincipal

Esta clase como su nombre indica implementa el menú que vemos por pantalla, pero además también se encarga de almacenar las llamadas a la librería grafica Java3D.

Como en todas las aplicaciones hechas en java que llevan interfaz grafica, esta clase contiene en forma de variables globales todas las estructuras necesarias para poder crear el entorno visual, en las que incluimos todo tipos de elementos como pueden ser paneles, botones, checkbox, radioButton, etc. La programación de cada uno de estos botones se ha realizado con clases anidadas. Como ya sabemos la respuesta a una interrupción realizado por un usuario en java a través de los eventos, dichos eventos se controlan a través de las clases antes mencionadas. También hay otras maneras de hacerlo, pero conllevan también un exceso de comprobaciones que son totalmente ilógicas en la capa superior de un programa.

Para la construcción de la interfaz grafica se utilizo IDE llamado NetBeans el cual nos permite, crear fácilmente la GUI de un programa, usando principalmente el ratón.

Esta clase incluye un MainFrame que es el sitio donde van incluidas todos los contenedores visuales, para java un mainframe es una ventana que utilizan los applets para ejecutarse. Dentro de los cuales podemos encontrar el Canvas3D que es la zona de dibujo proporcionada por la librearía grafica para poder dibujar.

También se almacenan los objetos necesarios para la creación de un escenario virtual como se ha explicado anteriormente.

En métodos tenemos:

• Init: que se encarga de inicializar todos los elementos visuales, pasando por la GUI, hasta la creación de un entorno tridimensional preparado para cuando se haga la carga de un archivo de puntos.

• crearEscenario: esto método devuelve un BranchGroup elemento necesario para la creación de la escena dentro del simpleUnivers.

• Main: este método lo único que hace es crear un mainframe y pasarle como contenedor de objetos visuales, un MenuPrincipal. Cabe destacar que el método main es aquel que todo programa escrito en java, busca el primero cuando se hace una ejecución.

40

5. Desarrollo

En este apartado se trata de realizar un recopilatorio en orden de todas las tareas realizadas durante la ejecución del proyecto. Desde el estudio previo junto con las pruebas iniciales hasta la construcción de la Gui.

5.1 Primeros Pasos

Este proyecto comenzó por una fase documental donde el autor, tuvo que buscar mucha información sobre todo lo relacionado con el tema, ya que era bastante desconocido para si mismo.

Primero y como el proyecto al principio fue enfocado de otra manera la documentación iba mas enfocada a la simplificación de mallas de triángulos ya construidas. Después se decidió que el alcance seria más bien la construcción de dichas mallas.

Entonces comenzó la recolecta de información que trataba sobre triangulación, entornos 3D (Java3D), algoritmos etc.

5.2 Pruebas Iniciales

Una vez delimitados los colindares del proyecto, entonces se paso a probar el entorno en 3D elegido. Para realizar esta pruebas se utilizaron infinidad de ejemplos, pero los más importes y más claros fueron el paquete de ejemplos creado por Sun Microsystem que se llama Java 3d Programing. En dicho paquete se encuentra toda la información relativa al visualizador, donde se explica detalladamente cómo funcionan todas las estructuras. Los ejemplos en código también fueron de mucha ayuda, dada la inexperiencia del autor en este tipo de entornos.

5.3 Carga Ficheros

Luego cuando el panel visual estaba controlado, se paso a la primera parte de todo programa informático que es la obtención de los datos para pode trabajar. Al principio se hacia un simple recorrido por el fichero, se obtenían los puntos y luego se mostraban por pantalla, luego a medida que se fue avanzando, a parte de la lectura se requería que los puntos proporcionados vinieran en forma de contornos, para ello se tuvo que crear la clase Contorno, en la cual se guarda una lista de los puntos pertenecientes a cada uno de los contornos, así como también otros datos para poder realizar cálculos posteriores. La manera de ordenar estos puntos hace referencia al método explicado en el punto 4.6.3.

41

5.4 Visualización de Contornos

Después de haber obtenido la lista de puntos ordenada por contornos, había que visualizarla en este caso había varias opciones. El entorno visual nos proporcionaba dos estructuras de datos ideales para hacer esta representación. Se trata de LineArray y LineStripArray, la primera funciona por pareja de puntos, ósea que traza una línea cada dos puntos, por lo que fue necesario pasarle siempre el punto anterior para que quedara una línea uniforme. En el caso del LineStripArray pudimos observar que la funcionalidad que ofrecía era exactamente la que antes se describe pero ya estaba implementada por la librería grafica con el fin de hacer más fácil la programación.

Además luego de hacer esto se utilizo el algoritmo de Graham para obtener el mismo resultado pero con más eficiencia.

5.5 Triangulación Contornos

Una vez teníamos los contornos teníamos que aplicar el método de Ganapthy a los mismos para poder obtener los triángulos. Para esta fase fueron necesarias bastantes horas de programación ya que las pruebas de estos algoritmos son básicamente visuales y numéricas, es decir el resultado ofrecido es un punto con sus tres coordenadas o es la representación de las mismas en el espacio 3D que es muy complicado de observar.

En este punto se dio una restructuración del proyecto ya que se creó la clase Polígono que iba a ser la encargada de ejecutar los métodos de triangulación, por tanto contiene todos los datos necesarios para esto, una lista de contornos, puntos, triángulos etc. También fue necesaria la creación de la estructura Triangulo el cual contiene tres puntos en tres dimensiones, un vector normal, las capitales de la ecuación del plano que forma dicho triangulo y un booleano que nos indica si es cara positiva o negativa para posteriores comprobaciones.

Luego se dio paso a la codificación del método de Ganapathy, donde encontramos unos cuantos problemas. Java3D tiene implementadas unas estructuras de datos que contienen los triángulos y a partir de ellos generan automáticamente la visión de este objeto construido a base de triángulos. Primero se intento utilizar la estructura TriangleStripArray que parecía la mas adecuada ya que como en el LineStripArray une el ultimo triangulo añadido al vector con el que se está añadiendo, pero esto ocasiono problemas a la hora de girar los triángulos. Entonces se decidió usar la TriangleArray que genera los triángulos uno a uno añadiendo de tres en tres puntos, con lo que el problema de cambiar el orden en que se añaden los triángulos tenía una solución trivial.

Otro punto importante estaba en la actualización de una lista de nodos la cual contenía la información necesaria para posteriormente calcular la media de las normales como comentaba en el punto 4.6.1.

42

5.6 Visualización de Triángulos

Luego de tener las estructuras de datos proporcionadas por Java3D bien inicializadas, solamente hace falta crear un BrachGroup, el cual contiene dentro un TransformGroup es propiamente al que se le agrega la figura. Primero hay que crear una estructura Shape3D a la cual se le pasa la TriangleStripArray genrada anteriormente, luego añadir esta al TransformGroup. Tambien se aplican al Tg las propiedades de escala, iluminación, niebla etc. Luego se compila el BrachGroup y entonces esta lista visualización del objeto.

5.7 Triangulación Puntos

Una vez realizados todos los pasos anteriores, quedaba comparar la triangulación de Ganapathy con la de otro algoritmo que no simplificara tanto los puntos del objeto. Entonces se realizo la implementación de un paquete que contiene Delaunay, la dificultad de esta tarea estuvo en comprender que este algoritmo funciona en 2D y que nosotros necesitamos la proyección de nuestro modelado en 3D como se explica en el apartado 4.3.2, por esta razón también se tuvo que adaptar para que admitiera que la altura del objeto fuese cualquier coordenada x y z. A raíz de esto se han producido problemas que no se han podido resolver como el hecho de que haya figuras que no acaban de cerrar todas sus posiciones con triángulos. Se pensó en las soluciones para resolver el problema, las cuales pasan por tratar el objeto de manera en que se puedan detectar sus caras exteriores por cada una de las coordenadas y así aplicar el algoritmo a cada una, luego detectar los puntos de unión entre los objetos generados y aplicar un cierre de triángulos.

5.8 Obtención de las Caras Externas

Como ya se ha comentado en el punto 4.6.3, cada vez que se genera una figura a partir de triángulos caemos en el problema de que estos estén orientados hacia adentro o hacia el exterior de la figura. Este problema se soluciono aplicando la teoría presentada en el apartado antes mencionado, pero surgió otro problema, si la figura fuese de contornos no cerrados, es decir que no formara un polígono cosa que se origina aplicando Delaunay, esta solución no funciona correctamente, ya que la comprobación de un triangulo se realiza con triángulos ubicados en el lado contrario, en este caso dichos triángulos no se encuentran en la posición adecuada. Por lo que entonces se planteo que la solución sería calcular el centro del objeto algo que no es trivial, porque depende de la situación en que se encuentren los puntos que forman al mismo.

43

5.9 Creación de la GUI

Este fue uno de los pasos más fáciles como en casi todos los programas. Se ha creado una GUI fácil de usar intuitiva que contiene básicamente las opciones básicas de visualización en 3D. Fue realizada en netBeans y adaptada para poder pasar a Eclipse e integrarla con el programa ya acabado.

5.10 Guardado Datos

Luego de hacer la GUI, se hicieron los últimos retoques para que el proyecto tuviera un poco más de usabilidad, como por ejemplo el guardado de la figura que se estuviera visualizado, esto se realiza mediante la creación de una estructura que encapsula un punto3D y que guarda en qué posición de la lista se encuentra. Así a la hora de construir un triangulo sabemos en posición de la lista esta cada punto. Por consiguiente si queremos guardar el esta de los triángulos, lo único que tenemos que hacer es guardar la lista de puntos intacta sin hacer ningún cambio y luego consultar la lista de triángulos uno a uno para imprimir los índices en que se encuentra cada uno de los puntos.

5.11 Carga de Datos

Ya tenemos el fichero con sus datos, la manera de leerlo será muy sencilla, ya que cuando empezamos a escribir los triángulos dejamos una marca, para que a la hora de leer sea más sencillo identificar a partir de donde están definidos los triángulos. Primero cargamos la lista de puntos, y luego simplemente ensamblamos los triángulos a partir de los índices proporcionados por el fichero.

44

6. Evaluación

El análisis de los resultados de este proyecto se realiza a partir de la observación de algunos modelos.

Primero vamos a enseñar la figura que usamos como phantom y luego mostraremos algunas figuras un poco más complejas. Seguidamente se hará el análisis de resultados y sus conclusiones.

6.1 Phantom En la Figura 29 podemos observar lo que sería una colección de puntos simplificada del un modelo creado a partir de computación geométrica.

Figura 29. Estado Inicial

45

Aplicando el algoritmo de Ganapathy obtenemos la triangulación de la Figura 30

Figura 30. Triangulado

Por último en la Figura 31 podemos apreciar la figura con la iluminación aplicada.

Figura 31. Iluminación

46

6.2 Ruinas Podemos observar en la Figura 32 la estructura de puntos de una ruina creada a partir de un modelo computado.

Figura 32. Puntos Ruina

En la Figura 33 podemos observar el modelo triangulado por Delaunay.

Figura 33. Triángulos Ruina Delaunay

47

En la Figura 34 podemos observar el modelo triangulado por Ganapathy.

Figura 34. Triángulos Ruina Ganapathy

Por último en la Figura 35 encontramos el modelo con iluminación aplicada.

Figura 35. Iluminación Ruina

48

6.3 Forma 1 En este se ha tomado un fichero de puntos de una figura real, analizada con un escáner de rayos. La figura original la podemos aprecia en la Figura 36.

Figura 36. Figura real

La triangulación de Delaunay es la que se encuentra en la imagen que se muestra en la Figura 37. La triangulación por Ganapathy se encuentra en la imagen que muestra la Figura 38.

Figura 37. Triangulación Delaunay

49

Figura 38. Triangulación Ganapathy

50

6.4 Forma 2 Igual que en el apartado anterior presentamos un ejemplo real y sus respectivas triangulaciones. La foto de la figura es la Figura 39 y sus respectivas triangulaciones de Delaunay y Ganapathy son la Figura 40 y 41.

Figura 39. Ejemplo Real Cilindro

51

Figura 40. Triangulación Delaunay

Figura 41. Triangulación Ganapathy

52

6.5 Forma 3 Seguimos analizando figuras reales con nuestros dos algoritmos, en el orden Figura 42 forma real, Delaunay Figura 43, Ganapathy Figura 44.

Figura 42. Figura Real

Figura 43. Triangulación Delaunay

53

Figura 44. Triangulación Ganapathy

6.6 Forma 4 Por último presentamos la última reproducción de un objeto real en la Figura 45 y sus triangulaciones Figura 46 y Figura 47.

Figura 45. Figura real

54

Figura 46. Triangulación Delaunay

Figura 47. Triangulación Ganapathy

55

6.7 Análisis de Resultados

A continuación se presenta los resultados numéricos obtenidos en todas las pruebas realizadas para poder realizar la comparación entre un algoritmo y otro.

Los resultados vienen dados por los Puntos Originales de cada una de las piezas trianguladas, los Puntos que se obtienen después de triangular y el número de triángulos. También se incluyen el porcentaje de simplificación y calidad para poder hacer comparaciones entre los dos algoritmos. El porcentaje de simplificación indica el número de puntos perdidos durante la simplificación y el porcentaje de calidad indica justamente lo contrario, el número de puntos que cumplen con los iníciales. La calidad en este caso es medida como la cantidad de parecido a los puntos reales que tiene la triangulación.

La Figura 48 contiene los resultados pertenecientes al algoritmo de Delaunay.

Modelo Puntos Originales

Puntos Obtenidos

Triángulos Obtenidos

Porcentaje de simplificación

Porcentaje de calidad

Phantom 7855 4310 8492 45,13 54,86950987 Ruina 5226 1414 2732 72,94 27,05702258 Forma1 450 450 786 0,00 100 Forma2 550 550 993 0,00 100 Forma3 450 450 786 0,00 100 Forma4 900 900 1605 0,00 100

Figura 48. Resultados Delaunay

0

1000

2000

3000

4000

5000

6000

7000

8000

9000

Puntos Originales

Puntos Obtenidos

Triangulos Obtenidos

56

La Figura 49 contiene los resultados pertenecientes al algoritmo de Ganapathy.

Modelo Puntos Originales

Puntos Obtenidos

Triángulos Obtenidos

Porcentaje de simplificación

Porcentaje de cailidad

Phantom 7855 2007 4035 74,45 25,55060471 Ruina 5226 381 766 92,71 7,290470723 Forma1 450 84 140 81,33 18,66666667 Forma2 550 99 174 82,00 18 Forma3 450 93 159 79,33 20,66666667 Forma4 900 211 398 76,56 23,44444444

Figura 49. Resultados Ganapathy

0

1000

2000

3000

4000

5000

6000

7000

8000

9000

Puntos Originales

Puntos Obtenidos

Triangulos Obtenidos

57

Una vez realizada la recogida de resultados se procede a la comparación de los mismos, para ello nos ayudamos con el grafico de la Figura 50.

Figura 50. Comparativa Resultados

En grafico podemos ver que los porcentajes de simplificación en general del algoritmo de Ganapathy son bastante más elevados y constantes que los proporcionados por Delaunay, pero como también podemos observar la pérdida de calidad aplicando Ganapathy es bastante amplia en comparación con los resultados obtenidos por Delaunay.

Por lo tanto se concluye que cada una de los algoritmos se utilizara en función de los requerimientos, si lo que se necesita es una figura aproximada a la realidad y que no necesite muchos recursos se utilizará Ganapathy. Pero por el contrario si lo que de necesita es una figura con el máximo de detalles posible sin importar el coste se utilizara Delaunay.

0,00

20,00

40,00

60,00

80,00

100,00

120,00

Porcentaje Simplificación Ganapathy

Porcentaje Calidad Ganapathy

Porcentaje Simplificación Delaunay

Porcentaje Calidad Delaunay

58

7. Conclusiones

Una de las conclusiones seria que el mundo de la reconstrucción en tres dimensiones, a partir de nubes de puntos, es bastante complicado y extenso. Con lo cual la solución dada por este proyecto parece ínfima ante la cantidad de información y problemas que se pueden llegar a tratar relacionados con este tema. No obstante se ha ofrecido de una manera sencilla y clara una solución al problema presentado.

Por otro lado y basándonos puramente en los colindares del proyecto, podemos decir que el objetivo de conseguir una clara comparación entre dos maneras de entender el problema planteado ha sido conseguido con éxito. Con lo que surgen dos conclusiones más, que no son más que la explicación de para que se debe utilizar cada una de las soluciones propuestas.

En el caso de los contornos podemos concluir, que será una solución muy ágil, rápida y que simplifica muy bien la figura con la que vamos a tratar, siempre y cuando los puntos de nuestra nube vengan dados en forma de contornos, es decir que tres puntos como mínimo compartan siempre un plano, ya que si no sería imposible de aplicar esta solución.

En el otro caso podemos decir que es una solución muy válida y que refleja de una manera lo más realista posible lo que se quiere representar con la figura obtenida a partir de los puntos. El problema está en que este método estaba pensado para una triangulación de puntos que vienen todos en 2D como los de la superficie de un terreno, entonces es cuando esta triangulación se complica ya que hay que aplicar métodos bastante difíciles para obtener la triangulación completa en 3D.

Para comparar estos algoritmos solo hace falta ver la manera en que se ejecutan, cuanta información llegan a tratar y cuanto tiempo tardan en hacerlo. Por ejemplo el problema de los contornos funciona más rápidamente, ya que al aplicar la ordenación de los puntos y construir el cierre convexo se eliminan el 60% de los puntos, cosa que hace que seguidamente en la triangulación no hagan falta tantas vueltas de CPU, pero sin embargo en este problema se ofrece la realidad de una manera muy vaga debido a la perdida de información. El caso de Delaunay tarda bastante más porque trata con el 100% de la información dada y porque la estructura interna del algoritmo función a base de fuerza, es decir prueba y error, en cambio y a diferencia de Ganapathy ofrece la realidad tal y como es sin ningún tipo de reducción de calidad.

Po lo tanto si lo que se quiere es una vista rápida de un objeto en tres dimensiones es preferible usar la solución de los contornos, pero por el contrario si lo que se desea es precisión a la hora de visualizar los datos, es mejor usar la triangulación directa de todos los puntos sin simplificar. A este se le pueden añadir muchas otras conclusiones como, si lo que se desea es un sistema compatible con móviles y que pueda ser reproducido fácilmente desde una navegador web es mejor utilizar una versión simplificada del objeto, ya que estos dispositivos no poseen la suficiente potencia de cálculo como para dar un tiempo de respuesta adecuado.

59

8. Recursos Utilizados

Para la realización del proyecto se han utilizado básicamente apuntes y algunas páginas web como ayuda. A continuación se presenta una lista:

A New General Triangulation Method for Planar Contours - S.Ganapathy

Visualitzacio de Dades en 2 i 3 Dimensions - Maria Ferré Bergadà - URV

Elements Bàsics en la Representació Gràfica - Maria Ferré Bergadà - URV

Envolupant Convexa - Vera Sacristan - UPC

Triangulacions de Núvols de Punts - Vera Sacristan - UPC

Computer Graphics Using Java 2D and 3D - Hong Zhang -Atlantic State University

The Java 3D API Specification - Sun Microsystems

http://www.elai.upm.es/spain/Investiga/GCII/personal/lrodriguez/web3D/

http://gts.sourceforge.net/samples.html

http://www.java3d.org/

Para el desarrollo del proyecto en la parte de software se ha utilizado básicamente el editor Eclipse y para la realización de la GUI el Net Beans. En la parte de hardware se ha utilizado un portátil genérico.

60

9. Manual

Este apartado se subdivide en dos partes el manual de usuario y el de administrador, a continuación se presentan los dos tipos de manuales.

9.1 Manual del Usuario

Como en todos los manuales en este se explicara cómo hacer que la aplicación funcione y como aprovechar al máximo sus prestaciones.

Una vez tenemos la aplicación en ejecución nos encontramos un menú donde hay una seria de opciones, si hacemos clic en la primera Archivo se despliega un menú contextual donde podremos elegir varias opciones como se expresa en la Figura 51.

Figura 51. Archivo

Tenemos cuatro opciones Guardar que en el estado inicial no está permitido ya que no existe ningún modelo en el área de dibujo, Cargar que se encarga de almacenar en memoria todos los puntos provenientes del fichero indicado, Leer que importa un fichero .triángulos para así no tener que realizar toda la triangulación y salir que es evidente.

61

El siguiente paso sería el de cargar un modelo, inmediatamente después de cargarlo nos aparece por la Consola el número de puntos que posee el modelo como podemos ver en la Figura 52.

Figura 52. Carga modelo

Luego nos encontramos en situación de poder hacer la primera triangulación, para ello nos vamos al menú triangulación y escogeremos una de las dos opciones en este y para este manual escogeremos Ganapathy, una vez escogida la triangulación el programa responde con el cálculo on-line de dicha triangulación y seguidamente la muestra por la zona de pintado negra como podemos observar en la Figura 53.

Figura 53. Archivo cargado

62

Una vez hecho esto tenemos todas las opciones que se encuentran en la parte inferior de la interfaz de usuario. Altura es un parámetro que se debe utilizar antes de la triangulación ya que determina porque eje va a triangular el algoritmo elegido. El modo hace referencia a la manera en que se muestra la figura por puntos, líneas, el poligo cerrado o se debe de rotar, un ejemplo en la Figura 54 y Figura 55.

. Figura 54. Puntos

Figura 55. Polígono

63

También está el menú de coloreado, que muestra la figura de color Único que sería blanco, color Fondo que es el verde y si se quiere más realismo se selecciona Iluminación como se puede ver en la Figura 56.

Figura 56. Polígono con iluminación

Una vez hecho esto podemos guardar el modelo triangulado con el botón de Archivo-Guardar o si no podemos borrar toda la escena para volver a cargar otra con el botón Borrar.

Luego de haber guardado el modelo podemos hacer Archivo-Leer seleccionamos una archivo .triángulos y automáticamente tendremos la figura antes guardada visualizándose por la pantalla.

Existe también otro submenú llamado visualización en cual encontramos las opciones Modelo y contornos. Estas opciones hacen referencia a lo que se ve por pantalla, en el caso de haber triangulado por Ganapathy tendremos disponible también la visualización de los contornos relativos a la figura.

64

9.2 Manual del Administrador

9.2.1 Recursos Necesarios

En esta sección hablaremos de lo que hace falta, para que esta aplicación funcione correctamente, es decir que características tiene que tener nuestro ordenador para poder ejecutar el programa.

Las especificaciones mínimas recomendadas por la librería grafica son las siguientes:

• 500Mhz de frecuencia del procesador principal. • Una tarjeta grafica dedicada con al menos 16MB de memoria. Tiene

que incluir compatibilidad adecuada con OpenGl, cosa que hoy en día cualquier tarjeta grafica cumple.

• 128MB de RAM en el sistema.

Ahora bien estas especificaciones se refieren solo al visualizador en tres dimensiones, no incluye la memoria gastada por los cálculos realizados para obtener la malla de triángulos.

Para poder hacernos una idea de que recursos vamos a necesitar, tendremos que contar con los gastos incluso del sistema operativo, basándonos en el ordenador donde se ha realizado las pruebas. Hoy en día un sistema operativo común “Windows Vista”, consume alrededor de 1GB de memoria RAM sin utilizar ningún programa. Con este dato y con los requerimientos mínimos del visualizador obtenemos que se necesitan 1128MB. Pero en este cálculo aun falta por incluir lo que consume el resto de la aplicación, a continuación se realiza un cálculo estimado del consumo de memoria de la aplicación. Si contamos que consume unos 80MB en estado inicial es decir sin ningún modelo cargado, y además contamos que cuando ejecutamos el algoritmo más pesado Delaunay consume 261MB más desde el momento de ejecución del algoritmo hasta la visualización. Cabe destacar que estos cálculos se han realizado con el modelo phantom el cual contiene unos 7855 puntos, mientras mas puntos se tengan mayor será la exigencia de memoria del programa.

En conclusión estamos hablando de que la maquina necesita 1,5 GB de memoria RAM para poder optar a una figura como esta, que es considerada bastante pequeña. El consumo absoluto para este caso sería 469MB. Este programa también da la posibilidad de cargar varios modelos a la vez, por lo que si cargáramos unas cuantas figuras como este necesitaríamos una maquina bastante actual para poder hacerlo todo con suavidad.

Hablando de la memoria surge el tema de la memoria asignada a la maquina virtual, la cual tiene por defecto 128MB de RAM asignados, lo cual quiere decir que el programa no funcionaria, ya que podríamos arrancarlo pero a lo hora de ejecutar cualquiera de los 2 algoritmos de triangulación encontraríamos que salta una

65

excepción donde la maquina virtual nos informad de la memoria ha sido excedida. Para esto java incluye una opción de ejecución, con la que le podemos decir a la maquina virtual cuanta memoria tendrá que reservar para que el programa funcione con normalidad. El comando es –Xmx1024m donde 1024 es la cantidad de memoria que se quiere asignar. En este caso se ha decido asignar esta cantidad para así no tener ningún tipo de problema a la hora de cargar varios modelos a la vez. Hay que recordar que si se quieren varias instancias del programa abiertas cada uno de ellos reservara una cantidad de 1GB de memoria, por lo que depende de la maquina solo nos permitirá un par de instancias como máximo.

9.2.2 Instalación

Para hacer la instalación del programa basta con ejecutar el archivo .jar proporcionado, o también está la opción de ejecutar a través de un .bat que también ha sido incluido en la entrega digital, caso de sea otro sistema operativo como por ejemplo cualquiera de los provenientes de UNIX se tendrá que hacer la ejecución a través de una consola empleando línea de comandos.

Dicha instalación es tan sencilla porque trabajamos con java, que como comentábamos en la parte de diseño, es un lenguaje parcialmente interpretado. Casi todos los lenguajes de este tipo se ejecutan sobre una maquina virtual. Dicha maquina funciona a modo de un pequeño sistema operativo que solo entiende de programas escritos en java. De ahí que el mismo programa funcione en tantos dispositivos diferentes sin necesidad de hacer copias especializadas en uno u otro sistema operativo general.

Un fichero .jar es una compresión de un conjunto de ficheros .java llamados clases, para la maquina virtual de java estos ficheros comprimidos son como para un sistema operativo lo que sería un archivo .exe un ejecutable común, que igual que el jar contiene toda la lógica de aplicación.

Un fichero .bat es un fichero que contiene un conjunto de comandos de la consola de Windows, con estos .bat lo que se consigue es poder hacer la compilación del programa con tan solo tener los ficheros base, es decir los .java. Para la ejecución por líneas de comandos también se suelen utilizar .bat ya que las llamadas para ejecutar un programa en java suelen contener muchos paquetes. Esto paquetes no son más que una agrupación ce clases para poder obtener una mejor estructuración del código fuente.

Para un sistema operativo diferente como por ejemplo cualquiera que sea proveniente de UNIX, podemos también crear un script que se encargue de ejecutar los comandos necesarios.

Evidentemente todos estos procesos necesitan que antes haya sido instalada la maquina virtual de java, para ello tenemos la web oficial desde donde podemos descargarla específica para casi cualquier sistema operativo. La dirección web es http://www.java.com/es/download/index.jsp que se muestra también en la Figura 57.

66

Figura 57. Maquina Virtual

Si lo que queremos es ejecutar el fichero .bat para compilar el código antes de ejecutarlo, necesitaremos también el JDK que es el kit de desarrollo de java. Para conseguirlo también podemos entrar a la siguiente web y seguir los pasos, que incluyen cambiar variables de entorno de nuestro sistema operativo, la Figura 58 muestra la dirección web http://java.sun.com/javase/downloads/index.jsp y que JDK se debe de elejir.

Figura 58. JDK

67

También se proporciona en formato digital un fichero .zip que contiene los ficheros del proyecto creado por eclipse. Para poder cargar estos ficheros en eclipse es necesario seguir los siguientes pasos exactamente:

i. Abrir eclipse ii. Una vez abierto seleccionar de la barra la opción file y luego import tal y

como se muestra en la Figura 59.

Figura 59. Eclipse Import

iii. Luego en el wizard seleccionar en la carpeta General la opción Archive File como se muestra en la Figura 60.

Figura 60. Import

68

iv. Una vez hecho esto nos aparecerá otra ventana con el selector del proyecto guardado en .zip y luego en que proyecto queremos depositarlo, evidentemente antes de hacer esto tendremos que haber creado un proyecto vacio, un ejemplo de ello lo vemos en la Figura 61.

Figura 61. Import

Con esto tendríamos el proyecto cargado en eclipse, a partir de aquí podemos hacer ejecutar el código con el botón run con el tipo icono de la flecha. También hay que decir que eclipse es un entorno de desarrollo que se encarga de revisar la sintaxis continuamente y la compilación la realiza en el momento antes de ejecutar el programa.

69

9.2.1 Manipulación de Ficheros

Como ya se explico en el apartado 4.6 la información tratada por este programa viene dada en forma de ficheros, se han creado dos tipos de ficheros los de entrada .puntos y los de salida .triángulos. Esta terminaciones son solamente identificativas podemos utilizar cualquier fichero .txt para cargar sus datos en la aplicación, siempre que posea la estructura comentada en el punto mencionado.

Hay que decir que puede que los ficheros de puntos pueden variar en función de los programas que los crean, por ejemplo los puntos de nuestro programa viene cada uno en una línea, pero también existen modelos donde los puntos se separan por comas y caben muchos más por línea.

También hay que recordar que si las estructuras de ficheros no son las adecuadas el programa podría presentar respuestas inesperadas. Por ejemplo un fichero .triángulos que contenga el carácter centinela T para delimitar donde empiezan los triángulos solo leería puntos.

70

10. Agradecimientos

Para finalizar recordar a todas las personas que han hecho posible la realización y culminación de este proyecto con buen pie. He contando con un grupo de personas que son a mi manera de ver inigualables, que son, mis padres, hermana, la tutora, los amigos, otros profesores que han sido de mucha ayuda y a ti cariño por estar ahí siempre.

Gracias a todos ellos por su comprensión y gran valía, Gracias...