Scalar-Function-Driven Editing onPoint Set Surfaces

Published by the IEEE Computer Society 0272-1716/04/$20.00 © 2004 IEEE IEEE Computer Graphics and Applications 43

Point-Based Computer Graphics

Three-dimensional acquisition is anincreasingly popular means of creating

surface models. As 3D digital photographic and scan-ning devices produce higher resolution images,acquired geometric data sets grow more complex interms of the modeled objects’ size, geometry, and topol-ogy. Point-based geometry is a form of 3D content acqui-sition popular in graphics and related visual computingareas. Points have unique advantages over traditionalprimitives such as triangle meshes. For example, theyare free of connectivity concerns, especially in large-scale scanned models.

Point set surfaces are enjoying a renaissance in mod-eling and rendering, with many efforts focused on directrendering techniques1–3 and effective modeling mecha-nisms.4,5 Despite these research achievements, the spec-trum of surface editing and deformation types is stillquite limited. For example, no current research investi-gates the physics-based dynamic simulation of virtualmaterials represented by point sets (that is, allowing thepoint sets to respond dynamically to users’ applied forcein an intuitive and natural fashion). Handling collisiondetection and topology changes using point informationalone is another challenging problem.

We’ve developed a scalar-field-driven editing para-digm and system for point set surfaces that let usersmanipulate and sculpt point clouds intuitively and effi-ciently. The paradigm is primarily based on the repre-sentation of versatile, embedded scalar fields associatedwith any region of the point set surface. Scalar-field-dri-ven implicit representation, such as volumetric implicitmodels6 and level sets, is a powerful paradigm that notonly handles arbitrary topology and complicated geom-etry, but also affords physics-based modeling techniques.

After constructing the surface distance field fromthe point clouds,7 we incorporate the dynamic implic-it volumetric model6 into the point-based geometrydeformation. Level-set editing lets us incorporatescalar-field guided free-form deformations (FFD)8 intoour surface deformation system to further expandlocal and global surface editing functionality. Usingdigital topology information, we can easily handle col-lision detection and the point set surface’s changing

topology. We’ve also integrated a haptics interface intoour surface-modeling framework. Experiments showthat the proposed paradigm complements currentpoint set surface modeling techniques with a morepowerful editing scheme.

System overview Figure 1 shows the data flow and architecture of our

scalar-function-driven point set surface-editing system.The system takes any region of the original point set sur-face as input, using physics-based dynamic volumetricdeformation and level-set-based editing techniques todeform the point set locally or globally and change itstopology when needed. It then usespoint-based surface-rendering tech-niques to render the modifiedsurface.

We can use several existing tech-niques to convert user-specifiedregions of the original point set sur-faces into an implicit surface repre-sentation. (Even after this process,we need to keep the original point-sampled geometry for downstreamprocedures such as local editing,global free-form deformation, topo-logical change, and rendering.)Dual representations facilitate the entire data-process-ing pipeline, as Figure 1 shows.

After constructing the implicit surface, we integratethe physics-based dynamic volumetric deformationmethod and level-set surface-editing techniques intoour system to provide editing operations such as force-based sculpting, free-form deformation, sketch-basedediting, and embossing or engraving. While incorpo-rating the level-set operators, we integrate scalar-fieldfree-form deformation (SFFD) techniques8 into thelevel-set framework to facilitate both local and globalsurface editing. After the system deforms the underly-ing implicit surface at each iteration step, we update thepoint set surface accordingly. In addition to geometricdeformation, we consider collision detection and topol-ogy change, as we discuss later.

A modeling paradigm and

system for local and global

editing on point set

surfaces lets users easily

modify the topology of

sculpted point sets.

Xiaohu Guo, Jing Hua, and Hong QinState University of New York at Stony Brook

Dynamic point set surfaceOur scalar-field-driven dynamic point set surface col-

lectively takes advantage of the topological strength ofimplicit surfaces, the modeling power of physics-basedsimulation techniques, and the simplicity of point-sam-pled surfaces.

Surface distance fieldThe input data consists of an unstructured point cloud

P = {pi|1 ≤ i ≤ N} that uniquely characterizes the geom-etry of an underlying manifold surface S.

In previous work,9 we fit a volumetric implicit func-tion to the local distance field in the neighborhood ofthe point sample pi, as Figure 2a shows. We used scalartrivariate B-spline functions as the underlying shapeprimitives. Implicit B-spline functions have severalattractive qualities: simplicity, generality, local support,

ease of evaluation, and so on. These trivariate functionstake the following form:

where Bi,r(u), Cj,s(v), and Dk,t(w) are the uniform B-splinebasis functions of degrees r − 1, s − 1, and t − 1. Pijk is thescalar coefficient in a volumetric mesh of size l × m × n,and s(u, v, w) is a scalar function at position (u, v, w) inthe parametric domain. In this case, the scalar functiondefines the distance of position (u, v, w) to the surface.The local reference parameter domain can enclose thek-nearest neighbors of pi. Blending the local implicitprimitive associated with each point sample using Shep-ard’s7,10 blending techniques produces the global con-tinuous distance field shown in Figure 2b:

If (x, y, z) is inside the local region of point sample pi,we use the trivariate implicit function associated with pi

for a distance value of si(x, y, z); if it is outside this region,we simply set the value to zero. Also, φi(x, y, z) is a smooth,positive, and monotonically decreasing weighting func-tion associated with pi. More detailed information on oursurface distance field construction is available elsewhere.9

Other researchers have also used locally fitted implic-it function methods.7,10 Ohtake et al. blended piecewisequadratic functions using an adaptive octree subdivi-sion method, an efficient approach to constructing animplicit surface from large point sets.7 Xie at al. appliedShepard’s method to blend locally fitted quadric fields,using a prioritized front growing scheme to handle high-ly noisy point clouds.10

Physics-based dynamic local editingOur approach uses dynamic volumetric models6 to

allow intuitive sculpting of the point-based distancefield. We resample the surface scalar field in a globalregion of interest, and then discretize the global scalarfield into a voxel raster. Every voxel contains a scalarvalue sampled at each grid position. While sculpting ordeforming the scalar field, we simulate the dynamics inthis global region. In each simulation step, if we changethe global scalar field on the global grids, we mustupdate each point sample’s positions and performdynamic sampling on the point set surface. We modelthe discretized scalar field as a collection of mass pointsconnected by a network of special springs across near-est-neighbor voxels. We use the straightforward densi-ty spring model (a special type of spring that attracts orrepels its neighbors’ density values) to simulate themodel’s dynamics.6 Figure 3 shows how we can applythe force tool to intuitively deform the global scalar field.

We formulate the discretized scalar field’s motion equa-tion as a discrete simulation of Lagrangian dynamics:

s x y zs x y z x y z

x y z

i ii

N

ii

, ,, , , ,

, ,( ) =

( ) ( )( )

=

=

∑ φ

φ

1

11

N∑

s u v w P B u C v D wi jk i r j s k t

k

n

j

, ,, , ,( ) = ( ) ( ) ( )

=

−

=∑

0

1

00

1

0

1 m

i

l −

=

−

∑∑

Point-Based Computer Graphics

44 July/August 2004

Physics-based editing

Level-set-based editing

Force tool

Free-formdeformation

Original pointset surfaces

Implicitsurface

construction

Sketch-basedediting

Embossing/engraving

Smoothing

Point-basedrendering

Modifiedpoint

set surface

1 System editing framework and data pipeline.

(a) (b)

2 Distancefields: (a) Localdistance field ineach pointsample’s neigh-borhood and(b) global dis-tance field.

Force Force3 We use theforce tool tointuitivelydeform theglobal scalarfield. The yellowcurves are thezero-level setsof isosurfaces.

where M is the mass matrix, D is the damping matrix, Kis the stiffness matrix, and fd is the external force vec-tor. We use d to denote the scalar grid value. The con-necting springs—each with force f = k (I − I0), accordingto Hooke’s law, which states that a spring’s restoringforce is proportional to how far it is stretched—generatethe internal forces. Unlike other pure geometric surface-sculpting methods (see the “Background on Point SetGeometry” sidebar), our method synchronizes the geo-metric and physical representations of modeled objectsand lets users deform the surface quickly and easily in aphysically plausible fashion. More details on dynamicvolumetric models, such as applied-force computationand numerical integration, are available elsewhere.6

In our haptic implementation, users can perform thedeformation just inside any sculpting region of theobject. The region is independent of the surface defini-tion and can be much smaller than the entire surface.Limiting the deformation to the inside of the surfaceregion of interest can thus help the system achieve real-time performance.

Level-set formulation for point geometryDeformable isosurfaces implemented through level-

set methods have great potential in fields such as visu-alization, scientific computing, and computer graphics.An implicit surface consists of all points S = {x(t)|φ(x,t) = k}, where φ(x, t) is a time-varying scalar functionembedded in 3D. Level-set methods relate the implicitsurface’s motion to a partial differential equationdefined on the associated volume by

(1)

where ∇φ denotes the implicit surface’s gradient anddx/dt describes the level-set surface’s motion. We canrewrite Equation 1 as

where F(x, φ, ∇φ, …) == − ∇φ/|∇φ| × dx/dt is the speedfunction.

Using the level-set method, we can implement a widerange of deformations by defining an appropriate speedfunction using a combination of data-dependent termsand geometric measures (curvature, for example) of theimplicit level-set surface11: F = FA + FG. FA is the advec-tion, which expands or contracts the front with speedFA depending on its sign (the advection independent ofthe moving front’s geometry). FG depends on the front’sgeometry, such as its local curvature, and can be usedto smooth high curvature regions in the front. We notonly use this representation to perform the level-set-based editing operations on the point set surfaces, butalso integrate SFFD8 into our level-set framework.

Because we’re only interested in surface editing thepoint set that relies on the isosurfaces’ zero level-set, weneed only compute the parts of the solution that areadjacent to the moving surface. In addition, we direct-ly apply our operations to the point set, so the level-setembedding occurs wherever the deformation is need-ed. Users interactively control the level-set space andthe deformation operators within the space.

We use Whitaker’s sparse-field method12 to updatethe wavefront and several layers around it via a sim-ple city block distance metric at each iteration. We callthe set of grid points adjacent to the level set the activeset, denoting it by L0, and defining its neighborhoodsin layers, L+1, …, L+l, …, L+N and L−1, …, L−l, …, L−N,where l indicates the city block distance from the near-est active grid point (negative numbers represent out-side layers). In this article, we use up to thesecond-order derivatives of φ, so we need only five lay-

∂∂

= ∇ ∇( )φ φ φ φt

F x, , ,...

∂∂

= −∇ ⋅φ φt

ddtx

Md Dd Kd f&& & + + =d

IEEE Computer Graphics and Applications 45

Background on Point Set Geometry In recent years, considerable research has sought to efficiently

represent, model, process, and render point-sampled geometry. Rusinkiewicz and Levoy1 introduced QSplat, a technique that

uses a hierarchy of spheres of different radii to approximate anddisplay a high-resolution model with level-of-detail control.Zwicker et al.2 introduced surface splatting for directly renderingopaque and transparent surfaces from point clouds withoutconnectivity. In later work, they present Pointshop 3D,3 a systemfor interactive shape and appearance editing of 3D point-sampledgeometry. The system’s key ingredients are a point cloudparameterization and a dynamic resampling scheme based oncontinuous reconstruction of the surface. Their geometry editing islimited to normal displacement, however.

Alexa et al.4 use the moving least squares (MLS) projectionframework to approximate a smooth surface defined by a set ofpoints, and they introduce associated resampling techniques togenerate an adequate representation of the surface.

Pauly et al.5 present a free-form shape-modeling framework forpoint-sampled geometry using the implicit surface definition of theMLS approximation, but their approach is limited to free-formdeformation and doesn’t offer physics-based surface-modelingtechniques. Most recently, Guo and Qin6 present a physics-baseddynamic local sculpting paradigm for point-sampled surfaces usingvolumetric implicit functions.

References1. S. Rusinkiewicz and M. Levoy, “QSplat: A Multiresolution Point Rendering

System for Large Meshes,” Proc. Siggraph, ACM Press, 2000, pp. 343-352.2. M. Zwicker et al., “Surface Splatting,” Proc. Siggraph, ACM Press, 2001, pp.

371-378.3. M. Zwicker et al., “Pointshop 3D: An Interactive System for Point-Based Sur-

face Editing,” Proc. Siggraph, ACM Press, 2002, pp. 322-329.4. M. Alexa et al., “Computing and Rendering Point Set Surfaces,” IEEE Trans.

Visualization and Computer Graphics, vol. 9, no. 1, Jan.-Mar. 2003, pp. 3-15.5. M. Pauly et al., “Shape Modeling with Point-Sampled Geometry,” Proc. Sig-

graph, ACM Press, 2003, pp. 641-650.6. X. Guo and H. Qin, “Dynamic Sculpting and Deformation of Point Set Sur-

faces,” Proc. Pacific Graphics, IEEE CS Press, 2003, pp. 123-130.

ers: L2, L1, L0, L−1, and L−2. The sparse field methodupdates the level-set geometry by computing andmanipulating the layers’ data structure at each itera-tion. Computational time complexity grows propor-tionally to the surface region area undergoing thedeformation. As described earlier, local level-setembedding and point-set geometry simplicity makedeformation extremely fast. (Conventional level-setmethods often build a global grid structure for theentire volumetric space where the surface resides.)

Scalar-field free-form deformationFree-form deformation is used extensively in shape

modeling and animation because it doesn’t requireknowledge about the embedded object’s underlying geo-metric representation and topological structure. We couldperform free-form deformation directly on the point setsurface fairly easily. However, we’d then have to rely onthe moving least squares surface projection for the exactpositions of the newly inserted points. Point insertion isunavoidable in large deformations and expands themodel significantly. Consequently, gaps occur at the cur-rent resolution. To address this problem, we perform free-form deformation directly on the global scalar field,which we can then use to guide both point movement andpoint insertion in a single, unified fashion.

Our approach uses SFFD.8 Because SFFD is found-ed on flow constraints based on a partial differentialequation, we can easily use the velocity field obtainedby SFFD to update our point surface’s global scalarfield. Furthermore, introducing intermediate stepsduring deformation lets us perform dynamic sam-pling on the point set surface to maintain a good sur-face quality throughout the model-sculpting session.Our representation consists of two classes of scalarfields:

� ss, or surface representation, is the global scalar fieldwe acquire from point clouds using the multilevel par-tition of unity (MPU) implicit surface constructionmethod6; and

� st is the scalar field of the deformation tool,8 such asa sketched point or curve skeleton.

We use the tool scalar field st to perform deformationson the point surface scalar field ss. In our global free-form deformation, discretized voxel grids store both ss

and st, which we update using the sparse-field methodat each iteration step.

During deformation of the tool scalar field st, weassume that the vertices on the discretized voxel gridsare constrained on their original level set. We thereforerepresent the trajectory of these grid vertices as{x(t)|st(x(t), t) = c}. The derivative of st(x(t), t) withrespect to time yields

where ∇xst is the gradient of st at x. To get the generalvelocity along the three coordinate axes of the 3D space

(vx, vy, vz), taking into account the deformation motion’ssmoothness, we add a smoothness constraint on theunderlying level-set surface ss by minimizing the objec-tive function:

(2)

where λ is a Lagrange multiplier. To discretize the objec-tive function in Equation 2, we consider a voxel grid ver-tex i, where i ∈ L−2 � L−1 � L0 � L1 � L2 (the sparse-fieldlayers), and its adjacent neighboring voxel grids Ni,where

and C6 is the set of six connected voxel grid pairs. Thislets us transform the objective function (Equation 2)into

where c(i) is the flow constraint approximation error:

and s(i) is the discretized smoothness factor computedas the velocity difference between the voxel grid vertexand its adjacent neighbors:

Here, |Ni| is the number of voxel grid vertices in Ni. Sat-isfying ∂E/∂vx(i) = 0, ∂E/∂vy(i) = 0, and ∂E/∂vz(i) = 0lets us minimize the objective function E and obtain theiterative solution:

(3)

where (vx,vx,vx) is the average velocity of the adjacentvoxel grids, and

Although we obtain the velocity field associated witheach voxel grid according to changes in the tool scalarfield st, we don’t change their positions. Instead, we usethe velocity field v to update the surface scalar field ss

by defining the speed function as

µ

λ

=+ + +

+

∂

∂

∂

∂

∂

∂

∂

∂

∂

∂

s

xx

s

yy

s

zz

s

t

s

x

t t t t

t

v v v

+

+

∂

∂

∂

∂

2 2 2s

y

s

z

t t

v v v v v vsx

sy

sx y z x y z

t t, , , , , ,

=

− ∂

∂∂∂

∂Τ Τµ tt

z∂

Τ

s iN

v i v j v i

v j v ii

x x y

y z( )

( ( ) ( )) ( ( )

( )) ( (= − + −

+1 2

2 )) ( ))−

∑ v jzj Ni

2ε

c isx

v isy

v isz

v ist

xt

yt

z( ) ( ) ( ) ( )= ∂∂

+ ∂

∂+ ∂

∂+ ∂ tt

t∂

2

E c i s ii

= +∑( ( ) ( ))λ

N j ij C j L L L L Li

= ∈ ∈ ∪ ∪ ∪ ∪{ }− −6 2 1 0 1 2,

E ss

td

tt= ∇ ⋅ +

∂

∂

+ ∇( )∫ x v v x2

2λ

∇ ⋅ +∂

∂=x

xs

ddt

s

ttt 0

Point-Based Computer Graphics

46 July/August 2004

(4)

Using these formulations, we design our level-set-based global free-form deformation as an evolutionprocess:

� We generate a tool scalar field using skeletons orsketches.

� We track down the original tool scalar values sto at thevoxel grid positions.

� After the user alters the tool scalar field, we find theirfinal tool scalar values stf.

� We then have stf = sto + k∆st, where k is a user-speci-fied number of steps taken to deform st, and ∆st is theevolution step size of the tool scalar field.

The SFFD algorithm for point geometry is as follows: At each time step m (m = 0 … k),

1. Update the tool scalar field by: st = sto + m∆st, then∂st/∂t = ∆st;

2. Calculate ∂st/∂x using finite differences;3. Initiate the sparse-field layer voxel grid velocities to

be 0;4. Deduce the current velocity field by iteration using

Equation 3 (converging the velocities typicallyrequires three to four iterations);

5. Deduce the surface scalar field updating rate usingEquation 4 and obtain the updated surface scalarfield ss;

6. Update points’ positions and perform dynamic sam-pling.

7. If m = k, terminate the deformation process; oth-erwise, proceed to the next time step m + 1 andrepeat steps 1 through 6.

Figure 4 shows how we deform the surface scalar fieldusing the tool scalar field deformation. In the figure, yel-low curves denote the isosurface of the surface scalarfield associated with the point set surface; blue curvesdenote the skeleton-based tools for defining the toolscalar field; and red arrows denote the velocities evalu-ated at the sparse-field layer voxel grids.

Dynamic update and samplingAfter user interaction modifies the global distance

field, we must change the points’ locations because the

point samples are assumed to be on the underlyingimplicit function’s zero level set. When deforming thedistance-field space, we represent the point sample tra-jectory as {x(t)|ss(x(t), t) = 0}, where x(t) is the point’sparameter position and ss is the point surface’s globalscalar field. The derivative of ss(x(t), t) with respect totime yields:

(5)

where ∇xss denotes the gradient ∂ss(x(t), t)/∂x.Because both ∇xss and v are vectors, no unique solu-tion for the point velocity exists. If we divide v intothree components v = vn + vt + vw along threeorthogonal directions n, t, w, where n = −∇xss/|∇xss|represents the unit principle normal vector of the dis-tance field’s isosurface, t represents the unit tangentvector, and w represents the unit binormal vector, thedot product ∇xss

. v in Equation 5 retains only the com-ponent containing vn. Therefore, if we assume a pointonly moves in its normal direction, we get its normalvelocity by

(6)

We use this velocity to update the point position byadvancing to the next time step through the forwardEuler method xi+1 = xi + vn∆t.

The point sampling density changes as users performsurface sculpting or deformation. To maintain surfacequality, we insert new sample points when the surfacedensity becomes too low. Alternatively, we simplify thesurface by eliminating points when the surface issqueezed. We use the farthest point sampling scheme5

for point insertion. In each modeling step, each pointchecks its neighboring density by projecting its neigh-bor points onto its tangent plane. Next, we computethe points’ Voronoi diagram using the Voronoi vertexwith the largest circle radius on the tangent plane. Ifthe radius is larger than a specified threshold, we pro-ject the vertex onto the global scalar field’s isosurface.This gives us a surface density that is locally near uni-form. Meanwhile, we can reduce the sampling densi-ty using various methods.4 We implement an iterativesimplification method similar to one introduced in ear-

v nx

n =

∂∂

∇

s

t

s

s

s

∇ ⋅ ∂∂

=x

vssts

s+ 0

Fs

s

s

s= − ∇

∇⋅v

IEEE Computer Graphics and Applications 47

(a) (b) (c) (d) (e) (f)

4 Scalar fields: (a) The surface scalar field ss representing the point set surface; (b) the initial tool scalar field st; (c) the deformed toolscalar field; (d) the velocity (red arrow) field computed according to the tool scalar field’s deformation; (e) the velocity field, which weuse to deform the surface scalar field; and (f) the deformed surface scalar field.

lier work.4 However, instead of using a quadric errormetric, we simply replace two points with their mid-dle point and project this new point onto the globalscalar field isosurface. A relaxation stage can followthe up- and down-sampling process, using a simplepoint repulsion scheme to obtain a more uniform sam-pling pattern.

Topology change handlingFor our level-set-based surface-editing tools to

change the shape and topology of a point set surface,the surface must be able to change its topology prop-erly whenever it detects a collision. The underlyinglevel-set surface contour automatically changes topol-ogy (for example, by merging or splitting) without anelaborate mechanism. However, the topology of thepoint set surface requires explicit handling. For exam-ple, unless we delete the points in the intersectionregion, we will have little control over the movementof points in the intersection region. In the topologychange region, for example, the surface scalar field gra-dient ∇xss might change to 0 during the iterations. Inaddition, because Equation 6 guides point samplemovement, we need a robust method to predict wheretopology changes will occur, and then delete the pointsamples in those regions.

Bischoff and Kobbelt control the level-set contourtopology by adding topological information to the vol-ume representation with the clear goal of locallyresolving topological ambiguities.13 Their novelmethod is useful for collision detection of the level-setcontour. Tasks in our current work differ from theirs,and we focus mainly on the robust and proper topo-logical modification of the point-sampled geometryundergoing deformation. We therefore simply changethe topology when the level-set surface detects a col-lision, even though integrating Bischoff and Kobbelt’ssetting into our framework to preserve the topologyof the underlying point set surface is quite straight-forward.13

Digital topology. We use fundamental digitaltopology techniques to detect collisions in a level-setcontext.

A grid point u ∈ Z3 is a 6-, 18-, 26-neighbor of anoth-er grid v ∈ Z3 if ‖v − u‖2 ″ 1, √2, √3, respectively. Wedenote the n-neighborhood (n ∈ {6, 18, 26}) of v byNn(v) = {u|u is an n-neighbor of v}, and setN *

n (v) = Nn (v)\{v}.Let v ∈ Z3 be a grid point and V ⊂ Z3 be a grid set. V is

an interior grid; its complement, V = Z 3\V is exterior.

We define the geodesic n-neighborhood of order k of agrid v with respect to V ⊂ Z3 recursively by

By denoting the number of n-connected componentsof a grid set V ⊂ Z3 by cn(V), we explicitly define the topo-logical numbers nint and next as

where nint(v, V) is the number of interior componentsof V that touch v, and next(v, V) the number of exteriorcomponents.

A grid point v is simple with respect to V ⊂ Z3 if V andV � {v} have the same number of components, handles,and cavities13; otherwise, v is complex. Furthermore, vis simple with respect to V if and only if

nint(v, V) = next(v, V) = 114 (7)

More theoretical results on digital topology are avail-able elsewhere.13,14

Collision detection. For clarity, we only considersituations in which the surface advances outward; whena surface moves inward, we simply switch the inside andoutside of the surface region. We call a grid point on thesparse field’s active layer L0 or inside the surface regionconquered. When a grid point is about to be conquered(that is, about to change its status from outside layer L−1 to active layer L0), we test it for simplicity using Equa-tion 7. If it’s simple, the sparse-field algorithm proceedsas usual. If it isn’t, we must explicitly resolve the point setsurface topology change—that is, delete the point sam-ples residing in the grid’s near vicinity.

Similar to Bischoff and Kobbelt,13 we distinguishfive cases, shown in Figure 5. We handle the topolog-ical change and resolve the topological ambiguity onlywhen nint ≥ 2—that is, when two parts of the front col-lide. Figure 6 illustrates collision detection and topo-logical modification. Grid v is added to L0 in thecurrent iteration step. The topology number nint for vequals 2. We therefore delete the point samples resid-ing in the prescribed vicinity of grids u and w (userscan identify the affected region interactively or auto-matically depending on their specified parameters,such as each grid’s influence factor). We also place atag between v and w, so the system will consider themdisconnected when checking topology numbers fornearby grid points.

Editing toolkitsOur sculpting system provides various tools for flexi-

bly performing many modeling operations on point setsurfaces.

n V c N V N

n V cext

int v v v

v

, ,

,

*( ) = ( )∩ ( )( )( ) =

6 62

26

266 26V N∩ ( )( )* v

N V V N

N V V N N

n n

nk

n nk

1

1

( , ) ( ),

( , ) { (

v v

v u u v

= ∩

= ∩ ( ) ∈+ ,, )}V

Point-Based Computer Graphics

48 July/August 2004

(a) (b) (c) (d) (e)

5 Characterization of the center grid (in red) with respect to its neighbor-hood: (a) nint = 1, next = 1; (b) nint = 0, next = 1; (c) nint = 1, next = 0; (d) nint =1, next = 2; (e) nint = 2, next = 1.

Force-based toolsUsing our force-based tools, users can select any point

location inside the sculpting region and simulate thedynamics on the mass points inside the region. A user-defined function, which can be Gaussian, constant,spherical, or any other distribution, distributes the forceamong nearby mass points. In addition to the point-based rope tool,15 our system offers a curve-based ropetool for applying force along any user-defined curve withany distribution mode. Figure 7a shows how we use thepoint-based rope tool to deform the rabbit model’s sur-face. Figure 7b shows a curve-based force tool for sculpt-ing the rabbit’s head.

Free-form deformation toolsOur system lets users perform free-form deformations

on point set surfaces by interactively sketching skele-tons using a mouse or 3D pointing device. The systemgenerates the tool scalar field as the blending of fieldfunctions gi of a set of skeletons ti(i = 1, …, N):

where skeletons ti can be any geometric primitive, suchas blobs and curves. The field functions gi are decreas-ing functions of the distance to the associated skeletongi(x, y, z) = Fi(d(x, y, z, ti)), where d(x, y, z, ti) is thedistance between (x, y, z) and ti, and we can define Fi

using polynomials or more sophisticated anisotropicfunctions.

After constructing the tool scalar field st, designerscan enforce global control of st in two ways:

� adjusting the coefficients of the implicit functionsdefined for each skeletal element, or

� manipulating or moving the skeletons.

When designers modify the tool scalar field, theembedded surface scalar field and the point set surfacesare deformed according to the SFFD algorithm. Figure8 shows how adjusting the influence radius of the under-lying blob skeletons achieves free-form deformationson a rabbit model. Figure 9 (next page) shows howbending the underlying curve skeleton bends the rabbitmodel. Bending the underlying curve skeleton firstchanges the tool scalar field, and then deforms theembedded point geometry according to the SFFD algo-rithm. Users can taper the model by sketching sourceand target strokes, as Figure 10 illustrates.

Sketch-based editing toolsWe also developed several simple sketching tools to

let users edit point set surfaces using hand strokes. Thesystem gathers strokes from the mouse as a set of curvesor collection of points, and assigns Gaussian blobs even-ly along the curve or at each point. The surface growsalong this implicitly defined region, either outside orinside of it depending on the surface motion’s direction.These tools use the well-known speed function, whichis a combination of two terms11:

s x y z g x y zt i

i

N

( , , ) ( , , )==

∑1

IEEE Computer Graphics and Applications 49

7 Force-basedtools: (a) Apoint-basedrope tool fordeforming therabbit model’ssurface and (b)a curve-basedrope tool forsculpting therabbit’s head.

(a)

(b)

8 Shrinking and inflating a rabbit model using blob skeleton: (a) definingthe blob skeleton on the original rabbit model (blue indicates the skeleton-based scalar field’s isosurface); (b) shrinking the rabbit model’s head; and(c) inflating the middle part of the rabbit model.

(a) (b) (c)

u v w

6 Collisionbetween twoparts of thefront of thesurface (greencurves). The reddashed curveadvances in thecurrent itera-tion step, whilethe red gridchanges statusfrom layer L−1 toL0. Green gridsdenote activegrid points in L0

from the previ-ous step. Bluegrids are insidethe active sur-face region.

where D depends on user input strokes, forcing the sur-face to expand or contract toward the stroke regionboundary. The term ∇ . ∇φ/∇φ is the surface’s mean cur-vature H, which forces the surface to remain smooth. We

use the topology change handling techniques addressedearlier for collision detection and point sample deletion.

Figure 11 shows the sketch-based surface growingmethod. The user simply draws a sketched curve on therabbit’s back (Figure 11a). The original point set sur-face grows along the curve (Figure 11b), automaticallyresolving topology change when it detects a collision(Figure 11c). Finally, it forms a handle on the rabbit’sback (Figure 11d). By inverting the growing directionof level-set surfaces, we achieve drilling operationsbased on user input strokes.

Embossing and engraving toolsAttracting and repelling the surface toward and away

from a set of curves or collection of points produces anembossing and engraving effect. In our system, after theuser draws curves or places points near the surface, weemboss or engrave the surface with the shape of thosecurves or point sets. We use Museth et al.’s speed func-tion16 F = Dq(d)C(γ)G(γ). Here Dq is a distance-based cut-off function that depends on a distance measure d to ageometric region of influence (ROI) primitive such as asuperellipsoid. C(γ) is a cut-off function that controls thecontribution of G(γ) to the speed function, whereas G(γ)depends on geometric measures γ of the level-set surface.

For the embossing and engraving tool, we formulatethe speed function as F(x, n, φ) = −αDq(d)C(−sign[φ(pi)]n . ui) φ(pi), where x is the current grid’slocation, n is the surface normal direction, d is a signeddistance measure to an ROI primitive evaluated at x, pi

is the closest point in the curve (or point set) to x, andui = (pi − x)/|(pi − x)|. Figure 12 is an example of sur-face embossing.

Smoothing toolsApplying motion to reduce local curvature can locally

smooth the surface. We use Museth et al.’s formulation16:

F = αDq(d)C(κ)κ (8)

where κ is either mean curvature or Gaussian curvatureof the level-set surface. The point set surface models pro-duced by the constructive solid geometry (CSG) Booleanoperations can contain sharp and jagged creases at sur-face intersections. Figures 13a and 13b show the effectsof applying the smoothing operator to the intersection

region of the point set surfaces con-structed from the CSG union opera-tions. Inverting α in Equation 8 andapplying an upper cut-off in C(κ) tomaintain numerical stabilityachieves the sharpening operator.

Implementation andresults

We implemented the simulationand rendering parts of our systemon a Microsoft Windows XP PC withdual Intel Xeon 2.4-GHz CPUs, 2-Gbyte RAM, and an Nvidia GeForceFx 5800 Ultra GPU. We wrote theentire system in Microsoft Visual

F D= + − ∇⋅ ∇∇

α α φφ

( )1

Point-Based Computer Graphics

50 July/August 2004

9 Bending a rabbit model using curve skeleton: (a) original frontal view ofthe model, (b) frontal view of the model after bending the underlyingcurve skeleton, (c) original profile of the rabbit model, and (d) profile afterbending the curve skeleton.

(a) (b) (c) (d)

10 Tapering the rabbit mouth using sketched strokes: (a) original profile ofthe rabbit model and (b) the sketched source stroke, and (c) the sketchedtarget stroke and (d) profile after applying the tapering operation.

(a) (b) (c) (d)

(a) (b) (c) (d)

11 Sketch-based surface growing: (a) the user draws a curve on the rabbit model’s back, (b)the point set surface grows along the curve, (c) the surface resolves topology change ondetecting a collision, and (d) the point set surface forms a handle.

C++ and built the graphics-rendering component onOpenGL. We used Sensable Technology’s Phantomdevice for haptic input and force feedback during localsurface sculpting.

We attach the haptic device to a low-end PC. A paral-lel technique multithreads the haptics, graphics, andsculpting processes with weak synchronization, reduc-ing latency and maximizing throughput. This techniquesignificantly improves performance and enables a par-allel implementation of haptic sculpting given high-endmultiprocessor computing resources. Having a dedi-cated low-end PC process haptic input and output exclu-sively saves this thread from competing with thecomputationally intensive simulation thread. The hap-tic thread gets enough CPU time to guarantee thedesired update rate of 1,000 Hz. We implement render-ing and simulation on different threads as well. There-fore, when we run the system on a dual-processor board,rendering and simulation don’t interfere with each otherfrom the CPU load’s viewpoint.

We’ve conducted many experi-ments and recorded update timesfor force-based sculpting operationsand various level-set-based editingoperations. Tables 1 and 2 detail theresults. We didn’t include dynamicsampling (that is, up-sampling anddown-sampling) time into theupdate times in Tables 1 and 2because it depends on the numberof points inserted or deleted at each

simulation step. The haptic loopalways completes within 1 millisec-ond on the separate low-end PC.

Using our scalar-function-drivenpoint set surface modeling frame-work, we’ve created several interest-ing objects, shown in Figure 14. Wegenerated the rabbit king’s crown by

dragging the rabbit’s head with the force tool for a bumpyeffect, and the rabbit king’s bow tie using embossing oper-ations. We created the rabbit teapots from rabbit modelsand the teapot spouts using curve-based bending on therabbit models, tapering for the rabbits’ mouths, sketch-based editing for the handles on the back of the rabbits,and smoothing for the intersection of the rabbits andspouts after the CSG union operation. We created theCGA 2004 logo using sketch-based editing techniques bysketching the logo-shaped curves on the rabbit point set

IEEE Computer Graphics and Applications 51

Table 1. Update time for force-based dynamic simulation.

No. of mass points No. of inside points Time (seconds)

20 × 20 × 20 6,060 0.018821 30 × 30 × 30 6,060 0.030717 40 × 40 × 40 6,060 0.050563 20 × 20 × 20 16,071 0.029026 30 × 30 × 30 16,071 0.042454 40 × 40 × 40 16,071 0.066969

Table 2. Update time for various level-set-based editing operations.

Editing tool No. of grids No. of points Time (seconds)

Shrinking/inflation 1283 67,038 4.652733Bending 1283 67,038 3.009914Sketch editing 643 9,348 0.183589Embossing 643 9,191 0.214501Smoothing 643 9,826 0.535967

12 Surface embossing based on aset of user-sketched curves near thesurface.

13 Curvature-based smoothing operations: (a) intersection region of thepoint set surface constructed from the constructive solid geometry (CSG)union operations and (b) smoothed intersection region.

(a) (b)

14 Rabbit king, rabbit teapots, and CGA 2004 logocreated using our scalar-function-driven editing frame-work and rendered using QSplat.

surface models and letting the surface grow along theuser input curves.

ConclusionSeveral improvements to our current work are possi-

ble in the near future. Currently the dynamic samplingand the underlying level-set approach limit the speed ofour free-form deformation. Our ultimate goal is toenhance the deformation operations with haptics sousers can have realistic force feedback when perform-ing deformations on point set surfaces. �

AcknowledgmentsThis research was supported in part by the US Nation-

al Science Foundation through grants IIS-0082035 andIIS-0097646 and an Alfred P. Sloan Fellowship. Theauthors thank Christopher Carner for proofreading thedraft. Special thanks to Mitsubishi Electric Research Lab-oratories and Liu Ren from Carnegie Mellon Universityfor providing us the vertex/pixel shader codes of the hard-ware-accelerated elliptical weighted average surfacesplatting. The rabbit model is courtesy of Cyberware.

References1. L. Ren, H. Pfister, and M. Zwicker, “Object Space Ewa Sur-

face Splatting: A Hardware Accelerated Approach to HighQuality Point Rendering,” Proc. Eurographics, Blackwell,2002, pp. 461-470.

2. C. Dachsbacher, C. Vogelgsang, and M. Stamminger,“Sequential Point Trees,” Proc. Siggraph, ACM Press, 2003,pp. 657-662.

3. H. Pfister et al., “Surfels: Surface Elements as RenderingPrimitives,” Proc. Siggraph, ACM Press, 2000, pp. 335-342.

4. M. Pauly, M. Gross, and L. Kobbelt, “Efficient Simplifica-tion of Point-Sampled Surfaces,” Proc. IEEE Visualization,IEEE CS Press, 2002, pp. 163-170.

5. M. Alexa et al., “Computing and Rendering Point Set Sur-faces,” IEEE Trans. Visualization and Computer Graphics,vol. 9, no. 1, Jan.-Mar. 2003, pp. 3-15.

6. J. Hua and H. Qin, “Haptics-Based Volumetric ModelingUsing Dynamic Spline-Based Implicit Functions,” Proc.IEEE Symp. Volume Visualization and Graphics, IEEE Press,2002, pp. 55-64.

7. Y. Ohtake et al., “Multilevel Partition of Unity Implicits,”Proc. Siggraph, ACM Press, 2003, pp. 463-470.

8. J. Hua and H. Qin, “Free-Form Deformations via Sketchingand Manipulating Scalar Fields,” Proc. 8th ACM Symp. SolidModeling and Applications, ACM Press, 2003, pp. 328-333.

9. X. Guo and H. Qin, “Dynamic Sculpting and Deformationof Point Set Surfaces,” Proc. Pacific Graphics, IEEE CS Press,2003, pp. 123-130.

10. H. Xie et al., “Piecewise C1 Continuous Surface Recon-struction of Noisy Point Clouds via Local Implicit QuadricRegression,” Proc. 14th IEEE Visualization Conf., IEEE CSPress, 2003, pp. 91-98.

11. R.T. Whitaker, “Volumetric Deformable Models: ActiveBlobs,” Proc. Conf. Visualization in Biomedical Computing,ACM Press, 1994, pp. 122-134.

12. R.T. Whitaker, “A Level-Set Approach to 3D Reconstruc-tion from Range Data,” Int’l J. Computer Vision, vol. 29, no.

3, 1998, pp. 203-231.13. S. Bischoff and L. Kobbelt, “Sub-voxel Topology Control

for Level Set Surfaces,” Proc. Eurographics, Blackwell,2003, pp. 273-280.

14. G. Bertrand, “Simple Points, Topological Numbers andGeodesic Neighborhoods in Cubic Grids,” Pattern Recog-nition Letters, vol. 15, no. 10, 1994, pp. 1003-1011.

15. F. Dachille, H. Qin, and A. Kaufman, “A Novel Haptics-Based Interface and Sculpting System for Physics-BasedGeometric Design,” Computer-Aided Design, vol. 33, no. 5,2001, pp. 403-420.

16. K. Museth et al., “Level-Set Surface Editing Operators,”Proc. Siggraph, ACM Press, 2002, pp. 330-338.

Xiaohu Guo is a PhD candidate inthe Department of Computer Scienceat the State University of New York atStony Brook. His research interestsinclude geometric and physics-basedmodeling, computer animation andsimulation, interactive 3D graphics,

scientific visualization, and virtual reality. Guo has a BSin computer science from the University of Science and Tech-nology of China. For more information see http://www.cs.sunysb.edu/~xguo.

Jing Hua is a PhD candidate in com-puter science at the State Universityof New York at Stony Brook, where heis also a research assistant in the Cen-ter for Visual Computing. Hisresearch interests include computergraphics, geometric and physics-

based modeling, scientific visualization, human–comput-er interaction, and computer vision. He has a BS inelectrical engineering from the Huazhong University of Sci-ence and Technology, China, and an MS in pattern recog-nition and artificial intelligence from the Institute ofAutomation, Chinese Academy of Sciences. For more infor-mation see http://www.cs.sunysb.edu/~jinghua.

Hong Qin is an associate professorof computer science at the State Uni-versity of New York at StonyBrook.His research interests include com-puter graphics, geometric andphysics-based modeling, computer-aided design, virtual environments,

animation, simulation, and robotics. He has a PhD in com-puter science from the University of Toronto. Qin receivedan NSF CAREER Award, a Honda Initiation Grant Award,and was an Alfred P. Sloan Research Fellow. He is on theeditorial board of The Visual Computer. For further infor-mation, please visit http://www.cs.sunysb.edu/~qin.

Readers may contact Xiaohu Guo at the Center for Visu-al Computing, Dept. of Computer Science, State Univ. ofNew York at Stony Brook, Stony Brook, NY 11794-4400;xguo@cs.sunysb.edu.

52 July/August 2004

Point-Based Computer Graphics