Interactive Visualization of Volumetric Vector Fields Using Texture BasedParticles

Stefan Guthe, Stefan Gumhold, Wolfgang Straßer

WSI/GRIS University of Tubingenguthe@gris.uni-tuebingen.de

ABSTRACT

This paper introduces a new approach to the visualization of volumetric vector fields with anadaptive distribution of animated particles that show properties of the underlying steady flow. Theshape of the particles illustrates the direction of the vector field in a natural way. The particles aretransported along streamlines and their velocity reflects the local magnitude of the vector field.Further physical quantities of the underlying flow can be mapped to the emissive color, the trans-parency and the length of the particles. A major effort has been made to achieve interactive framerates for the animation of a large number of particles while minimizing the error of the computedstreamlines.There are three main advantages of the new method. Firstly, the animation of the particles dimin-ishes the inherent occlusion problem of volumetric vector field visualization, as the human eyecan trace an animated particle even if it is highly occluded. The second advantage is the variableresolution of the visualization method. More particles are distributed in regions of interest. Wepresent a method to automatically adjust the resolution to features of the vector field. Finally, ourmethod is scalable to the computational and rasterization power of the visualization system bysimply adjusting the number of visualized particles.

Keywords: flow visualization, vector field visualization, flow animation, steady flow, splatting.

1 INTRODUCTION

The number of new applications in the area ofComputational Fluid Dynamics is constantly in-creasing while at the same time the dataset com-plexity is also increased. The need for visualiza-tion methods is not exhausted yet. Although theproblem has been studied thoroughly in two di-mensions for volumetric vector fields new chal-lenges are arising. The major problem in threedimensions is the occlusion problem. The humanvisual system works on the basis of 2d images.One eye produces 2d images while two eyes pro-duce 2d images with additional depth informa-tion. All visualization methods have to projecttheir interpretation of the vector field into a twodimensional image. The simplest method is toslice the vector field and use a hedge hog method,i.e. drawing small arrows. But here the globalstructure of the vector field may be lost. If thecomplete volume of the dataset is projected intotwo dimensions because of occlusion only thesurface of the dataset can be seen. Three possi-

ble workarounds are a transparent visualization, asparse sampling of the vector field or feature ex-traction. Feature extractions is very difficult forthree dimensional vector fields because there is amuch larger variety of features and it is not clearhow to illustrate them intuitively.

The use of transparency and sparse samplingonly diminish the occlusion problem slightly.Even for a scalar field a transparent renderinggives a depth impression only, when the dataset isrotated interactively. As a volumetric vector fieldcontains much more information than a scalarfield, a simple transparent visualization will fail.In the case of a sparse sampling of volumetricvector fields it is very difficult to get an idea ofthe visual order of the samples without additionalcues. Our new visualization method combines theuse of transparency with an adaptive sampling.We use transparent arrow shaped or comet likeparticles as samples, which intuitively show thedirection of the vector field. It is also possibleto use any of the icons proposed by Walsum et

al. [van W96]. The perception of the depth or-dering is improved by adding a halo around eachparticle and by the high occlusion of the particles.The changing of the occlusion by animating par-ticles gives further cues about the depth ordering.And at the same time the human eye is able totrack even highly occluded particles deep insidethe vector field with the help of the motion co-herence. In this way the sampling density can beincreased with a deeper insight into the interiorof the vector field. The length and the speed ofthe particles in the animation reproduce the mag-nitude of the vector field in a natural way.

A second major advantage of the use of par-ticles is that the visualization resolution can lo-cally be adapted to the resolution of a vector fieldwith highly varying sampling resolution. We alsoshow how to accentuate vector field features byincreasing the sampling resolution in their sur-rounding. Again the animation of the particlesimproves the understanding of the different kindsof features very intuitively. Thus we can visualizevector field features without the need of actuallyextracting and visualizing them.

A further important advantage of our methodis the low pre-computation time and the interac-tive frame rates, which can be guaranteed also onlow-end machines by reducing the number of vi-sualized particles. This does not imply a reduc-tion of the sampling resolution of the vector fieldas the particles can be focused on any arbitraryregion.

1.1 RELATED WORK

Zockle et al. [Zockl96] introduce an interactivealgorithm for visualization of flow data using asparse representation of the vector field. They vi-sualize a large number of very fine illuminatedstreamlines, which are preferably initiated nearfeatures of the vector field. It is difficult to vi-sualize further physical quantities and the depthimpression is only good for a very sparse sam-pling of the vector field.

Wijk [Wijk93] extends the streamline ap-proach to stream surfaces by the use of para-metric surfaces. The extraction of stream sur-faces gives a good overview over the global prop-erties of the vector field, but views at severaldepths are not possible at the same time, sincethe stream surfaces are opaque. Raycasting sev-eral of these stream surfaces as proposed byFruhauf [Fruha96] permits the perception of sev-eral stream surfaces in different depths, but thelow sampling resolutions orthogonal to the streamsurfaces is disturbing. It is also very tricky to lo-cate critical points of the flow without visualizingthem separately, but the main drawback is that

the difference of the vector length between twostream surfaces can not be seen.

For the 2d case Line Integral Convolution(LIC, see Cabral and Leedom [Cabra93]) is oneof the best ways to visualize a vector field in twodimensions because it generates a dense represen-tation of the vector field. Although it does notexplicitly extract streamlines the resulting pic-tures are very similar to the ones generated withstreamlines. To combine a good global overviewand the visualization of critical points, Inter-rante and Grosch [Inter97] generalize the LICto volumetric vector fields, while H. W. Shen etal. [Shen96] use three- and two-dimensional LICto visualize local and global properties of the vec-tor field. The density of the LIC representationmakes it almost perfect for two dimensional vec-tor fields but rather unsuitable for volumetric vec-tor fields because of the extreme amount of occlu-sion.

Simple particle tracing uses only points asparticles and therefore represents the vector fielddirection only through the particle animation.The larger the particle and the more complex it is,the fewer particles can be visualized without con-fusing the observer. Visualizing flow data with aprobe as proposed by Leeuw and Wijk [Leeuw93]gives a good impression of the local surround-ing of the particle but cannot provide a globaloverview of the whole vector field or the globaltopology.

Crawfis and Max [Crawf93] took a differentsplatting approach to render the scalar and vectorvalued fields by encoding the vectors with parti-cles that reside on the texture used by the splattingalgorithm. The particles in their method have theshape of little blobs that fade along the directionof the vector field.

1.2 PAPER OVERVIEW

The visualization of volumetric vector fields us-ing particles leads to several tasks. Starting witha vector field, we present a way to visualize localproperties of the field using a single particle. Af-ter being able to set up a particle, we introducean accurate method to move a particle along astreamline while maintaining a certain distribu-tion within the vector field. After this, the ani-mated particles are displayed using our texturedbased approach.

In section 2 we describe how to find a vectorfor any location in space using tri-linear interpo-lation. Section 3 describes how to animate parti-cles along streamlines and how to distribute themwithin the vector field. In section 4 we explainhow the particles are rendered and which prob-lems arise that way. Finally, we give some results

on the performance of our method in section 5.

2 FAST DATA ACCESS

In order to visualize a vector field using particlesthat represent properties of the underlying field,we need to know the vector and the additional pa-rameters for any location in space and thereforethe relative position within the dataset. Due tothe non-regularity of the underlying grid of realworld vector fields, we have to solve two mainproblems. We need a fast interpolation within ev-ery type of primitive in the dataset and a fast wayto find the corresponding primitive for any givenlocation in space.

2.1 INTERPOLATION

The interpolation that has been used during thecreation of the dataset can not be reconstructedin general. Therefore we need to define a localsteady interpolation within each cell of the grid.There are mainly four different primitives usedfor a cell within a dataset representing a vectorfield, the tetrahedron, the pyramid, the triangu-lar prism and the hexahedron cell. While the in-terpolation within a tetrahedron is rather straightforward, the other three schemes are not that sim-ple.

The easiest way to define an interpolation isto split the cells into tetrahedra and interpolatewithin each tetrahedron using a matrix. Besidethe huge amount of matrices, the resulting gridand therefore the interpolation are not unique. Todefine an interpolation within a primitive consist-ing of n vertices requires the inversion of a n� nmatrix. Although inverting these matrices can becarried out quiet fast this leads to a huge over-head for storing the resulting matrices. Assum-ing that the surface of each primitive is nearlyplane, which can safely be assumed for most ofthe datasets used in the area of ComputationalFluid Dynamics, we can use a different, more ef-fective approach.

With vn as the vector at the point pn and thedistances dn to describe the position within theprimitive, leads to the following interpolation fora tetrahedron (see figure 1a for the naming of thedistances):

v =d0v0 + d1v1 + d2v2 + d3v3

d0 + d1 + d2 + d3(1)

Using a bi-linear interpolation on the quad-rangle of the pyramid (figure 1b) and a linear in-terpolation between the bottom and the top of thepyramid also results in a very simple interpola-tion. A bi-linear interpolation on the two opposite

a) b)

c) d)

Figure 1: Relative position of point l withineach primitive.

triangles and a linear interpolation between themcan be used for a triangular prism (figure 1c). Fi-nally the interpolation for the hexahedron (fig-ure 1d) is a simple tri-linear interpolation usingthe distances to each of it’s six faces.

Although these calculations can be carriedout very fast, the results are not linear within thecell, because the sum of the distances is not con-stant. On the other hand the interpolation usedduring construction may also not have been lin-ear. The later algorithm needs fewer space andtime than splitting the primitives into tetrahedraand by far less precomputational time than theone using inverted matrices.

2.2 FINDING CELLS

We are now able to calculate an interpolationwithin a cell, but we still need a way to find thecell containing the given point. Although thismight not seem necessary because animated par-ticles could find the new cell using the neigh-borhood information of the grid, we still needthese cells for inserting new particles. De Berget al. [Berg97] stated that the problem of pointinclusion in 3D can not be solved in general inlog(n) time, where n is the number of primitivesto be checked and that no optimal algorithm isknown.

The simplest but inefficient way to find thecorresponding cell would be to check every cellwhether it contains the point or not. Although thisis still quite fast for about 100 cells if a bound-ing box check is done first, large datasets can notbe visualized this way. To reduce the number ofcells to be tested for large datasets a bsp-tree canbe used. Although this would theoretically resultin a search time of log(n), there might alwaysbe cells intersecting the split plane of the tree.Therefore the intersecting cells have to be storedin both parts of the bsp-tree (as seen in figure 2a).

To reduce the number of cells to be tested ef-

a) b)

Figure 2: Building of bsp-tree with a singleplane or single references to every cell.

fectively we have to construct a bsp-tree by split-ting the dataset into two more or less evenly sizedparts while producing as few duplicate cells aspossible. This would require a balanced bsp-treeas described by de Berg et al. [Berg97] that cannot be constructed in general without limiting usto curvilinear grids. To reduce the number of pos-sible planes to split at, we only allow splits inthe direction of the x, y and z-axis, resulting ina rectangular bsp-tree and a faster search for theleaf that contains our current location. To con-struct a balanced bsp-tree while using the mosteasy to handle planes (those along the three axis),we use a three dimensional kd-tree (see de Berget al. [Berg97]). We split the dataset using allthree possible planes and choose the one produc-ing the least overhead splitting the dataset intotwo parts containing roughly the same number ofcells. This results in a nearly balanced bsp-treewhile trying to minimize the overhead. Howeversplitting the dataset until it can’t be split any fur-ther, i.e. no edge of any bounding box is insideour node of the bsp-tree, would result in a hugeoverhead as a single cell may be stored in a largenumber of leafs.

To handle more complex datasets, we need anapproach that does not need any additional mem-ory to store multiple references to each cell andtherefore enables us to split the dataset until onlya single cell is contained in every leaf of the bsp-tree. As seen in figure 2b, we split the datasetrather than the space at the current plane, result-ing in a fuzzy split region rather than a singleplane. The resulting region is stored in the bsp-tree rather than the plane used for splitting thedataset, because both parts of the tree have to betested if our current location is between these twoplanes. Therefore we can not guarantee that onlyone leaf is needed to find the corresponding cell.In the worst case it might even be possible that aregion of the dataset is present in every leaf of thetree and therefore every cell has to be tested. Thisapproach reduced the number of tests to an av-erage of 1:58 using the Oxygen Post dataset (seefigure 6) and is therefore faster than using neigh-borhood information. The overhead of this algo-rithm, i.e. the space contained in more than one

leaf, can be seen in section 5 table 1.

3 ANIMATED PARTICLES

Being able to visualize a single still particleleaves three problems for animating a largeamount of them. We need a scheme to distributeany number of particles within the dataset. Weneed a fast way to move a particle along the vec-tor field, i.e. a streamline has to be computed. Inaddition we also have to track them during theirmovement to remove particles at undesired loca-tions and insert new ones.

3.1 DISTRIBUTION OF PARTICLES

We need a distribution of particles to achieve ahigh sampling resolution in interesting regions ofthe vector field and a lower one in less interestingones. There are several characteristics that can beof interest. First of all the density or other physi-cal attributes attached to a flow field might be cor-related to the importance of a region, includingthe magnitude of the vector field. The curvatureand the square norm of the divergence as definedby Leeuw and van Wijk [Leeuw93], normalizedwith the local magnitude may also correlate to theimportance. Thus we come up with the followingdefinition of a weight function:

!(x) = !const + !1(x) + : : :+ !n(x) +(2)!(x)grad + !(x)div + !(x)curv

While !const is the amount of homoge-neously distributed particles, the weights !i(x)allow consideration of the different physicalquantities of the vector field to influence the par-ticle distribution. Finally, !(x)grad, !(x)div and!(x)curv incorporate the local gradient, diver-gence and curvature of the vector field. The func-tion !(x) can also be extended to handle the localshear and rotation of the vector field or any addi-tional function, such as the distance to the closestcritical point.

Now we can define a weight for any positionwithin the vector field but we still need a way todistribute the particles according to these weights.In order to distribute newly created particles, weintroduce the distribution octree. Every leaf getsits weight assigned by sampling the weightingfunction. Each node in this octree stores theweight of all its children. In each knot the num-ber of actually contained particles is stored andinitialized to zero at the beginning.

Each time a new particle is created, the distri-bution octree is traversed from top to bottom, thecell with the most missing particles is located andthe particle is placed randomly inside this cell.

Figure 3: Distribution octree for 10000 parti-cles with a maximum of 16 particles per leaf(Blunt Fin dataset).

The distribution octree is dynamically coarsenedand refined during the insertion and the removalof particles. A leaf, that should contain more theneight particles, is split while a node that containschildren of which each should hold less than oneparticle is combined to a single leaf. The distri-bution octree after insertion of all particles for theBlunt Fin dataset is shown in figure 3. To opti-mize the memory allocation we store the removedoctree cells during coarsening in a linked list (asproposed in [Meyer92]) in order to speed up cellcreation during refinement.

3.2 MOVEMENT

The fastest way to compute streamlines is a sin-gle step Euler integrator. Although it is suitablefor a quick preview, it can not be used for mostof the present vector fields due to its large er-ror. The best choice between performance and er-ror of the computed streamlines is a fourth orderRunge-Kutta integrator with adaptive step widthas described by Press et al. [Press92].

Although the integration is very fast for smalldatasets, there is a huge overhead for larger onesdue to the randomness of the memory access pro-duced by particles at different locations. To lo-calize most of the memory access the distributionoctree can be used. The algorithm starts with oneleaf and moves every particle in it before movingto the next one. Therefore we can test the cell thatcontained the previous location first.

3.3 UPDATING

After the particles have been moved along thevector field their distribution changed and regionsof low interest may contain more particles thanthey are supposed to, while regions of high inter-est may contain too few. For removing misplacedparticles and inserting them at a different locationwe need to know the current distribution of par-

ticles within the distribution octree. So we needto keep the number of particles per cell up to datewhile they are moving. But just replacing parti-cles at undesired locations leads to a heavy flick-ering that prevents the user to see any propertiesof the vector field if the particles are animated.

To reduce the amount of particles being re-moved during each step of the animation, everyparticle gets an age property attached. This ageallows a particle to stay in an overcrowded regionfor some time before it will be removed, thus en-suring that a particle is visible for at least a de-fined number of frames, allowing the user to traceit’s motion. Particles that sometimes visit over-crowded regions but mainly move along under-crowded ones need not be removed. To keep theseparticles, we reduce their age while they are inundercrowded regions and only increase the ageof additional particles in overcrowded ones. Thisalso leads to a minimum number of particles ineach region even if there are constantly too manyparticles present. This can be implemented by us-ing the list of particles in each leaf used for opti-mization in the last section.

Although this reduces the flickering as muchas possible while keeping the correct distributionof particles, there is still another way to dimin-ish it further. The flickering is produced by par-ticles that are removed from one location and arecreated at another at the same time. So we haveto fade them out after they reach their maximumage and fade them in again after creation insteadof ”teleporting” them to their new location. As aresult of this technique there is nearly no visibleflickering left.

4 DISPLAY

Visualizing a huge amount of extended, transpar-ent particles would be very slow if they were ren-dered using their correct geometry. On the otherhand, image based rendering would also be slowor need a huge amount of texture memory, if wedesire the perspective to be correct. This trade-off between speed and accuracy leads to a simpletexture based approach.

4.1 RENDERING

We need a fast and simple texture based approachto render each particle using only one rectangleand therefore only one texture per particle. Mov-ing this rectangle to the particle’s location fixesthree degrees of freedom. There are five de-grees of freedom left: three for the orientation ofthe particle and two for its length and diameter.The orientation can be specified by three rotationsalong the three coordinate axes. Let us assume the

Figure 4: Part of two different textures used forrendering particles.

particle is aligned with the x-axis (the local direc-tion of the vector field). The first rotation aroundthe x-axis can be avoided by choosing rotation-ally symmetric particles. The rotation around they-axis is performed by selecting the correct pre-rendered arrows or comet like shapes from oneof the textures shown in figure 4, which samplethe rotation around the y-axis densely. Next thelength and diameter of the particle are adjusted byscaling the rendering rectangle accordingly. Fi-nally the rotation around the z-axis is performedby rotating the rendering rectangle around the z-axis. For rendering all particles they have to besorted using the hashing algorithm proposed byMueller et al. [Muell99].

Although this simple texture based renderingis very fast, it has some major drawbacks. Thedistance between the viewer and the particle is ig-nored, resulting in a wrong perspective for mostof the particles. The particle is rotated after beingscaled while the texture is rotated first and there-fore the scaling changes the rotation angle. Thedistortion caused by the distance to the viewercan not be corrected without using more than onetexture per particle or a set of textures as seenin figure 4 for different perspectives. The distor-tion caused by scaling of the particle can partlybe removed if we take a closer look at the re-sulting transformations. The length of the parti-cle is scaled by s while it’s diameter is scaled bys0 = 1=

ps to keep the same volume. After this

the particle is rotated by �. On the other hand thetexture with the rotational angle of � is chosenand scaled by xs, ys and zs to simulate the orig-inal transformation. As the scaling to zs alongthe z-axis is lost during the projection to the finalimage, the following values for the texture corre-spond to any given particle.

� = atan

�tan�p

s3

�(3)

xs = scos�

cos�

ys =1ps

By now, we assumed that the viewing vectoris along the z-axis and the view up vector is they-axis. To calculate the coordinates of the tex-tured rectangle using any arbitrary camera direc-tion vdir and position vpos of a particle at theposition ppos with the direction pdir we definethe relative position and direction of the particle;vdir and pdir are normalized vectors.

rpos = ppos� vpos (4)

rup =vdir� pdir

jvdir� pdirjrfwd = � vdir� rup

jvdir� rupj� = asin(rpos � pdir)

After computing xs, ys and � using equa-tion 3 the textured rectangle p0:::3 can be drawnusing texture n out of 512 textures as seen in fig-ure 4.

n = 255:5 + 511�=pi (5)p0 = ppos� xs=2 � rfwd� ys=2 � rupp1 = ppos + xs=2 � rfwd� ys=2 � rupp2 = ppos� xs=2 � rfwd + ys=2 � rupp3 = ppos + xs=2 � rfwd + ys=2 � rup

4.2 TEXTURES

Our technique strongly depends on a good vi-sualization of the particles. The main demandson the particle visualization are that each particleshows the direction and vector length of the vi-sualized flow at the particle location and that theparticles are transparent. The direction and vec-tor length can be nicely represented with an arrowor a comet like shape. In order to achieve a highrendering quality of the particles, they where pre-rendered with a ray-tracer using high over sam-pling, thus resulting in a light source positioned atthe viewers position. The pre-rendered particlescontain luminance and absorption values, suchthat further attributes can be visualized throughthe hue and saturation values of each particle.

To allow deep insight into the vector fieldwhile maintaining a depth perception for eachparticle requires the particles to be transparentand occluding at the same time. The top left im-age in figure 5 shows non transparent particles re-sulting in a good depth perception but only fewinsight into the vector field. Using a constanttransparency of 50% as seen in the top right im-age results in better insight into the vector field,but the depth perception is nearly lost. Varyingthe transparency with the thickness of the parti-cle for each pixel, as seen in the bottom left im-age, does not improve the depth perception sig-nificantly. To improve the result any further we

Figure 5: top left to bottom right: Non trans-parent, constant transparency, varying trans-parency, varying transparency with added halo.

dataset cells cel./leaf overh.Blunt Fin 37,479 0.999 0.73Rotor Blade1 96,310 0.996 2.27Oxygen Post 102,675 0.997 1.90Delta Wing 201,135 0.988 3.79Space Shuttle1 834,938 0.993 6.47Cavity 1,124,253 0.999 3.77

Table 1: Number of cells and cells per leaffor bsp-tree using duplicate space. Over-head produced by duplicate space con-tained in different parts of the bsp-tree.

need to apply a halo like the one used by West-over [Inter97] that does not reduce the overalltransparency of each particle and therefore the in-sight into the vector field but improves the depthperception. It is also improved by a simple light-ing algorithm that scales the brightness of eachparticle according to its distance to the viewer.

Further improvements of the insight into thevector field and the depth perception can only beachieved by the movement of the particles alongthe streamlines and the ability of the user to rotateand move the complete dataset interactively.

5 RESULTS & PERFORMANCE

For performance measurements we used threedatasets from the NASA, the Blunt Fin, the Oxy-gen Post, the Delta Wing and the Space Shuttledataset (9 parts). Additionally two datasets fromthe 1995 ICASE/LaRC Symposium on Visualiz-ing Time-Varying Data, the Rotor Blade (4 parts)and the Cavity dataset (2 parts) were used, as seenin figure 6. Although the Rotor Blade and theCavity dataset are time-varying, only one timestep is visualized due to the amount of memoryneeded for the complete datasets.

a) Blunt Fin

c) Oxygen Post

e) Space Shuttle

b) Rotor Blade

d) Delta Wing

f) Cavity

Figure 6: The curvilinear grids of all used datasets.

The performance has been tested on an AMD-K7-800 using a GeForce 2 GTS chipset. All testswere made using 10,000 particles, a weight func-tion depending on the local divergence (50%) andcurvature (50%) of the vector field and a suitablespeed for the animated particles. The time neededto build the bsp-tree and the initial distribution oc-tree varies from 5 seconds for the bluntfin datasetto 89 seconds for the Space Shuttle dataset. Theadditional memory usage of the bsp-tree is 36bytes per cell, which is about the same as the 32bytes per vertex of the dataset itself. In additionthere are about 45 bytes per particle needed, as-suming an average of 4 particles per leaf for thedistribution octree.

The display part of our algorithm is capableof displaying about 250,000 to 275,000 particlesper second, depending on how much the densityof particles varies within the dataset. The moreevenly the particles are distributed the faster therendering is done due to the used hashing ap-proach.

The animation of the particles has been testedusing two different modes. A preview mode wasdefined using a single step Euler integrator asmentioned in section 3.2. The animation modeitself was defined using an adaptive step widthRunge-Kutta integrator with an error tolerance of1% that has also been defined in section 3.2. Al-

1Additional overhead (0.18 for Rotor Blade and 0.005for Space Shuttle dataset) produced by space containedwithin different parts of the dataset.

dataset fps preview fps animationBlunt Fin 10.63 7.50Rotor Blade 5.78 4.02Oxygen Post 8.95 6.39Delta Wing 6.32 3.60Space Shuttle 5.77 4.14Cavity 6.69 5.22

Table 2: Frames per second using 10,000particles animation preview (Euler singlestep) and animation (Runge-Kutta 1%).

though one might think the preview mode is a lotfaster, this is not true for most of the datasets asupdating the distribution octree and removing orinserting particles is very expensive compared tothe integration.

6 CONCLUSION & FUTURE WORK

The presented vector field visualization methodis based on a very simple and therefore very fasttexture based rendering algorithm, that allows theanimation of a large number of transparent parti-cles at interactive frame rates. The high quality ofthe particles was achieved by pre-rendering themwith a ray-tracer.

The transparency and animation of the parti-cles allows the user to see deeper into the dataset.Although the huge amount of information in avolumetric vector field still leads to some amountof occlusions when projected to the screen, thecoherent movement of the particles allows the hu-man eye to also determine direction and magni-tude of the vector field in partly occluded areas.With this advantage the sampling density of thevisualization can be increased compared to othermethods. The animation of the particles provedvery useful for intuitively understanding the mag-nitude of the underlying flow as the particles’ ve-locity is scaled accordingly.

The use of the texture based approach allowsus to adapt the visualization not only to the sam-pling of datasets with highly changing samplingresolution but also to emphasize features of theflow such as critical points and vortices. Finally,the rendering algorithm achieves high frame rateswith low pre-computational time and thereforeallows the user to investigate datasets nearly in-stantly.

REFERENCES[Berg97] Mark de Berg, Mark van Kreveld, Mark

Overmars, and Otfried Schwarzkopf. Com-putational Geometry Algorithms and Appli-cations. Springer-Verlag, Berlin Heidelberg,1997.

[Cabra93] Brian Cabral and Leith (Casey) Leedom.Imaging vector fields using line integral con-volution. In James T. Kajiya, editor, ComputerGraphics (SIGGRAPH ’93 Proceedings), vol-ume 27, August 1993.

[Crawf93] R. A. Crawfis and N. Max. Texture splatsfor 3D scalar and vector field visualization. InGregory M. Nielson and Dan Bergeron, edi-tors, Proceedings of the Visualization ’93 Con-ference, October 1993.

[Fruha96] Thomas Fruhauf. Raycasting vector fields.In Roni Yagel and Gregory M. Nielson, edi-tors, Proceedings of the Conference on Visual-ization, October 27–November 1 1996.

[Inter97] Victoria Interrante and Chester Grosch.Strategies for effectively visualizing 3D flowwith volume LIC (color plate S. 568). In RoniYagel and Hans Hagen, editors, Proceedings ofthe 8th Annual IEEE Conference on Visualiza-tion (VISU-97), October 19–24 1997.

[Leeuw93] W. C. de Leeuw and J. J. van Wijk. Aprobe for local flow field visualization. In Gre-gory M. Nielson and Dan Bergeron, editors,Proceedings of the Visualization ’93 Confer-ence, October 1993.

[Meyer92] Scott (Scott Douglas) Meyers. Effec-tive C++: 50 specific ways to improve yourprograms and designs. Addison-Wesley pro-fessional computing series. Addison-Wesley,1992.

[Muell99] Klaus Mueller, Naeem Shareef, JianHuang, and Roger Crawfis. High-quality splat-ting on rectilinear grids with efficient culling ofoccluded voxels. IEEE Transactions on Visu-alization and Computer Graphics, 5(2), April1999.

[Press92] William H. Press, Saul A. Teukolsky,William T. Vetterling, and Brian P. Flannery.Numerical Recipes in C, 2nd. edition. Cam-bridge University Press, 1992.

[Shen96] H. W. Shen, C. R. Johnson, and K. L. Ma.Global and local vector field visualization us-ing enhanced line integral convolution. In Sym-posium on Volume Visualization, 1996.

[van W96] Theo van Walsum, Frits H. Post, DeborahSilver, and Frank J. Post. Feature Extractionand Iconic Visualization. IEEE Transactionson Visualization and Computer Graphics, 2(2),June 1996.

[Wijk93] J. J. van Wijk. Implicit stream surfaces. InGregory M. Nielson and Dan Bergeron, edi-tors, Proceedings of the Visualization ’93 Con-ference, October 1993.

[Zockl96] Malte Zockler, Detlev Stalling, and Hans-Christian Hege. Interactive visualization of3D-vector fields using illuminated streamlines.In Roni Yagel and Gregory M. Nielson, edi-tors, Proceedings of the Conference on Visual-ization, October 27–November 1 1996.

Figure 7: Blunt Fin dataset (20,000 particles,!div = 0:5, !curv = 0:5)

Figure 8: Oxygen Post dataset (20,000 parti-cles, !div = 0:5, !curv = 0:5)

Figure 9: Space Shuttle dataset (50,000 parti-cles, !div = 0:5, !curv = 0:5)

Figure 10: Rotor Blade dataset (50,000 parti-cles, !div = 0:5, !curv = 0:5)

Figure 11: Delta Wing dataset (20,000 parti-cles, !div = 0:5, !curv = 0:5)

Figure 12: Cavity dataset (50,000 particles,!div = 0:5, !curv = 0:5)