DESIGNING AND IMPLEMENTING A SURFACE MODELING SYSTEM
By
LEJENG SHIUE
A THESIS PRESENTED TO THE GRADUATE SCHOOL
OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT
OF THE REQUIREMENTS FOR THE DEGREE OF
MASTER OF SCIENCE
UNIVERSITY OF FLORIDA
2001
Copyright 2001
by
LeJeng Shiue
ACKNOWLEDGEMENTS
I owe my success in the research work and my career in computer science to
my research advisor, Dr.Jorg Peters I benefited from his vision, his broad and deep
knowledge and his rich experiences in computer graphics.
I would also like to express my sincere gratitude to Dr. Paul A. Fishwick and
Dr. Baba C. Vemuri for serving on my supervisory committee.
I am especially grateful to my parents for their emotional support and encour
agement throughout my academic career.
TABLE OF CONTENTS
ACKNOWLEDGEMENTS ... ............. .......... iii
LIST OF FIGURES ..................... .......... vi
ABSTRACT ................... ....... ....... viii
CHAPTERS
1 INTRODUCTION ............................. 1
1.1 Overview of Major Parametric Surface Representations ..... 1
1.2 Overview of The Surface Modeling System ............ 2
1.3 Contributions of The Thesis .......... .......... 4
2 BACKGROUND............ ....... .. ... ...... 5
2.1 Overview of CGAL ........................ 5
2.1.1 Halfedge Data Structure in CGAL ............. 6
2.1.2 Representation of CGAL Polyhedron ............ 8
2.2 CatmullClark Subdivision .......... ........ ... 9
2.3 Patching CatmullClark Meshes ....... ......... 13
2.3.1 Overview of PCCM ............... . . .. 13
2.3.2 Patch Transformation .............. .. .. 14
3 DESIGN OF THE REFINEMENT ALGORITHM . . . . ... 18
3.1 Design Issues ................ .... ....... 18
3.1.1 User Extended CGAL Polyhedron . . . . ... 18
3.1.2 Geometry Rules ................ ...... 18
3.1.3 Hierarchical Subdivision Polyhedron . . . . .... 19
3.2 CatmullClark Subdivision with CC scheme . . . . .... 23
4 DESIGN OF INTERACTIVE SURFACE MODELING . . ... 25
4.1 Design Issues ........ ........... ... ...... 25
4.2 Quad PolyhedronHalfedge Data Structure + Quad ...... . 26
4.2.1 Quad Map .................. ..... .. 26
4.2.2 Quad Polyhedron ................... . . 27
4.3 Interactive Modeling with PCCM . . . . . . 32
4.3.1 Effect of Knot Insertion .................. .. 35
4.3.2 Effect of Corner Smoothing . . . . . ..... 40
4.3.3 Algorithm for Local Updating . . . . . ..... 40
5 CONCLUSION AND FUTURE WORK ....... .......... 42
5.1 Conclusion ................... ........ 42
5.2 Future W ork ............................. 46
REFERENCES ................... .............. 47
BIOGRAPHICAL SKETCH ............................ 48
LIST OF FIGURES
1.1 System diagram .............................. 3
2.1 Halfedge data structure .................. ..... 7
2.2 Structure of CGAL halfedge data structure. ..... . . . . 7
2.3 Incidental operations of halfedges in the halfedge data structure. .. 9
2.4 Structure of CGAL polyhedron. ............... .. .. 10
2.5 Euler operations .................. ........... .. 10
2.6 CatmullClark subdivision .................. ... .. 12
2.7 Om esh ................................. .. 14
2.8 PCCM mesh ................ .. ... ........ 15
3.1 Mipmap polyhedron .................. ........ .. 20
3.2 Storage State .. .. .. .. .. ... .. .. .. ... .... .. . 21
4.1 Quad polyhedron .................. .......... .. 29
4.2 Initialization of the quad polyhedron ..... . . . . ..... 31
4.3 Knot insertion .................. ............ .. 32
4.4 Relations between Imesh, Omesh and quad polyhderon ...... ..34
4.5 Interactive Modeler .................. ......... .. 36
4.6 Influence region .................. ........... .. 37
4.7 Influence region of knot insertion ............... . .. . 39
5.1 Examples of the different steps of the surface modeling. . . ... 43
5.2 Omesh and interactive modeling surfaces. . . . . . ..... 44
5.3 An example of modeling surfaces ............. . .. .. 45
Abstract of Thesis Presented to the Graduate School
of the University of Florida in Partial Fulfillment of the
Requirements for the Degree of Master Of Science
DESIGNING AND IMPLEMENTING A SURFACE MODELING SYSTEM
By
LeJeng Shiue
May 2001
Chairman: Dr. Jorg Peters
Major Department: Computer and Information Science and Engineering
Subdivision surfaces and spline surfaces are widely used surface modeling tech
niques. Both techniques have some drawbacks when used in interactive modeling
systems. Reevaluation of subdivision surfaces from start is prohibitively slow when
updating small areas. For spline surfaces, the challenge is to maintain the smoothness
across patches during the manipulation of control points of the individual patch.
In this thesis, I designed and implemented a new modeling system that sup
ports interactive smooth freeform 3D modeling. The system uses the PCCM al
gorithm (Patching CatmullClark Meshes) to transform an intermediate mesh of
CatmullClark subdivision to a parametric surface consisting of NURBS (NonUniform
rational BSpline) patches. The PCCM algorithm is extended to support interactive
surface modeling and to update the surface instantly while still enforcing the smooth
ness of the surface.
This thesis also introduces a simple scheme for supporting the hierarchically
subdivided polyhedron that serves as input to the PCCM algorithm and a new data
structure that makes implementation of PCCM more natural. In addition, the new
data structure supports the local updates of PCCM surface and makes the imple
mentation easy and efficient.
CHAPTER 1
INTRODUCTION
Applications such as special effects and animations require creation and ma
nipulation of complex geometric models of arbitrary topology. These models can be
created by digitization or complex modeling packages. To represent different scales
of detail, these models are often composed of high resolution meshes. These high
resolution meshes cause the difficulty of interactive modeling and user interface of
manipulating of the models.
The contribution of this thesis is to create a new, simple and intuitive tool
for a interactive modeling system. The focuses of the design of the system are the
creation of simple mesh, intuitive modeling operations and instant 'i,, f.n : f' i'J.lt;li
1.1 Overview of Major Parametric Surface Representations
The popular techniques for modeling smooth parametric surface can be broadly
classified into two distinct categories: spline surfaces and subdivision surfaces.
Spline surfaces usually consist of a set of smoothly joining individual paramet
ric patches. When treated individually and manipulated via separate control meshes,
enforcing the continuity across the patches becomes very complicated.
Subdivision surfaces are generated by recursively applying a set of mesh refine
ment rules. It can easily produce a tangent continuous limit surface. Users have to
carefully select the initial mesh and manipulate the control points at different levels
of the subdivision hierarchy since there is no direct and intuitive way to manipulate
the limit surface.
PCCM(Patching CatmullClark Meshes) [5] provides another way to generate
and represent the smooth and complex surface. The PCCM algorithm transforms
intermediate meshes of subdivision surfaces to parametric surfaces that consist of
smoothly joining NURBS (NonUniform rational BSpline) patches. Chapter 2 pro
vides the details of the algorithm and the representation.
1.2 Overview of The Surface Modeling System
Figure 1.1 illustrates our surface modeling system. The system is subdivided
into five subsystems.
1. Mesh editor: For an initial mesh of arbitrary shape and topology, users can
modify it by using geometry and connectivity operations. This stage will output
the input mesh.
2. PCCM preprocessor: To build the mesh with required connectivity for
PCCM algorithm, the preprocessor first checks if the input mesh only consists
of quadrilateral facets. If not, it refines the input mesh to become all rectangles
by calling a general quadralization function or one step of the CatmullClark
subdivision. The result mesh of this step is called Imesh. The preproces
sor then executes two steps of the CatmullClark subdivision generating the
Omesh as the input mesh for the PCCM algorithm.
3. PCCM transformer: Transform the Imesh into the PCCM mesh consisting
of the control nets of the parametric surfaces.
4. Surface generator: The surface generator evaluates the PCCM mesh as a set
of NURBS patches and displays the resulting PCCM ,,,, f.i.,
PCCM Preprocessor
IMesh
Geometry Operations
Connectivity Operations
All facets quadrilateral ?
Yes
No
Quadralization
Surface Generator
IPCCM Transformer ]
Two Steps PCCM NURBS
Tw oStep s .... .......... .. .........
CatmullClark Subdivision Transformation Evaluation
OMesh PCCM Mesh 
0Mesh PCCM Mesh
f
PCCM Surface
Interactive Modeler
Figure 1.1: System diagram of the modeling system(see Figure 5.1 for instances).
Mesh Editor
Initial Mesh
Input Mesh
5. Interactive modeler: While users manipulate the Omesh, the interactive
modeler defines the influence regions of the manipulated vertices, then it "re
PCCM"s these regions and locally updates the PCCM mesh and the PCCM
1.3 Contributions of The Thesis
The objectives of this thesis are the study of the PCCM algorithm, the ex
tension to the interactive modeling using PCCM and the extension of the CGAL
library(see Chapter 2) to support the CatmullClark subdivision and the PCCM al
gorithm.
This thesis describes an encoding/decoding scheme for supporting the hier
archically subdivided polyhedron that can apply to any generic CGAL polyhderon.
The hierarchical polyhderon also serves as the input to the PCCM algorithm and sep
arates the algorithm and the data structure of refinement and transformation steps in
PCCM. This thesis also introduces a new data structure, called quad polyhedron, and
an interactive modeling scheme that make the local updating of the PCCM surface
easy and efficient.
CHAPTER 2
BACKGROUND
In this thesis, the CGAL(Computational Geometry Algorithm Library) pro
vides core data structures. Modeling algorithms include CatmullClark subdivision[1]
and Patching CatmullClark Meshes(PCCM) algorithm [5]. This chapter gives a brief
overview of the CGAL and details of the modeling algorithms.
2.1 Overview of CGAL
CGAL is a Computational Geometry Algorithm Library[6] that contains prim
itives, data structures, and algorithms for computational geometry. It was started
six years ago in Europe in order to provide correct, efficient and reusable implemen
tations.
CGAL consists of three 1 ,\' i[G 4] and each layer is divided into smaller mod
ular units. The core library consists of basic functionalities such as configuration,
assertions, iterators and enumerations. The second layer, the kernel library, con
sists of constant size nonmodifiable geometric primitives such as points and lines and
operations on these primitives. The third layer, the basic library, consists of basic
geometric data structures and algorithms. CGAL also has a support library which
contains functionality with nongeometric aspects such as visualization, circulator,
number types, etc.
The design goals for CGAL include robustness, generality, efficiency and ease
ofuse. To fulfill these goals, developers of the CGAL opted for the generic pro
,1,/,i,;i,,,i ,j'.ih, II L[3] in most of the design of CGAL. Hence, C++ templates[7]
parameterized data types and functionsare heavily used and users have to specialize
(specify template parameters of the data types or functions) the CGAL data struc
tures or algorithms with specific template arguments. After being specialized, CGAL
classes can be used as normal C++ classes.
By replacing the template parameters, users can horizontally extend the classes
of the CGAL library. Users can also 'i, i; ..,//li extend CGAL classes by inheriting the
classes to build an object oriented classes hierarchy. There are two different ways of
extending CGAL by inheritance. First, a new class can be inherited from a special
ized class by treating it as a normal C++ class. Second, a new inheritated template
class passes the template parameters) to the base CGAL template class.
In the implementation of our system, CGAL classes are extended both hori
zontally and *, t //..,/// to support the modeling algorithms.
2.1.1 Halfedge Data Structure in CGAL
Halfedge data structure[8] is an edgecentered data structure which main
tains the connectivity of the primitivesvertices, edges and facets (shown in Figure
2.1). Each edge is decomposed into two opposite oriented halfedges which store the
pointers to the incident vertices and facets. Each facet is surrounded by a set of
halfedges which are oriented counterclockwise as seen from the outside.
CGAL separates the connectivity and geometry in the halfedge data structure
as well as the primitive classes which specialize the halfedge data structure. CGAL
halfedge data structure acts as a container which stores and maintains the connec
tivity information and the primitives store both the connectivity and/or geometry
information. Figure 2.2 illustrates the design. The CGAL halfedge data structure,
acting as a black box, stores three lists or vectorsdepending on the type of the
storage ci,,iiii .,li.,, users have chosenof the primitives and maintains the inci
dent relation of the halfedge. On the other hand, the primitive bases are replaceable
template parameters and can carry the geometry data, user defined data or even
\ \,
\\ I
\ \ I I
Incident Vertex OQ .

/ / I
I C)s
Opposite Halfedge
Halfedge
Incident Facet
'o
C)
(o
"3
c)
X
=2
0
C)
0 0 0
Figure 2.1: In a halfedge data structure, each halfedge has five incident primitives.
Users can traverse the mesh by using these incident relations.
void pointer. Users can define their own primitive bases either by inheriting prim
itive bases from CGAL or by building new classes that comply with the functional
requirements of the halfedge data structure.
CGAL currently supports two types of halfedge data structure with different
internal storage organizations. One is a doolilhi ., .l list and the other one is an STL
std::vector[3]. A halfedge data structure using list has dynamic capacity and hence
can easily add or remove the primitives. On the other side, a halfedge data structure
Halfedge Data Structure
* Storage Type
* TypeSafe Pointer
SVertex  Halfedge Facet
Figure 2.2: Structure of CGAL halfedge data structure.
Primitive Bases
* Geometry Information
* User Defined Information Vertex Base Halfedge Base Facet Base
* Void Pointer
using vector is efficient for predefined size of the primitives yet is very slow at adding
or removing any primitives after the structure is created. Since vector structure does
not use extra space to store pointer to the next element and can randomly access
the elements in constant time, using vector is usually more efficient than using list
on aspect of time and space. Both types of the halfedge data structures always add
new primitives in the end of the internal storage structure.
CGAL provides a set of primitive base classes for different level of functional
requirements. Users can directly use these bases or adapt them to fulfill some special
demands and functionalities. For example, users can instantiate a halfedge data
structure that has only connectivity information by using CGAL::Vertexmin_base,
CGAL::Halfedge_min_base and CGAL::Facetmin_base in which no geometry data
are stored. Or, users can create a new vertex class, say with color, by inheriting
CGAL::Vertex_min_base and adding a new member variable as the color tag.
In CGAL halfedge data structure, operations are provided to access the prim
itives and to traverse the data structure. Although iterator and circulator are the
primal interfaces of these operations, users can directly use the incidental operations
of the halfedge to access and traverse the primitives of the data structure (shown in
Figure 2.3).
2.1.2 Representation of CGAL Polyhedron
A polyhedron is a 3dimensional solid bounded by not necessarily planar facets.
A polyhedron surface is a set of connected facets that bound a polyhedron. For
simplicity, we will use polyhedron instead of polyhedron surface throughout the thesis.
A polyhedron in CGAL is based on the halfedge data structure plus the ge
ometric constraints, internal data protections and high level operations (see Figure
2.4). CGAL polyhedron is also a template class of the halfedge data structure with
specific storage modelvector or linked list. To maintain combinatorial consistency,
A
Sprev on vertex()
\I \
\ \ I /
'\ /f ,opposite()
vertex() O
AHalfedge
I (facet() )
0 w O
Figure 2.3: Incidental operations of halfedges in the halfedge data structure.
a CGAL polyhedron only provides Euler operations as the modification interface (a
subset is shown in Figure 2.5).
2.2 CatmullClark Subdivision
CatmullClark subdivision[1] is an algorithm for i,. ,i,, bi generating
limit surfaces. In each pass, the algorithm generates more regular vertices, which are
valence 4, and consequently approaches the limit surface. For regular meshes that
have only regular vertices, the algorithm generates a standard Bspline surface with
C2 continuity. For irregular meshes, it generates a sequence of standard Bspline
surface rings with C2 continuity except at the extraordinary vertices.
After each pass of the CatmullClark subdivision, the result mesh is formed
by a new set of vertices. Classified by the subdivision rules and the connectivity
relation with the previous mesh, there are three types of the vertices in the refined
mesh: facet vertices, edge vertices, and vertex vertices.
Polyhedron
* Combinatorial Integrity Vertex Halfedge Facet
* Handles, Iterators, Circulators
Halfedge Data Structure
* Storage Type Vertex Halfedge Facet
* TypeSafe Pointer
Primitive Bases
* Geometry Information
* User Defined Information Vertex Base (Halfedge Base Facet Base
* Void Pointer
Figure 2.4: Structure of CGAL polyhedron.
. ..
Q. AU
split_facet(hl, h2)
join_facet(h)
.<0.
h
split vertex(hl, h2)
join_vertex(h)
Figure 2.5: Only four Euler operations are shown here
hl
o0
vrO
h
0 4 O
Denote the input mesh as 0mesh and the mesh after the dth pass be dmesh.
To generate the dmesh, the 0mesh needs to be refined d times generating the new
geometry data and build the refined connectivity.
To generate the geometry data of the vertices of d+mesh, which is refined
from dmesh, CatmullClark subdivision has the following rules shown in Figure 2.6:
Facetvertex FVd+ = the average of all vertices surrounding the corresponding
facets Fd of dmesh.
Edgevertex EVd+ = the average of the midpoints of the corresponding edges
Ed of dmesh with the average of the two facet vertices of d+mesh whose
corresponding facets share the corresponding edges.
Vertexvertex
Q 2R S(n 3)
VVd+ = + +
n n n
where
Q = the average of the facetvertices of all facets adjacent to the vertex
V.
R = the average of the midpoints of all edges incident on the vertex V.
S = the corresponding vertex V.
n = the valence of the corresponding vertex V.
To build the connectivity of d+mesh, CatmullClark subdivision has the following
rules:
Connect each facetvertex to the edgevertices of the edges surrounding the
facet.
Connect each vertexvertex to the edgevertices of the incident edges of the
vertex.
d mesh
CatmullClark
Subdivision
d +mesh
(a) Facetvertex rule
vl
fv 1 EV fv2
fl E f2      
v2
(b) Edgevertex rule
fvy1 ev1 fvn
fl e1 fn     
V I VV
ev2 evn
f2   ...
fv2
(c) Vertexvertex rule
O Geometry data
Newly generated vertex
Newly generated edge
Figure 2.6: CatmullClark subdivision.
FV
2.3 Patching CatmullClark Meshes
2.3.1 Overview of PCCM
Patching CatmullClark Meshes(PCCM) [5] creates a set of large, smoothly
joining bicubic NURBS patches from an input mesh consisting of all foursided facets.
The PCCM algorithm transforms each facet of the input mesh to a bicubic NURBS
patch. The patches forming the output surface join parametrically C2 except at the
extraordinary patch corners where they join with C1 continuity.
The PCCM algorithm consists two procedures of generating the PCCM mesh
from the input mesh. Mesh refinement, the first procedure, refines the input
mesh, called Imesh in the modeling system, to an Omesh. An Omesh consists
a set of submeshes, called qmeshes, that onetoone map to the facets of the I
mesh(see Figure 2.7). Each qmesh can be transformed to a quadan array containing
(2i + 1) x (2i + 1) entries, where i > 2. These array entries store the positions of
the vertices of the corresponding qmesh. To generate the Omesh, we use Catmull
Clark subdivision as the refinement algorithm. The number of the passes of the
subdivision, denoted as i in previous equation, defines the size of the quad arrays.
Since the patch transformation, the second procedure of the PCCM algorithm,
accepts the quad arrays with arbitrary geometry data, the geometry rules of the
CatmullClark subdivision are not mandatory and users can directly manipulate the
vertices of the Omesh.
Patch transformation uses a quad structure initialized from Omesh as the
input data to generate the control nets of the patches forming the PCCM surface
and ensures the boundary continuity across the patches. The transformation consists
of two stepsknot insertion and corner smoothing. The first step ensures C2
continuity across the boundary of the patches except for extraordinary corners. The
second step ensures the C1 continuity around the extraordinary corners. After patch
14
u: 3 0 3 6 3 0
0
3 ...
30
3
6
03 33
3
3 ........................ .. .... ... .......... ........... ............ ........ ............
00 30
0
3
3 ...................................................
Figure 2.7: The Omesh consists of a set of connected qmeshes(shaded area). Each
qmesh subdivides an IMesh facet(blue rectangle). The Imesh corresponds to heavy
black lines. The initial data of the quad array corresponds to the positions in the
qmesh. A quad array contains (2i+ 1) x (2i+ 1) control points indexed by the Greville
abscissa which are scaled by 3.
transformation, the quad array contains (2i + 5) x (2i + 5) NURBS control points
and would be input to gluNurbsSurface[9].
2.3.2 Patch Transformation
After refinement of the Imesh, we will have the Omesh structured as shown
in Figure 2.7. Each quad, or Pmesh, corresponds to a facet in the Imesh, and is
a submesh of the Omesh. The quads surrounding a corner point, a vertex in the
Imesh, are arranged in counterclockwise order indexed by i, and the nodes Puv(i) is
the uv node of ith quad. The double subscripts uv are the Greville abscissa, scaled
4  
2     .               .  
0
1
2
4
4            
2     : I
4   
2   I
i''''''''7 'T y    
01 11 21 41
Figure 2.8: PCCM mesh: the enlargement shows the indices of the control points
relevant for corner smoothing. Different corners have different orientation which is
significant to the indices. The shaded area indicates the control points used and
modified for corner smoothing.
by 3, of the PCCM surface. After the knot insertion of the PCCM transformation,
the refined mesh, called Qmesh, looks like in Figure 2.8. The same indexing of
the Pmesh is used for the Qmesh except it is denoted by Quv(i) and the double
subscripts uv are no more scaled by 3. The mesh without extraordinary vertex will
stay unchanged after the corner smoothing, which is mandatory only when the corners
of the quad are extraordinary vertices.
After the transformation, the result mesh is called PCCM mesh It can be
evaluated as the control points of a set of NURBS patches. These NURBS patches
form the PCCM surface and are C2 continuity everywhere except at the extraordinary
patch corners where are C1 continuity.
Required Omesh Connectivity
An Omesh consists of a set of chess board submeshes of equal size that
contain at least (5 x 5) vertices. These submeshes should only intersect to each
other on the boundary and cover the whole Omesh. Each submesh plus one ring of
the facets surround it corresponds to a quad array in the PCCM mesh. Figure 2.7
shows an example of an Omesh.
Knot Insertion
For each quad, we initialize the array with the qmesh which is one ring larger
than the submesh inside the corresponding facet boundary: we borrow one layer of
nodes from all direct and diagonal neighbor submesh(shown in Figure 2.7).
To make each quad into standard interpolating form of an order 4 NURBS
patch with uniform knots sequence, we insert three knots for Q1, Q2, and Q4first
at u direction and then insert other three knots at v direction. The new points Qui
are obtained from the old points Pui via
Qo = (P3 + 4Po + P3)/6
Qi = (2Po + P3)/3
Q2 =(Po + 2P3)/3
Q4= (2P3+ P6)/3
All remaining Q3i,3j = P3i,3j, except for the corner point Qoo which we place
directly on the CatmullClark limit surface:
E nPoo (i) + 4P30( )+P33(i)
Qoo = 4P3o(i) + P33(i) where n is the valence of the corner point
n(n + 5)
Corner Smoothing
To obtain the tangent continuity instead of position continuity at the extraor
dinary corners, we need to modify the control points at the corners. The enlargement
of Figure 2.8 shows the relevant double subscripts of Qmesh after knot insertion.
We define, for every n, two n by n matrices A, and B, with rows i = 1,... n
and columns j = 1,... n and entries
2a 2
A,(i,j) = cos( (i j)) a = 1(default) and
B (1)
B (1)j 2nij( )J1/n if n is even,
nij = mod (n + i j, n).
We collect the points Quv(i) E R3 generated by Knot Insertion for i = 1,... ,n and
uv {00, 10, 20, 40} into Quv E RnX3. Only if n is even and greater than 4, do we
compute r = (1)Q40(i)/n and if r / 0 we add, for each i, hi = l)r
to Q40(i) = Q04(i 1), 41(i) and Q14(i 1) so that E~ (1)i4o(i) = 0 and
Q40(i) = (Q41(i)+ 14(i 1))/2. Otherwise all coefficients remain unchanged except
Qio = Qoo + AnQo,
Q2o = (40 + 6Qo0 2Qoo)/5,
11 = Bn (Qi + c(2/) (40 Q20))
6
For = 1,... ,n, we copy Qvo(i+ 1) = Qov(i) for v {1, 2, 4} and add Q20o(i) 20o(i)
to Q21(i) and Q1(i 1).
CHAPTER 3
DESIGN OF THE REFINEMENT ALGORITHM
To build the required Omesh connectivity, we use the CatmullClark subdi
vision as the refinement algorithm since it is widely implemented and used in current
modeling systems. My design separates the connectivity and geometry rules in order
to add more flexibility of changing the geometry rules dynamically.
3.1 Design Issues
There are three goals of the design. First, the subdivision function must be
able to apply to any user extended CGAL polyhedron. Second, the user can change
the geometry rules of the subdivision by simply replacing the rule object. Third, the
subdivision function must support a hierarchical polyhedron that allows tracing the
relation of the primitives in different layers of the subdivided polyhedron.
3.1.1 User Extended CGAL Polyhedron
To fulfill this goal, the subdivision is implemented as a template class in C++.
Users can instantiate the subdivision class with their own specialized polyhedron class
as the template parameter. The only requirement on the user extended polyhedron
is that it must support a subset of Euler operations with the same interface(function
names) as them in the CGAL(see Figure 2.5).
3.1.2 Geometry Rules
To give the users more control of the shape of the Omesh and PCCM mesh,
users are allowed to extend the subdivision with different geometry rules. By plugging
new geometry rules classes when calling the subdivision function, users can easily
add more feature controls on the Omesh. For example, blend ratio which controls
the edge on the surface is one good feature that users can add to the subdivision
implementation.
To achieve this goal, I template the subdivision functions of the subdivi
sion class. A generic subdivision functioncalled quadralize _polyhedron in our
implementationin the subdivision class accepts a RULE class as the geometry rules.
Two rule classes are currently supported. One is the average ruleevery new gen
erated vertex is the average of all its incident vertices in the previous layer. The
other is the standard CatmullClark rule that I mentioned in the previous chapter.
Both rule classes provide three operations vertexvertex rule, edgevertex rule and
facetvertex rule. These three operations are mandatory for all user defined classes
of the geometry rules.
3.1.3 Hierarchical Subdivision Polyhedron
For PCCM, users need to collect the geometry data of the vertices into their
corresponding quad (see next chapter) before transforming the patches. To collect
the data, the system need some functions to trace back the hierarchical relation of the
primitives between different layers of the subdivision polyhedron. For instance, given
a vertex of layer i, the tracing function should return the corresponding vertex of
layer i + 2. By building a 1y.p l,, .,ron container, called mipmap polyhedron, which
stores the subdivided polyhedron through the subdivision process, we can ;i,,i'l. ;tti,
make the tractability available by storing the primitives in a specific order.
A mipmap polyhedron is a simple vector which stores the sequence of the
subdivided polyhedrons(see Figure 3.1). Every time the mipmap polyhedron gets
subdivided, it adds a new layerthe subdivided polyhedron from previous layerat
the end of the vector. Hence, for an ntimes subdivided mipmap polyhedron, it has
n + 1 7,,, , stored in the vector and the initial 1.~ 1;1,, ,Jron is at 7.'1, 1 0. To support
tracing operations, we can build the tracing table that ,1 i/. ';tl registers the primitive
Mipmap Polyhedron
I Vertex List PO Layer 0
S+ : Edge List Subdivision
Tracing I Facet List
Operations Layer
uPl Layer 1
I : Subdivision
Figure 3.1: A mipmap polyhedron consists of a list of polyhedrons starting with the
input polyhedron Po. A polyhedron Pj+i is subdivided from the polyhedron P in
the mipmap polyhedron. Each polyhedron contains three primitive lists. The shaded
areas in the primitive lists indicate the newly generated primitives by the subdivision.
relation for every two layers in the mipmap polyhedron. Or we can i',, lI. Itll decode
the tracing information by encoding the newly generated primitives with a specific
storage scheme. Considering the saving of memory space and slightly sacrificing the
speed, I chose the implicit scheme as the solution to support the tracing operations.
The implicit scheme requires a specific storage order for initial and newly
generated primitives. In any user extended CGAL polyhedron, these primitives are
stored in three separate lists or vectors (vectors have speed advantage over lists)
vertex list, edge list (edge is represented by 2 consequently stored halfedges) and
facet list(see Figure 3.2(a)). After one step of CatmullClark subdivision, all the
newly generated primitives will be added at the end of each list and have the same
storage order as shown in the Figure 3.2(b). We call this storage scheme CC scheme
since it is specific to CatmullClark subdivision.
Definition 3.1 A primitive list can be represented as a string of indices of the
primitives. For the p'.'ili ron of 'ii,, I in the mipmap p. 1',1, iron, VLi, ELi, and
FLi are the vertex, edge and facet list of the y.1'.l;h, Jron and #vi, #e6 and #fi are
vertex list (size = v) edge list (size = e) facet list (size = f)
1 2 ... v 1 2 ... e 1 2 ... f
(a) Normal state
vertex list (size = V = v + e +f)
1 2 ... v 1 2 ... e 1 2 ... f
1 2 ......... V
edge list (size = E = 2e + 4f)
1 2 ... e 1 2 ... e 1 1 1 1 2 2 2 2 ... f f
1 2 ......... E

_' facet list (size = F = f+ 3f)
12 ... f 111222 2 ... f f f
1 2 F
 (b) After onestep subdivision
(b) After onestep subdivision
Figure 3.2: The storage state of the primitive lists.
Table 3.1: Tracing operations: the input of the tracing operations is the index of the
primitive and the output is the index of the corresponding primitive or a set of the
primitives.
the size of each list. A primitive list with CC scheme has following storage state
with the tracing operations defined in Table 3.1,
AL = {VV2. } subdivision VLI+ = VLI O ELi o FLi
ELi = {eie2...e } subdl"soi ELI+ = ELi o EL o FL4
FLi = {flf2 ...f##f} subision FLI1 = FLi o FLI
where FLn = {fofo...fo fl...f#f
n
o is the string concatenation.
Definition 3.2 If a p 1,1il, iron Ps subdivided from a p 1,1il, iron P stores the prim
itive lists ... ni jtin CC scheme, Ps and P are CC scheme compatible and have
complete tracing relations between them.
For a mipmap polyhedron of depth L, we define the tracing operations for
layer I as 'trac(pi) + pi+l' and 'trac(pi) + pl' where pi is the primitive index of
layer I and 0 < I < L.
There are 2 categories of the tracing operationuptracing and down
tracingand each category has six operations (see Table 3.1).
1. Uptracing operations
UpTracing DownTracing
Upvv(Ul) Vl+1 '" "'" (Vl) Vl1
], r'' f (vi)  e_1
l,,,,',, f(vi) + fii
upe"(C) + v{i+1,'i } (ci)  ef_1
upfv(fi) vi+ downff(fi) fi_1
upfe(fi) f {el+1,el+i + 1, el+i + 2, el+ + 3}
upff(fi) {fi +, fJ'+1, fJ+l 1, fi I + 2}
(a) upvv(vi) > v+1 : vi+l = vi
(b) upev(el)  v+1 : vl+l = el + #vi
(c) upee(el) {ie+1,e' 1} : el+1 = el, e l = el + #el
(d) Upfv(fi) v1+1 : v1+1 = fi + #vi + #e
(e) upfe(fi) {ei+l, e+1i + 1, ei+1 + 2, ei+1 + 3} : ei+1 = el + #el + #e
(f) upff(f/)  {f+i, fl+1, f+1 + f1+1 + 2} : fl+1 = fl, fl = fi + #fi
2. Downtracing operations
(a) downv,(vi) > vi1 : v1 = vi
(b) downve(v ) > e_ : 1el1 = vl #1_1
(c) downvf(vi) fi : fi1 = vi #il1 #el1
Sezi, if el < #el_1
(d) downee(el) el1i = #ei, if e #e_
ei #ei 1, if e > #ei1
(e) downef (el) fi 1: fi = (ei #ei1 #ei)/4 + 1
(f) down(fi) f f, Iif :f < #f f
(ft #fi1)/3 + 1, if fi > #fji
3.2 CatmullClark Subdivision with CC scheme
To make the subdivided polyhedron CC scheme compatible in the modeling
system, the subdivision algorithm first ..'/,'i the initial polyhedron P, to the sub
divided polyhedron P1+1 and preserves the index order of the primitives. This step
ensures
VLi+1 = VLi
ELI+1 = ELi
FLi+1 = FLi
Then, following the sequence of the edges stored in the edge list, add an edge vertex
on each edge. Adding the edge vertex on a edge is equivalent to splitting the edge
into two edges. Hence, the new edge is onetoone mapped to the split edge. So far
the lists become
VLi+1 = VLi oELi
ELI+1 = ELi o ELL
FL+1+ = FLi
Next step, the algorithm quadralize the facets following the sequence of the facets
stored in the list. For each facet, it randomly select two neighbor edgevertices and
connect them with a new edge. On this new edge, it add a new facetvertex and then
connect the new vertex to all remaining edgevertices around this facet. After this
step, the primitive lists have one new vertex, four new edges and three new facets
stored with facets storing order. Now, the lists become
VL1+1 = VLi o ELi o FLi
ELi+1 = ELi o ELi o FLf
FLi+1 = FLi o FL
and all the CC scheme operations are well defined.
Algorithm 1 shows the pseudo code for this procedure. addVertex() and
addEdge () can be implemented by using the Euler operations described in Figure
2.5.
Algorithm 1 CatmullClark subdivision with CC scheme
Require: input polyhedron (Pi1)
Require: output polyhedron (P1)
Ensure: CC scheme primitive lists (VLI, ELI and FLi) in Pi
P1 = P_1
for i = 1 to size(ELI) do
addVertex(EL [i])
end for
for i = 1 to size(FLI) do
vertex vl, v2 = randomly selected edge vertices of FLi[i]
edge e = addEdge(vl, v2)
vertex v = addVertex(e)
addEdge(v, all remaining edge vertices)
end for
CHAPTER 4
DESIGN OF INTERACTIVE SURFACE MODELING
For an interactive modeling system, real time feedback is the basic require
ment. To fulfill this requirement, the system needs a surface representation that not
only provides a smooth surface but also can locally update a deformed region of the
surface. In this chapter, I will introduce a new data structurequad polyhedronto
be the surface representation and illustrate how to implement the PCCM algorithm
and the local update of the surface using the new data structure.
4.1 Design Issues
PCCM surfaces consist of a set of smoothly joining NURBS patches; hence,
users can manipulate the control points of the meshes that reprented the PCCM
surfaces to sculpture the surface. But this direct manipulation on the control points
might destroy the smoothness condition across the boundaries of the patches. Instead
of manipulating the PCCM mesh, the system will only allow users to manipulate the
Omesh and "rePCCM" the Omesh in order to enforce the smoothness conditions.
To acheive the realtime feedback for an interactive system, we cannot afford to re
PCCM the complete Omesh. Hence, the update region decided by the manipulation
region must be restricted as small as possible yet still maintains the smoothness
condition across the boundaries.
The goals of my design will be as follows,
1. Maintain the smoothness condition: the patches should join paramet
rically C2 everywhere except at the extraordinary patch corners where they
should join with C1 continuity.
2. Minimize the update region: only rePCCM and update the smallest region
that maintains the smoothness conditions.
4.2 Quad PolyhedronHalfedge Data Structure + Quad
The PCCM algorithm can be naturally implemented with an arr ill.i,, data
structurethe quad map[5]. But considering the requirements of the interactive
system and the deficiencies of quad map listed below, an extended data structure
the quad polyhedron will be introduced.
4.2.1 Quad Map
A quad map contains a quad list storing the geometry data and a vertex
list supporting the connectivity of the represented mesh. Each quad in the quad list
stores a (2' + 5) x (2' + 5) array, where i is the number of passes of CatmullClark
subdivision and i > 2, containing the geometry data of the vertices. The state of
valid entries of the array will be varied along the PCCM transformation(see Figure
4.3). Each entry in the vertex list stores the indices of incident quads and the corner
index of the incident quad corresponding to this entry.
A quad map can be used to implement the CatmullClark subdivisionand then
as the input of the PCCM transformation. The initial state of each quad contains
a 4 x 4 array centered in the quad array. The initial array maps to the submesh
centered to the facet of the input mesh which has only foursided facets. After itimes
subdivision, the size of array grows up to (2' + 3) x (2' + 3) and has the valid data to
proceed PCCM transformation. By enlarging the array to (2' + 5) x (2' + 5) in order
to reserve the space for newly inserted knots, the structure is ready for PCCM.
PCCM with this structure consists of two potentially parallel steps:
a. For each quad, apply Knot Insertion.
b. For each extraordinary mesh node, use the vertex list to
collect Qoo(1) and Qv(i), uv e {10, 20, 40}.
compute Quv(i), uv E {10, 20, 11}, Q20 2o and possibly Q40 40.
distribute Quv(i), uv E {10,01,20,02, 11} and add to {21, 12} and possibly
{04,40,14,41}.
The quad arrays can be input directly to gluNurbsSurface or displayed as the quad
mesh.
There are some disadvantages in using the structure for PCCM:
Weak connectivity information.
Different orientation of the indices for different corners.
Need to collect and distribute the data.
A quad array is the smallest updating unit.
The first two disadvantages make the code hard to implement and extend.
The last two cause the inefficiency of the transformation and updating.
4.2.2 Quad Polyhedron
Considering the disadvantages of the quad map, I build a new data struc
ture, named quad polyhedron, which combines the quad structure and the CGAL
polyhedron(see Figure 4.1).
Each facet in the quad polyhedron is a quad array just as it in the quad map.
The initial quad array contains the vertices in the submesh corresponding to the
facet of the Imesh. The halfedges in the quad polyhedron not only maintain the
connectivity of the Imesh but also a corner view and a shadow array corresponding
to the incident corner of the halfedge. The corner view is an index reference array that
does not store any valid geometry information but redirects the access to the actual
position in the quad array. It works like an index mapping function for quad arrays.
By using the corner view, accessing to the four corner regions of the quad array can be
simplified to the same index orientation that is consistent to the incidental halfedge.
The size of corner view is one quarter of the quad array and can be treated as an
independent transformation unit. The shadow array has the same size as well as
the same indexing scheme of the corresponding corner view, but it only exists when
incident corner is an extraordinary vertex. The shadow array is an internal buffer
which stores the geometry data right after applying knot insertion in quad array. It
is used to speed up the update of the PCCM mesh and localize the influence region
caused by corner smoothing.
The first step of the algorithm to build the quad polyhedron is to build the
same connectivity of the Imesh. Then it initializes the quad array associated with
each facet in the quad polyhedron. The initialization can be done parallelly for all
quad arrays.
Assume that we have an Imesh IM generated form the input mesh I and a
quad polyhedron QP having the same connectivity of IM. After locating facets F, in
I, F,, in IM and Fqp in QP by traversing the corresponding facet lists concurrently,
we can initialize the quad array of Fqp by using the CC scheme operations and
polyhedron traversing operations.
To initialize the quad array of Fqp, my algorithm first locates the center vertex
and the corner vertices of F,,. Since the IM was itimes subdivided from I, all the
center vertex and the corner vertices can be traced by CC scheme operations on F,.
After locating the center vertex and the corner vertices, the algorithm sw. 1,.1i ,', ,
the orientation of the facets (F, and F,,) by matching the corner vertices in F, and
Fi,. It then defines a pivot edge that always points to the first corner vertex in
F,,. By traversing the IM starting with the pivot edge, the algorithm collects the
 Shadow array
~~OZ NY[0
 0Z 0 1 0
fO
)4
11 11 21
1) 10 20 40
 Comer view
Figure 4.1: Each facet in the quad polyhedron contains a quad array that has four
corner views associated with each halfedge. The orientation of the indices in the
corner view is consistent with the halfedge. A shadow array is only associated with
the extraordinary corner and has the same size and indices of the corresponding
corner view.
O 
I T
0
geometry data into the center region of the quad array. This procedure is shown in
Figure 4.2.
Algorithm 2 Building Quad Polyhedron
Require: facet list in input mesh I: FLi
Require: facet list in Imesh IM: FLim
Ensure: facet list in quad polyhedron QP: FLqp
Build QP from I with the same connectivity
for i = 1 to size(FLi) do
vertex cv = downf,(FLi[i])
{v1, Vv 2, V 3, V {lst,2nd,3rd,4th} corner of FLi[i]
{viT1n, vi2, Vim3, Vi 4} = Il'l {1, v V U4})
vim = the corner vertex traversed from cv by up and then left.
synchronize the orientation between FLi[i] and FLim[i] by matching vim and
{V V 3, V
locate pivot edge pe that points to the corner vertex matching vim
travse the submesh started from pe and collect the data into quad array of
FLqp[i]
end for
Each quad array can be processed by PCCM transformation in parallel. The
first step of PCCM algorithm applys the knot insertion in each quad array. First, it
vertically and then horizontally scans and inserts new knots in the quad array. It then
circulates the edge around each vertex using traverse functions of CGAL polyhedron
and inserts the new value of corner knots. Since the corner views associated with
each edge give us the unified accessing to the knots, the corner insertion can be very
simple without synchronizing the orientation of indices. Figure 4.3 shows the change
of the region of the valid data in the quad array through different steps of the knot
insertion. In the second step of PCCM algorithm, it applys the corner smoothing in
the vertex list and skips the ordinary vertices. Similar to the corner insertion, it uses
the vertex circulator around the extraordinary vertex and the corner views to directly
access the necessary datait does not need to collect and then distribute the data
as the quad map does. Before applying the corner smoothing, for each corner view
associating the extraordinary vertex, the algorithm preserves the state of the corner
.
Quad Polyhedron
Quad:Arfay .. 
/ '' \
        
./ \
/
/ :::: \
/ :::: \
: 4 . . . . . . . . . . . . . . . . . ..  :
     1           
 /,
\ .. / .
, : : /
: ^ : ^ :
... x 
7^7
. . . ...
. 1. . : ..
:
\\ 
x
Comer Vertex
/
0mesh
* Pivot edge .
I
       .. . ; . . . . .
       
Read in the data
Figure 4.2: Initialization of the quad polyhedron: only the shaded region in the quad
array has valid data after initialization and the valid region will grow up to whole
array after the first step of the PCCM transformation.
2time subdivision
;7
S I_ .. . . I ; I. .
Imesh
Vertical Pass
Pu Qu
3 0 3 6 3 03 0 1 2 4 6 4 2 1 0
3 3
0 0
3 3
Pv 6 Pv 6
3 3
0 0
3 3
Horizontal Pass
Qu Qu
0 1 2 4 6 4 2 1 0 0 1 2 4 6 4 2 1 0
0 0
1 1
4   4   
Qv 6 Qv 6
4 4
2 2
1 1
0 0
0 0
Corer Insertion
Figure 4.3: Knot insertion: the shaded area indicates the valid data.
view by storing it in the corresponding shadow array. Since the shadow array has the
same size of the corner view, the preservation only needs to call the copy operation
from the corner view to the shadow array.
4.3 Interactive Modeling with PCCM
For each facet f, of the input mesh, exists a corresponding submesh fmi in the
Imesh, called fmesh. frmi is a (2d + 1) x (2d + 1) array centered by the facet vertex
FLi of fi, where d indicates the number of passes of the CatmullClark subdivision.
Algorithm 3 PCCM using quad polyhedron
Require: initialized quad polyhedron: QP
Ensure: smoothly joining patches
for each quad array QA in QP do
apply vertical pass of the knot insertion
apply horizontal pass of the knot insertion
end for
for each vertex v in QP do
apply corner insertion of the knot insertion
update all corresponded corners in quad arrays
end for
for each vertex v in QP do
if v is an extraordinary vertex then
apply corner smoothing in v using operation of the corner view
end if
end for
For fmi, I define a qmesh qmi as the submesh that is one layer of the facet larger
than fmi. Each qmi has a corresponding quad array qi of the quad polyhedron and
the vertices of qmT specify the initial data in q;. Figure 4.4 illustrates these definitions.
Apparently, any modification of the vertices of qmi will invalidate qi and trig
ger the updating of the corresponding patch. However, since the intersection of all
qmeshes of the Imesh is not empty, any change of a single vertex might cause the
update of several quad arrays.
To make the update region as small as possible, I equally divide the quad
array into four subarrays adjacent to the center vertex and make these subarrays
the update units for the update procedure. I call these subarrays corner quads since
each of them associates with a corner vertex of the quads.
 corer
 facet
corer vertex
...
Omesh:
quad
initialization
 facet vertex
fmesh
qmesh
Figure 4.4: Relations between Imesh, Omesh and quad polyhderon.
Imesh
2times
subdivision
My update procedure is defined by two mapping functions:
ki:V C
cs : C EV
where V is a set of the vertices of the Omesh,
C is a set of the corner quads of the quad polyhderon,
EV is a set of the extraordinary vertices of the quad polyhedron.
Figure 4.5 illustrates the functionality of ki and cs functions in the interactive
modeler.
4.3.1 Effect of Knot Insertion
For each qmesh, I define nine exclusive equivalent sets of vertices, called in
fluence region, which are classified into three types V region, E region, and F
region(see Figure 4.6). Each region contains a set of vertices and affects a set of cor
ner quads that define the update region. All vertices belonged to the same influence
region should define the same update region.
Definition 4.1 Primitive meshes and regions
V mesh: a ring of incident facets to the corner vertex.
E mesh: a 3 x (d2 3) array along the quad edge. The center of the region
resides in the center of the quad edge.
F mesh: a (d2 3) x (d2 3) array centered inside the fmesh.
V region: the vertices in the V mesh.
E region: the vertices in the E mesh.
* F region: the vertices in the F mesh.
         i
 PCCM ..:.. I...:..:. .. NURBS
Transformation .... ... ..:. Evaluation
OMesh PCCM Mesh PCCM Surface
t Interactive Modeler t
No, Local
Surface Update
Scorner smoothing
Figure 4.5: Interactive Modeler
U F Region
Comer Quad
Figure 4.6: For each quad, there
four E regions and one F region.
 IMesh
OMesh
are nine exclusive influence regions four V regions,
V Region
E Region
For a set of manipulated vertices V = {vi, v2, ..., Vn, we define
ki(V) = ki(vi) U ki(v2) U ...ki(vn).
Let RV = {vl, v2, ..., v,} be one of these region vertex sets and a function
rv(v) = RV, if vertex v in the Omesh e RV.
Since ki(RV) = ki(vi) U ki(v) U ...ki(vn) and ki(v) = ki(v) = ... = ki(vn), then
ki(RV) = ki(v), where v i RV.
Hence,
ki(v) = ki(rv(v)) = ki(RV).
Definition 4.2 ki function
ki(v) = ki(rv(v)) = ki(RV)
= the set of overlapped corner quads.
ki({v, ...,Vn}) = ki(vi) U ki(v2) U ...ki(vn).
ki(V region) = all corner quads that are adjacent to the corner vertex.
ki(E region) = four corner quads that are adjacent to the quad edge.
ki(F region) = four corner quads v,,i.i 11;, up the corresponding quad.
Figure 4.7 details each influence region. For the twopass knot insertion, an F
region sits inside the center of the submesh and intersects four corner quads making
up the quad. Four E regions sit along the four edges and each intersects a pair of
corner quads of two incident quads. Four V regions sit around the four corners and
each intersects all corner quads around each corners. For corner insertion, since we
need all P3 around the Po and Po itself, the influence region covers all these needed
knots and has the same intersection as the V region in twopass knot insertion.
0 3
6 3
6 3
6 3 0 3 6
I
0 3
7
. . . . . ~~   .. .. . . . .
. . . . . ~~   .. .. . . . .
6 3 0 3 6
I
U F Region
Quad
E Region
 Sub Quad
V Region
PreMesh
Figure 4.7: Influence region of knot insertion: (a),(b),(c) indicate the three different
influence regions caused by the twopass knot insertion. (d) indicates the influence
region caused by the corner insertion.
i i
    .. .         .     
                
4.3.2 Effect of Corner Smoothing
For an extraordinary vertex of valence n, there are n corner quads around the
vertex. If any one of these corner quads gets updated by knot insertion, every one in
these corner quads need to be updated by corner smoothing.
Definition 4.3 cs function
For a set of corner quads CQ q= {,q2, *..., qm}
Sc() the corner vertex cv of q if cv is an extraordinary vertex.
S0c otherwise.
cs(CQ) = cs(ql) U cs(q2) ...cs(q,).
Let CQ = {ql, q2, ..., q } be the update region of knot insertion, cs(CQ) re
turns a set of extraordinary vertices EV. Then we update the corner quads around
the vertices in the EV by applying corner smoothing on EV. To speed up the updat
ing, we use shadow arrays that preserve the Qmesh data before corner smoothing
instead of applying the quad initialization and knot insertion on the corner quads
that are not in the CQ.
4.3.3 Algorithm for Local Updating
Algorithm.4 gives us the systematic look of how to use the functions we defined
in previous sections to locally update the PCCM surface.
Algorithm 4 Local updating
Require: modified vertices MV = {mvi, mv2, ..., n}
Ensure: smooth PCCM surface
corner quads CQ = ki(MV) = ki(rv(mvi)) U ki(rv(mr2)) U ...ki(rv(mTV))
for each corner quad q in CQ do
initialize q from the modified Omesh
apply knot insertion on q
update corresponding shadow quad
end for
extraordinary vertices EV = cs(CQ)
for each vertex v in EV do
apply corner smoothing on v using shadow quads around v
update corner quads around v
end for
update the PCCM surface
CHAPTER 5
CONCLUSION AND FUTURE WORK
5.1 Conclusion
In this thesis I presented an extension of the PCCM algorithm supporting
the interactive manipulation of the surface. To make this PCCM algorithm and its
extension easy and efficient, I designed the quad ,p.Ih,, ,ron and applied it to the
implementation.
This thesis introduced a simple encoding/decoding scheme, the CC scheme,
that helps to trace the primitives relation of different level in a sequence of Catmull
Clark subdivided polyhedrons. I also presented a specific CatmullClark subdivision
algorithm for generating the CC scheme compatible subdivided polyhedron. Using
the tracing operations supported by the CC scheme, I introduced an initialization
algorithm for the quad polyhedron. And then by applying PCCM transformation,
we generate the PCCM surface represented by the quad polyhedron.
Finally, this thesis talked about the interactive modeling PCCM surfaces. I
define an influence region as a set of manipulated vertices in the Omesh. Influence
regions localize the update region of the PCCM mesh and surface and hence make
the interactive modeling possible.
Figure 1.1 illustrates the result mesh/surface of the different steps in my sys
tem. Figure 5.2 and Figure 5.3 show the resulting surfaces of interactive modeling.
Initial mesh / Input mesh
IMesh after one step subdivision
Omesh
PCCM mesh PCCM surface
Figure 5.1: Examples of the different steps of the surface modeling.
IMesh
Figure 5.2: Omesh and interactive modeling surfaces.
Figure 5.3: An example of modeling surfaces.
5.2 Future Work
Much more work remains to be done to build a userfriendly interactive mod
eling system. Future work might include using the extension of LeSS(localized
hierarchy surface splines) [2] to support finer control of the surface, designing the
boundary rules for the PCCM transformation and extending the manipulation to
change the genus of the object.
Another avenue of exploration, virtual tools are to be explored in my system.
Currently, my system only supports a vertex displacement tool. Other virtual tools
like edge sharpening, facet twisting and extrusion remain to be implemented. And
the intuitive operations that do not require high precision are also good candidates
to be supported in future system.
REFERENCES
[1] E. Catmull and J. Clark. Recursively generated Bspline surfaces on arbitrary
topological meshes. Computer Aided Design, 10:350355, Oct 1978.
[2] C. GonzalezOchoa and J. Peters. Localizedhierarchy surface splines. In
S.N. Spencer J. Rossignac, editor, ACM S~, ,iumi'II on Interactive 3D Graph
ics, pages 715, 1999. http://www.cise.ufl.edu/research/SurfLab/papers/.
[3] Nicolai M. Josuttis. The C++ Standard LibraryA Tutorial and Reference.
AddisonWesley, Berkeley Califorina, 1999.
[4] Lutz Kettner. Algorithm library design. Class notes of comp 290001, U. of North
Carolina, Spring 2000. http://www.cs.unc.edu/kettner/courses/.
[5] J. Peters. Patching CatmullClark meshes. SIGGRAPH 2000 Conference Proceed
ings, pages 255258, 2000. http://www.cise.ufl.edu/research/SurfLab/papers/.
[6] Stefan Schirra, Remco Veltkamp, and Mariette Yvinec, editors. Computational
Geometry Algorithms Library online reference. 1999. http://www.cgal.org/.
[7] Bjarne Stroustrup. The C++ P,. .ii.,,,,i,,.i L.,.I,.,i AddisonWesley, Berkeley
Califorina, 3rd edition, 1997.
[8] K. Weiler. Edgebased data structures for solid modeling in curvedsurface en
vironments. IEEE Computer Graphics and Applications, pages 2140, January
1985.
[9] Mason Woo, Jackie Neider, and Tom Davis. OpenGL Pi., .i/,immii.i Guide.
AddisonWesley, Berkeley Califorina, 2nd edition, 1997.
BIOGRAPHICAL SKETCH
LeJeng Shiue was born on December 1st, 1972, in Keelung, Taiwan. He
received his B.S degree in electronic engineering from the National Taiwan Institute
of Technology in 1994. He joined the University of Florida in August 1999 and started
to pursue a master's degree in computer science. He is currently a research assistant
of computer graphics and surface modeling for Dr. Jorg Peters and worked as a
teaching assistant for the class of computer graphics in 2000. His research interests
include data structure, algorithm, computer graphics and surface modeling.
