Bounded normal trees for reduced deformations of triangulated surfaces.
ABSTRACT Several reduced deformation models in computer animation, such as linear blend skinning, pointbased animation, embedding in finite element meshes, cagebased deformation, or subdivision surfaces, define surface vertex positions through convex combination of a rather small set of linear transformations. In this paper, we present an algorithm for computing tight normal bounds for a surface patch with an arbitrary number of triangles, with a cost linear in the number of governor linear transformations. This algorithm for normal bound computation constitutes the key element of the Bounded Normal Tree (BNTree), a novel culling data structure for hierarchical selfcollision detection. In situations with sparse selfcontact, normalbased culling can be performed with a small outputsensitive cost, regardless of the number of triangles in the surface.

Article: Rapid collision detection for deformable objects using inclusionfields applied to cloth simulation
[Show abstract] [Hide abstract]
ABSTRACT: We introduce an inclusionfield technique for fast detection of collisions between a highly deformable object and another object with limited deformations. We mainly target the cloth simulation application where cloth (highly deformable) collides with deforming skin of a moving human model (has limited deformation as skin stretches and compacts within finite spacial and temporal limits specified by the bending angle and speed). Our technique intermixes concepts from space voxelization and distance fields to make use of the limited deformation nature of human skin. The technique works by discretizing the space containing the object into cells, and giving each cell an inclusion property. This property specifies whether this cell lies inside, outside, or on the surface of the deforming object. As the object deforms, the cells’ inclusion properties are updated to maintain the correctness of the collision detection process. We tested our technique on a generally deforming Bezier surface, and on cloth simulation to detect collisions between cloth and several articulated and deforming human body parts. Results showed that the inclusion field allows realtime collision detection between cloth and limited deformable objects on a standard PC. The technique is simple and easy to implement.Journal of Advanced Research. 01/2012; 3(3):245252.  [Show abstract] [Hide abstract]
ABSTRACT: This paper presents a method of selfintersection detection and resolution for dynamic cylindricallatticebased freeform deformation (FFD). The latticebased approach allows efficient computation of deformation of complex geometries. But excessive deformation can cause visual anomalies such as surface infiltration and distortion. This paper derives a geometrically intuitive sufficient condition to guarantee that the FFD function is a homeomorphism and there is no selfintersection. The FFD function is defined by linear and quadratic BSpline functions with the control points of the cylindrical lattice cell. The sufficient condition is satisfied if each trilinear function of the nine prismshaped pentahedrons derived from the cell has a positive Jacobian determinant. The positivity is satisfied if the 12 tetrahedrons derived from the pentahedron have positive volumes. Based on the sufficient condition, the proposed method converts the selfintersection problem into a pointface collision detection and response problem suitable for dynamic simulation. The efficiency and accuracy of the selfintersection detection algorithm is analyzed and compared with a previous method. The results show that the proposed technique allows simulation of excessive deformation of tubular objects in an efficient and realistic manner.IEEE transactions on visualization and computer graphics. 04/2011; 17(4):51526.  [Show abstract] [Hide abstract]
ABSTRACT: In this paper, we accelerate selfcollision detection (SCD) for a deforming triangle mesh by exploiting the idea that a mesh cannot self collide unless it deforms enough. Unlike prior work on subspace selfcollision culling which is restricted to lowrank deformation subspaces, our energybased approach supports arbitrary mesh deformations while still being fast. Given a bounding volume hierarchy (BVH) for a triangle mesh, we precompute Energybased SelfCollision Culling (ESCC) certificates on boundingvolumerelated submeshes which indicate the amount of deformation energy required for it to self collide. After updating energy values at runtime, many boundingvolume selfcollision queries can be culled using the ESCC certificates. We propose an affineframe Laplacianbased energy definition which sports a highly optimized certificate preprocess, and fast runtime energy evaluation. The latter is performed hierarchically to amortize Laplacian energy and affineframe estimation computations. ESCC supports both discrete and continuous SCD with detailed and nonsmooth geometry. We observe significant culling on many examples, with SCD speedups up to 26X.ACM Transactions on Graphics  TOG. 01/2012;
Page 1
Eurographics/ ACM SIGGRAPH Symposium on Computer Animation (2009)
E. Grinspun and J. Hodgins (Editors)
Bounded Normal Trees for Reduced Deformations
of Triangulated Surfaces
SaraC. Schvartzman, Jorge Gascón & MiguelA. Otaduy
URJC Madrid, Spain†
Abstract
Several reduced deformation models in computer animation, such as linear blend skinning, pointbased anima
tion, embedding in finite element meshes, cagebased deformation, or subdivision surfaces, define surface vertex
positions through convex combination of a rather small set of linear transformations. In this paper, we present
an algorithm for computing tight normal bounds for a surface patch with an arbitrary number of triangles, with
a cost linear in the number of governor linear transformations. This algorithm for normal bound computation
constitutes the key element of the Bounded Normal Tree (BNTree), a novel culling data structure for hierarchical
selfcollision detection. In situations with sparse selfcontact, normalbased culling can be performed with a small
outputsensitive cost, regardless of the number of triangles in the surface.
1. Introduction
Selfcollision refers to the intersection of an object’s sur
facewithitself.Selfcollisionposesanimportantcomplexity
challenge onto typical acceleration data structures for col
lision detection, because pairs of geodesically nearby sur
face primitives cannot be efficiently pruned away. Many
applications in computer animation, such as cloth anima
tion [BFA02], character skinning [LCF00], or softtissue
cutting [SOG06], are likely to exhibit selfcollision phenom
ena, hence the importance of efficient solutions.
In this work, we address selfcollision detection of sur
faces with a high triangle count that are deformed through
their embedding in a reduced deformation field with rel
atively few degrees of freedom. In particular, we address
reduced deformations where the position of each surface
vertex is defined as a convex combination of linear trans
formations. This type of reduced deformation has multi
ple examples in computer animation: (i) character defor
mation through linear blend skinning or skeleton subspace
deformation [LCF00], (ii) cagebased deformation using
convex basis functions [JMD∗07], (iii) embedding in low
resolution finiteelement meshes, (iv) subdivision surfaces
applied, e.g., to postprocessing cloth animation [BFA02],
or (v) pointbased animation [MKN∗04].
†http://www.gmrv.es/Publications/2009/SGO09/
Ourworkcomplementshierarchicalcollisiondetectional
gorithms, in particular the approach for selfcollision detec
tion of Volino and MagnenatThalmann [VMT94]. Their al
gorithm computes in a bottomup fashion a tree of bounding
volumes and normal bounds, and executes selfcollision de
tection by topdown traversal of the tree. In this paper, we
present two main contributions:
1. We have designed a novel algorithm for efficient computa
tion of normal bounds (See Section 3). Given a patch with n
triangles whose vertices are defined by convex combinations
of m linear transformations, our algorithm computes a tight
normal bound with cost O(m). On dense surface patches
with n ? m, our algorithm produces large speedups. As a
substep of the algorithm, we compute efficient bounds of the
deformation gradient of a patch.
2. We have incorporated our efficient evaluation of normal
bounds into an algorithm for selfcollision detection (See
Section 4). We refer to it as Bounded Normal Tree (BN
Tree). The algorithm employs ondemand update of nor
mal bounds and exploits temporal coherence through front
caching with conservative ascent.
2. Related Work
Bounding volume hierarchies (BVHs) [GLM96] have long
been used as acceleration data structures for collision
c ? The Eurographics Association 2009.
Page 2
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
Figure 1: From left to right: 13041vertex cloth computed using Loop subdivision; 231vertex control mesh; selfcollisions
shown in red; normal test front of the BNTree; and normal test front using stateoftheart hierarchical selfcollision detec
tion [VMT94]. In the colorcoded test front, blue means that selfcollisions are pruned high in the tree, while red means that the
tests reach the leaves. With bluish color, normal bounds are computed high in the BNTree, leading to high efficiency.
detection. When applied to general deformation models,
BVHs are updated in a bottomup manner every simulation
frame [dB97]. If the choice of bounding volumes (BVs) is
one of spheres, AABBs, or kDOPs, the cost of the update
is linear in the number of vertices, with constant cost per
BV. However, deformation models with far fewer degrees of
freedom than the number of vertices potentially allow for
sublinear update of BVs high in the hierarchy, and thereby
efficient interruptible collision detection [Hub95], or even
sublinear cost for exact collision detection.
As mentioned in the introduction, selfcollision detection
poses an additional complexity, because geodesically nearby
surface primitives cannot be easily pruned away. Most of the
research on selfcollision detection has targeted cloth anima
tion. Volino and MagnenatThalmann [VMT94] presented a
hierarchical algorithm that exploits normal and contour con
ditions for pruning large surface patches (See more details
in Section 4.1). Their algorithm incurs an O(n) cost for up
dating the hierarchy. Their initial approach employed dis
crete normal cones, while Provot [Pro97] used actual cones.
Baciu and Wong [BW02] adopted many of these ideas into
a parallel algorithm and implemented it on graphics hard
ware. Mezger et al. [MKE03] used oriented inflated kDOPs
together with other heuristics. Govindaraju et al. [GKJ∗05]
proposed a chromatic decomposition of a triangle mesh in
order to circumvent adjacencyrelated problems. More re
cently, Tang et al. [TCYM08] have incorporated additional
adjacencyrelated optimizations, as well as an extension of
Volino’s normal criterion to the continuous collision de
tection setting. Selfcollision detection has also been ad
dressed with other data structures and algorithms, such as
spatial partitioning data structures optimized through hash
ing [THM∗03] or visibilitybased culling [GRLM03]. Hier
archies of normal cones have been used for culling in other
problemssuchasgeneralproximityqueries[JC01],andhalf
space intersections (which are somewhat more involved but
related to normal cones) have been used for hierarchical
backface culling [KMGL99]. The dynamic update of nor
mal cones is easily computed as a rotation under rigid trans
formations, but general deformations require visiting each
and every triangle bounded by the cone.
Several researchers have designed collision detection al
gorithms with a potentially sublinear cost on the number of
vertices, for deformation models governed by few degrees
of freedom. Larsson and AkenineMöller [LAM03] applied
those ideas to morphing, while Klug and Alexa [KA04]
later improved them for linearly interpolated shapes. James
and Pai [JP04] introduced the BDTree, an efficient sphere
tree for bounding surfaces described by linear combina
tion of a few degrees of freedom. The BDTree was orig
inally applied to reduced deformable models, and other
extensions of spheretrees have been applied to FEM de
formations on coarse meshes [MO06], geometric deforma
tions through shape matching [SBT06], or meshless anima
tions [AKP∗05].
Kavan and Zara [KZ05] computed efficient BVs for
skinned articulated bodies, with each surface vertex defined
by a convex combination of rigid transformations. Given
m rigid transformations, they found a set of limited con
vex combinations defined by a set of O(m2) corners in IRm.
Then, finding the bound of a surface patch, regardless of
the number of vertices, had a cost O(m2). The use of lim
ited convex combinations has been extended to spherical
blend skinning [KOZ06] and FEM deformations on coarse
meshes [OGRG07]. Steinemann et al. [SOG08] found a
way to compute bounds more efficiently, by identifying ex
treme corners with cost O(m). Their algorithm was initially
used on pointbased animations, but it is applicable to any
deformation defined through convex combination of linear
transformations. Approaches for bound computation based
on limited convex combinations are not directly applicable
to the computation of normal bounds, as surface normals
are quadratic in vertex positions. One may then think of
augmenting the coordinate set to include quadratic position
terms, but this would lead to an explosion into O(m2) prod
ucts of the original linear transformations.
Our work is perhaps closest in spirit to the one of Grin
spun and Schröder [GS01], who proposed a computation of
c ? The Eurographics Association 2009.
Page 3
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
interference of subdivision surfaces by efficient evaluation
of normal bounds. Their work differs from ours, however,
both in the method and its target application. Theirs exploits
bounds of partial derivatives of the eigenvectors of subdivi
sion matrices and is applicable to the limit surfaces produced
by subdivision schemes. Ours, on the other hand, exploits
bounds of a triangle’s deformation gradient and is applica
ble to triangle meshes defined through convex combination
of arbitrary linear transformations.
3. Efficient Normal Bounds
In this section, we describe our main contribution: An effi
cient method to compute a normal bound for a surface patch
S with n triangles, whose vertices are defined through con
vex combinations of m linear transformations. The normal
bound of S is computed with a cost O(m), for a general case
where the number of transformations, m, is much smaller
than the number of triangles n.
The naïve approach to solve this problem would be
to define transformed normals using the cross product of
edge vectors, i.e., n = (a − b) × (a − c), bound the vari
ous operands of this expression for all triangles in the patch,
and then bound the cross product operation using interval
arithmetic. However, edge vectors are not spatially coherent
across triangles, hence bounding this expression yields typi
cally a useless normal cone that spans the complete sphere.
Assuming spatially coherent triangle normals in the unde
formed state, together with spatially coherent convex trans
formation weights, our approach for computing a bound of
the normal will be the following: We will define the normal
of each deformed triangle through an operation composed
by spatially coherent operands; we will bound the normal
of all triangles in the patch S by first bounding the spatially
coherent operands, and then bounding their composition.
In the rest of this section, we describe first the expression
we use for defining transformed normals, based on a trian
gle’s deformation gradient. Hence, next we describe how to
formulate a triangle’s deformation gradient using spatially
coherent operands. Finally, we discuss the runtime compu
tation of bounds for the deformation gradient and the nor
mals for a surface patch.
3.1. Transformed Normals
Barr [Bar84] devised an expression for transforming the nor
mal of a smooth surface given the deformation gradient J.
The deformation gradient is constant inside a triangle, hence
the reststate normal of a triangle, n0, can be transformed
using Barr’s expression as
n = Mn0= detJ·J−Tn0.
With a columnwise expression of J = (j1 j2 j3), the trans
formation can be more easily computed as
(1)
M = (j2×j3 j3×j1 j1×j2).
(2)
There are other alternatives for defining the deformed nor
mal, such as using the cross product of triangleedge vectors,
or the cross product of surface partial derivatives. However,
neither of them is well suited in our case. Triangleedge vec
tors are not spatially coherent, as discussed above, and the
partial derivatives cannot be obtained from an analytic ex
pression for a triangulated surface. The use of Barr’s expres
sion, however, decomposes the computation of the normal
into operands that are indeed spatially coherent: (i) the input
normal and (ii) the deformation gradient.
The deformation gradient is not uniquely defined for a tri
angle. Botsch et al. [BSPG06] discuss extensively this issue,
and they propose the following formula, which depends only
on the initial and deformed positions of the triangle vertices.
Given initial vertex positions {a0,b0,c0} and deformed po
sitions {a,b,c}, they define the deformation gradient
J =?
G =
The rows of the matrix G represent the gradients of a trian
gle’s basis functions.
abc
0
1
?G,
(3)
1
0
0
0
0
−1
−1
?
(a0−c0)(b0−c0)
n0
?−1.
We have considered other alternatives for computing the
deformation gradient, such as using a fourth point per trian
gle, as done by Sumner et al. [SP04]. However, the choice of
fourth point is not straightforward, and this alternative tends
to suffer from amplification due to the inverse of badly con
ditioned matrices, which negatively affects the computation
of bounds. We obtained the best results with our approach.
3.2. Transformed Points
To calculate the new positions of the vertices we will assume
they are defined as a convex combination of governor linear
transformations:
p =∑wk(Akp0+tk).
This assumption applies to the deformation models dis
cussed in the Introduction, such as subdivision surfaces
(with control points as governors), linear blend skinning
(with bones as governors), or pointbased animation (with
particles as governors). Convex combinations imply that
0 ≤ wk≤ 1 and ∑wk= 1.
Instead of directly using the above expression for defining
vertex positions, we employ their relative position w.r.t. the
centroid of the patch. Specifically, we express the reststate
vertex positions as p0=∆p+x0, with x0the reststate patch
centroid. The transformation of the centroid can be extracted
from Eq. (4), which yields modified translations¯tk=Akx0+
tk. Altogether, the transformed vertex positions can be then
defined as
p =∑wk(Ak∆p+¯tk).
(4)
(5)
c ? The Eurographics Association 2009.
Page 4
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
Using relative vertex positions leads to tighter bounds for
the deformation gradient, as the norm of the values under
consideration becomes smaller. This is especially relevant
for the term Jkto be defined later in Eq. (15).
3.3. Decomposition of the Deformation Gradient
We decompose the deformed position of a vertex p into three
different terms: patch deformation pp, triangle deformation
pt, and vertex deformation pv:
p = pp+pt+pv.
(6)
These three terms, which we define in detail below, carry the
following information. The patchdeformation term captures
the perpatch average deformation of all triangles. Given the
remaining deformation, the triangledeformation term cap
tures the average deformation for the three vertices in a trian
gle. And the vertexdeformation term captures the remaining
intriangle deformation. The decomposition of vertex posi
tions leads to an analogous decomposition of the deforma
tion gradient,
J = Jp+Jt+Jv.
(7)
This decomposition favors the computation of tight bounds.
3.3.1. Patch Deformation
For each patch, we compute an average linear transforma
tion Apand an average translation tp. Then, we express the
governor transformations as Ak= Ap+∆Ak,¯tk= tp+∆tk.
Thanks to the properties of convex weights, we can extract
the patchdeformation term from Eq. (5):
p = pp+∑wk(∆Ak∆p+∆tk),
with pp= Ap∆p+tp.
(8)
From Eq. (3), and substituting the contribution to vertex
positions due to patch deformation, we can now define the
patch deformation gradient for a triangle,
Jp=?
The contribution of the translations cancels out because the
gradients of the basis functions (i.e., the rows of G) add up
to zero. Then, the patch deformation gradient can be sum
marized as:
Jp= ApJ0, with J0=?
3.3.2. Triangle Deformation
Ap∆a+tp
Ap∆b+tp
Ap∆c+tp
?G.
(9)
∆a
∆b
∆c
?G.
(10)
For each trianglegovernor pair, we define an average weight
¯ wkas the mean of the weights of that governor for the three
vertices of the triangle. By separating the average weight in
Eq. (8), we can also separate the triangle and vertex defor
mation terms:
pt=∑¯ wk(∆Ak∆p+∆tk),
pv=∑(wk− ¯ wk)(∆Ak∆p+∆tk).
(11)
(12)
By plugging the triangledeformation terms into the defi
nition of the gradient, Eq. (3), we obtain the triangle defor
mation gradient. The use of average weights simplifies this
deformation gradient in two ways. First, since we use aver
ageweights,thetransformationsofthethreetrianglevertices
are the same. Second, the use of average weights together
with the fact that the basisfunction gradients add up to zero,
cancel out the contribution of the translation. Altogether, the
triangle deformation gradient can be expressed as
Jt= AtJ0, with At=∑¯ wk∆Ak.
(13)
3.3.3. InTriangle Vertex Deformation
The remaining intriangle vertex deformation, pv, defined in
Eq. (12), yields the following term of the deformation gradi
ent by substitution into Eq. (3):
Jv=∑(∆Ak∆tk)Jk,
?
The intriangle deformation gradient is not spatially coher
ent, hence it is crucial to minimize its magnitude. This is
achieved by using vertex positions relative to the patch cen
troid, as discussed in Section 3.2, together with extracting
the average transformations.
(14)
?
Jk=
(wak− ¯ wk)∆a
wak− ¯ wk
(wbk− ¯ wk)∆b
wbk− ¯ wk
(wck− ¯ wk)∆c
wck− ¯ wk
G.
3.4. Bounding the Deformation Gradient
Substituting the various terms of the deformation gradient
into Eq. (7), we obtain the complete decomposed expression
for one triangle’s deformation gradient:
J =?Ap+At
In this expression, the terms J0, At, and Jkvary across the
trianglesinapatch.Withspatiallycoherentweights,theterm
Atvaries smoothly across triangles. With spatially coherent
reststate normals, the term J0varies smoothly across tri
angles as well. The term Jkdoes not vary smoothly, but its
magnitude is small compared to the other terms, as it de
pends only on intriangle variations.
?J0+∑(∆Ak∆tk)Jk.
(15)
We bound the deformation gradient in a patch by bound
ing separately the various variable terms. We represent with
[x] a variable that bounds each element of x with an inter
val. Then, applying interval arithmetic, we can compute the
bound of the deformation gradient as
[J] =?Ap+[At]?[J0]+∑(∆Ak∆tk)[Jk].
We precompute the bounds [J0] and [Jk] by simply bound
ing the pertriangle values as a preprocess. The bound of tri
angle average transformations, [At], needs to be computed at
runtime. Since the average weights ¯ wkare convex, bound
ing Atreduces to a problem of bounding convex combina
tions of linear transformations. We apply the algorithm of
Steinemann et al. [SOG08], which exploits limited convex
combinations with efficient evaluation of extreme corners,
(16)
c ? The Eurographics Association 2009.
Page 5
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
and bounds Atwith cost O(m), with m the number of trans
formations.
3.5. Bounding the Transformed Normals
For each patch, we precompute a bound of reststate nor
mals, [n0]. Then, following Eq. (1) and Eq. (2), and given
the bound of the deformation gradient [J], we compute the
normal bound of a patch using interval arithmetic as
[n] = ([j2]×[j3] [j3]×[j1] [j1]×[j2])[n0].
The normal bound [n] described above can be regarded as an
axisaligned bounding box. Other possible representations
include a normal cone defined by an axisangle pair.
(17)
4. SelfCollision Detection Using BNTrees
Normal bounds for hierarchical selfcollision detection were
introduced by Volino and MagnenatThalmann [VMT94].
In this section, we present a modified version of their al
gorithm, called the Bounded Normal Tree (BNTree), that
computes normal bounds ondemand using the efficient al
gorithm presented in the previous section. We pay special
attention to the elementary selfcollision test based on nor
mal bounds, and the traversal and update of the tree.
4.1. Elementary SelfCollision Test
The algorithm of Volino and MagnenatThalmann prunes
surface patches S that do not selfcollide if the following two
conditions hold:
1. There exists a vector v such that, for all triangles in S,
vTni> 0, with nithe triangle normal.
2. TheorthogonalprojectionofthecontourofS ontoaplane
with normal v does not selfintersect.
Following observations by Volino and MagnenatThalmann,
we construct the BNTree by partitioning the surface into
patches that maximize the areaperimeter ratio. In this way,
the ‘contour test’ 2 above is extremely unlikely to fail.
Hence, and also following Volino and MagnenatThalmann,
we omitted the contour test in our implementation. Let us re
markthattheselfcollisiondetectionalgorithmisnotconser
vative without the contour test, and in Section 6 we discuss
an extension to efficiently handle it.
The ‘normal test’ 1 above reduces to computing the in
tersection of the halfspaces defined by all triangle normals
in the patch. Similar to Volino and MagnenatThalmann, we
perform a slightly conservative version of the normal test
by storing a discrete normal cone (DNC) consisting of a bit
mask for 14 directions (6 for the directions of the Cartesian
axes, and 8 for the corners of a cube aligned with the axes).
In the original algorithm by Volino and Magnenat
Thalmann, DNCs are computed bottomup in a BVH, such
that the DNC of a node is computed by intersecting the
DNCs of its children. The total cost for updating DNCs is
then O(n), with n the number of triangles in the surface.
Instead, using our algorithm for computing normal bounds
from the previous section, we can update a DNC ondemand
with cost O(m), with m the number of linear transformations
that govern the deformation. Given a normal bound [n], a
‘true’ bit in the DNC denotes that all triangle normals in the
patch have a positive dot product with the direction associ
ated to that bit. The value of the bit is computed by checking
whether the lower bound of the dot product between its as
sociated direction and the bound [n] is positive.
4.2. Hierarchical SelfCollision Detection
Given as input a connected triangle mesh, we construct as
preprocessing a BNTree that successively partitions mesh
patches into 2 connected components. If the triangle mesh
is not connected, the various connected components may be
treated separately. Note that we have used a branching factor
of 2, but other branching factors are also possible.
At runtime, a selfcollision detection test starts by issuing
a selfcollision query on the root node, and then proceeds
hierarchically by performing three types of queries:
1. self_collide(a) prunes the subtree rooted under node a if
its corresponding surface patch fulfills the normal test de
scribed in Section 4.1. This test requires the computation
of the DNC of a.
2. self_collide(a, b) is a query on adjacent nodes a and b,
and is executed similarly. It requires the computation of
the intersection of the DNCs of a and b.
3. collide(a, b) is a query on disjoint nodes a and b, and it
checks the collision between BVs of a and b.
Queries with a positive result descend recursively on chil
dren nodes, issuing self_collide() or collide() queries based
on whether the nodes are adjacent or disjoint. At the leaves
of the tree, we perform primitivelevel tests.
Before executing a collide() or self_collide() test, we first
check whether the BVs or DNCs have already been com
puted in the current simulation frame for the involved nodes.
If they are not computed yet, we execute an ondemand up
date. For BVs, we use the efficient update algorithm for
AABBs by Steinemann et al. [SOG08]. For DNCs, we use
our novel normal bound computation described in Section 3.
In order to test adjacency of nodes, we store adjacent pairs
in a hash table, although other approaches are also possi
ble [VMT94, GS01]. A hash table is efficient in our case
because our queries descend simultaneously to all children,
hence most nodes need only test for adjacency against nodes
at the same BNTree level.
4.3. Front Caching
Instead of starting the update of DNCs at the root of the BN
Tree every animation frame, we exploit temporal coherence
c ? The Eurographics Association 2009.
Page 6
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
0 2004006008001000
0
20
40
60
80
100
120
Frames
BN−Tree Vs. HSC (cloth subdivision) (ms./frame)
DNCs Update
DNCs + BVs Update
BN−Tree (total)
HSC
2
Subdivision Levels
34
0
1
2
3
4
5
6
7
Performance Gain Vs. HSC
Figure 2: Left: Performance comparison of BNTree and
[VMT94] for cloth subdivision (Fig. 1); Right: performance
gain as a function of the number of Loop subdivisions.
and store a front that determines where to apply our efficient
computation of DNCs. At a new frame, we first compute the
DNCsoffrontnodes,andthencomputeDNCsfromthefront
up to the root by intersection of children’s DNCs. If a node
below the front is visited during a selfcollision query, we
update its DNC ondemand. We store separate update fronts
for DNCs and BVs.
In order to determine the update front, we mark nodes
if they were tested in a selfcollision query in the previ
ous frame or if at least the DNC of one of their children
was computed. In essence, the front for DNC computation
separates the subtree of marked nodes from the unmarked
ones. However, this showed to be insufficient, as the self
collision query may suffer a sudden descent on several lev
els due to degradation of DNCs. We avoid such costly query
descents by performing a conservative ascent of the DNC
update front. If a node whose DNC was computed in the pre
vious frame is now a candidate for ascent (because it was not
tested in a selfcollision query and none of the DNCs of its
children were computed), we perform a test computation of
its parent’s DNC. If this DNC degrades and its bitmask has
less than 3 active bits, we preserve the location of the up
date front. Front caching together with conservative ascent
brought additional temporal coherence to the selfcollision
queries and, therefore, an important speedup.
We add yet another optimization to the update front in or
der to avoid costly computation of DNCs low in the tree.
As a preprocessing, we check for each node whether it is
more efficient to compute the DNC in a bottomup fash
ion on its subtree or using our algorithm for computing nor
mal bounds. At runtime, if the update front reaches a node
where bottomup computation of the DNC is more efficient,
we force the front all the way to the leaves on that subtree.
5. Results
We discuss now the application of the BNTree to cloth up
sampling using subdivision surfaces, linear blend skinning,
and pointbased animation. All experiments were executed
on a 2.0GHz dualprocessor PC with 2GB of RAM.
Subdivision. Cloth simulations are often postprocessed
with subdivision in order to obtain smoothed folds and wrin
kles in final renders. Bridson et al. [BFA02] discuss a post
processing method that handles possible collisions produced
by subdivision. With the BNTree, it is possible to test colli
sions on a highly subdivided surface with a cost possibly as
low as linear in the number of vertices of the control mesh.
We have used Loop’s subdivision scheme in our exam
ples. Then, the vertices in a surface patch are governed by a
set of control points (up to 12 in our examples) with initial
and deformed positions {xi} and {yi}. It would be possi
ble to apply our algorithm for normal bound computation
using as governor transformations Ai= 0, ti= yi. How
ever, we obtained notably tighter bounds by extracting a
bestfit average transformation for every patch. Given initial
and deformed centroids xcand yc, we express the deformed
control points that govern a patch as yi= Axi+ ti, with
A = argminA∑?yi−yc−A(xi−xc)?2. The inverse matrix
of the linear system for the leastsquares fit can be precom
puted for each patch.
Since we fit one single transformation per patch, the patch
deformation defined in Section 3.3.1 is simply Ap= A, i.e.,
the bestfit average transformation. For the same reason, the
triangle and differential deformations cancel out, i.e., At=0
and ∆Ak= 0.
Fig. 1 shows a cloth animation example where we tested
the BNTree. The control mesh consists of 231 vertices,
and we performed tests with 2, 3, and 4 subdivision levels.
Fig. 2left compares the perframe update and query times
across the whole simulation for 4 subdivision levels, using
the BNTree and stateoftheart hierarchical selfcollision
detection [VMT94] (denoted as HSC). We also evaluated the
performance of spatial hashing [THM∗03], but we do not
depict it because it was considerably slower (739 ms/frame
on average). Note that spatial hashing is fully conservative,
while the BNTree and our implementation of HSC do not
perform the contour test (See Section 4.1). Fig. 2right com
pares the average performance of the BNTree against HSC
for various subdivision levels, and the speedup increases, as
expected, as the number of subdivisions increases. BNTree
clearlyoutperformswhenmanyregionsoftheclothareclose
to planar, as the update front can remain high in the tree.
Linear Blend Skinning. Fig. 3 shows a comparison of
timings on two different animations of a cat. The cat is ani
mated with a skeleton with 40 bones, and the triangle mesh
consists of 244735 triangles. Each vertex is governed by up
to 9 bones, using linear blend skinning. In one animation
the cat walks slowly, producing sparse selfcollisions, and
the BNTree outperforms HSC consistently by a factor of
3. In the other animation the cat runs and jumps and suf
fers many selfcollisions (including large pinching at joints).
The amount of selfcollision, together with the lack of tem
poral coherence, produce sudden changes in the update front
of the BNTree, yet it still outperforms HSC, although by a
c ? The Eurographics Association 2009.
Page 7
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
0200400600800
0
100
200
300
400
500
600
700
Frames
BN−Tree Vs. HSC (linear blend skinning) (ms./frame)
BN−Tree run
BN−Tree walk
HSC run
HSC walk
Figure 3: On the left, performance comparison between BNTree and [VMT94] for a cat animated with linear blend skinning,
in two different situations: walking (middle) with sparse selfcollisions, and running (right) with many selfcollisions.
smaller factor. These examples show that the BNTree pro
duces large speedups, as expected, with sparse contact, and
it becomes comparable to previous methods under dense
and/or nontemporallycoherent contact.
PointBased Animation. In pointbased animation, the
positions of surface vertices are defined using a mov
ing least squares interpolation of linear deformation
fields [MKN∗04]. Our last example is a teddy bear model
with 26402 vertices animated using pointbased animation
with 24 particles (shown in Fig. 4). The figure also shows
the comparison of performance between our BNTree algo
rithm and HSC [VMT94].
6. Discussion and Future Work
We have presented an algorithm for efficiently computing
tight normal bounds for triangulated surfaces governed by
reduced deformations. This algorithm serves as the main
building block for outputsensitive normalbased culling in
hierarchical selfcollision detection. Our algorithm relies on
the computation of tight bounds of a triangle’s deformation
gradient. Even though we have applied our algorithm in the
context of selfcollision detection, it would be interesting to
evaluate other possible applications.
Our experiments demonstrate that the comparative effi
ciency of the BNTree increases with triangle density, hence
it appears as a good solution for densely tessellated objects.
The BNTree also works best in practice for objects with low
curvature in the rest configuration, such as our cloth exam
ple, because there is higher potential for highlevel culling.
In models with relatively high local curvature, the DNC up
date front is too low, even at levels where the evaluation of
bounds using our algorithm would become the bottleneck.
For that reason, in such cases we simply force the front down
to the leaves. By doing this, we locally treat the BNTree
update in a way analogous to the traditional bottomup up
date [VMT94]. In the near future, we plan to explore ways to
locally transition to full bottomup update when the anima
tion does not exhibit temporal coherence, perhaps by evalu
ating the amount of interframe deformation.
The major limitation of our method is that it is not
fully conservative, as it does not support the contour test.
This test, however, can be regarded as a lowerdimensional
version of the normal test, as discussed by Grinspun and
Schröder [GS01], and it might also benefit from our algo
rithm. Nevertheless, it remains to test the impact of efficient
bound computations on the overall performance when the
contour test is also considered.
There are many possible avenues for future work, such
as parallelization of the algorithm, addition of continuous
collision detection, or handling of hierarchy updates under
topological changes (i.e., cutting and fracture). It would also
be interesting to explore algorithms for outputsensitive self
collision detection for other types of reduced deformation
models not currently handled, such as modal analysis or
posespace deformation.
Acknowledgements
We wish to thank the reviewers for their help in improving
our paper, Caroline Larboulette for the animation of the run
ning cat, Pablo Quesada and Juanpe Brito for further help
with this demo, Denis Steinemann for pointbased animation
code, and Marcos García for proofreading and comments.
This project was partially funded by URJC  Comunidad
de Madrid (proj. CCG08URJC/DPI3647) and the Spanish
Science and Innovation Dept. (proj. TIN200767188).
References
[AKP∗05]
GROSS M., DUTRE P.: Efficient raytracing of deforming point
sampled surfaces. Proc. of Eurographics (2005).
[Bar84]BARR A. H.: Global and local deformations of solid
primitives. Proc. of ACM SIGGRAPH (1984).
[BFA02]BRIDSON R., FEDKIW R., ANDERSON J.: Robusttreat
ment of collisions, contact and friction for cloth animation. Proc.
of ACM SIGGRAPH (2002).
[BSPG06]BOTSCH M., SUMNER R., PAULY M., GROSS M.:
Deformation transfer for detailpreserving surface editing. Proc.
of Vision, Modeling & Visualization (2006).
[BW02]BACIU G., WONG W. S.K.: Hardwareassisted self
collision for deformable surfaces. Proc. of the ACM Symposium
on Virtual Reality Software and Technology (2002).
ADAMS B., KEISER R., PAULY M., GUIBAS L. J.,
c ? The Eurographics Association 2009.
Page 8
S.C. Schvartzman, J. Gascón & M.A. Otaduy / Bounded Normal Trees for Reduced Deformations of Triangulated Surfaces
0 204060
0
20
40
60
80
100
Frames
BN−Tree Vs. HSC (point−based anim.) (ms./frame)
DNCs Update
DNCs + BVs Update
BN−Tree (total)
HSC
Figure 4: On the left, performance comparison between BNTree and [VMT94] for a teddy deformed with pointbased anima
tion. The other images show the simulated particles, selfcollisions, and the DNC update front of the BNTree.
[dB97]
plex deformable models using aabb trees. J. Graphics Tools 2, 4
(1997), 1–14.
[GKJ∗05]GOVINDARAJU N. K., KNOTT D., JAIN N., KABUL
I., TAMSTORF R., GAYLE R., LIN M. C., MANOCHA D.: In
teractive collision detection between deformable models using
chromatic decomposition. Proc. of ACM SIGGRAPH (2005).
[GLM96]GOTTSCHALK S., LIN M., MANOCHA D.: OBBTree:
A hierarchical structure for rapid interference detection. Proc. of
ACM SIGGRAPH (1996), 171–180.
[GRLM03]GOVINDARAJU N., REDON S., LIN M., MANOCHA
D.: CULLIDE: Interactive collision detection between complex
models in large environments using graphics hardware. Proc.
of ACM SIGGRAPH/Eurographics Workshop on Graphics Hard
ware (2003), 25–32.
[GS01]GRINSPUN E., SCHRÖDER P.:
subdivisionsurface interference detection. Proc. of IEEE Visual
ization Conference (2001).
[Hub95]HUBBARD P. M.:
spheres for timecritical collision detection.
Graphics 15, 3 (1995).
[JC01]JOHNSON D. E., COHEN E.: Spatialized normal cone hi
erarchies. Proc. of the Symposium on Interactive 3D Graphics
(2001).
[JMD∗07]JOSHI P., MEYER M., DEROSE T., GREEN B.,
SANOCKI T.: Harmonic coordinates for character articulation.
Proc. of ACM SIGGRAPH (2007).
[JP04]JAMES D. L., PAI D. K.: BDTree: Outputsensitive col
lision detection for reduced deformable models. Proc. of ACM
SIGGRAPH (2004).
[KA04]KLUG T., ALEXA M.: Bounding volumes for linearly
interpolated shapes. Proc. of Computer Graphics International
(2004).
[KMGL99]KUMAR S., MANOCHA D., GARRETT W., LIN
M. C.:Hierarchical backface computation.
Graphics 23, 5 (1999).
[KOZ06]KAVAN L., O’SULLIVAN C., ZARA J.: Efficient col
lision detection for spherical blend skinning. Proc. of Graphite
(2006).
[KZ05]KAVAN L., ZARA J.: Fast collision detection for skele
tally deformable models. Proc. of Eurographics (2005).
[LAM03]LARSSON T., AKENINEMÖLLER T.: Efficient colli
sion detection for models deformed by morphing. The Visual
Computer 19 (2003).
DEN BERGEN G. V.: Efficient collision detection of com
Normal bounds for
Approximating polyhedra with
ACM Trans. on
Computers &
[LCF00]
deformation: a unified approach to shape interpolation and
skeletondriven deformation. Proc. of ACM SIGGRAPH (2000),
165–172.
[MKE03]MEZGER J., KIMMERLE S., ETZMUβ O.: Hierarchi
cal techniques in collision detection for cloth animation. Proc. of
WSCG (2003).
[MKN∗04]MÜLLER M., KEISER R., NEALEN A., PAULY M.,
GROSS M., ALEXA M.: Point based animation of elastic, plastic
and melting objects. Proc. of Eurographics/ACM SIGGRAPH
Symposium on Computer Animation (2004).
[MO06]MENDOZA C., O’SULLIVAN C.: Interruptible collision
detection for deformable objects. Computers & Graphics 30, 2
(2006).
[OGRG07]OTADUY M. A., GERMANN D., REDON S., GROSS
M.: Adaptive deformations with fast tight bounds. Proc. of ACM
SIGGRAPH/Eurographics Symposium on Computer Animation
(2007).
[Pro97]PROVOT X.: Collisionandselfcollisionhandlingincloth
model dedicated to design garment. Proc. of 8th Eurographics
Workshop on Computer Animation and Simulation (1997), 177–
189.
[SBT06]SPILLMANN J., BECKER M., TESCHNER M.:
cient updates of bounding sphere hierarchies for geometrically
deformable models. Proc. of VRIPHYS (2006).
[SOG06]STEINEMANN D., OTADUY M. A., GROSS M.: Fast
arbitrary splitting of deforming objects.
SIGGRAPH/Eurographics Symposium on Computer Animation
(2006).
[SOG08]STEINEMANN D., OTADUY M. A., GROSS M.: Tight
and efficient surface bounds in meshless animation. Computers
& Graphics 32, 2 (2008).
[SP04]SUMNER R. W., POPOVI´C J.: Deformation transfer for
triangle meshes. Proc. of ACM SIGGRAPH (2004).
[TCYM08]TANG M., CURTIS S., YOON S.E., MANOCHA D.:
Interactive continuous collision detection between deformable
models using connectivitybased culling. Proc. of ACM Sympo
sium on Solid and Physical Modeling (2008).
[THM∗03]TESCHNER M., HEIDELBERGER B., MÜELLER M.,
POMERANETS D., GROSS M.: Optimized spatial hashing for
collision detection of deformable objects. Proc. of Vision, Mod
eling and Visualization (2003).
[VMT94]VOLINO P., MAGNENATTHALMANN N.:
selfcollision detection on smoothly discretized surface anima
tions using geometrical shape regularity. Eurographics (1994).
LEWIS J. P., CORDNER M., FONG N.:Pose space
Effi
Proc. of ACM
Efficient
c ? The Eurographics Association 2009.
View other sources
Hide other sources
 Available from Sara C. Schvartzman · May 28, 2014
 Available from gmrv.es