An Evaluation of a Collision Handling System using Sphere-Trees for Plausible Rigid Body Animation Rafael de Sousa Rocha

Maria Andréia Formico Rodrigues

Mestrado em Informática Aplicada Universidade de Fortaleza Av. Washington Soares, 1321 60811-905 Fortaleza–CE, Brazil

Mestrado em Informática Aplicada Universidade de Fortaleza Av. Washington Soares, 1321 60811-905 Fortaleza–CE, Brazil

[email protected]

[email protected]

ABSTRACT Collision handling plays a fundamental role for achieving realism and interactivity in 3D graphical systems. Nevertheless, it is still one of the bottlenecks of such systems. In this work, we use the Sweep & Prune algorithm and Sphere-Tree approximations of the objects to perform the collision detection. Besides, we show how to compute the contact data for the narrow phase out of the overlapping leaf spheres from the Sphere-Trees. For collision response, we have implemented a simple, yet efficient and accurate, impulse-based method. A number of experiments in virtual scenarios with objects falling in a static plane were conducted. The results show that when Sphere-Trees with 2 levels are used for scenarios with a great number of objects (up to 200 falling objects) and simultaneous contacts among them (up to 16381.50 contacts at each frame on average), our system is capable of generating real time plausible rigid body animation, with always more than 30 frames per second (FPS) on average.

Categories and Subject Descriptors I.3.5 [Computer Graphics]: Computational Geometry and Object Modeling—Physically based modeling; I.3.7 [Computer Graphics]: Three-Dimensional Graphics and Realism—Animation; I.3.7 [Virtual Reality]: Three-Dimensional Graphics

Keywords performance analysis, collision detection, sphere-tree, physically-based animation

1.

INTRODUCTION

Interactive environments have become an interesting research field with the enhancement of graphics hardware and input/output devices. Due to these new computer technologies, a large range of applications especially concerning 3D

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SAC’08 March 16-20, 2008, Fortaleza, Cear´a, Brazil Copyright 2008 ACM 978-1-59593-753-7/08/0003 ...$5.00.

computer simulation and entertainment (even more realistic) have been developed. However, if much realism is required, the application’s interactivity may be compromised and vice-versa. In this regard, collision handling plays a fundamental role for achieving both features. It may leverage the realism, by simulating the physical motion of the objects [6], while guiding the interaction of the user with graphical objects through the environment. Collision handling can be divided into two main steps, namely, collision detection and collision response. Collision detection aims at gathering information concerning the collisions that take place in the environment (e.g., pairs of colliding objects, colliding points and normals, penetration depths, times of collisions). On the other hand, collision response makes use of previous computed contact data to update the status of the application accordingly. The task of the latter can vary from making one of the colliding objects disappear to updating the objects’ physical properties (linear and angular momenta), which is affected by impulses arising from collisions [8]. Even nowadays, collision handling is still one of the bottlenecks of interactive environments. For example, in scenarios with thousands of colliding objects the collision detection processing can deteriorate the performance of the application. A na¨ıve approach will test all O(n2 ) pairs of possible interacting objects. Hence, collision detection methods must ensure that a quadratic asymptotic behavior will not occur. To achieve this, most methods are carried out in two or three phases. For example, Zachmann proposes a general framework for collision detection where pairs of objects are successively filtered in a pipeline [19]. In general, pairs of objects that are too far away are firstly discarded in the broad phase of the collision detection. Then, bounding volume hierarchies [18], which encapsulate the objects in levels of detail, are used to narrow in on regions where the remaining pairs of objects are colliding. This is known as the narrow phase of the collision detection. Finally, an exact phase can be carried out to perform exact tests among the objects’ polygons, which are stored in the hierarchies’ leaves. The second and third phases are sometimes referred to as one (narrow phase). In previous work, we have developed a collision detection prototype system [17]: the Sweep & Prune algorithm was implemented for the broad phase of the collision detection [4], and inspired by the work of Bradshaw and O’Sullivan [3], we used their Sphere-Tree construction algorithms to build tight representations for the colliding objects. Based on this

1241

Sphere-Tree representation, we implemented then an algorithm for the narrow phase. We have successfully applied this hybrid collision detection algorithm in scenarios with up to 1000 moving objects (each one with approximately 1500 triangles) without physically-based animation to generate interactive frame rates (greater than 10 FPS). In this work, we have extended our previously implemented collision detection algorithm and used it for the generation and evaluation of plausible animation of rigid bodies. Sphere-Trees are utilized to handle collisions in a similar way of that presented by Dingliana and O’Sullivan [6]. For collision response, we have implemented a simple, yet efficient and accurate, impulse-based method. The impulse magnitudes are computed through the traditional equation for rigid body impulse [14]. The experiments were made in virtual scenarios with objects falling in a static plane. The times to process the collision detection, response, and the frame generation were collected at each frame, as well as the number of contacts. We also varied the number of objects and the Sphere-Tree depth in our experiments. The results show that when Sphere-Trees with 2 levels are used in scenarios with a great number of objects and simultaneous contacts among them (up to 16381.50 contacts at each frame on average), our system is capable of generating real time plausible rigid body animation. For example, when there are 4 stacks, each one with 50 falling objects (totalizing 200 objects), we achieve 33.29 FPS on average, and when there are 8 stacks, each one with 20 falling objects (totalizing 160 objects), we achieve 31.50 FPS on average. It is important to notice that the current work implements a more computational expensive response and, therefore, less objects (up to 200) were used when compared with our previous work (up to 1000). The remainder of this paper is organized as follows. Section 2 describes some related work. Section 3 details the collision detection algorithms we have implemented. Section 4 briefly explains the collision response method we have applied to simulate collisions among rigid bodies. In Section 5, we detail our experiments and show the obtained results. Finally, Section 6 summarizes the main conclusions and gives directions for future work.

2.

RELATED WORK

There are two main categories for collision detection methods: continuous and discrete [15]. The continuous collision detection methods approximate the motion of objects through interpolation, and are used to derive the first time of contact between a pair of colliding objects. The colliding points along with their normals are also derived. A comprehensive overview of the most commonly used continuous collision detection approaches can be found in [15, 16]. On the contrary, discrete methods sample the trajectory of the objects. This sampling is usually done at each time step of the animation. Discrete collision methods suffer from a problem known as collision tunneling [7]. That means collisions between samples can be missed if the objects move too fast or are too thin. Another problem is that collisions are normally discovered when a pair of objects has already interpenetrated. Two strategies can be used to overcome this problem. One of them is to recursively backtrack all objects of the animation to find out the very moment of touch between objects (the recursion proceeds until a given threshold). A more common approach is to compute the

penetration depth, a distance metric used to describe the extent of overlap between two intersecting objects [20]. Despite the fact that continuous methods are more accurate than discrete methods, the latter ones usually execute faster and are easier to implement. Regardless of the collision detection method, the majority of the algorithms starts the detection by pairing the objects that are near each other. This test is commonly carried out with the objects’ bounding volumes, such as boxes [9] and spheres [10]. Many algorithms have been developed to avoid testing all possible pairs of bounding volumes. A common approach to tackle this problem is the use of spatial partitioning data structures. Grids and octrees are some examples that have been extensively used [19]. Luque et al. report the successful use of semi-adjusting BSP-Trees [12]. A popular algorithm that does not use spatial partitioning data structures is the Sweep & Prune [4]. This algorithm relies on the projection of the objects’ axis aligned bounding boxes (AABBs) in the three coordinate axes to detect collisions very efficiently. Coming and Staadt report the successful implementation of a variation of the Sweep & Prune algorithm, namely Kinetic Sweep & Prune, which uses a kinetic data structure to continuously detect collisions among the AABBs [5]. After the broad phase, the computed object pairs are successively refined in the narrow phase. At this phase, bounding volume hierarchies (BVHs), such as OBB-Trees [9] and Sphere-Trees [3], are used to approximate the geometry of the objects. A time-critical approach may be applied to trade accuracy for speed, that is, the narrow phase is processed for some amount of time. Whenever this time expires, the detection is interrupted and contact data is derived based on the current levels of the BVHs being processed. Hubbard pioneered time-critical collision detection [11]. Dingliana and O’Sullivan have used this approach to gracefully degrade the collision handling in rigid body animations [6]. When the collision detection finishes for the current step of the animation, a list of colliding object pairs, if any, are passed to the collision response module, along with their contact data. Collision response for rigid bodies can be divided into two main approaches: impulse-based [13] and constraint-based [1] ones. In the former approach, the impulse magnitudes are computed for only one contact per colliding object pair. However, there exists methods to cope with this limitation, like the one we have implemented in this work as suggested in [14]. To the best of our knowledge, interactive visualization with more than one hundred colliding objects using SphereTrees for the collision detection and response, as we have implemented for the generation of plausible animation, have not been found.

3.

COLLISION DETECTION

We have implemented a hybrid collision detection system to perform the broad and narrow phases. In the broad phase, pairs of objects whose AABBs do not overlap are discarded. The Sphere-Tree representations of the remaining pairs are used in the narrow phase. Objects whose SphereTrees overlap are issued as colliding objects. The contact data between these objects is approximated from the contact between spheres of the Sphere-Tree. The next sections detail the algorithms we have implemented to perform rigid

1242

body collision detection.

3.1

Sweep & Prune Algorithm

There are many approaches to compute the intersection of various AABBs. For example, we have experimented with traditional spatial partitioning data structures (grids and octrees) [17]. These approaches decompose the virtual environment into groups of near AABBs and then carry out an all-pair test with objects pertaining to the same group. These approaches have some performance issues and we have experimentally confirmed that the Sweep & Prune algorithm has better performance and scales better as the number of objects increases. The Sweep & Prune algorithm is based on the AABB intersection test itself. Two AABBs intersect if and only if their projections in the three coordinate axes (represented by continuous intervals) also intersect. The Sweep & Prune algorithm keeps three ordered lists (one for each axis) containing all the AABBs’ intervals. If the intervals of two AABBs intersect in all three lists, then the AABBs also intersect. This algorithm computes pairs of overlapping AABBs in O(n+m), where n is the number of objects and m is the number of overlapping AABBs. Furthermore, because objects usually move small distances between two frames (known as temporal coherence), an Insertion Sort algorithm is used to order the three lists, what makes the expected time to update the lists nearly linear. Our implementation of the Sweep & Prune algorithm is based on the algorithm presented in [7].

3.2

Sphere-Trees

The approximation of the objects’ geometry can be achieved through the use of many types of BVHs. However, Sphere-Trees are particularly attractive because spheres have rotational invariance, fast intersection method, and low memory requirement. Besides, there is a number of published algorithms for the efficient and automatic building of such structures [11, 3]. Sphere-Trees have also been successfully used in level-of-detail collision handling of rigid bodies [6]. Our narrow phase algorithm relies only in the SphereTrees and we do not perform exact tests (e.g., polygonpolygon intersection test). We have used Bradshaw’s Sphere Tree Construction Toolkit to generate the Sphere-Trees of the 3D objects [2]. It implements some algorithms for building Sphere-Trees, including Bradshaw’s own algorithms [3]. In particular, we have used the Combined algorithm, an approach that allows the use of different sphere reduction algorithms in conjunction (e.g., Merge and Burst algorithms), to generate SphereTrees with, at most, eight children per node. The Stanford Bunny object, as well as the second and third level of its resulting Sphere-Tree are depicted in (a), (b), and (c) of Figure 1, respectively. Observe that the Sphere-Tree for this object quickly converges to its surface. One way to compute the intersection between two SphereTrees is as follows. Suppose that N1 and N2 are the current nodes of two different Sphere-Trees. If N1 and N2 intersect themselves, then N1 ← N2 , and every one of its node children, C1 , receives N2 . This procedure is done recursively until that the current nodes do not intersect themselves or do not have children. In the latter case, the nodes are overlapping leaf spheres that will be kept by the algorithm. If the algorithm is modified to be interrupted at any time, then

(a) Stanford Bunny (b) Second level

(c) Third level

Figure 1: Sphere-Tree generated by the Combined algorithm for the Stanford Bunny.

it should be decided whether to discard or to process the remaining non-leaf sphere pairs. We have implemented an interruptible narrow phase algorithm. However, we found out that its use can generate implausible rigid body simulations as the number of objects increases.

3.3

Contact Data Approximation

The ultimate task of rigid body collision detection is the acquisition of contact data. For this, we use the collection of overlapping sphere pairs returned from the narrow phase. It is possible to derive approximated collision points and normals for each of one of these pairs. Let (S1 , S2 ) be a pair of overlapping spheres, and r1 and r2 their respective radii. Also, let v be a vector connecting their centers C1 and C2 (Eq. 1). The normalized vector n (Eq. 2) is the normal vector on the contact region, pointing from S1 to S2 . To find the collision point P, starting from C1 , we move in the direction of v a distance proportional to r1 (Eq. 3). This point subdivides the line segment between the centers C1 and C2 into lengths, which are proportional to the spheres’ radii r1 and r2 [6]. The better the sphere approximation of the surface, the more accurate the contact data (contact point and normal).

4.

v

=

n

=

P

=

C2 − C1 v v r1 v + C1 r1 + r2

(1) (2) (3)

COLLISION RESPONSE

Whenever a pair of objects collide, all the contact data together with the pair of colliding objects are passed to the collision response module. The collision response must update the objects linear and angular velocities so that they tend to move apart and do not interpenetrate. For this, we apply an impulse in the contact point along the contact normal. We have implemented the traditional equation for calculating the impulse magnitude [14]: −(1 +
)vc −1 + n · (I−1 1 (r1 × n)) × r1 + n · (I2 (r2 × n)) × r2 (4) Where the variables are:

j=

1 m1

+

1 m2


: the coefficient of restitution of an object mi : mass of body i n: the contact normal Ii : the inertial tensor matrix of body i ri : the displacement vector representing the displacement of

1243

the collision point P from respective centers of mass of the colliding objects vc : the collision velocity which represents the relative velocities of the points of collision along the collision normal.

ship. Thus, the closer the coefficient is to either +1 or -1, the stronger the correlation between the sequence of values. sphere-

number

number

frame per

tree

of

of

second

standard

depth

objects

contacts

(FPS)

deviation (ms)

2

4 × 25

4216.81

57.47

5.89

2 3 3

4 × 50 4 × 25

5621.16 122445.31

33.29 12.70

7.79 35.96

4 × 50

542613.84

3.34

302.89

2

8 × 10

16381.50

43.80

9.25

2 3 3

8 × 20 8 × 10

12771.69 77246.49

31.50 17.41

8.29 18.92

8 × 20

265562.60

6.91

69.29

Once j has been computed, the impulse J is given by J = jn. This approach effectively prevents objects from interpenetrating as long as the contact data is computed correctly and the time step is small.

5.

EXPERIMENTS AND RESULTS

The scenarios utilized for the experiments are composed of a static plane and stacks of falling bunnies, as shown in (a) and (b) of Figure 2. All the bunnies fall onto the plane. We have varied the number of stacks, the number of objects per stack, and the Sphere-Trees’ depth (2 and 3). For the plane, we have generated a Sphere-Tree with 5 levels built through an octree subdivision. The time to detect and respond to all collisions, as well as the number of contacts were collected at each frame. Also, the total time to generate each frame was gathered. In what follows, we outline the results for scenarios with 25 and 50 bunnies in 4 stacks (100 and 200 objects, respectively), and 10 and 20 bunnies in 8 stacks (80 and 160 objects, respectively). These data were gathered during 880 frames of the animation (this number of frames was enough to let all the objects fall onto the static plane in all experiments).

(a)

(b)

Figure 2: In (a) an example of a scenario with 4 stacks and 50 bunnies per stack (totalizing 200 bunnies) in the beginning of their falling, and in (b), in the end of their falling. In the Table 1 we show the average values for the number of contacts and the FPS for the eight experiments we have conducted. We can observe that the depth of the SphereTree (2 and 3) significantly affects the number of contacts. This happens because the deeper the Sphere-Tree, the more the number of leaf spheres and, therefore, our collision detection system will find a great number of colliding leaf sphere pairs when two Sphere-Trees intersect. From each pair we derive one contact in our approximation to the contact data. Moreover, the number of contacts is, actually, the bottleneck of the whole system. The values for the average FPS in the most totality of the table confirms this fact, as the number of contacts increases, the number of FPS decreases. Specifically, the correlation between these two columns is +0.75. The correlation coefficient measures the strength of the relationship between these two variables. A value of +1 indicates a perfect relationship, a value of -1 indicates a perfect inverse relationship (i.e., one variable decreases while the other one increases). Values near zero indicate no relation-

frame time

Table 1: Average values for the number of contacts and the frames per second (FPS) for each experiment, as well as the standard deviation of the time (in milliseconds) to generate each frame. Table 1 shows that we have obtained high average FPS for a considerable number of objects when Sphere-Trees with 2 levels are used. For example, in the second row, we have obtained 33.29 FPS for a scenario with 4 stacks with 50 objects each (totalizing 200 objects), and, in the sixth row, we have obtained 31.50 FPS for a scenario with 8 stacks with 20 objects each (totalizing 160 objects). Another important variable for interactive environments is the variance to generate each frame. The less the variance, the better is the resulting animation and the user experience with the system. Table 1 also shows the standard deviation of the time (in milliseconds) to generate each frame. For Sphere-Trees with 2 levels, the standard deviation is relatively small, as this value drastically increases when Sphere-Trees with 3 levels are used. The number of contacts seems also to affect the frame time standard deviation, as the correlation between these two columns is +0.96. Finally, in these experiments, 23% of the time was spent on the collision detection on average, with a standard deviation of 0.08%. On the other hand, 40% of the time was spent on the collision response on average, with a standard deviation of 0.26%. This happens because our scenarios have a great number of contacts and all of them have to be dealt with in the collision response. In particular, the correlation between the collision detection percentage and the number of contacts is -0.59, while the correlation between the collision response percentage and the number of contacts is +0.88.

6.

CONCLUSIONS AND FUTURE WORK

In this work, we have described a hybrid collision detection algorithm that utilizes the Sweep & Prune algorithm for the broad phase and Sphere-Trees approximations of the objects for the narrow phase. This algorithm has been applied and experimentally tested for the generation of plausible animation of rigid bodies, useful for many virtual reality applications. Also, we have shown how to derive contact data from the overlapping leaf spheres. For collision response, we have implemented a simple, yet efficient and accurate, impulse-based method that uses a traditional equation to compute the impulse magnitude. The experiments were made in virtual scenarios with objects falling in a static plane. The results suggest that the

1244

number of contacts computed at each frame affects significantly the performance of our system. In particular, we have demonstrated that for the experimented scenarios the average number of contacts per frame is highly correlated with the average FPS and the standard deviation to generate each frame of the animation. Furthermore, as the scenarios have a great number of contacts on average, most of the processing time is spent performing collision response (40% of the time on average, with a standard deviation of 0.26%). Also, when Sphere-Trees with 2 levels are used in scenarios with a great number of objects and simultaneous contacts among them (up to 16381.50 contacts at each frame on average), our system is capable of generating real time plausible rigid body animation. For example, when there are 4 stacks with 50 falling objects each we achieve 33.29 FPS on average, and when there are 8 stacks with 20 falling objects each we achieve 31.50 FPS on average. As future work, we aim at implementing some approaches to decrease the number of contacts computed at each frame. For example, we have shown that the deeper the SphereTree, the more the number of contacts. Hence, better algorithms for building Sphere-Trees would result in less spheres to cover the object and, consequently, less contacts would be generated in our collision detection system. Another approach is to determine somehow which contacts are more representative to result in a plausible animation. Then, only these prioritized contacts would be resolved by the collision response module. We also wonder whether a continuous intersection test between Sphere-Trees could improve the performance of our system, as the number of contacts would naturally decrease.

7.

ACKNOWLEDGMENTS

Rafael de Sousa Rocha benefits from a scholarship and would like to thank CAPES, the Brazilian Ministry of Education Agency, for the financial support. Maria Andr´eia Formico Rodrigues is supported by the Brazilian Agency CNPq (The National Council for Scientific and Technological Development) under grant No 303046/2006-6.

8.

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

REFERENCES

[1] D. Baraff. Fast Contact Force Computation for Nonpenetrating Rigid Bodies. In Proceedings of the 21st Annual Conference on Computer Graphics and Interactive Techniques (SIGGRAPH ’94), pages 23–34. ACM Press, 1994. [2] G. Bradshaw. Sphere-Tree Construction Toolkit. http://isg.cs.tcd.ie/spheretree/, February 2003. Last visited 11/11/06. [3] G. Bradshaw and C. O’Sullivan. Adaptive Medial-Axis Approximation for Sphere-Tree Construction. ACM Transactions on Graphics, 23(1):1–26, January 2004. [4] J. D. Cohen, M. C. Lin, D. Manocha, and M. K. Ponamgi. I-COLLIDE: An Interactive and Exact Collision Detection System for Large-Scale Environments. In Proceedings of the 1995 Symposium on Interactive 3D Graphics, pages 189–196, Monterey, California, USA, 1995. ACM Press. [5] D. Coming and O. Staadt. Kinetic Sweep and Prune for Collision Detection. In Proceedings of the Second Workshop in Virtual Reality Interactions and Physical

[17]

[18]

[19]

[20]

1245

Simulations (VRIPHYS’05), pages 81–90, Pisa, Italy, November 2005. J. Dingliana and C. O’Sullivan. Graceful Degradation of Collision Handling in Physically Based Animation. Computer Graphics Forum, 19(3):239–248, 2000. C. Ericson. Real-Time Collision Detection. The Morgan Kaufmann Series in Interactive 3D Technology. Morgan and Kaufmann Publishers, 2005. T. Giang, G. Bradshaw, and C. OSullivan. Complementarity Based Multiple Point Collision Resolution. In Proceedings of the Fourth Irish Workshop on Computer Graphics, 2003. S. Gottschalk, M. C. Lin, and D. Manocha. OBBTree: A Hierarchical Structure for Rapid Interference Detection. Computer Graphics, 30:171–180, 1996. P. M. Hubbard. Collision Detection for Interactive Graphics Applications. IEEE Transactions on Visualization and Computer Graphics, 1(3):218–230, September 1995. P. M. Hubbard. Approximating Polyhedra with Spheres for Time-Critical Collision Detection. ACM Transactions on Graphics, 15(3):179–210, July 1996. R. G. Luque, J. L. D. Comba, and C. M. D. S. Freitas. Broad-Phase Collision Detection Using Semi-Adjusting BSP-Trees. In Proceedings of the 2005 Symposium on Interactive 3D Graphics and Games, pages 179–186. SIGGRAPH, ACM Press, 2005. B. Mirtich and J. Canny. Impulse-Based Dynamic Simulation. In Proceedings of the Workshop on Algorithmic Foundations of Robotics, pages 407–418, San Francisco, California, USA, 1995. R. Parent. Computer Animation: Algorithms and Techniques. The Morgan Kaufmann Series in Computer Graphics and Geometrical Modelling. Morgan and Kaufmann Publishers, 2002. S. Redon. Continuous Collision Detection for Rigid and Articulated Bodies. Tutorial, 2004. ACM SIGGRAPH Course Notes. S. Redon, A. Kheddar, and S. Coquillart. CONTACT: Arbitrary in-between Motions for Collision Detection. In Proceedings of IEEE Workshop on Robot-Human Interaction, ROMAN’2001, pages 106–111, Bordeaux, Paris, France, 2001. R. S. Rocha, M. A. F. Rodrigues, and L. S. Taddeo. Performance Evaluation of a Hybrid Algorithm for Collision Detection in Crowded Interactive Environments. In Proceedings of the XIX Brazilian Symposium on Computer Graphics and Image Processing (SIBGRAPI 2006), pages 86–93, Manaus, AM, Brazil, 2006. IEEE CS Press. S.-E. Yoon and D. Manocha. Cache-Efficient Layouts of Bounding Volume Hierarchies. Computer Graphics Forum (Eurographics), 25(3):507–516, 2006. G. Zachmann. Optimizing the Collision Detection Pipeline. In Proceedings of the First International Game Technology Conference (GTEC’01), 2001. L. Zhang, Y. J. Kim, G. Varadhan, and D. Manocha. Generalized Penetration Depth Computation. In Proceedings of the 2006 ACM Symposium on Solid and Physical Modeling, pages 173 – 184, Cardiff, Wales, UK, 2006. ACM Press.