ArticlePDF Available

Abstract and Figures

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.
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.
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.
. 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}
. 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}
Manuscript received 14 Nov. 2003; revised 19 Feb. 2004; accepted 26 Feb.
For information on obtaining reprints of this article, please send e-mail to:, 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
. 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.
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
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
weight !ð
Þ and two transformations M
and M
, the
resulting position of the vertex is given by:
¼ !ð
þ½1 !ð
: ð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.
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.
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.
Fig. 4. Simple skinning application to a polygonal primitive. Combination
of M
and M
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).
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
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
we first find if there exists another segment S
that is the
closest to S
is S
if all other neighbors are further from
). Then, we find a segment S
that is the closest to S
. 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.
Fig. 7. Tracking the local minima of distance between nonneighboring
Fig. 8. Distance computation between two intestine segments.
Let the end-point velocities of segment S
be v
and v
and that of segment S
be v
and v
, respectively. Let x
, x
, and x
be the corresponding end-point positions. Let v
and v
be the velocities of the closest approaching points
within each segment and x
and x
be the positions of the
closest points (Fig. 9). Let
s ¼ 1 s and t ¼ 1 t. We have:
¼ sv
þ sv
¼ tv
þ tv
: ð2Þ
Let two impulses per time step, f and f
ð¼ 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
and v
such that:
Þ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
¼ v
¼ v
¼ v
where m
, m
, m
, and m
are the masses of the end-points.
Again, expressing the new velocity of the colliding point
in terms of v
and v
¼ sv
þ sv
¼ v
Similarly, for segment S
¼ v
fu: ð6Þ
Substituting (5) and (6) into (3), we have:
f ¼
: ð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
and r
Þu ¼ r
þ r
: ð8Þ
The integrated impulse value g that changes the positions in
accordance with the above condition is then:
g ¼
Þu þ r
þ r
: ð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.
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
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
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
; ...;P
Þ of C,the
corresponding key parameter values ðu
; ...;u
Þ (uni-
formly sampled with u
¼ 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
defined using:
þ 1
; ð10Þ
where P
¼ P
. Extremal values c
and c
are treated
by considering two additional ghost sampling point s,
generated using the Bessel technique [39], i.e., the ghost
point at u
(similarly u
) is calculated using the unique
parabola that interpolates P
, P
, P
(similarly P
, P
). Note that c
, 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
value (10). Fig. 10 shows a visual evaluation of this step,
associating different colors to each segment, depending on
the numerical values of c
. 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
j <"
and jc
j <", then the spline segment ½u
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
on a segment satisfies a linear equation.
Using this, the parameter segments that are actually drawn
are ½u
, ½m
, and ½m
, with
: ð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
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
), 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
and M
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
g is a reordered set of fu
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
; k
; b
Þ corresponding to the parameter value a
calculated from the previous frame using:
¼ t
and k
¼ b
: ð12Þ
The t
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
), we
use the Frenet frame. Each frame gives the local orientation
of the sweep cross-section. These frames generate the
homogeneous transformation matrices M
and M
for the
considered parameter interval. They are then used by the
blending technique (cf. Section 2) on an elementary
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:
þ y
¼ 1
z 0; 1:
This nondeformed cylinder is approximated by polygons
using a positive integer n as the approximation resolution.In
our implementation, we used 2
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
and M
. 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
1 2z
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 ¼
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
Þ to th e next one ð"
Þ use the following
¼ "
þ ðf
þ ð"
is a floating point version of the integer variable
, and are two arbitrary constants, f
is the current
measured frame rate, and f
is the desired one. In our
implementation, we used ¼ 10
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.
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
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.
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:
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
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.
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
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.
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
[1] A.P. Fine, “Patient Information: Laparoscopic Colon Surgery” Soc.
Laparoendoscopic Surgeons, Inc., 2004,
[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://
[4] “Laparoscopic Colectomy,”Center for Videoendoscopic Surgery,
Univ. of Washington, 2004,
[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
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.
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
Þ 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,
[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,
[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://
[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,
[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
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
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
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.
... To find the static equilibrium, we apply Algorithm 1 to our inhouse code. Contact detection and contact forces are computed in lines 11-31 of the Algorithm, following the idea of real-time simulation [24] and Soft-Soft contact processing algorithm [25]. ...
Full-text available
Coaptation characteristics are crucial in an assessment of the competence of reconstructed aortic valves. Shell or membrane formulations can be used to model the valve cusps coaptation. In this paper we compare both formulations in terms of their coaptation characteristics for the first time. Our numerical thin shell model is based on a combination of the hyperelastic nodal forces method and the rotation-free finite elements. The shell model is verified on several popular benchmarks for thin-shell analysis. The relative error with respect to reference solutions does not exceed 1–2%. We apply our numerical shell and membrane formulations to model the closure of an idealized aortic valve varying hyperelasticity models and their shear moduli. The coaptation characteristics become almost insensitive to elastic potentials and sensitive to bending stiffness, which reduces the coaptation zone.
... In order to provide real-time collision detection between soft bodies, researchers have proposed many algorithms, such as hierarchical bounding box method [2], the space subdivision method [3], random collision detection [4,5], collision detection based on distance field and collision detection based on image space [6], etc. Many scholars do the further improvement and optimization of classical algorithms [7][8][9]. ...
Full-text available
Rapid and accurate detection of collision between virtual objects is crucial for many virtual reality based applications. In order to ensure a high-level of accuracy and to meet the real-time requirement, a fast collision detection algorithm between soft bodies is proposed. The developed algorithm is a combination of stochastic methods and particle swarm optimization with adaptive Cauchy mutation. The hierarchical bounding box method is used for a rough detection in order to filter out obvious disjoint space, and the problem is converted to a nonlinear optimization problem based on the distance of points. Then particle swarm optimization with adaptive Cauchy mutation is used to find the optimal solution. When it is updated iteratively, keeping some particles experience value and variation of other particles avoids particles trapped in local optimum, which further accelerates the speed of collision detection. The algorithm is implemented and evaluated through experiments and the results confirm the advantages of the developed algorithm.
Full-text available
Minimally invasive surgery (MIS) is emerging as a burgeoning mode of medical treatment and is widely adopted in practical clinical operations. Here, we report a soft manipulator that can actively deform and navigate through a narrow and constrained environment. Stiffness tunability, tremor filtration, and motion scaling capabilities are incorporated to ensure the position and posture of the manipulator during operation. Based on teleoperation through a handle shank, we demonstrate the capability of navigating through a complex, constrained, and narrow space of the human skeleton. By attaching a camera and syringe needle at the front tip of the soft manipulator, the capability of acupuncture treatment and in vivo drug delivery in a medical mannequin is further demonstrated. Finally, autonomous recognition and tracking systems are developed to ensure the surgeon can effortlessly teleoperate the soft manipulator to enter the human body.
In the virtual environment, all kinds of geometric models are composed of basic geometric elements such as triangular patches and tetrahedrons. The key of its detection is to test the intersection of different geometric model elements. Based on the two-dimensional projection method, this paper presents a fast test method of intersection between basic geometric elements. By changing the internal data structure of the virtual object, an optimization algorithm is proposed by using the spatial decomposition method and spatial-temporal correlation. It is expected that this algorithm will sacrifice a small amount of storage space to improve the real-time performance of the algorithm. Not only that, it can also deal with the collision detection of multiple geometric models colliding at the same time. The experimental results show that this method can improve the efficiency of collision detection to a certain extent.
In the process of simulating and modeling real objects, the phenomenon of objects penetrating each other may occur in the model, which is unrealistic and then the research of collision detection (CD) is generated. As a bottleneck of virtual environment simulation, researchers have conducted in‐depth research on CD, especially the CD of deformable objects. In this paper, we briefly review the related research on CD of deformable objects regarding relevant literature. First, we briefly introduce previous reviews of CD. Second, we review the popular research methods and limitations of CD between deformable objects. Third, we review the popular research methods and limitations of self‐collision detection in deformable objects. Finally, we discuss future directions of development. This review can be used as a reference for the application of CD in all directions.
In this paper, a method for detecting and mapping the petals of plant petals is presented. Firstly, the parametric equations are used to represent the initial state of the petals surface. The three - dimensional Cartesian coordinates of each point in the petals are projected onto the spherical coordinates respectively, The discrete values of the projection of the petals are converted to the two-dimensional coordinate plane. Secondly, multiple buffers are used to record the result of each petals projection and the distance of the petals from the origin of the spherical coordinates. According to the value of each buffer, it is determined whether the current petal collides with others, the collides result can be determined the range of collision. Finally, the current petals are deformed or moved to avoid collided with others. Through the collision test between the petals in the process of flower generation, it shows that the detection effect is good.
Shape registration is very fundamental for shape analysis problems, especially for abnormality detection in medical applications. In virtual colonoscopy, CT scans are typically acquired with the patient in both supine and prone positions. The registration of these two scans is desirable so that the user can clarify situations or confirm polyp findings at a location in one scan with the same location in the other, thereby improving polyp detection rates and reducing false positives. However, this supine-prone registration is challenging because of the substantial distortions in the colon shape due to the patient’s change in position. In this work, we present an efficient algorithm and framework for performing this registration through the use of conformal geometry and Ricci flow to guarantee that the registration is a diffeomorphism (a one-to-one and onto mapping). The taeniae coli and colon flexures are automatically extracted for each supine and prone surface, employing the colon geometry. The two colon surfaces are then divided into several segments using flexures, and each segment is cut along a taenia coli and conformally flattened to the rectangular domain using Ricci flow. Corresponding feature points between supine and prone are found and used to adjust the conformal flattening to be quasi-conformal, such that the features become aligned. We present multiple methods of visualizing our results, including 2D flattened rendering, corresponding 3D endoluminal views, and rendering of distortion measurements. We demonstrate the efficiency and efficacy of our registration method by illustrating matched views on both the 2D flattened colon images and in the 3D volume rendered colon endoluminal view. We analytically evaluate the correctness of the results by measuring the distance between features on the registered colons.
Full-text available
Clouds and the weather are important aspects of any natural outdoor scene, but existing dynamic techniques within computer graphics only offer the simplest of cloud representations. The problem that this work looks to address is how to provide a means of simulating clouds, that are suitable for virtual environments. Techniques for cloud simulation are available within the area of meteorology, but numerical weather prediction systems based on physics laws are computationally expensive and provide more numerical accuracy than the required for computer graphics. Within computer graphics, we often need to direct and adjust physical features or to bend reality to meet artistic goals, which is a key difference between the subjects of computer graphics and physical sciences. Pure physically-based simulations, however, evolve their solutions according to pre-set rules and are notoriously difficult to control. In this sense, the challenge is then to develop models that are computationally lightweight and able to be directed in some measure, while at the same time producing believable results. This work presents a new lightweight physically-based cloud simulation scheme that simulates the dynamic properties of cloud formation.This new model avoids solving the physically-based equations typically used to simulate the formation of clouds by explicitly solving these equations using SkewT/LogP thermodynamic diagrams. The system incorporates a water model that uses real data to simulate parameters related to cloud formation. This is specially suitable to the simulation of cumulus clouds that are from due to a convective process. This approach not only reduces the computational costs of previous physically-based methods, but also provides means of control the shape and dynamics of clouds by controlling the cloud levels in the SkewT/LogP diagram. This method is extended to clouds that form over mountains (orographic) to demonstrate its applicability, and a new method is presented. The novelty in this method relates to the fact that these type of clouds are non-convective and different atmospheric levels have to be determined to generate this type of clouds. Moreover, since orographic clouds form over mountains we also present a method to determine the mountain influence in the cloud motion. In summary, this dissertation successfully presents and end-to-end set of algorithms for the modelling, visualisation and simulation of weather clouds.
Full-text available
Background: Robot-assisted laparoscopic surgery offers several advantages compared with open surgery and conventional minimally invasive surgery. However, one issue that needs to be resolved is a collision between the robot arm and the assistant instrument. This is mostly caused by miscommunication between the surgeon and the assistant. To resolve this limitation, an assistant surgical robot system that can be simultaneously manipulated via a wireless controller is proposed to allow the surgeon to control the assistant instrument. Methods: The system comprises two novel master interfaces (NMIs), a surgical instrument with a gripper actuated by a micromotor, and 6-axis robot arm. Two NMIs are attached to master tool manipulators of da Vinci research kit (dVRK) to control the proposed system simultaneously with patient side manipulators of dVRK. The developments of the surgical instrument and NMI are based on surgical-operation-by-wire concept and hands-on-throttle-and-stick concept from the earlier research, respectively. Tests for checking the accuracy, latency, and power consumption of the NMI are performed. The gripping force, reaction time, and durability are assessed to validate the surgical instrument. The workspace is calculated for estimating the clinical applicability. A simple peg task using the fundamentals of laparoscopic surgery board and an in vitro test are executed with three novice volunteers. Results: The NMI was operated for 185 min and reflected the surgeon's decision successfully with a mean latency of 132 ms. The gripping force of the surgical instrument was comparable to that of conventional systems and was consistent even after 1000 times of gripping motion. The reaction time was 0.4 s. The workspace was calculated to be 8397.4 cm(3). Recruited volunteers were able to execute the simple peg task within the cut-off time and successfully performed the in vitro test without any collision. Conclusions: Various experiments were conducted and it is verified that the proposed assistant surgical robot system enables collision-free and simultaneous operation of the dVRK's robot arm and the proposed assistant robot arm. The workspace is appropriate for the performance of various kinds of surgeries. Therefore, the proposed system is expected to provide higher safety and effectiveness for the current surgical robot system.
Full-text available
Dans cette thèse, nous présentons un modèle granulaire décrivant la dynamique d'un assemblage de floes rigides de tailles et de formes diverses, soumis aux forces de traînée dues aux courants atmosphérique et océanique. Ce modèle est basé sur les équations des moments linéaire et angulaire pour décrire la dynamique régulière des floes et sur la résolution de problèmes linéaires de complémentarité pour traiter les collisions entre les floes. Entre les collisions, le mouvement d'un floe isolé satisfait la conservation des équations des moments linéaire et angulaire écrites à partir des formulations classiques des traînées dues au vent et à l'océan. Nous décrivons les collisions entre les floes comme des événements instantanés et les traitons avant qu'elles n'entraînent une interpénétration. Cela implique la notion d'impulsion de contact et la mise sous la forme de problèmes linéaires de complémentarité basés sur la condition de Signorini pour la non interpénétration et la loi de Coulomb. La nature du contact est représentée à travers un coefficient de friction et un coefficient de restitution décrivant la perte d'énergie cinétique durant la collision. Dans cette présente version du modèle, le coefficient de restitution est fixé. Le modèle a été validé en utilisant des données obtenues du mouvement de disques de bois évoluant en bassin de test aussi bien qu'en comparant le comportement des floes simulés avec un comportement attendu dans des scénarios classiques de dérive de glace et de collisions entre des solides rigides. Les résultats de simulations comprenant différents assemblages contenant des floes de tailles et de formes variées, soumis à différents scénarios de forçage, sont aussi discutés. Ils montrent tout le potentiel de notre approche sans qu'une analyse détaillée et complète n'est encore été proposée.
Conference Paper
Simulating flexible models can create aesthetic motion for computer animation. Animators can control these motions through the use of constraints on the physical behavior of the models. This paper shows how to use mathematical constraint methods based on physics and on optimization theory to create controlled, realistic animation of physically-based flexible models. Two types of constraints are presented in this paper: reaction constraints (RCs) and augrmented Lagrangian constraints (ALCs). RCs allow the fast computation of collisions of flexible models with polygonal models. In addition, RCs allow flexible models to be pushed and pulled under the control of an animator. ALCs create animation effects such as volume-preserving squashing and the molding of taffy-like substances. ALCs are compatible with RCs. In this paper, we describe how to apply these constraint methods to a flexible model that uses finite elements.
Collision handling is very computationally expensive, especially in large scale interactive animations. Hierarchical object representations play an important role in performing efficient collision handling. Many different geometric primitives have been used to construct these representations, which allows areas of interaction to be localised quickly. For time-critical algorithms, such as interruptible collision detection, there are distinct advantages to using hierarchies of spheres, known as sphere-trees. This paper presents a novel algorithm for the construction of sphere-trees. The algorithm presented approximates objects, both convex and non-convex, with a higher degree of fit than existing algorithms. In the lower levels of the representations, there is almost an order of magnitude decrease in the number of spheres required to represent the objects to a given accuracy.
We present a scheme for exact collision detection between complex models undergoing rigid motion and deformation. The scheme relies on a hierarchical model representation using Axis-Aligned Bounding Boxes (AABBs). Recent work has shown that AABB trees are slower than Oriented Bounding Box (OBB) trees for performing overlap tests. In this paper, we describe a way to speed up overlap tests between AABBs, such that for collision detection of rigid models, the difference in performance between the two representations is greatly reduced. Furthermore, we show how to update an AABB tree quickly as a model is deformed. We thus find AABB trees to be the method of choice for collision detection of complex models undergoing deformation. In fact, because they are not much slower to test, are faster to build, and use less storage than OBB trees, AABB trees might be a reasonable choice for rigid models as well.
We present an algorithm for fast, physically accurate sim- ulation of deformable objects suitable for real time ani- mation and virtual environment interaction. We describe the boundary integral equation formulation of static linear elasticity as well as the related Boundary Element Method (BEM) discretization technique. In addition, we show how to exploit the coherence of typical interactions to achieve low latency; the boundary formulation lends itself well to a fast update method when a few boundary conditions change. The algorithms are described in detail with examples from ArtDefo, our implementation.
Three-dimensional space curves can represent the path of an object or the boundary of a surface patch. They can also participate in various free-form geometric constructions. For example, the generalized cylinder (a cylinder with arbitrary cross-sections along a central, space curve axis) is used in Computer Graphics to good effect. Establishing reference frames for the cross-sections of a generalized cylinder, or for any other geometric use, is the subject of this article.