View-Dependent Streamlines for 3D Vector Fields
St
´
ephane Marchesin, Cheng-Kai Chen, Chris Ho, and Kwan-Liu Ma
Fig. 1. Sample rendering of a plume vector field dataset using our streamline selection technique. Our technique is able to depict the
interesting data features in a view-dependent fashion while avoiding self-occlusion from the streamlines, and does not require any
user intervention.
Abstract—This paper introduces a new streamline placement and selection algorithm for 3D vector fields. Instead of considering
the problem as a simple feature search in data space, we base our work on the observation that most streamline fields generate a
lot of self-occlusion which prevents proper visualization. In order to avoid this issue, we approach the problem in a view-dependent
fashion and dynamically determine a set of streamlines which contributes to data understanding without cluttering the view. Since our
technique couples flow characteristic criteria and view-dependent streamline selection we are able achieve the best of both worlds:
relevant flow description and intelligible, uncluttered pictures. We detail an efficient GPU implementation of our algorithm, show
comprehensive visual results on multiple datasets and compare our method with existing flow depiction techniques. Our results show
that our technique greatly improves the readability of streamline visualizations on different datasets without requiring user intervention.
Index Terms—Streamlines, Vector fields, View-dependent.
1INTRODUCTION
Streamlines are a very simple way of conveying the structure of 3D
vector fields. By following the vector field path, they show this in-
formation in an intuitive fashion. However, two major issues arise
because of the aforementioned simplicity of the technique:
• The first issue is the ability of the final pictures to convey the ac-
tual vector field structure carried by the data. In order to properly
present the vector field information, it is necessary to choose the
streamlines which best depict the behavior of the field. This is
only a function of t he vector field characteristics and is therefore
a view-independent problem.
• The second issue is that of cluttered pictures; it is caused by the
occlusion between streamlines and is especially relevant when
visualizing 3D fields. As we show in the related works section,
this problem was not yet taken into account for 3D fields in the
literature. Indeed it is difficult to choose the lines which accu-
rately depict the flow - too many lines result in unreadable pic-
tures, while too few lines does not actually convey the vector
field structure. Although this is not a major issue in the case of
2D flows (because occlusion will never completely occlude in-
formation in this case, at worse it can drown it), for 3D flows
• St
´
ephane Marchesin, Cheng-Kai Chen, Chris Ho, and Kwan-Liu Ma are
with the University of California, Davis.
Manuscript received 31 March 2010; accepted 1 August 2010; posted online
24 October 2010; mailed on 16 October 2010.
For information on obtaining reprints of this article, please send
email to: tvcg@computer.org.
the situation worsens as actual occlusion along the line of sight
prevents structure visibility. In the specific case of 3D vector
fields this paper focuses on, the problem is therefore highly view-
dependent.
If we consider both issues at the same time, it becomes clear that a
streamline-based method needs to take view-independent and view-
dependent criteria into account at the same time to achieve proper
3D vector field visualization. Indeed, if we approach this visualiza-
tion problem in a data-centric fashion or in a view-dependent fash-
ion only, one of these issues will remain unsolved. In this paper, we
introduce a new streamline selection method based on streamline ad-
dition and removal algorithms. By combining view-dependent and
view-independent criteria we are able to depict 3D vector fields in
an uncluttered yet accurate fashion. Our method is automatic in that
it does not require user intervention to obtain readable pictures. We
present an implementation of our algorithm on the GPU using CUDA
and OpenGL, give detailed visual and performance results, and com-
pare our algorithm with other techniques.
2R
ELATED WORKS
For an overview on the general issue of flow visualization, we refer
the reader to the work of Weiskopf et al. [28] and to existing surveys
on flow visualization [6, 10], as this related work section focuses on
the sub problem of streamline placement and selection.
Streamline placement and selection for 2D fields and surfaces has
been a much researched topic. In this field, early strategies for the
placement of 2D streamlines minimizing cluttering have been intro-
duced by Turk et al. [26]. The authors propose to take into account
an image-space energy function when adding lines. This allows de-
piction of an accurate vector field structure while reducing the visual
1578
1077-2626/10/$26.00 © 2010 IEEE Published by the IEEE Computer Society
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 16, NO. 6, NOVEMBER/DECEMBER 2010
clutter of the final images. This work was later generalized to mapping
streamlines onto surfaces by Mao et al. [17]. Max et al. [19] propose
enhancing a contour surface with particle and streamline information,
and in particular do this in a view-dependent way. This work was gen-
eralized to planar surfaces by Jobard and Lefer [9] who use a similar
growing algorithm to fill a 2D field with evenly-placed streamlines.
Later, this work was further improved to handle 3D streamline seed-
ing by Ye et al. [31]. Zhanping et al. [15] propose an advanced
technique for evenly spaced streamlines including a loop detection al-
gorithm. Heuristic techniques have been proposed for the specific case
of electric current flow [7]. Wu et al. use the topology of the 2D vec-
tor field to place streamlines [30]. A different strategy for placing 2D
streamlines is introduced by Mebarki et al. [20]. By placing each new
line as far as possible from others, the authors ensure that long stream-
lines are favored. Annen et al. [2] propose a method to outline vector
field contours using streamlines. Li et al. [11] propose an illustrative
streamline placement method which summarizes the vector field with
few streamlines. In order to do this the authors use varying streamline
densities and use a dissimilarity metric to help choose different stream-
lines. Chen et al. [3] also use a similarity-guided streamline placement
method along with an error evaluation quantifying the loss of informa-
tion from representing a vector field using streamlines. Verma et al.
[27] use topological templates to choose streamline seeds. They then
use a statistical distribution to fill the rest of the vector field. Feature
detection is also made use of, and authors have proposed techniques
to detect swirling features [8], and closed streamlines [29]. However,
critical points are often difficult to find in a robust fashion. Despite
wide exploration of topology and heuristic based streamline placement
methods, the final visualizations are still subject to clutter when ap-
plied to 3D vector fields as the position of the viewpoint is not taken
into account.
Image-space methods have not been considered for 3D fields yet,
but they have been used for streamline and glyph placement onto
3D surfaces. Spencer et al. [24] introduce an evenly-spaced stream-
line placement method for 3D surfaces based on image-space criteria.
Using a projection/unprojection method which matches image-space
with data-space streamlines, Liu et al. [14] are able to place stream-
lines evenly onto 3D surfaces. In the field of glyph placement, Peng
et al. [21] introduce a view-dependent multi-resolution algorithm for
placing glyphs onto 3D surfaces. This algorithm uses different screen-
space glyph densities for different parts of the data. Li and Shen [13]
propose an illustrative image-based streamline placement technique,
but this method is restricted to a single plane of streamlines perpen-
dicular to the view direction. Although the authors focus on determin-
ing the streamlines which characterize a flow, the process can easily
omit relevant data portions. The same authors also proposed a view-
dependent LIC technique for surfaces [12]. Another solution to avoid
visual clutter is to use focus+context methods, for example as done by
Mattausch et al. [18].
Aside from the streamline placement problem, the information en-
tropy theory as introduced by Shannon [23] has been used in the vi-
sualization field, in particular for viewpoint selection [25] and for
streamline selection [5]. A number of enhancements have also been
done for streamline rendering quality, for example by Mallo et al. [16].
Salzbrunn et al. [22] introduce the concept of streamline predicates
which allows differentiating streamlines based on user queries.
Although much literature exists on the streamline placement and
selection issue, it mostly focuses on 2D problems (either 2D vector
fields, or finding streamlines onto a single surface or a single cut
plane). Applying these methods to 3D fields greatly limits the in-
formation that these visualizations can convey as it leads to missing
phenomena or features from the dataset. To address this problem and
produce relevant and readable visualizations, the viewpoint should be
taken into account as well as the vector field structure in the streamline
selection stage.
This paper introduces a new method addressing this issue. Our
method uses a hybrid image-space and data-space streamline selec-
tion and placement technique intended for arbitrary 3D vector fields
which does not require user selection. Our model is automatic and
allows accurate depiction of 3D vector field structure while avoiding
occlusion.
3V
IEW-DEPENDENT STREAMLINES
This section presents our view-dependent streamline visualization al-
gorithm for 3D vector fields. We first give an overview of our approach
and motivate the internals of our algorithm, and then detail its three
major components: the occupancy buffer and the streamline removal
and addition methods.
3.1 Motivation and Method Overview
Our view-dependent streamline visualization technique is iterative. In
order to achieve 3D vector field visualization using streamlines, we
adapt the position and number of streamlines to the current viewing
conditions as well as to each dataset. Our algorithm is based on four
major stages:
• Initially we compute a pool of random streamlines. The advan-
tage of working from a pool of precomputed streamlines is the
increased performance from not having to seed new streamlines
each time we run the algorithm. This stage is shown on the left
of Figure 2.
• The second stage computes an occupancy buffer by projecting
all the streamlines from the previous stage onto this buffer. Intu-
itively, the occupancy buffer is used to tell which regions of the
screen are highly occluded and which ones are not.
• The third stage prunes the streamlines which generate visual
clutter. Based on the information from the occupancy buffer
and also on streamline-specific criteria, we are able to determine
which lines to remove first while maintaining a high visualiza-
tion accuracy. We repeat this stage until our criterion for lines is
met by all lines. The result is shown in the middle of Figure 2.
• The last stage adds streamlines to uncovered areas. Filling the
empty areas helps conveying the global shape of the data and the
context of phenomena. By looking at the occupancy buffer data
it is possible to find the empty areas in image space and seed new
streamlines there. Figure 3 motivates the use of a streamline ad-
dition technique on top of streamline removal. Although the flow
in these empty areas could be depicted using some pre-existing
lines (shown in red in Figure 3), we cannot use them because
they will hide other features (shown in green in Figure 3). In
such a case, we need to be able to seed new streamlines (shown
in blue in Figure 3); the result of this stage is shown on the right
of Figure 2.
Fig. 2. Outline of our algorithm. Left: initial pool of streamlines. Middle:
we keep only streamlines which score high on our metric. Right: result
after adding streamlines to the previous stage to fill screen space.
3.2 Occupancy Buffer Computation
The first step of our algorithm is to build a so-called occupancy buffer.
This buffer is a screen-sized view-dependent buffer in which each
point contains the number of streamlines projecting to this point di-
vided by the local thickness of the data. The occupancy buffer will be
used to evaluate how cluttered portions of the screen are.
To compute this occupancy buffer, we first iterate all the stream-
lines from the initial pool and project their f ootprint onto the buffer.
1579MARCHESIN ET AL: VIEW-DEPENDENT STREAMLINES FOR 3D VECTOR FIELDS
Fig. 3. Motivation for seeding new lines: the lower right part of the
picture could be covered using the red lines, but these red lines also
hide interesting features (in green). Instead, we choose to seed new
lines (in blue) to cover the lower right area.
The result is a per-pixel number of streamlines projecting onto this
pixel (this is depicted in Figure 4). Notice that only the screen-space
footprint of each streamline is projected here, and therefore we do not
take self-occlusion of a given streamline into account. Taking self-
occlusion into account would have a number of disadvantages. First,
it would favour small, non-overlapping lines. Second, it would mark
swirly lines as highly occluding and therefore discard them, whereas
such lines are often critical to flow understanding. Finally, even a mod-
erately curvy line can be seen as highly occluding from certain angles.
Therefore, we chose not to take line self-occlusion into account and
use the actual screen-space footprint instead.
We now know the number of streamlines projecting to each pixel.
However, thicker areas of the data contain more lines on average, while
thinner areas contain less lines on average. Therefore we need to nor-
malize this metric depending on the local thickness of the data for each
pixel, as shown in Figure 5. We thereby obtain the occupancy buffer.
Fig. 4. Streamline projection. For each pixel we compute the number
of streamlines projecting to that pixel. Self-occluding streamlines are
counted only once.
Fig. 5. Occupancy buffer value computation for two different rays at
screen points P
1
and P
2
. In order to obtain a data size-invariant metric
we divide the number of streamlines projecting to the c urrent point by
the length of the ray inside the data (L
1
and L
2
).
3.3 View-dependent Streamline Removal
Our view-dependent streamline removal algorithm starts from a large
pool of streamlines and decides which streamlines should be shown
Fig. 6. Parameters used to compute the entropy criteria. The streamline
is depicted in green and the distance (D
j
) and angular (A
j
) parameters
are s hown. Notice that there is one less value for angles than for dis-
tances.
according to a view-dependent criterion. We therefore need a criterion
to tell the needed lines from the unneeded lines. This criterion should
take into account both the relevance of a line (because of its shape
and ability at depicting the flow) and also the amount of occlusion it
produces. In order to achieve this goal, we now introduce multiple
criteria which we combine together to obtain a relevant metric.
The entropy theory [23] has been applied by Furuyo et al. [5] to
streamline selection. They define the streamline entropy as follows:
E
L
= −
1
log
2
(m + 1)
m
∑
j=0
D
j
L
S
log
2
D
j
L
S
(1)
where m is the number of streamline segments, D
j
is the length of the
j-th segment (as shown in Figure 6) and L
S
is the total length of the
streamline (the sum of the D
j
values). Using this value E
L
(which we
will refer to as the linear entropy), the authors are able to discriminate
streamlines featuring interesting properties. However, this quantity
only takes into account the local length of the streamline and not its
curvature. Therefore, we introduce in this paper a new quantity we
call the angular entropy, which quantifies the entropy of the angular
variations along a streamline:
E
A
= −
1
log
2
(m)
m−1
∑
j=0
A
j
L
A
log
2
A
j
L
A
(2)
where m is the number of streamline segments, A
j
is the absolute value
of the angle at the j-th streamline joint (as depicted in Figure 6) and L
A
is the total angular variation along the streamline (the sum of the ab-
solute values of the A
j
). In a fashion similar to the linear entropy, this
quantity conveys the amount of angular variation along a streamline
and therefore is useful for detecting flow phenomena.
Notice that both these entropy criteria depend on the step size used.
As the step size converges towards zero, these formulas converge to-
wards the amount of information carried by the angular and linear be-
haviour of the line. Intuitively, the linear and angular entropies quan-
tify the amount of variation in the length of the streamline segments
and in the amount of angular variation between those segments, re-
spectively. For example, if we consider the angular entropy measure
for a streamline making a perfect circle, the entropy is zero since the
angle is constant. On the other hand, if the angle between the line seg-
ments has high variations (for example the line has both circular and
straight sections), the angular entropy value will increase.
The last criterion used by our metric is the overlap value. Intu-
itively, this value quantifies how occluding a given streamline is. By
inverting the streamline projection and reconstructing the overlap in-
formation for each streamline, we are able to determine the amount
of occlusion for each of them. To do so, we compute the footprint of
each streamline, iterate its pixels and fetch the corresponding values
in the occupancy buffer, as shown in Figure 7. From a series of occu-
pancy values o
j
over n pixels, we compute the per-streamline overlap
average value:
Overlap =
n
∑
j=0
o
j
n
(3)
1580 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 16, NO. 6, NOVEMBER/DECEMBER 2010
The results of this operation are shown for each streamline on the bot-
tom of Figure 7.
Fig. 7. Streamline unprojection. On the top of the figure, the occupancy
buffer is shown along with four streamlines. On the bottom, we unpro-
ject these streamlines and gather the related occupancy numbers. The
per-streamline occupancy numbers are computed as the average of the
occupancy as shown in Equation 3.
Once we know the linear and angular entropies and the overlap
value for each streamline, we can compute t he streamline metric. Our
metric is the weighted sum of the linear and angular entropies divided
by the average overlap; this allows discriminating the streamlines with
interesting properties but which do not generate too much overlap:
C =
α
E
L
+
β
E
A
Overlap
(4)
where
α
and
β
are use-tunable coefficients allowing selection of
curved or straight lines; the impact of these coefficients will be dis-
cussed in the results section.
After the metric has been computed for each streamline, we sort the
streamlines using this score, and remove the streamlines with the low-
est values. Notice that since removing a streamline changes the occu-
pancy buffer contents and therefore the score for all other streamlines,
each streamline removal operation has to be followed by an occupancy
buffer update and an update of the score of the other streamlines. To do
so, we add one divided by the local thickness of the buffer to all the lo-
cations belonging to the footprint of the removed streamline. Once the
occupancy buffer has been modified, we have to recompute the met-
ric for all the lines. As this in turn can change the order of the other
streamlines, we need to sort them again. However, since we do this in
an incremental fashion the list is almost sorted and obtaining a fully
sorted list is usually achieved in a single pass. This process is repeated
iteratively until we reach a given number of target streamlines.
3.4 View-dependent Streamline Addition
In a similar fashion to the streamline removal algorithm, our stream-
line addition method is based on the information provided by the oc-
cupancy buffer. We decompose the occupancy buffer into a number
of tiles and compute the average occupancy per tile. We seed a small
pool of random streamlines (we use 5 lines in our implementation) of
constant length from the tile with the lowest occupancy, as depicted in
Figure 8, and keep the line resulting in the least occlusion. Notice that
we chose a constant length for simplicity reasons, but we envision that
a more complex cutoff technique could be used, for example by tak-
ing the projection of the streamline into account. Once we have added
this new streamline, we need to update the occupancy buffer in a way
similar to the streamline removal. We iteratively add streamlines until
all tiles have a non-zero occupancy. Notice that since seeding a single
new line can impact multiple tiles, this has to be implemented as an
iterative process and the occupancy buffer must be updated after each
addition.
Fig. 8. Streamline addition. We consider the occupancy information for
each tile and seed streamlines from the empty tiles. In this figure the
empty tiles are outlined in red.
4IMPLEMENTATION
We have implemented our streamline visualization technique in C++.
OpenGL was used for rendering and CUDA was used for the compu-
tation parts. The rendering uses shadows [1] and we color the lines
using Boy’s surface immersion [4] according to the local streamline
direction.
We now detail our implementation, whose outline is shown in Fig-
ure 9. The first stage is the streamline generation which is imple-
mented in CUDA and uses fourth order Runge-Kutta integration to
generate streamlines. Once the streamlines are generated, we further
construct streamtubes used for rendering from each streamline’s path.
We then compute the occupancy buffer which we will subsequently
use for removal and addition. This buffer is generated by rendering
streamlines in an additive fashion with the OpenGL blending function
set to (GL
ONE, GL ONE). However, we do not want a given stream-
line to count more than once per pixel. The straightforward way of
avoiding this would be to clear the depth buffer between the stream-
lines, and use the GL
LESS depth function. However, this would have
considerable overhead since one clear operation is required per stream-
line. Instead, we separate the depth buffer into the same number of
bins as we have streamlines, and we use a different depth value for
each streamline along with the GL
LESS depth testing function. As
the streamlines are drawn, they are put into successive bins, from back
to front. Thus we can avoid clearing the depth buffer between stream-
lines and still prevent each streamline from adding contributions to the
same pixel multiple times because of self-overlap. Notice that modi-
fying the depth value to a per-streamline constant in the vertex shader
does not work, because the OpenGL invariance rules do not apply if
the triangle points are different. Therefore we modify the depth value
in the fragment shader instead. Once the occupancy buffer has been
computed, we use its contents from within CUDA to derive the sort-
ing order for the streamlines. To do so we iterate the path of each
streamline and collect the overlap values (as shown in Figure 7), and
then compute the average of these values along each streamline to ob-
tain the overlap number from Equation 3. We then compute the metric
from Equation 4 for each streamline and sort them on the CPU ac-
cording to their metric score. Only the highest scoring streamlines are
kept. The line addition implementation also uses CUDA and the val-
ues from the occupancy buffer. We first compute the per-tile values
using a naive reduce algorithm, and sort the tiles based on their occu-
pancy. To seed a new line in a given empty tile, we randomly generate
a point (x, y) in screen space inside this tile, and unproject it into vol-
ume space to obtain (p,q,r) coordinates where r is chosen randomly
inside the volume. We then seed a new line from this point.
5R
ESULTS
This section presents results obtained with our method. In order to
conduct testing, we used multiple datasets, in all these datasets the
vector field is defined on a Cartesian grid. The datasets we used are the
following: a simulation of a hurricane (100 × 100 × 20), a simulation
of swirls resulting from wake vortices (64 × 64 × 64), a simulation of
1581MARCHESIN ET AL: VIEW-DEPENDENT STREAMLINES FOR 3D VECTOR FIELDS
Fig. 9. Outline of our implementation. The initial pool of streamlines is generated, and the occupancy buffer is computed for this pool. We collect
the occupancy for all streamlines and combine it with the entropy values to score them; we keep the best ranking streamlines. We then separate
the screen into tiles to find the empty screen areas. New streamlines are seeded from these tiles in an iterative fashion.
a tornado (64 × 64 × 64), a simulation of the air flow in a computer
room (417 × 345 × 60), a simulation of a solar plume (126 × 126 ×
512), a simulation of the heat flow around a cooking crayfish (322 ×
162 × 119), a simulation of a supernova formation (64 × 64× 64), and
a simulation of the air flow around a car (368 × 234 × 60).
The results section is organized as follows: we first give results per-
taining to the method parameters and their influence on the final pic-
tures, and determine the suitable ranges of parameters for use with our
technique. We t hen give performance results using an efficient GPU-
based implementation of our method. Next, we detail visual results
using our technique, and in particular show the view-dependent adap-
tivity of our work. Finally, we compare our technique with existing
methods.
5.1 Influence of the Parameters
We first evaluate the influence of the entropy criteria on streamline se-
lection. To do so, we seed a pool of 300 random streamlines into four
different datasets, and compute the linear and angular entropies for
each of these streamlines. Then we keep only the 30% of streamlines
with the highest entropy criterion. The results of these experiments
are shown in Figure 10. The first column shows the streamlines with
the highest linear entropy (
α
= 1and
β
= 0 in Equation 4). In particu-
lar, these lines are relevant for detecting long streamlines with velocity
variations, as seen on the swirls dataset (second row). The second col-
umn shows the result of using the sum of these two criteria (
α
= 1and
β
= 1 in Equation 4). As one would expect, this criterion is a middle
ground between the previous two cases. The sum of these two criteria
is the only metric which captures both the shape of the tornado and
the central vortex line. Using the swirls dataset, this criterion is able
to convey both the swirl cores and their interaction, without including
background lines which the random selection includes. Because of its
good ability at extracting both linear and curved features this is the
metric we chose for the rest of this paper. T he third column shows
the streamlines with the highest angular entropy (
α
= 0and
β
= 1in
Equation 4). This criterion allows selecting the lines with the high-
est curvature variation as seen with the tornado and swirls datasets (in
rows 1 and 2). Finally, the fourth column is there for reference and
shows a selection of 30% of random streamlines.
Figure 11 shows the influence of the size of the initial pool of lines.
This figure shows that the size of the initial pool does not heavily in-
fluence the quality of the final pictures.
5.2 Performance Results
Performance results are given in Table 1. These results were conducted
on a Xeon 5450 machine with 16GB of memory and a Geforce GTX
285 graphics card with 2GB of video memory; the performance was
evaluated at a 1024 × 1024 screen resolution. As Table 1 shows, the
performance of our algorithm does not highly depend on the number of
streamlines, because our technique works mostly in image space. We
therefore advocate the use of a large initial pool of streamlines. This
table also shows that we are able to obtain pictures in a few seconds (2
to 4 seconds depending on the dataset) at a 1024 × 1024 resolution.
Table 1. Performance results for our adaptive technique using different
datasets and different sizes for the initial streamline pool at a 1024× 1024
screen resolution. Times are given in milliseconds.
h
h
h
h
h
h
h
h
h
h
h
h
Dataset
Initial streamlines
1024 2048
Tornado 2541 ms 2545 ms
Crayfish 4498 ms 4488 ms
5.3 Visual Results
Figure 1 shows a visualization of the solar plume dataset using our
method. This picture shows that the areas of interest (core of the plume
and turbulences) are accurately depicted, and the correct context is also
given.
Figure 12 shows the influence of the tile size on the final render-
ings. As one could expect, these results show that the tile size impacts
streamline seeding. We notice that a good compromise is achieved at
1/20th of the screen size, which produces readable pictures without
generating too much clutter. For the rest of the results, the tile size we
use is therefore 1/20th of the screen
Figure 13 presents view-dependent renderings using the supernova
(top row) and the crayfish (bottom row) datasets. For each of these
datasets, a picture showing the initial pool of streamlines is shown
on the left, and two view-dependent renderings using our algorithm
are produced. In the case of the supernova dataset, although the base
streamline seeding results in a lot of overlapping, we are able to auto-
matically generate view-dependent streamline placements which keep
the core of the data visible. Similarly, with the crayfish dataset, both
view-dependent renderings maintain the visibility of the swirls inside
the data, and this information is not occluded by the surrounding ho-
mogeneous flow.
5.4 Comparison with other techniques
In Figure 14 we present a comparison of our method against a view-
dependent illustrative method from Li and Shen [13] (in the first row).
For these experiments, we tried to select the best dropping plane for
[13], i.e. the dropping plane providing the best description of the data
features. Notice that although the line selection we used is the same,
we did not implement the illustrative line rendering technique but used
realistic line rendering instead. In the second row, we present the 3D
streamline seeding technique from Ye et al. [31]. In rows 3 and 4,
we use two different densities of equispaced streamlines (a high and
a low density in rows 3 and 4, respectively). The last row of Figure
14 presents our streamline selection and placement algorithm. These
tests have been conducted on 4 different datasets, one per column.
1582 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 16, NO. 6, NOVEMBER/DECEMBER 2010
