See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/220183523

Resolving surface collisions through intersection contour minimization

Article in ACM Transactions on Graphics · July 2006

DOI: 10.1145/1141911.1142007 · Source: DBLP

CITATIONS READS

84 604

2 authors, including:

Nadia Magnenat Thalmann

University of Geneva
1,354 PUBLICATIONS 24,632 CITATIONS

SEE PROFILE

All content following this page was uploaded by Nadia Magnenat Thalmann on 03 June 2014.

The user has requested enhancement of the downloaded file.

 Resolving Surface Collisions through
Intersection Contour Minimization

Pascal Volino* Nadia Magnenat-Thalmann**

MIRALab, University of Geneva MIRALab, University of Geneva

Abstract may occur in the simulation is needed. This involves detecting

collisions between all different surface areas of cloth. Unlike
Robust handling of collisions on non-oriented deformable surfaces describing volume hulls, cloth surfaces do not have any
surfaces requires advanced methods for recovering intersecting orientation (both sides are “outside”), and contacts on any of the
surfaces. We present a novel method that resolves intersections sides are valid. Unfortunately, this context prevents a simple
between two intersecting surface regions by inducing relative resolution of inconsistently intersecting surfaces.
displacements which minimize the length of the intersection
contour between them. This method, which does not rely on Surface intersections do not usually represent a physically correct
intersection regions, has a broader application field than existing state in usual simulation systems. Most of the time, they result
methods, and its implementation is also much simpler, allowing from approximate collision detection and response schemes that
integration into most existing collision response schemes. We are not able to enforce consistently the geometrical collision
demonstrate the efficiency of this method through examples in the constraints along any situations that may occur during the
context of cloth simulation. simulation. Unfortunately, comprehensive methods for ensuring
adequate processing of all geometrical collision constraints are
CR Categories: I.3.7 [Three-Dimensional Graphics and complex (detection of numerous mesh collision configurations,
Realism]: Animation, Virtual Reality; I.6.3 [Simulation and interactions between numerous collisions, handling correctly
Modeling]: Applications. geometrical singularities and numerical errors...). Therefore, they
are totally impractical to implement for processing large numbers
Keywords: Collisions, Surface Intersections, Cloth Simulation. of collisions with realistic computation times (for example, in the
context of simulation of complex garments). Meanwhile, faulty
initial geometric configurations and nonphysical factors in the
1. Introduction simulation context may also lead to surface intersections (for
instance, when the cloth is pinched by two interpenetrating
Cloth simulation involves accurate mechanical models and geometric objects, as described by Baraff et al [2003]).
numerical methods that can reproduce the properties of cloth
materials and integrate the resulting equations in realistic
computation times. However, in many practical applications such
as garment simulation, collisions play a major role in the
simulation, and have to be handled comprehensively. Putting
aside the problematic of detecting collisions between mechanical
objects efficiently and their integration in the mechanical model (a
good overview of this is described by Teschner et al [2005]), we
here focus on robustness issues that are important to address in the
context of simulation of complex mechanical surfaces.

In early cloth simulation models, collision processing was

restricted to prevent cloth surfaces to penetrate volumes (for
instance, a garment surface against a body volume). The surfaces
describing the hull of these volumes had a clear “inside-outside”
orientation, and collision processing only had to bring the cloth
surface on the right (outside) side of the volume hull surface. Fig.1. Robust simulation of complex garments requires algorithms that
automatically remove of intersections between multiple layers of cloth
In more complex simulation contexts (for instance, simulating a during the simulation (from left to right). Our approach is based on
complex set of layered garments on a virtual character, as shown minimization of the intersection contour length (blue lines).
in Fig.1), a comprehensive handling of all possible collisions that
As we can see, defining a robust simulation system for complex
cloth objects cannot only be done by trying to prevent surface
intersections from occurring, but also requires being able to
*
e-mail: pascal@miralab.unige.ch “repair” those intersections whenever they occur (Fig.1). Several
**
e-mail: thalmann@miralab.unige.ch approaches are available for solving this problem. The most
common approach is to identify “collision regions” consisting of
adjacent collisions between common surface regions, and to
ensure global orientation consistency between the collisions of a
region. This approach has been followed by Volino et al. [1995],
by defining the global orientation of a collision region by majority
polling the orientations of all collisions of that region, and 2. Description of the Method
correcting the orientation of the minority collisions when
required. Each collision would also be tracked along time, In the following, we assume that the surfaces are described as
retaining a constant orientation with detection and correction of polygonal meshes, and that the polygons are flat (this is always
orientation changes resulting from surface crossings along time. the case for triangle meshes). In this context, regular surface
While fairly efficient in many contexts, such methods are collisions are typically detected as proximities between vertices
however quite impractical to implement, as they require complex and polygons, sometimes between edges. These collisions
data structures and heavy algorithms for grouping detected illustrate that surfaces are close enough for considering them as
collisions into regions, and tracking evolving collisions along time interacting. Meanwhile, surface intersections are typically
during all the simulation. Furthermore, as discussed by Baraff et detected as intersections between edges and polygons. Their
al [2003], such history-dependent methods may even prevent presence denotes that surfaces interpenetrate in a usually not
recoveries if, for any reason, an erroneous configuration is physically plausible way, and we aim to present a scheme to
“remembered” to be correct by the simulation. resolve this situation. The surface intersection contour is actually
described as two lines, drawn identically on the two intersecting
Simpler approaches aim at preventing surface intersections to surfaces. In the case of polygonal meshes, this contour is indeed a
occur or spread, mostly by constraining regions where such polygonal line, and the edge-polygon intersections define the
situations might happen, removing all instability that might result vertices supporting it (Fig.2).
from interaction with mechanical simulation. For instance, Baraff
et al [2003] use “flypapering” for preventing instabilities in The idea of resolution scheme is fairly simple: We define a
intersecting mechanical surfaces, and Bridson et al [2003] use collision response scheme that induces a relative displacement
geometrical methods to preserve wrinkle patterns in colliding between intersecting edges and polygons so as to reduce the
surfaces. The most comprehensive way of preventing length of the intersection contour, ultimately leading to the
intersections to occur is presented by Bridson et al [2002]. disappearance of the surface intersection.
Anyhow, whatever the complexity of these methods, none can
prevent intersections to occur if they have to because of non-
consistent constraints.

A major contribution in the resolution of intersecting surfaces has

been brought by Baraff et al [2003] through their Global
Intersection Analysis method. This method tracks intersections by
reconstructing the intersection contours of the colliding regions.
Once a closed contour has been identified, the colliding surface
regions within is identified using a “flood-fill algorithm” on the
mesh and, once orientation correspondence between the detected
regions is established, their collision response method would
bring these surfaces back to their non-colliding relative positions
as soon as it is possible, in conjunction with their “flypapering”
method. However, a major restriction is the necessity to have
“well-defined” intersection regions unambiguously identified by
intersection contours. Unfortunately, this is not always the case
when surface boundaries are involved in the intersection, and we
have found that such situations occur quite often, when resulting
from approximate collision processing of complex surfaces. Even
more, sometimes the “orientation” of intersecting surfaces does Fig.2. Minimizing the intersection contour length not only resolves the
not even make sense (for example, in Fig.2 bottom). Hence, case of closed contours (top), but also open contours (middle) and cases
methods based on orientation of collision and intersection regions where the orientation of “collision regions” is meaningless (bottom).
are quite unlikely to work correctly in the contexts described in
Section 3.1.1 and 3.1.3. 2.1. Minimizing Edge-Polygon Intersections

Our goal is to overcome these limitations through the definition of In a mesh, an edge E is typically adjacent to several polygons Bi
a new method for resolving surface intersections. Rather than (usually two, only one if the edge is on a surface boundary).
spending time identifying colliding surface regions as done by When this edge intersects a polygon A, the intersections between
Volino et al [1995] or Baraff et al [2003], we base our method on A and Bi define segments of the intersection polygonal line,
a very simple paradigm: Minimizing the length of the intersection drawn on the surfaces of A and Bi in an identical way. We
contours (Fig.2). initially focus on how a small displacement D of the edge E
relatively to the polygon A changes the length of the intersection
Through these developments, we present a very general scheme segment between one polygon Bi and the polygon A.
for resolving surface intersections that do not suffer from the
limitations of collision region and surface orientation Naming N and Mi the normals of the polygons A and Bi
reconstruction methods. It can complement most forms of respectively, we first compute a vector Ri representing the
collision response techniques, as long as local surface direction of the intersection segment. This vector is obtained
intersections are detected. We put emphasis on the versatility of through cross-product of N and Mi. We normalize it to unit length
the method, and we detail two variations offering various degrees and choose its orientation so as to indicate from the edge E the
of simplicity and efficiency. None of them require complex inside of the polygon Bi (Fig.3). Using the geometric construction
algorithms or data structures, and none rely on the history of the shown in Fig.3, with E representing any direction vector of the
simulation. We describe the principles of this method in Part.2, edge, and noting that E is collinear to the vector PbQ and N is
and some examples illustrating its capabilities are shown in Part.3. orthogonal to the vector PaQ = D+PbQ, we have:
 (N ⋅ E ) PbQ = (N ⋅ PbQ ) E = −(N ⋅ D ) E (1)

From this, the reduction of intersection segment length li+ki

drawn on the polygon A (as the intersection point slides from Pa
to Q over it) is computed as following:
N ⋅D
l i + k i = Pa Q ⋅ Ri = D ⋅ Ri + Pb Q ⋅ Ri = D ⋅ Ri − E ⋅ Ri (2)
N ⋅E
Meanwhile, the reduction of intersection segment length ki drawn
on the polygon Bi (as the intersection point slides from Pb to Q
over it) is computed as following: Fig.4. Some configurations representing edge-polygon intersections
(yellow dots), and the orientation of the gradient G (red arrows) or its
N ⋅D (3)
k i = Pb Q ⋅ Ri = − E ⋅ Ri opposite (green arrows). Reducing the length of the intersection contour is
N ⋅E done by moving intersected edges along the red arrows and intersected
polygons along the opposite green arrows.
Bi It is important to note that there are no assumptions on the number
E of polygons Bi adjacent to the edge E. Hence, the presented
method is perfectly applicable for non-manifold meshes. This can
Pb be important in the field of garment simulation, when complex
D
seams are involved in multiple collisions (Fig.1).
Pa 2.2. Integration with Collision Response
Ri ki li
Mi
Q A Collision response aims at integrating the effects of collisions in
the simulation. In the context of mechanical simulation, this is
N possible through ad-hoc mechanical “penalty forces” modeling
the mechanical contact. It can also be done directly through
geometrical corrections that enforce geometrical and kinematical
Fig.3. When the edge E moves by a small displacement D relatively to the constraints through displacement values, speed or acceleration
polygon A, the intersection point between E and A moves from Pa to Q momentums depending on the actual collision response method,
over the polygon A. Thus, the length of the intersection segment of Bi which are then distributed on colliding elements according to
drawn on A is shortened by li+ki, Meanwhile, the intersection point slides mechanical momentum conservation laws. In all cases, the
from Pb to Q over the polygon Bi. Thus, the length of the intersection direction of the gradient G and its amplitude are good indications
segment of A drawn on Bi is shortened by ki. of the direction to follow for correcting the intersection.
We need to evaluate the change of length of the contours drawn Integration of our intersection resolution in such a collision
on both intersecting surfaces. For this, we can now add the response scheme is done by defining an “interaction vector” H
contributions of all polygons Bi adjacent to the edge E. The total from the gradient G according to the features and possibilities of
length reduction of all intersection segments drawn on polygons A the collision response scheme. Obviously, we should construct the
and all Bi can be expressed from the relative displacement D vector H on the same direction as the vector G for optimizing the
through a linear gradient vector G, as follows: intersection contour length reduction. Then, their norm should be
related as well, but adequate solutions highly depend on the nature
⎛ E ⋅ Ri ⎞ (4)
∑ (l + 2 k ) = G ⋅ D
i
i i where G = ∑ ⎜ Ri − 2
i ⎝ E⋅N ⎠
N⎟ and properties of the collision response scheme. As a fairly
general solution, we propose to use the following scaled
arctangent function:
The direction of the gradient vector G indeed represents the
direction along which the edge E should be moved relatively to
the polygon A so as to get the best reduction of the intersection G
contour length (Fig.4). Hence, with a relative displacement D H = h0
2
between both colliding elements, the intersection contour length G + g 02
(5)
reduction is G·D, assuming a first-order approximation that
preserves the directions of the edge E and the intersection Ri The value h0 represents the maximum norm of the correction
(pure translation between colliding elements), and that the acceptable for the collision response scheme, while the value g0
intersection point does not “jump out” of the edge E or the defines a progressive slope that stabilizes the response if the
polygon A. In practice, this justified as long as the displacement D intersection contour length minimization is ambiguous.
does not become much larger compared to the size of a mesh
element (such requirement is quite typical to most collision 2.3. The Local and the Global Scheme
response schemes), since surfaces are most of the time regular
enough to have similar intersection angles when the contour Implemented as is, the intersection correction scheme handles all
moves between adjacent polygons. In these conditions, the length edge-polygon intersections independently, locally reducing the
of the gradient still represents roughly how efficiently a relative size of the intersection contour around them. This local scheme is
displacement along its direction reduces the length of the indeed very simple to implement, as only the geometry of the
intersection contour. It can be noted that G is always null if the colliding mesh elements is needed, without any need to explore
intersected edge separates two polygons of a flat surface. the surface mesh further away. While this scheme is able to solve
most surface intersection configurations, it is however sometimes This method has been integrated in a cloth simulation engine
not very efficient. Hence, while small or closed intersection based on particle systems tuned for accurate representation of the
contours on quasi-parallel surfaces (Fig.2 top) are resolved mechanical properties of cloth, based on the ideas described by
efficiently, longer and complex contours (Fig.2 middle) require Etzmuss et al [2003] and Volino et al [2005]. Numerical
significantly more iterations. Indeed, the iterative scheme of the integration is performed using Implicit Euler, as described by
contour length reduction process is fairly similar to a “snake” that Baraff and Witkin [1998] and Hauth et al. [2002]. Broad-phase
reduces its length by locally straightening itself. This is not collision detection is performed using Axis-Aligned Bounding
efficient if the contour is already quite straight, and actions on the Volume hierarchies using Discrete Orientation Polytopes from
extremities of open contours are frequently the largest Klosowsky et al [1997], and self-collision detection optimizations
contributors for the length reduction. In the particular context of from Volino et al [1994]. Collisions are then refined by detecting
“straight” open contours (Fig.2 bottom), only the two edge- proximities between mesh elements below a given threshold
polygon intersections at the extremities of the contour actively distance for regular collision response. Meanwhile, surface
participate to the length reduction. intersections are detected through edge-polygon intersections.
Collision response is performed by enforcing the collision
The idea of the global scheme is to have all the corrections of a constraints through geometric corrections of position, speed and
given intersection contour to “work together” towards a global acceleration distributed on mesh elements so as to preserve
reduction of the contour length. For this, we add all gradients mechanical momentum, in a similar way to Volino et al [2000],
corresponding to all edge-polygon intersections of a given without any subframing. Hence, one iteration of the computation
intersection contour to a single total gradient (their signs might be refers to one mechanical iteration with collision response, which
flipped depending on which surface carries the intersecting edge also considers the gradients of the intersection resolution scheme.
and which carries the intersecting polygon). This total gradient
represents how the total length of the intersection contour varies We illustrate the efficiency of our method through a set of
respective to the relative displacement between the intersecting challenging examples. None of these examples contain surfaces
surfaces. The collision correction resulting from this total gradient with predefined surface orientation information.
is then applied uniformly over all edge-polygon intersections
involved in the contour (Fig.5). 3.1. Some Test Examples

3.1.1. Untangling Cloth Surfaces

In this test, we let fall 25 squares of cloth on a ground (about 300
polygons each). These squares are initially highly intersecting,
producing more than hundred mangled intersection contours
(roughly 2000 edge-vertex intersections) (Fig.6). Without
intersection resolution, the whole set falls like a clump on the
ground without any improvement in the collisions. With
Fig.5. The local scheme (left) and the global scheme (right), shown on a resolution, intersecting squares are adequately pushed apart,
given surface intersection. With the local scheme, correction is applied on quickly leading to a totally intersection-free configuration. The
each intersection according to its own gradient. This is not very efficient if simulation was computed between 0.4 and 0.2 second per iteration
the intersection contour is almost straight at each side of the edge-polygon on a 3GHz Intel Pentium4 PC (it depends on the amount of
intersections. With the global scheme, correction is applied identically on “regular” collisions), and the extra computational cost required by
all intersections according to the sum of all gradients in order to globally our method was not measurable.
reduce the length of the whole contour.

It can be noted that it is not essential to implement a very robust

and complete intersection contour reconstruction algorithm for
having the global scheme to work. First, it is only necessary to
group the detected edge-polygon intersections respectively to the
intersection contour they belong to, not to order them so as to
have the contour polygonal line explicit. Then, any edge-polygon
intersection missing from the collision detection will not break the Fig.6. Untangling a set of 25 falling cloth squares.
algorithm (a contour could be split into several sections handled
independently). Thus, we can highly simplify the collision The simulation has been carried out with the global scheme.
detection algorithm by just ignoring geometric singularities and Despite complexity, a large amount of intersections are resolved
special intersection cases (such as edge-edge or polygon-vertex in the first 10 iterations. The local scheme works poorly in this
intersection coincidences). Therefore, our algorithm can deal quite context, because of the extent of the intersection contours.
robustly with imperfect and approximate collision detection
methods, as demonstrated in Section 3.1.2. 3.1.2. Robustness Test
A major issue in the lack of robustness results from incomplete
3. Results collision detection, as designing comprehensive algorithms for
We acknowledge that the efficiency of the presented method is detecting all possible geometric configurations is quite
likely to be very dependent on the actual nature and impractical. We have simulated a faulty collision detection system
implementation of the simulation and collision response system in by randomly ignoring 50% of all collisions (regular collisions as
which it is actually integrated. We will however illustrate this well as intersections) detected by our system. In the cloth
efficiency using a mechanical cloth simulation system which is simulation context shown in Fig.7, this produces small
fairly typical to the implementations actually used. intersections randomly appearing between colliding surfaces.
Using intersection resolution, intersecting regions are resolved a quickly accumulate and propagate in the system, producing
few frames after they appear, and the simulation is maintained inconsistent ribbon “crumple clumps” that finally break the
along time. Without, they quickly expand, breaking the simulation.
simulation.
Using our intersection resolution method, these intersections are
While the local scheme is fairly efficient in this context as long as removed only a few frames after their occurrence, ensuring
intersecting regions are not allowed to expand too much, the correct untangling of the ribbon at the end of the simulation. The
global scheme gives better robustness in more difficult cases, local scheme was sufficient to address this context, as
despite the fact that ignoring some detected intersections prevents intersections usually don’t extend too much as they appear.
intersection contours from being completely reconstructed. Most
intersections are resolved in only 1 or 2 frames. The simulation, 3.1.4. Garment Simulation
which involves about 2400 polygons, is simulated at about 12
iterations per second on a 3GHz Intel Pentium4 PC, with no This intersection resolution system is actually being used in
measurable slowdown resulting from intersection correction. garment simulation. This is a particularly important feature when
the aim is to design complex dressings made of several layers of
cloth (Fig.1), and when these are animated using geometrically-
deformed bodies that are not always mechanically accurate. In
this context, the interest of the intersection resolution method is
two-fold: First, it ensures that the simulation always reverts back
to correct even when any simulation artifact or inaccuracy
produces intersections. Then, it greatly enhances the ease of
garment design since an exact initial placement of garments is not
necessary (Fig.1). The global scheme offers best results in this
case, as the intersecting regions might be quite extended.

3.2. Performance and Limitations

Fig.7. Cloth simulation (frames 0, 10, 20 from left to right) while
randomly ignoring 50% of the detected collisions: Without (top) and with Computationally, the extra processing required by our method is
(bottom) Intersection resolution. very low, and in practice not measurable compared to the
processing of the “standard” collision detection and response
3.1.3. The Ribbon Simulation algorithms in which it has been implemented. This is mainly
because the number of edge-polygon intersections remains very
This torture-test scenario for collision processing consists in a low compared to the number of regular collisions between mesh
very long ribbon (120 meters long × 5 centimeters wide) falling elements. Possibly, most additional computation would result
on a rotating and slowly tilting dish (Fig.8). Using our from the explicit detection of polygon-edge intersections, a task
implementation, the computation of the ribbon, which has about which should be performed anyhow for detecting that surfaces do
80000 polygons, took roughly between 3 and 30 seconds per intersect.
iteration on a 3GHz Intel Pentium4 PC, depending on the highly
variable amount of collisions. Resolution of the surface intersections is an iterative process, and
the iteration “width” is inherently dependent on the amount of
“correction” that the underlying collision response scheme can
afford. Our tests have also shown that it is much more efficient to
resolve intersections progressively along the simulation (with a
very limited number of resolution iterations between each
mechanical iteration) than attempting to completely correct all
intersections before next simulation step. This allows regular
simulation to relax and fair the correction artifacts progressively
along the intersection correction process, and eventually jump out
of any possible local minimum that result from particular
geometric configurations. Most cases (such as those shown in
Figs.1, 2, 7) are typically resolved in less than ten iterations with
our implementation.

Unfortunately, there are still a few intersection configurations

where this minimization cannot remove the intersection. Some of
them are shown in Fig.9. Our algorithm then converges to a local
minimum of the intersection contour length (Stability of this
convergence can be obtained with a sufficiently large value of g0
Fig.8. The ribbon falling in the rotating dish.
in formula (5)). These configurations represent the cases where
Despite its performance, collision response is unable to ensure no the paradigm of reducing the length of the intersection contour is
intersections among the several tens of thousands of highly not sufficient alone for “improving” the current surface
interacting collisions detected in each frame. This is particularly intersections toward full resolution. Not all of these configurations
true when the ribbon “pasta” rolls in the tilted dish (Fig.8 bottom would be solved systematically by any other method anyway, as
left), because of all the sliding produced by the shear deformation sometimes there is no clear and formal way to devise from them
of the rolling, and a few intersections always come to happen in what would actually be the non-intersecting configuration (one
each frame. Without any intersection resolution method, these could consider the largest side respective to the intersection
contour, the shortest path to pull surfaces apart, not ignoring
 geometrical constraints such as attach points, the simulation scheme. We have demonstrated the efficiency of this method
context and high-level metadata or ontology...). For instance, a through several challenging examples.
possible addition to the presented method would be to identify
intersection regions whenever possible, and combine the Thanks to its generality and simplicity, this method can easily be
intersection contour length reduction criterion with an intersection combined with most usual approaches for collision detection and
area reduction criterion for evaluating the relative displacement response on mechanical surfaces, and may also be complemented
between intersecting surfaces. Possibly also, these areas, when by other intersection resolution schemes for broader context of
well-defined, could be handled directly with a method based on use or better performance in specific situations. We are now
Baraff’s ideas [2003]. looking forward to extend this method towards even more
challenging goals, such as untangling severely crumpled cloth...

Acknowledgements
We are grateful to all MIRALab team who participated to this
research through their contributions, advices, testing and creative
artwork. Special thanks for Christiane Luible for her expertise in
garment design and animation. This research is funded by the
European FP6 project LEAPFROG IP (NMP2-CT-2005-515810).

References
Fig.9. Some particular surface intersection configurations that intersection BARAFF D., WITKIN A., 1998, Large Steps in Cloth Simulation,
contour minimization cannot resolve. Proceedings of ACM SIGGRAPH 98, ACM Press, 32, p.106-117.
BARAFF D., WITKIN A., KASS M., 2003, Untangling Cloth, ACM
In practice, our method also often fails to address particular local Transactions on Graphics (ACM SIGGRAPH 2003), 22, pp 862-870.
crumpling patterns that involve several mangled self-intersecting
shapes. In that case, intersection contours could be moved away BRIDSON R., FEDKIW R., ANDERSON J., 2002. Robust treatment of
from their “dead-end” vertices within the surface through local collisions, contact, and friction for cloth animation, ACM Transactions
surface-flattening methods. Combination with Bridson’s ideas on Graphics (ACM. SIGGRAPH 2002), pp 594–603.
[2002] and other history-based methods through self-collision BRIDSON R., MARINO S., FEDKIW R., 2003, Simulation of Clothing with
processing of Govindaraju et al [2005] would also perform well Folds and Wrinkles, Eurographics-SIGGRAPH Symposium on
here, since these crumple configurations often result from local Computer Animation, pp 28-36.
surface crossings around excessively bent mesh edges.
ETZMUSS O., GROSS J., STRASSER W., 2003, Deriving a Particle System
Addressing extensively all these cases would anyhow require a from Continuum Mechanics for the Animation of Deformable Objects,
combination of several context-specific methods. Anyway, we IEEE Transaction on Visualization and Computer Graphics, 9(4), pp
538-550.
still believe that intersection contour minimization is a fairly
general method that deals with most cases encountered in the GOVINDARAJU N.K., KNOTT D., JAIN N., KABUL I., TAMSTORF R., GAYLE
context of cloth simulation, while being very simple to implement R., LIN M., MANOCHA D, 2005, Interactive Collision Detection between
and combine, if needed, to other specific methods aimed at Deformable Models using Chromatic Decomposition, ACM
addressing such particular configurations related to the actual Transactions on Graphics (ACM SIGGRAPH 2005), 24(3), pp 991-
context. 999.
HAUTH M., ETZMUSS O., STRASSER W., 2002, Analysis of Numerical
Methods for the Simulation of Deformable Models, The Visual
4. Conclusion Computer, 19(7-8), pp 581-600.

We have proposed a new method aimed at resolving surface KLOSOWSKI J.T., HELD M., MITCHELL J.S.B., 1997, Efficient Collision
intersections during animation processes. Among its major Detection Using Bounding Volume Hierarchies of k-dops, IEEE
interests, it is very general and does not suffer from the limitations transactions on Visualization and Computer Graphics, 4(1), pp 21-36.
of existing methods based on collision regions and orientation. It TESCHNER M., KIMMERLE S., HEIDELBERGER B., ZACHMANN G.,
is particularly adapted to the context of cloth simulation, and may RAGHUPATHI L., FUHRMANN A., CANI M.P., FAURE F., MAGNENAT-
resolve most of the challenging cases encountered in this context. THALMANN N., STRASSER W., VOLINO P., 2005, Collision Detection for
Deformable Objects. Computer Graphics Forum, 24(1), pp 61-81.
Another major advantage of this method is the simplicity of its
implementation. Hence, the local scheme only relies on a very VOLINO P., MAGNENAT THALMANN N., 1994, Efficient Self-Collision
Detection on Smoothly Discretised Surface Animations using
simple geometrical computation done independently on each
Geometrical Shape Regularity, Computer Graphics Forum
detected edge-polygon intersection on the meshes describing the (Proceedings of EuroGraphics 1994), 13(3), pp 155-166.
surface, while the global scheme only additionally requires
grouping these intersections by intersection contours using VOLINO P., COURCHESNE M., MAGNENAT-THALMANN N., 1995, Versatile
algorithms that do not need to be fully comprehensive. The global and Efficient Techniques for Simulating Cloth and Other Deformable
scheme can efficiently resolve very large surface intersections, Objects, Proceedings of ACM SIGGRAPH 95, ACM Press, pp 137-144.
and should therefore be favored as a basis for general-purpose VOLINO P., MAGNENAT-THALMANN N., 2000, Accurate Collision
cloth untangling. The local scheme is however most of the time response on polygonal Meshes, Computer Animation 2000, IEEE
sufficient to address small intersections that do not spread far in Computer Society, pp 154-163.
the mesh, such as those resulting from approximate or faulty
collision response, and it is therefore a very simple addition for VOLINO P., MAGNENAT-THALMANN N., 2005, Accurate Garment
Prototyping and Simulation, Computer-Aided Design and Applications,
adding extra robustness in an existing collision processing
CAD Solutions, 2(5), pp 645-654.

View publication stats