An Intestinal Surgery Simulator: Real-Time Collision Processing and Visualization

Abstract

This research work is aimed toward the development of a VR-based trainer for colon cancer removal. It enables the surgeons to interactively view and manipulate the concerned virtual organs as during a real surgery. First, we present a method for animating the small intestine and the mesentery (the tissue that connects it to the main vessels) in real-time, thus enabling user interaction through virtual surgical tools during the simulation. We present a stochastic approach for fast collision detection in highly deformable, self-colliding objects. A simple and efficient response to collisions is also introduced in order to reduce the overall animation complexity. Second, we describe a new method based on generalized cylinders for fast rendering of the intestine. An efficient curvature detection method, along with an adaptive sampling algorithm, is presented. This approach, while providing improved tessellation without the classical self-intersection problem, also allows for high-performance rendering thanks to the new 3D skinning feature available in recent GPUs. The rendering algorithm is also designed to ensure a guaranteed frame rate. Finally, we present the quantitative results of the simulations and describe the qualitative feedback obtained from the surgeons.

Full text

An Intestinal Surgery Simulator: Real-Time
Collision Processing and Visualization
Laks Raghupathi, Laurent Grisoni, Franc¸ois Faure,
Damien Marchal, Marie-Paule Cani, and Christophe Chaillou
Abstract—This research work is aimed toward the development of a VR-based trainer for colon cancer removal. It enables the
surgeons to interactively view and manipulate the concerned virtual organs as during a real surgery. First, we present a method for
animating the small intestine and the mesentery (the tissue that connects it to the main vessels) in real-time, thus enabling user
interaction through virtual surgical tools during the simulation. We present a stochastic approach for fast collision detection in highly
deformable, self-colliding objects. A simple and efficient response to collisions is also introduced in order to reduce the overall
animation complexity. Second, we describe a new method based on generalized cylinders for fast rendering of the intestine. An
efficient curvature detection method, along with an adaptive sampling algorithm, is presented. This approach, while providing improved
tessellation without the classical self-intersection problem, also allows for high-performance rendering thanks to the new 3D skinning
feature available in recent GPUs. The rendering algorithm is also designed to ensure a guaranteed frame rate. Finally, we present the
quantitative results of the simulations and describe the qualitative feedback obtained from the surgeons.
Index Terms—Virtual reality, physically-based modeling, animation, curve and surface representation.
æ
1INTRODUCTION
M
INIMALLY invasive surgical (MIS) procedures are
gaining popularity over open procedures among
surgeons and patients. This is mainly due to less post-
operative pain, fewer infections, and an overall faster
recovery. The tremendous success of laparoscopic chole-
cystectomy (gall bladder removal) has prompted surgical
practitioners and educators to apply such techniques to
other gastrointestinal procedures. In this paper, we focus on
laparoscopic colectomy (colon cancer removal). Studies show
that many patients undergoing this procedure benefit from
the advantages of the MIS procedures listed above while
sharing the same risks of the corresponding open procedure
[1]. Yet, as with most laparoscopic procedures, it is difficult
to master, with a very flat learning curve [2]. As part of the
current training procedure, surgeons practice on pigs to get
a feel for the organ’s behavior. However, this technique is
prohibitively expensive and also raises numerous ethical
issues. We believe that a VR-based simulator platform can
significantly help nonspecialist surgeons and medical
residents to acquire the necessary surgical skills in a cost-
effective way. This may well result in popularizing the use
of the laparoscopic technique for this procedure, thus
benefiting more patients. Thus, our aim is to simulate the
behavior of the intestine when the surgeon is practicing in
the virtual environment. Note that the current scope of this
research work does not include the simulation of the cancer
removal itself. We focus on two important pedagogical
problems: 1) camera positioning by allowing the trainee to
visualize the relevant organs in 3D, 2) manual dexterity by
letting them interactively manipulate these organs. For
many surgeons who are trained primarily in open techni-
ques, this may help to overcome the perceptual and motor
challenges associated with MIS procedures.
We will first review the background of the problem and
highlight the challenges posed. During this surgical
procedure, the patient is lying on his back. As a result,
the small intestine (henceforth simply referred to as
intestine) is positioned just above the colon region, hiding
the colon beneath (Fig. 1). The intestinal region of a human
body is characterized by a very complex anatomy. The
intestine is a tubular structure, about 4 m long, constrained
within a small space of the abdominal cavity, resulting in
the creation of numerous folds. This is further complicated
by a tissue known as the mesentery that connects the
intestine to the blood vessels [3] (Fig. 2). An important
surgical task of this procedure is to displace the tissues and
organs by pulling and folding them from the site of the
operation [4]. As the surgeon manipulates these organs,
they deform and collide with each other. Thus, the broad
challenges here are the real-time animation and visualiza-
tion of these organs at an acceptable frame rate (a minimum
of 25 frames a second). Our overall approach to solving this
problem consists of a layered model: a skeletal axis
deformed using physically-based animation, rendered with
a generalized cylinder-based skinning. Thus, in order to
animate these organs in real-time, we propose to:
. efficiently model the intestine and the mesentery,
taking into account its geometry,
. detect the collisions and self-collisions occurring in
the intestinal region during animation,
. provide a fast and stable collision response.
708 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004
. L. Raghupathi, F. Faure, and M.-P. Cani are with the GRAVIR/IMAG lab,
655 ave. de l’Europe, 38334 Montbonnet, France.
E-mail: {laks, francois.faure, marie-paule.cani}@imag.fr.
. L. Grisoni, D. Marchal, and C. Chaillou are with the LIFL lab, University
of Lille 1, 59655 Villeneuve d’Ascq, France.
E-mail: {laurent.grisoni, marchal, christophe.chaillou}@lifl.fr.
Manuscript received 14 Nov. 2003; revised 19 Feb. 2004; accepted 26 Feb.
2004.
For information on obtaining reprints of this article, please send e-mail to:
tvcg@computer.org, and reference IEEECS Log Number TVCG-0108-1103.
1077-2626/04/$20.00 ß 2004 IEEE Published by the IEEE Computer Society

The skeletal model used for animation should be covered
with a triangulated mesh which can be realistically shaded
or textured. However, a naive skinning approach will create
tessellation problems in high-curvature regions. Hence, we
present:
. an efficient method to detect high-curvature regions
and to adapt the sampling of the axis accordingly,
. an algorithm that dynamically changes the skinning
parameters to maintain a preimposed frame rate,
. a hardware-based skinning feature for fast and
smooth rendering available in recent GPUs.
All these contributions have been implemented within a
surgical simulator platform [5] that can be easily evaluated
by the surgeons. Note that the first versions of our
contribution on intestine animation and rendering appeared
as separate conference proceedings [6], [7]. This paper gives
an extended presentation of both, describes their integration
into a simulator platform, provides the results of the
integration, and summarizes the evaluation of the results,
both qualitative and quantitative.
The remainder of this paper is organized as follows: In
Section 2, we briefly describe the previous work related to
our problem, from both the animation and rendering
perspectives. We then elaborate on creating a virtual
intestine and mesentery, an initial geometric model defin-
ing their shape, and a mechanical model for animation in
Section 3. Section 4 presents our collision detection and
response algorithms in detail. We then propose a method
for fast rendering, along with a self-tuning algorithm for
guaranteed frame rate in Section 5. Section 6 bri efly
describes the integration into a surgical simulator platform.
The results and validation are discussed in Section 7,
followed by the conclusions in Section 8.
2PREVIOUS WORK
2.1 Real-Time Animation of Deformable Models
Recently, many researchers have focused on the efficient
simulation of deformable models, with some of them using
adaptive, multiresolution techniques [8], [9], [10] and some
applied to surgery simulators [11], [12], [13], [14], [15], [16].
In all these works, volumetric deformable bodies were
either simulated in isolation or were interacting with a
single rigid tool, enabling the use of very specific techniques
for collision detection and response, such as methods based
on graphics hardware [17]. The problem we have to solve
here is different. As will be shown in the next section, no
volumetric deformable model will be needed since the
intestine and the mesentery can be represented as a 1D and
a 2D structure, respectively. Moreover, the main issue is
detecting and processing the collisions and self-collisions of
the intestinal system in real-time. Accordingly, a simple
spline model animated by mass-spring dynamics was used
by France et al. [18], [19] for simulating the intestine. France
et al . used a grid-based approach f or detecting self-
collisions of the intestine and collisions with its environ-
ment. All objects were first approximated by bounding
spheres, whose positions were stored, at each time step, in
the 3D grid. Each time a sphere was inserted into a
nonempty voxel, new collisions were checked within this
voxel. Thou gh this method achieved real-time perfor-
mances when the intestine alone was used, it did not
handle the simulation of the mesentery.
A well-known technique for accelerating collision detec-
tion is to approximate the objects by a bounding volume
hierarchy (BVH) [20], [21], [22], [23], [24], [25]. Such
approaches provide simple t ests for fast detection of
noncolliding regions. The BVH can be recursively updated
when the objects undergo small deformations. However,
this is not suitable for intestine-mesentery interaction,
where even a small local deformation can potentially cause
a large movement of the folds. This creates a large scale
global deformation, which prevents the BVH from being
efficiently updated. An alternate multiresolution method,
based on layered shells, was recently presented by Guy and
Debunne [26]. It is well-suited for collision detection
between deformable objects since the shells themselves
are deformable structures extracted from a multiresolution
representation of these objects. Though suitable for volu-
metric deformable bodies, this method is not appropriate
for intestine and mesentery modeling since the time-
varying folds cannot easily be approximated at a coarse
scale. They also exploited temporal coherence following Lin
and Canny’s [27] idea of detecting collisions between
convex polyhedra by tracking pairs of closest vertices.
These pairs were efficiently updated at each time step by
propagating closest distance tests from a vertex to its
neighbors. Guy and Debunne adapted this technique for
detecting collisions between their volumetric layered shells
very efficiently. Since these shells were neither convex nor
rigid, a stochastic approach was used at each time step to
RAGHUPATHI ET AL.: AN INTESTINAL SURGERY SIMULATOR: REAL-TIME COLLISION PROCESSING AND VISUALIZATION 709
Fig. 1. Position of the intestine during the surgery.
Fig. 2. Anatomy of the intestinal region.

generate new pairs of points anywhere on the two
approaching objects. These pairs were made to converge
to the local minima of the distance, disappearing when they
reached an already detect ed minimum. Our work is
inspired by this idea of stochastic collision detection
exploiting temporal coherence. It has been adapted here
to the specific processing of multiple collisions and contacts
between the intestine and the mesentery folds.
2.2 Intestine and Mesentery Rendering
In addition to handling the collisions, we also need to
provide a real-time, smooth rendering of the organs. The
intestine and the mesentery are geometrically complex
organs and also topologically distinct from each other: a
deformable cylinder-like object and a deformable, nonde-
velopable tissue. Thus, it is natural to study their rendering
separately. Many efficient techniques do exist for surfaces (a
simple tessellation actually gives good results). Hence, we
shall devote more preference to dealing with the much
harder problem of intestine rendering.
A possible approach to intestine rendering is to use an
implicit representation [18]. This is indeed a powerful
representation, especially for handling topologically com-
plex or deformable objects. Yet, it is not well-suited for our
purpose since none of its classical features are useful here.
Moreover, the blending property inherent to implicit
surfaces implies that some control operations would have
to be performed on the implicit intestine model. This
additional processing is necessary in order to avoid
unwanted blending between the intestinal folds.
A more natural approach to intestine modeling is to use
generalized cylinders, also sometimes called sweep. To our
knowledge, only a very few previous techniques dealt with
the efficient rendering of such objects. Classical generalized
cylinders are defined using a parameterized axis CðuÞ,
along with a set of planar cross-section that can be
represented as a continuous set SðuÞ depending on the
same u scalar value that parameterizes the axis [28]. The
classical tessellation approach is as follows: The axis C is
sampled either uniformly or adaptively, depending on
some curvature isolation (see [7] for an extensive overview
of the possible techniques). For each axis sample, section S
is positioned on a local frame calculated along the axis [29]
and then approximated by a polyline. Two consecutive
polyline sections along the axis are then connected by a
triangle stripset in order to form a local approximation of
the sweeps. High curvature point detection becomes a
critical step for such a process and any sharp angle is likely
to be missed in the sampling. It is also likely that the
tessellated sections can overlap, hence providing the user
with a self-intersecting mesh (see Fig. 3).
Our solution, rather, comes from skinning and thus takes
advantage of the OpenGL skinning feature provided by
recent GPUs [30]. Skinning (also called vertex blending)is
most commonly used in character deformation applications
that allow continuous deformation of a skin mesh over an
animated skeleton. The principle of this extension is as
follows: It is a standard practice to define a simple
geometric transformation in homogeneous coordinates by
a 4  4 matrix. This composition of rotation, translation, and
scaling allows an initial mesh to be positioned anywhere
within a given scene, along with simple deformations. For
an object, skinning uses two matrices (i.e., two different
positions of the object) and, for all the vertices of the object,
a scalar value (called weight) is used to interpolate the vertex
position. Acc ordingly, given an initial vertex 
0
,with
weight !ð
0
Þ and two transformations M
1
and M
2
, the
resulting position  of the vertex is given by:
 ¼ !ð
0
ÞM
1

0
þ½1  !ð
0
ÞM
2

0
: ð1Þ
The above transformation can be done entirely by the GPU
with no CPU computation involved. Set ting optimal
weights for a given deformation is, in general, a difficult
problem. Recently, Bloomenthal presented a technique for
automatically setting weights when skinning is used in
character animation [31].
The above transformation process allows for simple
deformation of the initial mesh. Fig. 4 shows a simple
2D example of what is obtained using an initial rectangle
deformation with weights that only depend on the z position
along its axis. In this figure, the weight function is similar to
the one described for other purposes in [32]. Controlling the
weight distribution curve determines the way the GPU will
interpolate from one transformation to the other. Indeed,
this technique cannot be directly applied to the rendering of
a folded generalized cylinder controlled by a skeleton, the
intestine in our case. Extending the skinning method to this
case will be the main contribution of Section 5.
3MODELING AND ANIMATING THE SYSTEM
Our overall aim is not to develop an accurate, patient-specific
trainer but rather a generic simulator which can help the
surgeons to practice the gestures used to manipulate the
organs. The first problem we have to solve is to create a virtual
model of the intestine and the mesentery which will serve as
the basis for the animation and rendering stages. In this
section, we describe the actual anatomy in brief, provide the
basis of our approach, and present the details of our model.
710 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004
Fig. 3. Classical tessellation problems on generalized cylinders. Top:
Inadequate sweep tessellation (a) and correct one (b). Bottom: Mesh
self-intersection when deforming the initial sweep.

We further present the mechanical model needed for
animating the intestinal system.
3.1 Anatomical Model
In order to extract the anatomy of the intestine and the
mesentery, we sought the help of our medical collaborator,
IRCAD, in Strasbourg (a digestive cancer research institute
[33]). With the current imagery techniques, they found it
impossible to extract the complex anatomy of organs such
as the mesentery. Hence, we decided to come up with
something simpler than the actual geometry, but which can
still capture the overall behavior.
The mesentery is a folded membrane-like surface,
approximately 15 cm wide, which links the intestine to
the main vessels of 10 cm length (Fig. 2) . Since the
mesentery cannot be unfolded onto a plane, setting up its
initial geometry free of self-intersections is quite difficult.
We solved the problem by modeling a possible rest position
for the intestine as a folded sine curve lying on the inner
surface of a cylinder of radius 15 cm. With the axis of the
cylinder representing the main vessel, the folds are placed
on the cylinder such that their total length is 4 m (Fig. 5).
Then, the mesentery can be defined as the surface generated
by the set of nonintersecting line segments linking the
cylinder axis to the curve. Though this initial geometry is
too symmetric to be realistic, this model gives adequate
local geometric properties to the mesentery membrane
(Fig. 6). When animated under the effect of gravity, these
collision-free initial positions will automatically move to
their correct positions. The geometry of the intestine is
defined by creating a piecewise tubular surface of radius
2 cm along its skeleton curve. The thickness of the
mesentery surface, parameterized based on patient-specific
data, was set to 1 cm.
3.2 Mechanical Considerations for Animation
For animation, our motivation to use a mass-spring
approach was derived from the following arguments:
. The mass-spring method is more efficient and
suitable over FEM for deforming bodies with large
displacements and local elastic deformations.
. In addition, an organ such as the intestine can have
an infinite number of rest states, whereas FEM is
based on the notion of displacements w.r.t. a unique
rest state thus making it unsuitable for our case.
. Mass-spring can provide stable simulation of de-
formable objects at moderate time steps.
. We can adjust the behavior of the system intuitively
by adjusting the damping, stiffness, etc.
. Collision detection here is a much more complex
task requiring more CPU-time over animation. So, a
very complex mechanical model might slow down
the simulation.
. Finally, the perceived quality of most interactive 3D
applications does not depend so much on exact
simu lation, but rather on real-time response to
collisions [34].
Accordingly, we designed a model consisting of mass
points connected by damped springs. Since the mesentery
has a much larger length (4 m near the intestine) than width
(15 cm near the vessel), we sampled our model by four sets of
100 masses each (Fig. 6). The last set of masses requires no
computation since they are attached to the main vessels,
requiring only 300 masses to be integrated at each time step.
In addition, no specific model is needed for the intestine since
it can be simulated by adjusting the mass and stiffness values
along the first bordering curve of the mesentery surface.
RAGHUPATHI ET AL.: AN INTESTINAL SURGERY SIMULATOR: REAL-TIME COLLISION PROCESSING AND VISUALIZATION 711
Fig. 4. Simple skinning application to a polygonal primitive. Combination
of M
1
and M
2
transformations on the object (top-left), using the weights
(bottom-left), gives the results (right).
Fig. 5. Initialization of the geometry of the intestine and mesentery. The
intestine is drawn on the inner surface of a small cylinder. The figure is
greatly simplified for clarity.
Fig. 6. Mechanical model of the organs (shown unfolded).

4REAL-TIME COLLISION PROCESSING
A major computational bottleneck in many animation/
simulation systems is the handling of collisions between the
objects under the influence of external forces (gravity, user-
input, etc.). In our case of real-time simulation, we need to
perform this as quickly as possible. Failure to detect the
collisions will result in interpenetration—an unrealistic
behavior. In this section, we describe our approach, which
efficiently detects the colliding regions, and a response
algorithm, which prevents/corrects the interpenetrations.
4.1 Collision Detection
Our m ethod for real-time collisi on detection exploits
temporal coherence [26], [27] (i.e., pairs of closest points
between colliding bodies are tracked over time). The main
differences here are: 1) the interacting objects have a tubular
(intestine) or a membrane-like structure (mesentery) and
2) most collisions will be self-collisions between different
folds of the same body. We first explain the collision
detection method for the intestine alone and then explain
the mesentery case.
Collision detection between cylinders can be processed
by computing the closest distance between their axes [35],
and comparing them to the sum of their radii. For the
intestine, computing the distance between two segments is
done by considering the distance between their principal
axes (a segment here refers to a simple line segment and its
end-points are parameterized by ðs; tÞ2½0; 1). We then
store the ðs; tÞ value corresponding to the closest point
within the segments and the actual minimum distance d
min
.
Adapting the notion of “closest element pairs” to this
skeleton curve means that we track the local minima of the
distance between nonneighboring segments along the curve
(Fig. 7). Of course, only the local minima satisfying a given
distance threshold are considered relevant. We refer to
these pairs of segments as active pairs. Each active pair is
locally updated at each time step in order to track the local
minima when the intestine folds move. This is done by
checking whether it is the current segment pair or a pair
formed using one of their neighbors now corresponds to the
smallest distance. This update requires nine distance tests
(Fig. 8) and the pair of segments associated with the closest
distance becomes the new active pair. When two initially
distant active pairs converge to the same local minimum,
one of them is suppressed. A pair is also suppressed if the
associated distance is greater than a given threshold.
The above process tracks the existing regions of interest,
but does not detect new ones. Since the animation of the
intestine may create new collisions, a method for creating
new active pairs of segments is needed. Our approach is
inspired by the stochastic approach of [26]. At each time
step, in addition to the update of the currently active pairs,
n additional random pairs of segments, uniformly distrib-
uted between the end-points, but under the distance
threshold, are generated. The update of these extra active
pairs is similar to the update of the existing local minima.
The complexity of the detection process thus linearly varies
with the user-defined parameter n. At each time step,
collision detection consists of selecting, from among the
currently active pairs, the pairs of segments which are
closer than the sum of their radii. Collision response (cf.
Section 4.2), will then be applied between these segments.
For the mesentery, the total number of segments to be
considered during each time step is too large for real-time
computation. We use the following approximations to
reduce the complexity of the problem: First, since the
mesentery is very thin and soft compared to the intestine,
its self-collisions will have almost no effect on the overall
behavior of the system. Hence, we ignore the testing of
these and only consider the nontrivial cases of intestine-
intestine and intestine-mesentery interactions.
Second, we use a two-step convergence algorithm to
reduce the number of distance computations required for
the mesentery. Accordingly, given a segment pair ðS
1
;S
2
Þ,
we first find if there exists another segment S
0
1
that is the
closest to S
2
(S
0
1
is S
1
if all other neighbors are further from
S
2
). Then, we find a segment S
0
2
that is the closest to S
0
1
. This
update requires 13 distance computations at most (i.e.,
between an intestine segment and a nonneighboring
mesentery segment). When a collision is detected, we apply
a response force not only to the deepest penetrating
segment-pair but also to the entire collision area (both for
intestine and mesentery). A recursive algorithm searches
the neighbors to find all the colliding pairs in the area.
4.2 Collision Response
We initiate the response whenever the distance between the
two segments is less than the sum of their radii. The earlier
approaches, such as the penalty method [36] and the
reaction constraint met hod [37], implemente d collision
response by altering the force matrix in the mass-spring
method. This force has to be of large magnitude in order to
be effective in large time step scenarios. However, this may
cause segment displacements several times larger than their
thickness, thus creating new collisions and instabilities.
Instead, our new method alters the displacements and
velocities such that it instantaneously cancels the inter-
penetration while keeping a resting contact between the two
colliding bodies with no bouncing effects.
712 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004
Fig. 7. Tracking the local minima of distance between nonneighboring
segments.
Fig. 8. Distance computation between two intestine segments.

Let the end-point velocities of segment S
1
be v
1
and v
0
1
and that of segment S
2
be v
2
and v
0
2
, respectively. Let x
1
, x
0
1
,
x
2
, and x
0
2
be the corresponding end-point positions. Let v
c1
and v
c2
be the velocities of the closest approaching points
within each segment and x
c1
and x
c2
be the positions of the
closest points (Fig. 9). Let
s ¼ 1  s and t ¼ 1  t. We have:
v
c1
¼ sv
1
þ sv
0
1
v
c2
¼ tv
2
þ tv
0
2
: ð2Þ
Let two impulses per time step, f and f
0
ð¼ fÞ (one for
each segment), be applied along the direction of collision u
to cause a velocity change such that the relative velocities
along u is zero. These impulses should set the new
velocities v
newc1
and v
newc2
such that:
1
ðv
newc1
 v
newc2
Þu ¼ 0: ð3Þ
This cancels the penetration velocity and avoids any
bouncing. The impulse f acting on the point of collision
can be split between the end-points according to their
barycentric coordinates. Then, we have:
v
new1
¼ v
1
þ
sf
m
1
uv
0
new1
¼ v
0
1
þ
sf
m
0
1
u
v
new2
¼ v
2
þ
tf
m
2
uv
0
new2
¼ v
0
2
þ
tf
m
0
2
u;
ð4Þ
where m
1
, m
0
1
, m
2
, and m
0
2
are the masses of the end-points.
Again, expressing the new velocity of the colliding point
v
newc1
in terms of v
new1
and v
0
new1
:
v
newc1
¼ sv
new1
þ sv
0
new1
¼ v
c1
þ
s
2
m
1
þ
s
2
m
0
1

fu:
ð5Þ
Similarly, for segment S
2
:
v
newc2
¼ v
c2

t
2
m
2
þ
t
2
m
0
2
!
fu: ð6Þ
Substituting (5) and (6) into (3), we have:
f ¼
ðv
c2
 v
c1
Þu
s
2
m
1
þ
s
2
m
0
1
þ
t
2
m
2
þ
t
2
m
0
2
: ð7Þ
Using this value of f, we compute the new velocities of the
end-points from (4). We use a similar formulation for
correcting the positions of the colliding segments. The only
difference is in the condition for avoiding interpenetration,
which considers the segment radii r
1
and r
2
:
ðx
newc1
 x
newc2
Þu ¼ r
1
þ r
2
: ð8Þ
The integrated impulse value g that changes the positions in
accordance with the above condition is then:
g ¼
ðx
c1
 x
c2
Þu þ r
1
þ r
2
s
2
m
1
þ
s
2
m
0
1
þ
t
2
m
2
þ
t
2
m
0
2
: ð9Þ
g is used to modify the end-point positions as in (4).
We note that updating the position and the velocity of
one edge may still create or cancel collisions among other
segments. A possible solution is to repeat the collision check
for all the pairs in our list in order to identify such pairs.
But, this may result in an endless loop. So, in our
implementation, we prefer using a fixed number of
iterations, even if we miss some collisions during the
current time step. Handling multiple collisions in general is
a difficult problem even for rigid bodies, with no
straightforward solution. Some approaches based on a
global solution (simultaneous handling of all the collisions)
have been proposed. Giang et al. [38] constructed this as a
constrained optimization problem and used an LCP-based
(Linear Complementarity Problem) solution. Needless to
say, it is much more difficult for flexible bodies with real-
time constraints and, to our knowledge, no such techniques
exist for our case.
5SKINNING AND RENDERING
In this section, we present our approach for intestine and
mesentery rendering. We shall deal with them separately as
explained before. Medical experience showed that it is very
hard to perceive how the mesentery actually deforms.
However, we observed that this surface most often lies
behind the intestine during surgical manipulations. Thus,
the main purpose of simulating the mesentery is to ensure
proper mechanical behavior of the intestine. As a result, we
chose a very coarse renderingrepresentationforthe
mesentery. The rendering primitive is simply a triangle
stripset whose points are the intestine mechanical sampling
points and the mesentery root. Using two separate models
for mechanics and rendering did not attract any negative
comments from the surgeons during demonstration, which,
in a way, vindicates our presumption. We now describe the
approach we used for efficiently rendering the intestine.
5.1 High-Curvature Detection and Adaptive
Sampling
We first convert the mechanical sampling points of the
intestine axis into a cardinal spline approximation (an
interpolation spline), which is a straightforward process [39].
This is done in order to counterbalance the piecewise linearity
of the mechanical model. The underlying idea behind the
sampling process is fairly simple. Many interesting spline
models have a regularity property [40]. This analytic property
has among its consequences that no undesired oscillation
appears in a given spline segment. In other words, a curve’s
overall shape can be somewhat predetermined by studying
its control point configuration. Although we used cardinal
RAGHUPATHI ET AL.: AN INTESTINAL SURGERY SIMULATOR: REAL-TIME COLLISION PROCESSING AND VISUALIZATION 713
Fig. 9. Collision response by displacement-velocity correction.
1. Where  denotes a vector dot product.

splines in our experiments, most of these techniques can be
easily generalized to other cases [7].
The sampling process uses the following input variables:
the contr ol point sequence ðP
0
;P
1
; ...;P
n
Þ of C,the
corresponding key parameter values ðu
0
;u
1
; ...;u
n
Þ (uni-
formly sampled with u
k
¼ k, where  is a constant value),
and some threshold value ". Recall that these control points
are generated from the mechanical sampling points using
spline approximation. The sampling algorithm is split into
two steps:
Step 1: A first pass calculates the indicators of the local
spline curvature. The spline regularity ensures that such a
perturbation can be studied by considering only the control
point configuration. A sequence of scalar values fc
i
g
i¼0...n
is
defined using:
c
i
¼
1
2

P
i1;i
:P
i;iþ1
kP
i1;i
kkP
i;iþ1
k
þ 1

; ð10Þ
where P
i;j
¼ P
j
 P
i
. Extremal values c
0
and c
n
are treated
by considering two additional ghost sampling point s,
generated using the Bessel technique [39], i.e., the ghost
point at u
1
(similarly u
nþ1
) is calculated using the unique
parabola that interpolates P
0
, P
1
, P
2
(similarly P
n
, P
n1
,
P
n2
). Note that c
i
, which measures the local control point
curvature, is proportional to the dot product (cosine of the
angle). Hence, a higher curvature will result in a smaller
angle between the segments and, consequently, a higher c
i
value (10). Fig. 10 shows a visual evaluation of this step,
associating different colors to each segment, depending on
the numerical values of c
i
. Here, the darker regions
correspond to those segments that the algorithm selects as
high curvature ones.
Step 2: A second pass further processes the segments that
potentially contain high-curvature points (only one such
point is possible per spline segment, once again thanks to
regularity). For each parameter interval ½u
i
;u
iþ1
,ifjc
i
j <"
and jc
iþ1
j <", then the spline segment ½u
i
;u
iþ1
 is treated as
a whole by the display process. Otherwise, the correspond-
ing spline segment potentially contains a high-curvature
point which can be detected by symbolic root extraction. In
the case of uniform cardinal splines, the maximal curvature
parameter point m
i
on a segment satisfies a linear equation.
Using this, the parameter segments that are actually drawn
are ½u
i
;m
i
 
i
, ½m
i
 
i
;m
i
þ 
0
i
, and ½m
i
þ 
0
i
;u
iþ1
, with

i
¼
m
i
 u
i
3
and 
0
i
¼
u
iþ1
 m
i
3
: ð11Þ
Such a separation ensures that the frame calculation (cf.
Section 5.2) is always done at low curvature regions of the
spline, ensuring numerical stability. Thus, the regularity
property ensures that the high curvature segments are
detected during the first pass of the process itself. It only
involves a simple and fast computation, thus fitting the
requirement for real-time rendering. The second pass
positions the additional sampling points in the hi gh-
curvature segments in order to get a more stable tessella-
tion. This sampling process is somewhat related to the
surface analysis technique described in [41], where both
symbolic and numerical tools are combined for solving the
addressed problem. Here, the high curvature segments are
isolated using numerical evaluators c
i
and the maximal
curvature points are calculated using symbolic extraction
on the considered spline segment. The main difference is
the simplification done in order to achieve faster perfor-
mance. However, with this modification (especially regard-
ing c
i
), no theoretical validation is available. In addition, our
scheme does not guarantee the minimality of the number of
samples with respect to any error criteria. It simply ensures
that no high curvature point will be missed. Our method
makes sure that a spline curve is turned into a set of interest
points along the curve (i.e., those corresponding to segment
extremities and high-curvature regions). The resulting
curve segments are displayed using a hardware-based
technique described in the following section.
5.2 Hardware-Based Rendering Using Skinning
The skinning definition (cf. Section 2) provides us with a
quite powerful tessellation primitive, more complex than an
ordinary polygon. In this section, we will define a
tessellation elementary cell from a regular cylinder with a
standard weight function and two matrices M
1
and M
2
.We
shall also see how combining this simple, precomputed
cylindrical shape with the skinning deformation process
can significantly reduce the software side of the tessellation
process. We now describe the overall tessellation algorithm
in two steps:
Step 1: The sampling process gives a set of parameter
intervals ½a
j
;a
jþ1
 (fa
j
g is a reordered set of fu
i
g with the
inserted parameters of the high-curvature region).
Step 2: For each interval generated by the sampling
algorithm, two frames (one for each segment extremity) are
calculated along the axis of C as follows [29]: Each frame
ðt
j
; k
j
; b
j
Þ corresponding to the parameter value a
j
is
calculated from the previous frame using:
2
b
j
¼ t
j
 k
j1
and k
j
¼ b
j
 t
j
: ð12Þ
The t
j
vectors are always assigned the first derivative of the
local curve. This reduces the frame twist along the curve,
which is not the case when using a simple Frenet frame.
However, for the first frame alone (corresponding to a
0
), we
use the Frenet frame. Each frame gives the local orientation
of the sweep cross-section. These frames generate the
homogeneous transformation matrices M
1
and M
2
for the
considered parameter interval. They are then used by the
blending technique (cf. Section 2) on an elementary
714 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004
Fig. 10. Spline segment coloration to illustrate our curvature isolation
process, during interactive sweep deformation.
2. Where  denotes a vector cross product.

nondeformed cylinder aligned along the z-axis, described in
our implementation as:
x
2
þ y
2
¼ 1
z 2½0; 1:

ð13Þ
This nondeformed cylinder is approximated by polygons
using a positive integer n as the approximation resolution.In
our implementation, we used 2
nþ1
sections for the cylinder,
uniformly positioned along the cylinder axis. All the
sections are discretized at a given constant resolution. The
higher the n value, the smoother the interpolation between
the frames represented by M
1
and M
2
. Many weight
functions are available for smooth deformation results
(see [7] for possible choices). In our case, the weight
function should be smooth, locally supported, and mono-
tonically decreasing from 1 to 0. Accordingly, we used the
following:
!ðÞ¼
1  2z
2

;z
2

<
1
4
ð1z
2

Þ
2
0:75þ1:5z
2

;z
2


1
4
;
(
ð14Þ
where z

is the z-coordinate of the vertex  on the
nondeformed cylinder defined in (13). This weight function
is a particular case of the more general function proposed in
[32] for soft objects blending.
Fig. 11 shows an example of a tessellation achieved using
this technique (hence, the display primitive is a deformed
cylinder). We can observe that the results of this new
technique are visually more pleasing than the standard
approach (brute-force tessellation with piecewise linear
approximation) and the high-curvature points are handled
in a much better way (see the box in Fig. 11). The software
part of this tessellation only involves the calculation of the
geometric transformations and no vertex position is ex-
plicitly evaluated and transmitted to the GPU during the
display process. The tessellation primitive for a given
resolution n is constant over time since only the matrix
changes from one parameter interval to another. Thus, it
can be stored in a displaylist using vertexArray technology
[30] to take f ull advantage of the data transmission
optimizations of the GPU. Note that there is no mathema-
tical proof that such a deformation tool can properly handle
all the classical tessellation problems. We also observe that
increasing the number of vertices on the tessellation
primitive results in smoother deformations (Fig. 12).
Though this may seem quite obvious, the smoothing
involves only a small CPU overhead since the deformation
process is performed entirely by the GPU. The only
overhead needed is the transmission of the tessellation
primitive to the GPU.
5.3 Guaranteed Frame Rate
The accuracy of the entire visualization process described
above depends on two parameters. The first parameter, ",
determines how many parameter intervals will be used in
the tessellation of the skeleton curve (this number should at
least be equal to the number of spline segments on C). The
second parameter n defines the complexity of the cylinder
primitive used for tessellation. In our implementation, we
actually use several versions of the tessellation primitive.
The number of polygons in each version is Oð2
i
Þ, i ¼
0; ...;n (cf. Section 5.2). For a given parameter interval,
increasing the number of vertices on the tessellation
primitive produces smoother interpolation with only a
small measured computational overhead. Accordingly, we
combine the tessellation scheme with an algorithm that
compares the current frame rate with a given reference
value and tunes the " and n values automatically. In
principle, this can be seen as a feedback control loop. More
precisely, the iterations from one display configuration
ð"
k
;n
k
Þ to th e next one ð"
kþ1
;n
kþ1
Þ use the following
relations:
"
kþ1
¼ "
k
þ ðf
0
 f
k
Þ

kþ1
¼ 
k
þ ð"
kþ1
 "
k
Þ
n
kþ1
¼b
kþ1
c;
ð15Þ
where 
k
is a floating point version of the integer variable
n
k
,  and  are two arbitrary constants, f
k
is the current
measured frame rate, and f
0
is the desired one. In our
implementation, we used  ¼ 10
4
and  ¼ 5. These values
were experimentally determined in order to provide a
satisfactory frame rate control (Fig. 12). The tessellation
process stabilizes itself at the desired frame rate in less than
a second.
6SYSTEM INTEGRATION
The models presented so far have been integrated into a
simulation p latform for seamless interoperability with
existing models and tools. We now briefly describe the
SPORE library (see [5], [15] for more details). Developed in
C++, this library provides a fully functional environment
RAGHUPATHI ET AL.: AN INTESTINAL SURGERY SIMULATOR: REAL-TIME COLLISION PROCESSING AND VISUALIZATION 715
Fig. 11. (a) Standard tessellation result and (b) high quality rendering
using our new technique.

for the simulation of minimally invasive ovarian surgery.
All the objects within this library are decomposed into three
different models: a geometric model used for rendering, a
mechanical model for animation, and a collision detection
model for evaluating the influence of the environment. The
three layers of an object share the necessary information in
order to access them (e.g., external forces are transferred
from the collision model to the mechanical model, which in
turn transfers the state variables to the geometric model for
rendering). The library is designed such t hat all the
interactions between objects are sphere-based, which is a
good trade off between speed and being generic. As a
result, the system composed of the intesti ne and the
mesentery has been included within the simulator as a
whole and is treated by other simulated objects as a single
entity. SPORE is organized as follows: A global animation
process iteratively processes the u ser interactio ns and
collisions between objects in order to calculate the forces that
will be applied to each object. It then gives an object the
possibility to evaluate its own behavior, by calling an ad hoc
method of the object class, transferring the applied external
forces to itself. This way, the system composed of intestine
and mesentery can calculate the forces due to self-collision
and the response to the global force system by itself using the
techniques described earlier. With this system integration, we
can evaluate the simulator for its performance and realism,
the results of which are presented in the following section.
7RESULTS AND VALIDATION
Simulator Results: Snapshots from the real-time animation of
the simulator are shown in Fig. 13. In all cases, the organs
were subject to forces due to gravity, user-input, and
collisions. Fig. 13a shows the case of an isolated intestine
and mesentery manipulated by a virtual probe (the tiny
sphere). Note that our displacement-velocity method for
collision response produces fairly stable simulations
(Fig. 13b) with some undesired vibrations. Fig. 13c and
Fig. 13d show the simulations inside a simulated abdominal
cavity. All the snapshots were captured from our simulator
in real-time on a standard PC with Bi-Athlon 1.2 GHz, 512
MB RAM and nVIDIA GeForce 3 graphics card. A dynamic
real-time demonstration of our simulator is available as a
companion to this paper at: http://www-evasion.imag.fr/
Membres/Laks.Raghupathi/intestine.html.
Quantitative Validation: The mechanical and collision
detection model were implemented and tested indepen-
dently prior to the integration. The results were fast enough
to run at 30 Hz on a standard PC and the overall behavior
was good. However, due to the stochastic nature of our
algorithm, we do not have any theoretical proof that all the
collisions are detected. However, in Fig. 14, we present one
of the several evaluations which we performed on the
collision processing algorithm (see [6] for detailed results).
Here, as the object is deformed, we plotted the colliding
regions as detected by our method and a naive Oðn
2
Þ
method. Results show that our method is able to identify all
the active colliding regions by evaluating a far fewer number
of points. Though not the same as finding the exact collisions,
this is good enough for our case since we can quickly
narrow down to these points using temporal coherence.
Nevertheless, we miss collisions in some cases between
intestine-mesentery due to an entirely different reason
(Fig . 13d). The interpenetrations occurred because we
performed only segment-segment collision detection. Note
that this technique worked well for intestine-intestine
collisions and we do not see any collisions missed here.
But, the mesentery was modeled as a triangulated mesh
and, when there are cases of segment-triangle or point-
triangle collisions, the above approach in its present form
was not effective. More recently, we extended this approach
by adding point-triangle, edge-triangle cases and tested it
successfully with a mesentery-like surface.
Qualitative Validation: The prototype simulator was
demonstrated to the surgeons at IRCAD in July 2003. The
surgical educators practiced on our simulator and ex-
plained to us the good points as well as the drawbacks of
the current model. The overall intesti ne behavior and
contact modeling was observed to be very good. Some of
the instabilities observed in certain cases of the intestine’s
motion actually turned out to simulate a patient who is
spasmodic (suffering from intestinal convulsions).
Although this happens quite frequently in a real patient,
this problem can be fixed by increasing the damping of the
system. They also suggested that the mesentery should be
less elastic. With our mass-spring model, the characteristics
demanded by the surgeons can be obtained simply by
tuning the simulation parameters. Though these parameters
can be varied intuitively, it is difficult to incorporate those
parameters obtained from biometric studies. Finally, a small
error was detected in the geometric design—the mesentery
should have a zero width at the two extremities, where the
intestine is directly attached to the main vessels.
8CONCLUSIONS
Our novel anatomical model greatly simplifies the problem
of simulating a complex deformable organ in real time. The
collision model efficiently determines all the active colliding
regions and provides a realistic and stable response. Our
rendering technique quickly generates high-quality image
sequences with no tessellation artifacts. All of our three
contributions were integrated into a surgical simulator
platform with real-time performance. The feedback from
the surgeons is positive in general, with suggestions for
improvements. The corrections are not hard to incorporate
into our system and we are currently working on them. We
believe that our simulator can be used as a generic trainer
that can mimic the behavior of the organs very well, thus
eventually replacing the practice on animals. The results
encouraged us to include triangle tests for more robust
716 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004
Fig. 12. (a) Low quality tessellation and (b) high quality tessellation
obtained using our automatic frame rate adaptation system at 900 and
460 frames/sec, respectively, on a GeForce 4-based system.

collision detection. We are also working on adapting
continuous collision detection techniques for handling fast
motion of thin objects such as membranes, vessels, etc.
ACKNOWLEDGMENTS
This work is supported by INRIA (National Institute for
Research in Computer Science and Control) under the ARC
SCI grant (Intestine Surgery Simulator project). The authors
would like to thank Luc Soler (IRCAD) for his help on
anatomy and for fac ilitating the feedback from the
surgeons.
REFERENCES
[1] A.P. Fine, “Patient Information: Laparoscopic Colon Surgery” Soc.
Laparoendoscopic Surgeons, Inc., 2004, http://www.sls.org/
patientinfo/colon.html.
[2] S. Sgambati and G. Ballantyne, “Minimally Invasive Surgery for
Diseases of the Colon and Rectum: The Legacy of an Ancient
Tradition,” Laparoscopic Colectomy, R. Jager and S. Wexner, eds.,
pp. 13-23, New York: Churchill & Livingstone, 1995.
[3] L. Augusten, R. Bowen, and M. Rouge, “Pathophysiology of the
Digestive System, ” Colorado State Univ., 20 04, http://
arbl.cvmbs.colostate.edu/hbooks/pathphys/digestion.
[4] “Laparoscopic Colectomy,”Center for Videoendoscopic Surgery,
Univ. of Washington, 2004, http://depts.washington.edu/cves/
lapcol.html.
[5] P. Meseure, J. Davanne, L. Hilde, J. Lenoir, L. France, F. Triquet,
and C. Chaillou, “A Physicall y Based Virtual Environment
Dedicated to Surgical Simulation,” Surgical Simulation & Soft
Tissue Modeling, pp. 38-46, Springer, 2003.
[6] L. Raghupathi, V. Cantin, F. Faure, and M.-P. Cani, “Real-Time
Simulation of Self-Collisions for Virtual Intestinal Surgery,”
Surgical Simulation & Soft Tissue Modeling, pp. 15-26, 2003.
[7] L. Grisoni and D. Marchal, “High Performance Generalized
Cylinder Visualization,” Proc. Shape Modeling Int’l ’03, pp. 257-
263, 2003.
[8] S. Capell, S. Green, B. Curless, T. Duchamp, and Z. Popovic,
“Interactive Skeleton-Driven Dynamic Deformations, ” Proc.
SIGGRAPH ’02, pp. 586-593, 2002.
[9] G. Debunne, M. Desbrun, M.-P. Cani, and A.H. Barr, “Dynamic
Real-timeDeformations Using Space and Time Adaptive Sam-
pling,” Proc. SIGGRAPH ’01, pp. 31-36, 2001.
[10] E. Grinspun, P. Krysl, and P. Schro
¨
der, “CHARMS: A Simple-
Framework for Adaptive Simulation,” Proc. SIGGRAPH ’02, 2002.
[11] M. Bro-Nielsen, “Finite Element Modeling in Surgery Simulation,”
Proc. IEEE, vol. 86, no. 3, pp. 490-503, 1998.
[12] D.L. James and D.K. Pai, “ArtDefo—Accurate Real Time Deform-
able Objects,” Proc. SIGGRAPH ’99, pp. 65-72, 1999.
[13] G. Sze
´
kely,C.Brechbu
¨
hler,R.Hutter,A.Rhomberg,N.
Ironmonger, and P. Schmid, “Modelling of Soft Tissue Deforma-
tion for Laparoscopic Surgery Simulation,” Medical Image Analysis,
no. 4, pp. 57-66, 2000.
[14] S. Cotin, H. Delingette, and N. Ayache, “A Hybrid Elastic Model
for Real-Time Cutting, Deformations, and Force Feedback for
Surgery Training and Simulation,” The Visual Computer, vol. 16,
no. 8, pp. 437-52, 2000.
RAGHUPATHI ET AL.: AN INTESTINAL SURGERY SIMULATOR: REAL-TIME COLLISION PROCESSING AND VISUALIZATION 717
Fig. 13. Snapshots from our intestinal surgery simulator. (a) Intestine
and mesentery on a plane pulled by a probe. (b) Stable rest position.
(c) Inside the virtual abdominal cavity. (d) Case when collision detection
fails (see encircled region).
Fig. 14. Quantitative evaluation of the collision detection method. Points
in green (light circles) detected by the Oðn
2
Þ method and blue (dark
points) by our approach.

[15] P. Meseure and C. Chaillou, “A Deformable Body Model for
Surgical Simulation,” J. Visualization and Computer Animation,
vol. 11, no. 4, pp. 197-208, 2000.
[16] M. Kauer, V. Vuskovic, J. Dual, G. Sze
´
kely, and M. Bajka, “Inverse
Finite Element Characterization of Soft Tissues,” Proc. Int’l Conf.
Medical Image Computing and Computer-Assisted Intervention (MIC-
CAI), 2001.
[17] J.C. Lombardo, M.-P. Cani, and F. Neyret, “Real-Time Collision
Detection for Virtual Surgery,” Proc. Computer Animation ’99,
pp. 82-91, 1999.
[18] L. France, A. Angelidis, P. Meseure, M.-P. Cani, J. Lenoir, F. Faure,
and C. Chaillou, “Implicit Representations of the Human
Intestines for Surgery Simulation,” Proc. Modeling & Simulation
for Computer Aided Medicine & Surgery (ESAIM), M. Thiriet, ed.,
pp. 42-47, 2002.
[19] L. France, J. Lenoir, P. Meseure, and C. Chaillou, “Simulation of a
Minimally Invasive Surgery of Intestines,” Proc. Fourth Virtual
Reality Int’l Conf., June 2002.
[20] G. Bradshaw and C. O’Sullivan, “Sphere-Tree Construction Using
Dynamic Medial Axis Approximation,” Proc. Symp. Computer
Animation, pp. 33-40, 2002.
[21] J.D. Cohen, M. C. Lin, D. Manocha, and M.K. Ponam gi,
“I-COLLIDE: An Interactive and Exact Collision Detection System
for Large-Scale Environments,” Proc. ACM Symp. Int’l 3D
Graphics, pp. 189-196, 1995.
[22] S. Gottschalk, M. Lin, and D. Manocha, “OBBTree: A Hierarchical
Structure for Rapid Interference Detection,” Proc. SIGGRAPH ’96,
1996.
[23] I.J. Palmer and R.L. Grimsdale, “Collision Detection for Animation
Using Sphere Trees,” CG Forum, vol. 14, no. 4, pp. 105-116, 1995.
[24] G. van den Bergen, “Efficient Collision Detection of Complex-
Deformable Models Using AABB Trees,” J. Graphics Tools, vol. 2,
no. 4, pp. 1-14, 1997.
[25] J. Klosowski, M. Held, J. Mitchell, H. Sowizral, and K. Zikan,
“Efficient Collision Detection Using Bounding Volume Hierar-
chies of k-DOPs,” IEEE Trans. Visualization and Computr Graphics,
vol. 4, no. 1, pp. 21-36, Jan.-Mar. 1998.
[26] S. Guy and G. Debunne, “Monte-Carlo Collision Detection,”
INRIA, Technical Report RR-5136, 2004, http://artis.imag.fr/
Publications/2004/GD04/.
[27] M. Lin and J. Canny, “Efficient Collision Detection for Anima-
tion,” Proc. Third EG Animation & Simulation Workshop, 1992.
[28] G. Agin and T. Binford, “Representation and Description of
Curved Objects,” IEEE Trans. Computers, vol. 25, no. 4, pp. 439-449,
Apr. 1976.
[29] J. Bloomenthal, “Calculation of Reference Frames along a Space
Curve,” Graphics Gems, A. Glassner, ed., pp. 567-71, New York:
Academic Press, 1990.
[30] OpenGL Vertex Weighting, NVIDIA Corp., 2004, http://
developer.nvidia.com/object/GL_EXT_vertex_demo.html.
[31] J. Bloomenthal, “Medial-Based Vertex Deformation,” Proc. Symp.
Computer Animation, pp. 147-151, 2002.
[32] C. Blanc and C. Schlick, “Extended Field Functions for Soft
Objects,” Proc. Implicit Surface ’95, pp. 21-32, 1995.
[33] L’Institut de Recherche contre les Cancers de l’Appareil Digestif,
Strasbourg, 2004, http://www.ircad.org.
[34] S. Uno and M. Slater, “The Sensitivity of Presence to Collision
Response,” Proc. IEEE Symp. Virtual Reality and Its Application in
Industry (VRAI), pp. 95-103, 1997.
[35] D.H. Eberly, 3D Game Engine Design: A Practical Approach to Real-
Time Computer Graphics. Morgan Kaufmann, 2000.
[36] D. Baraff and A. Witkin, “Large Steps in Cloth Simulation,” Proc.
SIGGRAPH ’98, pp. 43-54, 1998.
[37] J. Platt and A. Barr, “Constraints Methods for Flexible Models,”
Proc. SIGGRAPH ’88, pp. 279-288, 1988.
[38] T. Giang, G. Bradshaw, and C. O’Sullivan, “Complementarity
Based Multiple Point Collision Resolution,” Proc. Fourth Irish
Workshop Computer Graphics, pp. 1-8, 2003.
[39] G. Farin, Curves and Surfaces for Computer Aided Geometric Design.
New York: Academic Press, 1990.
[40] L. Piegl and W. Tiller, The NURBS Book. New York: Springer, 1995.
[41] G. Elber and E. Cohen, “Second Order Surface Analysis Using
Hybrid Symbolic and Numeric Operators,” ACM Trans. Graphics,
vol. 12, no. 2, pp. 160-178, 1993.
Laks Raghupathi received the BSEE degree
from the Birla Institute of Technology & Science,
Pilani, India, in 1999 and the MSEE degree from
the University of Texas at Arlington in 2002. He
is currently pursuing the PhD degree at the
Institut National Polytechnique de Grenoble,
France, and is a member of the GRAVIR/IMAG
laboratory. His research interests include physi-
cally-based modeling, collision detection, and
various other aspec ts of real-time computer
graphics. He is a member of Tau Beta Pi and Eta Kappa Nu.
Laurent Grisoni received the diploma in com-
puter science from the ENSEIRB national
engineering school in 1996 and the PhD degree
from the University of Bordeaux I in 1999. He is
currently an assistant professor at the Poly-
tech’Lille engineering school, University of Lille
1, and is a member of the INRIA ALCOVE
project. His research interests include spline and
implicit modeling, animation, and multiresolution
aspects.
Franc¸ois Faure received the PhD degree in
computer science from the University of Joseph
Fourier, Grenoble, France, in 1997, where he is
currently an assistant professor. He previously
studied mechanical engineering at the

EEcole
Normale Supe
´
rieure de Cachan. His research
interests are about physically-based animation
of complex scenes.
Damien Marchal received the Master’s degree
from the University of Lille 1 in 2003. He is
currently working on the PhD degree at the LIFL
lab and is a member of the INRIA ALCOVE
project. His research interests include collision
detection, deformable models, and hardware-
accelerated computation.
Marie-Paule Cani is a graduate of the

EEcole
Normale Supe
´
rieure and received the PhD
degree from the University of Paris Sud in
1990. She is a professor of computer science
at the Institut National Polytechnique de Greno-
ble, France. Her main research interests cover
physically-based simulation, implicit surfaces
applied to interactive modeling and animation,
and the design of layered models incorporating
alternative representations and LODs.
Christophe Chaillou has been a professor at
the Polytech’Lille engineering school, University
of Lille 1 since 1995 and is the research director
of the INRIA ALCOVE project. His research
interests include haptic peripheral design and
collaborative virtual environments.
718 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004