Detecção de Colisões para Corpos Rígidos em Tempo Real
utilizando Hierarquias de Volumes Envoltórios
Denison L. M. Tavares e Robson R. Lemos
Departamento de Informática – Universidade de Caxias do Sul (UCS) Caixa Postal 1352 – 95.020-972 – Caxias do Sul – RS – Brasil
{dlmtavar,rrlemos}@ucs.br
Abstract. Many applications in Computer Graphics require fast and robust collision detection algorithms. This work presents a performance analysis of collision detection algorithms using bounding volume hierarchies. The algorithms are analyzed in a physically-based virtual world in which the behavior of rigid bodies occur according to the law of newtonian mechanics. The results show that, considering a set of specific parameters, virtual worlds containing a significant number of rigid bodies, with arbitrary geometry and levels of detail, can be developed for physically-based applications with interaction in real time.
Resumo. Diversas aplicações em Computação Gráfica necessitam de algoritmos de detecção de colisões rápidos e robustos. Este trabalho apresenta uma análise de desempenho de algoritmos de detecção de colisões utilizando hierarquias de volumes envoltórios. Os algoritmos são analisados em um ambiente virtual baseado em física onde o comportamento de corpos rígidos ocorre de acordo com as leis da mecânica newtoniana. Os resultados mostram que, dentro de um conjunto específico de parâmetros, ambientes virtuais compostos por um número significativo de corpos rígidos, com diferentes geometrias e níveis de detalhamento, podem ser desenvolvidos para aplicações baseadas em física com interação em tempo real.
1. Introdução
Em um ambiente virtual composto de corpos rígidos em movimento ocorrerá a interferência da geometria de um dos objetos com as dos outros. Ambientes virtuais de corpos rígidos procuram simular o comportamento dos mesmos de acordo com as leis da física. Assim sendo um corpo rígido não pode simplesmente atravessar a geometria de um outro objeto. Quando a geometria de um objeto interfere na geometria de outro objeto isto ocorre na forma de uma Colisão. A determinação de quando e onde as interações entre as geometrias ocorrem é chamado de detecção de colisões e o efeito causado pela interação é chamado de resposta a colisão [Eberly 2001].
O requerimento computacional na grande maioria dos sistemas que necessitam detecção de colisões e resposta é a solução deste problema em taxas de quadros por segundo para interação em tempo real. A detecção de colisões conhecida como força bruta é realizada fazendo-se testes de sobreposição entre pares de polígonos de objetos. Entretanto, quando um ambiente é composto de cenas complexas (cenas com muitos objetos) ou composto de objetos complexos (objetos com muitos polígonos) esse método se degenera rapidamente, pois possui uma complexidade de ordem O(n2). Neste trabalho são investigados algoritmos que utilizam estruturas hierárquicas para o tratamento de colisões de objetos. No modelo computacional
Este trabalho tem como objetivo apresentar uma análise de desempenho de algoritmos de detecção de colisões para corpos rígidos utilizando hierarquia de volumes envoltórios em um ambiente virtual baseado em física. Os algoritmos de árvore esferas, de caixas alinhadas no eixo e de caixas orientadas são investigados. Estes algoritmos são analisados em um ambiente virtual considerando o movimento de corpos rígidos de acordo com as leis da mecânica newtoniana. O desempenho destes algoritmos é comparado em função do número de operações aritméticas de sobreposição de volumes envoltórios e polígonos para diferentes quantidades de objetos colidentes em uma cena. Na próxima seção, os trabalhos relevantes da literatura e algumas considerações em detecção de colisões são apresentados. Na seção 3, a arquitetura geral do ambiente virtual é apresentada em conjunto com os algoritmos de detecção de colisões. Na seção 4, testes e análises de desempenho são apresentados para os algoritmos de detecção de colisões. Finalmente, na seção 5 são apresentadas as conclusões e trabalhos futuros.
2. Trabalhos Relacionados e Considerações em Detecção de Colisões
Exemplos de estruturas hierárquicas para o particionamento do espaço ocupado pela cena são Octrees, BSP-trees, brep-indices e grades regulares [Sammet & Webber 1988]. Algoritmos para decompor o espaço ocupado pelo objeto e identificar de uma forma eficiente as áreas de contato entre objetos durante uma colisão utilizando hierarquias de volumes envoltórios têm sido propostos na literatura [Jiménez et al. 2001].
Em [Gottschalk 1990] é apresentado um teorema que determina um conjunto de condições para que dois poliedros convexos não estejam se interceptando. Este teorema é conhecido como Teorema do Eixo de Separação (Separating Axis Theorem – SAT). Em [Gottschalk et al. 1996] o SAT é utilizado para realizar o teste de interseção entre malhas poligonais de objetos. Uma árvore de caixas orientadas (oriented bounding boxes trees – OBBs trees) é utilizada para aproximar o modelo por meio de uma hierarquia de volumes envoltórios a qual contém os vértices que compõem o modelo. A estrutura de dados resultante é uma árvore binária, onde os nós internos são subárvores e cada nó folha corresponde a um polígono do modelo. Neste algoritmo a sobreposição entre as OBBs é determinada pela execução de testes nos 15 eixos potenciais de separação entre as OBBs como demostrado no SAT. O algoritmo realiza de uma forma rápida os testes de sobreposição necessitando aproximadamente de 200 operações aritméticas. Em [Van Der Bergen 1997] é utilizado o algoritmo de árvores de caixas alinhadas ao eixo (axis-aligned bounding boxes trees – AABBs trees). A hierarquia AABBs trees não tem orientação arbitrária como no caso das OBBs trees. Logo, o custo computacional da construção deste tipo de árvore é inferior comparado a OBBs trees. Hierarquias do tipo AABBs trees ajustam-se de uma forma mais fácil a modelos deformáveis os quais requerem que a árvore seja reconstruída freqüentemente. A mais simples de todas primitivas de volumes envoltórios é a esfera. A construção de uma hierarquia de volumes envoltória de esfera necessita apenas uma transformação simples dos centros dos pontos de cada esfera. [O’Sullivan & Dingliana 2001] utilizam a organização de uma grade regular de esfera na hierarquia para construir a árvore de esferas. O algoritmo para os testes de sobreposição de esferas necessita aproximadamente de 10 operações aritméticas. Hierarquias de volumes envoltórios fazendo uso de sólidos em dimensões arbitrárias (discrete oriented polytopes - DOP) também têm sido propostas na literatura [Klosowski et al. 1998]. No caso de detecção de colisões para simulação de corpos rígidos, os algoritmos de hierarquia de volumes envoltórios mencionados acima assumem uma fase de pré-processamento correspondente a construção da árvore. Neste trabalho, os teste de comparação entre alguns destes algoritmos clássicos são realizados na fase de utilização da árvore para otimizar a detecção de colisões.
3. Detecção de Colisões em um Ambiente Virtual Baseado em Física
O ambiente virtual desenvolvido para os testes dos algoritmos de detecção de colisões corresponde a um sistema de simulação física de corpos rígidos. No desenvolvimento deste ambiente foi construída uma biblioteca de classes em C++ em conjunto com a biblioteca gráfica OpenGL.
No ambiente virtual baseado em física, a simulação é realizada a partir da descrição do estado inicial do sistema dinâmico (forças e torques) [Moore and Wilhems 1988]. O estado dinâmico em um tempo t posterior é obtido a partir do estado dinâmico inicial (onde h corresponde ao incremento de tempo discreto entre os quadros de animação). Assim, cada estado subseqüente (t = t + h) é obtido a partir do estado anterior. Durante a resolução das equações de movimento, utilizando-se o método de Runge-Kutta de quarta ordem [Press et al. 1988], as posições e orientações dos objetos são atualizadas para o passo de tempo discreto corrente. A partir disto é atualizada a velocidade dos objetos (angular e linear) de acordo com sua aceleração. É verificado, então, se existe sobreposição da geometria entre pares de objetos (detecção de colisões) para esta nova posição e orientação. Se houver colisões, os pontos e o vetor normal de contato entre pares de objetos são identificados e as mudanças nas velocidades dos objetos resultantes da colisão são determinadas (resposta a colisão através da dinâmica de contato instantâneo baseado em impulso). E, por fim, o quadro é atualizado (renderização da cena). 3.1. Hierarquia de Volumes Envoltórios
Neste trabalho, o algoritmo para construção da hierarquia de volumes envoltórios utiliza volumes arbitrários (i.e., esferas, caixas alinhadas no eixo e caixas orientadas). A principal etapa deste algoritmo corresponde a regra de subdivisão do espaço ocupado pelo objeto de uma forma recursiva [Gottschalk et al. 1996]. Este método consiste em dividir o maior eixo do volume envoltório com seu plano ortogonal correspondente. Este processo ocorre recursivamente sendo os polígonos do objeto particionados de acordo com o lado do plano que contém o ponto médio do polígono. A classe ArvoreDeVolumesEnvoltorios e a classe Nodo implementam este método para volumes arbitrários. A classe ArvoreDeVolumesEnvoltorios contém o objeto Raiz do tipo Nodo o qual representa uma árvore binária com os atributos necessários para construção da hierarquia de volumes envoltórios. A construtora da classe Nodo cria o volume envoltório para os triângulos e os particiona de acordo com a regra de subdivisão. O algoritmo CriaVolume contrói o volume específico utilizado na hierarquia (i.e., CriaEsfera, CriaCaixaAlinhadaNoEixo e CriaCaixaOrientada).
3.1.1. Construindo uma Árvore de Esferas
Para construção de uma árvore de esferas é necessário utilizar o algoritmo CriaEsfera para gerar o volume específico na hierarquia de volumes envoltórios. O volume da esfera é definido por seu centro e raio. A esfera é construída a partir do cálculo do ponto médio (centro) o qual é utilizado para calcular o raio (maior distância do centro aos vértices) (Figura 1A).
3.1.2. Construindo uma Árvore de Caixas Alinhadas no Eixo
Para construção de uma árvore de caixas alinhadas no eixo é necessário utililizar o algoritmo CriaCaixaAlinhadaNoEixo para gerar o volume específico na hierarquia de volumes envoltórios. O volume da caixa é definido pelo seu centro, eixos (orientação no espaço tridimensional) e extensão (comprimento de cada um dos eixos). A caixa alinhada no eixo é construída a partir do cálculo do ponto mínimo e do ponto máximo (cálculo do valor mínimo e
Classe ArvoreDeVolumesEnvoltorios Nodo Raiz ArvoreDeVolumesEnvoltorios(triangulos) Raiz=new Nodo(triangulos,1) Classe Nodo Nodo Esquerda Nodo Direita VolumeEnvoltorios Volume Triangulo TriangulosDaFolha Nodo(triangulos,triangulosporfolha)
//Cria volume (esfera, caixa alinhada no eixo ou caixa orientada) Volume=CriaVolume(triangulos) Se triangulos.Tamanho <= triangulosporfolha TriangulosDaFolha=triangulos Esquerda=NULL Direita=NULL Senão
//Calcula plano ortogonal ao maior eixo do volume envoltório Plano p=CalculaPlanoOrtonormal(Volume)
//Ordena em ordem crescente os triângulos baseado na distância //do plano ao ponto médio dos triângulos
Ordena(triangulos)
Mediana=(triangulos.Tamanho-1)/2 //Cria nodos recursivamente
Esquerda=new Nodo(triangulos[0,mediana],triangulosporfolha)
Direita=new Nodo(triangulos[mediana+1,triangulos.Tamanho],triangulosporfolha)
Esfera CriaEsfera(triangulos) Esfera e
e.Centro=CalculaPontoMedio(triangulos) //Encontra a distância máxima dos
//vértices dos triângulos ao centro da esfera e.Raio=CalculaDistanciaMaxima(triangulos) return e Caixa CriaCaixaAlinhadaNoEixo(triangulos) Caixa c c.Eixo[0]=(1,0,0) c.Eixo[1]=(0,1,0) c.Eixo[2]=(0,0,1) Min,Max=CalculaPontoMinimoEMaximo(triangulos) c.Centro=(Min+Max)/2; c.Extensao[0]=(Max.X-Min.X)/2; c.Extensao[1]=(Max.Y-Min.Y)/2; c.Extensao[2]=(Max.Z-Min.Z)/2; return c Caixa CriaCaixaOrientada(triangulos) Caixa c c.Centro=CalculaPontoMedio(triangulos)
//Os eixos correspondem aos autovetores da matriz de covariância utilizando //distribuição gaussiana
c.Eixo=CalculaEixo(triangulos)
//Encontra produto escalar mínimo e máximo dos vértices dos //triângulos em relação ao centro e ao eixo da caixa informada
Min0,Max0=CalculaProdutoEscalarMinimoEMaximo(triangulos,c.Centro,c.Eixo[0]) Min1,Max1=CalculaProdutoEscalarMinimoEMaximo(triangulos,c.Centro,c.Eixo[1]) Min2,Max2=CalculaProdutoEscalarMinimoEMaximo(triangulos,c.Centro,c.Eixo[2]) c.Centro+=((Min0+Max0)/2)+c.Eixo[0] + ((Min1+Max1)/2)+c.Eixo[1] + ((Min2+Max2)/2)+c.Eixo[2] c.Extensao[0]=(Max0-Min0)/2 c.Extensao[1]=(Max1-Min1)/2 c.Extensao[2]=(Max2-Min2)/2 return c
3.1.3. Construindo uma Árvore de Caixas Orientadas
Para construção de uma árvore de caixas orientadas é necessário utililizar o algoritmo CriaCaixaOrientada para gerar o volume específico na hierarquia de volumes envoltórios. O centro da caixa orientada tem como base de cálculo o ponto médio dos vértices dos triângulos. Os eixos da caixa orientada são calculados a partir dos autovetores da matriz de covariância utilizando uma distribuição gaussiana [Van Der Bergen 1997]. A partir disto é calculado o produto escalar mínimo e máximo dos vértices dos triângulos em relação ao centro e aos eixos da caixa, os quais servem para atualizar o centro e a extensão da caixa (Figura 1C).
Bool TesteDeColisao(arvore0, arvore1)
return TesteDeSobreposicaoDeArvores(arvore0.Raiz, arvore1.Raiz) //Teste de sobreposição das árvores de volumes envoltórios Bool TesteDeSobreposicaoDeArvores(nodo0,nodo1)
//Testa sobreposição de volumes envoltórios
//(esfera, caixa alinhada no eixo ou caixa orientada) Se TesteDeSobreposicaoDeVolume(nodo0.Volume,nodo1.Volume) Se ÉNodoInterior(nodo0)
//Compara subárvore nodo0.Esquerda com toda a subárvore nodo1 Se TesteDeSobreposicaoDeArvores(nodo0.Esquerda,nodo1)
return Verdadeiro
//Compara subárvore nodo0.Direita com toda a subárvore nodo1 Se TesteDeSobreposicaoDeArvores(nodo0.Direita,nodo1) return Verdadeiro
Senão
Se ÉNodoInterior(nodo1)
//Compara subárvore nodo0 com toda a subárvore nodo1.Esquerda Se TesteDeSobreposicaoDeArvores(nodo0,nodo1.Esquerda) return Verdadeiro
//Compara subárvore nodo0 com toda a subárvore nodo1.Direita Se TesteDeSobreposicaoDeArvores(nodo0,nodo1.Direita) return Verdadeiro
Senão
Se TesteDeSobreposicaoDeTriangulos(nodo0.TriangulosDaFolha,nodo1.TriangulosDaFolha) //Achou colisão entre triângulos
//Calcula ponto e vetor normal de contato return Verdadeiro
return Falso
3.2. Detecção de Colisões utilizando Hierarquia de Volumes Envoltórios
O algoritmo TesteDeColisao realiza testes de sobreposição entre pares de objetos utilizando suas respectivas hierarquias de volumes envoltórios. O volume de uma hierarquia é comparado com o volume da outra hierarquia através de chamadas recursivas. Se pares de volumes se sobrepõem, então os filhos da primeira árvore são comparados com toda a segunda árvore. Senão toda primeira árvore é comparada com os filhos da segunda árvore. Quando este processo de caminhamento recursivo atinge dois nodos folhas é testada a sobreposição de triângulos. A partir disso os pontos e o vetor normal de contato entre pares de objetos são calculados e encaminhados para resposta da colisão no ambiente virtual.
4. Testes e Resultados
Para os testes de detecção de colisões foram geradas cenas virtuais compostas de três tipos de objetos. Os objetos são torus, pedra e cubo os quais contem 1800, 760 e 14 triângulos, respectivamente. Nos testes utilizou-se cenas com diferentes números de objetos (e.g., 2, 4, 8, 16, 32 e 64). Estes objetos foram posicionados em círculo e seus estímulos iniciais (i.e., forças e torques) foram fornecidos para que sua trajetória de colisão ocorresse no centro do círculo. O período total de cada cena é de 600 quadros. Na construção das árvores de volumes adota-se a mesma regra de subdivisão recursiva do espaço do objeto para diferentes tipos de volumes (e.g., esferas, caixas alinhadas no eixo e caixas orientadas) desta forma a quantidade de nodos filhos e níveis da hierarquia de volumes de um objeto é igual para os três tipos de árvores. Por exemplo, a quantidade máxima de níveis gerada para hierarquia de volumes de envoltórios para os objetos torus, pedra e cubo é 11, 10 e 4 níveis, respectivamente. Para a análise de desempenho de processamento foram realizados testes de sobreposição de volumes (Figura 2A) e triângulos (Figura 2B) para diferentes quantidades de objetos.
Na implementação adotada para a hierarquia de volumes envoltórios a árvore não necessita ser reconstruída a cada passo. No momento de mudança de posição e orientação do objeto realiza-se na árvore associada uma translação e rotação equivalente. A equação de custo utilizada para a implementação em questão é uma adaptação de [Gottschalk et al. 1996] como a seguir: EC = V.CV + T.CT onde, V é o número de testes de sobreposições de volumes (Figura 2A), CV é o custo em termos de número de operações aritméticas de um teste de sobreposição de volume (200 operações para o volume caixa e 10 operações para o volume esfera [Gottschalk 1990]), T é o número de testes de sobreposições de triângulos (Figura 2B) e CT é o custo em termos de número de operações aritméticas de um teste de sobreposição de triângulos (assumiu-se um valor constante porque os três algoritmos de volumes envoltórios apresentam o mesmo custo). Na Figura 2C é apresentado o custo de processamento dos três algoritmos. Na Figura 2D observa-se a detecção de colisões e resposta no centro de uma cena virtual com 64 objetos.
Figura 2. Número de testes de sobreposições de volumes (A), de triângulos (B) e equação de custo (C) em função do número de objetos. Cena virtual (D).
5. Conclusões
Neste trabalho desenvolveu-se uma plataforma de testes para análise de desempenho de algoritmos de detecção de colisões. Algoritmos existentes na literatura foram testados em um ambiente virtual baseado em física composto por corpos rígidos com diferentes níveis de detalhamento. A geração do movimento através de equações dinâmicas baseadas em leis físicas fornece um alto grau de realismo. A detecção de colisões e resposta permite a inclusão de mais um nível de realismo o qual é necessário em ambientes virtuais de corpos rígidos em tempo real. Concluímos que, no ambiente onde os testes foram realizados (AMD Athlon64X2 4600), os três algoritmos implementados apresentaram taxas de quadros por segundo aceitáveis para aplicações em tempo real até um número aproximado de 32 objetos para a cena virtual. Em relação a análise de custo de processamento realizada para testes de colisões, o algoritmo de árvore de esferas apresentou um desempenho melhor comparado aos algoritmos de árvore de caixas alinhadas no eixo e caixas orientadas. Em relação a aproximação do espaço ocupado pelo objeto, observou-se que o algoritmo árvore de caixas orientadas apresenta uma melhor aproximação comparado com os outros dois algoritmos. Uma possibilidade de extensão deste trabalho seria a implementação de regras de subdivisão adaptativas para construção de uma árvore de volumes mais balanceada. Também, estes algoritmos podem ser utilizados em aplicações de computação gráfica que requerem aproximações simplificadas da geometria de objetos de uma cena virtual. Atualmente, técnicas de implementação de física computacional para processamento em GPU (Graphics Processor Units) estão sendo investigadas.
6. Agradecimentos
Este trabalho recebeu apoio da FAPERGS através do Programa ARD.
7. Referências
Eberly, D. H. (2001) 3D Game Engine Design, San Francisco, Academic Press.
Gottschalk, S. (1990) “Separating Axis Theorem”, Technical Report, TR96-024, UNC.
Gottschalk, S., Lin, M. C., & Manocha, D. (1996) “OBBTree: A Hierarchical Structure for Rapid Interference Detection”, Proceedings of the 23th Annual Conference on Computer Graphics and Interactive Techniques, pp. 171-180.
Jiménez, P., Thomas, F., & Torras, C. (2001) “3D Collision Detection: A Survey”, Computer and Graphics, v. 25, pp. 269-285.
Klosowski, J.T., Held, M. Mitchell, J.S.B., Sowizral, H. & Zikan, K. (1998) “Efficient collision detection using bounding volume hierarchies of k-DOPs”. IEEE Transactions on Visualization and Computer Graphics, v. 4, n. 1, pp. 21-36.
Moore, M. & Wilhelms, J. (1988) “Collision detection and response for computer animation”, Computer Graphics, New York, v. 22, n. 4, pp.289-298.
O' Sullivan, C. & Dingliana, J. (2001) “Collisions and perception”. ACM Transactions on Graphics, v. 20, n. 3, pp. 151-168.
Press, W. H., Flannery, B. P , Teukolsky, S. A., & Veterling, W. T. (1988) Numerical recipes in C, New York, Cambridge University Press.
Sammet, H. & Webber, R. (1988) “Hierarchical data structures and algorithms for computer graphics”. IEEE Computer Graphics and Applications, v. 8, n. 3, pp. 48-68.
