GI Collide : detección de colisiones usando imágenes de ...

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


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.


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.


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.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


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.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


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


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


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.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


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


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


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


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


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


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


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


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


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.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


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


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


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


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.


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


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


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





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


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


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


./ 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


./ 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


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,.,,,,.,.,


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

GI Collide : detección de colisiones usando imágenes de ...

Documents

Transcript of GI Collide : detección de colisiones usando imágenes de ...