GPU-based Raycasting of Hermite Spline Tubes

Benjamin Russig* Mirco Salm† Stefan Gumhold‡

TU Dresden TU Dresden TU Dresden

Figure 1: Rendering results from the technique presented in this paper. From left to right: example datasets Fibers, HotRoom and
Brain, as well as a side-by-side comparison of the bounding box geometry we use for raycasting and the tube segments they cover.

A BSTRACT radius, also follow a Hermite spline. During rendering, the Hermite
Visualizing curve and trajectory data is a common task in many sci- spline tubes are processed per Hermite spline segment, where each
entific fields including medicine and physics. Tubes are an effective segment is defined by two nodes with information about position,
visualization primitive for this sort of data, but they require highly radius, and their respective first derivatives.
specialized renderers to achieve high image quality at frame rates The remainder of this paper will give a focused overview of
sufficient for interactive visualization. We present a rendering algo- related methods in Sect. 2, explain our raycasting algorithm in detail
rithm for Hermite spline tubes, i.e. tubes that result from Hermite in Sect. 3, discuss preliminary results in section Sect. 4 and provide
splines interpolating the data, with support for varying-radii circular a brief outlook on future work in Sect. 5.
tube cross sections. Our approach employs raycasting and works 2 R ELATED W ORK
directly on this continuous representation without the need for sur-
face tessellation, made possible by an efficient ray-tube intersection Generalized cylinders were originally introduced by Agin and Bin-
routine suitable for execution on modern GPUs. ford [1]. In contrast to a regular cylinder, the cross section of a
generalized cylinder can be arbitrarily shaped and its axis is de-
Index Terms: Computing methodologies—Computer graphics— scribed by a curve. Tubes are a form of generalized cylinder with –
Rendering; Human-centered computing—Visualization—Visualiza- at least when characterizing common usage of the term in the visu-
tion Application domains—Scientific visualization alization community – rather simple, mostly convex cross sections.
In this section, we give a brief overview of related methods for
1 I NTRODUCTION rendering tubes. For conciseness, we restrict ourselves to methods
Tubes are employed as a primitive for visualizing a wide variety that employ raycasting or -tracing, as they are most related to our
of natural and abstract structures, ranging from white matter tracts approach. We categorize these methods according to whether they
and blood vessels (Merhof et al. [8]) over trajectories of physical work on some continuous description of the tube directly (we refer
particles and objects (Fraedrich et al. [4]) to stream- and pathlines to that as spline tubes) or rely on some sort of line primitives to
emerging from vector fields (Zöckler et al. [14], Meuschke et al. [9]). connect data points.
Formed by a (potentially varying) cross section extruded from a Spline Tubes. Bronsvoort and Klok [2] presented a method for ray-
central axis, they pose several challenges for efficient rendering, usu- tracing tubes defined by parametric curves. Their method employs
ally addressed by striking a compromise between image fidelity and a generic subdivision scheme that does not make any assumptions
render time. Traditionally, interactive realtime visualizations using about curve parameterization or cylinder cross sections, resulting
tubes rely on adaptive surface tessellation to maximize throughput in a highly versatile but expensive intersection routine targeted at
with minimal loss of quality (e.g. Stoll et al. [12], Nunes et al. [10]). offline renderers. Reina et al. [11] present a GPU-based raycasting
Since this still means discretization of the tube surface, a lot of addi- scheme for spline tubes with elliptical cross section. Ellipsoids have
tional data is being generated for rendering, worsening the geometry a discernible orientation, and this translates to intuitively understand-
bottleneck for large, complex datasets. able corkscrew patterns on the tube surface. They cannot provide
Raycasting of analytically or algebraically defined tube surfaces a compact implicit function for the tube surface, so they employ
can circumvent this problem, but compact formulations of the ray- the distance-bound raymarching strategy first presented by Hart [6]
surface intersection for the former or even just the tube surface to find ray intersections. Although raymarching tends to be slower
itself for the latter are not straight-forward or – depending on the than direct raycasting, their profiling results suggest that tessellation-
versatility of the tube primitive – non-existent. based techniques will be slower still for sufficiently large datasets
We tackle this problem by defining the tube from the volume as the GPU hits a vertex bottleneck. More recently, the open source
traced out by a sphere moving along the central axis, which we CPU raytracing framework Embree [13] added support for a variety
describe using a Hermite spline. Other tube attributes, notably the of spline curves for use as geometry primitives. The tube variants
* e-mail:
of these primitives sweep a planar circle along the axis, which can
[email protected]
† e-mail: create bulge artifacts in locations of very high curvature. Thus, they
[email protected]
‡ e-mail: [email protected] restrict valid cross section radii at a point to be smaller than the local
curvature radius of the axis.
Line Primitives. The other major category of relevant rendering
techniques is based on discretization into piecewise linear segments,
relying on a dense sampling for smooth-looking curves.
Han et al. [5] raytrace cone stumps and spheres on the CPU. To sup-
port artifact-free transparency despite composing their tube primitive
from multiple objects, they employ a CSG-derived interpretation of
ray surface hits. Kanzler et al. [7] utilize a novel voxel representa-
tion for lines, enabling fast image-order raycasting of line datasets
as tubes. Their main contribution is the voxel representation itself,
as it supports level-of-detail by means of a tailor-made averaging
operation, as well as fast voxel-based approximate simulation of
global illumination phenomena. For actual intersection of the rays
with tube segments, they employ a similar approach to Han et al. [5],
albeit without support for varying radii.

3 H ERMITE S PLINE T UBE R AYCASTING

3.1 Preliminaries
Figure 2: To obtain the oriented bounding box for a quadratic sub-
Terminology. A Hermite spline tube is defined by a sequence of segment, we compute a matrix M that transforms the unit cube in the
control points (henceforth called nodes) that provide position, radius, positive octant such that it tightly fits the tube segment geometry. The
and color values as well as derivatives. The shape and coloring of a direction from start to end control point (bb1 and b 3 , respectively) and
tube in between nodes is determined by a cubic Hermite interpolation the tangent ~t = b2 − b1 determine the orientation.
of the node attributes or, for the purpose of ray casting, a piecewise
quadratic approximation thereof (see Sect. 3.2). We will refer to the Rays are then cast in the fragment shader for every fragment gen-
value of an attribute of some node i as ni and its derivative as ti . erated by the rasterizer, yielding color and depth information for
The position spline defines a curve in world space that forms the closest intersection of the ray with the tube segment inside the
the generalized cylinder axis. We will mathematically refer silhouette.
to the position spline as p (t) and its component functions as
px|y|z (t), respectively. A tangent spline ~t (t) can be derived Segment subdivision. To obtain the two sub-segments, we create
from the position spline by differentiation with regard to the two quadratic Bezier curves per attribute, the control points of which
curve parameter, and it will interpolate the node tangents just we denote as a1 , a2 , a3 and b1 , b2 , b3 , respectively. For a segment
like the position spline interpolates the node positions. The referencing nodes i, j, we set the control points at the segment nodes
radius spline r(t) defines the radius of the sphere extruding to a1 = ni and b3 = n j . The respective middle control points are
... then calculated as a2 = ni + c1 ti and b2 = n j − c2 t j . We choose
the tube at t, and the color spline c (t) describes the color value
attributed to t. c1 = c2 = 1/3, motivated by the Hermite/Bezier basis transformation.
Finally, pairs of adjacent nodes form tube segments, resulting in Setting a3 = b1 = (a2 +b2 )/2 connects the sub-segments with C1 con-
individual per-segment polynomial curves. Of particular interest for tinuity at the junction. The Bezier control points are provided to the
our algorithm are the position curves p k (t) and radius curves rk (t), fragment shader as vertex attributes of the respective bounding box.
t = 0..1 of a segment k. Silhouettes. In order to minimize the number of ray misses, the
Data organization. During rendering, node data is stored as vertex silhouettes should be as tight-fitting around the tube sub-segments
attributes in a vertex buffer, each vertex representing one node. To as possible. At the same time, geometry load on the GPU should
form segments, pairs of nodes are referenced by means of an index be minimized in order to not lose the performance advantage of
buffer. The whole dataset can then be drawn with a single indexed raycasting for large datasets. We believe that oriented bounding
draw call for line lists. boxes are a reasonable choice. Despite their simplicity, they are
Note that we impose no notion of individual tubes; they form likely to be a good fit for the majority of tube segments in a dataset
naturally from segments that fit together. Sharp corners are sup- since individual segments curve relatively little in practice.
ported by duplicating a node with a differing tangent, at the To determine the bounding box for a sub-segment, we first select
cost of introducing redundancy for the other attributes of that a suitable orientation. We found the following strategy to yield
node. Bifurcations are supported by referencing the same node reasonable results (the sub-segment position curve b (t) is again
more than twice, or optionally – if discontinuity of any of the at- determined by Bezier control points b1 , b2 , b3 ):
tributes is desired – referencing another duplicate of that node from • x-axis: use the normalized vector from start node to end node,
the bifurcating segment. i.e. x̂x = kbbb3 −bb1
−bb k
.
3 1

3.2 Rendering • y-axis: project the tangent~t = b 2 −bb1 onto a plane with normal
x̂x and normalize, i.e. ŷy = ~v/k~v k where~v =~t − x̂xh~t , x̂xi. In case
Algorithm. We begin with a high-level view of the rendering the tangent and x̂x are colinear, we choose any unit vector
algorithm. Our method targets rasterizer systems, meaning we have orthogonal to x̂x.
to first identify the fragments for which to cast rays at the scene.
• z-axis: results from the cross product ẑz = x̂x × ŷy.
This necessitates the use of silhouette geometry. We opted to employ
oriented bounding boxes around the tube segments in world space. We can now construct a matrix R = (x̂x ŷy ẑz)T representing a rotated
The algorithm starts with a single indexed line list draw call for the version of world space that has its basis vectors aligned with the final
whole dataset. The vertex shader is purely pass-through, providing bounding box edges. Transforming control points into this frame
the geometry shader with the start and end node of a segment. The yields the transformed position curve q (t) = R · b (t), which we use
geometry shader takes the line formed by the two nodes as an input for determining the bounding box extents by calculating the extrema
and outputs triangle strips for two oriented bounding boxes tightly of the component functions qx|y|z (t) ± r(t).
covering the whole tube segment. We output two boxes per segment Let qx|y|z,− (t) = qx|y|z (t) − r(t) and qx|y|z,+ (t) = qx|y|z (t) + r(t).
because we actually subdivide the cubic curves of a segment into The segment extrema can be found by evaluating each component
two quadratics at the geometry shader stage – we will explain our function at t = 0, 1 as well as an additional candidate tx|y|z acquired
reasoning for doing this when discussing the intersection routine by analytically computing the roots of the respective (linear)
later on. first derivatives q0x|y|z,− (t) and q0x|y|z,+ (t). This candidate will be
considered only if it falls inside the parameter range [0, 1]. y
We denote the minimum and maximum value of a component
as {x|y|z}min and {x|y|z}max . With the extrema of each component
function known, they result from the respective smallest and largest
values. For the x-extent, this yields:
xmin = min (qx,− (0), [qx,− (tx ), ] qx,− (1))
xmax = max (qx,+ (0), [qx,+ (tx ), ] qx,+ (1))

With this, scaling and translation for the oriented bounding box can
be fixed. The corresponding homogeneous transformation matrix xmin xl x
for use on the positive unit cube (see Fig. 2) is calculated as follows:
z
 xmax − xmin 0 0 xmin
 

R T 0  0 ymax − ymin 0 ymin 
M= ·
0 1  0 0 zmax − zmin zmin  Figure 3: Spheres along a spline segment in ray space are intersected
0 0 0 1 with the x-axis (the ray), resulting in an intersection point x1 . The point
p k (t) on the position curve and corresponding sphere radius rk (t) are
Intersection. Since no compact implicit function describing a parametrized by the local curve parameter t = 0..1 of tube segment k.
spline tube segment is available, direct raycasting (i.e. without The first intersection xmin with the tube segment is found by minimizing
employing a ray marching strategy) requires a parametrized ray- x with respect to t.
segment intersection to be formulated first. To that end, we
parametrize the ray-sphere intersection problem such that position When using the cubic position and radius curves of the segment as
and radius of the sphere are determined by the respective attribute is, g will become a polynomial of degree 6. If we use the quadratic
curves. We then construct a function l = f (t) that directly relates sub-segment curves instead, we can get g down to degree 4. We
the curve parameter t to the ray parameter l corresponding to the could now analytically calculate all real roots of g by applying the
front-facing intersection with the sphere at t. Thus, the smallest quartic equation. However, due to the large number of arithmetic
local minimum of that function within the segment domain t = 0..1 operations involved, we opted to use the same fast iterative approach
yields the closest intersection of the ray with the tube segment. we apply to f 0 .
We further simplify the problem by formulating the intersection
in ray space (see Fig. 3). We define the ray as r(l) = o + l · d̂d , Root finding. In the following, we describe the strategy we use
where the ray origin o is the eye position and d̂d gives the direction for solving all root finding problems posed by our method. Let u(x)
to the point on the image plane corresponding to the fragment. In ray be a polynomial. We bracket the real roots we are interested in by
space, the coordinate system origin is at o , while the ray direction d̂d some isolating interval [xa , xb ] such that u(xa ) and u(xb ) evaluate to
coincides with the x-axis (any two vectors forming an orthonormal opposite signs. We then use the bisection method [3] to approximate
basis with d̂d may be chosen as y and z axes). them. We believe bisection to be a reasonable choice for our use
We start with the intersection of a sphere (defined by its position case because of its low per-iteration cost and fixed convergence rate,
p and radius r) and the x-axis, which is computed as: but investigating methods with faster theoretical convergence is a
q promising avenue for future work.
s(pp, r) = px ± r2 − p2y − p2z (1) Since every real root of u within some interval [a, b] of interest lies
in between two subsequent extrema that evaluate to opposite signs,
its extrema provide all the information needed to form isolating
Plugging in the segment attribute curves for ray-space position and
intervals (in this context, the interval borders can be extrema as
radius (we omit the segment ID k for legibility) and chosing the
well). Determining the extrema of u is equivalent to finding the roots
front-facing intersection yields:
of its derivative. Therefore, starting with some derivative for which
q it is known that only a single root inside [a, b] exists, it is possible to
f (t) = px (t) − r(t)2 − py (t)2 − pz (t)2 (2) recursively apply bisection to determine the isolating intervals for
all lower derivatives of u up to the original polynomial.
We minimize f via differentiation with respect to t. For convenience, If u is of degree n, the roots of n derivatives need to be found.
we denote the individual polynomials outside and inside the square Additionally, the number of potential real roots of each derivative
h(t) = px (t) and g(t) = r(t)2 − py (t)2 − pz (t)2 , i.e. f (t) =
root asp equals its degree. Consequently, the worst-case complexity of this
h(t) − g(t), yielding the derivative algorithm is O((n2 +n)/2). However, some root searches can be saved
by analytic computation as soon as the derivative is of sufficiently
g0 (t) low degree. For our g of degree 4, we chose to analytically compute
f 0 (t) = h0 (t) − p (3) the real roots of g00 (which is quadratic), necessitating 7 numerical
2 g(t)
root searches in the worst case.
f and f 0 are real only within intervals where g(t) ≥ 0, so finding the f is not a polynomial, so we cannot stop at some derivative for
minima of f via root search on f 0 requires knowing the real roots of which a closed-form solution exists. However, we observed from
g first. Then, root finding on f 0 has to be performed on the following empirical study of f that the number of roots consistently decreases
intervals of t = 0..1: with every differentiation, and that f 0 has a maximum of 3 roots per
(a) tmin = 0 and the first real root of g at t0 , iff. g(0) > 0 real interval (we would like to follow up with a formal proof for
these claims in future work). This means that starting from f (3) , 6
(b) two subsequent real roots ta and tb of g, iff. g((ta +tb )/2) > 0
numerical root searches per interval are required in the worst case to
(c) the last real root of g at tn and tmax = 1, iff. g(1) > 0
find all real roots of f 0 . Also, we observed that in every real interval
Intuitively, these intervals can be thought of as ranges of the curve where f 0 has 3 real roots, the middle one always corresponds to a
parameter t where the tube segment and the ray spatially overlap, local maximum of f and can thus be ignored, bringing down the
and the number of these intervals corresponds the the number of worst-case number of root searches per interval to 5. For some
times the ray hits the tube segment (see Fig. 4). illustrative plots of f and its companions, see Fig. 4.
 (a)

ms ours (far) tess. (far) triangles

ours (close) tess. (close)

63,8
62,6
triangles (ours) triangles (tess.)

26,0
26,6
(b) (c)

19,1
10,2
Figure 4: Example plots of f . Every interval where f is real corre-

9,7
9,3

8,9
8,8
7,6

5,6
5,4
sponds to an intersection with the tube. Most configurations will result

4,6
3,2
2,5
1,5
0,5

0,5
0,4
in just one such interval (examples (a) and (b)). Several disjunct in-
tervals are possible if the ray leaves and enters the tube several times
(example (c)). Fibers HotRoom Bundle Brain Furball
Figure 5: Top: Procedurally generated datasets Bundle (left) and
Finally, we evaluate f at the roots of f 0 and chose the smallest value Furball (right). Bottom: Comparison of average render times (in
as the ray parameter corresponding to the closest intersection. milliseconds) and triangle count for each test dataset and view con-
figuration. For our method, the hatched area represents the average
Shading. For demonstration purposes, we apply simple local light- render time without any fragment shading performed. The triangle
ing with diffuse Lambertian reflectance and a Blinn-Phong specular count measured for tessellation is the average over all camera orbits
term to the tube surface. The surface normal required for lighting performed on a given dataset.
calculations equals the normal of the sphere at the curve parame-
ter t0 corresponding to the closest intersection, i.e. n̂n = ~n/k~n k with competitive with and finally surpasses tessellation as datasets in-
~n = r( f (t0 )) − p (t0 ). crease in size, in line with the findings reported for other raycasting
...
Currently, we use just the color obtained from c (t0 ) to determine techniques [7, 11]. Zooming in on a dataset incurs a noticeable
surface albedo. Adding texture would be possible by adopting a performance penalty for our method as it is highly fillrate-bound.
suitable surface parameterization. In general, performance of tessellation is more strongly coupled
to dataset size. Our method scales favorably in this regard, but over-
4 R ESULTS draw is a major performance factor even for smaller-sized data, as
For example renderings of the five test datasets using our method, see evidenced by the anomaly exposed by dataset HotRoom, which is
Fig. 1 and Fig. 5. These datasets are characterized by the following made up of segments much smaller in length than their average tube
statistics: radius, causing significant silhouette overlap within a tube (even the
Fibers HotRoom Bundle Brain Furball spheres at the bottom consist of dozens of segments each). In addi-
tion, we noticed a considerable impact of the geometry stages for
tubes 241 722 1250 1701 10000 very large datasets, suggesting alternative means of generating sil-
segments 3530 30948 105640 114489 787327 houettes are worth investigating. Irrespective of these considerations,
We compare the performance of our method against a tessellation- our method achieved fully interactive frame rates for all five datasets.
based strategy with comparable capabilities that employs dynamic
hardware tessellation for view-dependent level-of-detail, similar in 5 C ONCLUSION AND O UTLOOK
spirit to the method proposed by Nunes et al. [10]. In contrast to We presented an efficient algorithm for raycasting Hermite spline
our raycasting method, the tube surface model of the tessellation tubes. While initial results are promising, we identified many possi-
approach results from sweeping a planar circle along the position ble improvements and directions for further research.
spline instead of a sphere. The cross section at every sample is made For one, cubics are a third-order approximant, opening up the
up of 6 vertices at the base tessellation level and may get refined opportunity for drastic data reduction. We envision a pre-processor
to up to 30 vertices to enable a visual fidelity comparable to our that automatically merges segments, observing a user-defined error
method. The tessellator is also allowed to insert up to 5 additional bound. GPU-side tessellation could then be used to generate more
samples along the spline. complex silhouette geometry if overall curvature of a segment makes
For measuring rendering performance, we rendered each dataset tight fitting with a single box impossible.
in a 1920x1080, 45° vertical FoV viewport from two different view- Complex datasets incur a lot of overdraw due to occlusion. While
ing configurations, which we call close and far. The view was then existing strategies can be used to tackle this problem in a rasterizer
rotated in an orbit around the center of the dataset for 1000 frames. system, we think that with an efficient intersection routine avail-
For the far configuration, we chose a distance from the center such able, realtime raytracing (e.g. using NVIDIA RTX) is a promising
that the whole dataset fits the viewport, for the close configuration alternative for rendering large numbers of Hermite spline tubes.
we chose the distance to be 1/3 of that. To estimate the impact of
generating the silhouette geometry, we also performed these tests ACKNOWLEDGMENTS
with an empty fragment shader that discards all fragments. For ren- This work has received funding from DFG through TRR 248 (grant
der time measurements, performed on a Geforce RTX 2080 Ti GPU, 389792660) and the two Clusters of Excellence CeTI (EXC2050/1
see Fig. 5. Our experiments confirmed that our method becomes grant 390696704) and PoL (EXC2068 grant 390729961).
R EFERENCES
[1] G. Agin and T. O. Binford. Computer description of curved objects.
IEEE Transactions on Computers, C-25(4):439–449, 1976. doi: 10.
1109/TC.1976.1674626
[2] W. F. Bronsvoort and F. Klok. Ray tracing generalized cylinders. ACM
Trans. Graph., 4(4):291–303, Oct. 1985. doi: 10.1145/6116.6118
[3] J. D. Burden, R. L. Faires, and A. M. Burden. Numerical Analysis.
Cengage Learning, Clifton Park, NY, USA, 10 ed., 2015.
[4] R. Fraedrich and R. Westermann. Motion visualization in large particle
simulations. In P. C. Wong, D. L. Kao, M. C. Hao, C. Chen, R. Kosara,
M. A. Livingston, J. Park, and I. Roberts, eds., Visualization and Data
Analysis 2012, vol. 8294, pp. 274 – 285. International Society for
Optics and Photonics, SPIE, 2012. doi: 10.1117/12.904668
[5] M. Han, I. Wald, W. Usher, Q. Wu, F. Wang, V. Pascucci, C. D. Hansen,
and C. R. Johnson. Ray tracing generalized tube primitives: Method
and applications. Computer Graphics Forum, 38(3):467–478, jul 2019.
doi: 10.1111/cgf.13703
[6] J. Hart. Sphere Tracing: a geometric method for the antialiased ray
tracing of implicit surfaces. The Visual Computer, 12:527–545, 1996.
doi: 10.1007/s003710050084
[7] M. Kanzler, M. Rautenhaus, and R. Westermann. A voxel-based render-
ing pipeline for large 3D line sets. IEEE Transactions on Visualization
and Computer Graphics, 25(7):2378–2391, July 2019. doi: 10.1109/
TVCG.2018.2834372
[8] D. Merhof, M. Sonntag, F. Enders, C. Nimsky, P. Hastreiter, and
G. Greiner. Hybrid visualization for white matter tracts using triangle
strips and point sprites. IEEE Transactions on Visualization and Com-
puter Graphics, 12(5):1181–1188, 2006. doi: 10.1109/TVCG.2006.
151
[9] M. Meuschke, S. Oeltze-Jafra, O. Beuing, B. Preim, and K. Lawonn.
Classification of blood flow patterns in cerebral aneurysms. IEEE
Transactions on Visualization and Computer Graphics, 25(7):2404–
2418, 2019.
[10] G. Nunes, A. Valdetaro, A. Raposo, B. Feijó, and R. de Toledo. Render-
ing tubes from discrete curves using hardware tessellation. Journal of
Graphics Tools, 16(3):123–143, 2012. doi: 10.1080/2165347X.2012.
659610
[11] G. Reina, K. Bidmon, F. Enders, P. Hastreiter, and T. Ertl. GPU-based
hyperstreamlines for diffusion tensor imaging. In B. S. Santos, T. Ertl,
and K. Joy, eds., EUROVIS - Eurographics /IEEE VGTC Symposium
on Visualization. The Eurographics Association, 2006. doi: 10.2312/
VisSym/EuroVis06/035-042
[12] C. Stoll, S. Gumhold, and H. P. Seidel. Visualization with stylized line
primitives. In VIS’ 05. IEEE Visualization, pp. 695–702, 2005.
[13] I. Wald, S. Woop, C. Benthin, G. S. Johnson, and M. Ernst. Embree: A
kernel framework for efficient CPU ray tracing. ACM Trans. Graph.,
33(4), July 2014. doi: 10.1145/2601097.2601199
[14] M. Zöckler, D. Stalling, and H.-C. Hege. Interactive visualization of
3D-vector fields using illuminated stream lines. In Proceedings of the
7th Conference on Visualization ’96, VIS ’96, p. 107ff. IEEE Computer
Society Press, Washington, DC, USA, 1996. doi: 10.5555/244979.
245023