- Computer Graphics Bonn

Collision Detection in Densely Packed Fiber
Assemblies with Application to Hair Modeling
Gerrit Sobottka
Ebadollah Varnik
Andreas Weber
Inst. of Computer Science II
Computer Graphics Group
University of Bonn
53117 Bonn, Germany
[email protected]
LuFG Software and Tools for
Computational Engineering
RWTH Aachen University
52056 Aachen, Germany
[email protected]
Inst. of Computer Science II
Computer Graphics Group
University of Bonn
53117 Bonn, Germany
[email protected]
Abstract— In this paper we investigate the application of bounding
volume hierarchies in collision detection among densely packed fiber
assemblies like hair strands or cable looms. In particular, we glance
at collision detection algorithms with sub-quadratic upper bound
and their practicability and performance in complex dynamic hair
scenes. Unlike common collision detection techniques our approach
exploits the topological structure of the underlying filament assembly
and allows for fast hierarchy updates in dynamic deformable scenes.
Furthermore, we compare hierarchies of the wrapped and the layered
type and show the feasibility of fiber based collision detection on full
human hair models. We simulate each fiber of an assembly by means
of Cosserat rod models.
Keywords—collision detection, fiber assemblies, hair modeling,
wrapped / layered hierarchies, C OSSERAT rods
Fig. 1. Left: Photo; Example of a densely packed fiber assembly, section of a
blond hair strand. This strand consists of about 300 single fibers of diameter
≈ 70µm. Right: Simulated fiber assembly; colliding segments are marked
red.
1 Introduction
Our paper is motivated by the need for efficient collision
detection methods for fiber assemblies with high packing
density. Such configurations can be observed in hair strands
or cable looms. A fiber or filament is an one dimensional
deformable structure and can be described by a sequence of
segments where each segment is connected with its successor
at one end point. Although the diameter of a filament is
small compared to the length it is crucially used for collision
detection between two segments.
In densely packed structures like hair strands the probability
for inter-fiber collisions is very high. Thus, we have to deal
with large collision numbers. As long as we do not consider dynamic deformable filaments space partition techniques
like grids [21], octrees [5], kd-trees, and BSP-trees [2] are
sufficient for interference detection. When the filaments of
the assembly are dynamically deformed costly updates are
inevitable. The most common technique are bounding volume
hierarchies [7], [20], [11], [12], [3]. Traditionally, bounding
volume hierarchies encode spatial proximity of the object
features. Hence, they are particularly suitable for collision
detection among rigid objects. Since spatial proximity changes
over time newer hierarchy based approaches exploit topological proximity rather than spatial proximity [8], [13], [10].
Recently Guibas et. al [8] proposed a special kind of
bounding sphere hierarchy for deforming ball sequences (so
called necklaces) which exploits the topological proximity of
the primitives. This sphere hierarchy is a balanced tree whose
leaves correspond to the spheres of the necklace. At each
internal node the minimum bounding sphere of the canonical
sub-necklace is stored. This type of hierarchy wherein spheres
enclose the associated geometry is called wrapped hierarchy.
They prove that for a necklace self-collision detection has a
sub-quadratic upper bound.
Lotan et al. [13] pursue a similar approach for self collision
detection in kinematic chains. A kinematic chain consists of
a set of links which are connected by joints. They employ
a chain-aligned hierarchy of oriented bounding boxes which
are not perfectly tight. A chain-aligned hierarchy encodes
the topological proximity of the links and can be updated
in O(k log nk ) time where k are the degrees of freedom
of the change. In particular, a 1-DOF change—only one
single freedom joint changes—would result in update costs
of O(log n).
James and Pai [10] have picked up the concept of the
wrapped hierarchy by introducing the bounded deformation
trees (BD-Tree). These trees are constructed on polygonal
models and exploit spatially coherent motion that can be
described as a superposition of displacement fields. Each
triangle of the underlying geometry is bounded by a leaf node
sphere. They use a conservative update scheme wherein a
conservative radius and a new center are computed from the
displacement fields describing the deformed state of the model.
Our Contribution: We examine the application of bounding volume hierarchies in collision detection among densely
packed fiber assemblies like hair strands or cable looms. In
particular, the practicability and performance of chain-aligned
hierarchies of the wrapped and the layered type are compared.
We show that suitable built hierarchies of axis aligned
bounding boxes outperform the previously used sphere hierarchies with respect to memory and computation time by
orders of magnitude and can be used for single fiber based
interference detection in hair strands.
2 Collision Detection
The application of bounding volume hierarchies for collision
detection and proximity queries is a common technique [7],
[20], [11], [12], [3]. However, most of these approaches are
limited to the collision interference detection between rigid
objects. If we consider the simulation of deformable objects in
conjunction with the well-established techniques the overhead
for the reorganization of the trees are high. New approaches
like [8], [13], [4], [10] make use of topological proximity
rather than spatial proximity which varies over time in a
dynamic simulation.
Given two BVH’s the standard collision detection algorithm
performs a simultaneous top down traversal of the two trees.
That is, it checks the root boxes for overlapping and if so
proceeds with the children until no overlap occurs or it has
reached the leaves. In case of self-interference detection the
sub-trees of each node have to be tested against each other
recursively. Usually the volumes of the tested cages are taken
as a simple split heuristic to allow for a balanced tree traversal.
Here we are interested in self-interference detection in one
dimensional deformable structures like filaments, chains or
necklaces. A filament is a sequence of segments or very thin
cylinders (compared to the the length of the filament) whereas
a necklace a sequence of closed balls is [8]. In a chain so
called links of arbitrary shape are connected via joints [13].
On an abstract layer we can transform a filament or chain
into a necklace by enclosing the segments or the links with
minimum enclosing spheres.
Self-collision detection of a chain consisting of n links
is a Θ(n2 ) process in the worst-case. Running time can be
improved if further assumptions about the chain are made,
specifically, if the topological proximity of the links is exploited. In this context, one can define a so called well-behaved
chain with the following properties (cf. [9]): a) the ratio of
the radii of largest and the smallest sphere in the necklace
is smaller than a constant, b) there exists a constant such
that for each sphere the concentric ball with radius times
constant does not enclose the center of any other sphere of
the necklace. Then the number of balls intersecting any other
balls is bounded by a constant. For example, molecules are
inherently well-behaved.
2.1 Chain-Aligned and Spatially-Adapted Hierarchies
We utilize chain-aligned bounding volume hierarchies for
collision detection in densely packed fiber assemblies [13], [8].
The chain-aligned hierarchy encodes the chain-wise proximity
of the links in a balanced binary tree. The topological order
of the links is represented by the order of the leaves. Thus,
neighboring nodes encode adjacent parts of the chain (cf.
Fig. 5). In contrast, a spatially-adapted hierarchy bases on the
spatial proximity of the links. Self-collision testing is more
efficient with a spatially-adapted hierarchy at a cost of Θ(n)
time in the worst case [23]. Since spatial proximity varies over
time as the filaments deform the tree has to be updated at each
time step at a cost of O(n log n) [7] but the hidden constants
are large. Normally, this involves costly reorganizations of
the tree whereas the structure of the chain-aligned hierarchy
cannot change. The attempt to maintain a spatially-adapted
hierarchy over several time steps can lead to situations where
Θ(n2 ) overlap tests are needed to check for self-collision.
It was shown by Lotan et al. [13] that in a chain-aligned
hierarchy of a well-behaved chain the maximum number of
4
overlapping boxes is Θ(n 3 ). Hence, the collision detection
4
takes Θ(n 3 ) time in the worst case.
Fig. 2. Assemblies. Left: Close up of blond hair fibers; Right: One of our
collision detection test cases; a C OSSERAT generated hair style consisting of
50,000 hair fibers with 50 segments each.
Fig. 3. A snapshot from our fiber assembly simulation environment. Left:
A guide filament of a simulated fiber assembly is interactively deformed.
Colliding segments are marked red. Right: Cages are displayed.
2.2 Wrapped and Layered Hierarchies
We can distinguish between two types of binary bounding
volume hierarchies: the wrapped and the layered hierarchy [8].
The differences can be explained by means of the spherical
hierarchy: Given a sequence consisting of n spheres B =
(B1 , ..., Bn ) the wrapped spherical hierarchy is a balanced
binary tree where each internal node stores the minimum
enclosing sphere (the so called cage) of all spheres in the
canonical sub-chain. That is, the cage of a node c encloses all
spheres of the necklace which are the leaves of the subtree
rooted at c. The spheres themselves are stored at the leaves.
So, the construction of the wrapped spherical hierarchy is
done in a top-down process by recursively subdividing a given
chain. In contrast, in the layered hierarchy each node stores
the minimum enclosing sphere of the spheres of the two child
nodes.
The independence of the wrapped hierarchy of the bead
order is apparent and results in tighter bounds whereas the
computational effort is much higher as for the layered hierarchy. It √
can be shown, that the radius of the root sphere is
at most h + 1 times the size that of the layered hierarchy
where h = dlog ne is the height of the balanced tree (cf. [8]).
Different kinds of bounding volumes can be used with the
wrapped hierarchy. The efficiency of the construction process
depends on whether one can find an efficient algorithm to
compute the minimum enclosing volume of a set of volumes
of the same type. We will discuss this problem later.
2.3 Bounding Volumes
The first step in building a BV hierarchy is to find a suitable
bounding volume type. So, we briefly discuss the assets and
drawbacks of two of the most popular types and verify their
appropriateness for the filament covering problem.
Fig. 4. Left: A single filament packed into AABB’s. Right: Filament bounded
by wrapped spheres. Note, that the child cages can stick out of the parent
cages.
AABB’s: Axis aligned bounding boxes (AABB) trees are
very popular because of their simplicity but normally displaced
downward by the more efficient OBB trees. The computation
of the AABB of a single segment is straightforward: Take
the two endpoints, subtract the radius from the first point’s
coordinates and add it to the second point’s coordinates. Then
sort the coordinates such that the first point represents the
lower left corner and the second point the upper right corner of
the AABB. So, only six scalars are needed. When we switch to
the arbitrarily orientable OBB the additional freedom requires
storage space for nine further scalars (the orientation matrix
of the OBB).
The side faces of an AABB are always parallel with respect
to the model’s local coordinate system. Thus, in fiber assemblies there exist preferential global orientations, for instance,
if all fibers are parallel to one axis. The more parallel the
fibers are with respect to a coordinate axis the smaller the
AABB’s will be and vice versa. This can benefit a dynamic
strand simulation where deformations are normally small.
As described above a wrapped hierarchy must be constructed in a top-down manner by recursively computing the
bounding volumes for the canonical sub-chains at each node.
In case of AABB’s the construction process simplifies when
we take into account the following lemma (without proof):
L EMMA : Let B = {B1 , B2 , ..., Bn } a sequence of spheres
and Bi,j ⊆ B with 1 ≤ i < j ≤ n an arbitrary
subsequence of B. Then if the minimum enclosing volume
is an AABB the M EV (Bi,j ) is equal to M EV (Bi,j )
= M EV (M EV (Bi,k ) , M EV (Bk+1,j )) where Bi,k and
Bk+1,j are arbitrary subsequences of Bi,j with i ≤ k ≤ j.
Hence, for AABB’s the hierarchies of the layered and the
wrapped type are identical. That is, we can compute the tree
bottom-up in post-order traversal: first the AABB’s of the child
nodes are computed and then we update the parent’s AABB
by union the AABB’s of the two children (cf. Fig. 4). The
construction can be performed at a cost of O(n) time. Note
that the hidden constants are very small (cf. Fig. 8).
Spheres: Sphere trees are the canonical example for BVH’s
[18], [17] because of their simplicity. In particular, Guibas et
al. [8] studied the properties of a wrapped sphere hierarchy.
The problem of finding the minimum enclosing sphere of a
set of balls can be solved by the deterministic algorithm of
Megiddo [15] or the randomized algorithm of Welzl [22] both
with linear expected time. Thus, the wrapped sphere hierarchy
for a set of n balls can be constructed in O(n log n) time. Note,
that the Welzl algorithm hides a large constant of O(δ · δ!)
where δ is k + 1 and k is the dimension of the space in which
the spheres are to be computed. For three-space this constant
becomes apparently large.
When we prefer the layered alternative construction takes
O(n) time. Unfortunately, spheres do not fit the segments
very well and cause much overlapping in arbitrarily oriented
configurations since the size of the spheres are invariant with
respect to the orientation of the filaments (cf. Fig. 4).
Of course, there are other bounding volume types like kDOP’s [11] or ellipsoids which we will omit here for brevity.
They are left as subject of further investigations.
3 Implementation
We implemented both, a chain-aligned wrapped spherical
hierarchy and a chain-aligned AABB hierarchy and compared
the running times for complex static and dynamic fiber assemblies. The software was integrated in our interactive fiber
assembly simulator (cf. Fig. 1, 3) which allows for interactive
fiber deformation based upon a mechanical rod model which
is described later in this section.
For the computation of the minimum enclosing spheres we
employed the algorithm of Welzl [22] (there is an efficient
implementation available, cf. [6]).
3.1 Maintenance of the Hierarchy
The two types of hierarchies require different maintenance
approaches. For the layered hierarchy we can follow a simple
bottom-up strategy as described above: we simply traverse the
tree in post-order and update all bounding volumes. If the
current node is a leaf the bounding volume of the associated
segment is recomputed. First, we have to update the bounding
volumes of the children of a node and then we proceed with
computing the bounding volume of the parent node in O(1)
time. For AABB’s this is simply a union of the two child
AABB’s.
When we switch to the wrapped hierarchy things become
more complicated. Before each self-collision test the correctness of the hierarchy has to be verified in a process called
cascade verification [8]. Since a sphere is determined by one to
four basis spheres these entities have to be stored at the internal
nodes. The idea is to check whether the basis of an internal
node’s cage is still valid or not. Hence, the verification is done
by traversing the tree bottom-up and checking if the leaf-node
spheres of the sub-tree rooted at the current node are still in
the associated cage from the previous time step. If one or more
leaf spheres escaped from the cage it has to be recomputed.
At least one of the escaped leaf spheres constitutes a basis
sphere of the new cage. This knowledge can accelerate the
recalculation of the basis cage if the underlying algorithm
makes use of such information (cf. Welzl [22]). The cascade
verification takes Θ(n log n) time in the worst-case while in
practice the time is closer to linear. The update frequency for
a single cage should be low because the assumption is that the
the basis of a cage stays constant over a long time.
Another question is, if the update process of a chainaligned AABB hierarchy can benefit from the application of
the cascade verification strategy. The answer is no, because
the cascade verification takes Θ(n log n) time in the worstcase whereas the simple bottom-up update scheme described
above is always linear. Furthermore, this would necessitate
the storage of the basis describing the cage associated with
each internal note. Unlike spheres, which are defined by at
most four basis spheres each AABB is defined by one to
six basis AABB’s which have to be stored at each internal
node. This would cause a noticeably increase in the memory
requirements. In contrast, Lotan et al. [13] used a chainaligned hierarchy of OBB’s. In particular, they kept an account
of the actual joint changes of the underlying kinematic chain in
every time step. These additional information allow for search
path pruning.
3.2 The Super Thread
Our main aim is to efficiently detect collision in a dense
bunch of filaments. The expounded approaches, though, are
directed towards self-interference detection in a kinematic
chain or necklace. Such chains can represent backbones of
large protein molecules with a few thousand atoms. Here,
we consider fiber assemblies consisting of a few hundred
filaments with up to 1,000 segments and more which are fixed
at one side. This necessitates a mechanism that prevents the
algorithm from checking each filament against each other. In
this context, we can make the following observation: Hair
strands usually consist of a few hundred single hair fibers.
They adhere together by friction or lipids so that the whole
hair strand behaves stiff to some degree. That is, fibers do not
move loosely like in a bunch of ropes but the global movement
of all points on the fibers are similar.
Fig. 5. Super thread: All filaments of an assembly are connected by a virtual
cord.
Motivated by these observations we treat the whole assembly as one big winding filament or super thread (cf.
Fig. 5). To accomplish this all filaments in our model have the
same length and the same number of segments. The filament
number as well as the segment number are stored with the
corresponding leaf node.
The super thread is obtained by threading a virtual cord
through the filaments. Then filament (i) is connected with
filament (i+1) at the tip and filament (i+1) is connected with
filament (i + 2) at the root and so forth. This link-up scheme
results in gaps between the end points. The size depends on
how close the connected end points are. Note, that we do
not really insert segments or connecting something. This is
only the direction of the traversal when we build up or update
our tree. Furthermore, we do not perform a nearest neighbour
search to decide which fiber end points to connect. The order
solely depends on the sequence of generation.
3.3 Strand Generation
To allow for interactive fiber deformation within our interactive assembly simulator and to generate non-interactive test
cases we use a mechanical rod model, the C OSSERAT model
[1]. The initial configuration of each filament is straight. We
apply the static C OSSERAT model to dynamically deform the
fibers of the hair strand. The advantage over a pure geometrical
deformation approach is that we obtain a continuous deformation for every load in consideration of authentic material
properties of the simulated filaments. By the application of
proper force-torque pairs at the end points we can deform the
filaments to the desired shape.
To model a single filament it is convenient to describe its
geometry in terms of a space curve r(s) with arc length s
(0 ≤ s ≤ L, length L). In particular, we are interested in the
equilibrium configuration of the filament under an external
load. The static equilibrium of a long thin rod is governed by
the well-known C OSSERAT equations [1], [14]:
dn
+f =0
ds
and
dm dr
+
× n + g = 0.
ds
ds
The vectors n and m are the resultant contact force and
torque transmitted at the cross sectional area, f are the external
forces acting on the rod, dr/ds is the tangent vector to
the curve and g are the external torques. To describe the
kinematics of the curve it is convenient to equip the curve
with a set of right handed orthonormal triads {di (s)} each
expressed by a rotation matrix. It can (but need not) be chosen
to be the Frenet frame (i.e., each triad is given by the normal,
binormal, and the tangent). The change of the frame with
respect to the curve parameter s is governed by d0i = u × di
where u is the Darboux vector expressing the rotational
strains. One can introduce an analogous vector v(s) = dr/ds
describing the linear strains of the filament. Both the Darboux
vector u and v can be thought of as angular and linear velocity
of an evolving triad when the curve parameter s is taken as
time. They should always be considered in conjunction with
corresponding reference strains û and v̂ characterizing the
reference configuration or undeformed state of the filament
which is always straight in our case. The stresses m and n are
related to the strains by constitutive laws. We use the simplest
possible relations given by m = K(u − û) and n = I(v − v̂)
where K and I are material dependent quantities.
The filaments we consider herein are fixed at one end, i.e.,
the position and orientation at s = 0 are given whereas for the
opposite (movable) end (s = L) a force and torque is specified.
One approximate solution algorithm to this boundary value
problem is described in [16].
To test stability of the hierarchies under dynamic conditions
we applied a series of force-torque pairs to the end point of
each filament which was prerecorded from an interactively
deformed guide filament. These sequences are replayed with
the strand configuration of the dynamic test cases (cf. Sec. 4).
The roots of the fibers of the assemblies are distributed
randomly over an elliptical area with a given density of 325
points/cm2 . This corresponds with the measured average hair
density on a human scalp [19].
4 Results
We used our assembly simulator for performance testing of
the two types of hierarchies and ran several tests on a Pentium
Fig. 6. A C OSSERAT generated strand consisting of 500 filaments of length
30 cm with 2,000 segments each. Right: The same tress with collisions marked
red.
IV, 2.4 GHz machine. Specifically, we consider four different
test cases:
1) Static assembly test: we created a fiber assembly and
increased the number of fibers from 50 up to 1,000 at
100 segments per fiber. We have chosen the filaments
of the assembly to have the same length and the same
number of segments. Therefore, all bounding volumes
on the filament level are of the same size.
2) Dynamic assembly test: here we consider a fiber assembly with a fixed number of filaments which is
dynamically deformed. Of course, for large segment
numbers this cannot be done interactively because of
long collision detection and deformation computation
times. To circumvent this problem we use prerecorded
force trajectories of an interactively deformed guide
filament which are superposed with a slight random
variation and then are applied to all filaments of the
assembly. We tested a small assembly of 150 filaments
with 100 segments each. Starting from an initially
straight configuration, i.e., all fibers are in parallel the
assembly is deformed to a loop in 100 deformation steps
(cf. Fig. 3).
3) Half scalp test: As a more complex example we generated a hair style consisting of 50,000 filaments (50
segments each) which covered one half of a human head
model (cf. Fig. 2). To our knowledge this is the first
approach on fiber based collision detection on a real
hair model.
4) Strand test: Here we consider a (typical) helical strand of
length 30 cm with 500 (1,000) filaments and a very high
sampling rate of 0.15 mm (2,000 segments, cf. Fig. 6).
Note, that this equals two times the human hair diameter
(0.007 cm).
4.1 Running-Times
In case of the wrapped spherical hierarchy as well as
the chain-aligned AABB-hierarchy we measured the running
times for construction, update, and collision detection. The
measurement results for the static test configuration with
varying number of segments are depicted in Fig. 7 to Fig. 9.
The costs for construction of the AABB hierarchy as well
as the update solely depend on the number of segments in the
super thread (cf. Fig. 7). In contrast, the collision detection
times heavily vary subject to the configuration. Clearly, the
more the filaments are in parallel with the coordinate axes
the faster the collision detection is. Normally, the fiber’s mean
axis is in parallel to one global axis. To avoid preferential
initial configurations we simply rotate the whole assembly
by π4 about two global axes. So the AABB’s take up their
maximum volume. Furthermore, the application of the prerecorded loads to each fiber results in an additional overall
deformation of the originally straight assembly.
As depicted in Fig. 9 collision detection with the AABB
hierarchy is consistently faster than with the wrapped spherical
hierarchy. The diagrams for the update and cascade verification
of the spherical hierarchy show peaks for certain segment
numbers. These profound oscillations must be ascribed to
the application of the randomized algorithm of Welzl [22]
for minimum enclosing sphere computation. Specifically, the
algorithm needs more time to compute the bounding volumes
of 55,000 segments than for 95,000 segments (cf. Fig. 7).
Updates with the chain-aligned AABB hierarchy are very
fast (cf. Fig. 8), since they linearly depend on the number
of segments. For example, for the super thread from a hair
tress (cf. Fig. 6) consisting of 1,000 filaments with a length of
30.0 cm and 2,000 segments each (= 2 × 106 segments) the
hierarchy update takes 300 ms. Detecting the 23,000 implicit
collisions in this assembly takes 1.7 secs. We doubled the
number of filaments in the hair tress to 2,000. Update took
600 ms as expected, the detection of 80,000 implicit collisions
took 4.3 secs with the AABB-hierarchy. For the half scalp
model it takes 100 secs. to find all 550,000 collisions whereas
the the wrapped spherical hierarchy needs 2, 000 secs. (cf.
Tab. I).
For the dynamic case we can observe a strong correlation
between the number of collisions found in each simulation
step and the corresponding collision detection times (results
of the dynamic test case are depicted in Fig.10). This is due
to the output sensitivity of the collision detection process. As
can be seen the update times are independent of the underlying
geometry and constitute a stable base line (the slight variations
are caused by the operating system).
5 Conclusion and Future Work
We have shown that collision detection for densely packed
fiber assemblies is possible on standard PC’s with passable
effort up to a complexity in the number of fibers and the
geometric settings that resemble human hair strands or even
Half scalp:
SPW
CABB
Strand:
SPW
CABB
Construction
[s]
Update
[s]
Detection
[s]
4.609
4.109
1924.74
0.766
1984.78
100.531
2.907
2.781
91.923
0.281
15.282
1.688
TABLE I
C OLLISION DETECTION
STATISTICS FOR CASE
SPHERICAL HIERARCHY;
3 AND 4; SPW: W RAPPED
ABB: C HAIN - ALIGNED AABB HIERARCHY.
the entire human scalp. Thus contrary to the common belief
that fiber based hair simulation is impossible we have shown
the feasibility of this approach in one important part of the
entire problem consisting of simulation, collision detection,
collision response and visualization.
Of course the integration of appropriate collision response
mechanisms—such as an adaption of the methods used for
cloth-modeling [3] into the context of hair modeling—is a
remaining challenge.
Fig. 7. Running times for the construction of the wrapped spherical hierarchy
and the chain-aligned AABB hierarchy.
References
[1] Stuart S. Antman. Nonlinear Problems of Elasticity, volume 107 of
Appl. Math. Sci. Springer-Verlag, Berlin and New York, 1995.
[2] Sigal Ar, Gil Montag, and Ayellet Tal. Deferred, self-organizing bsp
trees. In Proceedings of the EUROGRAPHICS 2002, volume 21(3),
2002.
[3] R. Bridson, R. Fedkiw, and J. Anderson. Robust treatment of collisions,
contact and friction for cloth animation. In SIGGRAPH 2002, ACM
TOG 21, pages 594–603, 2002.
[4] Joel Brown, Jean-Claude Latombe, and Kevin Montgomery. Real-time
knot tying simulation. The Visual Computer, 20(2):165–179, 2003.
Fig. 8. Running times for the cascade verification of the wrapped spherical
hierarchy and the update of the chain-aligned AABB hierarchy.
Fig. 9. Times for collision detection using the wrapped spherical hierarchy
and the chain-aligned AABB hierarchy.
[5] F. Ganovelli, J. Dingliana, and C. O’Sullivan. BucketTree: Improving
collision detection between deformable objects. In SCCG2000 Spring
Conf. on Comp. Graphics, 2000.
[6] Bernd Gärtner and Sven Schönherr. Smallest enclosing ellipses - fast
and exact.
[7] S. Gottschalk, M. C. Lin, and D. Manocha. OBBTree: A hierarchical
structure for rapid interference detection. In Proceedings of the 23rd
annual conference on Computer graphics and interactive techniques,
pages 171–180, 1996.
[8] Leonidas Guibas, An Nguyen, Daniel Russel, and Li Zhang. Collision
detection for deforming necklaces. In Proceedings of the eighteenth
annual symposium on Computational geometry, pages 33–42, 2002.
[9] Dan Halperin and Mark H. Overmars. Spheres, molecules, and hidden
surface removal. In Symposium on Computational Geometry, pages 113–
122, 1994.
Fig. 10. Running times for update and collision detection with the chainaligned AABB hierarchy in a dynamic deformable scene (150 fibers with 100
segments each are deformed from a straight configuration to a loop). The third
curve indicates the number of collisions found in each deformation step.
[10] Doug L. James and Dinesh K. Pai. BD-Tree: Output-sensitive collision detection for reduced deformable models. ACM Transactions on
Graphics (SIGGRAPH 2004), 23(3):3–18, 8 2004.
[11] J.T. Klosowski, M. Held, J.S.B. Mitchell, H. Sowizral, and K. Zikan.
Efficient collision detection using bounding volume hierarchies of kDOPs. In IEEE Transactions on Visualization and Computer Graphics,
volume 4(1), March 1998.
[12] Thomas Larsson and Tomas Akenine-Möller. Collision detection for
continuously deforming bodies. In Proceedinsg of Eurographics, short
presentations, pages 325–333, 2001.
[13] Itay Lotan, Fabian Schwarzer, Dan Halperin, and Jean-Claude Latombe.
Efficient maintenance and self-collision testing for kinematic chains.
In Proceedings of the eighteenth annual symposium on Computational
geometry, Barcelona, Spain, pages 43–52, 2002.
[14] John Maddocks. Mathematical modelling of DNA, course notes, 2001.
http://lcvmwww.epfl.ch/
[15] Nimrod Megiddo. Linear-time algorithms for linear programming in
R3 and related problems. In Proc. 23rd Annu. IEEE Sympos. Found.
Comput. Sci., pages 329–338, 1982.
[16] Dinesh K. Pai. STRANDS: Interactive simulation of thin solids using
Cosserat models. In Computer Graphics Forum, volume 21(3), pages
347–352, 2002.
[17] I.J. Palmer and R.L. Grimsdale. Collision detection for animation using
sphere-trees. In Computer Graphics Forum, volume 14(2), pages 105–
116, 1995.
[18] Sean Quinlan. Efficient distance computation between non-convex
objects. In IEEE Int. Conference on Robotics and Automation, pages
3324–3329, 1994.
[19] C.R. Robbins. Chemical and Physical Behavior of Human Hair.
Springer-Verlag, New York, 4. edition, 2002.
[20] Gino van den Bergen. Efficient collision detection of complex deformable models using aabb trees. Journal of Graphics Tools, 2(4):1–14,
1997.
[21] Kelly Ward and Ming C. Lin. Adaptive grouping and subdivision for
simulating hair dynamics. In Proc. of Pacific Graphics, 2003.
[22] Emo Welzl. Smallest enclosing disks (balls and ellipsoids). In H. Maurer,
editor, New Results and New Trends in Computer Science, number 555
in LNCS, pages 359–370. Springer, August 1991.
[23] Yunhong Zhou and Subhash Suri. Collision detection using bounding
boxes: Convexity helps. In Algorithms - ESA 2000, 8th Annual European
Symposium, pages 437–448, 2000.