See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/51076059

Visualizing Nonmanifold and Singular Implicit Surfaces with Point Clouds

Article  in  IEEE Transactions on Visualization and Computer Graphics · April 2011

DOI: 10.1109/TVCG.2011.79 · Source: PubMed

CITATIONS READS
6 98

3 authors, including:

R.J. Balsys
Central Queensland University
25 PUBLICATIONS   258 CITATIONS   

SEE PROFILE

All content following this page was uploaded by R.J. Balsys on 20 June 2020.

The user has requested enhancement of the downloaded file.

IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011
Visualizing Non-Manifold and Singular Implicit
Surfaces with Point Clouds
R.J. Balsys, Member, IEEE, D.J. Harbinson, and K.G. Suffern Associate Member, IEEE.
Index Terms—implicit surfaces, non-manifold surfaces, singu-
lar surfaces, curvature surfaces, point clouds, octree, intervals,
ray, cusp, ridge, intersection curves
Abstract—We use octree spatial subdivision to generate point
clouds on complex non-manifold implicit surfaces in order to
visualize them. The new spatial subdivision scheme only uses
point sampling and an interval exclusion test. The algorithm
includes a test for pruning the resulting plotting nodes so that
only points in the closest nodes to the surface are used in
rendering. This algorithm results in improved image quality
compared to the naive use of intervals or affine arithmetic
when rendering implicit surfaces, particularly in regions of high
curvature. We discuss and compare CPU and GPU versions of
the algorithm.
We can now render non-manifold features such as rays, ray-
like tubes, cusps, ridges, thin sections that are at arbitrary angles
to the octree node edges, and singular points located within plot
nodes, all without artefacts. Our previous algorithm could not
render these without severe aliasing.
The algorithm can render the self-intersection curves of
implicit surfaces by exploiting the fact that surfaces are singular
where they self-intersect. It can also render the intersection
curves of two implicit surfaces. We present new image space and
object space algorithms for rendering these intersection curves
as contours on one of the surfaces. These algorithms are better at
rendering high curvature contours than our previous algorithms.
To demonstrate the robustness of the node pruning algorithm
we render a number of complex implicit surfaces such as high
order polynomial surfaces and Gaussian curvature surfaces. We
also compare the algorithm with ray casting in terms of speed
and image quality
For the surfaces presented here, the point clouds can be
computed in seconds to minutes on a typical Intel based PC.
Once this is done, the surfaces can be rendered at much higher
frame rates to allow some degree of interactive visualization.
I. I NTRODUCTION
N implicit surface is a level (iso-valued) surface
A f (x, y, z) = c, where c ∈ < and f (x, y, z) is a 3D
scalar field. Implicit surfaces can be regular, non-manifold or
singular. Non-manifold surfaces have regions where they are
locally non Euclidean; singular surfaces include those that self
intersect. Implicit surfaces are widely used in mathematics,
science and engineering. Software that renders non-manifold
surfaces must be able to accurately render features such as
rays, cusps, singular points and arbitrarily thin sections.
Manuscript received February 26th, 2010; revised March 15th, 2011.
D. Harbinson and R.J. Balsys are with the Centre for Intelligent and
Networked Systems, Central Queensland University, Rockhampton, Qld.,
4702. Australia.
K.G. Suffern is with the Faculty of Engineering and Information Tech-
nology and the Faculty of Design, Architecture & Building, University of
Technology, Sydney. P.O. Box 123, Broadway, NSW, 2007. Australia.
Author for contact: balsys@cqu.edu.au
1
The main techniques for rendering implicit surfaces are
polygonization, scan line algorithms, ray casting, and point
based techniques. Regular parts of implicit surfaces can be
polygonized, but polygons can’t be used to render rays or
curves of self intersection because these have no surface area.
Relevant papers on polygonization include Bloomenthal[8],
Schmidt [24], and Bloomenthal et al.[9]. Thin sections, even
if they are regular parts of surfaces, can also be difficult to
polygonize, as discussed in Balsys and Suffern[2].
Sederberg and Zundel [25] presented a scan line algorithm
that can render non-manifold implicit surfaces, and success-
fully rendered the rays for Steiner’s Roman surface [28]. The
algorithm is, however mathematically complex, and only able
to render algebraic surfaces.
Until recently, high order algebraic surfaces and non-
polynomial implicit surfaces have been difficult to ray trace
because of the need to solve the ray surface intersection
equation. But Loop et al.[22], Knoll et al.[21] and Singh et
al.[26] have used interval ray casting to render such surfaces
where the ray-surface equation solution is replaced by interval
analysis along the ray to bound the intersections.
A. Contribution of this work
The major contribution in this work is a new point based
algorithm that computes a point cloud for implicit surfaces,
and can render high order algebraic and complex non algebraic
surfaces. The algorithm uses point sampling and the interval
extension of the implicit function as the octree subdivision
criteria. It uses a pruning algorithm, based on a signed distance
function, to reduce the number of plotting nodes around non-
manifold features. This results in more accurate rendering of
these features compared with our previous algorithms, for
example Harbinson et al.[17]. We have implemented CPU
and GPU versions of the algorithm. The node subdivision and
pruning scheme is discussed in Section II in the context of the
CPU version.
Using this approach, we can render thin sections of sur-
faces, cusps, ridges, tubes, singular points and curves of self
intersection at arbitrary orientations to the octree node edges.
We can therefore render thin rays at arbitrary angles, and
curved rays as in Figure 4. This was not possible using the
algorithm in Harbinson et al.[17] where rays and curves of
self-intersection had to be along node edges to be rendered
without severe aliasing. This was a major limitation. Table V
lists the implicit equations for the surfaces we have used in this
work. We discuss the implementation of the GPU algorithm in
Section III and also discuss its advantages and disadvantages.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011
In Section IV we present examples of non-manifold surfaces
rendered using our algorithm. In Section V we render a
curvature map, surface intersection curves, and curves of self-
intersections of surfaces. In Section VI we discuss two new
algorithms for rendering contours on surfaces. One works in
image space and the other in object space. In Section VII we
render some curvature surfaces of non-manifold surfaces. In
Section VIII we compare our algorithm to interval ray casting.
B. Related Work
A number of papers have been published on point based
techniques. Stolte et al.[29], and Stolte[30] used interval
arithmetic for voxelizing implicit surfaces. Their voxel space
has a resolution of 5123 , and they used the painter’s algorithm
for rendering the voxels. Balsys et al.[5] also developed a
sampling technique that uses octree space subdivision with an
interval exclusion test to minimize octree subdivision, but there
where issues of aliasing and robustness. They also presented a
criterion for the complete pixel coverage of implicit surfaces.
Harbinson et al.[17] reduced the rendering artefacts by using
gradient and point sampling information in the plotting nodes
to trim the interval voxels found at the plot depth. This resulted
in fewer points being rendered around non-manifold features,
thus sharpening the image. The new algorithm also resulted
in the rendering of singular lines as lines of constant finite
thickness. The resulting images were of much improved visual
quality and accuracy at lower plot depth. However, a disad-
vantage of the work was that the images still suffered aliasing
issues along silhouette edges, around surface contours, and
along the singular lines. In particular, artefacts still occurred
along rays and self-intersection curves that where not aligned
with node edges.
Harbinson et al.[18] also reported on a number of ap-
proaches to antialiasing silhouette edges, and developed a jitter
based antialiasing approach that does real time antialiasing,
and allows for antialiased contours to be rendered in real time.
Balsys et al.[4] used point based algorithms to render the in-
tersections of an implicit surface with a series of level surfaces
of scalar fields gi (x, y, z), i = 1..n. These are the surfaces
gi (x, y, z) = c for different values of c. The intersections are
rendered as contour lines on f (x, y, z) = 0. For example, this
can be used to visualize the intersections of various planes
with implicit surfaces. Alternatively, the scalar fields may be
functions related to the implicit surface, such as the Gaussian
curvature (see Spivak[27]).
Recently, GPU based ray tracing has been used for the real
time rendering of implicit surfaces. See for example Loop et
al.[22], Knoll et al.[21] and Singh et al.[26].
II. N ODE SUBDIVISION A LGORITHM
The new algorithm begins by defining a viewing cube with
center point C(x, y, z), and width w. This defines the parent
octree node. Eight child nodes are created with center points,
Ci=1,8 (x ± w4 , y ± w4 , z ± w4 ), and width w/2. If required,
the subdivision process will then recursively descend to a
maximum plot depth d, but a child node will be further
subdivided only if the natural interval extension F (X, Y, Z)
2
find_point_in_node( )
for vertex ← 0 to 7 do
if zero(vertex, index) then
p ← vertex(index)
point_list.push(p, g(p))
return
endif
if sign_change( ) then
c ← centroid( )
point_list.push(c, g(c))
return
endif
end
point_sampling_fails(C, w)
Fig. 1. Algorithm 1. f ind point in node(). Algorithm for finding point
data on f (x, y, z). Here, C is the center coordinate of the plot node, c is the
centroid of the polygon found in the node, p is the coordinate of the vertex
with a zero evaluation, w is the node width, and g(x, y, z) is the gradient
function, ∇f .
of the surface function f (x, y, z) contains 0.0. See Stolte[30]
and Balsys et al.[2]. This indicates that the surface may be
present in the interval defined by the vertices of the octree
node. Only if we are at the final plot depth, and if the surface
may be present, do we render the surface representation in the
plotting node.
The fact that we do not subdivide nodes that do not contain
the surface provides the algorithm with its efficiency. If the
node may contain a surface element then we either further
subdivide, or if we are at the maximum plot depth, we may
define a point that will be used to represent the surface in the
plotting node.
We need an approximation for the point f (x, y, z) = 0 and
the surface gradient g(x, y, z) in the plotting node as these
are both needed to render the point with shading. We compute
the gradient by numerically evaluating the analytic formula for
∇f .
In Algorithm 1 the function f ind point in node() con-
tains the steps to decide whether or not a point will be rendered
in the node. We use point sampling at the vertices of the
plotting node to determine the signs of the function f (x, y, z)
at the vertices. If any of these evaluates to 0.0 we push the
vertex’s coordinates into the point list as the vertex is on the
surface. Although it’s not common, a vertex can lie exactly
on a surface, and ignoring this results in rendering artefacts.
This is particularly important for rendering rays aligned along
an octree axis.
If no zero’s are found then, in sign change(), we try to
detect a sign change between any two vertices of the node.
If this occurs, part of the implicit surface must cross an edge
of the node, and the surface is unambiguously present. We
explored two options to determine which point to use in the
plotting node to represent the surface, with the results shown
in Figure 2 for Steiner’s Roman surface[28], (2). In Figure
2(a) we use the center of the plotting node. In Figure 2(b)
we use the centroid of the polygon. The centroid produces
points that are closer to the surface in the node and results
in a smoother surface appearance with less shading artefacts.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 3

(a) (b)
Fig. 2. Steiner’s Roman surface (2), partially rendered with points, using points that are (a) always at the center of the plotting node and (b) at the centroid
of the polygon found by polygonizing the node.

For illustration purposes we have used a low subdivision depth a point at the center of all such nodes and thus render all the
here so the points do not completely cover the surface. This extra points.
makes it appear semi-transparent. We timed these approaches, However, it is well known that intervals overestimate the
using 1200x1200 pixel images, for a number of surfaces with possibility that the surface exists in an interval, see Moore
the results given in Table I. et al.[23]. The test guarantees not to miss regions that may
contain the surface, but it is not an inclusion test. So always
TABLE I pushing points in the nodes that fail the sign test will result
S URFACE TIMING ( SEC ) FOR RENDERING USING NODE CENTER (NC) AND
POLYGON CENTROID (PC) AS THE R ENDER POINT WITH PLOT DEPTH OF 9 in too many points being generated, particularly around thin
USING CPU ALGORITHM . sections, cusps, ridges, tube and ray like sections. This is unde-
sirable as it results in rendering artefacts around such features.
Surface NC PC Ratio A possible solution is to use affine arithmetic[12], [13], in
Mitre 1.72 2.53 0.68 place of the interval test because affine arithmetic intervals are
Cyclide 24.50 25.86 0.95 tighter than those from intervals, see De Figueiredo et al. [12],
Steiners Roman 5.83 6.43 0.91
Chmutov 8th 272 278 0.98
[13]. This occurs because affine arithmetic keeps information
Bohemian star 127 132 0.96 on which terms occur in the interval. That allows the bounds
Boy’s 28.89 29.84 0.97 to be narrowed when the same term is used more than once
in an affine equation.
These timings show that there is about a 5% penalty in Figure 3(a) and (b) show the nodes of Steiner’s Roman
finding the polygon centroid rather than using the node center. surface produced using interval and affine arithmetic subdi-
As using the polygon center gives better visual results, we vision respectively. These show that the number of nodes
use this approach. Since the surface is present in the node we produced increases as the surface curvature increases. This is
can find the centroid of the polygon by simply averaging the worst around the non-manifold features - the rays and cusps in
surface intersections along the node edges. We investigated this case. Although affine arithmetic produces less nodes than
the use of a gradient descent method to move in the direction intervals, neither technique produces accurate images of the
of the zero of the ∇g(x, y, z) in the plot node, but this non-manifold features. Moreover, the time penalty for using
appreciably slowed the algorithm with little improvement in affine arithmetic can be high, see Table II.
image quality. As a result, we developed a method to prune the “false
positives” from the interval test. Because we subdivide the
viewing cube using an octree, we can generate the 26 values
A. Node Pruning of the center points in the neighbor nodes of f (x, y, z);
If neither of the above situations has occurred we have a f (xi , yi , zi ) where i ∈ {−1, 0, 1} except x0 , y0 , z0 . For each
quandary. Point sampling fails in the plotting node, but the neighbor node we test if the surface may be present. If it is
interval test indicates the surface may be present. As we render the voxels surface present flag is set to true, and we set a
to high plot depths where the projection of the plotting node flag to indicate whether the neighbor node centre is closer
is less than the size of the pixel we could, naively, just push by evaluating |f (p)| < |f (x0 , y0 , z0 )|. When all the neighbor
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 4

(a) (b) (c)

Fig. 3. Steiners’ Roman surface (2) rendered at a plot depth of 5 showing nodes that are found (a) using intervals, (b) using affine arithmetic and (c) using
the node pruning algorithm.

(a) (b) (c)

Fig. 4. The bohemian star surface (4) rendered using (a) interval, (b) affine arithmetic, and (c) interval pruning exclusion test at a plot depth of 9.

TABLE II
nodes have been tested in this manner we call prune(voxels). S URFACE TIMING ( SEC ), AND NUMBER OF NODES ( MILLIONS ) FOUND
In this function we count the number of nodes that are closer USING INTERVAL , AFFINE , AND INTERVAL PRUNING EXCLUSION TESTS AT
A PLOT DEPTH OF 9.
than the node being tested, that also have neighbors that are
closer to the surface. If this count reaches three, we discard Intervals Affine Pruning
the plot node f (x0 , y0 , z0 ) because there is a surface patch in Surface time nodes time nodes time nodes
the neighborhood of f (x0 , y0 , z0 ) that is closer to the surface. Mitre 1.35 1.75 41.2 1.42 1.72 1.40
Cyclide 6.98 9.09 87.0 1.83 24.5 1.82
Using this approach we get, for example, a small set of plotting Steiners Roman 2.04 2.20 20.4 0.61 5.83 0.55
nodes that bound a ray passing through the octree. This is Chmutov 8th 34.7 45.9 251 1.79 272 1.44
evident even at a low plot depth of 5, as in Figure 3(c). Bohemian star 16.8 18.5 142 1.18 127 0.84
Boy’s 6.91 5.09 131 0.62 28.9 0.56
Table II shows that the number of points found at plot depth
9 is consistently less for our interval pruning approach than
with the use of interval or affine arithmetic exclusion tests. point p, the magnitude |f (~ p)|, and flags to indicate if the
This is evident in Figure 3 and Figure 4 where surfaces are surface is present in the node, and if the node is to be pruned.
rendered using the three approaches. In Figure 4 we visually The plotting node has its center at C and if f (C) ≥ 0 the
compare the results of running the three algorithms to a plot node is discarded. Otherwise we initialize the 26 neighbor
depth of 9 for the Bohemian star surface (4). Compared to nodes voxels as given in Algorithm 2.
interval pruning the interval and affine arithmetic approaches The function voxels.prune() is called, as discussed previ-
produce poor results, particularly around the non manifold ously, when considering pruning false positives. Only if the
sections. plot node is not pruned do we push the plot node centre,
Comparison timings for a number of surfaces are also given C(x, y, z), and gradient function, g(x, y, z), into the point
in Table II. These show that generally, interval pruning is faster list to be plotted. In this manner we fill the point list with
than affine arithmetic, but slower than just using intervals. a large number of points that are close to the surface, and
The code is encapsulated in the function point sampling- thus part of the surface point cloud. The normal and point
f ails() in Algorithm 2. Here, voxels is a structure that stores values in point list are used with Phong shading and a z-
the following information about a node: the center coordinate buffer to render the surface. We use the jitter based antialiasing
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011
point_sampling_fails(  )
if f(C)  ” return
i=0
for  z  =  -­1  to  1  do
for  y  =  -­1  to  1  do
for  x  =  -­1  to  1  do
pĸ&  (x*  w),    pĸ&  (y*  w),    pĸ&  (z*  w)
x x y y z z
if surface_present  (p,  w/2) then
voxels[i++].set(true,  |  f  (p)  |  <    |  f  (C)  |  )   i  ++
else
voxels[i++].set(false,  false)
endif
end
end
end
if prune(voxels)  ==  false then
point_list.push(  C,  g(C))
endif
Fig. 5. Algorithm 2. point sampling f ails(). Here f is the function
being evaluated. C is the center coordinate of the plot node, and w is the
width of the plot node. A voxels is a struct that stores the center coordinate,
magnitude of the function value, and flags for whether the surface is present,
and whether the node is to be pruned or not. An array of 3 × 3 × 3 voxels
centered on the current plot node are created, a prune() method is used to
determines if the plot node is to be discarded.
approach presented in Harbinson et al.[18] to antialias the
resulting images, as it produces better results than the standard
OpenGL antialiasing algorithm.
III. GPU IMPLEMENTATION
Ultimately, we are only interested in obtaining a set of
points on the surface and their associated normals. If we
directly implemented our CPU algorithm on the GPU, the
resulting algorithm would be inefficient. This is because, as
we proceed down a subdivision pathway, we get to leaf nodes
more quickly down some pathways than others. Ideally, we
need an algorithm that will terminate all kernels at approxi-
mately the same time. The worst case scenario is when the
entire subdivision takes place by the subdivision of a single
node as this would use a single kernel.
Typical GPU’s are organized as a set of multi-
processors which each have execution units. For instance our
N vidia
R
275 has 30 multi-processors with 8 execution units.
Each execution unit can run 1 kernel at a time, so this card
can run 240 simultaneous kernels. To obtain good performance
from the GPU we need to try and keep all execution units
running. This implies that we balance the load across them.
The main problem is how to proceed with the node subdi-
vision process so that each kernel processes the same code,
and how to collect the resulting points list. Typically, to use
the GPU, you define an index value specifying how many
instances of a kernel you need. This also requires you to
specify a dimension for the index space. For this application
we used a 1 dimensional index space as each instance of a
kernel handles a single node.
We arrived at a two step solution shown in Figure 6 as
Algorithm 3 and in Figure 7 as Algorithm 4. In Algorithm 3 we
5
gpu_subdivide_1(Node*  in,  Node*  out,  int  outSize)
LQGH[ĸJOREDOBLG(0)
surface_present  (in[index],  F) ? IDOVH return
true
Lĸ0
IDOVH
i  <  8 ? return
true
MĸDWRPLFBLQF&outSize)
out[j]ĸFUHDWHBFKLOGBQRGH(i,  in[index])
Fig. 6. Algorithm 3. gpu subdivide 1(). The kernel takes as input an array
of nodes, in. The kernel global id() identifies the actual node. If the surface
may be present, up to 8 child nodes are created using create plot node(). The
atom inc() function is used to atomically index the output node, outthat store
the output nodes. The kernel is repeatedly called by the CPU until plot depth1
is reached.
gpu_subdivide_2(Nodes*  in,  Points*  out,  int  count)
LQGH[ĸJOREDOBLG(0)
VXUIDFHBSUHVHQW(in[index],  F) ? IDOVH return
true
in[index].depth  <  plot_depth2 ? IDOVH VXEGLYLGH(in[index])
true
out[atom_inc(&count)]ĸILQGBSRLQWBLQBQRGH(in[index])
return
Fig. 7. Algorithm 4. gpu subdivide 2(). We use the out nodes from
gpu subdivide 1() as in nodes to this kernel. Surfaces that pass the interval
test are checked to see if the node depth is less than plot depth2. If
not, then a subdivide block of code is run where the parent node is
repeatedly subdivided. If the child node is not present then the child is
discarded. When these nodes reach a plot depth2 then a GPU version of
f ind point in node() is used to return a point structure that is atomically
added to the output P oints array.
ultimately subdivide the root node to a plot depth plot depth1.
This can generate a theoretical maximum of plot depth18
nodes to be processed, but the actual number generated will
be less than this due to node pruning. We also have to stop
generating nodes before we run out of GPU memory. On our
GPU card with 980 MB of RAM this occurs when around one
million nodes are generated.
The gpu subdivide 1() algorithm performs a task similar to
spawning multiple threads. The CPU iterates until plot depth1
is reached. On each iteration it launches a kernel with an array
of nodes to be checked for possible surface containment using
the interval test. The node that may contain the surface creates
up to 8 child nodes by subdividing the parent node. These are
then atomically added to the output array, out. A child node
will not generate any new instances of a kernel if it does not
contain the surface. The output array becomes the input array
on the next iteration of the kernel by the CPU.
As a result the function gpu subdivide 1() creates a large
number of nodes to be processed, which converge to the
surface based on the interval exclusion test. The use of
rectangular boxes results in a tiling of space that is guaranteed
to bound the surface. We can therefore use each of these nodes
as though it where a root node.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011
We use another GPU function gpu subdivide 2() to process
the nodes found in gpu subdivide 1(). While we have nodes
to process from gpu subdivide 1(), we check if the current
node may have the surface present in it. If so, and if the
depth is less than plot depth2 we call subdivide(). This block
of code (not shown due to space and lack of complexity)
subdivides the input node into child nodes with a depth 1
greater than the parent node. This occurs as long as the
surface may be present in the child node and the child
nodes depth is less than plot depth2. When plot depth2 depth
has been reached we process the node as described in the
f ind point in node() function in Algorithm 2, but on the
GPU. As this is straightforward we don’t elaborated it here.
Most of the figures in this paper were rendered at a final
plot depth between 9 and 11. We limit the value of plot depth2
to be 2 to 3 greater than plot depth1. Limiting the depth
used in gpu subdivide 2() occurs for two reasons. First, it
minimizes the difference in time it takes each thread to
execute gpu subdivide 2(), and thus minimizes stalls between
the parallel tasks. Second, the computationally expensive
process of finding a point in a plot node is performed in
gpu subdivide 2().
When we find a point on the surface and compute the
associated normal we use an atomic variable to assign an
unique index to the array used to store the point and normal
data. In this way each point and normal is added to a shared
data structure in GPU memory. Table III compares the time
taken to render a number of surfaces using the CPU and GPU
algorithms. This shows that the performance increases on the
GPU range from a factor of 8 to 86 times, depending on the
surface.
TABLE III
CPU AND THE GPU ALGORITHM TIMING FOR RENDERING SURFACES AT A
PLOT DEPTH OF 9.
Surface CPU (sec) CUDA (sec) Ratio
Mitre 2.53 0.44 5.7
Steiners 6.43 0.82 14.0
Cyclide 25.9 1.84 14.0
Chmutov 8th 278 5.56 50
Bohemian star 132 2.94 44.8
Boy’s 29.8 1.52 19.6
Chmutov 14th 2233 26.41 84.5
After the point cloud has been computed, the GPU allows
us to alter the viewing geometry at reasonable frame rates
for most of the surfaces. We can therefore rotate them and
zoom into them in real time, which is a significant aid for
their visualization. There is, however a problem. For the initial
viewing geometry, we use the technique in Balsys et al.[5] to
ensure complete pixel coverage by the points when the camera
is outside the viewing cube. If we zoom in close enough, this
will no longer be true, and gaps will appear in the surface.
To remedy this we would need to re-generate the point cloud
for each frame as the camera zooms in, increasing the plot
depth when necessary. This process would be complicated by
the fact that the camera could be inside the viewing cube and
the surface.
We couldn’t do this fast enough for most of the surfaces.
6
From the timings in Table III we could get about 8 fps for
the Mitre surface, but only about 1 fps for the 14th order
Banchoff-Chmutov surface. Increasing the plot depth would
also increase the generation times, but a partial solution would
be to just generate the point cloud at a higher depth at the start.
IV. E XAMPLES
Surfaces that self-intersect, such as the Klein bottle
surface[20] (3) in Figure 8(a), and the Mitre surface[16] (5)
in Figure 8(b) which also has rays and ridges, are rendered
without artefacts.
The spiky surface[2] (6) in Figure 9, has ray like tubes
asymptotic to the four lines x = ±y = ±z. These become
rays in the limits as (x, y, z) → ±∞.
Our algorithm can also render high order algebraic surfaces
such as Chmutov surfaces[11], and Banchoff’s simplified
Chmutov surfaces (BC’s)[6], defined by Tn (x) + Tn (y) +
Tn (z) = 0, where Tn (x) is an nth order Chebyshev poly-
nomial of the first kind. The 9th order Chmutov surface (7),
which has multiple double points, is shown in Figure 10. We
show this surface, rather than the BC’s 8th order surface given
in the Tables as it is has singular points. The 14th order
BC surface (8) is shown in Figure 11(a). Plot depths of 9
were required to render these surfaces without holes. We used
OpenGL occlusion testing to speed up the rendering of the
14th order surface because of its complex internal structure.
We show this structure in Figure 11(b) by clipping it with the
plane f (x, y, z) = x + y + z = 0.
V. R ENDERING C ONTOURS ON S URFACES
In Balsys and Suffern[3] contours of constant apparent
thickness (slabs) were drawn on surfaces to aid their visualiza-
tion. In this paper it was assumed that the slab is approximately
planar in the neighborhood of the point, but in regions of
very high or very low surface curvature this assumption can
break down as it did in Figure 12 when rendering lines of
constant Gaussian curvature on Boy’s surface[1]. This results
in incorrectly rendered contours. We therefore developed two
new GPU based algorithms for rendering curved contours on
surfaces.
The first algorithm works in image space. Along with the
OpenGL surface color buffer we use an additional buffer to
store the (x, y, z) values of the depth buffer pixel on the GPU
as floats. This allows us to look up the (x, y, z) coordinate for
the depth buffer pixel (i, j) in the additional buffer. For visible
surface pixels we compute the contour value, g(x, y, z) = ci,j ,
of the (i, j)th pixel and its neighbors (see Figure 13) using
the positions in the GPU buffer. We compute g(x, y, z) at the
center of every pixel on the visible part of the surface to obtain
a value ci,j for each pixel. The contour value g(x, y, z) = c
to be rendered is passed as an input parameter to the pixel
shader. For the center pixel in Figure 13 we make a series of
comparisons to determine whether the pixel should be shaded
with the contour color. For example, we compute g(x, y, z) at
pixel (i, j) and (i+1, j−1) as gi,j = c1 and gi+1,j−1 = c2 . We
then test if c1 ≤ c ≤ c2 and, if this is true, the contour passes
near the pixel, and we render the (i, j)th pixel with the contour
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 7

(a) (b)
Fig. 11. (a) The T14 Banchoff-Chmutov surface (8); (b) the T14 BC surface (8) cut by the plane x + y + z = 0, and color coded Yellow for outside of
surface and Blue for inside the surface.

(a)

Fig. 9. The Spiky surface (6).

color. The (i, j)th pixel value is set to the contour color if this
condition occurs for any of the immediate neighbor pixels.
The second approach works in object space. The plotting
node is polygonized to find the roots f (x, y, z) = 0 on the
plotting node edges. The polygon will have from 3 to 6
sides (see Balsys et al.[2]). Figure 14 shows the case where
four roots have been found (labelled V1 , V2 , V3 and V4 ). The
values of g(x, y, z) at the vertices are computed and their
minimum (min) and maximum (max) values are found. If
min ≤ g(x, y, z) = c ≤ max the contour passes through the
polygon in the node and the pixel is rendered with the contour
color.
(b) The glP ointSize() function can be used to create lines
Fig. 8. (a) The Klein bottle surface (3) cut by the root node to show internal of different apparent thickness. This can be done for either
structure and using ~
n.~v < 0 to color the surface purple and lemon; (b) The algorithm as they both generate points to be rendered.
Mitre surface (5).
The advantage of the image space algorithm is that it is
implemented on the GPU, is faster than the object space
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011
Fig. 10. The T9 Chmutov surface (7).
Fig. 12. Breakdown of slab algorithm from Balsys and Suffern[3] on Boy’s
surface.
algorithm as it only renders contours for pixels that pass
the depth test, and it can be used for rendering contours
in real time. The disadvantage is that only the parts of the
surface visible from the viewing vector ~v , can be rendered. The
object space algorithm doesn’t have this restriction, but has the
disadvantage that the polygonization becomes progressively
more difficult as non-manifold features are approached. This
can result in aliasing. The method discussed in Harbinson
Fig. 13. Determining whether a pixel has a contour, g(x, y, z) = c, passing
through it in image space.
8
Fig. 14. Determining whether a pixel has Gaussian curvature contour,
g(x, y, z) = c, passing through it in object space.
et al.[18] is used to produce antialiased contours for both
algorithms.
Figure 15 shows the GPU algorithm applied to two surfaces.
Figure 15(a) is an implicit form for the Bohemian Dome
surface[14] (9) rendered with contours parallel to the (x, y, z)
axes. Figure 15(b) shows the super-toroid surface[7] (10) ren-
dered with a series of contours of constant Gaussian curvature.
To plot contours of Gaussian curvature we first render the
surface at a low plot depth to estimate the curvature range for
the plotted points. We can then step from a minimum to a
maximum value using a computed step value.
VI. C URVES OF S ELF I NTERSECTION AND C URVATURE
M APS
Curves of self intersection are easily rendered by Algorithm
1 as the surface is singular along the curve (the gradient is
not uniquely defined). We therefore need only plot points
that are found in the point sampling f ails() section of the
algorithm. Figure 16 shows the curve of self intersection of
Boy’s surface.
Figure 17(a) and (b) shows Boy’s surface[1] (1) rendered
with a Gaussian curvature color map where the map ranges
from negative on the left to positive on the right. The apparent
size change is due to perspective distortion. As the formula
for the Gaussian curvature of Boy’s surface was too complex
to calculate by hand, we used M athematica to generate
all the partial derivatives of the surface up to second order
from the implicit formulae for Gaussian curvature in Balsys
and Suffern[2]. M athematica also generated C code for
the derivatives. Although Algorithm 1 is not essential for
rendering curvature maps, this figure provides a useful context
for Figures 18, 19 and 21.
VII. C URVATURE S URFACES
The Gaussian curvature K(x, y, z) surface of an implicit
surface f (x, y, z) = 0 is a 3D scalar field. A specific
value of this scalar field K(x, y, z) = k, with k ∈ < is
another implicit surface. We call this a curvature surface of
f (x, y, z) = 0. Curvature surfaces make an interesting and
challenging application of our algorithms because they are
more geometrically complex than the corresponding implicit
surfaces in Table V, and there are an infinite number of them
for each implicit surface.
To render shaded images of curvature surfaces we must
compute ∇K, which involves all the third order partial deriva-
tives of f (x, y, z). This is necessary because our attempts
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 9

(a) (b)
Fig. 15. (a) The Bohemian Dome surface (9) with contour slabs perpendicular to the x, y, and z, principal axes with a glP ointSize() of 2. This was
rendered with the object space algorithm. (b) The super-toroid surface (10) with a = b = c = 4, 1 = 3, and 2 = 3, and contours of constant Gaussian
curvature rendered on the surface using the image space algorithm.

-
K 0 K

(a) (b)
Fig. 17. Curvature map for Gaussian curvature of Boy’s surface (1); (a) viewed from “front” camera position; (b) viewed from the “rear” camera position.

(a) (b)
Fig. 18. The curvature surfaces for Boy’s surface (1) showing (a) Kboys = −1; (b) The Kboys = −1 sliced by a plane perpendicular to the line x = y =
z = 1, and translated to show inner detail.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 10

Fig. 16. The curve of self-intersection of boys surface.

Fig. 20. The purple and lemon Klein bottle surface (3) and its cyan and
orange K = 0 curvature surface shown cut against the plane y = 0 to reveal
internal structure.

to estimate the normal from neighboring points produced

rendering artefacts. So, for each curvature surface, we used
M athematica to generate the formulae and C code for all
the partial derivatives up to third order of f (x, y, z).
Figure 18(a) shows the curvature surface of Boy’s surface
for K = −1. Figure 18(b) shows the surface is cut by the plane
x = 0, and translated, to show some of its inner structure.
Figure 19 illustrates the curvature surfaces of two implicit
surfaces rendered using our algorithms. Figure 20 shows the
Klein bottle surface (3) and its K = 0 curvature surface. The
two colors make it appear to have two sides, but the lemon
color results from ~n · ~v < 0.
As a final example, the cyclide surface[10] (13) has three
forms depending on the value of the parameter r relative to the
parameters a and f . In the ring form, r is between a and f , in
(a) the spindle form r is less than a and f , and in the horn form
r is greater than a or f . Figure 21 shows examples of these
three forms with their K = 0 curvature surfaces. As we can
render more than one surface in an image by rendering them
sequentially and not clearing the depth buffer, the surface pairs
are in the same images. These are cut through the (x, z) plane
and translated in the y direction to reveal some of their inner
structure. Each surface is rendered in two colors where the
angle between the normal and the view direction determines
which color is used for each point.

VIII. C OMPARISON WITH R AY C ASTING

(b)
Fig. 19. (a) The K = 0.2 Barth sextic (11) curvature surface; (b) The
K = −10 Bretzel (12) curvature surface.
We implemented and compared the GPU interval ray casting
method in Singh et al.[26] with our GPU approach in terms
of image quality and speed using an Intel Core2 Quad PC
and a NVIDIA 275 graphics card. We set the plot depth for
the interval pruning method and then adjusted the interval
precision term in the ray caster to produce visually similar
results with the same viewing geometry and image resolution.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 11

(a) (b) (c)

Fig. 21. The 3 forms for the cyclide surface[10] (13) and their K = 0 curvature surfaces. (a) ring cyclide with a = 2.95, r = 3 and f = 10; (b) spindle
cyclide with a = 5, r = 0.25 and f = 10; (c) horned cyclide with a = 7.5, r = 10 and f = 2.5. Cyclide surface shown in mauve and lime, Curvature
surface in cyan and gold. Surfaces cut and translated vertically to show internal structure.

TABLE IV
As Table IV shows, our GPU based algorithm is much slower GPU T IMING ( SECONDS ) FOR VARIOUS S URFACES USING THE I NTERVAL
than ray casting for the simpler surfaces, but as the complexity PRUNING VS . RAY CASTING .
of the surface expression increases, the difference in timing
decreases. For the 14th order Chmutov surfaces our method Surface Interval Pruning Depth Raycasting eps
is faster than ray casting. We have not timed the curvature Mitre 0.64 10 0.19 e−9
surfaces as we have had difficulties in implementing the Cyclide 1.20 9 0.76 e−9
Super toroid 1.57 10 0.6 e−10
interval ray cast versions of these. However, the timings for
Barth sextic 3.91 9 1.78 e−12
antialiasing with the method discussed in Harbinson et al.[18] Boys 1.87 10 4.60 e−16
is very low, but we only used a single ray per pixel for the Bohemian Star 101. 10 74. e−16
ray casting. Ray traced images are commonly antialiased with 8th Order Chmutov 76. 9 28.49 e−14
14th Order Chmutov 104. 9 473. e−16
9 or 16 rays per pixel, with the rendering times proportional
to the number of rays used.
Ray casting does not converge as fast when rendering high
order algebraic surfaces and produces worse results, compare IX. C ONCLUSIONS
Figure 22(a) with Figure 22(b). Ray casting does not render We have introduced new simple CPU and GPU based al-
non-manifold features as sharply as our approach. Compare gorithms that reduce point overestimation when using interval
Figure 23(a) and Figure 23(b). methods to drive octree spatial subdivision for implicit surface
Our algorithm is easily adapted for stereo display with left- visualization. The algorithms produce point cloud representa-
right eye images because these only differ in the viewing tions of the surfaces. We illustrated the usefulness and robust-
geometry. The point cloud therefore does not need to be ness of these techniques by efficiently rendering a number of
recomputed. complex implicit surfaces with non-manifold features such as
For interactive visualization, the ray tracer could be mod- rays, cusps, thin sections, ridges, points, and arbitrarily thin
ified to store the hit points as a point cloud, and then tubes. These non-manifold features can be rendered at arbitrary
render them on the GPU, but the points would not be evenly orientations and locations relative to the octree plotting nodes.
distributed on the surfaces. This results from two geometric By pruning excess nodes during the spatial subdivision, the
factors. The first is the divergence of rays in perspective algorithms can produce superior images of rays and thin tubes
viewing, which results in density decreasing with distance without affecting their robustness. This is a major contribution
from the viewpoint. The second is the density dependence on of the work.
the angle between the rays and the surface normal. It is low at The algorithms have a number of advantages over other
silhouettes. This would make the algorithm even more prone surface rendering techniques. They are far simpler than scan-
than our algorithm to rendering artefacts when the camera line techniques because they only require surface interval
zooms in. function evaluations to generate the point clouds, and gradient
Finally, our algorithm is more suited than ray casting for 3D expressions to shade them. Compared with ray casting they
manufacturing, where the point cloud needs to be triangulated. are faster at producing antialiased images, and are better at
The reasons are its uniform distribution of points and the fact rendering non-manifold features.
that we can store neighboring node pointers in the point cloud We can also render curves of self intersection of implicit
data structure. surfaces by using the fact that surfaces are singular where
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 12

(a) (b)
Fig. 22. The T14 Chmutov surface (8), (a) point subdivided to depth 9; (b) interval ray cast with −14

(a) (b)
Fig. 23. The Bohemian star surface (9) (a) point subdivided to depth 9; (b) interval ray cast with −14 .

they self intersect.
We developed new object space and image space algorithms
for rendering contours on surfaces, and used them to render
the intersections of implicit surfaces.
The GPU algorithm can be used for limited real time
manipulation and splitting of the surfaces, provided the camera
does not zoom in too close to them.
X. F UTURE W ORK
We have recently made progress with a dual representation
that uses polygons for the manifold sections of surfaces, and
points for the non-manifold and singular features. This allows
much faster surface generation, but at this stage the work is
preliminary, see Harbinson et at. [19]. We intend to pursue
this further, to enable faster and more flexible interactive
manipulation.
We intend to visualize more complex surfaces. For example,
we can define a double infinite series of curvature surfaces
for each implicit surface f (x, y, z) = 0 with the following
recurrence relation:
K (n+1) (x, y, z) = K[K (n) (x, y, z)] = k,
where n ∈ [0, ∞), k ∈ <, and K (0) (x, y, z) = K(x, y, z).
Here, the geometric and code complexity of the surfaces
increase exponentially with n.
The cut surfaces in Figures 11(b), 18(b), 20 and 21 show
some of their interior structure, but this is a primitive vi-
sualization technique. We need to develop better tools to
help people understand the structure of complex surfaces. A
simple example would be an algorithm that only renders the
interior parts of surfaces with a specified level of nesting. This
would allow us to strip away layers of surfaces that have
inner structure. More generally, the hand drawn images in
Francis[15] are inspirational, and we would like implement
and animate some of his techniques. Examples include cutting
away sections of surfaces and exploding them. A limitation is
that we would always need formulae for the surfaces.
Interactive visualization would be an important aspect of all
these techniques.
ACKNOWLEDGMENT
The authors would like to thank their respective Universities
for their support of this research.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 13

TABLE V
D EFINITIONS OF S URFACES IN PAPER .

# Surface Name Formulae

(1) Boy’s surface 64(1 − z)3 z 3 − 48(1 − z 2 )z 2 (3x2 + 3y 2 + 2z 2 ) + 12(1 − z)z

√
27(x2 + y 2 )2 − 24z 2 (x2 + y 2 ) + 36 2yz(y 2 − 3x2 ) + 4z 2

+(9x2 + 9y 2 − 2z 2 ) −81(x2 + y 2 )2 − 72z 2 (x2 + y 2 )
√ 
+108 2xz(x2 − 3y 2 ) + 4z 2 = 0
(2) Steiners’ Roman x2 y 2 + y 2 z 2 + x2 z 2 − xyz
 =0 
(3) Klein bottle (x2 + y 2 + z 2 + 2y − 1) (x2 + y 2 + z 2 − 2y − 1)2 − 8z 2
+16xz(x2 + y 2 + z 2 − 2y − 1) = 0
(4) Bohemian Star y 4 x4 + 2y 6 x2 + 2y 4 x2 z 2 + y 8 + 2y 6 z 2 + y 4 z 4 − 4y 4 x2 − 4y 4 z 2
−16x2 z 2 y 2 + 16x2 z 2 = 0
(5) Mitre 4x2 (x2 + y 2 + z 2 ) − y 2 (1 − y 2 − z 2 ) = 0
(6) Spiky x8 + y 8 + z 8 − x4 y 4 − x4 z 4 − y 4 z 4 − 1 = 0
(7) 9th order Chmutov 256x9 − 576x7 + 432x5 − 120x3 + 9x + 256y 9 − 576y 7 + 432y 5 − 120y 3 + 9y
−256z 9 − 576z 7 + 432z 5 − 120z 3 + 9z + 3 = 0
(8) 14th order Chmutov 8192x14 − 28672x12 + 39424x10 − 26880x8 + 9408x6 − 1568x4 + 98x2 +
8192y 14 − 28672y 12 + 39424y 10 − 26880y 8 + 9408y 6 − 1568y 4 + 98y 2 +
8192z 14 − 28672z 12 + 39424z 10 − 26880z 8 + 9408z 6 − 1568z 4 + 98z 2
−3 = 0
(9) Bohemian Dome −y 4 − x4 − z 4 + 2x2 z 2 + 4y 2 − 2x2 y 2 − 2y 2 z 2 = 0
  22  2
2 2 1 2
(10) Supertoroid (x
a
) 2 + ( yb ) 2 −√ d
+ ( zc ) 1 = 0
a2 +b2
(11) Barth Sextic 4(t2 x2 − y 2 )(t2 y 2 √
− z 2 )(t2 z 2 − x2 ) − (1 + 2t)(x2 + y 2 + z 2 − 1)2 = 0
where t = (1 + 5)/2
 2
(12) Bretzel x2 (1 − x2 ) − y 2 + z 2 − 0.01 = 0
(13) Cyclide (x2 + y 2 + z 2 )2 − 2(x2 + r2 )(f 2 + a2 ) − 2(y 2 − z 2 )(a2 − f 2 )
+8af rx + (a2 − f 2 )2 = 0

R EFERENCES
[1] F. Apéry, F. The Boy Surface. Adv. Math. 61, pp. 185-266, 1986.
[2] R.J. Balsys, K.G. Suffern, Visualisation of implicit surfaces, Computers
and Graphics, vol. 25, pp. 89–107. 2001.
[3] R.J. Balsys, K.G. Suffern, Ray Tracing Surfaces with Contours. Computer
Graphics Forum, vol. 22, no. 4, pp. 743-752. Dec. 2003.
[4] R.J. Balsys, K.G. Suffern, Point Based Rendering of Non-Manifold Sur-
faces With Contours. ACM/Graphite 2004, 15-19 June 2004, Singapore.
7-14, 2004.
[5] R.J. Balsys, K.G. Suffern, H. Jones, Point Based Rendering of Non-
Manifold Surfaces. Computer Graphics Forum, vol. 27, no. 1, pp. 63–72.
2008.
[6] T. F. Banchoff, Computer Graphics Tools for Rendering Algebraic
Surfaces and for Geometry of Order. Geometric Analysis and Computer
Graphics, Proceedings of a Workshop Held May, 1988 [P. Concus, R.
Finn, D. A. Hoffman (Eds.)]. Springer-Verlag, pp. 31–37, 1991.
[7] A.H. Barr, Superquadratics and Angle-Preserving Transformations. IEEE
CG&A, pp. 1123, Jan. 1981.
[8] J. Bloomenthal, Polygonization of implicit surfaces. Computer Aided
Geometric Design, vol. 5, pp. 341–355. 1988.
[9] J. Bloomenthal, K. Ferguson, Polygonization of Non-Manifold Implicit
Surfaces. Proceedings of SIGGRAPH 95, August 1995, pp. 309-316.
[10] V. Chandru, D., Dutta, C.M., Hoffmann, On the geometry of Dupin
cyclides, The Visual Computer, vol. 5, pp. 277–290. 1989.
[11] S.V. Chmutov, Examples of Projective Surfaces with Many Singularities.
J. Algebraic Geom., vol. 1, pp. 191–196. 1992.
[12] L. H. De Figueiredo, J. Gomes. Sampling implicit objects with
physically-based particle systems. Computers and Graphics, vol. 20, no.
34, pp. 365375. 1996.
[13] L. H. De Figueiredo, J. Stolfi. Adaptive enumeration of implicit surfaces
with affine arithmetic. Computer Graphics Forum, vol. 15, no. 5, pp.
287296. 1996.
[14] Fischer, G. (Ed.). Mathematische Modelle aus den Sammlungen von
Universitaten und Museen Kommentarband. Braunschweig, Germany:
Vieweg, pp. 19–20, 1986.
[15] G.K. Francis, A Topological Picturebook, Springer-Verlag, N.Y., 1987.
[16] C. Jessop, Quartic Surfaces with Singular Points. Cambridge, England:
Cambridge University Press, 1916.
[17] D. Harbinson, R.J. Balsys, K.G. Suffern, Rendering Surface Features
Using Point Based Methods, ACM/Graphite2007, 1-4th Dec 2007, Perth,
Western Australia. pp. 47–53. 2007.
[18] D. Harbinson, R.J. Balsys, K.G. Suffern, Real-time Antialiasing of
Edges and Contours of Point Rendered Implicit Surfaces, International
Conference on Computer Graphics, Imaging and Vision cgiv’08, 26-28th
August, 2008, USM, Penang, Malaysia. pp. 38-46.
[19] D. Harbinson, R.J. Balsys, K.G. Suffern, ’Polygonisation of non-
manifold implicit surfaces using a dual grid and points’, Computer
Graphics, Imaging & Visualisation: CGIV 2010, Sydney, Australia, 7th-
10th August, 2010, pp. 26-31.
[20] F. Klein, Über Riemann’s Theorie der algebraischen Functionen und
ihrer Integrale, Teubner Leipzig, pp. 80.1882.
[21] A. Knoll, Y. Hijazi, A. Kensler, M. Schott, C. Hansen, H. Hagen Fast
Ray Tracing of Arbitrary Implicit Surfaces with Interval and Affine
Arithmetic (p 26-40) Computer Graphics Forum, vol. 28, Issue 1, pp. 26
– 40. 2008.
[22] C. Loop, J. Blinn, Real-Time GPU Rendering of Piecewise Algebraic
Surfaces, Trans. on Graphics, vol. 25, no. 3, pp. 664–670. 2006.
[23] R. E. Moore, R. Baker Kearfott, M. J. Cloud, Introduction to Interval
Analysis. Society for Industrial and Applied Mathematics, 2009.
[24] M.F.W. Schmidt, Cutting cubes - visualizing implicit surfaces by
adaptive polygonization. The Visual Computer, vol. 10, pp. 101–115.
1990.
[25] T.W. Sederberg, A. K. Zundel, Scan Line Display of Algebraic Surfaces.
Computer Graphics, vol. 23, pp. 147–156. 1989.
[26] J. M. Singh, P. J. Narayanan, Real-Time Ray-Tracing of Implicit
Surfaces on the GPU, IEEE Transactions on Visualization and Computer
Graphics, http://doi.ieeecomputersociety.org/10.1109/TVCG.2009.41,
2009.
[27] M. Spivak, A Comprehensive Introduction to Differential Geometry.
Publish or Perish Inc., Berkeley. Volume III, Second Edition, Chapter 3,
1979.
[28] J. Steiner, Gesammelte Werke, two volumes, Prussian Academy of
Sciences, 1881-82, reprinted, Chelsea House, 1971.
[29] N. Stolte, A. Kaufman, Parallel Spatial Enumeration of Implicit
Surfaces using Interval Arithmetic for Octree Generation and its direct
Visualization. In Implicit Surfaces’98, pp. 81–87, Seattle, 1998.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 14

[30] N. Stolte, Graphics using Implicit Surfaces with Interval Arithmetic

based Recursive Voxelization Proceedings Computer Graphics and
Imaging, Honolulu, USA. pp. 200–205. 2003.

Ron Balsys has a B.App.Sc. (Physics), M.App.Sc.

(Physics & Materials) and a PhD (Computer Sci-
ence) (2001). Currently he works in the School of In-
formation and Communication Technology, CQUni-
versity Rockhampton, Australia. His research inter-
ests includes material science, HCI, and computer
graphics. Interests in computer graphics include;
spatial data structures, visualising surfaces, and non-
photorealistic imaging.

Dirk Harbinson is a PhD student at CQUniversity

Australia. He completed his BIT (Honors) with 1st
class in 2006. He is interested in implicit surface
rendering algorithms. He is also interested in GPU
programming and games programming. He has re-
cently submitted his PhD and is now working as
a software engineer for a scheduling company in
Melbourne, Australia.

Kevin Suffern is an Honorary Associate of the Fac-

ulty of Engineering and IT at UTS and an Adjunct
Professor in the Faculty of Design, Architecture and
Building at UTS. He received a PhD in Applied
Mathematics from the University of Sydney in 1979.
His research interests include algorithms for ren-
dering mathematical surfaces. His computer art has
been exhibited at SIGGRAPH 1994 and 2003, and
has won two international awards. He has published
a textbook on ray tracing, and has won four awards
for teaching ray tracing.

View publication stats