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

Departament d’Enginyeria Informàtica i M atemàtiques
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
Índice
1.
Introducción ................................................................................................................... 4
2.
Objetivos ........................................................................................................................ 6
3.
4.
2.1
Objetivo Principal ............................................................................................................... 6
2.2
Objetivos Secundarios ........................................................................................................ 6
Especificaciones ............................................................................................................. 7
3.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
Diseño........................................................................................................................... 13
4.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
2
5.
6.
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
Desarrollo ..................................................................................................................... 40
5.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
Evaluación .................................................................................................................... 44
6.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 ................................................................................................................ 58
8.
Recursos Utilizados ...................................................................................................... 59
9.
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
3
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.
4
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.
5
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.
6
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.
7
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ú
8
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.
Guardar
i.
ii.
iii.
iv.
El usuario hace clic sobre archivo y luego sobre Guardar.
El sistema responde llamando a la ventana de selección de archivo.
El usuario eligen un directorio y escribe el nombre del archivo, luego hace
clic en guardar.
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.
Cargar
i.
ii.
iii.
iv.
El usuario hace clic sobre archivo y luego sobre Cargar.
El sistema responde llamando a la ventana de selección de archivo.
El usuario selecciona el archivo y presiona abrir.
El sistema inicializa las estructuras de puntos y muestra por la consola el
número de puntos cargados.
9
Leer
i.
ii.
iii.
iv.
v.
El usuario hace clic sobre archivo y luego sobre Leer.
El sistema responde llamando a la ventana de selección de archivo.
El usuario selecciona el archivo y presiona abrir.
El sistema crea una estructura triangular a partir de la información obtenida
del fichero seleccionado.
El sistema visualiza dicha estructura.
Salir
i.
ii.
El usuario hace clic sobre archivo y luego sobre Salir.
El sistema termina la ejecución del programa.
Delaunay
i.
ii.
iii.
El usuario hace clic sobre Triangulación y luego sobre Delaunay.
El sistema crea una figura nueva, ejecutando el código perteneciente al
algoritmo escogido.
Seguidamente el sistema muestra la figura por pantalla.
Ganapathy
i.
ii.
iii.
El usuario hace clic sobre Triangulación y luego sobre Ganapathy.
El sistema crea una figura nueva, ejecutando el código perteneciente al
algoritmo escogido.
Seguidamente el sistema muestra la figura por pantalla.
Modelo
i.
ii.
iii.
El usuario hace clic sobre Visualización y luego sobre Modelo.
El sistema comprueba la si la opción es posible en ese instante.
Seguidamente el sistema muestra la figura por pantalla con todos sus
características y opciones disponibles.
Contornos
i.
ii.
iii.
El usuario hace clic sobre Visualización y luego sobre Contornos.
El sistema comprueba que se trate de una figura triangulada por Ganapathy.
Seguidamente el sistema muestra únicamente los contornos que forman
dicha figura.
Instrucciones
i.
ii.
iii.
iv.
El usuario hace clic sobre Ayuda y luego sobre Instrucciones.
El sistema abre una ventana donde se muestra un pequeño manual de uso
rápido.
El usuario hace clic en aceptar.
El sistema cierra la ventana.
10
Sobre el Autor
i.
ii.
iii.
iv.
El usuario hace clic sobre Ayuda y luego sobre Sobre el Autor.
El sistema abre una ventana donde se muestra la información relativa al
autor del proyecto.
El usuario hace clic en aceptar.
El sistema cierra la ventana.
Único
i.
ii.
iii.
El usuario hace clic sobre Único.
El sistema realiza los cambios en la escena grafica para que la figura acabe
pintada de blanco.
El sistema muestra la figura con los cambios.
Fondo
i.
ii.
iii.
El usuario hace clic sobre Fondo.
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.
El sistema muestra la figura con los cambios.
Iluminación
i.
ii.
iii.
El usuario hace clic sobre Iluminación.
El sistema realiza los cambios en la escena grafica para que la luz definida
inicialmente actúe sobre el objeto que se esta visualizando.
El sistema muestra la figura con los cambios.
Puntos
i.
ii.
iii.
El usuario hace clic sobre Puntos.
El sistema realiza cambios sobre la apariencia de la figura que se visualiza,
para visualizar únicamente los puntos de la misma.
El sistema muestra la figura con los cambios.
Líneas
i.
ii.
iii.
El usuario hace clic sobre Líneas.
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.
El sistema muestra la figura con los cambios.
Polígono
i.
ii.
iii.
El usuario hace clic sobre Único.
El sistema muestra los triángulos generados por nuestros algoritmos, la
diferencia es que las caras están pintadas.
El sistema muestra la figura con los cambios.
11
Rotación
i.
ii.
iii.
El usuario hace clic sobre Rotación.
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.
El sistema muestra la figura rotando o no.
X
i.
ii.
iii.
El usuario hace clic sobre X.
El sistema cambia la asignación de una variable hacia x, esta luego es
comprobada a la hora de realizar la triangulación.
El sistema muestra la figura rotando o no.
Y
i.
ii.
iii.
El usuario hace clic sobre Y.
El sistema cambia la asignación de una variable hacia y, esta luego es
comprobada a la hora de realizar la triangulación.
El sistema muestra la figura rotando o no.
Z
i.
ii.
iii.
El usuario hace clic sobre Z.
El sistema cambia la asignación de una variable hacia z, esta luego es
comprobada a la hora de realizar la triangulación.
El sistema muestra la figura rotando o no.
Borrar
i.
ii.
iii.
El usuario hace clic sobre Borrar.
El sistema elimina todas las figuras del marco de visualización.
El sistema se mantiene a la espera de la carga de otro archivo para poder
seguir mostrando figuras.
12
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.
13
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
14
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
15
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.
16
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.
17
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
18
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
19
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
20
•
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
21
•
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.
22
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
23
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.
24
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
25
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
26
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(𝑦𝑦𝑖𝑖 − 𝑦𝑦𝑗𝑗 ) ∗ (𝑧𝑧𝑖𝑖 − 𝑧𝑧𝑗𝑗 )
Ny=∑𝑛𝑛𝑖𝑖=1(𝑧𝑧𝑖𝑖 − 𝑧𝑧𝑗𝑗 ) ∗ (𝑥𝑥𝑖𝑖 − 𝑥𝑥𝑗𝑗 )
Nz=∑𝑛𝑛𝑖𝑖=1(𝑥𝑥𝑖𝑖 − 𝑥𝑥𝑗𝑗 ) ∗ (𝑦𝑦𝑖𝑖 − 𝑦𝑦𝑗𝑗 )
(5)
(6)
(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
27
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.
28
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
29
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
30
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
31
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
32
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.
33
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.
34
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.
35
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.
36
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.
37
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.
38
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.
39
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.
40
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.
41
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.
42
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.
43
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
44
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
45
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
46
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
47
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
48
Figura 38. Triangulación Ganapathy
49
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
50
Figura 40. Triangulación Delaunay
Figura 41. Triangulación Ganapathy
51
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
52
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
53
Figura 46. Triangulación Delaunay
Figura 47. Triangulación Ganapathy
54
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.
Puntos
Modelo Originales
Phantom
7855
Ruina
5226
Forma1
450
Forma2
550
Forma3
450
Forma4
900
Puntos
Obtenidos
4310
1414
450
550
450
900
Triángulos
Obtenidos
8492
2732
786
993
786
1605
Porcentaje de
simplificación
45,13
72,94
0,00
0,00
0,00
0,00
Porcentaje de
calidad
54,86950987
27,05702258
100
100
100
100
9000
8000
7000
6000
5000
4000
Puntos Originales
3000
Puntos Obtenidos
2000
Triangulos Obtenidos
1000
0
Figura 48. Resultados Delaunay
55
La Figura 49 contiene los resultados pertenecientes al algoritmo de Ganapathy.
Puntos
Modelo Originales
Phantom
7855
Ruina
5226
Forma1
450
Forma2
550
Forma3
450
Forma4
900
Puntos
Obtenidos
2007
381
84
99
93
211
Triángulos
Obtenidos
4035
766
140
174
159
398
Porcentaje de
simplificación
74,45
92,71
81,33
82,00
79,33
76,56
Porcentaje de
cailidad
25,55060471
7,290470723
18,66666667
18
20,66666667
23,44444444
9000
8000
7000
6000
5000
4000
Puntos Originales
3000
Puntos Obtenidos
2000
Triangulos Obtenidos
1000
0
Figura 49. Resultados Ganapathy
56
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.
120,00
100,00
80,00
Porcentaje Simplificación
Ganapathy
60,00
Porcentaje Calidad
Ganapathy
40,00
Porcentaje Simplificación
Delaunay
Porcentaje Calidad Delaunay
20,00
0,00
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.
57
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.
58
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.
59
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.
60
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
61
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
62
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.
63
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
64
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.
65
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
66
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.
ii.
Abrir eclipse
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
67
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.
68
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.
69
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...
70