Content uploaded by Damien Marchal

Author content

All content in this area was uploaded by Damien Marchal

Content may be subject to copyright.

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

i1;i

:P

i;iþ1

kP

i1;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

n1

,

P

n2

). 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

j1

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

ð1z

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