Professional Documents
Culture Documents
TVCG 2010 02 0054.R2
TVCG 2010 02 0054.R2
net/publication/51076059
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.
Index Terms—implicit surfaces, non-manifold surfaces, singu- The main techniques for rendering implicit surfaces are
lar surfaces, curvature surfaces, point clouds, octree, intervals, polygonization, scan line algorithms, ray casting, and point
ray, cusp, ridge, intersection curves based techniques. Regular parts of implicit surfaces can be
Abstract—We use octree spatial subdivision to generate point polygonized, but polygons can’t be used to render rays or
clouds on complex non-manifold implicit surfaces in order to
visualize them. The new spatial subdivision scheme only uses
curves of self intersection because these have no surface area.
point sampling and an interval exclusion test. The algorithm Relevant papers on polygonization include Bloomenthal[8],
includes a test for pruning the resulting plotting nodes so that Schmidt [24], and Bloomenthal et al.[9]. Thin sections, even
only points in the closest nodes to the surface are used in if they are regular parts of surfaces, can also be difficult to
rendering. This algorithm results in improved image quality polygonize, as discussed in Balsys and Suffern[2].
compared to the naive use of intervals or affine arithmetic
when rendering implicit surfaces, particularly in regions of high Sederberg and Zundel [25] presented a scan line algorithm
curvature. We discuss and compare CPU and GPU versions of that can render non-manifold implicit surfaces, and success-
the algorithm. fully rendered the rays for Steiner’s Roman surface [28]. The
We can now render non-manifold features such as rays, ray- algorithm is, however mathematically complex, and only able
like tubes, cusps, ridges, thin sections that are at arbitrary angles to render algebraic surfaces.
to the octree node edges, and singular points located within plot
nodes, all without artefacts. Our previous algorithm could not Until recently, high order algebraic surfaces and non-
render these without severe aliasing. polynomial implicit surfaces have been difficult to ray trace
The algorithm can render the self-intersection curves of because of the need to solve the ray surface intersection
implicit surfaces by exploiting the fact that surfaces are singular equation. But Loop et al.[22], Knoll et al.[21] and Singh et
where they self-intersect. It can also render the intersection al.[26] have used interval ray casting to render such surfaces
curves of two implicit surfaces. We present new image space and
object space algorithms for rendering these intersection curves where the ray-surface equation solution is replaced by interval
as contours on one of the surfaces. These algorithms are better at analysis along the ray to bound the intersections.
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 A. Contribution of this work
order polynomial surfaces and Gaussian curvature surfaces. We
also compare the algorithm with ray casting in terms of speed
The major contribution in this work is a new point based
and image quality algorithm that computes a point cloud for implicit surfaces,
For the surfaces presented here, the point clouds can be and can render high order algebraic and complex non algebraic
computed in seconds to minutes on a typical Intel based PC. surfaces. The algorithm uses point sampling and the interval
Once this is done, the surfaces can be rendered at much higher extension of the implicit function as the octree subdivision
frame rates to allow some degree of interactive visualization.
criteria. It uses a pruning algorithm, based on a signed distance
function, to reduce the number of plotting nodes around non-
I. I NTRODUCTION manifold features. This results in more accurate rendering of
N implicit surface is a level (iso-valued) surface these features compared with our previous algorithms, for
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
example Harbinson et al.[17]. We have implemented CPU
and GPU versions of the algorithm. The node subdivision and
singular. Non-manifold surfaces have regions where they are pruning scheme is discussed in Section II in the context of the
locally non Euclidean; singular surfaces include those that self CPU version.
intersect. Implicit surfaces are widely used in mathematics, Using this approach, we can render thin sections of sur-
science and engineering. Software that renders non-manifold faces, cusps, ridges, tubes, singular points and curves of self
surfaces must be able to accurately render features such as intersection at arbitrary orientations to the octree node edges.
rays, cusps, singular points and arbitrarily thin sections. We can therefore render thin rays at arbitrary angles, and
curved rays as in Figure 4. This was not possible using the
Manuscript received February 26th, 2010; revised March 15th, 2011. algorithm in Harbinson et al.[17] where rays and curves of
D. Harbinson and R.J. Balsys are with the Centre for Intelligent and
Networked Systems, Central Queensland University, Rockhampton, Qld., self-intersection had to be along node edges to be rendered
4702. Australia. without severe aliasing. This was a major limitation. Table V
K.G. Suffern is with the Faculty of Engineering and Information Tech- lists the implicit equations for the surfaces we have used in this
nology and the Faculty of Design, Architecture & Building, University of
Technology, Sydney. P.O. Box 123, Broadway, NSW, 2007. Australia. work. We discuss the implementation of the GPU algorithm in
Author for contact: balsys@cqu.edu.au Section III and also discuss its advantages and disadvantages.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 2
(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
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 5
return
approach presented in Harbinson et al.[18] to antialias the
resulting images, as it produces better results than the standard Fig. 7. Algorithm 4. gpu subdivide 2(). We use the out nodes from
OpenGL antialiasing algorithm. 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
III. GPU IMPLEMENTATION 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
Ultimately, we are only interested in obtaining a set of f ind point in node() is used to return a point structure that is atomically
points on the surface and their associated normals. If we added to the output P oints array.
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 ultimately subdivide the root node to a plot depth plot depth1.
more quickly down some pathways than others. Ideally, we This can generate a theoretical maximum of plot depth18
need an algorithm that will terminate all kernels at approxi- nodes to be processed, but the actual number generated will
mately the same time. The worst case scenario is when the be less than this due to node pruning. We also have to stop
entire subdivision takes place by the subdivision of a single generating nodes before we run out of GPU memory. On our
node as this would use a single kernel. GPU card with 980 MB of RAM this occurs when around one
Typical GPU’s are organized as a set of multi- million nodes are generated.
processors which each have execution units. For instance our The gpu subdivide 1() algorithm performs a task similar to
N vidia
R
275 has 30 multi-processors with 8 execution units. spawning multiple threads. The CPU iterates until plot depth1
Each execution unit can run 1 kernel at a time, so this card is reached. On each iteration it launches a kernel with an array
can run 240 simultaneous kernels. To obtain good performance of nodes to be checked for possible surface containment using
from the GPU we need to try and keep all execution units the interval test. The node that may contain the surface creates
running. This implies that we balance the load across them. up to 8 child nodes by subdividing the parent node. These are
The main problem is how to proceed with the node subdi- then atomically added to the output array, out. A child node
vision process so that each kernel processes the same code, will not generate any new instances of a kernel if it does not
and how to collect the resulting points list. Typically, to use contain the surface. The output array becomes the input array
the GPU, you define an index value specifying how many on the next iteration of the kernel by the CPU.
instances of a kernel you need. This also requires you to As a result the function gpu subdivide 1() creates a large
specify a dimension for the index space. For this application number of nodes to be processed, which converge to the
we used a 1 dimensional index space as each instance of a surface based on the interval exclusion test. The use of
kernel handles a single node. rectangular boxes results in a tiling of space that is guaranteed
We arrived at a two step solution shown in Figure 6 as to bound the surface. We can therefore use each of these nodes
Algorithm 3 and in Figure 7 as Algorithm 4. In Algorithm 3 we as though it where a root node.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 6
We use another GPU function gpu subdivide 2() to process From the timings in Table III we could get about 8 fps for
the nodes found in gpu subdivide 1(). While we have nodes the Mitre surface, but only about 1 fps for the 14th order
to process from gpu subdivide 1(), we check if the current Banchoff-Chmutov surface. Increasing the plot depth would
node may have the surface present in it. If so, and if the also increase the generation times, but a partial solution would
depth is less than plot depth2 we call subdivide(). This block be to just generate the point cloud at a higher depth at the start.
of code (not shown due to space and lack of complexity)
subdivides the input node into child nodes with a depth 1 IV. E XAMPLES
greater than the parent node. This occurs as long as the
Surfaces that self-intersect, such as the Klein bottle
surface may be present in the child node and the child
surface[20] (3) in Figure 8(a), and the Mitre surface[16] (5)
nodes depth is less than plot depth2. When plot depth2 depth
in Figure 8(b) which also has rays and ridges, are rendered
has been reached we process the node as described in the
without artefacts.
f ind point in node() function in Algorithm 2, but on the
The spiky surface[2] (6) in Figure 9, has ray like tubes
GPU. As this is straightforward we don’t elaborated it here.
asymptotic to the four lines x = ±y = ±z. These become
Most of the figures in this paper were rendered at a final
rays in the limits as (x, y, z) → ±∞.
plot depth between 9 and 11. We limit the value of plot depth2
Our algorithm can also render high order algebraic surfaces
to be 2 to 3 greater than plot depth1. Limiting the depth
such as Chmutov surfaces[11], and Banchoff’s simplified
used in gpu subdivide 2() occurs for two reasons. First, it
Chmutov surfaces (BC’s)[6], defined by Tn (x) + Tn (y) +
minimizes the difference in time it takes each thread to
Tn (z) = 0, where Tn (x) is an nth order Chebyshev poly-
execute gpu subdivide 2(), and thus minimizes stalls between
nomial of the first kind. The 9th order Chmutov surface (7),
the parallel tasks. Second, the computationally expensive
which has multiple double points, is shown in Figure 10. We
process of finding a point in a plot node is performed in
show this surface, rather than the BC’s 8th order surface given
gpu subdivide 2().
in the Tables as it is has singular points. The 14th order
When we find a point on the surface and compute the
BC surface (8) is shown in Figure 11(a). Plot depths of 9
associated normal we use an atomic variable to assign an
were required to render these surfaces without holes. We used
unique index to the array used to store the point and normal
OpenGL occlusion testing to speed up the rendering of the
data. In this way each point and normal is added to a shared
14th order surface because of its complex internal structure.
data structure in GPU memory. Table III compares the time
We show this structure in Figure 11(b) by clipping it with the
taken to render a number of surfaces using the CPU and GPU
plane f (x, y, z) = x + y + z = 0.
algorithms. This shows that the performance increases on the
GPU range from a factor of 8 to 86 times, depending on the
surface. V. R ENDERING C ONTOURS ON S URFACES
In Balsys and Suffern[3] contours of constant apparent
TABLE III
CPU AND THE GPU ALGORITHM TIMING FOR RENDERING SURFACES AT A thickness (slabs) were drawn on surfaces to aid their visualiza-
PLOT DEPTH OF 9. tion. In this paper it was assumed that the slab is approximately
planar in the neighborhood of the point, but in regions of
Surface CPU (sec) CUDA (sec) Ratio very high or very low surface curvature this assumption can
Mitre 2.53 0.44 5.7 break down as it did in Figure 12 when rendering lines of
Steiners 6.43 0.82 14.0 constant Gaussian curvature on Boy’s surface[1]. This results
Cyclide 25.9 1.84 14.0
Chmutov 8th 278 5.56 50
in incorrectly rendered contours. We therefore developed two
Bohemian star 132 2.94 44.8 new GPU based algorithms for rendering curved contours on
Boy’s 29.8 1.52 19.6 surfaces.
Chmutov 14th 2233 26.41 84.5 The first algorithm works in image space. Along with the
OpenGL surface color buffer we use an additional buffer to
After the point cloud has been computed, the GPU allows store the (x, y, z) values of the depth buffer pixel on the GPU
us to alter the viewing geometry at reasonable frame rates as floats. This allows us to look up the (x, y, z) coordinate for
for most of the surfaces. We can therefore rotate them and the depth buffer pixel (i, j) in the additional buffer. For visible
zoom into them in real time, which is a significant aid for surface pixels we compute the contour value, g(x, y, z) = ci,j ,
their visualization. There is, however a problem. For the initial of the (i, j)th pixel and its neighbors (see Figure 13) using
viewing geometry, we use the technique in Balsys et al.[5] to the positions in the GPU buffer. We compute g(x, y, z) at the
ensure complete pixel coverage by the points when the camera center of every pixel on the visible part of the surface to obtain
is outside the viewing cube. If we zoom in close enough, this a value ci,j for each pixel. The contour value g(x, y, z) = c
will no longer be true, and gaps will appear in the surface. to be rendered is passed as an input parameter to the pixel
To remedy this we would need to re-generate the point cloud shader. For the center pixel in Figure 13 we make a series of
for each frame as the camera zooms in, increasing the plot comparisons to determine whether the pixel should be shaded
depth when necessary. This process would be complicated by with the contour color. For example, we compute g(x, y, z) at
the fact that the camera could be inside the viewing cube and pixel (i, j) and (i+1, j−1) as gi,j = c1 and gi+1,j−1 = c2 . We
the surface. then test if c1 ≤ c ≤ c2 and, if this is true, the contour passes
We couldn’t do this fast enough for most of the surfaces. 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)
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 8
(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
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. where n ∈ [0, ∞), k ∈ <, and K (0) (x, y, z) = K(x, y, z).
We developed new object space and image space algorithms Here, the geometric and code complexity of the surfaces
for rendering contours on surfaces, and used them to render increase exponentially with n.
the intersections of implicit surfaces. The cut surfaces in Figures 11(b), 18(b), 20 and 21 show
The GPU algorithm can be used for limited real time some of their interior structure, but this is a primitive vi-
manipulation and splitting of the surfaces, provided the camera sualization technique. We need to develop better tools to
does not zoom in too close to them. help people understand the structure of complex surfaces. A
simple example would be an algorithm that only renders the
X. F UTURE W ORK interior parts of surfaces with a specified level of nesting. This
We have recently made progress with a dual representation would allow us to strip away layers of surfaces that have
that uses polygons for the manifold sections of surfaces, and inner structure. More generally, the hand drawn images in
points for the non-manifold and singular features. This allows Francis[15] are inspirational, and we would like implement
much faster surface generation, but at this stage the work is and animate some of his techniques. Examples include cutting
preliminary, see Harbinson et at. [19]. We intend to pursue away sections of surfaces and exploding them. A limitation is
this further, to enable faster and more flexible interactive that we would always need formulae for the surfaces.
manipulation. Interactive visualization would be an important aspect of all
We intend to visualize more complex surfaces. For example, these techniques.
we can define a double infinite series of curvature surfaces
for each implicit surface f (x, y, z) = 0 with the following ACKNOWLEDGMENT
recurrence relation:
The authors would like to thank their respective Universities
K (n+1) (x, y, z) = K[K (n) (x, y, z)] = k, 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 .
R EFERENCES [17] D. Harbinson, R.J. Balsys, K.G. Suffern, Rendering Surface Features
Using Point Based Methods, ACM/Graphite2007, 1-4th Dec 2007, Perth,
[1] F. Apéry, F. The Boy Surface. Adv. Math. 61, pp. 185-266, 1986. Western Australia. pp. 47–53. 2007.
[2] R.J. Balsys, K.G. Suffern, Visualisation of implicit surfaces, Computers [18] D. Harbinson, R.J. Balsys, K.G. Suffern, Real-time Antialiasing of
and Graphics, vol. 25, pp. 89–107. 2001. Edges and Contours of Point Rendered Implicit Surfaces, International
[3] R.J. Balsys, K.G. Suffern, Ray Tracing Surfaces with Contours. Computer Conference on Computer Graphics, Imaging and Vision cgiv’08, 26-28th
Graphics Forum, vol. 22, no. 4, pp. 743-752. Dec. 2003. August, 2008, USM, Penang, Malaysia. pp. 38-46.
[4] R.J. Balsys, K.G. Suffern, Point Based Rendering of Non-Manifold Sur- [19] D. Harbinson, R.J. Balsys, K.G. Suffern, ’Polygonisation of non-
faces With Contours. ACM/Graphite 2004, 15-19 June 2004, Singapore. manifold implicit surfaces using a dual grid and points’, Computer
7-14, 2004. Graphics, Imaging & Visualisation: CGIV 2010, Sydney, Australia, 7th-
[5] R.J. Balsys, K.G. Suffern, H. Jones, Point Based Rendering of Non- 10th August, 2010, pp. 26-31.
Manifold Surfaces. Computer Graphics Forum, vol. 27, no. 1, pp. 63–72. [20] F. Klein, Über Riemann’s Theorie der algebraischen Functionen und
2008. ihrer Integrale, Teubner Leipzig, pp. 80.1882.
[6] T. F. Banchoff, Computer Graphics Tools for Rendering Algebraic
[21] A. Knoll, Y. Hijazi, A. Kensler, M. Schott, C. Hansen, H. Hagen Fast
Surfaces and for Geometry of Order. Geometric Analysis and Computer
Ray Tracing of Arbitrary Implicit Surfaces with Interval and Affine
Graphics, Proceedings of a Workshop Held May, 1988 [P. Concus, R.
Arithmetic (p 26-40) Computer Graphics Forum, vol. 28, Issue 1, pp. 26
Finn, D. A. Hoffman (Eds.)]. Springer-Verlag, pp. 31–37, 1991.
– 40. 2008.
[7] A.H. Barr, Superquadratics and Angle-Preserving Transformations. IEEE
[22] C. Loop, J. Blinn, Real-Time GPU Rendering of Piecewise Algebraic
CG&A, pp. 1123, Jan. 1981.
Surfaces, Trans. on Graphics, vol. 25, no. 3, pp. 664–670. 2006.
[8] J. Bloomenthal, Polygonization of implicit surfaces. Computer Aided
Geometric Design, vol. 5, pp. 341–355. 1988. [23] R. E. Moore, R. Baker Kearfott, M. J. Cloud, Introduction to Interval
[9] J. Bloomenthal, K. Ferguson, Polygonization of Non-Manifold Implicit Analysis. Society for Industrial and Applied Mathematics, 2009.
Surfaces. Proceedings of SIGGRAPH 95, August 1995, pp. 309-316. [24] M.F.W. Schmidt, Cutting cubes - visualizing implicit surfaces by
[10] V. Chandru, D., Dutta, C.M., Hoffmann, On the geometry of Dupin adaptive polygonization. The Visual Computer, vol. 10, pp. 101–115.
cyclides, The Visual Computer, vol. 5, pp. 277–290. 1989. 1990.
[11] S.V. Chmutov, Examples of Projective Surfaces with Many Singularities. [25] T.W. Sederberg, A. K. Zundel, Scan Line Display of Algebraic Surfaces.
J. Algebraic Geom., vol. 1, pp. 191–196. 1992. Computer Graphics, vol. 23, pp. 147–156. 1989.
[12] L. H. De Figueiredo, J. Gomes. Sampling implicit objects with [26] J. M. Singh, P. J. Narayanan, Real-Time Ray-Tracing of Implicit
physically-based particle systems. Computers and Graphics, vol. 20, no. Surfaces on the GPU, IEEE Transactions on Visualization and Computer
34, pp. 365375. 1996. Graphics, http://doi.ieeecomputersociety.org/10.1109/TVCG.2009.41,
[13] L. H. De Figueiredo, J. Stolfi. Adaptive enumeration of implicit surfaces 2009.
with affine arithmetic. Computer Graphics Forum, vol. 15, no. 5, pp. [27] M. Spivak, A Comprehensive Introduction to Differential Geometry.
287296. 1996. Publish or Perish Inc., Berkeley. Volume III, Second Edition, Chapter 3,
[14] Fischer, G. (Ed.). Mathematische Modelle aus den Sammlungen von 1979.
Universitaten und Museen Kommentarband. Braunschweig, Germany: [28] J. Steiner, Gesammelte Werke, two volumes, Prussian Academy of
Vieweg, pp. 19–20, 1986. Sciences, 1881-82, reprinted, Chelsea House, 1971.
[15] G.K. Francis, A Topological Picturebook, Springer-Verlag, N.Y., 1987. [29] N. Stolte, A. Kaufman, Parallel Spatial Enumeration of Implicit
[16] C. Jessop, Quartic Surfaces with Singular Points. Cambridge, England: Surfaces using Interval Arithmetic for Octree Generation and its direct
Cambridge University Press, 1916. Visualization. In Implicit Surfaces’98, pp. 81–87, Seattle, 1998.
IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. X, NO. XX, MAR 2011 14