ARTICLE IN PRESS

0098-3004/$ - se

doi:10.1016/j.ca

$Code availa�Correspond

fax: +333 83 59

E-mail add

(G. Caumon), B

Laurent.Castan

paul@tsinghua

Computers & Geosciences 31 (2005) 671–680

www.elsevier.com/locate/cageo

Visualization of grids conforming to geological structures:a topological approach$

Guillaume Caumona,�, Bruno Levyb, Laurent Castaniea, Jean-Claude Paulb,c

aENSG, INPL-CRPG, rue du Doyen M. Roubault, 54501 Vandoeuvre cedex, FrancebISA Loria, rue du Jardin Botanique, 54500 Vandoeuvre, France

cLIAMA, School of Software, Tsinghua University, 100084 Beijing, PR China

Received 1 October 2003; received in revised form 3 January 2005; accepted 15 January 2005

Abstract

Flexible grids are used in many Geoscience applications because they can accurately adapt to the great diversity of

shapes encountered in nature. These grids raise a number difficult challenges, in particular for fast volume visualization.

We propose a generic incremental slicing algorithm for versatile visualization of unstructured grids, these being

constituted of arbitrary convex cells. The tradeoff between the complexity of the grid and the efficiency of the method is

addressed by special-purpose data structures and customizations. A general structure based on oriented edges is defined

to address the general case. When only a limited number of polyhedron types is present in the grid (zoo grids), memory

usage and rendering time are reduced by using a catalog of cell types generated automatically. This data structure is

further optimized to deal with stratigraphic grids made of hexahedral cells. The visualization method is applied to

several gridded subsurface models conforming to geological structures.

r 2005 Published by Elsevier Ltd.

Keywords: Algorithm; Volume visualization; Unstructured grid; Stratigraphic grid; Data structure

1. Introduction

Most partial differential equations (PDEs) describing

natural processes in the subsurface are too complex to

be solved analytically. The solution to these equations is

usually approximated by a numerical method (e.g., finite

differences), hence relies on the definition of a grid

discretizing the domain of study. This grid may be

Cartesian, but geological heterogeneities are modeled

e front matter r 2005 Published by Elsevier Ltd.

geo.2005.01.020

ble from http://www.loria.fr/�levy/Graphite

ing author. Tel.: +333 83 59 64 40;

64 60.

resses: Guillaume.Caumon@ensg.inpl-nancy.fr

runo.Levy@loria.fr (B. Levy),

ie@ensg.inpl-nancy.fr (L. Castanie),

.edu.cn (J.-C. Paul).

more accurately and at a lower computational cost using

a flexible grid made to conform to sedimentary and

tectonic structures. For flow simulation, a flexible grid

can be further optimized to account for radial flow

around wells (Heinemann et al., 1991; Aziz, 1993; Verma

and Aziz, 1997; Mlacnik et al., 2003). Such a flexible grid

may also be used in Geographical Information Systems

(Breunig, 1999) and in model building (Courrioux et al.,

2001; Hale, 2002; Mallet, 2004). A grid is generally

defined by three components:

1.

The geometry consists of a set of n vertices

fv1; . . . ; vng; each defined by a coordinate vector x ¼

ðx; y; zÞ in 3D space.

2.

The topological model describes how these vertices are

connected to each other (Fig. 1), defining a partition

ARTICLE IN PRESS

regular curvilinear weakly(zoo)

strongly

homogeneous

Sections 3-4

Grid

structured unstructured

heterogeneous

Section 5

A B C D F

Fig. 1. Grid taxonomy. This article presents a unified method

for visualizing all types of grids encountered in Geosciences. We

consider the general case of strongly heterogeneous grids, then

present optimizations for the more special cases of zoo and

curvilinear grids.

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680672

of the space into polyhedral 3-cells (or, more simply,

cells); each cell c is defined by its faces, each face by

its edges, and each edge by its bounding vertices. As

opposed to a structured grid in which connection

patterns are repeated as in a crystal lattice, an

unstructured grid must have its topology explicitly

defined. A zoo grid is an unstructured grid containing

only a small number of cell types.

3.

The property model assigns property values to the

vertices, the edges, the faces or the cells of the grid.

For the sake of clarity, this paper describes only the

case of one scalar property value f (e.g., pressure,

porosity, concentration) attached to the vertices.

There are several of challenges associated with unstruc-

tured grids:

1.

The gridding methods must find a compromise

between conflicting criteria such as conformity to

geological structures vs. cell numbers, sizes and

shapes (e.g., Owen, 1998; Lepage, 2002).

2.

As a counterpart for better accuracy, the discretiza-

tion of PDEs is more difficult to define on unstruc-

tured grids than on Cartesian grids (Verma and Aziz,

1997).

3.

Existing implementations of geostatistical algorithms

cannot be used directly; new implementations for

unstructured grids rely on efficient neighborhood

search algorithms, and must account for variable cell

volumes (Deutsch et al., 2002).

4.

Most volume visualization techniques, essential for

quality control and perception of geological volumes,

were also developed on Cartesian grids, hence must

be adapted to unstructured grids (e.g., Shirley and

Tuchman, 1990; Williams et al., 1998; Silva and

Mitchell, 1997; Levy et al., 2001).

the volume visualization of a scalar field f defined on an

This paper is concerned with this last point, namely

unstructured grid. Producing explicit images from a

volume grid is always challenging, for a large amount of

data has to be traversed and organized in real time. The

way a grid is structured conditions the applicability and

the efficiency of a particular rendering algorithm.

Whereas most existing methods practically handle only

tetrahedral grids (Shirley and Tuchman, 1990; Silva and

Mitchell, 1997; Cignoni et al., 1998; Wittenbrink, 1999),

we consider the more general case where grid cells are

arbitrary convex polyhedra.

After a short review of existing volume visualization

techniques (Section 2), we present a new imaging

algorithm, accepting any grid composed of convex cells

(Sections 3 and 4). This algorithm is then specialized for

zoo grids for increased memory and time efficiency

(Section 5).

2. Volume visualization

2.1. Visualization techniques

Two types of approaches have been defined to

visualize the interior of a volume grid (e.g., Kaufman,

1996):

�

Surface-based techniques use classical 3D drawing of

a surface extracted from the grid. Such a surface may

be a cross-section or, more generally, an equipotential

j of some scalar field f defined on the grid (isosurface

rendering). Note that an arbitrary planar section is

just a particular isosurface where j � ax þ by þ cz þ

d ; with a; b; c; d being real coefficients and ðx; y; zÞthe spatial coordinates. These surface extraction

methods produce meaningful pictures, but do not

yield a comprehensive view of the whole volume.

This limitation can be overcome by extracting solid

slices (Martha et al., 1997) or a sequence of

isosurfaces separated by some increment Dj (Levy

et al., 2001).

�

Volume rendering considers the grid as a semi-

opaque medium: the propagation of light is modeled

as through a cloud of particles whose density would

vary with the scalar value f (Max, 1995). Since

volume rendering aims at generating specifically

meaningful images, a transfer function between the

scalar value f and the image color and transparency

ðr; g; b; aÞ is used to focus on the desired range of

values. This transfer function can be defined arbi-

trarily by the user, or by a special-purpose analytical

model, possibly after having transformed the data as

proposed by Gerhardt et al. (2002) for visualizing

seismic data.

ARTICLE IN PRESS

C3 C2

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680 673

Both types of visualization techniques are addressed

in this paper, thanks to one single algorithm.

C1

C2

vm

P1 2

P 3P

vm

(A) (B)

Fig. 2. The algorithm computes a series of slices (A) or

isosurfaces (B) incrementally, by maintaining a list of active

elements. Small cells, such as the shaded triangles and

quadrilateral between P2 and P3 in (A) and the shaded polygon

between C1 and C2 in (B) are used for the mesh-driven

propagation, even if they are not intersected by the slicing

surfaces. Local minima (vm in (A) and (B)) need to be taken into

account when propagating.

2.2. Visualization algorithms

3D rendering algorithms are traditionally split into

screen-space methods, where the color of each pixel is

calculated at once by ray-casting, and object-space

methods, where the object is projected piecewise onto

the screen (Kaufman, 1996). Object-space methods are

made attractive by today’s graphics hardware, for

performance can be improved by balancing computations

between the graphics processor and the central processor.

Projecting an unstructured grid onto the screen raises

two problems. First, the polygonal projection of a

polyhedral cell has to be determined. This can be done

efficiently for tetrahedral cells (Shirley and Tuchman,

1990), but appears difficult to achieve in acceptable time

for arbitrary polyhedra. Second, the cells of the grid

must be projected in visibility order (either back-to-front

or front-to-back) to avoid visual artifacts. This order

can be determined for most tetrahedral (Cignoni et al.,

1998; Wittenbrink, 1999) and polyhedral (Williams et

al., 1998) grids, but cannot be found when some grid

cells overlap cyclically (visibility cycles).

As an alternative to cell projection, we apply in this

article the paradigm of incremental slicing, first intro-

duced by Yagel et al. (1996): the whole grid is sliced

several times in a plane orthogonal to the viewing

direction, and the slices are rendered back-to-front using

classical polygon drawing instructions using OpenGL

(Neider et al., 1993). As compared to projection

approaches, the visibility problem is resolved implicitly

by this method. Performance can be increased at the

expense of image quality by reducing the number of slices.

3. Generic incremental slicing algorithm

3.1. Principle

We propose to compute a set of isosurfaces between

two values jmin and jmax separated by a Dj interval.

On a grid made of Nc cells and rendered with Nj

slices, a naive algorithm trying to check each cell against

every isosurface would have an OðNj NcÞ average

complexity, whereas only OðNj N2=3c Þ cells are inter-

sected by a slice.

In this respect, the contour seeds method (Bajaj et al.,

1996) is probably optimal: for each connected compo-

nent of the isosurface, all the intersected cells are found

from a single seed cell using mesh connections. How-

ever, this method does not exploit the coherency from

one value j to the next value jþ Dj: Therefore, weprefer using an active element data structure updated

from slice to slice: at the current step of the algorithm,

all the cells intersected by the slicing plane j are in the

active set; this set must then be updated for the value

jþ Dj:For this, Yagel et al. (1996) use an auxiliary

EdgeBucket data structure. This structure requires all

the edges to be sorted, duplicates the combinatorial

information of the grid, and has to be recomputed

whenever the number of slices changes. Instead, Silva

and Mitchell (1997) use topological information to

propagate a sweeping plane in a tetrahedral grid; border

edges are checked for insertion between two successive

planes not to overlook connected components of the

isosurface (Fig. 2).

Our method is close to that of Silva and Mitchell

(1997), but uses a more general grid topology. For

efficiency, the border set is replaced by a sorted list of

mesh elements that cannot be reached by local

propagation, called local minima (Fig. 2). The number

of elements m of this minimal set can be orders of

magnitude smaller than the border set, depending on the

grid representation used (see Sections 4 and 5).

Whenever the scalar field of values f is modified, only

the set of minima needs to be updated and sorted. For

volume rendering, we propose to minimize this proces-

sing by slicing orthogonally to the axis ðx; y; zÞ the ‘‘mostperpendicular’’ to the screen. This only requires pre-

computing and sorting the minimal set in six directions

ðxþ; x�; yþ; y�; zþ; z�Þ:

3.2. Updating the active elements

Some mesh elements of the grid may not be

intersected by the slicing planes; these cells are

ARTICLE IN PRESSG. Caumon et al. / Computers & Geosciences 31 (2005) 671–680674

nevertheless considered during the mesh-driven propa-

gation (Fig. 2A): an element can be added then removed

from the active elements list between two consecutive

isovalues. This can be efficiently performed using two

queues, active_elems and swept_elems, that

distinguish between the elements to draw and the

elements that are only traversed during propagation.

For a given isovalue j; active_elems contains all

the elements intersected. When proceeding to the next

slice, jþ Dj; the two queues are swapped, then the

minimal elements found in ½j;jþ Dj are added to

swept_elems. The new active elements can be found

efficiently by propagating from swept_elems. The useof queues is more elegant and faster than a doubly-

connected element list, since no element is removed

from the active set. Also, it simplifies the marking of

elements as compared to our previous implementation

(Levy et al., 2001).

3.3. Drawing intersection polygons

Our purpose is now to draw the polygons of the

isosurface from the set of intersected elements. For an

intersected convex polyhedron, the vertices of the

polygon are given by a linear interpolation on the

intersected edges. Their order can be obtained by

turning around the faces of the cell, as proposed by

Bloomenthal (1988) (Fig. 3A). The algorithm and data

structure to extract this order will be given in Section 4.

This method does not address ambiguous cases, which

may arise if the scalar field varies non-linearly within the

cell or if the cell is concave (Fig. 3B,C). A simple

workaround is then to tetrahedralize the cell, but more

advanced methods should also be investigated, building

on the work by Wilhelms and Gelder (1990).

(B)(A)

Fig. 3. (A) Starting from an intersected edge in a given polyhedron, al

polyhedron; (B) and (C) two possible interpretations for an ambigu

ambiguities. Ambiguities may only arise if the polyhedron is concave

3.4. Instanciating the framework

From the generic method presented above, the

practical implementation for a given type of grid just

requires:

1.

l th

ou

or

To specify the type of active element used.

2.

To define precisely the minimal set. This definition is

deducted from the way combinatorial information is

used to find the successors of an element.

3.

To define how an active element is practically used to

compute and draw the intersection polygon.

In the remainder of the paper, we define data

structures and adaptations of this slicing-based render-

ing method from the general case of arbitrary polyhedral

grids (Section 4) to the specific case of curvilinear grids,

which are often used to model stratigraphic structures

(Section 5).

4. Circular incident edge lists (CIEL)

This section is a revisit of our previous work (Levy

et al., 2001). The memory requirements of the data

structure have been reduced without loss of performance

by eliminating the use of an edge structure. The active

edges update has been improved, using two FIFO

queues in place of a list of active edges, and the complete

description of the construction algorithm is given.

4.1. A flexible and complete data structure

CIEL is a topological data structure to represent very

general unstructured grids. As in other classical repre-

sentations (Kettner, 1998; Mantyla, 1988), a set of

(C)

e intersections are retrieved by ‘‘turning around’’ faces of the

s configuration. If cells are convex, slicing cannot produce

if the property f is not monotonous within the cell.

ARTICLE IN PRESS

(C)(B)(A)

Fig. 4. The notion of half-edge (white-headed arrows) plays a central role in the CIEL data structure. Each half-edge has a pointer to

its successor next_around_face in the polygon, and a pointer mate_face to a half-edge of adjacent polygon (black-headed arrows

in (A)). A half-edge also has a pointer mate_cell enabling adjacent polyhedron to be retrieved (B). In addition, one half-edge per

edge starting from the same vertex appears in a circular linked list implemented by the next_around_vertex pointer (C).

Fig. 5. The CIEL data structure: half-edge, cell and vertex

definitions.

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680 675

oriented edges (or half-edges) is used to define the mesh

topology. A half-edge is connected to its neighbors

through four types of links that completely define the

connections in the grid (Figs. 4 and 5):

1.

The polygonal face of a polyhedral cell is formed by a

loop of half-edges connected by a next_around_face link (Fig. 4A).

2.

The mate_face link binds two half-edges of

opposite orientation belonging to the same edge,

same polyhedral cell and two adjacent polygonal

faces of that cell (Fig. 4A).

3.

The mate_cell link connects two half-edges of

opposite orientation belonging to the same edge,

same polygonal face, and two adjacent polyhedral

cells (Fig. 4B).

4.

All half-edges incident to a given vertex can be

traversed using the cyclic operator next_around_vertex, (Fig. 4C). This last operator is critical foran efficient updating of the active set during

incremental slicing.

In addition to these links, the CIEL data structure

stores an array of vertices to represent the geometry and

the scalar field f; and an array of polyhedral cells whichcan be marked during grid traversal. This explicit

identification of cells could be omitted at the expense

of a slightly higher computational cost.

4.2. CIEL construction

Writing and loading strongly unstructured grids

require file formats that capture the combinatorial

information for each cell. Commonly, unstructured

grids formats are based on an enumeration of vertices

followed by an enumeration of polyhedra. Each poly-

hedron is defined by a set of faces, and each face is

defined by the indices of its vertices.

The construction of the CIEL data structure from this

type of data file first creates an array V of vertices,

mapping an index vi to a vertex V ½vi : Then, for eachpolyhedron, the faces are built from their ordered list of

vertices. Each time a face is created, attempt is made to

link its edges to the edges of the same polyhedron that

already exist, and with the neighboring polyhedra. This

initialization uses the list of incident edges while they are

constructed.

At the end of the construction, the list of incident

edges contains redundant information because several

half-edges may connect the same two vertices. This

redundancy can be eliminated by keeping in the set of

edges connected by next_around_vertex only one

ARTICLE IN PRESS

Fig. 6. The primitives of a Cellular Graph and the meta-cell

data structure. Cells and vertices use the minimum amount of

information to capture the combinatorial information of the

grid. A meta-cell contains a numbering scheme that defines the

connections between vertices, edges and faces. It also acts as a

general marching polyhedra lookup table (note that face_

flags, is_ghost and is_active can be packed in the same

word). Each meta-cell is stored just once for each cell type in the

grid.

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680676

half-edge out of those connected by mate_face and

mate_cell.

4.3. Half-edge based slicing algorithm

The rendering of the CIEL structure is based on two

queues of active edges. The list of edges around a vertex

is used to find the successors of an inactivated edge. The

local minima cannot be accessed by this process: a vertex

is a local minimum if, and only if, none of its neighbors

has a lower property value. The half-edges starting from

such a vertex are accessed through the next_around_vertex link.

All the cells around an active edge can be retrieved

through the mate_face and mate_cell links. For

such a cell, drawing the isosurface polygons is then

easily implemented using the next_around_face and

mate_face links (Fig. 3A). Each active cell must be

marked when drawn to avoid repetitious processing,

hence must be unmarked between successive slices. For

each intersected edge, the coordinates and property

gradient of the intersection point are calculated by linear

interpolation.

In the algorithm by Levy et al. (2001), the intersection

of an edge with an isosurface is computed once and

stored in an edge data structure. Such a buffering creates

a memory overhead for storing edges and referencing

them in the half-edges. In the present version, intersec-

tions are recomputed for each cell around an edge. This

reduces memory usage dramatically without loss of

performance, since data locality accesses and cache use

are optimized.

5. Cellular graphs

The CIEL implementation of our generic volume

rendering algorithm handles arbitrary polyhedral grids

made of convex cells. Yet, such a generality has a cost

in terms of memory requirements and performance. In

this section, we address the simpler class of zoo grids

(Fig. 1). This type of grid can be generated by mixing

structured parts with hexahedral cells and unstructured

parts with tetrahedra and pyramids, e.g., at the

neighborhood of fractures.

5.1. A memory efficient data structure

We propose a compact alternative to CIEL for

representing the combinatorial information in zoo grids,

called Cellular Graph (CGraph). This topological model

is made of two parts:

�

The cell lookup table is a dynamic catalog of meta-

cells, each describing a specific cell type in the grid. A

meta-cell is a graph of connected vertices, edges

and faces identified by their indices (Fig. 6). This

graph can be stored as a set of adjacency

matrices without incurring significant memory

overhead, since a meta-cell is defined only once per

cell type in the grid. As a generalization of the

marching cubes lookup table (Lorensen and

Cline, 1987), a meta-cell also contains, for each

possible isovalue, the ordered list of intersected edges.

For a cell made of vc vertices, the 2vc possible

configurations are stored in three tables of size 2vc :The first one, config_size, gives the number of

vertices in each intersection polygon. The second one,

config, provides the indices of the edges that are

intersected by the isovalue, as obtained by turning

around the cell faces (Fig. 3). The third table,

config_is_ambiguous, keeps track of ambiguous

configurations. Ambiguities could also be resolved by

adding an indexed tetrahedralization in the definition

of meta-cells.

�

The grid sensu stricto represents the geometry

and the scalar field attached to the set of vertices,

and the connections between grid cells (Fig. 6).

Each cell, characterized by its type (meta-cell), is

defined by an array of vertices and an array of

neighboring cells. Last, a cell contains orientation

flags for its faces.

ARTICLE IN PRESSG. Caumon et al. / Computers & Geosciences 31 (2005) 671–680 677

5.2. Constructing a cellular graph

P1 P2(B)

P1 P2(A)

Fig. 7. Propagating through a cellular graph. (A) from slicing

plane P1 to P2 the cells no longer intersected (hatched) are

deactivated, and their successors (in light grey) are activated.

(B) when drawing the active cells (in light grey), faces

intersected by P2 (bold segments) are used to get the missing

intersected cells (in dark grey).

A cellular graph first builds automatically the cell

lookup table from a description of cell types, then the

grid itself.

The cell lookup table can be constructed as a set of

isolated CIEL cells. Using the mate_face and next_around_face links, the cell can be traversed very

easily to build the connectivity graph. The number of

meta-cells being much smaller than the number of cells

in the grid, the construction time for the cell lookup

table is negligible as compared to the time spent building

the grid itself.

Using the cell lookup table, the grid is created from a

list of vertices and a list of cells. The cells of the grid are

first created independently from each other, using their

types and their sets of vertices. Next, cells can be sewn

thanks to a transitory list of incident polyhedra known

for each vertex. This list, easily built from the set of

disconnected cells, is discarded once the cellular graph is

complete.

5.3. Cell-based incremental slicing

The rendering algorithm for CGraph makes use of

active cells which can be updated between two slices

using the cell neighbors. The faces of a cell are marked

either as incoming, outgoing or neutral relatively to the

gradient of the scalar field phi. This orientation is pre-

computed for a given face using the signed cell volume

and an estimation of the gradient (e.g., by a least-square

method, see Levy et al., 2001). Because these computa-

tions can be numerically unstable, face status are

consistently set in adjacent cells, so that an outgoing

face in a cell is always incoming in the corresponding

neighbor. Furthermore, cells containing degenerated

faces are deactivated (although these should ideally

have different cell types).

During the rendering of the grid, these orientation

flags are used to update efficiently the set of active cells

from an isosurface j to the next one jþ Dj: The

successors of a deactivated cell c are obtained through

the outgoing faces of c. The cells having all their

incoming faces on the boundary of the grid cannot be

reached by this process, hence must be stored in the set

of local minima. Also, a cell c0 connected to c only by a

vertex or an edge cannot be activated by this face-based

propagation, although c0 may actually be intersected by

the isovalue jþ Dj (Fig. 7A). We propose to check for

these inactive neighbors when drawing the intersection

polygons of the surface jþ Dj (Fig. 7B).

To render the intersection of an active cell with the

current isosurface j; a configuration code is generated

from the values of the cell’s vertices relatively to j: Thiscode acts as a key to the meta-cell’s tables config_sizeand config (Fig. 6). Note that these arrays are

automatically initialized at loading time using the same

algorithm as for CIEL rendering.

5.4. Specializing cellular graphs for curvilinear grids

Cellular Graphs make it possible to render zoo grids

and homogeneous grids (for instance tetrahedral and

curvilinear grids). Yet, this data structure is not optimal

for curvilinear grids used for stratigraphic modeling,

because connections between cells can be represented

implicitly. Therefore, we have defined a customization of

Cellular Graphs for handling efficiently curvilinear

grids. In this specialization, called structured cellular

graph, the cell lookup table contains only a hexahedral

meta-cell. Stored in a 3D array, the building brick

of a structured cellular graph contains information

relative to both vertex and cell: geometry, property,

gradient and face orientation flags. The adjacencies

between these primitives are easily defined thanks to a

pre-computed table of grid offsets. Border effects are

suppressed by adding a raw of ‘‘ghost’’ cells on the

borders of the grid.

6. Results

The visualization method described here has been

implemented in Cþþ using generic programming.

It was applied to several grids of various topologies

(Table 1, Fig. 9): the Voronoi data set is a synthetic grid

created from the Delaunay tetrahedralization of a point

cloud, as encountered in reservoir simulation applica-

tions. The SGrid data set is a faulted stratigraphic grid

made of hexahedral cells, and the Warped Skull is a

warped medical grid.

For each of these data sets, storage cost is separated

into cells, edges, vertices and minimum elements

ARTICLE IN PRESS

Table 1

Sizes and memory usage for data sets

Voronoi SGrid Warped skull

(CIEL) (CGraph) (S-CGraph)

Vertices 604 232 236 874 2 146 689

size (MB) 16.9 6.6 68.7

Cells 95 308 206 912

size (MB) 0.8 5

Half-edges 7 220 766 na na

size (MB) 202.2 0 0

Minima (MB) 0.2 1.7 0.5

Total 220.1 13.3 69.2

Table 2

Preprocessing times, in seconds

Voronoi SGrid Warped skull

(CIEL) (CGraph) (SCGraph)

Loading 38.1 12.1 14.2

Gradient 1.4 0.6 5.4

Minima 1.9 0.1 0.5

Total 41.4 12.8 20.1

0 10,0008,0006,0004,0002,000

Tim

e (s

)

Intersected cells

10

9

8

7

6

5

4

3

2

1

0

CGraph

CIEL

S-CGraph

Fig. 8. Rendering frame rate against the average number of

intersected cells. The graph has been generated with 200 slices

on curvilinear grids of varying sizes. For a grid with Nc cells,

the average number of intersected cells is N2=3c :

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680678

(Table 1). As predictable, the half-edges make up the

main part of the memory usage on the CIEL data

structure. In CGraph, a very small amount of memory is

used for storing combinatorial relationships, as the cell

lookup table factorizes most of this information. The

cell lookup table only requires negligible memory as

compared to the grid itself.

The performance of our method has been separated in

pre-processing time and rendering time. The pre-

processing, needed only once per data set, consists in

loading, computing gradients, looking for and sorting

minimum elements. Given times (Table 2) were obtained

on a 2.4GHz desktop PC with 2GB RAM, and a

NVIDIA Quadro 4900 XGL graphics card with 128MB

of dedicated memory.

As for the rendering itself, the time is experimentally

linear in the size of the output (Fig. 8). This optimal

complexity is the same as that of Yagel et al. (1996), but

our method is more flexible.

7. Conclusion

Based on a general efficient incremental slicing

algorithm, we have presented a generic method for

visualizing unstructured grids with convex cells through

volume rendering or isosurface extraction. This method

has been applied to the various types of grids

encountered in Geosciences, namely polyhedral grids

(CIEL), zoo and homogeneous grids (CGraphs), and

curvilinear stratigraphic grids (structured CGraphs).

This method generalizes previous approaches based on

the sweeping paradigm (Silva and Mitchell, 1997; Yagel

et al., 1996), providing a practical way of dealing with

complex topologies.

About the visualization method, future works include

defining disambiguation strategies, improving gradient

estimation and better handling degenerated cells.

Image quality issues should also be addressed. For

that purpose, the interval between slices could be

adapted to the resolution of the grid, and a smarter

interpolation within polygons could be performed,

as done by Williams et al. (1998). In addition to the

topological aspects addressed in this work, the quest

for meaningful transfer functions and rendering

of vector or tensor fields (e.g., permeability, strain)

are important challenges for visualizing Geoscience

data.

In this article, we have only considered property

models where the scalar value is defined at each vertex.

Recently, Mallet (2004) proposed to use a property

model defined in a high resolution grid decoupled from

the present-time model. This representation can easily be

addressed by our system, using 3D texture mapping

(Fig. 9E).

As a final remark, the data structures and traversal

algorithms developed in this work for visualization

could be easily exploited in other applications, for

instance to implement geostatistical algorithms on

unstructured grids.

ARTICLE IN PRESS

Fig. 9. Sample results: the Voronoi data set in solid view (A) and rendered with 500 slices (B); the SGrid data set, in solid view (C) and

volume rendered with 1000 slices (D); sections of a polyhedral version of the SGrid, displaying a high-resolution property stored as a

1283 3D texture (E); the warped skull (1283 cells) rendered with 700 slices (F).

G. Caumon et al. / Computers & Geosciences 31 (2005) 671–680 679

Acknowledgements

This work was supported by the ACI Geogrid (French

Ministry of Research), the ARC Plasma (INRIA), and

ChevronTexaco. Part of this work was performed in the

frame of the Gocad Consortium (http://gocad.ensg.inpl-

nancy.fr). Thanks to Total for the SGrid data set, and to

Siemens Medical Systems for the skull data set.

References

Aziz, K., 1993. Reservoir simulation grids: opportunities and

problems. Journal of Petroleum Technology 45 (7),

658–663.

Bajaj, C., Pascucci, V., Schikore, D., 1996. Fast isocontouring

for improved interactivity. In: Proceedings of the Sympo-

sium on Volume Visualization, Association Computing

Machinery, New York, pp. 39–46.

Bloomenthal, J., 1988. Polygonalization of implicit surfaces.

Computer Aided Geometric Design 5 (4), 53–60.

Breunig, M., 1999. An approach to the integration of spatial

data and systems for a 3d geo-information system.

Computers & Geosciences 25 (1), 39–48.

Cignoni, P., Montani, C., Scopigno, R., 1998. Tetrahedra

based volume visualization. In: Hege, H.-C., Polthier, K.

(Eds.), Mathematical Visualization. Springer, Berlin,

pp. 3–18.

Courrioux, G., Nullans, S., Guillen, A., Boissonnat, J.-D.,

Repusseau, P., Renaud, X., Thibaut, M., 2001. 3d

volumetric modelling of Cadomian terranes (Northern

ARTICLE IN PRESSG. Caumon et al. / Computers & Geosciences 31 (2005) 671–680680

Brittany, France): an automatic method using Voronoi

diagrams. Tectonophysics 331, 181–196.

Deutsch, C.V., Tran, T.T., Pyrcz, M.J., 2002. Geostatistical

assignment of reservoir properties on unstructured grids. In:

SPE Annual Technical Conference and Exhibition (SPE

77427), 10p.

Gerhardt, A., Machado, M., Silva, P.M., Gattass, M., 2002.

Enhanced visualization of 3-d seismic data. In: Proceedings

of the 72nd Annual Meeting. Society of Exploration

Geophysicists, 4p.

Hale, D., 2002. Atomic meshes: from seismic images to

reservoir simulation. In: Proceedings of the ECMOR VIII.

European Conference on Mathematics of Oil Recovery, 8p.

Heinemann, Z.E., Brand, C.W., Munkan, M., Chen, Y., 1991.

Modeling reservoir geometry with irregular grids. SPE

Reservoir Engineering (SPE 18412), pp. 225–232.

Kaufman, A., 1996. Volume visualization. ACM Computing

Surveys 28 (1), 165–167.

Kettner, L., 1998. Designing a data structure for polyhedral

surfaces. In: Proceedings of the 14th Annual ACM

Symposium on Computational Geometry, pp. 146–154.

Lepage, F., 2002. Triangle and tetrahedral meshes for

geological models. In: Proceedings of the IAMG, Berlin,

Terra Nostra, 4, 105–110.

Levy, B., Caumon, G., Conreaux, S., Cavin, X., 2001. Circular

incident edge lists: a data structure for rendering complex

unstructured grids. In: Proceedings of the IEEE Visualiza-

tion, pp. 191–198.

Lorensen, W.E., Cline, H.E., 1987. Marching cubes: a high

resolution 3d surface construction algorithm. Computer

Graphics (Proceedings Siggraph) 21 (4), 163–170.

Mallet, J.-L., 2004. Space–time mathematical framework for

sedimentary geology. Mathematical geology 36 (1), 1–32.

Mantyla, M., 1988. An Introduction to Solid Modeling.

Computer Science Press, Rockville, MD 401p.

Martha, L.F., de Carvalho, M.T., de Beauclaire Seixas, R.,

1997. Volume contouring of generic unstructured meshes.

Journal of the Brazilian Computer Society 3 (3), 43–51

ISSN 0104-6500.

Max, N., 1995. Optical models for direct volume rendering.

IEEE Transactions on Visualization and Computer Gra-

phics 1 (2), 99–108.

Mlacnik, M., Harrer, A., Heinemann, Z.E., 2003. Locally

streamline-pressure-potential-based pebi grids. In: Proceed-

ings of the Symposium on Reservoir Simulation, Houston

(SPE 79684). SPE, 12p.

Neider, J., Davis, T., Woo, M., 1993. OpenGL Programming

Guide, Addison-Wesley, Reading, MA, 640pp.

Owen, S., 1998. A survey of unstructured mesh generation

technology. In: Proceedings of the Seventh International

Meshing RoundTable, pp. 239–267.

Shirley, P., Tuchman, A., 1990. A polygonal approximation to

direct scalar volume rendering. Computer Graphics (San

Diego Workshop on Volume Visualization) 24 (5), 63–70.

Silva, C.T., Mitchell, J.S.B., 1997. The lazy sweep ray casting

algorithm for rendering irregular grids. IEEE Transactions

on Visualization and Computer Graphics 3 (2), 142–157

ISSN 1077-2626.

Verma, S., Aziz, K., 1997. A control volume scheme for flexible

grids in reservoir simulation. In: Proceedings of the

Reservoir Simulation Symposium (SPE 37999). SPE, 13p.

Wilhelms, J., Gelder, A.V., 1990. Topological considerations in

isosurface generation extended abstract. Computer Gra-

phics (San Diego Workshop on Volume Visualization) 24

(5), 79–86.

Williams, P.L., Max, N.L., Stein, C.M., 1998. A high accuracy

volume renderer for unstructured data. IEEE Transactions

on Visualization and Computer Graphics 4 (1), 37–54 ISSN

1077-2626.

Wittenbrink, C.M., 1999. Cellfast: Interactive unstructured

volume rendering. In: Proceedings of the IEEE Conference

on Visualization—Late Breaking Hot Topics, IEEE Press,

Piscataway, NJ, pp. 21–24.

Yagel, R., Reed, D.M., Law, A., Shih, P.-W., Shareef, N., 1996.

Hardware assisted volume rendering of unstructured grids

by incremental slicing. In: Proceedings of the Volume

Visualization Symposium, IEEE Press, Piscataway, NJ,

pp. 55–62. ISBN 0-89791-741-3.