Fast continuous collision detection among deformable models using graphics processors

Abstract

We present an interactive algorithm to perform continuous collision detection between general deformable models using graphics processors (GPUs). We model the motion of each object in the environment as a continuous path and check for collisions along the paths. Our algorithm precomputes the chromatic decomposition for each object and uses visibility queries on GPUs to quickly compute potentially colliding sets of primitives. We introduce a primitive classification technique to perform efficient continuous self-collision. We have implemented our algorithm on a 3.0 GHz Pentium IV PC with a NVIDIA 7800 GPU, and we highlight its performance on complex simulations composed of several thousands of triangles. In practice, our algorithm is able to detect all contacts, including self-collisions, at image-space precision in tens of milli-seconds.

Introduction

The problem of collision detection (CD) arises in modeling, simulation and interaction for many different areas, including virtual reality (VR), cloth simulation, haptic rendering, animation, rapid prototyping, CAD/CAM, robotics, and entertainment. In this paper, we primarily focus on CD over a given time period between deformable objects that includes inter-object collisions between disjoint objects and intra-object collisions (or self-collisions) within each deformable model. Most of the earlier work in CD has been restricted to CD at discrete time instances and these algorithms may not check for possible overlaps between successive time steps. As a result, it is possible to miss a collision and result in visual artifacts, inconsistent state, or incorrect simulation that can significantly affect the sense of immersion and lead to break in presence (BIP) in a virtual environment (VE). Such problems can be especially challenging in environments composed of thin or fast moving objects, like cloth on virtual avatars.

In order to overcome the limitations of discrete CD algorithms, different techniques have been proposed that model the motion between successive time instances as a continuous path and check for collisions along these paths. These are classified as continuous collision detection (CCD) algorithms [1], [2], [3], [4], [5]. However, current CCD algorithms are only able to handle rigid objects, articulated models, or simple deformable meshes (consisting of only a few hundreds of polygons) at interactive rates.

Main results: We present a novel algorithm to perform CCD between general deformable models at interactive rates using commodity graphics processing units (GPUs). Our approach is general and makes no assumption about object motion. Each object is represented as a triangulated mesh and we assume that the mesh connectivity does not change during the simulation. We model the continuous motion using a piecewise linear motion between successive discrete instances and check for collisions between the resulting swept volumes (SVs).

Our algorithm precomputes an improved chromatic decomposition [6] for each object and decomposes the problem into checking for overlap between adjacent and non-adjacent primitives. We extend the Quick-CULLIDE collision culling algorithm [7], which performs collisions at discrete time instances, to check for collisions between the SVs of non-adjacent primitives. In order to achieve high-culling efficiency, we classify the adjacent primitives into vertex-adjacent and edge-adjacent primitives. We pair the edge-adjacent primitives to reduce the number of penetrating contacts, as well as lowering the number of pairwise tests. Based on this decomposition, our algorithm directly checks for inter- and intra-object collisions and does not need to perform any special processing. The overall accuracy of our algorithm is governed by image-space resolution used to perform visibility queries (or 2.5D overlap tests) on the GPUs.

We have implemented the algorithm on a 3.0 GHz PC with a NVIDIA 7800 GPU and applied to complex cloth simulation benchmarks consisting of thousands of triangles. We are able to check for all collisions between the discrete time instances at 10–15 frames per second at $1000\times 1000$ image-space resolution, enabling real-time CCD for high-resolution deformable meshes with challenging contact scenarios in VEs. As compared to earlier work [6], [7], our approach offers the following advantages:

• High culling efficiency using tight bounding SV representations for the mesh primitives.

• Interactive performance using an improved mesh decomposition scheme and a novel primitive classification technique, resulting in fewer false positives.

Organization: The rest of the paper is organized as follows. In Section 2, we briefly review the prior work on CCD and GPU-based CD algorithms. We give an overview of our approach in Section 3 and describe our primitive classification scheme. We present our algorithm in Section 4 and describe its implementation and performance on complex benchmarks in Section 5. We analyze its performance in Section 6 and highlight some of its limitations.