A Survey on Collision Detection Techniques for Virtual
Environments
Mauro Figueiredo1,2, Luis Marcelino1, Terrence Fernando1
1
Centre for Virtual Environments, University of Salford
University Road, Salford, UK
2
Escola Superior Tecnologia, Universidade do Algarve
Faro  Portugal
[email protected], {L.Marcelino, T.Fernando}@salford.ac.uk
Abstract. Collision detection is an important component of many
applications in computer graphics applications. In particular, it is a critical
question for virtual environments applications, where real time performance is
required to provide the feeling of being immerse in a environment that looks and
is interactive like a real one. In this paper, we look into current approaches for
collision detection that can be used for real time interactive virtual environments
where the trajectories of moving objects are not predefined. We also present a
taxonomy for classifying different collision detection algorithms. In the end,
using collision detection toolkits publicly available, we have performed a set of
experiments in order to compare the performance between collision detection
algorithms based on axis-aligned, discrete orientation polytopes and oriented
bounding boxes.
1. Introduction
Fundamental to much of the virtual environment work is, in addition to high-level 3D
graphical and multimedia scenes (visual output), is the research on advanced methods of
interaction and the development of behavioral models. The user, or rather, the visitor of
such virtual worlds must be able to act and behave intuitively, as well as receive
expectable natural behavior presented as feedback from the objects in the environment,
in a way that he/she has the feeling of direct interaction with his/her application, and not
using a computer.
The collision detection process plays a very important role for achieving the
construction of a realistic virtual world, enabling interaction among virtual objects and
assisting in the simulation of their dynamic behavior. In many virtual environments,
collision detection allows the virtual representation of the user (e.g. the virtual hand) to
interact with other virtual objects.
This paper reviews different approaches for finding exact collisions between multiple
objects with arbitrary trajectories for virtual environment applications.
Recently [Jiménez 01] presented a survey on collision which focus greatly in methods
for collision detection that explore the tradeoff between the accuracy in finding
collisions and the computational time. In our paper, we concentrate on methods to find
exact collisions in real time. We think that this is an important issue in a virtual
environment. If we want to provide a realistic feedback of an interactive 3D world it is
important to simulate the behavior and the exact interactions between 3D virtual
objects. To achieve this goal, it is necessary to use the exact representation of the
models’ geometry. If we consider the case of using only bounding boxes or bounding
spheres, for example, as approximate models we can obtain very unrealistic situations of
interaction in a virtual environment. Furthermore, in virtual environment applications
such as virtual prototyping it involves exact object interactions and control.
In this paper, we also propose an extension of the taxonomy presented by [Lin 98].
Lin’s classifies the different collision detection techniques according to the model
representation. Nevertheless, we have found that most of the current collision detection
methods for virtual environment applications are supported by polygonal models and
therefore we have found the need to extend her taxonomy in order to compare and
classify different approaches for collision detection.
This paper is organised as follows. In section 2 it is introduced a taxonomy for
classifying different collision detection techniques. In section 3, it is presented different
methods used for partitioning the space occupied by objects. In section 4, we show
several approaches to decompose 3D models in hierarchies of bounding volumes to
speed up the collision detection process. In section 5 we also present some results using
public available toolkits. In section 6 conclusions are presented.
2. A Taxonomy for Collision Detection
Currently there are many implementations of collision detection schemes. It is important
to find a framework that enables us to classify and compare different approaches.
[Lin 98] relates collision detection techniques according to its 3D model representation:
constructive solid geometry, implicit surfaces, parametric surfaces or polygonal models.
We have found that much of the work done in collision detection for virtual
environment applications is supported by polygonal models. Then, it is necessary to
introduce an additional refinement, extending this classification, in order to unite similar
approaches and to compare strengths and weakness of each method.
In this way, we present a taxonomy for collision detection algorithms in figure 1, which
is used to structure the following sections of this paper.
World
Spatial
Partitioning
Representations
Regular
Grid
Octree
Binary
Space
Partitioning
Tree
Bounding
Volume
Hierarchies
R-Tree
AxisAligned
Bounding
Volumes
Oriented
Bounding
Boxes
Discrete
Orientation
Polytopes
3-d Tree
Figure 1. A taxonomy for comparing different approaches for collision
detection.
3. Spatial Partitioning Representations
One class of hierarchical data structures used for collision detection are spatial
partitioning representations: regular grids, octrees, BSP-trees, k-d trees and R-trees.
Spatial subdivisions are a recursive partitioning of the embedding space occupied by
objects. In general, spatial partitioning structures are used as a secondary representation
for the collision detection process.
The main idea behind all space partitioning methods is to exploit spatial coherency. For
each object, we check for collision only objects of the neighborhood, eliminating
comparisons with those objects that are faraway and therefore cannot be colliding.
By dividing the space occupied by 3D objects in the environment, one needs to check
for contact between only those pairs of objects that are in the same cells of the
decomposition. Using such decompositions in a hierarchical manner, as in octrees, BSPtrees, k-d trees or R-trees, can further speed up the collision detection process.
Spatial partitioning representations can be used for the N-body or broad phase problem,
as well as, for the pair processing or narrow phase problem of the collision detection
process. In the broad phase we want to discard, so many as possible, pairs of objects
that do not collide. While in the narrow phase we want to know if two objects are
colliding.
3.1. Regular Grids
The most basic spatial division of the environment is the uniform grid.
The three-dimensional space, which is considered to be a unit cube, is divided into
N × N × N cubic cells of equal volume, building a grid of boxes called voxels (figure 2).
Each voxel has a list of the objects occupying that region. Each of the three-dimensional
objects of the scene can occupy one or more cells of the grid. In this way, an object can
be stored in the list of several voxels and the resulting data structure can be large
compared to the input data structure.
Figure 2. Partition of a 2D scene by a 4x4 uniform grid.
When using regular grids some care must be taken when choosing the number N of
divisions considered for each of the coordinate axes. It is always difficult to know
which is the optimal number N. This is an important question because N defines the size
of the cells. According to [Held 95] experiments this value is typically kept small
between 5 to 50. If we choose a large value, then each cell will have a smaller volume
and will have a small number of objects, which can be good for the collision detection
problem, but on the other hand it will result in large memory usage. If we choose a
small value for N, then the size of each cell is larger and we will loose the advantages of
using spatial partition techniques.
Due to its simplest structure, algorithms based on regular grids are in general very
simple and for the collision detection problem an algorithm based on regular grids is
straightforward. To find out overlapping objects in the broad phase we need to check
only those objects that share the same cells. Uniform grids can also be used in the
narrow phase. To find out if two objects are colliding it is necessary to check only those
cells that have more than one polygon from different objects.
Grids are used in a dynamic environment to find collisions in real time by [Zyda 93]. It
is used to find overlapping objects in the broad phase of the collision detection
procedure, determining pairs of objects candidates for collision, from the intersection of
the bounding volumes of the objects. The testbed scenario used is a very large
environment where objects are very small compared to grid cells. In fact, they are so
small, that objects are approximated by points. Cells are also large enough so that
objects cannot traverse more than one cell per frame.
[García-Alonso 94] also uses uniform grids. However, in this case, this structure is used
to find exact collisions between 3D objects for the narrow phase. It is used a uniform
grid for each object. The bounding volume of each object is partitioned in equal boxes
and each voxel has a list of the corresponding overlapping faces of that object. To find
if two objects are intersecting, then it finds if there is an interference between the voxels
of the corresponding objects.
In [Held 95] it is also described an algorithm for collision detection that makes use of a
grid with 40x40x40 voxels to represent a scene of three dimensional models. In their
work, grids are used in a collision detection algorithm implemented in two-phases. In
the first phase, they use the bounding volume of the moving object to find out the
intersecting cells. An object can occupy more than one cell. From these overlapping
voxels they have a list of triangles from the static environment which are candidates for
collision. For each static triangle, from the previous step, if its bounding volume
intersects the bounding volume of the flying object, then this triangle is passed to a
second phase of the collision detection process. In the second phase, for each triangle of
the moving object it is determined the overlapping cells, using its bounding box, and it
is intersected with each triangle from the static environment in the list of the
overlapping cells. They have implemented this approach and tested it in the
determination of exact collisions in a static environment with one moving object. [Held
95] concludes that the collision detection algorithm implemented using regular grids is
comparable to the faster approach they have implemented using R-trees. In fact, it is
known that in sparse environments, in which the objects are uniformly distributed
through the space, the use of regular grids is very effective for finding out pairs of
colliding objects [Cohen 95].
In a virtual environment, [Zachmann 00] reports the use of grids for finding pairs of
candidate objects for collision, also in the broad phase. In this case, objects can also
occupy more than one cell. It is presented an improvement of about eighty percent,
when using a grid of 8 × 8 × 8 voxels, compared to the traditional algorithm for the allpairs test without using a grid. Although, the scenario presented was fairly simple,
including one moving object with 20 polygons among five hundred static objects with
52 polygons each.
Despite the effective use of uniform grids by several authors, regular grids cannot adapt
to the distribution of the objects or primitives in the scene. It treats in the same way,
regions of the environment with different degrees of occupancy. It cannot adapt to large,
entirely occupied or empty regions of space.
3.2. Octree
An octree represents 3D solid objects by a tree defining a recursive subdivision of space
[Samet 84, Veenstra 88]. The volume occupied by objects in the environment is
partitioned, at each time, into eight axis-aligned subvolumes, using a cubic
decomposition. Each cube is marked as empty or occupied by solid objects. The
resulting octree is a tree structure of degree eight where each nonleaf node has eight
sons. There is also an alternative representation where spheres are used instead of cubes
as octant including volumes [Hubbard 93, Tzafestas 96].
We start with a finite unit axis-aligned cubic universe, the root node, which is
decomposed into eight smaller axis-aligned cubes called octants, numbered from one to
eight (figure 3). These octants are obtained from the split of each coordinate direction in
the middle of the original cube.
If an octant is completely outside the object, then the corresponding node is labeled as
white, which means that this region of space is empty. If an octant is completely inside
the object, then the node in the octree structure is labeled as black. In both cases, the
recursive procedure on that side of the tree is finished. Leaf nodes are either marked as
black or white whether they are occupied by the 3D object or not, respectively.
If the octant is partially contained in the object, then the octant is decomposed into eight
suboctants, each of them being tested again to determine if it is completely inside or
completely outside the object. At this time, the size of the corresponding suboctants is
again divided by two. At a node level n the corresponding cube is of size 2− n , where
node level zero is the root. This recursive procedure is continued until there isn’t any
octant partially contained in the object or until a desired level of resolution is achieved
defined by the depth of the octree structure. If this is the case, then those octants that are
only partially contained in the object are approximated as occupied or unoccupied,
black or white, using some criteria. Figure 3-b presents an object enclosed by its octant
hierarchy and the corresponding octree representation is shown in figure 3-c.
Root
z
3
4
2
1
1
6
8 x
3
2
4
5
6
7
8
y
5
1
(a)
(b)
2
3
4
5
6
7
8
(c)
Figure 3. (a) Octant labeling; (b) an object octree partitioning and (c) the octree
structure for the above 3D model.
Many researchers use octrees to represent three-dimensional objects. They have also
been used to represent the spatial relationship of geometrical objects, making it
relatively simple to determine neighbor objects [Moore 88] and to traverse the volume
from front to back for hidden surface removal [Gargantini 93].
The idea behind using octrees for collision detection is to compare for collision only
those pairs of objects that share the same cells. In figure 4, it is shown the partition of a
2D scene using the quadtree subdivision, which is the equivalent for 2D of the octree
subdivision. In this two-dimensional example, it is considered a new quadtree
subdivision if the node has more than five objects. Those pairs of objects that do not
have some cell in common cannot be overlapping and should not be considered. Each
leaf node, in the octree representation of the scene, has a list of the objects sharing that
suboctant which are cross checked pairwise for collision.
Figure 4. Spatial partition of a 2D scene using a quadtree subdivision.
Octrees recursively partition cubes into axis-aligned octants. At each instance, the
objects are assigned to one or more octants and each cell is classified as empty or not
empty. Those parts of space where octants are labeled as empty are simply discarded,
since no overlapping occurs in those cases. Collisions are checked between all object
pairs belonging to a particular cell.
In order to find pairs of objects that are intersecting, we start at the unit universe root
node and find out which are the cells occupied with more than one object. Then we
check for exact collision those objects that share at least one of these cells.
The resulting advantage of using an octree structure is that we can discard many pairs of
objects and primitives that cannot be colliding, increasing the overall performance of
the collision detection process.
The hierarchical nature of octrees makes them a good choice because they are also
adaptive to the cluttering of the environment. In fact, during the octree construction
process, as the subdivision is carried at a node level, if the node contains more than the
optimum number of objects, an octal-subdivision is generated. On the other hand, it is
also more efficient for representing large areas of the free space.
However, there are also some problems. Position of the octants is restricted to be
aligned with the coordinate axes and the sizes of the octants are fixed to powers of two.
In this way, the size of the octree is dependent of the position and orientation of the
object. In some positions of the object, the tree may be compact. While in others the tree
can become very large. In fact, the position and orientation of the object, affects the size
of the octree, as well as, it can influence the quality of the representation, since it is
restricted to the depth of the tree allowed for its implementation. Octree models are
approximations of the solid objects which are restricted to the desired depth of the tree
structure. On the other hand, representing a complex 3D scene can return in a large
octree representation with a quite large depth, requiring a large amount of memory and
which results in poor worst-case search time.
It is possible to overcome these difficulties using vector octrees [Samet 88], extended
octrees [Ayala 85, Brunet 90] or polytrees [Carlbom 85]. These generalizations of an
octree structure, allows terminal nodes to contain parts of the solid geometry of the
object. In this way, the 3D model can be exactly represented, by the underlying
primitives, and also reduce the degree of subdivision making the resulting
representation to be more compact.
[Hubbard 93, 96] approach for finding collisions in real time is based on a time-critical
computing algorithm and on octrees of spheres. A time-critical collision detection
implementation finds out collisions between successive more detailed approximations
of the 3D objects. It uses different levels of detail to the objects geometry. The collision
precision is dependent on the time slot available for the detection process, regarding that
the overall performance cannot slow down, in order to maintain the application running
interactively. A time-critical collision detection algorithm as different levels of
accuracy.
[Kitamura 94] algorithm for collision detection uses an octree for each object. To find
collisions it traverse the updated octree of the moving objects against the static ones to
find intersecting nodes. Only those face pairs found on overlapping octree nodes are
then cross checked for intersection.
[Smith 95] uses bounding volumes in the broad phase to find out possible colliding
objects. For each object that share some overlapping bounding box, using the faces’
bounding volumes, it is found a list of faces for that object that intersect the overlapping
region. If there is more than one list of faces, then it is built a face octree structure for
the remaining faces. Each face from the lists of faces are inserted in the octree where the
root node is the unit cubic of the scene. To find if there is any exact collision, the face
octree is traversed and those faces from different objects that share the same cell are
intersected, and a list of intersecting face pairs is built. This implementation was tested
with two spheres of varying complexity, from about 200 to 4000 triangles, and with
fifteen models of the space shuttle with 528 faces. This approach supported by octrees
did find the first intersection between 3D objects interactively. However, real
applications do not terminate at the first collision. In fact, after the first collision there
will be in the next time steps more collisions, probably of the same objects, in the
neighborhood. [Smith 95] compared his approach with better results than the work of
[Kitamura 94].
A real time exact collision detection for the narrow phase using spherical octrees was
developed by [Tzafestas 96]. In this algorithm, each 3D object is described by an octree
structure in its local coordinate system. The decomposition process is done using
spheres instead of cubes. At each node, it is inscribed a sphere into the cube of the
original cubic octree decomposition. From this consideration, it should be noted that in
this case the total volume of the spherical octree representation is larger than an
equivalent cubic octree structure. The leaf nodes of the spherical octree structure, point
to the list of vertex, edge or faces that the corresponding sphere intersects. The exact
collision detection algorithm is done in two steps. In the first step it is found the
intersecting spherical octree nodes, determining the candidate faces of each object for
collision. In the second step, it is determined exactly the pairs of colliding faces from
two objects. This implementation was tested using a virtual scene where fifty was the
maximum number of vertices of colliding objects. This is in fact a very simple object
scene. It is outlined that as the depth of the spherical octree is increased, the collision
detection process has a behaviour that approximates to linear.
[Zachmann 00] also implemented an incremental collision detection algorithm for the
broad phase using octrees, that makes use of temporal coherence. His concern was in
finding an approach of quickly updating the octree in a dynamic environment, when the
geometry of an object is changed or when it moves. Some care has to be taken since the
octree representation must have to be recomputed, which can be particularly expensive.
3.3. Binary Space Partitioning Tree
Binary space partitioning (BSP) is an approach that was initially designed to solve the
visible surface determination problem [Fuchs 80, Gaede 98, Naylor 90] and can also be
used for partitioning the space.
A BSP tree is a binary hierarchy tree that represents a recursive subdivision of the n
dimensional universe into homogeneous subregions, using n-1 dimensional hyperplanes.
In a BSP-tree, the partitioning of the space is defined by these hyperplanes and therefore
is not limited to be axis-aligned. Each subregion is divided independently of preceding
subdivisions and of the other subspaces, repeatedly until the number of objects or
primitives in each subregion is under a given threshold, τ .
In a three-dimensional space, a hyperplane h is a plane defined by the set of points that
satisfies the equation ax + by + cz = d .
It partitions ¡3 into two half spaces. Those points in space defined as
h + = {p ∈ ¡ 3 : ax + by + cz > d } represent the positive or front open halfspace.
The negative or back open halfspace h − is defined by the set of points that satisfies the
condition represented as h− = {p ∈ ¡3 : ax + by + cz < d } .
The BSP tree is stored in a binary structure. The root node t0 of a BSP tree matches the
complete region of the 3-D environment, r (t0 ) = ¡3 . In fact, the region covered by the
root node is unlimited, but in practice it is considered only the region limited to the
bounding volume that covers the 3D models of the scene.
To this region it is applied a hyperplane h0 , defining a negative h0− and a positive h0+
open halfspaces. Such hyperplane, partitions the original space into two new
subregions: r − (t1 ) = r (t0 ) ∩ h0− and r + (t1 ) = r (t0 ) ∩ h0+ , stored in the tree as the left ( t0 .left ) and
right ( t0 .right ) child of t0 .
To each of this sub-regions, this procedure can be repeated recursively to construct a
binary space partition tree. The intent is to cut space recursively into two halves.
Starting with the whole universe, cut it in half and continue with each of the halves.
Each internal node t of the binary tree stores a hyperplane ht responsible for the
partitioning of the space in two disjoint subregions represented by the descending
nodes: left edge corresponding to the negative halfspace and right edge for the positive
halfspace. The region r (t ) represented by each internal node t is defined by the
intersection of the open-halfspaces, determined by the hyperplanes associated with the
previous nodes on the path from the root to the node t . That is, given a node ti at depth
i which is along the path defined by {t0 ,..., t i } , where the subscripts denote depth, then if
ti is the left child of ti −1 it defines the region r (ti ) = r (ti −1 ) ∩ ht− otherwise r (ti ) = r (ti −1 ) ∩ ht+ .
i−1
i−1
If the number of objects or primitives is under some predefined constant τ , then the
subspace is no longer partitioned and the node is a leaf of the BSP tree. Each leaf node
of a BSP structure corresponds to an unpartitioned region designated as cell and stores
references to those objects or primitives that are present in the corresponding region.
Figure 5 illustrates the building procedure of a BSP tree.
1
2
a
2
1
1
4
3
c
b
a
3
d
5
f
4
b
5
c
e
f
d
e
(a)
(b)
Figure 5. a) Partitioning the 2D space and (b) the corresponding BSP tree.
BSP trees are often used to solve problems in computer graphics such as global
illumination, shadow generation, ray casting and visibility [Naylor 90, Chin 89, Fussel
90]. They are also used to represent solid models and in information retrieval for finding
nearest and farthest neighbours, and performing range queries [Thibault 87, Naylor 90].
A major disadvantage of BSP trees is when used in a dynamic scene. If we want to use a
BSP structure for collision detection in dynamic scenes, other approaches must be taken
in the design of the tree structure.
[Naylor 90] approach to this problem was to build a BSP tree for the static environment
and another BSP tree for the moving object. At each frame, the two trees are merged to
produce a complete scene.
An alternative incremental approach was implemented by [Chrysanthou 92] where the
polygons of a moving object, and the nodes they define, are removed from the tree and
re-inserted at their new position at each frame. When a polygon is deleted from the tree,
then we will get two unconnected trees that are merged incrementally. The complexity
of restructuring is claimed to be reduced since any moving polygon is closed to a leaf
node after the first deletion. This approach was tested with small moving objects.
[Kumar 99] describes an algorithm to deal with dynamic environments by expanding
BSP trees for polygons to BSP representations of objects and using separating planes
between objects. Three-dimensional scenes are represented as a composition of a set of
objects, each of which can be represented, added, deleted and moved independently.
The BSP tree of an object stores the corresponding polygons in the leaf nodes and the
BSP for the complete scene is built by successive merging operations of objects. When
an object is moving there is no need to reconstruct the tree, since this structure is not
changed under translation and rotation. It is necessary to update only the geometry
information to maintain current positions and orientations. Nevertheless, as it is
described, after a number of iterations a number of redundant planes result in the parent
object from the motion of an object. This leads to the need of periodically reconstruct
the complete BSP tree.
The main problem of the BSP approach is that in general it is not possible to avoid that
the hyperplanes will not cut objects or polygons. Thus, the size of a BSP tree can get
very large.
Other disadvantage is that the choice of partitioning planes depend heavily on the
current arrangement of objects which is critical for dynamic scenes, as it is the case in
virtual environments.
One of the main advantages of BSP trees is that they provide simple 3D searching,
using simple comparisons involving a sidedness test against the hyperplane cut
associated to each of the nodes of a BSP tree representation.
A BSP tree is not suitable for objects which change their geometry, since in this case the
BSP representation has to be recomputed.
Binary space partition trees can adapt well to different data distributions [Gaede 98].
Nevertheless, in general they are not balanced and may have very deep subtrees, which
has a negative impact on the tree performance.
3.4. k-d Tree
The k-d tree [Bentley 75, Bentley 79, Gaede 98] is a binary space partition tree that
represents a recursive partition of the space into subspaces using (d-1) dimensional
hyperplanes. These hyperplanes are iso-oriented and their directions alternates among
the d possibilities.
In the three dimensional space, a 3-d tree is a BSP tree whose splitting hyperplanes are
chosen alternately orthogonal to the coordinate axes.
The 3-d structure is similar to the BSP tree. The root node is also associated to the
universe. The difference is that, in this case, as the hyperplanes are always
perpendicular to the coordinate axes, then each node of the tree is associated with a
parallelepiped, and implicitly with the set of objects or primitives that intersect that
subregion. Each non-leaf node is also associated with a hyperplane. To define the
children of a node, we must decide if the hyperplane is orthogonal to the x-, y- or z-axis
and the coordinate of the corresponding split. If the number of objects or primitives
intersecting a subregion falls below a threshold, τ , then the subspace is not partitioned,
and the corresponding node is a leaf in the tree. Each leaf node has a list of objects or
primitives that intersect its subregion as in a BSP tree.
The 3-d tree structure presents identical properties to BSP trees. In addition, a 3-d tree
as a very good depth property, since it is always O (log n) [Duncan 01], which is
important for the performance of the tree structure that is directly related to its depth.
[Held 95] presents the implementation of a 3-d tree for exact collision detection in a
virtual reality walkthrough application. In his work, he evaluates the resulting collision
detection manager in a 3-D world, with one moving object in a static environment. Only
the static objects in the environment are represented in the 3-d tree.
The implemented collision detection manager finds collisions in two steps. First, it
searches, in the leaf nodes of the 3-d tree, for triangles from the scene whose bounding
boxes overlap the bounding volume of the moving object. If there is an overlapping
between bounding volumes, then in the second step, each triangle from the moving
object is passed to the 3-d tree and processed until it reaches the appropriate leaf nodes
and it is intersected for an exact collision with the corresponding triangles of the 3D
scene.
In his implementation, [Held 95] found that better results were achieved with a cutting
plane perpendicular to the coordinate axis that minimize the product of the number of
triangles in the two resulting subregions. It was also decided to split always at the
midpoint of the corresponding parallelepiped length and it was defined a threshold
τ = 10 .
The performance of the collision detection manager implemented with the 3-d tree was
always worst when compared to an approach supported in a regular grid representation
[Held 95].
A single polygon can belong to more than one partition in a 3-d tree and therefore is
stored as many times as the number of regions that it overlaps. Experiments conducted
by [Held 95] shows that the number of triangles stored in a 3-d tree can be from three to
eight times more than the original number of triangles for 3D objects models. Testing
scenarios used different objects, with a number of triangles changing from 100 to quite
complex ones with about 30 000. On average the number of triangles stored in a 3-d tree
is five times more than the original number of triangles. On the other hand, the 3-d
structure requires two times more triangles stored than the correspondent uniform grid
structure. Besides, to find exact collisions, the implementation based on the 3-d tree
required ten times more nodes visits than the approach based on the regular grid.
3.5. R-Tree
Another hierarchical data structure used to represent a partition of the space is the R-tree
[Guttman 84, Beckmann 90].
The main idea is to partition the set of objects or primitives associated with a node, as it
is shown in figure 6, rather than partitioning the subregion associated with a node, as is
done in a BSP or a 3-d tree.
1
6
5
Root
4
1
2
3
7
10
11
8
12
4
5
6
7
8
9
10
11
12
9
3
2
(a)
(b)
Figure 6. (a) A 2D scene of a set polygons partitioned in a R-tree. (b) The
corresponding R-tree for the 2D scene shown above.
A R-tree is a multi-ary tree in which the non-leaf node has between τ and σ children,
except for the root node. The values τ and σ (σ ≥ 2τ ) are the minimum and maximum
number of children of a node, respectively. The root node has at least two children
unless it is a leaf. The root node is associated to the space covered by all the objects or
primitives in the environment. Each node of the tree defines a subregion represented by
the bounding volume that encloses the corresponding primitives of its child nodes. If the
number of primitives of a node is between τ and σ , then the node is a leaf, and the
corresponding primitives are stored on that leaf node. Otherwise, the node is split and
the child nodes will then represent their respective subsets of the objects or primitives.
Subregions of different nodes can overlap in a R-tree. This means that a spatial query
may often require the visit of several nodes to find out overlapping bounding volumes.
When building an R-tree, each object is inserted at a leaf node. The appropriate leaf
node is found by traversing the R-tree from the root and at each internal node choosing
the subtree whose covering bounding volume has to be enlarged the least. Once the leaf
node is found, then it is necessary to see if the insertion will cause the node to overflow.
If this is the case, then it must be split and the σ + 1 primitives are divided between two
nodes. This split is then propagated up the tree.
Some important properties of R-tree can be underlined. At any level of the tree, each
primitive is associated with only a single node. It is also interesting to note that in a Rtree all leaf nodes appear on the same level. The depth of a R-tree storing n primitives is
O (log n / log τ ) . The total number of primitives stored in a R-tree equals the number of
original primitives. On the contrary, as it was discussed in section 3.4, in a BSP tree the
number of stored primitives can be much greater than the original number of primitives.
To find collisions of a moving object in a virtual environment, [Held 95] implemented a
binary R-tree to represent the static scenario. From their experiments they have
concluded that the R-tree was the best approach for finding exact collisions in walkthroughs, when compared to regular grids and 3-d trees. In the R-tree implemented it
was defined a threshold τ = 1 . In this way, leaf nodes were chosen to have only one
triangle. Internal nodes were split using the median x-, y-, or z-coordinate of the
centroids of the primitives associated to that node. The corresponding primitives were
associated to one of the two sons of the split according to how the centroids fall with
respect to the median value.
We conclude this section with the Table 1 that summarizes the main properties of the
different spatial partitioning techniques for the collision detection problem.
4. Bounding Volumes Hierarchies
Many different approaches based on bounding volumes hierarchies have been used to
speed up collision detection algorithms in the broad and narrow phases between general
polygonal models. The basic idea of these approaches is to approximate the threedimensional models with bounding volumes to reduce the number of pairs of objects or
primitives that is needed to be checked for contact.
These methods cannot find out if two 3D models are intersecting, but they can be used
to quickly reject objects or pairs of polygons which cannot intersect.
There are many types of bounding volumes: axis-aligned bounding boxes, spheres,
oriented bounding boxes and discrete orientation polytopes.
4.1. Axis-Aligned Boxes and Spheres
Typical examples of bounding volumes used in collision detection algorithms for virtual
environments are axis-aligned boxes [Van Der Bergen 98] and spheres [Hubbard 96,
Palmer 95, Quilan 94].
An axis-aligned bounding box (AABB) is a parallelepiped whose faces are aligned with
the coordinate axes. It is very simple to compute an AABB since it is represented with
the minimal and maximal values along each axis, specifying a region R limited by the
planes parallel to the axes specified by the values: xmin, xmax, ymin, ymax, zmin, zmax. This
requires six parameters to specify an axis-aligned bounding box.
A bounding sphere is defined with four parameters describing its center point C and
radius r, specifying the bounded region.
Table 1. Advantages and disadvantages of the spatial partitioning representations.
Type of
Representation
Regular Grids
Octrees
BSP
3-d Tree
Advantages/Disadvantages
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
§
R-Tree
§
§
§
§
Simple algorithms.
Improved performance of about 80% [Zachman 00] compared to the traditional
n-body problem.
Unadapted to the environment distribution of 3D objects.
Number of stored primitives greater than the original.
Hierarchy structure.
Adaptive to the object distribution.
Position and size of octants is restricted.
Size of the octree is dependent of the position and orientation of 3D models.
Requires large amount of memory.
Hierarchy structure.
Simple 3D searching algorithms.
Adapt well to the environment distribution.
Hyperplanes cut objects and polygons.
Hyperplanes depend on the scene.
Number of stored primitives greater than the original.
A BSP tree can get very large.
In general the BSP tree is unbalanced.
Not suitable for objects that changes its geometry.
Same as BSP trees.
Good depth property.
Number of stored primitives is about three to eight times more than the original
[Held 95].
Worst performance compared to regular grids [Held 95]. A 3-d structure requires
two times more stored primitives than the regular grid. The collision detection
algorithm implemented with the 3-d tree required to traverse ten times more
nodes than the approach based on the regular grid.
Hierarchy structure.
Each primitive is associated with only a single node.
All leaf nodes are on the same level.
The number of primitives stored equals the number of original primitives.
A collision detection algorithm supported only with bounding volumes cannot find out
accurately if two polyhedral models are intersecting. In fact, bounding volumes can be
effectively used to support an algorithm to reject pairs of objects that do not intersect
and generate a list of pairs of models candidates for intersection.
A further step can be considered and, for each object, a bounding volume tree is built in
order to reduce the number of comparisons needed to find out the candidate primitives
for intersection between two polytopes.
These types of volumes trees have been widely chosen in virtual environments since it
is very easy to implement and fast to find collisions between two such volumes.
In fact, to find out if two axis-aligned bounding boxes are overlapping only six
comparisons are required. It is also possible to say that two AABBs are disjoint, in the
best case situation, with only one comparison.
Testing two bounding spheres for overlap is also trivial and can be done with only four
additions/subtractions and three comparisons.
In addition, it is simple to update these volumes as an object rotates and translates.
Collision detection algorithms based on bounding volume hierarchies recursively test
pairs of bounding volumes for overlap. If they do not intersect, then that recursion
branch ends. If they intersect, then the children bounding volumes nodes are tested for
overlap. If it has reached a point where two leaf nodes are found to overlap, then to find
out if the two models are colliding, we have to intersect the descendant polygons.
4.2. Oriented Bounding Boxes
An oriented bounding box (OBB) is also a rectangular bounding box but with an
arbitrary orientation so that it encloses the underlying geometry more tightly (figure 7).
The representation of an oriented bounding box encodes not only position and widths,
as in the case of the axis aligned bounding boxes, but also orientation.
a1A1
C
a 2A2
(a)
(b)
(c)
Figure 7. a) An example of an oriented bounding box in 2D and (b) the
corresponding axis-aligned bounding box. c) Definition parameters of an OBB.
For the representation of an oriented bounding box A (figure 7-c), fifteen parameters are
used to define the center point C, edge half-lengths a1, a2, a3 and an orientation
specified as three mutually orthogonal unit vectors A1 , A 2 and A 3 , which are the
columns of a 3x3 rotation matrix. With these parameters we can define the bounded
region of the oriented bounding box.
4.2.1. RAPID
Recent work using oriented bounding boxes was presented by [Gottschalk 00], for the
implementation of an algorithm for collision detection that has been made publicly
available in a system called RAPID (Rapid and Accurate Polygon Interference
Detection).
Using a top-down approach, RAPID builds a hierarchical tree of oriented bounding
volumes. This tree is constructed as a recursive application of fit-and-split operations.
Given a collection of polygons, it fits a bounding volume to them, and then partitions
the collection into two groups. To each group, fit a new bounding volume and partition
again until all leaf nodes are indivisible.
The subdivision rule used in the RAPID system is to split the longest axis of an oriented
bounding box with a plane orthogonal to one of its axes. The placement of this splitting
plane is chosen to be that of the mean point, µ, of the vertices. Then descending
polygons are grouped into subgroups according to which side of the plane their center
point lies on. If the longest axis cannot be subdivided, the second longest axis is chosen.
Otherwise, the shortest one is used. If the group of polygons cannot be partitioned along
any axis by this criterion, then the group is considered indivisible and this procedure
ends. The resulting OBB tree built in this way, based on where the median center point
lies, is balanced [Gottschalk 00].
The basic approach in RAPID for fitting an OBB aligned with the model is, using
covariance methods, to choose first an orientation for the OBB, and then choose a centre
and minimal edge lengths that enables it to cover the model.
The overall time to build the oriented bounding tree is not an essential issue for virtual
environments applications. This is a pre-processing step which does not influence the
interactive component of a virtual environment. On the other hand, it is important that
the algorithm for the intersection of three-dimensional models, supported by this
hierarchical tree of oriented bounding boxes, runs in real time.
An algorithm for finding the overlap status of two oriented bounding boxes tests
exhaustively all edges of one box for intersection with any of the faces of the other box
and vice-versa. If two OBB overlap, then either one completely contains the other or
their boundaries overlap. Testing to find if there is contact between the two OBB
requires 144 edge-face tests, which each is a 3-by-3 linear system. If they do not touch,
then it is necessary to test whether any point in one box is entirely contained in the other
box and vice-versa. In practice, it is an expensive test. What RAPID does to overcome
this problem is based on the separating axis theorem [Gottschalk 00].
Two disjoint 3D models can always be separated by a plane which is parallel to a face
of either object, or parallel to an edge taken from each object. An oriented bounding box
has three unique face orientations and three unique edge directions. This leads to fifteen
potential separating axes to test, three faces from one OBB, three faces from the other
OBB, and nine pairwise combinations of edges. If two oriented bounding boxes are not
in contact, then a separating axis exist, and at least one of the fifteen axes mentioned
above will be a separating axis. If the polytopes are overlapping, then clearly no
separating axis exists. So, testing the fifteen given axes is a sufficient test for
determining overlap status of two OBBs.
RAPID implemented this effective approach and the worst-case intersection test
between two overlapping oriented bounding boxes is done with 252 arithmetic
operations of which we have 15 comparisons, 96 additions and subtractions, 117
multiplications and 24 absolute values. The best case input requires 89 arithmetic
operations, distributed as one comparison, 39 addition and subtractions, 39
multiplications and 10 absolute values calculations.
4.2.2. V-COLLIDE
V-COLLIDE is a system for interactive collision detection for polygonal models
undergoing rigid motion in VRML environments [Hudson 97].
V-COLLIDE is built on top of the RAPID library, where RAPID is a collision detection
library based on oriented bounding boxes (OBB). V-COLLIDE does a sweep-and-prune
operation for the broad phase using an axis-aligned bounding box (AABB) for each
object. In this first level, V-COLLIDE finds all pairs of overlapping bounding boxes
eliminating pairs of objects that cannot intersect. Then for each pair of objects, which
are potentially in contact, it uses RAPID algorithm for the narrow phase based on
oriented bounding boxes to detect collisions.
V-COLLIDE does not provide direct access to the triangles of the underlying geometry.
Thus, if the application changes part of the object geometry, then it is necessary to
destroy the complete object and rebuild it again from scratch.
4.2.3. Proximity Query Package
The PQP library, Proximity Query Package, uses two different type of bounding
volumes [Larsen 99]. It uses rectangle swept spheres (RSS) for distance queries and
oriented bounding boxes (OBBs) for collision detection. It is also based on RAPID
library.
4.3. Discrete Orientation Polytopes
As defined by [Klosowski 98] discrete orientation polytopes, or “k-dops”, are bounding
volumes that are convex polytopes whose facets are determined by halfspaces whose
outward normals come from a small fixed set of k orientations.
An axis-aligned bounding box in 3D is anrexample of a six-dop with orientation vectors
r
r
determined by the unit vectors ± i , ± j , ± k .
An eight-dop in two dimensions is defined by eight fixed normals defined by the
orientations at ±45, ±90, ±135 and ±180 degrees. These different types of bounding
boxes are illustrated in figure 8.
(a)
(b)
Figure 8. An example in 2D of (a) an oriented bounding box and (b) an eightdop.
The work of Klosowski, which is available in the QuickCD toolkit, concentrated in the
study of four choices of k-dops: 6-dops, 14-dops, 18-dops and 26-dops for the collision
detection problem. Six-dops are in fact axis-aligned bounding boxes and can easily be
built as it was explained in the section 4.1.
In order to build a 14-dop, for example, it is required to find the minimum and
maximum coordinate values of the primitives along
each of the seven directions, which
r r r r r r r r r r r r
were defined by Klosowski by the unit vectors i , j , k , i + j + k , i − j + k , i + j − k and
r r r
i − j − k . That is, a 14-dop uses six halfspaces defining the volume of an axis-aligned
bounding box, plus additional eight diagonal halfspaces that are used to cut off as much
of the eight corners of an AABB as possible.
Consider again the seven directions vectors defined above, which can also be written as
the vectors vv 1 = (1,0,0) , vv 2 = (0,1,0) , vv 3 = (0,0,1) , vv 4 = (1,1,1) , vv 5 = (1,−1,1) , vv 6 = (1,1,−1) and
v
v 7 = (1,−1,−1) . To define a 14-dop bounding volume, fourteen parameters are required to
define the lower, l i , and upper, u i , coordinate values of the m vertices, P j , of the
r
underlying polygons, projected onto the seven vectors vr i . For each direction v i , the
lower and upper values can then be determined by the following expressions:
 uuur
li = min OP j ⋅

 uuur
ui = max OP j ⋅

r
vi

r ∧ j = {1..m} , i = {1..7}
vi

r
vi

r ∧ j = {1..m} , i = {1..7}
vi

(1)
This values of li and ui specifies fourteen halfspaces defining a bounding volume for the
underlying geometry constructed as an axis-aligned bounding box with its corners cut
off. This volume defines the bounded region for the 14-dop as:
uuur

R =  P ∈ ℜ3 : li ≤ OP ⋅

r

vi
r ≤ ui ∧ i = {1..7}
vi

(2)
This concept can be extended and more directions can be considered.
The QuickCD system also implements a 26-dop volume constructed by the union of the
defining halfspaces for the 14-dops and 18-dops, using the six halfspaces of an axisaligned bounding box, plus the eight diagonal halfspace that cut off corners and more
twelve halfspaces that cut off edges. The 18-dops is reported as the more effective
choice of discrete orientation polytopes.
The implementation of the collision detection problem in this system is also based on a
bounding volume tree, in this case supported by k-dops.
Discrete orientation polytopes are very simple to intersect. If we use 18-dops volumes
we need to perform only eighteen comparisons.
5. Experimental Tests
Our experiments were conducted using collision detection toolkits publicly available
that implement different types of bounding volumes hierarchies.
We have used QuickCD, that implements discrete orientation and axis-aligned bounding
volumes, which is a particular case of a 6-dop. RAPID was also used for testing the
implementation of collision detection schemes supported by oriented bounding boxes.
Unfortunately, we did not find any publicly available collision detection that
implemented any of the spatial partitioning techniques described in section 3 and,
therefore, we could not test its practical importance.
First, we have compared different types of bounding volumes. We wanted to have an
idea about the order of magnitude of the computation time for calculating the worst-case
intersection between two bounding volumes. The running experiments were done in two
platforms. We have used one AMD Athlon1600+ with 256Mb of memory and one
Silicon Graphics ONYX2 with MIPS10000 processors clocked at 250MHz and 4
gigabytes of RAM.
Table 2. Intersection times between bounding volumes.
Bounding Volume
Athlon1600+
Inf. Reality
AABB
18 DOP
OBB
31 ns
78 ns
940 ns
67 ns
168 ns
800 ns
As we can see from Table 2, the axis-aligned bounding box is found to be an order of
magnitude faster than the oriented bounding boxes. In fact, in a SGI the AABBs are
about twelve times faster than the OBBs. Although, the axis-aligned bounding boxes do
not enclose the object geometry so tight, nevertheless they are much faster than the
oriented-bounding boxes. It is expected in a collision detection cycle that we will
require more bounding boxes checks than oriented-bounding boxes intersections. But,
these last ones are very expensive and in the end if a proper hierarchy of bounding
volumes is chosen then a collision detection supported by axis-aligned bounding box is
effective. For this reason, we understand why axis-aligned bounding box are commonly
used for collision detection.
In a second step, we also wanted to compare different collision detection toolkits
publicly available. To make the experiment results comparable we used similar
conditions for all experiments.
For the first tests, we have used equal prisms with four thousand triangles each. One of
the prisms is static, centered at the origin of the coordinate axis system. The second
prism is moving along the x-axis from an initial position until it reaches the origin. In
this case, at the initial position, the two objects are separated from each other. At the
final position, the two objects are completely overlapping each other. In this path, the
number of contacts between triangles change from 509 to 2601.
In this first experiment, we want to compare the use of axis-aligned bounding volumes,
using quickCD configured as 6-dops, against 18-dops bounding volumes, which is
reported as the most effective choice for k-dops. Results are presented in figure 9.
From figure 9-a), we can see that it is not achieved real time interaction. Nevertheless,
we have chosen this working scenario because we have tried first with smaller objects,
in terms on number of polygons, and it was not possible to compare the two approaches,
since the results were quite similar. However, in more complex worlds we can see that
using k-dops is more effective than using axis-aligned bounding volumes.
18-dop
Bounding Volumes
1600
140%
1400
120%
Ratios AABB/18-dops
time to collision (ms)
AABB
1200
1000
800
600
400
100%
80%
60%
40%
20%
200
0
509
Triangles
1075
1449
1859
Number of Contacts
(a)
2095
0%
509
1075
1449
1859
Number of Contacts
2095
(b)
Figure 9. (a) Performance of an AABB approach compared to k-dops. (b)
Overhead of an AABB versus 18-dop approach in terms of percentage of
bounding volumes and triangles intersection tests.
The 18-dops bounding volume intersection checks are more expensive than the simple
axis-aligned tests. On the other hand, 18-dops volume are more tight to the underlying
geometry. Therefore, it is possible to filter out much more pairs of not colliding
bounding volumes and triangles. In the end, this is more important for the collision
detection problem.
This assumption is confirmed in figure 9-b), where it is presented the relation between
the number of intersection tests between bounding volumes and triangles of axis-aligned
bounding boxes, in respect to the 18-dops volumes. On average, axis-aligned bounding
volumes requires 30% and 47% more bounding volumes and triangles intersection tests,
respectively, than the collision detection manager based on 18-dop. We remember that
we have used the QuickCD collision detection toolkit for both tests. Therefore, the
algorithm for building the hierarchy tree is the same and, in this way, we are comparing
only the use of AABBs or 18-dops.
Our next experiment was also done with two prisms, with four hundred polygons each,
under identical trajectories circumstances of the first test. We have used a simpler scene
because we wanted to test the use of oriented bounding boxes or discrete orientation
polytopes at interactive rates.
Figure 10-a) presents the comparison between RAPID and QuickCD configured with
18-dops volumes. The number of colliding triangles in this path varies from 268 to 380.
In this setup the QuickCD collision detection toolkit has better performance than
RAPID. In figure 10-b), we can see the ratios of 18-dops versus oriented bounding
boxes. It is interesting to see that on average the 18-dops require 83% more bounding
volume tests than the oriented bounding volumes. However, we have seen before that
the cost of intersecting oriented bounding volumes is about five times more than 18dops. It is also interesting to see that QuickCD does on average about 800% more
triangle intersection tests than RAPID, which is an expensive test. Although, in this
case, they can be optimised since the underlying primitives are triangles. But in the end
the QuickCD was faster than RAPID.
100
80
Bounding Volumes
Rapid
70
60
50
40
30
20
10
0
268
309
336
Number of Contacts
(a)
Triangles
1200%
QuickCD
Ratios 18-dops/OBBs
time to collision (ms)
90
366
1000%
800%
600%
400%
200%
0%
268
309
336
Number of Contacts
366
(b)
Figure 10. (a) Time to find exact collisions using RAPID and QuickCD. (b)
Overhead of an 18-dops versus OBBs approach in terms of percentage of
bounding volumes and triangles intersection tests.
In our last experiment, we have used a real industrial case study from Rolls Royce. A
Fuel Metering Unit is moving into an Oil Pump from the Trent 800 engine, along a path
where the number of contacts change from 28 to 851. These parts are used in the engine
for the Boeing 777.
The Fuel Metering Unit is a component tessellated to 5130 triangles and the Oil Pump
has 23 541 triangles. Figure 11 shows the fuel-metering unit and the oil pump.
Figure 11. The fuel metering unit and the oil pump.
In figure 12 we compare RAPID and QuickCD. In this case, RAPID is faster and at
each time step, it requires on average 26ms to find all collisions, against 38ms by
QuickCD. From the ratios of 18-dops versus oriented bounding boxes, we can see now
that on average the 18-dops require 500% more bounding volume tests and 200% more
triangle intersection tests than the oriented bounding volumes.
Bounding Volumes
90
Rapid
QuickCD
80
Ratios 18-dops/OBBs
time to collision (ms)
Triangles
1200%
100
70
60
50
40
30
20
1000%
800%
600%
400%
200%
10
0
0%
28 117 198 221 240 261 286 525 603 846
Number of Contacts
(a)
28
117
198
221 240 261 286 525
Number of Contacts
603
846
(b)
Figure12. (a) Time to find exact collisions using RAPID and QuickCD for the
industrial case study. (b) Overhead of an 18-dops versus OBBs approach in
terms of percentage of bounding volumes and triangles intersection tests.
6. Conclusions
In this paper we have presented a taxonomy that classifies current collision detection
algorithms for polygonal soups in two classes, based on the representations: spatial
partitioning representations and bounding volume hierarchies.
We have found out that much of the collision detection algorithms that use some spatial
partition representation is supported by octrees. In fact, they were used by several
researchers in both the broad and/or narrow phases to find colliding objects. Its
hierarchical structure adapts well to the environment distribution. Nevertheless, the Rtree structure should be considered more often in the development of collision detection
toolkits. We believe that, in fact, the R-tree n-ary hierarchical structure can be more
effective than other structures for partitioning the 3D space. Moreover, in such
structure, the number of primitives stored equals the number of original ones. This is
important for the performance of the traversal algorithms. On the other hand, the R-tree
is more compact than an octree structure.
We have also compared collision detection toolkits publicly available. In particular, we
could compare different types of bounding volumes hierarchies based on axis-aligned,
discrete orientation polytopes and oriented bounding boxes. We have seen that a
bounding volume hierarchy based on discrete orientation polytopes is faster than one
based on axis-aligned bounding boxes. We also showed that RAPID and QuickCD can
be effectively used interactively. However, we should note that QuickCD current
version allows only one moving object in a virtual environment scenario and does not
report collisions when one object is full inside of another. Nevertheless, their
performace is comparable. In fact, it is difficult to compare collision detection toolkits
and as we could see it is dependent on the type of scenario and application. In future,
some work should be done in order to provide a set of standard testing scenarios that
could be used for comparing different approaches.
Acknowledgements
Mauro Figueiredo is grateful to Calouste Gulbenkian Foundation for financing and
supporting his work. We would like to thank to Rolls Royce for providing the case
study used for these experiments.
References
Ayala, D., Brunet, P., Juan, R. and Navazo, I. (1985) “Object representation by means of
non minimal division quadtrees and octrees”, ACM Trans. Graphics, vol. 4, no. 1, pp.4159.
Beckmann, N., Kriegel, H-P., Schneider, R. and Seeger, B. (1990) “The R*-tree: An
efficient and robust access method for points and rectangles”, In Proc. ACM SIGMOD
International Conference on Management of Data, pp. 322-331.
Bentley, J. (1975) “Multidimensional binary search trees used for associative searching”,
Communicaions of ACM, Vol. 18, No. 9, pp. 509-517.
Bentley, J. and Friedman, J. (1979) “Data structures for range searching”, ACM Computing
Surveys, Vol. 11, No. 4, pp. 397-409.
Brunet, P. and Navazo, I. (1990) “Solid Representation and Operation Using Extended
Octrees”,. ACM Trans. on Graphics, Vol. 9, No. 2, pp. 170-197.
Carlbom, I., Chakravarty, I. and Vanderschel, D. (1985) “A hierarchical data structure for
representing the spatial decomposition of 3D objects”, IEEE Computer Graphics and
Applications, vol. 5, no. 4, pp.24-31.
Chin, N. and Feiner, S. (1989) “Near real time shadow generation using BSP trees”, ACM
Computer Graphics, Vol. 23, No. 3, pp. 99-106.
Chrysanthou, Y. and Slater, M. (1992) “Computing dynamic changes to BSP tree”, In
Computer Graphics Forum (Proc. of Eurographics), Vol. 11, No. 3, pp. 321-332.
Cohen, J., Lin, M., Manocha, D. and Ponamgi, K. (1995) “I-COLLIDE: An Interactive and
Exact Collision Detection System for Large-Scale Environments”, In Proceedings of
ACM Int. 3D Graphics Conference , vol. 1, pp. 189-196.
Duncan, C. A., Goodrich, M. T. and Kobourov, S. G. (2001) “Balanced Aspect Ratio Trees:
Combining the Advantages of k-d Trees and Octrees”, Journal of Algorithms, Vol. 38,
pp.303-309.
Fuchs, H., Kedem, Z. and Naylor, B. (1980) “On visible surface generation by a priori tree
structures”, ACM Computer Graphics, Vol. 14, No. 3, pp. 124-133.
Fussel, D. and Campell, A. (1990) “Adaptive mesh generation for global diffuse
illumination”, ACM Computer Graphics, Vol. 24, No. 3.
Gaede, V. and Gunther, O. (1998) “Multimensional Access Methods”, ACM Computing
Surveys, Vol. 30, No. 2, pp. 170-231.
García-Alonso, A., Serrano, N. and Flaquer, J. (1994) “Solving the collision detection
problem”, In IEEE Computer Graphics and Applications, Vol. 14, No. 3, pp. 36-43.
Gargantini, I. and Atkinson, H. (1993) “Ray Tracing an octree: Numerical Evaluation of the
first intersection”, Computer Graphics Forum, vol. 12, no. 4, pp. 199-210.
Gottschalk, S. (2000) “Collision Queries using Oriented Bounding Boxes”, PhD thesis,
University of North Carolina, Chapel Hill.
Guttman, A. (1984) “R-trees: A dynamic index structure for spatial searching”, In
Proceedings of the ACM SIGMOD International Conference On Management of Data,
pp. 47-57.
Held, M., Klosowski, J. and Mitchell, J. (1995) “Evaluation of Collision Detection Methods
for Virtual Reality Fly-Throughs”, In Proc. Seventh Canadian Conference Computer
Geometry, vol. 3, pp. 205-210.
Hubbard, P. M. (1993) “Interactive collision detection”, In Proc. of IEEE Symposium on
Research Frontiers in Virtual Reality, pp. 24-31.
Hubbard, P. M. (1996) “Approximating polyhedra with spheres for time-critical collision
detection”, ACM Trans. Graphics, Vol. 15, No. 3, pp. 179-210.
Hudson, T. C., Lin, M. C., Cohen, J., Gottschalk, S. and Manocha, D. (1997)
“V_COLLIDE: Accelerated Collision Detection for VRML”, In Proc. of VRML, pp. 119125.
Jiménez, P., Thomas, F., and Torras, C. (2001) “3D Collision Detection: A Survey”,
Computers and Graphics, Vol. 25, No. 2, pp. 269-285.
Kitamura, Y., Ahuja, H. and Kishino, F. (1994) “Coarse to fine collision detection for real
time applications in virtual workspace”, In International Conference on Artificial Reality
and Tele-Existence, pp 147-157.
Klosowski, J., Held, M., Mitchell, J., Sowizral, H. and Zikan, K. (1998) “Efficient Collision
Detection using Bounding Volume Hierarchies of k-DOPs”, IEEE Trans. On
Visualization and Computer Graphics, 4, 1, pp. 21-36.
Kumar, S., Manocha, D., Garret, W. and Lin, M. (1999) “Hierarchical Back-Face
Computation”, In Computers and Graphics, 23, 5, pp. 681-692.
Larsen, E., Gottschalk, S., Lin, M. C. and Manocha, D. (1999) “Fast Proximity Queries with
Swept Sphere Volumes”, Technical report TR99-018, Department of Computer Science,
University of N. Carolina, Chapel Hill.
Lin, M. C. and Gottschalk, S. (1998) “Collision Detection between Geometric Models: A
Survey”, In Proc. of IMA Conference on Mathematics of Surfaces (San Diego (CA)), vol.
1, pp. 602-608.
Moore, M. and Wilhelms, J. (1988) “Collision Detection and Response for Computer
Animation,” Computer Graphics (SIGGRAPH ’88 Proc.), vol. 22, pp. 289-298.
Naylor, B., Amatodes, J. A. and Thibault, W. (1990) “Merging BSP trees yields polyhedral
set operations”, Computer Graphics (SIGGRAPH’90 Proc.), vol. 24, pp. 115-124.
Palmer, I. and Grimsdale, R. (1995) “Collision detection for animation using sphere-trees”,
Computer Graphics Forum, vol. 14, no. 2, pp. 105-116.
Samet, H. (1984) “The Quadtree and Related Hierarchical Data Structures”, ACM
Computing Surveys, Vol. 16, No. 2, pp. 187-260.
Samet, H. and Webber, R. (1988) “Hierarchical data structures and algorithms for computer
graphics, part I: Fundamentals”, IEEE Computer Graphics and Applications, vol. 8, no.
3, pp.48-68.
Samet, H. and Webber, R. (1988) “Hierarchical data structures and algorithms for computer
graphics, part II: Applications”, IEEE Computer Graphics and Applications, vol. 8, no. 4,
pp.59-75.
Smith, A., Kitamura, Y., Takemura, H. and Kishino, F. (1995) “A simple and efficient
method for accurate collision detection among deformable objects in arbitrary motion”,
In Proceedings of the IEEE Virtual Reality Annual Symposium, pp. 136-145.
Thibault, W. and Naylor, B. (1987) “Set operations on polyhedra using binary space
partition trees”, ACM Computer Graphics, Vol. 21, No. 4, pp. 153-162.
Tzafestas, C. and Coiffet, P. (1996) “Real-time collision detection using spherical octrees:
Virtual reality application”, IEEE International Workshop on Robot and Human
Communication.
Van Der Bergen, G. (1997) “Efficient Collision Detection of Complex Deformable Models
using AABB Trees”, In Journal of Graphics Tools, 2, 4, pp. 1-13.
Veenstra, J. and Ahuja, N. (1988) “Line Drawings of Octree-Represented Objects”, ACM
Trans. On Graphics, Vol. 7, No. 1, pp. 61-75.
Zachmann, G. (2000) “Virtual Reality in Assembly Simulation – Collision Detection,
Simulation Algorithms and Interaction Techniques”, PhD thesis, Darmstadt University of
Technology, Germany.
Zyda, M., Osborne, W., Monahan, J. and Pratt, D. (1993) “NPSNET: Real time vehicle
collisions, explosions and terrain modifications”, In The Journal of Visualization and
Computer Animation, Vol. 4, No. 1, pp. 13-24.