Upload
others
View
3
Download
0
Embed Size (px)
Citation preview
INSTITUTO TECNOLÓGICO Y DE ESTUDIOS
SUPERIORES DE MONTERREY
Campus Ciudad de México
Escuela de Graduados en Ingeniería y Arquitectura
Maestría en Ciencias Computacionales
"GI-COLLIDE: Detección de Colisiones usando Imágenes de Geometría"
AUTOR: Néstor Adrián Gómez Villanueva ASESOR: PhD Bedrich Benes
México D.F. julio de 2005- TECNOLÓr.; ! (O • DE MONT::RREY e
Resumen
Se introduce un algoritmo para la detección de colisiones que funciona en el dominio de
las imágenes de geometría. El uso de las imágenes de geometría para detectar las
colisiones es una línea de investigación completamente nueva y sin antecedentes directos.
Se utiliza una jerarquía de volúmenes envolventes que se encuentra perfectamente
balanceada. Los volúmenes envolventes utilizados son esferas y la información referente
a la jerarquía se almacena en una imagen, donde los valores RGB representan el centro de
la esfera y en el canal Alfa se almacena el radio de la esfera. La detección de colisiones
se lleva a cabo recorriendo los dos árboles jerárquicos implícitos dentro de las imágenes y
probando si las esferas se intersecan. Los árboles se navegan mediante la indexación en
dos dimensiones de la imagen, haciendo uso del corrimiento de bits a la izquierda.
La principal meta que se persigue es crear un nuevo algoritmo para la detección de
colisiones que funcione en el dominio de las imágenes de geometría, de forma tal que si
se elige esta estructura de datos para guardar modelos, no se tenga que usar ninguna otra
para detectar las colisiones entre los objetos a representar. Se busca también mostrar la
eficiencia del método sugerido y compararlo ante otros métodos existentes y bajo
distintas condiciones.
El trabajo contribuye en las ciencias computacionales, específicamente en las gráficas
computacionales, introduciendo un nuevo algoritmo para la detección de colisiones y
mostrando que el método sugerido es eficiente y también fácil de implementar. El método
aquí presentado, culminó también con una presentación en el congreso Spring
Conference on Computer Graphics (SCCG) 2005 en Eslovaquia y la publicación por
ACM SIGGRAPH.
11
Contenido
Agradecimientos ..................................................................................................... .
Reswnen .................................................................................................................... 11
Lista de Tablas ..................................... ............ ........................................................ v1
Lista de Figuras . .. . . .. .. ... . . . ... . .. . .. . . . . .. . . .. . . .. .. .. .. .. . . .. .. .. .. .. .. .. . .. .... .... .. .. .. . .. . . . ... . .. . .. .. .. .. .. . v11
1. Introducción . . . . . . . . . . .. . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1. Motivación ...................................................................................................... 1
1.2. Imágenes de Geometría .................................................................................. 2
1.3. Detección de Colisiones ............................................................... .................. 3
1.4. Organización de la tesis ............................... ............. ................. .. ..... .. ............ 6
2. Trabajo Previo ... ...... .... .............. ...... .................... ....................... ...... .................. 7
2.1. Imágenes de Geometría . .. .. .. .. .. .. .. .. .. .. .. . . .. .. .. .. . . .. .. .. .. .. .. .. .. .. . .. .. .. .. .. .. .. .. .. .. .. . .. .. . 7
2.1.1. Propuesta de la imágen de geometría ............ ........ ............................... 7
2.1.2. Parametrización esférica para crear imágenes de geometría............... 10
2.1.3. Imágenes de geometría como múltiples partes.................................... 12
2.1.4. Videos de geometría............................................................................ 14
2.1.5. Imágenes de geometrías suaves........................................................... 15
2.2. Detección de Colisiones . . . . . . . . . . . . . .. . . .. . . . . . . . . . . . . .. .. .. . . . . .. . . .. . . .. . . . . . . . . . . . . . . . .. . . . . .. .. . . . . . 17
2.2.1. RAPID ................................................................................................. 17
2.2.2. QuickCD . .. . . .. .. .. . . .. . . . . . . . . . . . . .. .. .. . . . . .. .. . . .. .. .. .. . . .. .. .. .. .. . . . . .. . . . . . . . . . .. .. . . .. . . . . . . .. 19
2.2.3. QuOSPO .......... .. ....... .... ............ ........ ........ ........ ....... .. ...... .. .............. .... 21
2.2.4. HYCODE ..................... ........ ..................................... ............. .......... .... 22
2.2.5. CULLIDE ......................................................................... ...... ............. 23
111
Contenido
2.3. Consultas de Proximidad .................. .............................................................. 24
2.3.1. I-COLLIDE .. .... ...... ...... .... .. .. .. ...... .. .. .... .. .... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .... .. .. . .. .. . 24
2.3.2. Algoritmos incrementales para la detección de colisiones .................. 25
2.3.3. V-Clip .......................................................................... 26
2.3.4. SWIFT ++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3. Definición del Problema .................................................................................. 28
4. Solución del Problema..................................................................................... 30
4.1. Estructura de Datos . . . . . . . . . . .. . . .. . . . . .. . . . . . . . . . .. . . . . . . . . . . . .. . . .. . . .. . . .. . . .. .. . . . . .. . . . . . . . . . . . . . . . . . . . 31
4.1.1. Jerarquías de Volúmenes ..................... ........ ........ ........ ........................ 31
4.1.2. Construcción de la Jerarquía de Volúmenes ........................................ 32
4.1.3. Codificación de la Estructura de Datos ................................................ 34
4.1.4. Pre-procesamiento y requerimientos de memoria ................................ 35
4.2. Algoritmo para la Detección de Colisiones .................................................... 36
4.2.1. Descripción del algoritmo .................................................................... 37
4.2.2. Precisión y complejidad .. .. . .. . .. .. .. .. .. . .. .. .. .. .. .. .. .. .. .. .. . .. .. .. .. .... .. .. . .. .. .. .. .. .. 39
5. Implementación ................................................................................................. 41
5 .1. Pre-procesamiento .. .. .. .. .. .. . . .. .. .. . . .. .. . . .. . . . . . . .. .. . . . . .. .. . . . . . . .. . . . . . . . .. .. . . . . . . . . . . . . . . . . . .. . . . . 41
5 .2. Detección de Colisiones....................... ................................................. .......... 42
6. Resultados . . . . . . . .. .. . . .. .. . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. . . . . .. .. .. .. .. . . . . .. .. . . . . . . .. .. . .. .. . . . . .. . . . . . . . . . . . . . . . . . 46
6.1. Descripción de las pruebas ................................................. ............................ 46
6 2 C . ' 1 . 48 . . omparac10n con otros a gontmos ................................................................ .
6.2.1. 1-COLLIDE vs GI-COLLIDE .. . .. .. .. .. .. .. .. . .. .. . .. .. .. .. .. . .. .. . .. . .. .. 48
6.2.2. BS-Tree vs GI-COLLIDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.2.3. RAPID vs GI-COLLIDE . .. .. . .. . . .. .. . .. . .. . . .. .. . .. . .. . .. . .. . . .. .. . . .. .. .. 51
6.3. Aplicación real ................................................................................................ 53
6.4. Pruebas de tiempo crítico ................................................................................ 54
7. Conclusiones......................... .. ........................................................................... 55
7. l. Resumen de los resultados .. .. .. .. . .. .. .. .. .. .. .. .. .. . .. .. .. .. .. .. . .. .. . .. . .. .. .. .. .. .. .. . .. .. . .. .. .. .. . 5 5
7.2. Contribución de la tesis.................................................................................. 56
IV
Contenido V
7.3. Investigación Futura....................................................................................... 57
7.3.1. Restricciones de resolución .................................................................. 57
7.3.2. Nivel de detalle en colisión .................................................................. 57
7.3.3. Implementación en hardware ................................................... ............ 58
7.3.4. Volumen envolvente alternativo .......................................................... 58
Bibliografia . . .. . . .. .. . . . . .. . . . . .. . . . . . . . . .. . . . . .. . . . . . . . . .. .. . . .. . . . . .. .. .. .. .. .. .. .. .. . . .. . . . . . . . . . .. .. . . .. .. .. .. .. . .. .. . 59
A Carta de Aceptación a Congreso y Revisión del Jurado del Artículo:
"GI-COLLIDE: Collision Detection with Geometry Images" ... ... ... . 62
B Artículo GJ-COLLIDE: Collision Detection with Geometry Jmages... 71
C Presentación realizada en el congreso SCCG 05 ...................................... 79
Lista de Tablas
1 Creación de la jerarquía de esferas durante el pre-procesamiento .............................. 41
2 Algoritmo principal para la detección de colisiones exacta y con tiempo crítico ....... 43
3 Algoritmo recursivo para el cálculo de colisiones exactas .......... ......... ..................... 44
4 Algoritmo recursivo para el cálculo de colisiones con tiempo crítico ........ ................ 45
VI
Lista de Figuras
1.1 Ejemplo de una malla triangular irregular a la izquierda, ejemplo de una
imagen de geometría a la derecha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Ejemplo de aplicaciones que utilizan la detección de colisiones ........................ 4
1.3 Diferentes volúmenes envolventes para un mismo objeto en dos
dimensiones ........................................................................................................ 5
2.1 Malla triangular irregular mostrando los cortes necesarios para ser convertida
en una imagen de geometría ................................................................................ 8
2.2 Artefactos resultantes de la distorsión causada por el método de los cortes en
la geometría presentado por Gu et al. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Nivel de detalle generado haciendo sub-muestreo de la imagen de geometría ... 11
2.4 Morphing creado a partir de dos imágenes de geometría con la misma
resolución . .. . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . .. .. . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Imagen de geometría como atlas. De izquierda a derecha, modelo mostrando
la segmentación de la geometría, imagen de geometría y modelo reconstruido .. 13
2.6 De izquierda a derecha, geometría original, imagen de geometría que contiene
los puntos de control, subdivisión con continuidad C1 .•.•.•.•.•.•.•.•.•...•...•....••...•••• 15
2. 7 Ondulaciones resultantes al aproximar los puntos de control a la geometría
Original . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2. 8 Creación del árbol de OBBs en dos dimensiones . .. .. .. . . .. . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . .. . . . 18
2.9 Actualización del kDOP al rotar. De izquiera a derecha, kDOP original, kDOP
del objeto rotado, kDOP del kDOP rotado .......................................................... 20
2.10 Detección de colisiones con objetos que se rompen, CULLIDE ........................ 23
4.1 Modelo geométrico y sus texturas de coordenadas después de parametrización
esférica y edición manual. Imagen de geometría y normales resultantes . . . . . . . . 30
4.2 Diferentes niveles de la jerarquía de esferas .......................................... 32
4.3 Construcción de la jerarquía de esferas ........ . ..... . ......................... ........ 33
Vil
Lista de Figuras Vlll
4.4 Polígonos no contenidos en la jerarquía si no se repitieran los vértices en las
esferas ...................................................................................... 34
4.5 Imagen de colisión. Los centros en RGB y el radio en el canal Alfa. Los
píxeles grises no son utilizados ........................................................................... 34
4.6 Dos alternativas para guardar la imagen de colisión de manera más eficiente .... 35
4. 7 Esferas de la jerarquía que se encuentran en contacto mientras se aproximan
los objetos ............... .. ........ ................................................................................... 37
4.8 Prueba de intersección triángulo vs. triángulo. Se ejecuta cuando los dos nodos
visitados son hoja ................................................................................................ 38
6.1 Modelo utilizado en las pruebas. Stanford Bunny y su imagen de geometría .... 46
6.2 Prueba para comparar el rendimiento de GI-COLLIDE contra otros
algoritmos. 512 conejos rebotando dentro de un cubo ........................................ 47
6.3 Simulador de vuelo de un helicóptero. Se detecta la colisión exacta usando
GI-COLLIDE . . . . . . . . . . . . . . . . . .. . . .. .. . . . . . . . . .. . . . . . . . . . .. . . . . . . .. . .. .. .. . . . . . .. .. .... . . . . .. .. . . . . .. .. . . . . . . . .. . . . 48
6.4 Tiempo que toma la determinación de colisión entre GI-COLLIDE y
I-COLLIDE ......................................................................................................... 49
6.5 Tiempo promedio necesario para detectar una colisión entre 1-COLLIDE y
GI-COLLIDE . . . . . . . . . . .. . . . . . . . . . . . . . ... . . . . . . . . . . . . .. .. .. .. . . . . . . . . . . . . . . . . . . . . . . . . . .. .. . . . . . . . . . . . . . . . . ... .. . . . . 50
6.6 Tiempo promedio para detectar la colisión entre el árbol dinámico y
GI-COLLIDE ...................................................................................................... 51
6.7 Tiempo promedio para determinar la colisión entre GI-COLLIDE y RAPID .... 52
6.8 Número de pruebas de colisión como una función de la resolución de los
objetos ................................................................................................................. 53
6.9 Tiempo requerido para calcular una colisión como función de la resolución de
los objetos. Se utilizó la detección de colisiones con tiempo crítico ........ .. ........ 54
1. Introducción
1.1 Motivación
La detección de colisiones es una rama muy importante de las gráficas computacionales,
tanto para la visualización en tiempo real, como para otras ramas de las gráficas
computacionales. La importancia de la detección de colisiones radica en la interacción
entre objetos en tres dimensiones. Ya sea un video juego, una aplicación CAD, CAM,
DCC o un simulador de vuelo, se necesita determinar si dos objetos han colisionado, para
tomar una decisión y generar una respuesta específica. La detección de colisiones puede
ser calculada de manera exacta, mediante un enfoque de fuerza bruta, pero esta técnica es
poco óptima. Por esta razón, muchas técnicas se han presentado para mejorar el
desempeño en la detección de colisiones.
La detección de colisiones ha sido extensamente estudiada en el área de las gráficas
computacionales y sigue siendo un tema de investigación activo. Existen muchos
algoritmos que solucionan alguno o varios casos específicos de la detección de
colisiones; como objetos convexos, cóncavos, deformables, aprovechando la coherencia
cuadro a cuadro, jerarquías de objetos, etc.
Estos algoritmos pueden llegar a tener una complejidad de implementación bastante
alta, debido a lo elaborado de sus estructuras o la complejidad del algoritmo en sí. Hasta
este momento, no se ha presentado ningún algoritmo que trabaje en el dominio de las
imágenes de geometría y que aproveche las propiedades intrínsecas de esta forma de
representar la geometría de un objeto.
En este trabajo se presenta un algoritmo que facilita el trabajo cuando se decide usar
la representación de imágenes de geometría, a la vez resulta bastante sencillo de
implementar y tiene muy buen desempeño cuando se le compara con otros algoritmos
existentes.
1
1. Introducción 2
1.2 Imágenes de Geometría
Las superficies geométricas son por lo general modeladas usando mallas triangulares
irregulares. La figura 1.1 muestra un ejemplo de una malla triangular irregular. El
proceso de reestructurar la geometría de un objeto se refiere a aproximar un objeto
usando una malla con conectividad semi-regular. Este tipo de conectividad ofrece varios
beneficios. La compresión aumenta, dado que la conectividad es implícita, también
facilita la creación de representaciones jerárquicas para la creación de representaciones
con múltiples resoluciones.
Una superficie arbitraria puede reestructurarse en una estructura totalmente regular
que se denomina imagen de geometría. Captura la geometría como un arreglo de n x n
elementos, donde cada elemento del arreglo contiene la tripleta de valores [x,y,z]. Otros
atributos de la superficie como normales y colores son almacenados en imágenes
adicionales, compartiendo el mismo dominio que la geometría. Dado que la geometría y
los demás atributos comparten la misma parametrización, la conectividad es implícita, las
coordenadas de texturas están ausentes. Las imágenes de geometría pueden codificarse
usando métodos y formatos tradicionales de compresión de imágenes. En la figura 1.1 se
muestra un ejemplo de una imagen de geometría de un objeto.
Figura 1.1 -Ejemplo de una malla triangular irregular a la izquierda, ejemplo de una imagen de geometría a la derecha
l. Introducción 3
El convertir una superficie arbitraria al dominio de una imagen cuadrada no es una
tarea trivial, varios métodos han sido propuestos. Lo que estos métodos buscan es
encontrar la mejor forma de guardar la superficie original representada con mallas
triangulares irregulares en un arreglo bidimensional que representa una conectividad
totalmente regular. Los aspectos a considerar en esta conversión son: la distorsión
generada al hacer la conversión, el tipo de objetos soportados, y la autonomía del método.
Los usos de esta estructura se encuentran en el procesamiento de geometría, la
visualización en tiempo real, despliegue de terrenos, transmisión progresiva de
geometría, compresión de geometría, compresión de geometría animada y ahora
detección de colisiones.
1.3 Detección de Colisiones
La detección de colisiones consiste en reportar de manera inmediata cuando dos modelos
geométricos están o estarán en contacto para generar la respuesta deseada. Los modelos
geométricos pueden ser superficies poligonales, curvas o superficies algebraicas. En
muchas aplicaciones, como lo son el diseño asistido por computadora, la manufactura
asistida por computadora, robótica, automatización y ambientes simulados por
computadora, la detección de colisiones es un componente importante, ya que permite la
simulación, verificación de tolerancia, ensamble y desensamble automatizado,
planificación de movimiento, movimiento y animación de elementos articulados, etc. En
la figura 1.2 se muestran aplicaciones que utilizan la detección de colisiones. Todas estas
tareas involucran el análisis y determinación de contacto y análisis espacial entre objetos
estáticos o móviles. En la mayoría de estas aplicaciones, la detección de colisiones es
considerada un cuello de botella mayor.
1. Introducción 4
Figura 1.2-Ejemplo de aplicaciones que utilizan la detección de colisiones [27}[32}
Los modelos poligonales son el tipo de modelo geométrico más común, y la clase de
modelo geométrico más común es la sopa de polígonos. Esta representación consiste en
una colección de polígonos que no se encuentran geométricamente conectados y que
todos en conjunto forman una superficie poligonal. Esta clase de representación poligonal
puede formar objetos con diferentes características como lo son; objetos abiertos,
cerrados, convexos, cóncavos, non-manifold, genus-zero, etc.
Para la detección de colisiones en objetos poligonales, la técnica más simple que
existe es la fuerza bruta, que consiste en verificar la intersección entre todos los pares
posibles de polígonos en los objetos a analizar. Aunque este método es exacto, su
desempeño no resulta adecuado para las aplicaciones antes mencionadas ya que su
complejidad temporal es den x m, para dos objetos den y m polígonos respectivamente.
Una manera de acelerar el rechazo temprano en la detección de colisiones es
mediante el uso de volúmenes envolventes. Los volúmenes envolventes aproximan el
volumen de una geometría arbitraria por un objeto menos complejo, del cual se puede
determinar su intersección en menos operaciones. Los volúmenes envolventes más
comunes son las esferas, las cajas alineadas al eje (AABB), cajas envolventes alineadas al
objeto (OBB), y los kDOPs (Discrete Orientation Polytopes). Se muestran ejemplos de
los diferentes tipos de volúmenes envolventes en la figura 1.3 (a), (b), (c) y (d). En (a) se
muestra una esfera conteniendo un objeto, en (b) se utiliza una caja alineada a los ejes,
(AABB) y ( c) muestra una caja alineada al objeto. En ( d) se muestra un politopo con
orientaciones discretas (kDOP) con una k=8.
l. Introducción 5
(a) Esfera (b) AABB (c) OBB (d) kDOP
Figura 1.3 - Diferentes volúmenes envolventes para un mismo objeto en dos dimensiones
Los volúmenes envolventes pueden ser usados en conjunto con jerarquías para
agilizar el rechazo temprano y determinar que no hubo colisión. En una jerarquía de
volúmenes envolventes, el nodo cabeza de la jerarquía contiene un volumen envolvente
que incluye todos los polígonos del modelo, mientras que las hojas contienen uno o
algunos polígonos. En este tipo de métodos existen dos tipos de pruebas de intersección;
la prueba de intersección para los volúmenes envolventes y la prueba de intersección para
los polígonos que se encuentran en las hojas.
Los métodos que determinan la colisión de dos objetos se pueden agrupar en dos
categorías; algoritmos para la detección de colisiones y consultas de proximidad. Ambos
tipos de algoritmos reportan información acerca de la posición de dos objetos. La
detección de colisiones reporta si dos objetos se encuentran sobrepuestos en el espacio o
si sus bordes comparten por lo menos un punto en común. Las consultas de proximidad
reportan información adicional como lo es: distancia de separación, profundidad de
penetración, verificación de tolerancia, distancia mínima exacta, distancia mínima
aproximada, determinación de contacto disjunto. El objetivo de los algoritmos para la
detección de colisiones es brindar una respuesta lo más rápido posible, por lo general
incluyen alternativas para terminar en el primer contacto encontrado o regresar todos los
puntos de contacto encontrados. En las consultas de proximidad se busca información
adicional de los objetos a analizar, puesto que la respuesta es más compleja por lo
general.
1. Introducción 6
1.4 Organización de la Tesis
Esta tesis se encuentra organizada de la siguiente manera; en el capítulo 2 se da una breve
reseña del trabajo previo sobre la detección de colisiones e imágenes de geometría. La
definición del problema se presenta en el capítulo 3. En el capítulo 4 se describe el
algoritmo creado para la detección de colisiones y se describen las estructuras de datos
utilizadas, así como el pre-procesamiento necesario. En el capítulo 5 se presentan los
detalles de la implementación. El capítulo 6 muestra los resultados obtenidos en las
pruebas realizadas con varios algoritmos para la detección de colisiones. Por último el
capítulo 7 presenta las conclusiones y el trabajo futuro que podría realizarse con esta
investigación.
2. Trabajo Previo
En este capítulo se presenta en la pnmera parte el trabajo prev10 hecho con la
representación de las imágenes de geometría, su construcción y varias de sus
aplicaciones. Posteriormente se presentan algunos de los trabajos más representativos en
el área de la detección de colisiones y las consultas de proximidad. Para una descripción
más detallada de los métodos presentados se refiere al lector a las publicaciones aquí
citadas.
2 .1 Imágenes de Geometría
Las imágenes de geometría han sido estudiadas en diversos trabajos de investigación. Los
trabajos que aquí se citan están relacionados con la creación y aplicaciones de las
imágenes de geometría, así como pruebas realizadas en su desempeño. Solo se presenta
una breve reseña de los métodos descritos por los autores y las características más
importantes de su trabajo.
2.1.1 Propuesta de la imagen de geometría
Las superficies geométricas son por lo general modeladas usando una malla triangular
irregular. Algunas técnicas para convertir la malla irregular en una malla con
conectividad completamente regular las proveen las imágenes de geometría. En 2002, Gu
et al. [ 15] presentaron el concepto de las imágenes de geometría; una estructura de datos
que codifica y almacena eficientemente la geometría de un objeto dentro de una imagen.
Esta representación captura la geometría como un arreglo bidimensional de puntos
discretos cuantizados. Cada píxel en la imagen contiene la tripleta [x,y,z] de valores.
Otras características de las superficies como las normales y los colores pueden ser
almacenados en arreglos similares usando la misma parametrización de la superficie.
Las imágenes de geometría se pueden codificar usando algoritmos tradicionales de
compresión como los wavelets o cualquier otro método de compresión. Esta estructura
7
2. Trabajo Previo 8
también puede ser transmitida al pipeline gráfico de forma comprimida tal cual se hace
con las texturas, eliminado las estructuras complejas basadas en apuntadores como lo son
las listas de vértices. La información de las coordenadas de texturas queda implícita en la
imagen a través de la posición en el arreglo bidimensional. No es necesario guardar los
valores de las coordenadas de textura, puesto que las coordenadas de texturas de un
vértice corresponden a la posición del vértice dentro del arreglo bidimensional, en el
rango [0-1].
No es una tarea trivial convertir una malla arbitraria a una malla con una estructura
totalmente regular. Se presentó [ 15] un sistema automático para convertir una malla
arbitraria a una imagen de geometría y asociar mapas de atributos a la misma. El método
consiste en encontrar ciertos cortes que permitan extender la malla irregular en una
superficie con forma de disco. En la figura 2.1 se muestra una malla triangular irregular
con los cortes necesarios para convertirla a una imagen de geometría. La estrategia
consiste en encontrar un buen corte y una parametrización y esto se logra de la siguiente
manera. Primero se encuentra un corte topológico suficiente y se crea una
parametrización inicial. Se usa la información obtenida de la parametrización inicial para
mejorar el corte y reparametrizar basado en el último corte. El proceso se repite hasta que
la parametrización no mejora más.
Figura 2.1 - Malla triangular irregular mostrando los cortes necesarios para ser convertida en una imagen de geometría [ 15]
2. Trabajo Previo 9
La parametrización asume que existe un corte p, primero se hace un mapeo entre el
corte p abierto y el borde del cuadrado D de la imagen. Después se resuelve para un mapa
M en D que sea consistente con las condiciones del borde. En el primer paso se deben
tomar varias condiciones en cuenta para realizar una buena parametrización del borde.
Para evitar rupturas en la superficie, es necesario que cada nodo del corte sea mapeado
exactamente en la nueva malla. Es decir, que cada nodo del corte debe quedar
exactamente en una casilla del borde dentro de la imagen de geometría. También los
nodos del corte deben estar en puntos de la superficie idénticos junto con los nodos del
corte en el borde contrario. Para evitar triángulos degenerados, existen dos condiciones
más; ningún triángulo puede tener sus tres vértices mapeados en los cuadro lados del
cuadrado (en caso que esto llegara a ocurrir, el triángulo se debe descomponer en otros),
se deben romper cualquier arista que atraviese cualquiera de las cuatro equinas del borde
de D. La parametrización interior se calcula usando la métrica del estiramiento
geométrico y el algoritmo de optimización jerárquica. El estiramiento geométrico mide la
cantidad de espacio entre los vértices en la superficie cuando el dominio del parámetro es
muestreado de manera uniforme, por lo tanto al minimizar el estiramiento geométrico, se
tiende a distribuir de manera uniforme los elementos de la superficie.
Se sabe que cualquier superficie cerrada puede ser extendida en un disco, cortando a
lo largo de ciertas aristas. A través de la experimentación, los autores encontraron que
para obtener mejores resultados, el corte debería pasar por todos los puntos extremos de
un modelo. Para lograr esto, se utiliza la información del estiramiento geométrico, de
forma tal que se asegure que el corte pasa por los extremos de la geometría. Cuando se
han encontrado los extremos, se busca la ruta mas corta al borde actual y se añade al corte
p, de esta manera se va mejorando el corte p en cada iteración. Se continua con el proceso
mientras el resultado del estiramiento geométrico disminuya.
Las aplicaciones que son posibles con el uso de imágenes de geometría están
relacionadas con el despliegue y la compresión. Se puede generar nivel de detalle
implementado mip-mapping de la imagen de geometría. Para evitar rupturas en la
superficie, las imágenes deben tener una resolución de 2n + 1 x 2n + 1 píxeles. Para la
compresión se pueden usar wavelets. Dado que los wavelets pierden cierta precisión en
los datos, el corte puede tener rupturas, por lo que es necesario guardar la información
2. Trabajo Previo 10
original del corte para poder cerrar esas rupturas generadas por la pérdida de datos en la
compresión.
Las desventajas más importantes de las imágenes de geometría cuando fueron
introducidas estaban relacionadas con las limitantes en la geometría. Las imágenes de
geometría no pueden representar geometría non-manifold. Al extender una superficie en
un solo cuadro puede crear parametrización con mayor distorsión que si se hiciera en
varios cuadros, particularmente con superficies de genus alto.
Figura 2.2 - Artefactos resultantes de la distorsión causada por el método de los cortes en la geometría presentado por Gu et al. [ 15 J
2.1.2 Parametrización esférica para crear imágenes de geometría
Los modelos geométricos son por lo general descritos por superficies cerradas y genus
zero, es decir, esferas deformadas. Para tales modelos la esfera es el dominio de
parametrización más natural, dado que no requiere cortes en la superficie. Por lo tanto el
proceso de parametrización esta libre de restricciones. Praun y Hoppe [29] introdujeron
una técnica para la parametrización directa de una superficie genus-zero a un dominio
esférico. La parametrización esférica no es trivial de obtener por dos razones. Primero,
para que el algoritmo sea robusto, se deben prevenir los dobleces de la superficie y
garantizar un mapeo esférico uno a uno. Segundo, aunque todas las superficies genus
zero son en esencia una esfera, algunas pueden estar muy deformadas y crear una
parametrización que pueda representar todas las regiones de las superficies es una tarea
complicada.
2. Trabajo Previo
n=l n=2 n=4 n=8 n=16 11=32 n=64
Figura 2.3 - Nivel de detalle generado haciendo sub-muestreo de la imagen de geometría [29]
11
Las muestras semi-regulares que se construye sobre el dominio del poliedro se pueden
desdoblar de tal manera que exista una correspondencia uno a uno sobre una malla
regular de dos dimensiones. Esta información se puede utilizar para convertir la
parametrización esférica en una imagen de geometría. Las forma de parametrizar las
imágenes de geometría presentadas por Gu [ 15] soportaban superficies de genus alto,
pero tiene restricciones en el nivel de detalle y en la compresión. También presenta
distorsión en ciertos casos, como lo ejemplifica la figura 2.2 donde se muestran artefactos
en la geometría. La técnica de Praun, al estar restringida a superficies genus-zero, permite
mejor nivel de detalle, morphing, compresión más efectiva y la creación de superficies
suaves.
Figura 2.4 - Morphing creado a partir de dos imágenes de geometría con la misma resolución [29]
El despliegue para las imágenes de geometría generadas con este método se puede
hacer simplemente conectando las muestras mediante triángulos. Para el caso del
2. Trabajo Previo 12
tetraedro y el octaedro, la conectividad entre los triángulos ya esta dada. En el caso del
cubo, se tiene que dividir cada dominio del cubo a lo largo de la diagonal más corta. Para
el caso del nivel de detalle, simplemente se hace un sub-muestreo como se puede ver en
la figura 2.3. El método presentado por Gu [15] tenía una restricción en el sub-muestreo a
causa del corte. En este caso el sub-muestreo se puede llevar hasta n=l, logrando en el
nivel de detalle más bajo un octaedro. Realizar el morphing de dos objetos resulta
sencillo una vez que se han obtenido sus parametrizaciones esféricas. En la figura 2.4 se
muestran los resultados de aplicar el morphing a dos objetos. Ese marco de trabajo
permite guardar en una misma imagen de geometría las dos posiciones de cada vértice
que corresponden a los dos modelos. Para hacer el morphing, simplemente se interpola
entre estos dos vértices para obtener la nueva representación. En el caso de la
compresión, se pueden usar wavelets esféricos o un codificador de imágenes. En el caso
del codificador de imágenes, se tiene que modificar para que se tomen en cuenta las
restricciones de los bordes del dominio, ya que si no se hace, se obtiene una versión que
puede tener discontinuidades en el borde.
2.1.3 Imágenes de geometría como múltiples partes
Las imágenes de geometría con una conectividad totalmente regular tienen problemas
para representar modelos con componentes desconectados, ya que necesitan una imagen
de geometría por cada componente. Otro problema que presentan es la distorsión causada
en modelos con muchas extremidades. En el 2003 Sander, Wood, Gortler, Snyder y
Hoppe [33] presentaron una nueva parametrización para definir una imagen de
geometría de múltiples partes. La superficie se parte en segmentos geométricamente
naturales, de igual manera que se hace para definir coordenadas de textura en un modelo.
Cada segmento se parametriza de forma individual en polígonos irregulares y todos los
polígonos se juntan en una imagen de geometría. La figura 2.5 muestra el resultado de
aplicar este método a un objeto geométrico.
2. Trabajo Previo
Figura 2.5 - Imagen de geometría como atlas. De izquierda a derecha, modelo mostrando la segmentación de la geometría, imagen de geometría y modelo reconstruido [33 J
13
La parametrización basada en un atlas reduce la distorsión, ya que al ser más
pequeñas las piezas, resulta más sencillo proyectarlas. Al existir poca distorsión las
muestras son distribuidas de manera más uniforme sobre la superficie y por lo tanto la
geometría resultante es mejor. La distorsión se disminuye con el pequeño inconveniente
de incluir muestras que son indefinidas ( espacios en blanco). Esta representación se
puede definir como regular en piezas, ya que esta compuesta por sub-regiones de una
imagen de geometría regular. El método mantiene la gran ventaja de las imágenes de
geometría originales, que es el despliegue mediante un recorrido en orden sobre las
muestras en la imagen.
La desventaja mayor con la parametrización basada en un atlas es que la
reconstrucción es discontinua a lo largo de los bordes. Esto sucede dado que los bordes
de los fragmentos no se alinean con la malla del muestreo y por que los bordes entre
vecinos son construidos con un muestreo diferente. En el caso de las imágenes de
geometría estas discontinuidades se traducen en rupturas en la superficie que no son
aceptables. Para prevenir estas rupturas, también se presenta [33] un esquema de costura
que une los bordes para crear un modelo continuo.
2. Trabajo Previo 14
Para realizar la costura, el algoritmo primero identifica los vértices que tienen más de
dos segmentos adyacentes. Estos vértices formarán un grupo de líneas que conforman el
borde entre los segmentos. Este se toma de la geometría original una vez que ha sido
rotada y escalada a su posición final y antes de ser discretizada. Los vértices discretizados
que pertenecen al borde, son reemplazados por el punto más cercano al borde entre los
segmentos de la geometría original. Los bordes discretizados de los segmentos por lo
general no contienen el mismo número de muestras, por lo que se tienen que unificar para
crear una superficie continua. Algunos vértices se tienen que unir para que los bordes
tengan el mismo número de elementos.
El procesamiento necesario para el método es muy considerable, los autores
reportaron tiempos de entre 1 y 2 horas por modelo. La mayor parte del procesamiento es
en la distribución eficiente de los segmentos de geometría. Este método tampoco aporta
soluciones para incluir nivel de detalle en el despliegue. Es claro que el problema para
implementar nivel de detalle con esta técnica reside en el algoritmo para unir las piezas,
ya que un sub-muestreo cambiaria las condiciones que la técnica necesita. La compresión
en este tipo de imágenes de geometría presenta las mismas dificultades en el algoritmo de
costura, teniendo muchas más restricciones que los algoritmos anteriores al tener más
bordes, i.e. un borde por cada pieza de geometría.
2.1.4 Videos de geometría
Las imágenes de geometría guardan la geometría de un objeto estático con una
conectividad totalmente regular. Briseño presentó [ 4] el concepto de videos de
geometría, una estructura de datos que almacena geometría animada. Está basada en las
imágenes de geometría y hereda las ventajas que se han mencionado. Esta estructura
también presenta ventajas que le permiten el envío progresivo por redes de comunicación
(streaming). Por sus características, es posible el uso de codificación para video como
MPEG para guardar la información de las geometrías animadas. Una dificultad que
presenta el método es que al mantener el mismo corte para toda la secuencia, el corte
puede no ser el óptimo para todas las instancias de la geometría animada, incrementando
la distorsión que el método en general presenta.
2. Trabajo Previo
Figura 2. 6 - De izquierda a derecha, geometría original, imagen de geometría que contiene los puntos de control, subdivisión con continuidad C1 [23]
2.1.5 Imágenes de geometrías suaves
15
Hasta este punto, las imágenes de geometría sólo habían sido utilizadas para la
representación de normales, vértices o geometría animada. Losasso , Hoppe , Schaefer y
Warren [23] utilizaron la imagen de geometría para guardar puntos de control de una
superficie de curvas, y no vértices de una malla. Dado que la estructura de tipo producto
tensor del parche de E-spline bicúbico, los puntos de control se pueden guardar en una
imagen de geometría. El despliegue se realiza calculando la subdivisión usando el GPU.
La figura 2.6 muestra los puntos de control guardados y el resultado de la subdivisión. El
esquema también incluye nivel de detalle continuo que varía desde un octaedro hasta una
versión altamente subdividida. Los mapas de desplazamiento también son soportados
mediante la técnica que presentan los autores.
La parametrización usada es la que se basa en el dominio del octaedro y después
desenrollando a un dominio cuadrado haciendo un corte en forma de X. A esta
parametrización se le realiza un muestreo usando una malla de dos dimensiones para
crear la imagen de geometría. Después se usa la parametrización obtenida para construir
una imagen de geometría la cual tiene asociada un parche de superficie que aproxima de
manera precisa la geometría original. No se pueden simplemente tomar muestras de la
imagen de geometría como los puntos de control, se tiene que llevar a cabo una etapa de
optimización donde se aproxima de la mejor manera la superficie bicúbica a la original.
2. Trabajo Previo 16
El resultado de la superficie bicúbica puede tener ondulaciones, como la mostrada en la
figura 2.7, como resultado del proceso de optimización, por lo que se debe aplicar un
procesamiento para reducir este efecto.
El nivel de detalle se obtiene usando una representación con menos geometría cuando
el objeto se encuentra a mayor distancia de la cámara. En el instante en que el nivel de
detalle cambia, se percibe un pop visual, que es ocasionado por la diferencia geométrica
entre los dos niveles de detalle. Esta técnica provee un nivel de detalle continuo que evita
este tipo de artefactos visuales. Esto se logra mediante una interpolación lineal entre los
diferentes niveles de detalle, de manera tal que exista una transición suave entre las dos
geometrías y el cambio no sea visible. Primero se calculan las triangulaciones de la
subdivisión para los dos niveles de detalle y después se realiza la interpolación lineal
entre estas dos mallas. De manera similar a técnicas anteriores, mediante el uso de sub
muestreo se puede obtener versiones con menos geometría hasta llegar a un octaedro en
el nivel más bajo. Aunado a la subdivisión, también se puede aplicar un mapa de
desplazamiento para agregar detalle en el modelo. El mapa de desplazamiento solo
requiere un canal para guardar los valores del desplazamiento y no requiere guardar las
coordenadas de texturas, puesto que se encuentran implícitas gracias a la imagen de
geometría. En este caso el mapa de desplazamiento se aplica usando shaders, programas
que se ejecutan en el procesador de la tarjeta gráfica.
Figura 2. 7 - Ondulaciones resultantes al aproximar los puntos de control a la geometría original [23]
2. Trabajo Previo 17
2.2 Detección de Colisiones
La detección de colisiones y la generación de respuestas basado en colisiones son
extremadamente importantes en muchas aplicaciones de las gráficas computacionales,
como lo son los videojuegos, la realidad virtual, interacción entre modelos CAD,
planeación de caminos, robótica móvil, etc. Varias técnicas para la detección de
colisiones entre objetos han sido recientemente introducidas. A continuación se presentan
algunos de los métodos más relevantes para el desarrollo de esta tesis.
2.2.1 RAPID
Los árboles de cajas envolventes orientadas (OBBTree por sus siglas en ingles), fueron
usados en el artículo fundamental [13] de Gottschalk et al. para la detección de colisiones
de objetos que conllevan un movimiento rígido. El algoritmo es aplicable para todos los
modelos poligonales. Precalcula una representación jerárquica de los modelos usando
árboles de cajas orientadas al objeto (OBBTrees). En la ejecución del algoritmo, los dos
árboles son visitados y son probados para determinar la interferencia entre las cajas
envolventes usando el teorema del eje de separación. La implementación de tal prueba
toma menos de 200 operaciones.
Dado un objeto geométrico, el árbol de volúmenes envolventes puede ser construido
de abajo-arriba o arriba-abajo. Las hojas pueden corresponder a primitivas de volúmenes
envolventes. Por lo general pueden estar representados como una colección de unos
cuantos polígonos. La construcción del árbol jerárquico tiene dos componentes: el
posicionamiento de un OBB alrededor de los polígonos y el agrupamiento anidado de los
OBB en una jerarquía. Para el procesamiento primero se triangulan todos los polígonos
con más de tres aristas. La construcción del OBB se hace mediante el uso de la media y
covarianza de los vértices que conforman el modelo poligonal. Para evitar que ciertas
regiones densas de vértices muevan el posicionamiento del OBB, se utiliza el envolvente
convexo del objeto para calcular el OBB. Aunque el problema aún puede existir, ya que
una densidad de puntos del envolvente convexo puede desviar el posicionamiento, se
2. Trabajo Previo 18
reduce la posibilidad de este problema. En RAPID, nombre que recibió la
implementación del trabajo de Gottschalk [13], la construcción de la jerarquía se hace de
arriba hacia abajo. La regla de subdivisión consiste en partir el eje más largo del OBB del
objeto, como lo muestra la figura 2. 8. Los polígonos contenidos en el OBB se dividen
tomando en cuenta de que lado de la división queda su centro. Si el punto para realizar la
división se escoge basado en la media, entonces se obtiene un árbol balanceado, que en
general tiende a tener un mejor desempeño.
Figura 2.8 - Creación del árbol de OBBs en dos dimensiones [13 J
Para determinar si dos OBBs son disjuntos, se realizan pruebas para comprobar si
existe un eje de separación entre todas las caras de los OBBs. Las cajas son proyectadas
sobre algunos ejes, si los intervalos de las cajas proyectadas no se suporponen, el eje
probado se dice que es un eje de separación. Varias de estas pruebas son necesarias para
determinar si las cajas son disjuntas. Dos objetos convexos en un espacio tridimensional
siempre pueden ser separados por un plano que es paralelo a una cara o paralelo a una
arista del objeto. Esto lleva a 15 ejes de separación potenciales, 3 caras de una caja, 3
caras de otra caja y 9 combinaciones de aristas. Si ninguno de los ejes probados es un eje
de separación, entonces se puede determinar que los objetos están en contacto. Cuando se
encuentra un eje de separación, se sabe que los objetos son disjuntos, por lo que no es
necesario seguir con los demás cálculos. En la mayoría de los casos, la prueba puede
terminar en los primeros 6 ejes probados. Los cálculos para la proyección se pueden
simplificar si se expresa la rotación de la caja B relativa a la caja A Con dichas
simplificaciones se pueden realizar todas las pruebas, en el peor de los casos, en 200
operaciones aproximadamente.
2. Trabajo Previo 19
2.2.2 QuickCD
Otros volúmenes envolventes pueden ser usados para la detección de colisiones.
Klosowski et al. [ 19] usaron, para la detección de colisiones, los kDOP (Poli topos con
orientaciones discretas) un objeto geométrico convexo cuyas caras son determinadas por
regiones cuyas normales están dadas por un número k predeterminado de orientaciones.
En dicho trabajo se comparan varios métodos para la construcción de la jerarquía de
kDOPs. También se presenta un algoritmo para mantener un árbol de volúmenes
envolventes efectivo para objetos en movimiento mientras rotan sin la necesidad de
reconstruir totalmente la jerarquía de kDOPs y el algoritmo para detectar la colisión entre
los volúmenes envolventes.
Los politopos con orientaciones discretas tienen un número pequeño de
orientaciones, que definen la forma del politopo. Una caja alineada al eje, es por ejemplo
un kDOP con k = 6 y las orientaciones separadas por 90 grados en cada eje. Se pueden
usar 6DOP, 14DOP, 18DOP, 26DOP, dependiendo del grado de exactitud con el que se
quiera aproximar el volumen a contener. La ventaja de este tipo de volumen envolvente
es que se pueden escoger las orientaciones de manera que la aproximación sea lo más
exacta posible. El término k se puede utilizar para balancear los dos factores más
importantes en la elección de volúmenes envolventes que son: el grado de exactitud en la
aproximación al volumen y la rapidez de la prueba de interferencia entre los volúmenes
envolventes. En el caso del trabajo de Klosowski [19] las orientaciones son predefinidas
y son escogidas de tal manera que faciliten el computo de los mismos. Las orientaciones
se encuentran en el conjunto {-1,0,1} y varias de sus combinaciones en los 3 ejes de
coordenadas, de esta manera elimina la necesidad de multiplicaciones en el cálculo de los
kDOPs. Esta elección disminuye la exactitud de la aproximación, pero aumenta el
rendimiento del método al reducir el número de cálculos necesarios.
Para determinar la colisión de dos objetos, los árboles generados deben ser recorridos
de manera similar a otros algoritmos, probando la intersección entre los nodos y en caso
positivo, determinar la intersección de sus hijos de manera recursiva. Determinar el
contacto entre dos kDOPs con diferentes vectores de dirección es mucho más costoso que
2. Trabajo Previo 20
hacerlo en kDOPs con orientaciones alineadas. En este caso se usan kDOPs con
orientaciones alineadas y para determinar si hay contacto, se requiere hacer k
comparaciones, de manera similar como se hace con los AABBs, dado que el kDOP esta
definido por los extremos de k/2 direcciones, por lo que no se requiere otra operación más
que comparaciones en la determinación de la colisión entre los politopos con
orientaciones discretas. La detección de interferencia exacta se realiza entre las hojas del
árbol que contienen los triángulos del modelo.
Figura 2.9 - Actualización del kDOP al rotar. De izquiera a derecha, kDOP original, kDOP del objeto rotado, kDOP del kDOP rotado [19]
En el caso particular de QuickCD, nombre que recibió la implementación de
Klosowski et al. [ 19], la detección de colisión está restringida a un ambiente estático y un
objeto en movimiento. El problema que presenta la rotación para el caso particular de los
kDOPs es la actualización de la jerarquía de los volúmenes envolventes. Si solamente se
rotaran los kDOPs contenidos en la jerarquía, se obtendrían kDOPs con orientaciones
diferentes, lo que resulta en un cálculo de la interferencia mucho más complejo. Por esta
razón se debe buscar conservar las mismas orientaciones y recalcular el kDOP necesario
para aproximar el modelo con la nueva transformación. Para recalcular la jerarquía se
presentaron dos alternativas, en las que ambas conservan la jerarquía generada durante el
pre-proceso y solamente se actualizan los kDOPs de cada nodo. En el primer caso, se
guarda el envolvente convexo del modelo poligonal original, se guardan los vértices
extremos para cada orientación y en cada actualización se prueba si el vértice sigue
siendo extremo, en caso contrario se visitan los vértices vecinos para determinar si son
los nuevos extremos. Usando este método se explota la coherencia cuadro a cuadro, pero
para el peor de los casos el método tiene una complejidad le para rotaciones rápidas. El
segundo caso es un método de aproximación y consiste en construir el kDOP que
2. Trabajo Previo 21
aproxime al kDOP del tiempo t-1 con la nueva rotación, por lo que la aproximación no es
la óptima, como la figura 2.9 lo muestra. Para éste último caso se utiliza el método de
fuerza bruta para calcular el nuevo volumen envolvente, ya que son pocos vértices los
que tienen que procesarse, solo aquellos del kDOP del cuadro anterior. En ambos casos se
requiere guardar algunos datos que se calculan durante el pre-proceso; en el primer caso
se guarda el envolvente convexo del modelo y en segundo caso los vértices del kDOP.
2.2.3 QuOSPO
He presentó [16] una solución para el problema de la detección de colisiones basado en
un volumen envolvente llamado QuOSPO, bloque con orientaciones cuantizadas y con
orientaciones primarias, por sus siglas en ingles. Este volumen envolvente combina y
extiende las ventajas de dos de los volúmenes envolventes ya mencionados, OBBs y
kDOPs. Combina también el uso de una jerarquía de este tipo de volúmenes envolventes
y presenta W1 algoritmo conservativo para determinar la interferencia entre los nodos del
árbol.
La estructura de datos QuOSPO, es W1 volumen envolvente muy parecido al kDOP,
pero con algunas modificaciones. Uno de los problemas que presentan los kDOPs es que
se tienen que actualizar los nodos del árbol para cada cambio de orientación del objeto. El
volumen envolvente resultante de esa actualización suele tener W1a aproximación menos
óptima debido a que no se usa la geometría original para recalcular el kDOP. En el
QuOSPO este error se trata de minimizar usando una cuantización del espacio de las
orientaciones. Esta cuantización trata de obtener un muestreo uniforme del espacio de las
orientaciones y después esta cuantización de orientaciones será utilizada de manera
similar a los kDOPs, para construir el volumen envolvente. Otra modificación utilizada
para acelerar el proceso consiste en escoger las orientaciones primarias a verificar. Dado
que el QuOSPO suele tener W1a k mucho más grande que los kDOPs, es importante la
forma en que las comparaciones son realizadas. Con las orientaciones primarias se trata
de reducir la complejidad de las pruebas de intersección usando solo las orientaciones
más efectivas del conjunto. Las orientaciones primarias son calculadas en base en el OBB
del objeto original, por lo que se debe calcular y guardar para cada nodo del árbol. Los
2. Trabajo Previo 22
QuOSPOs ofrecen la ventaja de tener una rápida actualización de los nodos del árbol.
Esto se logra proyectando el OBB en las orientaciones primarias que se obtienen de unas
tablas de búsqueda. Esta proyección da como resultado un pseudo-kDOP que aproxima el
volumen del OBB original el cual puede ser probado para determinar la interferencia.
2.2.4 HYCODE
Los algoritmos mencionados hasta el momento funcionan en el espacio de los objetos
geométricos en tres dimensiones. Baciu et al. propusieron [2] un método para la
detección de colisiones que funciona en el espacio bidimensional de las imágenes. Este
algoritmo rompe el cuello de botella ocasionado por la detección de colisiones en el
espacio de los objetos, mediante la distribución de la carga computacional al flujo de
trabajo del hardware gráfico. En los algoritmos que funcionan en el espacio de los
objetos, la geometría se representa con estructuras muy complejas debido a la
conectividad del modelo. Por esta razón se puede llegar a un grado de complejidad
bastante alto en la programación de un algoritmo para detectar los puntos más cercanos
entre dos objetos. En los algoritmos tradicionales las pruebas de interferencia se realizan
en el procesador mientras que el hardware de despliegue espera a que la escena este
procesada. En contraste con los métodos basados en el espacio de los objetos, los
algoritmos basados en el espacio de las imágenes son más sencillos de implementar y
proveen el potencial de ser asistidos en el cómputo por el hardware gráfico.
HYCODE es el nombre que recibió la implementación de Baciu [2], que obtiene sus
siglas de "detección de colisiones híbrida". El volumen envolvente utilizado es la caja
alineada al eje (AABB). La prueba de interferencia en el espacio de las imágenes esta
basado en la proyección de la geometría en el plano de la imagen y haciendo un análisis
en un espacio de dimensiones reducidas. El algoritmo híbrido para la detección de
colisiones primero calcula el vector de separación para encontrar los objetos que no
colisionan. Si no se encuentran vectores de separación, el algoritmo basado en las
imágenes es invocado para realizar más pruebas de interferencia. Se usa el stencil buffer
para determinar posibles zonas de contacto. Cuando se detecta una zona de posible
contacto, se proyecta en el plano y se determina si existe contacto.
2. Trabajo Previo 23
2.2.5 CULLIDE
CULLIDE fue presentado por Govindaraju, Redon, Lin y Manocha [14] y es un método
basado en el GPU ( Graphics Process Unit) para la detección de colisiones que también
trabaja en el espacio de las imágenes. Soporta objetos deformables y que pueden ser
separados en pedazos. El algoritmo para la detección de colisiones calcula los conjuntos
de colisión potenciales que son obtenidos mediante consultas de visibilidad. Esto permite
calcular la detección a solo ciertas partes del objeto.
Figura 2.10-Detección de colisiones con objetos que se rompen, CULLIDE [2}
Los algoritmos que se basan en el uso del GPU para el procesamiento de la
interferencia de dos objetos tienen un problema con el ancho de banda entre el GPU y el
CPU. Aunque el GPU puede calcular a una gran velocidad, leer una región de cualquiera
de los buffers puede tomar valiosos milisegundos. También varios de los algoritmos de
este tipo están limitados a objetos cerrados, por hacer uso de los mínimos y máximos de
la geometría. CULLIDE presenta las ventajas de soportar múltiples objetos, no hay
requerimientos para la geometría a procesar, inclusive soporta sopa de polígonos. No
guarda jerarquías ni requiere pre-procesamiento. Puede soportar objetos deformables y
cambios en la geometría y no hay restricción en el tipo de movimiento que los objetos
pueden tener. Inclusive el número de objetos puede cambiar de un cuadro a otro.
El conjunto de colisiones posibles se calcula mediante consultas de proximidad. Si
dos objetos están en contacto, cierta parte del objeto será ocluida por el otro. De esta
manera se crea el conjunto y se desechan todos los objetos que no forman parte del
2. Trabajo Previo 24
conjunto. En esta parte del proceso se puede utilizar la geometría original o desplegar un
volumen envolvente para acelerar el despliegue. Este algoritmo no hace lecturas del
buffer, por lo que no tiene problemas con el ancho de banda del GPU. De manera similar,
con los objetos pertenecientes al conjunto de colisión potencial, se realiza una consulta de
visibilidad, pero ahora con partes de los objetos originales. Por último se detecta la
colisión exacta en el CPU mediante el cálculo de la intersección entre triángulos.
2.3 Consultas de Proximidad
Los algoritmos de detección de colisiones reportan cero-una ó cero-varias colisiones. Las
consultas de proximidad detectan las colisiones, pero también reporta información extra
como la distancia entre dos objetos, la profundidad de penetración, etc. El resultado de
una consulta de proximidad puede ser exacto, aproximado o un valor booleano. Más aun,
la mayoría de las consultas de proximidad comparten una característica, explotan la
coherencia entre cuadro y cuadro. Aquí se presenta un resumen de algunos de las técnicas
de consultas de proximidad más importantes y recientemente publicadas.
2.3.1 1-COLLIDE
I-COLLIDE es una técnica de dos niveles basada en podar múltiples pares de objetos
usando cajas envolventes y calculando la detección de colisión exacta entre los pares de
geometrías seleccionadas. Para determinar si una colisión ha ocurrido o no, el método usa
el algoritmo de la característica más cercana de Lin-Canny. Este algoritmo reduce el
número de pruebas necesarias que se requieren en comparación en una prueba de
intersección entre cajas envolventes. Una vez que la colisión es detectada, la prueba
exacta que involucra a todos los polígonos es calculada.
Este método, presentado por Cohen, Lin, Manocha y Ponamgi [5], funciona para
ambientes grandes, donde muchos objetos están en movimiento y la complejidad de los
objetos es grande. No se asume que la función de movimiento de los objetos pueda ser
expresada como una curva cerrada como lo requieren otros métodos. La coherencia
cuadro a cuadro es utilizada para acelerar la determinación de interferencia entre los
2. Trabajo Previo 25
pares. Los objetos cóncavos son aceptados mediante la representación de los mismos
como una jerarquía de objetos convexos. Para podar los objetos que no están en colisión
con algún otro, el algoritmo representa los objetos como un volumen envolvente y todos
estos volúmenes son ordenados y se determina cuales de estos están en contacto. Los
volúmenes envolventes utilizados son los AABBs, debido a que utilizan la proyección en
los planos xy,yz, y zx para determinar la interferencia.
2.3.2 Algoritmos incrementales para la detección de colisiones
En 1995 Ponamgi, Manocha y Lin presentaron [28] un algoritmo de consultas de
proximidad incremental entre dos representaciones de volúmenes. El algoritmo combina
una representación jerárquica de AABBs (Axis Aligned Bounding Boxes) junto con una
computación incremental cuadro a cuadro. La coherencia entre instancias sucesivas
determina el número de objetos que interactúan. Localiza las regiones de interferencia en
los envolvente convexos de cada par de objetos. Los grupos de polígonos asociados a
estas regiones son almacenados en una jerarquía precalculada.
Durante el pre-procesamiento se catalogan los elementos de la geometría ( caras,
vértices y aristas), los elementos que formen parte del envolvente convexo del objeto se
catalogan como elementos del volumen envolvente, los que no forman parte se catalogan
como elementos de concavidad. Los vértices y aristas que se encuentran entre las
regiones de elementos del volumen envolvente y las regiones de concavidad se catalogan
como bordes. Esta información se utiliza para calcular tapas que servirán para rellenar las
partes del volumen envolvente que tienen concavidad. Para ese método se utiliza una
jerarquía de tipo octree, donde los AABBs de la geometría son almacenados. En las hojas
del árbol se almacenan un cierto número de polígonos que se determina mediante un
umbral en la implementación. Para determinar la interferencia de los envolvente convexo
se utiliza un algoritmo de detección de penetración basado en regiones de Voronoi. Todos
los objetos a su vez, son proyectados y ordenados en tres listas, una para cada eje. Los
objetos que se encuentren en la misma posición en las tres listas, son analizados para
determinar su colisión. Dado que la lista de ordenamiento cambia poco entre cuadros
sucesivos, se aprovecha la coherencia y se usa el algoritmo de inserción para acelerar el
2. Trabajo Previo 26
ordenamiento.
2.3.3 V-Clip
V-Clip es un algoritmo presentado por Mirtich (24] que busca los pares más cercanos de
elementos entre objetos convexos, usando una técnica similar al algoritmo de Lin-Canny
para calcular la detección de colisiones. Las mejoras que ofrece son: la complejidad de
codificar se reduce, la robustez del algoritmo es mayor y no presenta problemas de ciclos.
El algoritmo acepta objetos que se penetran y también puede ser usado para detectar la
colisión entre objetos cóncavos y convexos. La jerarquía usada ayuda a construir un
objeto cóncavo de varios objetos convexos. Un envolvente convexo de estos
subconjuntos es construido y cuando una colisión es detectada, se verifica de manera
exacta si hay interferencia en los subconjuntos.
El algoritmo de Lin-Canny es uno de los algoritmos más avanzados de los basados en
características de la geometría que calcula la distancia entre objetos disjuntos. I
COLLIDE es uno de los algoritmos que usan Lin-Canny para ejecutar la detección de
bajo nivel. Uno de los problemas que presenta el algoritmo de Lin-Canny es que no
soporta objetos que se penetran. Si esta situación se presenta, las condiciones para
terminar no se cumplen y el algoritmo se cicla. Otro problema es la robustez, el algoritmo
tiende a tener problemas de ciclos también con geometría degenerada. V-Clip soporta el
caso de geometría que se penetra, reportando estos casos y casi con el mismo tiempo de
procesamiento que necesita el caso disjunto. Las configuraciones de geometría
degenerada no le presentan un problema y tampoco contiene tolerancias numéricas. Un
caso especial en el que V-Clip es ineficiente es cuando un objeto contiene a otro
completamente, y la información que presenta acerca de los elementos que colisionaron
es limitada a comparación con Lin-Canny.
2.3.4 SWIFT ++
SWIFT++, que es el nombre que recibe el algoritmo presentado por Ehmann y Lin [12],
muestra un acercamiento unificado de consultas de proximidad para verificar la
2. Trabajo Previo 27
intersección de objetos, tolerancia de verificación, distancia mínima exacta y aproximada
y determinación de contacto disjunto. Los métodos usados incluyen una estructura de
datos jerárquica construida a partir de una descomposición del objeto. La consulta
incremental toma ventaja de la coherencia entre cuadros sucesivos. Se describe un
algoritmo para determinar la proximidad de dos pares de objetos convexos basado en
Voronoi marchante.
Son varios los algoritmos que componen a SWIFT ++, con todos ellos se busca
ofrecer un grupo de consultas de varios niveles de dificultad y que puedan ser atendidos
sin la necesidad de estructuras complicadas y postproceso costoso. Los algoritmos están
basados en la descomposición de objetos convexos y está dirigido a geometría general
con movimiento rígido. Se crea una jerarquía como resultado de los segmentos de
superficie creados en la descomposición. Cada nodo de la jerarquía es un envolvente
convexo que encierra a sus descendientes. En las hojas se encuentran los envolvente
convexos de los parches resultados de la descomposición. Para la determinación de
colisión exacta se usa el algoritmo de los elementos de geometría más cercanos de Lin
Canny.
3. Definición del Problema
La detección de colisiones consiste en comprobar sí algún o algunos polígonos de un
objeto están intersecando algún o algunos polígonos de otro objeto. Esta comprobación se
puede hacer probando todas las combinaciones posibles de intersección entre los
triángulos de los dos objetos, lo que resulta en una complejidad O(n x m), donde n es el
número de polígonos del primer objeto y m del segundo objeto. Muchas alternativas han
sido presentadas para disminuir la complejidad temporal de la detección de colisiones.
Una de las alternativas comúnmente usadas es el uso de jerarquías de volúmenes
envolventes para la representación de los objetos. Aunque se han logrado grandes
avances en la detección de colisiones usando esta técnica, el problema de la detección de
colisiones no esta resuelto por completo. Varios de los métodos presentan limitaciones o
restricciones importantes en sus soluciones como la restricción de ciertos tipos de objetos
geométricos o el tipo de movimiento que deben tener los objetos a procesar. Por otro lado
el constante desarrollo del hardware gráfico, abre la posibilidad de explotar más aún el
poder de cómputo disponible para mejorar el desempeño de la detección de colisiones.
Las imágenes de geometría son una estructura de datos que ofrece la posibilidad de
explotar el hardware gráfico. Junto con esta ventaja, también provee otras como la
compresión, transmisión progresiva y la conectividad implícita gracias a la topología
totalmente regular de la geometría. Las imágenes de geometría no han sido utilizadas en
la resolución del problema de la detección de colisiones. Esta estructura de datos, junto
con sus ventajas, puede ser utilizada para resolver el problema de la detección de
colisiones.
Debido a la regularidad de la estructura de datos, resulta claro que se puede
implementar un algoritmo para la detección de colisiones que presente ventajas sobre
otros algoritmos previamente publicados. Mediante el uso de mipmapping, se puede
implementar una jerarquía, la cual no necesita guardar información de su estructura,
debido a que el balanceo y la relación entre los nodos de la jerarquía esta implícita en el
mipmapping de la imagen. Por otra parte, se puede utilizar la imagen de geometría para
guardar información de un volumen envolvente.
28
3. Definición del Problema 29
Se busca diseñar, implementar y someter a pruebas un algoritmo para la detección de
colisiones que explote todas las ventajas de las imágenes de geometría. Se definirá el pre
proceso y estructuras necesarias. Utilizará una jerarquía de volúmenes envolventes, en
este caso esferas, y se diseñará el algoritmo para recorrer los dos árboles y detectar las
colisiones. El algoritmo busca ser eficiente, fácil de implementar y robusto. Se probará la
eficiencia del algoritmo, comparándolo con otros algoritmos para la detección de
colisiones en condiciones similares.
4. Solución del Problema
Para el desarrollo del algoritmo se necesitan modelos en la representación de las
imágenes de geometría. La geometría, es primero transformada de una sopa de polígonos,
a una imagen de geometría. Esta conversión se realiza mediante una proyección esférica
de los vértices para la parametrización de las texturas de coordenadas y edición manual
de las mismas, eliminado texturas de coordenadas encimadas. Este proceso se puede
llevar acabo en un programa de modelado tridimensional como Maya o de manera
autónoma utilizando los métodos presentados por Gu [15] y Praun [29]. En la figura 4.1
se muestra un ejemplo de las texturas de coordenadas después de aplicarse el proceso
mencionado. Las texturas de coordenadas son después utilizadas para rasterizar la
geometría y almacenarla como una imagen en formato TIFF. Se utilizan imágenes TIFF
de 16 bits por canal para tener una mayor precisión en la quantización de la posición de
los vértices en la geometría. La posición de cada vértíce se almacena como un número
entre O y 65536 dentro de la imagen. La geometría se almacena de manera unitaria
( valores en el rango { 0-1}) y para su despliegue se puede utilizar un parámetro para
escalar la geometría al tamaño deseado. El escalamiento de los vértices se hace cuando se
lee la imagen de geometría y se guarda como un valor flotante en la memoria, de esta
manera se evita repetir el cálculo del escalamiento en cada cuadro. El mismo proceso de
rasterización se lleva acabo con la información de las normales, almacenándose en
L . ' d . 1 . ' d 2 n+I 2 n+I imágenes separadas. as 1magenes genera as tienen una reso uc10n e x
píxeles.
Figura 4.1 - Modelo geométrico y sus texturas de coordenadas después de parametrización esférica y edición manual. Imagen de geometría y normales resultantes
30
4. Solución del Problema 31
4 .1 Estructura de Datos
El algoritmo usa una representación jerárquica de volúmenes envolventes para los objetos
geométricos. Cada nodo del árbol construido contiene un volumen envolvente que
encierra a todos los vértices que contienen a su vez a sus nodos hijos. En los nodos hoja
del árbol se almacenan cuatro vértices, que representan a dos triángulos de la geometría
original. Esta estructura es la base fundamental del algoritmo para la detección de
colisiones. Una de las características que tiene la estructura es que resulta un árbol
perfectamente balanceado, debido a su construcción de manera muy similar al método de
mipmapping.
4.1.1 Jerarquías de Volúmenes
La jerarquía de volúmenes es una técnica que permite disminuir la complejidad temporal
del cálculo de la detección de colisiones. Esto se logra gracias a que las jerarquías
permiten descartar de manera temprana grandes regiones de la geometría que no son
factibles de estar en colisión. Un factor importante en la construcción de las jerarquías de
volúmenes envolventes es la elección del volumen envolvente. Se deben tomar en
consideración dos aspectos importantes para la elección del volumen envolvente, el
primero es la precisión con la que son capaces de representar al objeto original, teniendo
el menor espacio vacío posible, y el segundo es la rapidez con que se pueda calcular la
interferencia entre dos de estos volúmenes. En la figura 1.3 del capítulo 1 se muestra un
ejemplo que ilustra diferentes niveles de aproximación para los tipos más importantes de
volúmenes envolventes. Los volúmenes envolventes más utilizados son las cajas
alineadas al eje (AABB), las cajas orientadas al objeto (OBB), los poli tipos con
orientaciones discretas (kDOPs) y las esferas.
Para el desarrollo de este algoritmo se escogió la esfera como el volumen envolvente
a utilizar por las siguientes razones. Las esferas son invariantes a la rotación, por lo que
no se necesitan hacer cálculos adicionales en cada cuadro para poder realizar la prueba de
interferencia como sucede en otros casos como las AABBs y kDOPs que necesitan
recalcularse o con los OBBs que necesitan reorientarse. En el caso de las esferas estas
4. Solución del Problema 32
operaciones son innecesarias, pero se pagan con un costo dado por la mala aproximación
al volumen original. Sobre todo en superficies alargadas, el espacio vacío que deja una
esfera al envolver un objeto puede llegar a ser muy grande. Pero por otro lado, la prueba
de interferencia es muy rápida para el caso de las esferas. Solo requiere el cálculo de la
distancia entre los centros de las dos esferas, la suma de sus radios y una comparación.
Cabe mencionar que no es necesaria la operación de la raíz cuadrada para el cálculo de la
distancia, ya que se pueden almacenar desde un principio el cuadrado de los radios de las
esferas.
Un factor importante para el buen desempeño de las jerarquías de volúmenes
envolventes es el balanceo del árbol a utilizar y la profundidad del mismo. En nuestro
caso, el árbol es utilizado es de tipo QuadTree, teniendo cada nodo cuatro descendientes.
Esto está dado por la similitud al proceso de mipmapping, que representa con un solo
píxel, 4 píxeles del nivel inferior de la pirámide. En cuanto al balanceo del árbol, para
nuestro caso es un balanceo perfecto, otra vez gracias al proceso de mipmapping o
pirámide de imágenes. Absolutamente todas las ramificaciones del árbol tienen la misma
profundidad al ser una imagen cuadrada.
Figura 4.2 - Diferentes niveles de la jerarquía de esferas
4.1.2 Construcción de la Jerarquía de Volúmenes
La construcción de la jerarquía se hace de abajo hacia arriba (buttom-up ). Se toman 4
píxeles de la imagen de geometría con un tamaño 2n + 1 x 2n + 1, se calcula el AABB
tomando el valor máximo y mínimo de los vértices en los ejes x, y, z. Se calcula el centro
del AABB sumando los valores mínimos y máximos de cada eje y dividiendo entre dos.
Para calcular el radio, se calcula la distancia del centro hacia todos los vértices del AABB
4. Solución del Problema 33
y se toma el máximo de las distancias. Los datos obtenidos son el centro de la esfera
[x,y,z] y el radio de la misma. Se toman los siguientes 4 vértices, pero compartiendo dos
de los vértices de la iteración anterior, como se muestra en la figura 4.3. Esto se hace para
que todas las conexiones entre los vértices queden incluidas en el cálculo de las
colisiones. Si no se repitieran vértices, quedarían hoyos entre las esferas, como lo muestra
la figura 4.4, lo que llevaría a posibles errores en el cálculo de la intersección. Una vez
que todos las combinaciones de vértices han sido procesadas, se habrán guardado 2n x 2n
píxeles en la imagen de la jerarquía.
geometria original
nivel 1
centro del cuadrado
~ envolvente
nivel O
nivel 2
Figura 4.3 - Construcción de la jerarquía de esferas
Cuando se termina de procesar el primer nivel de la jerarquía de volúmenes
envolventes, se vuelve a realizar el mismo proceso, pero ahora se toman 9 vértices de la
imagen de geometría original. Esto resulta en otro nivel de la imagen de jerarquía, ahora
con un tamaño de 21 + 1 x i + l. Se podrían usar los datos generados por la iteración
anterior y calcular el AABB de las cuatro esferas del nivel anterior, pero esto resulta en
una acumulación de errores de aproximación de la geometría original. Aunque realizar el
pre-proceso de esta manera requiere más cálculos, resulta en la mejor aproximación a la
4. Solución del Problema 34
geometría original para cada una de las esferas en la jerarquía de volúmenes envolventes.
El proceso sigue de la misma manera, usando 2n + 1 x 2n + 1 vértices en cada iteración,
hasta llegar a una sola esfera que contiene a todos los vértices de la geometría original.
Figura 4.4 - Polígonos no contenidos en la jerarquía si no se repitieran los vértices en las esferas
4.1.3 Codificación de la Estructura de Datos
La jerarquía generada puede ser almacenada en una imagen de 16 bits de manera similar
a la imagen de geometría. Los centros de las esferas se pueden guardar en los canales
RGB de una imagen TIFF. El radio de las esferas se guarda en el canal Alfa de cada
píxel. Los niveles de la jerarquía se guardan uno encima de otro, generando una nueva
imagen de (2n) x (2n+I - 1) píxeles. Esta imagen recibe el nombre de imagen de colisión y
será usada por el algoritmo para el cálculo de colisiones. En la figura 4.5 se muestra una
imagen de colisión con los canales RGB y Alfa separados.
Figura 4.5 -Imagen de colisión. Los centros en RGB y el radio en el canal Alfa. Los pixeles grises no son utilizados
4. Solución del Problema 35
Con esta configuración hay mucho espac10 sm utilizar en la imagen. Para la
implementación presentada se uso esta configuración para facilitar la lectura de la
imagen. Pero se pueden generar varias alternativas de configuración que disminuyan el
espacio sin usar en la imagen de colisión. Una alternativa es poner el primer nivel de la
jerarquía del lado izquierdo y el resto de los niveles del lado derecho, esto reduce Y4 de
tamaño del primer nivel en x. Otra configuración posible es separando los canales RGB y
Alfa. Los canales RGB pueden ser almacenados de la misma manera que se crea el
mipmapping de una imagen, que consisten en separar los canales RGB y ordenarlos uno
al lado de otro en una imagen cuadrada. En el sector restante se almacenan los niveles
inferiores de manera recursiva. Para almacenar la imagen de esta manera solo se necesita
un canal de 16 bits y una imagen de 2n x 2n. Para almacenar el canal Alfa se necesita una
imagen con un canal de 16 bits y una configuración de las antes mencionadas. En la
figura 4.6 se muestran estas dos configuraciones; la que disminuye Y4 de espacio a la
izquierda y la que utiliza mipmapping a la derecha.
Figura 4.6 - Dos alternativas para guardar la imagen de colisión de manera más eficiente
4.1.4 Pre-procesamiento y requerimientos de memoria
Para cada modelo se necesita generar una jerarquía de volúmenes envolventes. Este
proceso se puede realizar de manera previa a la ejecución del programa de detección de
colisiones y el resultado puede ser guardado como una imagen. Dado que las imágenes
usadas son de formato TIFF, se puede utilizar un algoritmo de compresión sin
4. Solución del Problema 36
introducción de errores (lossless), como lo es LZW, para comprimir la imagen. El
procesamiento solo se necesita calcular una sola vez y las instancias del mismo objeto
pueden compartir tanto las imágenes de geometría como las imágenes de colisión. Por lo
que solo se necesita una imagen de colisión por cada objeto con geometría diferente.
El espacio en memoria requerido para almacenar una imagen de geometría esta dado
por su resolución. Una imagen de s = 2n + 1 x 2n + 1 necesita 3s flotantes para almacenar
la información de los vértices. De manera similar las normales necesitan 3s flotantes para
guardarse en memoria. Entonces la imagen de geometría más las normales necesitan 6s
flotantes para ser almacenadas. En el caso de la imagen de colisión, el espacio requerido
por cada esfera es de 4 flotantes, 3 para el centro y uno para el radio. El tamaño del nivel
más bajo de la jerarquía es de n x n, ya que las esferas comparten dos de sus vértices con
los vecinos. Los siguientes niveles siempre son n/2 del nivel anterior. Por lo que el
numero de flotantes requeridos para almacenar la jerarquía esta dado por la fórmula
log2 n
4¿txt i=O
Estrictamente el espacio necesario para almacenar la jerarquía en términos des está
dado por 5.17s aproximadamente para una imagen de 65 x 65 píxeles, lo que da un total
de 11.17 s flotantes para almacenar toda la información necesaria de un modelo,
recordando que varias instancias del mismo modelo pueden compartir esta información.
4.2 Algoritmo para la Detección de Colisiones
La representación jerárquica de los objetos es usada para descartar de manera temprana
áreas del objeto que no son probables de estar en contacto con otro objeto. Para
determinar la interferencia entre los objetos las jerarquías deben ser recorridas. Las
jerarquías de volúmenes envolventes generadas durante el pre-procesamiento son usadas
en el algoritmo para la detección de colisiones. En esta sección se describe como
funciona el algoritmo, la información que reporta y se presenta un análisis de la
complejidad temporal del mismo.
4. Solución del Problema 37
4.2.1 Descripción del algoritmo
El algoritmo para la detección de colisiones reqmere dos árboles de esferas que
representen a dos objetos geométricos. Este algoritmo, de manera similar a otros
algoritmos que utilizan jerarquías de volúmenes envolventes, recorre ambos árboles y
realiza una serie de pruebas entre los nodos del árbol. La detección de colisión comienza
probando si las esferas en los nodos superiores de los dos árboles están en contacto. Para
determinar el contacto, primero se multiplica la posición del objeto por su matriz de
transformaciones para obtener su posición en coordenadas del mundo. Se calcula la
distancia entre los dos objetos y se compara contra la suma de los radios de las esferas
que se están analizando. Si la distancia entre las esferas es menor a la suma de sus radios,
entonces las esferas están en contacto y se prosigue con el algoritmo, de otra manera se
regresa un resultado negativo, indicando que no hubo colisión entre los objetos.
Figura 4. 7 - Esferas de la jerarquía que se encuentran en contacto mientras se aproximan los objetos
4. Solución del Problema 38
Para seguir con la detección de colisiones, se comparan las esferas del nivel siguiente
inferior para detenninar su interferencia. Cada esfera tiene cuatro descendientes. Se
prueban todas las posibles combinaciones entre las cuatro esferas de un objeto y las
cuatro esferas del segundo objeto. Para cada una de las combinaciones se realiza el
mismo cálculo para detenninar la interferencia de las esferas, se calcula la distancia y se
compara con la suma de los radios. Cuando cualquiera de las combinaciones da un
resultado positivo en el cálculo de la interferencia, recursivamente se bajará nivel por
nivel, calculando la interferencia de las dieciséis esferas. Cuando ya no existan niveles
inferiores, es decir cuando los nodos sean hojas, se calculará la intersección exacta de los
triángulos. Cuando los objetos a comparar tienen un tamaño de imagen de geometría
diferentes y se detecta que alguno de ellos ya esta en un nodo hoja, se baja un nivel de la
esfera que no es nodo hoja. Se sigue expandiendo el árbol hasta que los dos nodos sean
hoja. Para el cálculo exacto, se utiliza la infonnación de la imagen de geometría. Cada
nodo hoja del árbol contiene cuatro vértices, que representan a dos triángulos. En total se
calculan cuatro pruebas de intersección entre los dos triángulos de un objeto y los dos
triángulos del segundo objeto.
Figura 4.8 - Prueba de intersección triángulo vs. triángulo. Se ejecuta cuando los dos nodos visitados son hoja
El algoritmo puede funcionar de dos maneras: puede regresar el resultado al primer
contacto encontrado entre dos triángulos o puede regresar todos los contactos
encontrados entre los dos objetos que se están probando. En el primer caso, el algoritmo
tennina cuando se encuentra la primera intersección entre dos triángulos. En el segundo
caso, se continúa con el algoritmo regresando al nivel superior y calculando la
4. Solución del Problema 39
interferencia de las esferas restantes, dejando que la recursividad tennine de calcular
todas las posibilidades. El este caso el algoritmo tennina cuando se han analizado todas
las esferas que estén en contacto con esferas del otro objeto. El resultado que se regresa
es la lista de puntos de intersección en caso que se requieran todos los puntos de
contactos, o el primer punto de intersección encontrado y un resultado booleano
indicando si hubo colisión.
Este algoritmo también provee la funcionalidad de calcular las colisiones con tiempo
crítico. Esto significa que se asigna un tiempo máximo para detenninar si ocurrió una
colisión. Si el algoritmo culmina antes de que el tiempo tennine, se regresa un resultado
obtenido como en el caso de la detección exacta. En caso de que el tiempo asignado se
tennine y no se haya detenninado la colisión, se regresará un resultado positivo. De esta
manera el algoritmo mantendrá una tasa de cuadros por segundo constante en el cálculo
de las colisiones, ya que no se rebasará el límite establecido para ser utilizado en la
detección de colisiones.
4.2.2 Precisión y complejidad
La construcción de la jerarquía de esferas incluye a todos los triángulos de los objetos
geométricos. Este implica que se tengan que repetir vértices de las esferas vecinas para
que se asegure que todos los triángulos serán incluidos en la jerarquía. Si no se repitieran
los vértices, se tendría un nivel menos en la jerarquía, pero no se podría asegurar que las
colisiones con los triángulos que conectan los vértices de una esfera con los de las esferas
vecinas sean detectadas correctamente. Por otro lado la detección final se realiza de
manera exacta calculando la intersección entre triángulos, por lo que no pueden existir
casos en que se reporten colisiones falsas. Debido a que la jerarquía de esferas se
construye de manera correcta y completa tampoco existe la posibilidad de dejar fuera
regiones del modelo, siempre y cuando se realicen las pruebas de interferencia necesarias.
En el caso del cálculo de colisiones con tiempo crítico, se introduce un cierto error en
la detección de la colisión. El error se debe a que cuando el tiempo disponible se agota, se
regresa un resultado positivo, aún cuando el resultado real podría ser negativo si se
tenninaran de calcular las pruebas. Se espera que debido a la simplicidad para detenninar
4. Solución del Problema 40
las interferencias entre las esferas, el algoritmo tenga tiempo suficiente para descender en
la jerarquía e introducir un error pequeño. Debido a que las esferas tienden a disminuir
rápidamente de tamaño entre un nivel y otro, el descender un par de niveles podría
proveer un resultado aceptable para ciertas aplicaciones. Un error pequeño puede ser
aceptable en aplicaciones donde la exactitud no sea necesaria y se prefiera mantener un
rendimiento en tiempo real, como en el caso de los videojuegos.
El algoritmo tiene la capacidad de terminar al encontrar el pnmer punto de
intersección o buscar todos los puntos de intersección entre los objetos. Para el primer
caso la complejidad temporal del algoritmo es muy similar a la búsqueda de un árbol.
Teniendo dos objetos de n1 y n2 vértices, la complejidad temporal es a (log(max{ n1,n2} )).
El peor de los casos para este algoritmo es cuando dos objetos idénticos se encuentran
casi en la misma posición y todos sus triángulos se encuentran intersecando. En este caso
se efectuarían todas las pruebas de interferencia entre las esferas de los dos árboles y
también el cálculo de intersección de todos los triángulos. Es dificil que este caso se
presente de manera natural en la mayoría de las aplicaciones. Uno de los casos donde esto
podría ocurrir es cuando se detectara la colisión entre dos planos de dimensiones,
transformaciones y teselación similar.
5. Implementación
En esta sección se mostrarán detalles acerca de la implementación del método propuesto,
tanto para el pre-procesamiento como para la detección de colisiones. La detección de
colisiones soporta salida al primer contacto o reportar todos los puntos de intersección,
así como cálculo exacto de la colisión o detección de colisión con tiempo crítico. La
implementación del método se hizo en C++ y para la visualización se utilizó OpenGL.
5 .1 Pre-procesamiento
Durante el pre-procesamiento se deben crear las imágenes de colisión a partir de las
imágenes de geometría. Estas imágenes de colisión son guardadas como una imagen en
formato TIFF de 16 bits y son después leídas por el algoritmo para la detección de
colisiones. La función mostrada en el algoritmo 1 calcula el centro y el radio de la esfera
que envuelve a los vértices de cada nivel. En la línea 4 se calcula la esfera que contenga a
los vértices indexados por XJ' y con un desplazamiento de n posiciones en ambas
direcciones. El método no reutiliza las esferas previamente calculadas de otros niveles, ya
que esto puede ocasionar un encadenamiento de errores en la aproximación de las esferas
envolventes. Esto implica que todos los vértices serán procesados más de una vez, pero
también se asegura que la esfera envolvente obtenida será lo más aproximada posible al
volumen original.
Algoritmo l. Creación de la jerarquía de esferas durante el pre-procesamiento 1 para cada nivel de la jerarquía
2 calcular número de píxeles a procesar
3 para cada píxel desde XJ' hasta el número de píxeles a procesar
4 calcular la esfera envolvente de n píxeles
5 escribir los datos de la esfera en la imagen de colisión
41
5. Implementación 42
5 .2 Detección de Colisiones
Para guardar los vértices de los modelos, centros de las esferas y radios de las esferas se
usaron arreglos de flotantes. Los arreglos son creados de manera dinámica y tomando en
cuenta las dimensiones de las imágenes de geometría y de colisión. Diferentes instancias
de un mismo modelo geométrico pueden compartir arreglos de vértices y árbol de esferas,
por lo que no es necesario tener varias copias de los datos en memoria. Cada instancia de
un objeto solo debe mantener su propia matriz de transformaciones y la referencia a una
imagen de geometría y a la imagen de colisión.
El uso de un árbol completamente regular permite el uso de la indexación como el
método optimo para acceder al árbol de esferas. Un árbol regular no necesita almacenar
apuntadores para conectar los nodos con sus descendientes, estas conexiones están
implícitas en el arreglo. Mediante el cálculo de un desplazamiento se puede saber la
posición en el arreglo de las esferas descendentes de un nodo. La ausencia de apuntadores
en la jerarquía reduce la cantidad de memoria requerida para almacenar el árbol de
esferas en memoria. Por otro lado, el uso de desplazamientos para acceder a otros
elementos del árbol permite múltiples optimizaciones aritméticas debido a la regularidad
del algoritmo y de la estructura. Una de las optimizaciones que se pueden lograr gracias a
la indexación es el uso de corrimientos hacia la izquierda para referenciar la posición de
las esferas descendientes en el arreglo de flotantes. El uso de la indexación permite
también la implementación de la rutina para la detección de colisiones como un píxel
shader que sea ejecutado en el procesador gráfico (GPU). El cálculo de la intersección de
los triángulos se realiza utilizando el algoritmo de Moller [25] y la implementación
proveída por el autor.
Cuando se requiere calcular la colisión de dos objetos, por lo general estos se
encuentran en constante movimiento. Para poder realizar el cálculo de la interferencia
entre dos esferas, se necesita obtener las coordenadas del mundo del centro de la esfera
en cada cuadro. Para no realizar cálculos que no serán utilizados, se realiza la
transformación de las coordenadas solo cuando éstas son necesarias. En el algoritmo 3
línea 2 y 4 es cuando se calculan las coordenadas del mundo para las esferas a las cuales
se les determinará la interferencia. En cada iteración de la recursividad se obtiene la
5. Implementación 43
posición en coordenadas del mundo de las dos esferas a verificar con las
transformaciones actuales y solo en caso de tener una interferencia positiva se calculan
las coordenadas de sus descendientes. Por otro lado para no utilizar la operación de la raíz
cuadrada en el cálculo de la distancia, se pueden almacenar los cuadrados de los radios
para determinar la interferencia más rápido.
Algoritmo 2. Algoritmo principal para la detección de colisiones exacta y con tiempo crítico 1 calcular coordenadas del mundo para la esfera en la cabeza del árbol 1
2 calcular coordenadas del mundo para la esfera en la cabeza del árbol 2
3 si el cuadrado de la distancia entre las dos esferas es menor a la suma del cuadrado de
4 sus radios entonces
5 si se va a calcular la colisión con tiempo crítico entonces
6 regresar el resultado de calcular la colisión recursiva con tiempo crítico
7 en otro caso
8 regresar el resultado de calcular la colisión recursiva exacta
La implementación actual permite la utilización de resoluciones distintas en las
imágenes de colisión. Las comparaciones hechas en las líneas 6, 12, 15 y 18 del
algoritmo 3 permiten que los objetos que tengan imágenes de colisión con mayor
resolución continúen bajando en su jerarquía hasta llegar a los nodos hoja. Cuando esto
suceda, la comparación hecha en la línea 8 permitirá que se ejecute el cálculo exacto de la
intersección entre triángulo y triángulo.
En el caso del cálculo de colisión con tiempo crítico, la comparación del tiempo
usado para la detección de la colisión y el tiempo disponible para la colisión se hace en la
línea 1 del algoritmo 4. En caso que el tiempo se haya agotado se regresa un resultado
positivo, pero dado que el algoritmo 2 es el que hace el llamado a la función recursiva de
colisión con tiempo crítico, se sabe que por lo menos las esferas que rodean a los dos
objetos están en contacto. Por esta razón, en el peor de los casos el error al detectar la
colisión con tiempo crítico es igual al que se tendría si se usara una esfera como volumen
envolvente para cada objeto. En la mayoría de las aplicaciones el algoritmo tendrá tiempo
suficiente para bajar más de un nivel en la jerarquía, reduciendo el error en la detección.
5. Implementación 44
Algoritmo 3. Algoritmo recursivo para el cálculo de colisiones exactas 1 para cada esfera descendiente del nodo 1
2 obtener las coordenadas del mundo de la esfera
3 para cada esfera descendiente del nodo 2
4 obtener las coordenadas del mundo de la esfera
5 si el cuadrado de la distancia es menor a la suma del cuadrado de los radios
entonces
6 si los dos nodos son hoja entonces
7 si hay que reportar todas las colisiones entonces
8 calcular la intersección de los triángulos de las dos esferas
9 en otro caso
10 regresar el resultado de la intersección de los triángulos de las dos esferas
11 en otro caso
12 si el nodo 1 no es hoja y el nodo 2 no es hoja entonces
13 regresar el resultado de calcular la colisión recursiva exacta bajando un
nivel en la jerarquía del nodo 1 y bajando un nivel en la jerarquía del nodo 2
14 en otro caso
15 si el nodo 1 es hoja y el nodo 2 no es hoja entonces
16 regresar el resultado de calcular la colisión recursiva exacta bajando un
nivel en la jerarquía del nodo 2
17
18
19
en otro caso
si el nodo 1 no es hoja y el nodo 2 es hoja entonces
regresar el resultado de calcular la colisión recursiva exacta bajando un
nivel en la jerarquía del nodo 1
20 regresar falso
5. Implementación 45
Algoritmo 4. Algoritmo recursivo para el cálculo de colisiones con tiempo crítico 1 si el tiempo transcurrido es mayor al tiempo disponible
2 regresar verdadero
3 para cada esfera descendiente del nodo 1
4 obtener las coordenadas del mundo de la esfera
5 para cada esfera descendiente del nodo 2
6 obtener las coordenadas del mundo de la esfera
7 si el cuadrado de la distancia es menor a la suma del cuadrado de los radios
entonces
8 si los dos nodos son hoja entonces
9 si hay que reportar todas las colisiones entonces
1 O calcular la intersección de los triángulos de las dos esferas
11 en otro caso
12 regresar el resultado de la intersección de los triángulos de las dos esferas
13 en otro caso
14 si el nodo 1 no es hoja y el nodo 2 no es hoja entonces
15 regresar el resultado de calcular la colisión recursiva con tiempo crítico
bajando un nivel en la jerarquía del nodo 1 y bajando un nivel en la jerarquía
del nodo 2
16 en otro caso
17 si el nodo 1 es hoja y el nodo 2 no es hoja entonces
18 regresar el resultado de calcular la colisión recursiva con tiempo crítico
bajando un nivel en la jerarquía del nodo 2
19
20
21
en otro caso
si el nodo 1 no es hoja y el nodo 2 es hoja entonces
regresar el resultado de calcular la colisión recursiva con tiempo crítico
bajando un nivel en la jerarquía del nodo 1
22 regresar falso
6. Resultados
El diseño del algoritmo para la detección de colisiones muestra muchas ventajas gracias a
las características de las imágenes de geometría. Para poder medir estas ventajas se
diseñaron varias pruebas para medir el rendimiento del algoritmo bajo diferentes
circunstancias. Un grupo de estas pruebas consisten en comparar GI-COLLIDE contra
otros algoritmos para la detección de colisiones que ya han sido presentados con
anterioridad. GI-COLLIDE fue probado contra 1-COLLIDE [5], árboles dinámicos de
esferas envolventes y RAPID [ 13]. El otro grupo de pruebas consiste en medir el
rendimiento del algoritmo en circunstancias reales, como lo son el cálculo de colisiones
en un simulador de vuelo y la detección de colisiones con tiempo crítico. Estas últimas
pruebas sirven para demostrar que el algoritmo además de mostrar varias ventajas
teóricas y de implementación, también es competitivo en su ejecución en varios
escenanos.
Figura 6.1 - Modelo utilizado en las pruebas. Stanford Bunny y su imagen de geometría
6.1 Descripción de las pruebas
Las pruebas realizadas contra otros algoritmos fueron diseñadas para comparar el
rendimiento de los algoritmos en la detección exacta de colisiones. Tomando como base
datos de un modelo escaneado del Stanford Bunny se creó un modelo del conejo de
Stanford como imagen de geometría con una resolución de 65 x 65 píxeles. La figura 6.1
46
6. Resultados 47
muestra el modelo usado y la imagen de geometría creada. Para 1-COLLIDE, RAPID y
BSTree dinámico se creo un modelo geométrico con una topología y número de
triángulos lo más parecido posible a la imagen de geometría para que la comparación
fuera objetiva. La prueba consiste en 2, 4, 8, 16, .. ,256 conejos moviéndose y rotando de
forma aleatoria dentro de un cubo. Se calcula la colisión entre los conejos y se genera una
respuesta. La respuesta generada es el rebote de los conejos hacia direcciones opuestas.
Los conejos, de igual manera rebotan en las caras del cubo, de forma que nunca salen de
éste. Cada prueba se ejecuta por 3000 cuadros. Se reporta el número de colisiones totales
y el tiempo total en milisegundos que tomó el cálculo de las colisiones reportadas. Este
proceso se repitió para cada uno de los tres algoritmos.
Figura 6.2 - Prueba para comparar el rendimiento de GICOLLIDE contra otros algoritmos. 512 conejos rebotando dentro de un cubo
Para mostrar un ejemplo de una aplicación real, se implementó una prueba de colisión
entre un helicóptero en movimiento y un terreno fractal. El helicóptero se mueve de
manera realista, elevándose, dando vueltas, acercándose y alejándose del terreno. Para
esta prueba se usaron resoluciones de 513 x 513, 1025 x 1025, 2049 x 2049, 4097 x 4097
y 8193 x 8193 cuando fue posible, obteniendo objetos con 256k, lM, 4M, 16M, y 64M
vértices. Se probaron todas las combinaciones posibles de resoluciones para el modelo
del terreno y del helicóptero. Cada prueba se realizó 12 veces, se descartaron los
extremos y se calculó el promedio.
6. Resultados 48
Figura 6.3 - Simulador de vuelo de un helicóptero. Se detecta la colisión exacta usando GI-COLLIDE
La alternativa para detectar la colisión con tiempo critico se probó implementando
una aplicación donde dos objetos con diferentes resoluciones se mueven e ínter penetran.
La resolución de uno de ellos se estableció en 2049 x 2049, mientras el segundo objeto se
probó con resoluciones de 513 x 513, 1025 x 1025, 2049 x 2049, 4097 x 4097 y 8193 x
8193. Se reportó el tiempo que tomó el cálculo de la colisión en todos los casos y se
midieron los cuadros por segundo de la aplicación sin tomar en cuenta el despliegue de
los modelos.
6.2 Comparación con otros algoritmos
Las pruebas realizadas para comparar los algoritmos para la detección exacta de
colisiones fueron realizadas en la misma computadora y bajo las mismas condiciones. Se
trató de realizar las pruebas lo más justo posible y sin favorecer a ninguno de los
métodos. En dos de los casos se consiguió el código fuente original y se alteró para
adaptarlo a la prueba. A continuación se presentan los resultados obtenidos en las pruebas
realizadas.
6.2.1 1-COLLIDE vs GI-COLLIDE
Para comparar GI-COLLIDE con I-COLLIDE se tomó el código fuente facilitado por los
autores de 1-COLLIDE [5] y se reemplazó la prueba de intersección original de la
característica del modelo más cercana de Lin-Canny por el algoritmo de GI-COLLIDE.
Para ser lo más justos posibles en la comparación, se cambiaron solo las partes del código
6. Resultados 49
donde la colisión es detectada. La técnica de subdivisión del espacio usada por I
COLLIDE para detectar los pares activos que después serán probados para determinar la
colisión exacta se dejó intacta. Para el caso de GI-COLLIDE se reportó la primera
colisión encontrada y para I-COLLIDE se usó la función más rápida que provee la
implementación usada.
6
5
2
1
~ 1-COLLIDE -9- GI-COLLIDE
100 150 Número de Objetos
200 250
Figura 6.4 - Tiempo que toma la determinación de colisión entre GICOLLIDE y 1-COLLIDE
Para comparar ambos algoritmos se usó un objeto geométrico con 8444 triángulos
para 1-COLLIDE y una imagen de geometría de 65 x 65 píxeles para GI-COLLIDE que
consiste de 8450 triángulos. Los resultados de la prueba se muestran en la figura 6.4. El
eje x muestra el número de objetos colisionando entre ellos y en el eje y se muestra el
tiempo total usado para calcular las colisiones en los 3000 cuadros. E] tiempo para
detectar las colisiones crecen con el número de objetos en ambos casos. La figura 6.4
muestra que GI-COLLIDE necesita significativamente menos tiempo que el algoritmo
original de 1-COLLIDE para calcular las colisiones. La diferencia es más significativa
para un número grande de objetos. En la figura 6.5 se muestra el tiempo promedio de
cada colisión. I-COLLIDE reportó valores entre 9.5 a 11.5 milisegundos mientras que
GI-COLLIDE reportó tiempos entre 0.29 y 0.94 milisegundos.
6. Resultados
12~~~~~~~~~~~~~~~~~~~~
,§ 1Q~----1e----~~--~-~~-*~I ·¡¡;
o t) 8 ... o a. ¡g 6 1J e: ::J C> Q) 4 (/)
2
100 150 Número de Objetos
+ 1-COLLIDE -E,- GI-COLLIDE
200 250
Figura 6.5 - Tiempo promedio necesario para detectar una colisión entre 1-COLLIDE y GI-COLLIDE
6.2.1 BS-Tree vs GI-COLLIDE
50
La Segunda prueba realizada no usa subdivisión del espacio para determinar los pares
activos. Se usa la fuerza bruta para determinar la colisión de todas las combinaciones de
objetos. En este caso se comparó GI-COLLIDE contra un árbol de esferas generado
dinámicamente. El árbol de esferas se construye con la misma información y exactamente
la misma jerarquía que GI-COLLIDE. La implementación de los árboles dinámicos es lo
más parecido posible a la implementación de GI-COLLIDE. En realidad la jerarquía del
árbol dinámico se crea con base en la imagen de colisión generada. De la misma manera,
el recorrido de los árboles se realiza en el mismo orden y el cálculo de las interferencias
de las esferas y la intersección de los triángulos se hacen de la misma manera también. La
intención es comparar la diferencia en el rendimiento entre estas dos técnicas. La
diferencia en el rendimiento viene del esquema basado en apuntadores usado en los
árboles dinámicos y el esquema de indexación utilizado en GI-COLLIDE.
Los resultados de esta prueba se muestran en la figura 6.6. Se muestra el tiempo
promedio por colisión para las diferentes cantidades de objetos dentro del cubo. Los
6. Resultados 51
resultados muestran que en la mayoría de los casos GI-COLLIDE requirió menos tiempo
para detectar la colisión, mostrando un incremento de la velocidad de hasta 19%. Esto
muestra que el esquema de indexación de la imagen de geometría es mucho más eficiente
que almacenar las esferas de manera dinámica en memona. Aparentemente, los
requerimientos de memoria son muchos menores para el caso de las imágenes de
geometría, dado que no se requieren apuntadores y la relación jerárquica entre las esferas
queda implícita en la imagen.
0.4 ~--~--~---~--~--~
0.38
e: 0.36 :2 "' = 0.34 o ü
0 0.32 a. ~ 0.3
"CI
§ 0.28 en QJ
.!!1 0.26
:E 0.24
0.22
......... ARBOLDIN -e- GI-COLLIDE
02~--~--~---~--~--~ o 50 100 150 200 250
Numero de Objetos
Figura 6.6 - Tiempo promedio para detectar la colisión entre el árbol dinámico y G!-COLLIDE
Cabe mencionar que el algoritmo de BS-Tree fue mejorado en gran manera. En
realidad es muy dificil obtener una jerarquía perfectamente balanceada en la
implementación común de BS-Tree. En este caso, dado que se tomó como base la imagen
de colisión para generar el árbol de esferas dinámico, la jerarquía queda perfectamente
balanceada. Los BS-Tree también necesitan tiempo de pre-procesamiento para balancear
la jerarquía, lo cual no fue necesario en este caso gracias al uso de las imágenes de
geometría.
6.2.1 RAPID vs GI-COLLIDE
La otra prueba realizada para comparar GI-COLLIDE con otros algoritmos para la
6. Resultados 52
detección de colisiones fue con RAPID [13]. Para esta prueba también se utilizó la fuerza
bruta para verificar la colisión de todas las combinaciones posibles entre los objetos
dentro del cubo. Las pruebas reportaron el número de colisiones y el tiempo que tomó la
determinación de las colisiones. RAPID provee una opción para terminar con el primer
punto de intersección detectado o puede reportar todas las colisiones. Usamos la primera
alternativa para determinar la colisión en ambos algoritmos.
0.5 ~--~-------------~
0.45
~0.4;~
:!i o 35 .i I º . I u j
0 0.3 a. ¡g 0.25 "C
§ 02 · en dl ~ 0.15
:l: 0.1 '
0.05
RAPID -e- GI-COLLIDE
o~--~--~---~--~---~ o 50 100 150 200 250
Número de Objetos
Figura 6. 7 - Tiempo promedio para determinar la colisión entre GI-COLLIDE y RAPID
En la figura 6. 7 se muestran los resultados de las pruebas. Las pruebas muestran que
RAPID provee una detección de colisiones más rápida que GI-COLLIDE. RAPID es una
representación jerárquica de OBBs, los cuales proveen una aproximación más exacta al
volumen original que la que proveen las esferas, dejando menos espacio vacío. Por esta
razón los OBBs reportan menos detecciones falsas. Esta puede ser la razón principal por
la cuál RAPID detecta las colisiones más rápido. Pero aún así, los resultados muestran
que no hay una diferencia muy grande en los tiempos reportados. En promedio RAPID es
0.148 milisegundos más rápido que GI-COLLIDE para detectar una sola colisión. Por
otro lado, el pre-procesamiento para crear el árbol de OBBs que necesita RAPID toma un
tiempo muy considerable en comparación con el pre-procesamiento de GI-COLLIDE.
6. Resultados 53
6.3 Aplicación real
Para mostrar un ejemplo de una aplicación real que pueda utilizar GI-COLLIDE para la
detección de colisiones se desarrollo la aplicación y se implementó una prueba de
colisión entre un modelo de un helicóptero en movimiento y un terreno fractal. Se
realizaron las pruebas entre todas las combinaciones de resoluciones de las imágenes de
geometría, desde 513 x 513 hasta 8193 x 8193 píxeles de resolución. La imagen de
geometría y de colisión más grande ocupa 512 MB en el disco duro y es guardad como
una imagen TIFF de 16 bits.
50
41
(/) 33 o
"O e ::::,
g' 25 -~ ~
16
a :1024
o1====~==:Jc::===±===::I===t===r==~ 512 1024 1536 2048 2560 3072 3584 4096
Resolución
Figura 6.8 - Número de pruebas de colisión como una función de la resolución de los objetos
La figura 6.8 muestra los resultados de la detección de colisiones y estos coinciden
con las expectaciones de rendimiento. El número de pruebas de colisión corresponde a
una función logarítmica del número de vértices del objeto. Es importante resaltar que dos
objetos en resolución 4097 x 4097 ocupan más de 448 MB de memoria (192 MB para la
geometría y las normales y 256MB). El tiempo para determinar la colisión fue, en el peor
de los casos para 68.106 polígonos, por debajo de los 60 milisegundos. Para casos no
6. Resultados 54
extremos, como objetos con una resolución de 1025 x 1025, el tiempo fue cercano a los 4
milisegundos. Es claro con estos resultados que GI-COLLIDE trabaja eficientemente
especialmente con esta cantidad de datos tan grande.
6.4 Pruebas de tiempo crítico
La última prueba fue realizada para mostrar la posibilidad del algoritmo de reportar
colisiones con tiempo critico. De nuevo se utilizaron imágenes con resoluciones de 2049
x 2049 hasta 8193 x 8193. Se le asigno un tiempo crítico de 15 milisegundos para el
cálculo de cada colisión. En a figura 6.9 se muestran los milisegundos que tomó cada
colisión contra el número de polígonos en los objetos. La tasa de cuadros por segundo se
mantuvo constante en 60 fps ( dejando 15 ms para cada colisión). El número de colisiones
tiene un crecimiento logarítmico, pero en un cierto punto se mantienen constante. Esto
muestra que aún con las imágenes de geometría más grandes, se puede mantener una tasa
de cuadros por segundo constante y con una exactitud aceptable. Debido a que por lo
menos se ejecuta la primera prueba de colisión con la esfera envolvente de todo el objeto,
se sabe que si se reporta una colisión por lo menos las esferas envolventes de todo el
objeto están en contacto.
en o "O e
16
14
5i 12
1 ~
10
8 10 110 210 310 410 510 610
Millones de polígonos
Figura 6.9- Tiempo requerido para calcular una colisión como función de la resolución de los objetos. Se utilizó la detección de colisiones con tiempo crítico
7. Conclusiones
Las pruebas realizadas, los resultados de las mismas, el algoritmo generado y la
publicación del artículo relacionado con este trabajo permiten llegar a conclusiones claras
acerca del método propuesto. Se presenta el resumen de los resultados de las pruebas, las
principales contribuciones de esta tesis y la investigación futura que podría realizarse
para extender este trabajo.
7 .1 Resumen de los resultados
Los resultados obtenidos en las comparaciones con otros algoritmos muestran que el
método propuesto provee un desempeño que se acerca y en algunos casos supera otros
trabajos previamente publicados y que se consideran muy importantes en la investigación
de la detección de colisiones. El método presentado obtiene sus ventajas en la simplicidad
del mismo. La indexación como método de acceso a la jerarquía permite la optimización,
menos requerimientos de memoria y la posible implementación de manera sencilla en el
hardware gráfico.
En la prueba de la aplicación real se pudo observar que el método es muy eficiente
con el manejo de grandes cantidades de datos, otra vez gracias al uso de la indexación. En
muchas de las pruebas, los otros métodos no podían manejar la cantidad de datos que GI
COLLIDE pudo resolver sin mayor problema. Esto muestra una ventaja para aplicaciones
que utilizan geometría con gran detalle y muchos polígonos. Los resultados de la prueba
de la detección con tiempo crítico mostraron que es factible obtener tasas de cuadros por
segundo interactivas aún cuando se utilice modelos con mucha geometría.
El algoritmo muestra ser eficiente y ser una buena opción para la resolución del
problema de la detección de colisiones, ya sea exacto o con tiempo crítico. Se puede
llegar a esta conclusión gracias a los resultados obtenidos en las pruebas realizadas. El
uso de las imágenes de geometría en la detección de colisiones es una idea
completamente nueva. El trabajo aquí presentado culminó con la presencia en una
conferencia internacional (SCCG 2005 Eslovaquia) como full-paper y será publicado por
55
7. Conclusiones 56
ACM SIGGRAPH. En el apéndice a y b se presentan los comentarios de los referees del
congreso y la presentación realizada en el congreso.
7 .2 Contribución de la tesis
La principal contribución de esta tesis es la introducción de un algoritmo para detección
de colisiones que funciona con la representación geométrica de las imágenes de
geometría. El uso de las imágenes de geometría en la detección de colisiones es una
alternativa totalmente nueva y provee varias oportunidades. Permite guardar la
información generada durante el pre-proceso como una imagen, en la que se almacena
una jerarquía de esferas envolventes, y que por ser guardada como una imagen, permite
usar métodos de compresión sin introducción de errores como lo es LZW. También se
presenta un algoritmo para recorrer dos jerarquías de esferas envolventes mediante el
indexado de un arreglo bidimensional, lo que reduce la dificultad de implementación al
no tener que usar estructuras dinámicas. Esto también permite la implementación total del
algoritmo usando el hardware de la tarjeta gráfica. Dado que el algoritmo es muy sencillo
y las estructuras de datos también lo son, la implementación del algoritmo usando el
hardware de la tarjeta gráfica, no requiere de mayor modificación para su
funcionamiento.
El método presentado provee una alternativa real para resolver el problema de la
detección de colisión exacta. El algoritmo explota todas las ventajas que las imágenes de
geometría presentan. Entre estas se encuentran: guardar los datos como imágenes que
pueden ser comprimidas, uso de la indexación para el acceso a los datos, explotación de
la regularidad de los datos, posible implementación en GPU, etc. La estructura de la
jerarquía de volúmenes es recorrida con un algoritmo propuesto que hace uso de la
indexación y que es muy sencillo de implementar y el recorrido de los árboles se hace
mediante operaciones de corrimiento a la izquierda en un arreglo de flotantes.
Comparado con los algoritmos que se utilizaron para hacer las pruebas, la facilidad de
implementación de GI-COLLIDE, queda como una de sus más interesantes
características. El algoritmo mostró tener la relevancia suficiente para ser aceptado,
presentado y publicado en el congreso SCCG 2005 en Eslovaquia. De la misma manera
7. Conclusiones 57
se recibieron sugerencias de extender la investigación para su posible publicación en un
Journal especializado.
7.3 Investigación Futura
El método propuesto tiene varias alternativas que se pueden seguir desarrollando y varias
que se pueden mejorar. Se presentó la idea general del método, pero es claro que se
pueden hacer varias extensiones que servirán para mejorar el rendimiento y robustez del
algoritmo. Las oportunidades de mejora son en las restricciones actuales, nuevas
funcionalidades y alternativas de implementación.
7.3.1 Restricciones de resolución
Una de las alternativas de las oportunidades de mejora del método está relacionada con la
adaptación del algoritmo para aceptar imágenes de geometría como las generadas por
Sander et al. [33] las cuales provee una mejor transformación de los modeles, menor
distorsión y aceptan objetos formados por varias partes. Otra extensión del método se
encuentra en eliminar la restricción de utilizar imágenes de geometría con resolución de
(2n + 1) x (2n + 1) píxeles.
7.3.2 Nivel de detalle en colisión
Dado que las imágenes de geometría, gracias al uso del sub-muestreo pueden proveer
varios niveles de detalle para el despliegue, el método se podría extender para hacer
cálculos de colisión con nivel de detalle también. De esta manera se podría calcular de
manera exacta la colisión de objetos que se encuentran cercanos a la cámara y para
objetos lejanos a la misma el cálculo podría hacerse como una aproximación. Esta
alternativa podría ser muy útil para aplicaciones con colisiones en tiempo real donde la
precisión en la detección de colisión no sea indispensable.
7. Conclusiones 58
7.3.3 Implementación en hardware
El método de indexación utilizado puede ser fuertemente explotado si el algoritmo se
implementara como un píxel shader que corriera dentro del procesador gráfico, dado que
los datos se pueden almacenar como texturas de 16 bits y estas pueden ser leídas y
utilizadas por el shader. De esta manera se podría utilizar el GPU para hacer los cálculos
de las transformaciones, indexación, intersección de esferas e intersección de triángulos,
lo que aumentaría de manera considerable el rendimiento del método.
7 .3.4 Volumen envolvente alternativo
El algoritmo se podría extender para usar OBBs como volumen envolvente en vez de
utilizar las esferas. Esto puede proveer una mejor aproximación y una velocidad mayor,
como lo mostró la comparación con RAPID. Las dimensiones y orientación de los OBBs
se pueden almacenar en otra imagen de geometría o en capas extra dentro de una misma
imagen TIFF de 16 bits, dado que el formato TIFF soporta múltiples capas dentro de un
mismo archivo. Eso se podría conjugar con la implementación en hardware para realizar
las transformaciones de los OBBs de manera eficiente utilizando el GPU.
Bibliografía
[ 1] Approximating polyhedra w ith spheres far time-critica/ col/is ion detection. http://www. graphics. come 11. edu/pubs/l 996/Hub96a. html
[2] BACIU G., WONG W. Jmage-based techniques in a hybrid collision detector. IEEE Transactions on Visualization and Computer Graphics 9, 2, 254-271. 2003
[3] BRADSHAW. G., O'SULLIVAN C. Adaptive media/axis approximationfor sphere-tree construction. ACM Transaction on Graphics 23, 1, 1-26. 2004
[4] BRICEÑO H. M., SANDER P. V., MCMILLAN L., GORTLER S., HOPPE H. Geometry videos: a new representationfor 3D animations. In Proceedings of the 2003 ACM SIGGRAPH/Eurographics Symposium on Computer Animation. 136-146. 2003
[5] COHEN, J. D., LIN M. C., MANOCHA D., PONAMGI M. 1-collide: an interactive and exact collision detection systemfor large-scale environments. In Proceedings ofthe 1995 symposium on Interactive 3D graphics, ACM Press, 189-ff. 1995
[6] Ca/lisian Detection. http://www.cs.unc.edu/-geom/collide/index.shtml
[7] Collision Detection. http://www.stanford.edu/-jgao/collision-detection.html
[8] CULLIDE. http://gamma.cs.unc.edu/CULLIDE/
[9] DEVILLERS O., GUIGUE P. Faster Triangle-Triangle lntersection Tests. Rapport de recherche 4488. Projet PRISME, Unit de recherche INRIA Sophia Antipolis; 2002.
(10] ECK M., DEROSE T., DUCHAMP T., HOPPE H., LOUNSBERY M., STUETZLE W. Multiresolution analysis of arbitrary meshes. Computer Graphics 29, Annual Conference Series, 173-182. 1995
(11] EHMANN S. A, LIN M.C. Accurate andfast proximity queries between polyhedra using convex surface decomposition. In Proc. Eurographics 2001.
(12] EHMANN S. A, LIN M. C. Accelerated proximity queries between convex polyhedra by mu/ti-leve/ voronoi marching. Technical Report. Computer Science Department. University of North Carolina at Chapel Hill. 2000.
59
Bibliografía 60
[13] GOTTSCHALK S., LIN M.C., MANOCHA D. Obbtree: a hierarchical structure for rapid interference detection. In Proceedings of the 23rd annual conference on Computer graphics and interactive techniques, ACM Press, 171-180. 1996
[14] GOVINDARAJU N. K., REDON S., LIN M.C., MANOCHA D. Cullide: interactive collision detection between complex models in large environments using graphics hardware. In Proceedings ofthe ACM SIGGRAPH!EUROGRAPHICS conference on Graphics hardware, Eurographics Association, 25-32. 2003
[15] GU, X., GORTLER, S. J., HOPPE H. Geometry images. In Proceedings ofthe 29th annual conference on Computer graphics and interactive techniques, ACM Press, 355-361. 2002
[16] HE T. Fast collision detection using quospo trees. In Proceedings ofthe 1999 symposium on Interactive 30 graphics, ACM Press, 55-62. 1999
[17] ffiJBBARD P. M. Approximating polyhedra with spheres for time-critica! collision detection. ACM Trans. Graph. 15, 3, 179-210. 1996
[18] 1-Collide. http://www.cs.unc.edu/-geom/I_COLLIDE/index.html
[19] KLOSOWSKI J. T., HELD M., MITCHELL J. S. B., SOWIZRAL H., ZIKAN K. Efficient collision detection using bounding volume hierarchies of k-dops. IEEE Transactions on Visualization and Computer Graphics 4, 1, 21-36. 1998
[20] LEE A W. F., SWELDENS, W., SCHR º"ODER, P., COWSAR, L., DOBKIN D. MAPS: Multiresolution adaptive parameterization of surfaces. Computer Graphics 32, Annual Conference Series, 95-104. 1998
[21] LIN M.C., CANNY, J. F. Afast algorithmfor incremental distance calculation. In IEEE Intemational Conference on Robotics and Automation, 1008-1014. 1991
[22] LIN M.C., CANNY, J. F. Efficient collision detectionfor animation. In Proceedings of the Third Eurographics Workshop on Animation and Simulation. Cambridge, England, 1991.
[23] LOSASSO F., HOPPE H., SCHAEFER S., W ARREN J. Smooth geometry images. In Proceedings ofthe Eurographics/ACM SIGGRAPH symposium on Geometry processing, Eurographics Association, 138-145. 2003
[24] MIRTICH B. V-clip: fast and robust polyhedral collision detection. ACM Transaction on Graphics 17, 3, 177-208. 1998
Bibliografia 61
[25] MOLLER T., RAINES E. Real-Time Rendering. A K Peters. 2002
[26] MOLLER T. Afast triangle-triangle intersection test. J. Graph. Tools 2, 2, 25-30. 1997
[27] Netcar. www.netcar.eo.il/ magazin/milon.asp
[28] PONAMGI M., MANOCHA D., LIN M. C. Incremental algorithms for collision detection between so/id models. In Proceedings of the third ACM symposium on Solid modeling and applications, ACM Press, 293-304. 1995
[29] PRAUN E., HOPPE H. Spherical parametrization and remeshing. ACM Transaction on Graphics 22, 3, 340-349. 2003
[30] QuickCD (Quick Collision Detection). http:/ /www. ams. sunysb. edu/-jklosow/ quickcd/QuickCD .html
[31] RAP ID -- Robust and Accurate Polygon lnterference Detection System. http://www.cs.unc.edu/-geom/OBB/OBBT.html
[32] Rigid Body Simulation. http://www.codercomer.com/Rigid.htm
[33] SANDER P. V.,WOOD Z. J., GORTLER S. J., SNYDER J., HOPPE H. Multichart geometry images. In Proceedings of the Eurographics/ ACM SIGGRAPH symposium on Geometry processing, Eurographics Association, 146-155. 2003
[34] SOLID - Software Library far lnterference Detection. http:/ /www.win.tue.nl/-gino/solid/
[35] SWIFT + + Speedy Walking via lmproved Feature Testingfor Non-Convex Objects. http://www.cs.unc.edu/-geom/SWIFT ++/
Apéndice A
Carta de Aceptación a Congreso y Revisión del Jurado del
Artículo: GI-COLLIDE: Collision Detection with Geometry
Images
Dear author,
we are pleased to inform you that your paper entitled
GI-COLLIDE --- Collision Detection with Geometry Images
has been accepted for the SCCG 2005 conference. Please find below the referees' comments on your paper. This acceptance is subject to the condition that at least one of the authors registers with the conference and presents the paper at the event.
Please prepare the final version of the manuscript according to the instructions at the conference web site (www.sccg.sk) until
May 2nd, 2005
For ali technical details conceming your submissions, please contact the people at Bratislava directly. Please take in mind that the number of pages should not be increased much, and that an even number of pages is preferable.
If sorne of the reviewers asked for specific revisions, then please prepare a short document that explains how the referees' comments have been taken into account. While this will not be checked for the first edition of the proceedings (published by Comenius University at the conference ), it will be examined when compiling the final version, which will be published by ACM Siggraph later this year. If in doubt, we will contact the referees again.
The paper should be submitted according to the instructions at the conference. The additional document describing the revisions should be sent by email to Pavel Chalmoviansky ([email protected]).
Thank you for submitting a paper to SCCG 2005! We look forward to
62
Apéndice A
seeing you at Budmerice Castle!
Best regards
Bert Juettler (Program Chair) Pavel Chalmoviansky (Assistant to the Program Chair and IPC member)
**************************************************
REPORT#l
----
P APER NUMBER <34 AUTHORS <Anonymous TITLE OF THE P APER <Gl-Collide - Collision Detection with Geometry Images
I. CLASSIFICA TION
Please classify the paper selecting one of the choices below: R - Research paper (presents innovative research results ); R P - Practice and experience (variants, applications, case studies); S - State-of-the-art report (reviews of recent advances);
U. SUMMARY
Please summarize the paper and state what you consider to be the contributions of this paper to computer graphics.
The paper presents a new collision algorithm, based on combination of geometry images and a hierarchy of spheres. As far as I know, this i a new idea howto solve the collision detection problem.
63
--------------------------------------
III. ASSESSMENT
Apéndice A
Please rate the submission using a scale of integers between O (totally unacceptable) and 9 (excellent)
for the seven items listed at the end of section III.
Please assign numbers as shown below:
O= totally unacceptable, 1 = very poor, 2 = poor, 3 = clearly below SCCG standard, 4 = dubious; not quite acceptable, 5 = marginal; only just acceptable, 6 = acceptable, 7 = good, 8 = very good, 9 = excellent
Add additional comments as you wish.
III.1 ORIGINALITY, NOVELTY
7
III.2 CLARITY OF PRESENTATION
7
III.3 TECHNICAL SOUNDNESS
7
III.4 IMPORTANCE, UTILITY
6
III.5 SUBJECT SUITABLE FOR EVENT?
7
III.6 COMPLETENESS OF REFERENCES (lf not, list missing references.)
7
64
Apéndice A
111. 7. COULD THIS APPROACH BE IMPLEMENTED BY A GRADUATE STUDENT?
Probably yes. [This is advantage or disadvantage, by the way?]
IV. OVERALL RECOMMENDA TION
Please rate the submission using one of the following integer values: 7
O = totally unacceptable, 1 = very poor, 2 = poor, 3 = clearly below EG standard, 4 = dubious; not quite acceptable, 5 = marginal; only just acceptable, 6 = acceptable, 7 = good, 8 = very good, 9 = excellent
65
V. füSTIFICA TION FOR DECISION AND MAIN CONTRIBUTION OF THE P APER
Please fill in. This is likely to be the most important part of the report, since it will help the authors comprehend the decision, and allow them to rectify potential problems.
Although the partial techniques (mainly the spheres hierarchies for collisions are old, their use with geometry images is new. The idea is simple. The paper is well written. The tests are well documented.
VI. CONFIDENCE IN THE EV ALUA TION
Please specify: 4
1 - Very unconfident, really justa guess; 2 - Rather unconfident, but I know a bit; 3 - Moderately confident, I know as much as most;
Apéndice A
4 - Pretty confident, I know this area well; 5 - Extremely confident, I consider myself an expert;
-----
VII. MAJOR REVISIONS REQUIRED TO BE ACCEPTED? (YES/NO)
I am missing one item in the tests: it is good that you shou comparison with other techniques and behaviour for a kind of real data. Why not to show also comparison with other methods for these data? I mean, to make the section 5.4 analogical to 5.2 or 5.3.
VIII. ADDITIONAL COMMENTS FOR THE AUTHORS
One remark: the shape of images is more or less rectangular and you embed it into spheres. Why not to use the rectangular boxes which would fit more? It would be also possible to code them as one value (instead of spehres radii), the value could be sorne kind of enlargement ofthe 'image box'.
######################################################################
REPORT#2
REVIEWER'S REPORT FORM
**** IMPORTANT **** Please note that *all * answers to *all * questions ( except the confidential comments question and of course reviewer identification) will be forwarded anonymously to the authors. It is thus important to word your responses appropriately.
P APER NUMBER 34 AUTHORS <Author(s) TITLE OF THE PAPER GI-COLLIDE - Collision Detection with Geometry Images
66
Apéndice A
l. CLASSIFICA TION
Please classify the paper selecting one of the choices below: R - Research paper (presents innovative research results ); P - Practice and experience (variants, applications, case studies); S - State-of-the-art report (reviews of recent advances);
R
II. SUMMARY
Please summarize the paper and state what you consider to be the contributions of this paper to computer graphics.
The author(s) presented a collision detection algorithm based on geometric images. The algorithm makes use ofbounding spheres, which can be perfectly balanced into hierarchical structure.
The most important contribution of the paper is the application of the geometric images to the collision detection problem, what has not been done before according to ma knowledge.
The important contribution is also the way how the tree hierarchies are stored. Instead of using the dynamic data structure, a simple two-dimensional arra y is applied which enables efficient accessing of bounding sphere coordinated.
67
-----------------------------------------------
III. ASSESSMENT
Please rate the submission using a scale of integers between O (totally unacceptable) and 9 (excellent)
for the seven items listed at the end of section III.
Apéndice A
Please assign numbers as shown below: 8
O= totally unacceptable, 1 = very poor, 2 = poor, 3 = clearly below SCCG standard, 4 = dubious; not quite acceptable, 5 = marginal; only just acceptable, 6 = acceptable, 7 = good, 8 = very good, 9 = excellent
Add additional comments as you wish.
III.1 ORIGINALITY, NOVEL TY
This approach open the new page in the collision detection field. As shown by the tests, the algorithm is extremely efficient.
III.2 CLARITY OF PRESENTATION
Paper is well written.
III.3 TECHNICAL SOUNDNESS
OK
III.4 IMPORTANCE, UTILITY
Very important
III.5 SUBJECT SUITABLE FOR EVENT?
Very suitable.
III.6 COMPLETENESS OF REFERENCES (If not, list missing references.)
Adequate.
III.7. COULD THIS APPROACH BE IMPLEMENTED BY A GRADUATE STUDENT?
68
Apéndice A
Yes.
IV. OVERALL RECOM:MENDA TION
Please rate the submission using one of the following integer values: 8
O = totally unacceptable, 1 = very poor, 2 = poor, 3 = clearly below EG standard, 4 = dubious; not quite acceptable, 5 = marginal; only just acceptable, 6 = acceptable, 7 = good, 8 = very good, 9 = excellent
69
V. JUSTIFICATION FOR DECISION AND MAIN CONTRIBUTION OF THE PAPER
Please fill in. This is likely to be the most important part of the report, since it will help the authors comprehend the decision, and allow them to rectify potential problems.
The paper explains how geometric images can be used at collision detection. It also introduces the new way how to represent the BS-tree. This representation also contributes to the extreme speed of the algorithm
VI. CONFIDENCE IN THE EVALUATION
Please specify: 4
1 - Very unconfident, really justa guess; 2 - Rather unconfident, but I know a bit; 3 - Moderately confident, I know as much as most; 4 - Pretty confident, I know this area well;
Apéndice A
5 - Extremely confident, 1 consider myself an expert~
VII. MAJOR REVISIONS REQUIRED TO BE ACCEPTED? (YES/NO) NO
If yes, please specify:
VIII. ADDITIONAL CO:MMENTS FOR THE AUTHORS
(if any)
70
Apéndice B
GI-COLLIDE - Collision Detection with Geometry lmages
Bedfich Benes • ITESMCCM
Nestor Goméz Villanueval ITESMCCM
Figw-e 1: 512 bulllli es tested for collisions
Abstract
A new collision detedion algoritlun GI·COLLIDE is presented Toe algorithm works with geomehy images and codes bowiding spheres as a perfecUy balanced mip·map-like hierarchical data slructure. Toe largest geometry image in the hierarchy stores the bouncing spheres oí the quadruples oí the vertices from the input geometry image. Center oíthe sphere is calculated as the center of the corresponcing min·max AABB and stored as the pixel's ROB value. The alpha value stores the sphere radius. In this way each leve! rep-esents bounding spheres of !he previous leve!. The upmost leve! oíthe hierarchy is the bouncing sphere oíthe entire object. Collisions between oijeds are deteded by the standard tree traversing and checking the overlaps among the bowiding spheres. Toe exad collision is detected by a biangle-triangle test at the lowest leve!. The bowiding sphere coding is implicit. A sphere at any leve! can be found efficienUy only by indexing the geornetry im· age. Once objecls are represenled as geometry images the collision deledion can be performed efficienUy using diredly this represen· tation and it is not necessary to use any other. The results show that this method is efficient and works well even for large objects. We have compared Gl·COLLIDE with the most importan! collision detection teclmiques.
CR Categorics: 1.3.3 (Computer Graphics]: Pidurellmage Gener· ation - Viewing Algoritluns- (I.3.7): Computer Graphics-Three Dimensional Graphics and Realism - Virtual Reality
Ktywonls: Geometry Images, Collision Detedion, Real·Time Rendering, nme-Critical Rendering
•e-mail bedrich.benes@itesm mx t e-mail: ngomez@itesmmx
71
1 lntroduction
Geometry images were recently introduced to Computer Graph· i es ( Gu et al. 2002 ). Their main advantage is the efficient way they code geometric iníormation. The sampled geometry is stored in a perfectly regular fonn - as an image. A geometry image can be compressed by the compressi on schemes used for images; i t can be efficienlly stored and processed by graphics hardware, efficiently transmitted over network, etc. Many algoritluns exploiting advan· tages oí geometry images have recenUy been introduced, but we have not found any approach focusing on collision detedion. There are collision detection algoritluns that worlc very well wiUt another represenlalions, but we do not know any algorithm thal worlcs directly with geometry images. We present a new algorithm named OI·COLLIDE. Toe advantage of our approach is in exploiting the properties of geometry images. Suppose, we have objecls represented as geometry images. Iíwe want to detect collisions among them we do not need to use anoUter represenlation, but we can use the geometry images cirectly.
We propose a mip·map-like (Moller and Haines 2002) hierarchi cal structure ofthe geometry images for an efficient collision detection. Toe input geometry image is used lo calculate the bowtding sphere tree (BS·tree). Toe deepest leve! holds in the RGB triplet the center oí the sphere that is calculated as the center oí the AABB oí the íow- vertices from the input data. The alpha value stores the bound· ing sphere radius. 11ús iníormation is sufficient to create bound· ing sphere oí the íow- vertices. Toe upper levels are computed and stored in the same way. Toe hierarchy can be eilher precomputed and stored together wi Ut the image or computed when Ute geometry image is read or created.
Oeometry images will change ií the object rotate and lhat is why we use spheres as the bouncing volumes, keeping in mind that lhey, in general, do not provide a good fil to the objects.
There are two general approaches to detect col lisions or interpenetrations between two objects: collision delection (also known
Apéndice B
as interference deteclion or contact detennination) and proximity queries (also known as penetration depth computation). The colli· sion detection tectmiques automatically report a geometric contact that occurs or has actually occurred, giving the point of collisioIL Proximity cp1eries algorithms report the collision as well, moreover they also provide extra infocmatioo such as interseclion detection, tolerance verification, exact oc approximate minimum distance, or disjoint contad deterrnination. GI·COLLIDE is a collision detec· tion technique i.e., the algorithm report weather a collision between two objects has occurred or not.
Gl·COLLIDE uses the precomputed hierarchical slructure and al· ways starts by comparing the upmost levels of the objects hierar· chies, i.e., the bouncing spheres ofthe enlire obj eds. In the case of overlap, there is also potenlial collision and the sbuctures of both objeds are recursively traversed down. At the deepest leve! the exact triangle-to-triangle test is applied (Moller 1997]. Figure 2 shows an example of the bounding spheres hierarchies refinement asan object gets doser to another one.
Figure 2: Sphere hierarchy refinement during the collisioo detection
Various stop-conditions can be applied We can terminate the tra· versation when one collision is detected. Another choice is to con· tinue and detect ali possible collisions. We also describe a limecritical version ofthis collision detection algorithm. The difference to the non-lime-critical version is that the collision test must be fin· i!tted within a user-defined time. The test returns the best possible result that is detected within this time.
Geometry images are normally used to store one object, so we describe the obj ect-to-object test in this paper. To detect colli· sions among more objects we have incorporated our test into the l·COLLIDE (Cohen et al. 1995] algorithm that uses an efficient space subdivision teclmique and :frame to frame coherence.
2 Previous Work
2 .1 Geometry lmages
Gu et. al. [Gu et al. 2002] introduced geomeby images; data struc· ture that efficiently codes and stores the object's geomeby. This representation captures geometry as a two-dimensional amy of quanlized disaete points. Other surface signals, like normal vec· tors and colors, are stored in similar arrays using the same sur· face parameterization. Texture coorcinates information is implicit in the image. Methods for reme!tting geomeby images where inlro· duced in [ Gu et al. 2002 J based on techniques for remeshing with (semi) regular conneclivity (Eck et al. 1995; Lee et al. 1998]. The
72
most important is the heurislics that cuts a surface into a disk thal maps the surface onto a scp1are.
Praun and Hoppe (Praun and Hoppe 2003) introduced a tectmi cpe for direct parameterizalion of a genus-zero surface onto a spher· ical domain. 1bis technique provides geomeby remeshing, level of detail, morphing, compression, and smooth surface sulxivision. The main limitalion of these technicpes is the restriction to a non· manifold geometry.
Sander et al. (Sander et al. 2003) presented an atlas construction that maps the surface piece wisely onto charts of arbitrary shape. Re<mced parameterizalion cistorlion was achieved anda zippering algorithm that ere ates a watertight surface was presented U p to this point, geometry images were used only to store georneby information, normal vectors, or animated geometry.
Geometry images with simple boundary symmetries werelater used to store spline surface control points (Losasso et al. 2003). A bi· cubic surface is evaluated using a subdivision scheme, and the reg· ular structure of the geomeby image makes this computation well suited for graphics hardware. Tois scheme also provides a smooth leve! of detail transitions from a subsampled base octahedron to a smooth model.
Various approachesfor collision detection, proximity, andinterpen· etration between two oijects exisl Next, we present the most im· portant recently published algorithms and approaches.
2.2 Collision Detection
Collision detection and collision response generation are extremely important in many Computer Graphics applicalions, such as video games, Virtual Reality, interaction with CAD models, etc. Severa! techniques for oijects collision detection have recently been intro· duced Computing a t~ over ali polygons in a model is exact, but very expensive in tenns of computatiOIL The majmty of the al· gorithms exploit hierarchical data structures of bOW1cing volumes re<mcing the time complexity ofthe algorithrns.
OBB ·lrees were used in the fundamental paper of Gottschalk et al. (Gottschalk et al. 1996] for computing collisioo detection. A hier· archical bounding volmne data structure uses light-fitting oriented bounding box trees. 1\vo such trees are traversed and tested for overlaps between oriented bomtcing boxes based on the separating axis theorem. A test for box overlap that takes about huncred oper· ations was presented.
Klosowski et al. (Klosowski et al. 1998] introwced hierarchies of discrete orientation polytopes (k·DOPs) for efficient collisioo de· tecli OIL The principal advantage of this method is a better fil of the k·DOPs compared to the previously used bouncing volumes. Toe BV-tree traversation is similar to the previously mentioned
He [He 1999] mows a combination of OBBs and k·DOPs called QuOSPOs. This approach provides a light approximation of the original model at each level, and suppocts a conservative overlap· checking algorithm.
Bradshaw and O'Sullivan (Brad!ttaw and O'Sullivan 2004] pre· sented a Sphere-ltee construclion that approximates both convex and non-convex objects. Their teclmicpe is based on the Dynamic Medial Axis Approximation and the fil reported is better than the one reported by Hubbard [Hubbard 1996].
The algorithms mentioned so far work in the geometrical objectspace. Baciu et al. [Baciu and Wong 2003] proposed a method for collision deteclion that works in the image space. This algoritlnn
Apéndice B
breaks the object-space collision detection bottleneck by cistribJting the computational load onto the graphics pipeline. The imagespace interfermce test is based on projecting the object geometry onto the image plane and performing analysis in a climensonally rewced space. The hybrid collision detection algorithrn first calculates the separating vector to find oon-colliding oqects. If no separating vectors are fOW1d, the image-based algorithm is invoked for further temng ofinterference.
CULLIDE (Govindaraju et al. 2003) is a GPU-based collision detection algorittun that also works in the image space. ~ects that are tested for collision can be deformable and breakable. The col· lision detection algorithm calrulates the potentially colliding sets that are obtained from visibility queries. This allows performing the detection only to parts and sub-parts of objects.
2.3 Proximity Queries
Collision detection algorittuns report zero-one, or zero-more collisions. Proximity queries detect collisions and also distance oftwo oijects, penetration depth, spanning distan ce, etc. Result of a proximity cpiery can be exact, approximate, or Boolean. Moreover, the majority of the proximity query techniques share one common approach; they exploit frame-to-frame coherence. Here we present overview of the most important proximity query algorithms and techniques recently published.
I ·COLLIDE [ Cohen et al. 1995] is a two leve! approach based oo pnming multiple obj ect pairs using bouncing boxes and performi.ng exact collision detectioo between selected pairs of polyhedral. models. To determine whether a collision has ocCWTed or oot, the algorithm uses the el ose& feature algorithm of [Lin and Canny 1991). This algorittun reduces the number of re<plired tests that would be calculated by checking for bounding boxes obj ect overlaps. Once the collisi.on is detected, the precise collisi. on test is performed for ali involucrate polygons.
An inaemeotal proximity query detection algorithm between two general B-rep objects was published [Ponamgi et al. 1995). The algoritbm combines a hierarchical representation of AABBs wilh an incremental frame-to-frame computalion. Coherence between successive instances determines the number of interacting object features. n localizes the interference regions on the convex hulls of each pair of objects. The features associated with the regions are stored in a precomputed hierarchy.
The V-Clip (Mirtich 1998) algorithm tracks the closest pair offeatures between convex polyhedra, using the approach similar to the closest feature algorithm of[Lin and Canny 1991). It handes penetrating polyhedra, and can also be used to detect collision between both convex and concave polyhedra. The hierarchy helps to build concave polyhedra from several convex polyhedra. A convex hull ofthese subsets is constructed and, when a collision is detected; the subsets are tested to find the exact collision.
SWIFT++ shows unified approach to perform queries for checking objects intersections, tolerance verification, exact and approxirnate mínimum distance computalion, and ( cli&j oint) contact determination. Toe methods involve a hierarchical data strudure built upon a surface decomposition ofthe models. The inaemental query algorithm takes advantage of coherence between successive frames. A mínimum distance computation algorittun based on "Voronoi marching" to test the proximity of a pair of convex polyhe<h was also described.
The paper continues with the description of the data structure that codes the BS-tree. We describe the algorittun itself in Section 4.
73
Results are shown in the next section and Section 6 describes some opened queslions and the future work.
3 Data Structures and the BS-trees
To generate geometry images we use obj ects that are modeled by hand in Maya, the Stanford Bunny, anda fractal surface patch. The objects are converted to sets oftriangles and then to geometry images. This allCM's us to create a variety of shapes, both conve,c and concave. Toe geometry images can be also sampled with cifferent precision, allowing images in higher resolution with more details and vice versa. Our geornetry images are represented by 16-bits per channel and therefore have better precision than the standard 8-bits per channel representation. Example of an oqject and its corresponcing geometry image is given in Figure 3.
Figure 3: An object and its geometry image
lnputgem,aby immu•
18V911 IIMl2
Figure 4: Calculating the hierarchy
From the given geornetry image, the adcitional data structure that codes the bouncing spheres hierarchy is directly generated. Geometry images are in our implementation, by now, limited to sizes of (2n + 1) x (2n + 1) vertices. Each quadrilateral is encompassed by a bounding sphere at the deepest leve! (see in Figure 4). The sphere ceoter is clefined as the center ofthe corresponding min-max AABB. Its racius is lhe half-length of the largest diagonal. The
Apéndice B
geometry image stores in the RGB values the center of the sphere and the alpha stores the sphere radius (see in Figure 6). When the deepest leve! is stored the upper levels are calculated recursively and stored Neighboring four spheres from the lower leve! are en· compassed by a bounding sphere. Its center is stored as the RGB and the radius as the alpha value. The topmost leve! is the bouncling sphere of the en tire object and corresponds to the root of the tree ofBSs.
Mip-mapping cannot be used directly because to store the complete infonnation four values are required To save the memory, we store the hierarchy in the way that is depicted in the Figure 6. Toe deepest level is stored at the position [O,OJ and the rernaining levels are rotated by 90° and shifted by the size ofthe base image. Toe upper image shows the geometry and the lower the alpha channel displayed as the intensity of gray color. It can be seen that the alpha gets greater with the increasing leve! (ctisplayed as the brighter color in gray scale), i.e., the spheres located higher in the hierarchy are bigger. The BS-tree generated in this way is always perfectly balanced that is one of the biggest advantages ofthe proposed tech· ni que.
Different levels of refinement corresponding to one object are shown in Figure 5. The bouncing spheres form an object's shape approximation that improves with each leve! ofthe BS-tree.
Figure 5: Different levels ofbouncing spheres tight to the object approximate its shape
The amount of space required to store the hierarchies and the im· ages can be expressed easily. Suppose the geometry image has res· olution (2n+1) x (2n+l). Each vertex hasthree coordinates that are stored as the RGB values. The required size of the geometry will be denoted by s = 3(2n + 1) x (2n + 1) ands is expressed in in· tegers. Toe normal vectors need the same space as the vertices. The total size of the geometry image together with the nonnal vectors will be 2s.
The lowest level of the hierarchy stores in each bounding sphere four vertices. Toe lowest leve! bounding spheres share vertices so each inner vertex belongs to four spheres. The deepest leve) is made up of n x n spheres. The upper I evel is always half of the previous one in the x and in the y direction. So the total size required for the hierarchy is i~ n zi. The geometry image is quadrilateral ( see Figure 6) so the total size required is 25% bigger. The size required to store the center of the spheres is therefore l.5s. The alpha values are scalars and they are stored in the same way. The size required for the alpha values is 0.5s so the total size ofthe BS·tree hierarchy is 2s. The entire size of the geometry image, normal vectors, and the BSs is 4s, where s is the geometry image itself, one mores is required for the normal vectors and 2s for the BSs.
4 Collision Detection Algorithm
Toe collision detedion algoo.tbm oftwo objectsis the classical dou· ble hierarchy traversation. First, the upmost-level spheresfrom both
74
Figure 6: Toe hierarchy of bounc&.ng spheres stored as the geometry images. Toe upper image shows the average values, lower one shows how the bounding sphere sizes are coded. Since the spheres are small, the gray intensities are enhanced
BS-trees are tested for collision. Ifthere is no collision, the algorithm quits. In the positive case, the algorithm recursively traverses the hierarchies down. It enters the first level of the first object and tests the upper leve) ofthe second object for collision with all four spheres. In the case of collision, it goes one leve) down in the hier· archy ofthe second object and tests the colliding sphere or spheres against ali four spheres ofthe second object. Both hierarchies are traversed recursively in this zigzag way. At each leve), one sphere from the upper leve) of one object is tested against four spheres of the lower leve) of the second object and vice versa. At the deep· est leve! the preáse triangle-to-triangle test [Moller 1997] is perfonned
As mentioned above the collision detedion test can finish with the first collision detected or it can report a list of ali possible collisions. Toe :first collision detection is fast and the algorithm has logarithmic complexity because ofthe tree hierarchy. Having two oijects with n 1 and n2 vertices the complexity of this kind of test is O(log(max:{n 1 ,n2} ).
In the case of detection of the all·possible collisions the complexity is IJ(n 1 x n2). An example of this situation is two plan ar mesh es laying one over another.
Toe collision detection can also be time critica!. In this case it stops the detedion when there is no collision or whet the time is up, retuming the best possible fit that was found The non-time-critica! test stops testing either when there is no collision or on the deepest leve! i.e., with the triangle-to-triangle test.
In our implementation, and in ali non-time-critica! tests shown later in the paper, we have implemented the test that quits when the first collision is detected It is possible to run the test completely and detect ali collisions. We also generate the collision response.
As long as an o1::gect moves, the corresponding bounding spheres are transl.ated, and theRGB values ofthegecmetryimages must be recalculated. The alpha that codes the distance remains unchanged.
Apéndice B
The cistance·offset calculation can be applied to ali vertices and spheres blincDy, but many calculations can be wasted without actu· ally being u sed. We prefer to perform this step during lhe hierarchy traversatioo,just befare it is actually neecled.
Spheres do not provicle very good :fit to the obj ects in general and this is very true especially in the case of quamlaterals. This can be observed in Figme 7, where the plane is refined by spheres. We have found that this is not an important limitation, because the sphere radius in the BS·tree decreases fast so possible false colli· sían in the first leve! would be discarded with a high probability in the next level or levels.
Figure 7: As the object gets closer to the plane the sphere hierar· chies are refined (the camera is moved closer to demoostrate the spbere refinement)
Toe main advantage of our method over the previously published techniques is the way the tree hierarchies are stored. Jnbtead of storing the tree in the dynamically allocated memory, it is implemented as indexing of a two-dimensional array. We simply access the data by dividing/multiplying the actual coorcinates by two in each leve! of hierarchy. Toe regular sampling, that is the natural property ofthe geometry images, assures that we always canmuct a perfectly balanced tree ofboWlding spheres. Findiog coordinates of a sphere within the hierarchy is done fast and is implemented only by the bitwi se shifts.
5 Results
GI·COLLIDE was tested against l·COLLIDE [Cohen et al. 1995), the dynamically allocated BS-trees, and the RAPID [Oottschalk et al. 1996) algorithm. We also show lhe results of a time-critical implementatioo anda real application. In the comparisons the same conditioos were used for ali tests. A cube was filled by 2,4,8, ... , 256 randomly moving Stanford Bunnies that were eventually col· liding. A collision was cletected and the collision response was cal· culated. To detect the collision the precise triangle·to·triangle test was used Each test was executed for 3000 :frames and the number of collisions and the total time in millisecands spent on collisioo detection were reported
We do not explain the algorithms here and we refer the reader to Section 2.
5.1 1-COLLIDE vs GI-COLLIDE
To compare Gl·COLLIDE with the l·COLLIDE we have taken the source code of l·COLLIDE and replaced the default Lin·Ceney closest feature test by the GI·COLLIDE algorithm. We tried to make the test as fair as possible. We have changed only the parts of source code where the collisioo is detected The space subdivisioo technique, used by l·COLLIDE to detect active pairs that are Jater tested for exact collision determination, was Je.ft intact.
4
+ <COLLl>E ,@, G! COLUDE
75
1CXJ 150 Numberotobj•ct
Figme 8: nme spent for collision detection with l·COLLIDE and GI·COLLIDE
To compare both tests we used an oij ect having 8444 triaogles fer the original l·COLLIDE test anda 65 x 65 pixels geometry image that corresponds to 8450 triangles.
Results of this test are shown in Figure 8. The r·axis shows the nwnber of objects colliding against each other and the y-axis the time in milliseconds spent on collision detection for 3000 trames. The time spent to detect the collisions grows with the number of objects in both cases. Toe graph shows that GI·COLLIDE needs sig· nificantly less time than the original algorithm used by l·COLLIDE. Toe dfference is more significant especially for large mmiber of oijects.
50 100 150 ltlmber of objecs
+ l·COLUDE ,e, Gl·COWOE
200 250
Figme 9: Average time needed to detecta collisi.on for l·COLLIDE and GI·COLLIDE
Figme 9 shows the average time in milliseconds spent per collisioo detection. l·COLLIDE reported values between 9.5 to 11.S mil· liseconcm pa- collision whereas Gl·COLLIDE reported times between 0.29 to 094 milliseconds.
Apéndice B
5.2 BS-trees vs GI-COLLIDE
Toe second test does not use any space subdivision and the brute force one-to-one test is applied to each pair of objects. We compare the GI-COLLIDE against dynanúcally allocated (bounding spheres hierarchy) BS-trees. The BS-trees carry exactly the same infonnation and the same hierarchy and structure of bounding spheres as GI-COLLIDE. Both hierarchies are the same, the objects and the tests as well, the dynamically allocated tree is perfectly balanced, and is constructed from the hierarchy stored in the geometry image. Both trees are traversed in the same order and both routines are implemented in the same way. Our intention is to compare the differences in performance between these two teclmiques. Toe speed difference comes from the pointer-based scheme used in the dynamically allocated BS-trees and the indexing scheme used by GI-COLLIDE.
04~--~--~--~---~--~
0.38
036
o 3.4 r lit .
! ·:: 1 o ' ~ O 28 ~ ~ 0.26
50
--+--
+ DYNAMIC TREE ...,. GI-COLLIDE
. "!'i-
100 150 200 250 Number of Ob¡ecs
Figure 1 O: Average time needed for collision detection by BS-tree and GI-COLLIDE
Results of this test are shown in Figure 1 O. The average number of milliseconds spent on collision detection for different nwnbers of Stanford Bunnies is displayed. The numbers of milliseconds per collision are almost constant for both cases. On the other hand, for majority of the tests, GI-COLLIDE required less time to detect a collision, providing speedup up to a 19%. It shows that the indexing the geometry image is much more effi.cient than storing the spheres dynamically allocated in the memory. Apparently, the memory requirements for the geometry images are much smaller, because no pointers are required and the position of each sphere is calculated implicitly.
The d.ynamically allocated algorithm of the BS-trees based collision detection test was strongly improved In reality it is really diffi.cult to obtain perfectly balanced trees (something natural to GICOLLIDE). Sorne time is also needed to construct and to balance a tree. A geometry image has all these properties inherited from the sampling scheme.
5.3 Rapid vs Gl-COLLIDE
Another test we have performed was comparison of the RAPID [Gottschalk et al. 1996] and GI-COLLIDE. The collision detection was again perforrned with one-to-one comparison, and the time spent on collision detection and nwnbers of collisions were reported The RAPID test can be terrninated either when the :first
76
collision is detected or can be run to detect all collisions. We have used the first contact detection for both algorithms in our test.
0.45
04 ·
·! 0351
8 0.3
~ ' 1'l 0.25 I
j 02'
i 015: 1" 1_!.'
01 .f 0.05
-;¡...-------+- ----·------:..:-
- RAPID ,e. GI-COLU DE
O'----~--~--~---'-----'--' o 50 100 150
Number of Objecs 200 250
Figure 11: Average time needed for collision detection by RAPID and GI-COLLIDE
The results in Figure 11 show that RAPID provides faster collision detection than GI-mLLIDE. RAPID is a hierarchical representation using OBB-trees that provides better fit and include less empty space than BSs. That is why the OBBs report less number offalse detections. We believe this to be the main reason why RAPID detects collisions faster. Comparing the graphics there is not a significant difference in the times reported In average, RAPID is 0.148 milliseconds faster than GI-ffiLLIDE for detecting a single collision. To create the OBB-tree a significantly large amount of preprocessing time is required than for GI-COLLIDE.
5.4 A Real Application
To give an example of a real application we have implemented a test of collisions between a model of a moving helicopter and a fractal terrain. The helicopter moves in a realistic way, pitching up and down and rolling left and right, getting close and far from the terrain surface.
Each test was performed on models in different resolutions. We used geometry images in resolution 513 x 513, 1025 x 1025, 2049 x 2049, 4097 x 4097, and (where possible) 8193 x 8193 providing objects with 256/c, IM, 4M, 16M, and 64M vertices. Ali possible resolutions were tested against each resolution that gives maximum of90. I o" possible sphere-to-sphere and 68.109 polygonto-polygon tests.
Each test was performed twelve times, both extremities were discarded, and the average values were used
Toe geometry images are uncompressed in the main memory. When stored on the disk, they are saved in the TIFF fonnat with 16-bits per channel. The largest geometry image occupies 5 l 2MB ofthe disk space.
Figure 12 shows the result ofthe collision detection and the results are in tune with the expectations. The number of collision tests corresponds to a logarithmical function of the number of vertices of the object. It is important to notice that two objects in the resolution 4097 x 4097 pixels occupy more than 368MB ofmemory (184 MB for the geometry and the nonnal vectors, and l 84MB for
Apéndice B
50
i --------- j
i i
16 ¡ i i .
..... ~ ................ ! ................. ,.. ---·f·- ······f·········-····--·) : . ' j__---+--....;-----1 ~.
. : ! : 8
i1024
1024 1538 2048 2560 3072 3584 4096
Figure 12: Nurnber of collision tests as the function of object resolution. Two equal objects in varying resolution are colliding and the collision detection times are reported The lines show the tests performed with geometry images in resolution 5132, l 0252, 204~, and 409'72
the bounding spheres). Toe time for collision detection test was, for the worst case of 68.106 polygons, under 60:ms. Non-extreme cases, for objects in resolution 1025 x l 025, were around four milliseconds. The GI-COLLIDE works really efficiently especially for huge amount of data.
5.5 Time Critica! Collision Detection
Toe next example, in Figure 13, shows results of a time-critica! test. We have tested an object in resolution 204~ against 5132, l 0252 , ... , 81932 . The framerate was kept constan! on 60fps (leaving 15ms per collision test). The figme shows the actual timing of the performed tests. Toe number of actual collision follows the logarithmical function but up to the certain leve!. From this leve! the amount of tests remains constant.
16
'/ 14 ... . ·71--------------: ................. ; ............... +·-------· .... ; .................... ; .... , .... _ ..
1 / ! •
¡ i .
12 - ,--------··-·+ •· ·--· r
10
8 10 110 210 310 410 510 810 Mpolygona
Figure 13: Time requi.red for the collision test as the function of object resolution in the case of time critica! collision detection. Object in resolution 20492 was tested against objects in resolution 5132 ,
... , 81932 . Toe framerate was kept on 60 fps. The x-axis shows the number of millions of polygons tested, the y-axis the time in milliseconds required to find the first collision
77
6 Conclusions and Future Work
We have presented a new approach for efficient collision detection using geometry images named GI-COLLIDE. Toe algorithm is based on an efficient coding of the bounding volume hierarchy within the geometry image. From the original geometry image a BS-tree is calculated. The deepest leve! of the hierarchy stores in its pixels the RGB values ofthe centers ofthe bounding spheres of the quadrilaterals. The alpha value stores the sphere radius. This calculation is perfo1med for ali possible levels. Toe highest pixel from the hierarchy corresponds to the bounding sphere ofthe entire object representedin the geometry image. Traversing both BS-trees performs the collision test and checking the bounding spheres collisions.
Qw- approach inherits ali advantages of the geometry images. The manipulation is fast., we can store extremely precise and huge data representations, etc. Toe main advantage of GI-COLLIDE is the way the BS-tree is represented in the mip-map-like structure. This structure is always perfectly balanced, can be computed very fast, and is accessed just by indexing the 20 array. Campa.red to the previously published methods minimum of additional data structures is needed This allows us to represent objects up to 8l93x8193 vertices in our current implementation. The algorithm is fast and one ofits main advantages is that it is really easy to implernent so it positions itself to computer games, VR applications, and to all time-critica! applications where the memory requirements are limiting and the high speed is required. Since we store the geometry images on the disk as TIFF images we can use ali the advantages ofthis representation. We can compress the stored data using LZW algorithm that helps to reduce the space required for the storage.
Our results show that the algoritlun is faster or almost ofthe same speed as 1-COLLIDE, RAPID, dynamically allocated BS-trees. It works for real applications even for huge data and can be easily implemented in a time-critica! version.
We are li:mited to genus zero objects in our implementation. More topologically complicated objects require more geometry images [Sander et al. 2003). Another disadvantage is that geornetry images are designed to represent objects, so the test is suited to object-te>-object collision detection. A technical disadvantage is that our actual implementation is limited to 2n + 1, n = 1, 2, ... geometry images.
There is sorne future work left. A possible application is a collision detection together with a leve! of detail (LOO). VJhen the object is chsplayed we would select the corresponding LOO and detect the collisions up to the certain leve! by performing the collision detection on the selected geometry image and not on the original one. This could significantly reduce the computational time namely in complex scenes. An important property of the algorithm is that we do not need necessarily to test a geometry image against another geometry image. lt would be interesting to compare a test of a geometry image against k-DOPs [Klosowski et al. 1998), against sphere trees or OBB-trees [Gottschalk et al. 1996), orto apply sorne image space techniques [Baciu and Wong 2003; Govindaraju et al. 2003). Another possible future work is an implementation of the collision detection using graphics hardware.
References
BACIU, G., AND WONG, W. 2003. lmage-based techniques in a hybrid collision detector. IEEE Transactions on Visuolization and Computer Graphics 9, 2, 254-271.
Apéndice B
BRADSHAW, G., AND O'SULLIVAN, C. 2004. Adaptive medialaxis approximation for sphe.re-tree construction ACM Transaction on Graphics 23, l, 1-26.
COHEN, J. D., LIN, M. C., MANOCHA, D., AND PONAMGI, M. 1995. I-collide: an interactive and exact collision detection system for large-scale environments. In Proceedings of the 1995 symposium on Interactive 3D graphics, ACM Press, 189-ff.
EcK, M., DEROSE, T., ÜUCHAMP, T., HOPPE, H., LOUNSBERY, M., AND STUETZLE, W. 1995. Multiresolution analysis of arbitrary meshes. Computer Graphics 29, Annual Conference Series, 173-182.
GOTTSCHALK, S., LIN, M.C., AND MANOCHA, D. 1996. Obbtree: a hierarchical structure for rapid interference detection. In Proceedings of the 23rd annual conference on Computer graphics and interactive techniques, ACM Press, 171-180.
GOVINDARAJU, N. K., REOON, S., LIN, M. C., ANO MANOCHA, D. 2003. Cullide: interactive collision detection between complex models in large environments using graphics hardware. In Proceedings of the ACM SIGGRAPHIEUROGRAPHICS conference on Graphics hardware, Emographics Associati.on, 25-32.
Gu, X., GORTLER, S. J., ANO HOPPE, H. 2002. Geometry images. InProceedings of the 29th annual conference on Computer graphics and interactlve techniques, ACM Press, 355-361.
HE, T. 1999. Fast collision detection using quospo trees. In Proceedings of the 1999 symposium on lnteractive 3D graphics, ACM Press, 55-62.
HUBBARO, P. M. 1996. Approximating polyhecb:a wi1h spheres for time-critical collision detection ACM Trans. Graph. 15, 3, 179-210.
78
KLOSOWSKI, J. T., HELO, M., MITCHELL, J. S. B., SOWIZRAL, H., ANO ZIICAN, K. 1998. Efficient collision detection using bolDlding volume hierarchies of k-dops. IEEE Transactions on Visualization and Computer Graphics 4, l, 21-36.
LEE, A. W. F., SWELDENS, W., SCHRÓOER, P., COWSAR, L., ANO DoBKIN, D. 1998. MAPS: Multiresolution adaptive parameterization of surfaces. Computer Graphics 32, Annua1 Conference Series, 95-104.
LIN, M.C., ANO CANNY, J. F. 1991. A fast algorithm for incremental distance calculation. In IEEE Jntemalional Conference an Robotics anti Automatian, l 008-1 O 14.
LOSASSO, F., HOPPE, H., SCHAEFER, S., ANO WARREN, J. 2003. Smooth geometry irnages. In Proceedings ofthe Eurographics!ACM SIGGRAPH symposium on Geometry processing, Eurographics Association, 138-145.
MIRTICH, B. 1998. V-clip: fast and robust polyhedral collision detection. ACM Transaction on Graphics 17, 3, 177-208.
MOLLER, T. A., ANO HAINES, E. 2002. Real-Time Rendering. A K Peters.
MoLLER, T. 1997. A fast triangle-triangle intersection test. J. Graph. Tools 2, 2, 25-30.
PONAMGI, M., MANOCHA, D., AND LIN, M. C. 1995. Incremental algorithms for collision detection between solid models. In Proceedings of the third ACM symposium on So/id modeling and applications, ACM Press, 293-304.
PRAUN, E., AND HoPPE, H. 2003. Spherical parametrization and remeshing. ACM Transaction on Graphics 22, 3, 340-349.
SANOER, P. V., Wooo, Z. J., GORTLER, S. J., SNYOER, J., ANO H OPPE, H. 2003. Multi-chart geometry images. In Proceedings of the Eurographics!ACM SIGGRAPH symposium on Geometry processing, Eurographics Association, 146-155.
Apéndice C Presentación realizada en el congreso SCCG 05
GI-COLLIDE Collision Detection with Geometry lmages
Bel2'h:h Benes
Bedfich Benes Nestor Goméz Villanueva
ITESM Campus Ciudad de México
[email protected] http://paginas.ccm.itesm.mx1-beda/
lntroduction
./ Collision detection (CD) is an essential technique in many applications
./ CD algorithms have a loooooooong tradition in CG
./ The standard CD algs work in the object space
./ Based on the bounding volume hierarchies
Beaid"I Benes
Collision Detection vs Proximity auerrjes
./ CD provides simple results (no hit/one/more hit)
./ 088-trees, k-DOPs (discrete oriented polytopes),
QuOSPOs a combination of OBBs and k-DOPs, [Baciu03] hybrid CPU and GPU algorithm etc. (please consult the paper)
./ Proximity queries provide: exact results or approximate or Boolean
./ (the list of them can be found in the paper)
Beaich Benes
79
Overview
./ Overview
./ 1 ntroduction
./ Collision detection
./ Proximity Queries
./ Geometry lmages
./ GI-COLLIDE
./ Results
./ Conclusions
Beatch Benes
Collision Detection
./ BV-hierarchies
./ can be traversed efficiently
./ different BVs have different fit
./ different # of ops required
éí)'ª~~j ./ How to build it?
Geometry lmages
./ lntroduced in [Gu02]
./ Regular sampling of an object
./ Stored in a 20 array (an image)
./ a RGB triplet - [x,y,z] coordinates of a sample
./ normal vectors - another image
./ remeshing techniques exist
./ originally limited to genus zero objects
./ later extended
BecYict, Benes
Apéndice C
Geometry lmages
.r Can be loaded into a GPU
.r Can be stored as a standard image (PNG, TIFF)
GI-Collide
.r The principal idea
.rconstruct the standard sphere tree Using geometry images
.r build a mip-map - like hierarchical structure
.r each level stores different bounding spheres
.r construct the quatemary tree
.r use it for the standard collision detections
Bectlch Benes
Input geomatry imaga
GI-Collide
uad center
lavalO
11
Geometry lmages
.r another examples "potatoes" (also used in our tests)
Becrlch Benes
GI-Collide
.r Coding the hierarchy using Gis
Do until the size of the G/ is one pixel{
1. Shrink the G/ into ha/ves
2. RGB - [x,y,z] the center of the bounding sphere
3. alpha - the sphere radius
4. each sphere has four sub spheres }
GI-Collide
80
level 1 level2
Bed"lch Benes
10
12
Apéndice C
GI-Collide
iil Example
~ higherthel~ bigger the sphere, brighter the color
GI-Collide
Sizes
~ geometry of a GI is limited to s=(2"+1)2
~ halving the image n times
~ 1.5s for the sphere centers
~ 0.5s for the radii (scalar, i.e., 1/3 of the centers)
~ total = 2s for the entire BSs
~ the entire object has 4s i.e.,
~Total: s (GI) + 2s (BSs) + s (normal vectors) = 4s
Bemch BE11es
,J
~ léim GI-Collide ~ ,.,,,, ... , .. l
Algorithm {contd.}
0 0 ~ @ ~ ®
Bedrich Baies
13
15
17
~ Resulting BS-tree
Beliich Benes
Algorithm
GI-Collide
GI-Collide
~ Classical BV-tree traversation
~ The first-fail is the most common case
~ if there is a hit zigzagging down the hierarchies
~ First each-again each in a level is tested
~ then one upper level against a lower one
81
~ at the deepest level - the triangle-triangle test
Betiich Benes
,¡
tenn ~('G'
GI-Collide ""'~ Ir Moalur,z
Com1;1lexities
~ having two hierarchies, with n1 and n2 vertices
~ checking
~ one collision requires O(/og{max(n1,n~})
~ all collisions require O(n1,n~
Beaich Benes
14
16
18
Apéndice C
GI-Collide
Sphere refinement
Beald"I Bales
Results
Tests
./ Each test performed 12x
./ The best and the worst results were discarded
./ 3GHz, PC 2GB memory, GeForce 4
./ The tests:
./ comparing with existing methods
./ real application
./ time critica!
Beaid'l Benes
GI-Collide vs BS-Tree
./ Average time needed to find a collision
·~ 0.22
u,~·~~~~~,w~~,~~~~~~~~ Nwr,NfofOlljld
19
21
23
82
Results
GI-Collide strenqths
./ The tree is a/ways perfectly balanced (wow!)
./ Tree traversation = indexing of 20 arrays
./ The entire tree requires 2x size of the geometry
./ How does it perform?
Bealch Benes
GI-Collide vs BS-Tree
./ two perfectly balanced trees (advantage for our opponent!)
./ 88-tree created from the GI
./ the same hierarchies, the same objects
./ up to 256 bunnies flying in the space
./ no space subdivision used
./ what do we measure?
./ just access into the memory
Bealch 88'les
GI-Collide vs BS-Tree
./ Results
./ average time required to find a collision
./ GI-Collide is approximately 19% faster
,/ why?
Seems that indexing is faster than accessing the dynamically allocated memory
Bealch Bene9
20
22
2,
Apéndice e
GI-Collide vs 1-Collide
./ taking the source code of 1-Collide
./ replacing the Un-Caney closest feature by GI-Collide
./ only the collision detection was changed
./ 1-Collide uses a space subdivision - left as it is
./ to compare the same data GI with 8444 triangles (Gl-collide) was converted to mesh with 8450 triangles
Be<lich Benes
A ,~ Sim GI-Collide vs 1-Collide ~$ '•"••t•rrtJ
./ Average time needed to find a collision
12
.. 1 • u
l.
J • 1~~[i1
----------•• .. 100 ... "" ...
N.,......ofdifld
Beaidl Benes
Sim e.~~ GI-Collide vs RAPI D • ..,, <ti,
, ........ ,,,, '" ./ one-to-one comparison
./ RAPID uses a space subdivision and 088-trees
./ 088-trees have much better fit than spheres
./ first contact option was used
./ the same number of triangles
25
27
29
83
GI-Collide vs 1-Collide
./ Time spent for collision detection
r•"'
•, "'
Beaich Benes
Sm :'<-e GI-Collide vs 1-Collide 8<-..,_,G;_ll,.,
,.,, .. ,.,,,, ' ./ Results
./ GI-Collide performs better
./ GI-Collide performs much better for huge data
./ average times 1-Collide - 9.5-11.5 [ms] GI-Collide - 0.29-0.94 [ms]
Bectich Benes
A
Sim GI-Collide vs RAPID ,,,11,.,,,,.,.,
./ Average time needed to find a collision
Bedrich Benes
....
. : ~ t ¡ \---0-! .. ~ l,.,,
l.: ...
'• ..
~
e"<Vos
26
28
30
Apéndice C
~
teim ,, ,,,,.,.,,., GI-Collide vs RAPID
~ Results
~ RAPID was approx 40% faster
~ both algorithms 0.2-0.4 [ms]
~ RAPID needs more preprocessing time
~ RAPID requires more additional data
31
""?li!<
Zeim GI e 11·d · .. 1 1· t· .. ,, ...... .,., - o r e rn a rea app rea ron
~ Moving helicopter
33
"·s
SimG1 e 11·d · .. 1 1· t· .. , .......... , - o r e rn a rea app rea ron
~ Time Critica! version
~ and object in 2049x2049 against all 513, ... ,8193
~ framerate kept on 60fps
Bectidl Benes 35
84
~-"511
l§hr, GI C ll"d . " 1 1· t. " ,, ...... .,., - o r e rn a rea app rea ron
~ Moving helicopter
~ Fractal terrain patch (regular height field)
~ TIFFs, 16bits per channel the largest had 512MB
~ Varying resolution 513x513, 1025x1025, ... , 8193x8193
~ i.e., 256k, 1M, ... , 64M vertices
~ in total 90x109 sphere-to-sphere
~ and 68x 109 polygon-to-polygon tests
Bem'lch Benes
A
SimGIC ll"d. " 1 1· t· " ,, "'"""' - o r e rn a rea app rea ron
~ times reported to find a collision 50
41 L...----' --------
,,,/ e--
r 33
25
/,.-
16
~ ---024
'1? o s12 1024 1536 2048 2560 30n 3564 4095
Seli'ich Benes
,¡
tem,GIC ll"d. " 1 1· t· " ,, ""'""' - o r e rn a rea app rea ron
e, ¡ j j
········· ~.· approx t···· ~ ' ! ! i
12
10 ...... ¡ ..... i
10 110 210 s10 410 510 810 Mpolygono
32
36
Apéndice C
Conclusions
., Geometry lmages can be easily used for collision detection
., perfectly balanced tree is always generated
., GI-Collide is really efficient
., GI-Collide works very well for huge data
-' only 50% of additional space is needed
-' they are faster than BS-trees
-' and than many classical approaches
Bea'lch BEfles 37
85
Conclusions
-' Future work (acronym for disadvantages) (acronym for we-did-not-implement-yet)
-' should be easily done on a GPU
., limited to 2"+1 resolutions
., genus zero objects
., different objects more geometry images needed
., combination with space subdivision techniques
., frame-to-frame coherence
Bed"lch B«tes 3B