1 Introduction 9
1.1 Poygonal Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Manifold Mesh Modeling . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Mesh Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 New Schemes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Polygonal Meshes 13
2.1 Euler Equation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Topologically Regular Meshes . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Manifold Polygons . . . . . . . . . . . . . . . . . . . . . . 18
2.2.2 Regular Platonic Meshes . . . . . . . . . . . . . . . . . . . 18
2.2.3 Regular Genus1 Meshes . . . . . . . . . . . . . . . . . . . 19
2.2.4 Regular Genuslargerthan1 Meshes . . . . . . . . . . . . 20
2.2.5 When Genus goes to Innity . . . . . . . . . . . . . . . . . 21
2.3 Topologically SemiRegular Surfaces . . . . . . . . . . . . . . . . 22
2.4 Curious Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 Graph Rotation Systems 25
3.1 Graph Rotation Systems . . . . . . . . . . . . . . . . . . . . . . . 26
3
3.2 Changing Topology with Graph Rotation Systems . . . . . . . . . . 29
3.2.1 Inserting or Deleting an Edge in a Graph Rotation System . 29
3.2.2 Topology Change with Edge Insert and Edge Delete . . . . 32
4 Mesh Data Structures 37
4.1 Preliminaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2 Data structures and topological validity . . . . . . . . . . . . . . . 40
4.2.1 Vertexbased data structures . . . . . . . . . . . . . . . . . 41
4.2.2 Edgebased data structures . . . . . . . . . . . . . . . . . . 42
4.2.3 Facebased data structures . . . . . . . . . . . . . . . . . . 45
5 Minimal Operators 49
5.1 A complete and sound operator set . . . . . . . . . . . . . . . . . . 50
5.2 Properties of Minimal Operators . . . . . . . . . . . . . . . . . . . 52
5.3 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.3.1 Background . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6 Efcient Implementation of Minimal Operators 59
6.1 Implementation on vertexbased data structures . . . . . . . . . . . 59
6.2 Implementation on edgebased data structures . . . . . . . . . . . . 60
6.3 Implementation on facebased data structures . . . . . . . . . . . . 64
7 Create Pipe and Cut Operators 67
7.1 Sequence of Minimal Operators . . . . . . . . . . . . . . . . . . . 69
8 NonIntuitive Nature of Topology Changes 71
9 NonManifold Looking Manifold Meshes 77
9.1 Introduction and Motivation . . . . . . . . . . . . . . . . . . . . . 78
9.1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.1.2 Algorithm Properties . . . . . . . . . . . . . . . . . . . . . 79
9.1.3 Main Results . . . . . . . . . . . . . . . . . . . . . . . . . 79
9.2 Previous Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.2.1 Overview of the Algorithm . . . . . . . . . . . . . . . . . . 82
9.3 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.3.1 Manifolds . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
9.3.2 NonManifold Conversion and Insight to Manifolds . . . . . 84
9.3.3 Crack Repair for Manifolds with Boundaries . . . . . . . . 88
9.4 Conclusion and Future Work . . . . . . . . . . . . . . . . . . . . . 89
9.4.1 Future Work . . . . . . . . . . . . . . . . . . . . . . . . . 89
10 Handle and Hole Improvement with Subdivision 93
10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.2 Topological Consistency and Subdivision Methods . . . . . . . . . 96
10.3 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
10.3.1 DLFL Structure . . . . . . . . . . . . . . . . . . . . . . . . 100
10.3.2 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
10.4 Conclusion and Future Work . . . . . . . . . . . . . . . . . . . . . 104
11 Corner Cutting Schemes 111
11.1 Introduction and Motivations . . . . . . . . . . . . . . . . . . . . . 112
11.2 Topological Operations and HandleFaces . . . . . . . . . . . . . . 114
11.3 HandleFace Reconstruction with Subdivision . . . . . . . . . . . . 117
11.4 Corner Cutting Schemes . . . . . . . . . . . . . . . . . . . . . . . 118
11.4.1 DooSabin Algorithm . . . . . . . . . . . . . . . . . . . . 119
11.4.2 A New Corner Cutting Algorithm with Tension . . . . . . . 120
11.5 Remeshing Algorithms for Corner Cutting . . . . . . . . . . . . . . 121
11.5.1 Remeshing Algorithm  1 . . . . . . . . . . . . . . . . . . 122
11.5.2 Remeshing Algorithm  2 . . . . . . . . . . . . . . . . . . 125
11.6 Implementation and Results . . . . . . . . . . . . . . . . . . . . . 127
11.7 Discussion, Conclusion and Future Work . . . . . . . . . . . . . . . 127
12 Remeshing and Subdivision Schemes 131
12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
12.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
12.3 Classication of Existing Subdivision Remeshing Algorithms . . . . 134
12.4 Topological Constraints . . . . . . . . . . . . . . . . . . . . . . . . 139
12.5 New Remeshing Schemes . . . . . . . . . . . . . . . . . . . . . . . 143
12.5.1 Pentagonalization Algorithm . . . . . . . . . . . . . . . . . 143
12.5.2 Pentagon preserving algorithm . . . . . . . . . . . . . . . . 147
12.6 Implementation and Results . . . . . . . . . . . . . . . . . . . . . 148
12.7 Conclusion and Future Work . . . . . . . . . . . . . . . . . . . . . 149
13 Extrusions & Stellations 153
13.1 Introduction and Motivation . . . . . . . . . . . . . . . . . . . . . 153
13.2 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
14 Interactive HighGenus Modeling 159
14.1 MultiSegment Curved Handles . . . . . . . . . . . . . . . . . . . 159
14.2 Introduction and Motivation . . . . . . . . . . . . . . . . . . . . . 159
14.3 Minimal Operators . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.4 Creating MultiSegment Pipes . . . . . . . . . . . . . . . . . . . . 165
14.4.1 Curved Handles . . . . . . . . . . . . . . . . . . . . . . . . 166
14.4.2 Face Morphing . . . . . . . . . . . . . . . . . . . . . . . . 166
14.5 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
14.6 Role of Subdivision . . . . . . . . . . . . . . . . . . . . . . . . . . 172
14.7 Discussion, Conclusion and Future Work . . . . . . . . . . . . . . . 174
14.8 Rind Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
14.9 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
14.10Previous Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
14.11Problem Description . . . . . . . . . . . . . . . . . . . . . . . . . 180
14.12Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
14.13Implementation and Testing . . . . . . . . . . . . . . . . . . . . . 187
14.14Remeshing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
14.15Conclusion and Future Work . . . . . . . . . . . . . . . . . . . . . 190
15 Very HighGenus Modeling 193
15.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
15.2 Wire Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
15.3 Column Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
15.4 Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
16 Fractal Modeling 195
16.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
16.2 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
16.3 Generalized Sierpinsky Polyhedra . . . . . . . . . . . . . . . . . . 198
16.3.1 Generalization of Mandelbrots Alternative Sierpinski Tri
angle Construction . . . . . . . . . . . . . . . . . . . . . . 198
16.3.2 Extension to 3D . . . . . . . . . . . . . . . . . . . . . . . 200
16.3.3 Sierpinski Subdivision Algorithm . . . . . . . . . . . . . . 202
16.3.4 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
16.4 Generalized Leibnitz Polyhedra . . . . . . . . . . . . . . . . . . . 207
16.4.1 Polyhedral Vertex Truncation . . . . . . . . . . . . . . . . 210
16.4.2 New Vertex Truncation Scheme . . . . . . . . . . . . . . . 212
16.4.3 Stone Wall Creation with Vertex Truncation . . . . . . . . . 215
16.5 Generalized Koch Polyhedra . . . . . . . . . . . . . . . . . . . . . 216
16.6 Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
17 Tiled Textures 219
17.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
17.2 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
17.3 Mapping Tiled Texture Images . . . . . . . . . . . . . . . . . . . . 225
17.4 Tiled Texture Image Synthesis . . . . . . . . . . . . . . . . . . . . 226
17.5 Implementation and Results . . . . . . . . . . . . . . . . . . . . . 227
17.6 Discussion and Conclusion . . . . . . . . . . . . . . . . . . . . . . 228
18 Progressive Renement with Topological Simplication 239
18.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
18.1.1 Previous Work . . . . . . . . . . . . . . . . . . . . . . . . 241
18.1.2 Topology Simplication . . . . . . . . . . . . . . . . . . . 242
18.1.3 Topological Simplication under Progessive Renement . . 243
18.2 Equidistance Surfaces to Simplify Topology . . . . . . . . . . . . . 245
19 Topologically Robust Mesh Modeling:
Concepts, Data Structures and Operations 249
19.1 Abstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
19.2 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
19.3 Testing topological validity . . . . . . . . . . . . . . . . . . . . . . 254
19.4 Conclusions and nal remarks . . . . . . . . . . . . . . . . . . . . 257
19.5 Proofs for Theorem 19.3.1 and Theorem 4.2.2 . . . . . . . . . . . . 260
Chapter 1
Introduction
One of the most exciting aspects of shape modeling and sculpting is the develop
ment of new algorithms and methods to create unusual, interesting and aesthetically
pleasing shapes. Recent advances in computer graphics, shape modeling and math
ematics help the imagination of contemporary mathematicians, artists and architects
to design new and unusual 3D forms [13].
One of the most notable artists of the last century, Escher, frequently applied
mathematical concepts to create drawings of unusual 3D forms [170]. With the ad
vance of computer graphics, many artists have begun to use mathematics as a tool
to create revolutionary forms of artworks. There currently exists many contempo
rary artists such as George Hart [10], Helaman Ferguson [9], Bathseba Grossman
[11], Brent Collins and Carlo S equin [22] who successfully combines art and math
ematics to create unusual sculptures. These mathematical sculptors, who have a
very noticeable presence in todays art scene, develop their own methods to model,
prototype and fabricate an extraordinary variety of shapes.
Unusual shapes are especially interesting for architectural design. Interestingly
shaped architectural structures are symbols of cities, regions, states, and even coun
tries. In fact, recent advances in computer graphics and shape modeling help the
9
imagination of contemporary architects to design new forms [13]. One most no
table contemporary example of interestingly shaped buildings that have become
symbols is Frank Gehrys Guggenheim Museum. The Museum, with its stunning
titaniumclad forms, has been credited with vitalizing an entire city and region of
Spain.
1.1 Poygonal Modeling
Polygonal modeling is the most widely used modeling approach in computer graph
ics applications. With the advent of subdivision surfaces, most users have converted
back to polygonal modeling to create control surfaces for subdivision schemes. It is
interesting to note that this popularity of polygonal modeling happened despite the
limited tools provided by commercial modeling systems (The users nd effective
uses of existing tools and share their experiences with other users by publishing
trade articles and books).
We believe that the popularity of polygonal modeling comes from one of its
underappreciated advantages over other modeling approaches. If the polygons are
not triangles or quadrilaterals, the faces are not geometrically welldened. With
geometrically illdened faces, selfintersection becomes meaningless. So, any
commercial system that allows general polygons does not check selfintersection
and avoids the cost of selfintersection computation which can considerably slow
down the application during interactive modeling.
The omission of automatic selfintersection avoidance is typically not of con
cern to most users, since they can easily avoid selfintersection manually. Given a
choice users usually prefer interactivity and higher speed in their applications. On
the other hand, when users become more advanced, their main complaint becomes
the limitations of the tools. For instance, opening a hole or adding a handle can re
quire huge amount of manual work. Therefore, modeling a very complicated shape
with huge number of holes and handles can be an uphill task even for experienced
users.
1.2 Manifold Mesh Modeling
The limitations of the polygonal modeling tools in commercial systems stems from
polygonal mesh representations. Most commercial systems, for convenience, al
low many nonmanifold representations and manifolds with boundaries. Several
manifold representations that are particularly useful for algorithm development are
not considered valid even if the underlying data structure can support them. These
decisions make sense in the early stages of commercial system development but
eventually become a burden for tool development.
Avoiding nonmanifolds and allowing all possible manifold meshes can greatly
simplify the algorithms and help develop newtools for interactive modeling. Avoid
ance of nonmanifolds is not really an issue. Starting from a simple set of manifold
meshes, manifold property can easily be guaranteed by using only manifold pre
serving operators. Examples of manifold preserving operators are Euler operators
[147], SPLICE operator [178] and INSERTEDGE operator [156].
The only real concern is the representation of all manifolds. There are two
issues related to this problem: (1) The underlying data structure must support all
manifold meshes, (2) Manifold preserving operations must be complete; i.e. they
must be able to create all manifold meshes.
1.3 Data Structures
Representing all manifolds with existing data structures is not really really a hard
problem. Most popular edgebased data structures such as halfedge, quadedge and
wingededge [147, 178, 163] can represent all manifolds with a minor extension by
including a manifold mesh with only one vertex and one face [147]. Face based
data structures, including the simple Wavefront OBJ le structure, can represent all
manifolds.
1.4 Mesh Operators
Forming a complete set of operators requires a careful study. We have identied
that the operators, CREATEVERTEX, DELETEVERTEX, INSERTEDGE and DELE
TEEDGE form such a complete and also minimal set (For reviewer: see [?] provided
in suplemental materials). In the development of our system we use this set since
INSERTEDGE and DELETEEDGE are particularly suitable for use as interactive op
erators. (For reviewer: see suplemental video for interactive demos [?])
1.5 New Schemes
The new schemes are based on manifold mesh modeling, in which we guarantee
topological manifold property of the meshes, but we do not keep any geometric
information about the shape except the positions of the vertices. The faces and
edges can have any shape, but, since we do not have to deal with their shapes,
our algorithms become simple and allow us to provide realtime interaction. Since
we largely ignore the geometry of the shapes, we do not have to deal with hard
problems such as selfinteractions or set operations. Moreover, we can represent
nonmanifold looking shapes with manifold meshes. These particular problems
and our solutions illustrate that many hard solid modeling problems can have simple
solutions using topological mesh modeling.
Chapter 2
Polygonal Meshes
Polygonal meshes are most commonly used representations in computer graphics
applications. The polygonal meshes can represent complicated surfaces by subdi
viding them into simpler surfaces, which are called faces. This subdivision idea
even exists in real life. We often create complicated surfaces by combining simpler
patches. Figure 2.1 shows one such example, a ball that is created by handsewn 12
pentagonal patches
1
As seen in this real example, the patches can be curved and do
not have to be planar.
Faces are not the only conceptual entities that are used to represent polygonal
meshes. We need two additional entities, edges and vertices, to represent the re
lationship between the faces. Edges are 1dimensional entities that represent the
boundaries between pairs of faces. Vertices, on the other hand, are 0dimensional
entities and represent boundaries between edges. Vertices and edges do not have a
real physical corresponding but help us to represent and understand surface struc
tures. Consider again the handsewn dodecahedralball shown in Figure 2.1: (Talk
about edges and vertices. in which we can consider the red lines as edges.)
1
I found this unusual dodecahedral ball in Germany when we visited my wifes sister.
13
Figure 2.1: Two views of a ball created by sewing pentagonal patches.
Formally, a mesh on a 2manifold S species an embedding (G) of a graph G
on the 2manifold S. Each connected component of S (G) plus the bounding
edges in G makes a face of the mesh. Following the conventions adopted by many
other researchers [11, 181, 20], we allow a mesh to have multiple edges (i.e., more
than one edge connecting the same pair of vertices) and selfloops (i.e., edges with
both ends at the same vertex). The mesh is cellular if the interior of each face
is homeomorphic to an open disk. Noncellular meshes have also been studied
in the literature but the corresponding modeling algorithms are more complicated
[12, 181]. In manifold mesh modeling, we only consider cellular meshes.
In computer graphics applications, most commonly used manifold meshes are
piecewise linear: the faces are planar polygons with straight edges. Triangular
meshes are particularly popular since triangles with straight edges are always pla
nar. Such planar faces are very useful for computer graphics: planar faces are easier
to render. It is also easier to detect collisions with planar faces.
Planarity is a geometric condition. In topological mesh modeling, we ignore any
such geometric condition and assume that faces and edges can have any shape. With
this assumption, although we lose the advantages coming from planarity/linearity
Figure 2.2: Real ball and its abstract representation with faces, edges and vertices.
of faces and edges, we gain a lot. Without geometric constraints, it is not only
possible develop simpler and faster algorithms for interactive modeling; it also is
possible to represent a wide variety of shapes. The Figure 2.3 shows that manifold
meshes can represent one or two dimensional entities such as points, lines, curves
and polygons.
PointSphere SelfLoop LineManifold TriangleManifold
Figure 2.3: Four examples of unusual Manifolds.
2.1 Euler Equation
In topological mesh modeling, our only concern is mesh structure; how faces, edges
and vertices are related with each other. Euler equation is the fundamental equation
that gives the relationship between the number of faces, f, the number of edges,
e, and the number of vertices v. Using EulerPoincare equation, without using
geometric properties, we can identify some essential properties of manifold meshes.
EulerPoincare equation is given as follows:
f e + v = 2 2g (2.1)
where g is the total number of holes, handles and columns in a surfaces, called
genus. Euler discovered early form of this equation 2.1 for genus0 surfaces where
g = 0.
As an example of genus0 polyhedra consider a cube: in a cube, there are 6
faces, 12 edges, 8 vertices and no holes, i.e. f = 6, e = 12, v = 8 and g = 0. If we
replace these values in equation 2.4, we can observe that they satisfy the equation
as 6 12 + 8 = 2.
The dodecahedral manifold in Figure 2.2 has 12 faces, 20 vertices and 30 edges.
These numbers also satisfy Eulers equation as 12 30 + 20 = 2. More interesting
examples are the manifolds meshes in Figure 2.3. For instance, point sphere has
only one vertex and one face. It does not have any edge and therefore again satisfy
the Eulers equation as 1 0 + 1 = 2.
The equation 2.4 can also apply polygonal meshes that represent manifold sur
faces. This equation is extremely useful to identify specic class of polygonal sur
faces.
2.2 Topologically Regular Meshes
We will dene topological regularity as all faces and vertices have the same prop
erty. A regular mesh is given as (n, m) where n is the number of the sides of faces,
and m is the valence of vertices.
The valence of a vertex is dened as the number of edgeends that emanates
from that vertex. For instance, the vertex of a pointsphere in Figure 2.3 does not
have any edge emanating from it and its valent is 0. On the other hand, the vertex of
the selfloop in Figure 2.3 has valence 2, since two edgeends emanates (although
both ends belong to the same edge) from the vertex.
The sides of a face is counted as the number of edge sides (also called half
edges) belong to a face. In other words, two sides of a same edge can belong two
same face and that edge will be counted twice. For instance, the only face of a
linemanifold in Figure 2.3 is a twogon in which the edge counted twice since both
sides of the edge belong to the same face.
Pointsphere in Figure 2.3 is the simplest regular mesh with (0, 0). We will
call point=sphere (0, 0) thereafter. All manifolds in Figure 2.3 are regular meshes.
For instance, linemanifold is (2, 1), selfloop, which is the dual of linemanifold is
(1, 2) and trianglemanifold is (3, 2).
It is possible to systematically search for regular meshes using EulerPoincare
equation. First note that if all faces have the same number of sides n and all vertices
has the same valence m, we can obtain the following relationships:
nf = 2e (2.2)
mv = 2e (2.3)
If we plug in these relationships in EulerPoincare equation, we obtain a simpli
ed equation
1
n
+
1
m
1
2
e = 1 g. (2.4)
For genus0 surfaces, the equation can 2.4 further simplify to the following.
e =
2nm
2n 2m + nm
(2.5)
The integer solutions of equation 2.5 gives us an idea about genus0 regular
manifold meshes. Note that having integer solutions to the equation 2.5 alone does
not prove existence of the regular mesh.
2.2.1 Manifold Polygons
The polygons can be dened as meshes in which all vertices has the valence 2. If
we plug in m = 2 to the equation 2.5, we simply get
e = n
If we plug in this value of e, to the equations 2.2 and 2.3, we nd that f = 2
and v = n. In other words, in this case, there exist exactly n number of edges and
vertices, which the number of the sides of the faces; and there are only two faces;
i.e. these are twosided (manifold) polygons. Some examples of manifold polygons
are shown in Figure 2.4
2.2.2 Regular Platonic Meshes
Regular genus0 meshes also include platonic meshes which are generalized version
of platonic polyhedra, and regular polygons. Regular or Platonic polyhedra are
dened by a set of geometric conditions. However, we do not need any geometric
condition to nd mesh structures of regular polyhedra. For both n and mlarger than
2, we obtain those mesh structures as (3, 3), (3, 4), (3, 5), (4, 3) and (5, 3).
(2, 2) (3, 2) (4, 2) (5, 2)
Twogon Triangle Quadrilateral Pentagon
Figure 2.4: Polygonmanifolds.
(3, 3) (3, 4) (3, 5) (4, 3) (5, 3)
Tetrahedron Octahedron Icosahedron Cube Dodecahedron
Figure 2.5: Regular genus0 meshes with both n and m larger than 2.
2.2.3 Regular Genus1 Meshes
For g = 1 the EulerPoincare equation greatly simplies
nm2n 2m = 0 (2.6)
This equation has only three integer solutions: (4, 4), 3, 6) and (6, 3). These solu
tions correspond regular tessellations of an innite plane.
For (4, 4) case, value of e should be an even number since e = 2v = 2f. For
v = f = 1 and e = 2, we get the simplest genus1 mesh shown in Figure 2.8(A).
For (6, 3) case, 2e = 6f = 3v, so v should be an even number, f should be
twice of v. For f = 1, v = 2 and e = 3, we get the simplest (6, 3) genus1 mesh
shown in Figure ??(A).
(A) (B) (C)
Figure 2.6: Two views of a ball created by sewing pentagonal patches.
Figure 2.7: Two views of a ball created by sewing pentagonal patches.
2.2.4 Regular Genuslargerthan1 Meshes
e =
2nm
nm2n 2m
(g 1) (2.7)
Figure 2.8: Two views of a ball created by sewing pentagonal patches.
f =
4m
nm2n 2m
(g 1) (2.8)
v =
4n
nm2n 2m
(g 1) (2.9)
If all these equations are integer, than there exist a regular mesh. If g > 1,
multiplication with g 1 does not affect integer condition. Thus, we only have to
check the rst term.
If we check integer solutions, we found the following regular meshes. These
regular meshes exist in any genus that is larger than 1, regardless of genus:
(3, 7); (3, 8); (3, 9); (3, 12); (4, 5); (4, 6); (5, 5); (5, 4); (6, 4); (6, 6); (7, 3);
(8, 3); (9, 3); (12, 3)
There is another group that strictly depends on genus: (4g, 4g).
2.2.5 When Genus goes to Innity
When genus goes to innity, can can further simplify the equation 2.7 as,
e
g
=
2nm
nm2n 2m
(2.10)
In other words, in this case for any any n and m, if
e
g
is a rational number, there
can potentially exist a regular manifold mesh.
Figure 2.9: Two views of a genus2 (4, 6) regular mesh.
2.3 Topologically SemiRegular Surfaces
2.4 Curious Cases
Figure 2.10: Two views of a ball created by sewing pentagonal patches.
Chapter 3
Graph Rotation Systems
Topological mesh modeling is based on graph rotation systems. A graph with a
rotation system is embedded to a unique 2manifold shape [169]. It always guaran
tees the representation of valid 2manifold polygonal meshes. Moreover, it is easy
to change the topology of meshes by simply inserting or deleting edges in the cor
responding graph rotation system. An edge insert operation can either (1) combine
two faces by inserting a hole, (2) combine two faces by adding a handle, (3) com
bine two faces by joining two separate 2manifold meshes, or (4) subdivide a single
face into two. Conversely, an edge delete operation can either (1) separate one face
into two by closing a hole, (2) separate one face into two by deleting a handle, (3)
separate one face into two by disconnecting one 2manifold object into two, or (4)
combine two faces into one. In either operations the rst three cases change the
topology of a mesh. The last one does not change the topology, it only changes the
number of polygons.
In order to represent graph rotation systems and efciently implement edge in
sertion and deletion operations, we have developed the Doubly Linked Face List
(DLFL) data structure. Using DLFL, we demonstrate examples of topology changes
based on this newparadigmand showthat the paradigmis convenient, effective, and
25
efcient for topological changes for subdivision surfaces.
We rst introduce the concepts behind subdivision methods and topological re
quirements imposed by subdivision methods. We then introduce the previous works
in graph rotation system. Then, we demonstrate why and how edge insert and edge
delete operations work by illustrating each of these cases with gures. The discus
sions in these sections are formal and abstract. The readers who are interested in
only implementation issues can skip them and go directly to the section that covers
implementation issues and examples.
3.1 Graph Rotation Systems
In this section, we introduce historical background and some mathematical funda
mentals for graph rotation systems (see [177] for more detailed discussion).
The concept of rotation systems of a graph originated from the study of graph
embeddings and it is implicitly due to Heffter [179] who used it in Poincare dual
form. A graph embedding in an orientable surface corresponds to an obvious rota
tion system, namely, the one in which the rotation at each vertex is consistent with
the cyclic order of the neighboring vertices in the embedding. Edmonds [169] was
the rst to call attention explicitly to studying rotation systems of a graph.
Let G be a graph. A rotation at a vertex v of G is a cyclic permutation of the
edgeends incident on v. A rotation system of G is a list of rotations, one for each
vertex of G. Given a rotation system of a graph G, to each oriented edge (u, v) in G
one assigns the oriented edge (v, w) such that vertex w is the immediate successor of
vertex u in the rotation at vertex v. The result is a permutation on the set of oriented
edges, that is, on the set in which each undirected edge appears twice, once with
each possible direction. In each edgeorbit under this permutation, the consecutive
oriented edges line up head to tail, from which it follows that they form a directed
cycle in the graph. If there are r oriented edges in an orbit, then an rsided polygon
can be tted into it. Fitting a polygon to every such edgeorbit results in polygons
on both sides of each edge, and collectively the polygons form a 2manifold.
Edmonds [169] has shown that every rotation system of a graph gives a unique
orientable 2manifold. Moreover, the corresponding orientable 2manifold is con
structible, as we described above. For any 2manifold S, there is a graph G and a
rotation system of G such that corresponds to an embedding of G on S [62].
Therefore, the existence of the bijective correspondence between graph embed
dings on orientable 2manifolds and graph rotation systems enables us to represent
topological objects by combinatorial ones. In particular, every 2manifold can be
represented by a rotation system of a graph, and every rotation system of a graph
corresponds to a valid 2manifold. In consequence, the presentation of graph ro
tation systems always guarantees topological consistency. Chen, Gross and Riper
have developed a very efcient algorithm that, given a rotation system of a graph,
constructs the corresponding 2manifold [63].
Figure 3.1: A graph drawn in a rotation system and the corresponding embedding
on the sphere.
Based on graph rotation systems, a graph that is drawn in 2D can uniquely rep
resent a 2manifold shape. For example, consider two graphs given in Figures 19.6
and 19.7. These graphs are drawn in such a way that the rotation at each vertex can
be traced by traversing the incident edges in counterclockwise order. These are
two different rotation systems for the same graph. When we consider the rotation
order they correspond to two different 2manifold shapes: the sphere in Figure 19.6
and the toroid in Figure 19.7.
Figure 3.2: The same graph as in Figure 19.6 drawn in a different rotation system
and the corresponding embedding on the toroid.
The graph rotation system also provides a concise and simple internal data rep
resentation as a set of vertices and a rotation order for each vertex. For example,
the rotation system of the graph in Figure 19.6 is given by the ordered lists:
v
1
: v
4
v
2
v
3
, v
2
: v
3
v
1
v
4
,
v
3
: v
1
v
2
v
4
, v
4
: v
1
v
3
v
2
,
and the rotation system of the graph in Figure 19.7 is given by ordered lists:
v
1
: v
4
v
3
v
2
, v
2
: v
3
v
1
v
4
,
v
3
: v
4
v
2
v
1
, v
4
: v
1
v
3
v
2
.
Rotation systems can be easily implemented as a set of linked lists. We should
also point out that each edge of a graph appears exactly twice in any of its rotation
systems. Therefore, the amount of computer memory used for this representation
is small.
Based on a rotation system, each face can be easily constructed by traversing
the face boundary, following the rotation order of the vertices on the boundary, as
shown in Figure 3.3. By a facecorner of a face, we refer to a vertex on the face
boundary, plus the two neighboring edges.
3.2 Changing Topology with Graph Rotation Systems
We have observed that graph rotation system provides a great convenience in topol
ogy changes [156]. Only edge insert and edge delete is enough to change the topol
ogy of a 2manifold mesh supported by graph rotation systems.
3.2.1 Inserting or Deleting an Edge in a Graph Rotation System
Any rotation order of two vertices of a graph rotation system can be given by the
following representation without loss of generality:
v
1
: v
3
v
2
, v
4
: v
6
v
5
where and are any sequence of vertices. Let an edge be inserted between v
1
and
v
4
as shown in Figure 4.3. The new graph rotation system can be easily obtained by
Figure 3.3: Rotation order of faces is provided by rotation system.
simply updating the rotation orders of v
1
and v
4
as follows:
v
1
: v
3
v
4
v
2
, v
4
: v
6
v
1
v
5
Although this insert operation is extremely simple, it changes the faces of the
2manifold object represented by the graph rotation system. It either connects two
faces by merging them into one single face or subdivides a single face into two
faces. These two cases are illustrated in more detail as follows:
Figure 3.4: Inserting an edge.
The facecorners v
3
, v
1
, v
2
) and v
6
, v
4
, v
5
) do not belong to the same face.
In this case, the insert operation connects the two faces by merging them into
one single face as shown in Figure 19.8.
The facecorners v
3
, v
1
, v
2
) and v
6
, v
4
, v
5
) belong to the same face. In this
case, the insert operation subdivides the face into two as shown in Figure 11.2.
The edge deletion operation can be elaborated in a similar manner. Basically, if
an edge has its two sides in different faces, then deleting the edge merges the two
faces into a larger one. On the other hand, if the two sides of the edge are in the
same face, then deleting the edge separates the face into two faces.
3.2.2 Topology Change with Edge Insert and Edge Delete
Let there be two faces that are described by a rotation system. We assume that
these two faces are not the same. However, they can share a vertex, an edge or
several edges. They may also belong to two disconnected 2manifolds. Based on
the rotation system, any edge inserted by connecting these two faces converts them
into one single face as we have shown in Figure 19.8.
If these two faces belong to two disconnected 2manifold shapes, after the insert
edge operation these two 2manifold shapes become connected by the new inserted
edge. If the faces belong to the same 2manifold, the edge insert operation increases
the genus of the 2manifold by one, i.e., a handle (or a hole) is added.
In both cases, a new face created by an edge insert operation is, in fact, a handle
as shown in Figure 17.11. Therefore, we call this type of face facehandle. It is
not easy to visualize this facehandle, however the structure of the handle becomes
apparent when the face is smoothed by subdivision operations as represented in
Figure 17.11.
If this handle goes through the inside of a 2manifold, it becomes a hole. If the
handle goes outside of the 2manifold, it becomes a handle. The hole and the handle
are automatically created or deleted based on geometry and edge insertion/deletion
rules we described in previous section.
The handle that results from a subdivision operation includes an extraordinary
vertex with a high valance. (The term valance is used to denote the number of edges
incident on a vertex. Valance of an extraordinary vertex on a handle is at least equal
to 7). In most cases, the resulting subdivision surface will not be C
1
continuous at
this extraordinary vertex because of the unusual structure of our facehandles.
Fortunately, it is possible to improve the quality of the handle simply by insert
ing new edges. As shown in Figure 14.20 if a second edge is inserted to connect
any two vertices of the facehandle, the new edge separates the facehandle into two
faces without changing the topology of the mesh. On the other hand, the quality of
the handle is usually improved.
Figure 3.5: Inserting an edge between two different faces merges the two faces.
Figure 3.6: Inserting an edge between two vertices of the same face divides it into
two faces.
Figure 3.7: Handle becomes apparent after subdivision operations.
Figure 3.8: Improving the quality of handles by inserting more than one edge.
Chapter 4
Mesh Data Structures
This chapter discusses differences between the current mesh data structures that can
be used to represent manifold meshes.
4.1 Preliminaries
Let Gbe a mesh on a 2manifold S. Because each vertex v of Ghas a neighborhood
in S homeomorphic to an open disk, the edges incident on v are cyclically ordered
in this neighborhood. This observation has turned out to be extremely important in
representing a 2manifold mesh. The classical wingededge data structure proposed
by Baumgart [3] for mesh representations was essentially developed based on this
observation.
Formally, the main component of a wingededge data structure is a list of edge
nodes. Each edge node consists of nine components: (name, vstart, vend, fcw, fccw,
ncw, pcw, nccw, pccw), where name is the name of the edge; vstart and vend are
the starting and ending endvertices of the edge (which thus give a direction to
the edge); fcw and fccw indicate the right face and the left face of the edge when
37
traversing along the edge direction; ncw and pccw give the next edges in the faces
fcw and fccw when traversing along the edge direction; and pcw and nccw give the
next edges in the faces fcw and fccw when traversing along the reversed direction
of the edge. See Figure 17.4 for illustration.
r vend d
d
ncw
pccw
r
vstart
pcw
r
r
d
d
nccw
fcw
fccw
name
Figure 4.1: A edge node in the wingededge structure
Thus, the wingededge structure is edgebased, which describes the mesh struc
ture in terms of the adjacency information on each edge of the mesh. An adaptation
of the wingededge structure is the halfedge data structure [181], which is a hier
archical data structure. The major difference between the halfedge data structure
and other structures is the introduction of the concept of halfedges
1
. A halfedge
describes oneside of an edge of the mesh, thus is uniquely associated with a face
of the mesh. A halfedge node consists of references to the face, to its starting ver
tex, to the corresponding edge, and to the previous and the next halfedges of the
face. The halfedge data structure indicates very clearly a property of the mesh on
a 2manifold that each edge of the mesh appears exactly twice on the boundaries of
the faces of the mesh.
Guibas and Stol [10] studied mesh structures by dening an algebra on the
edges of a mesh and its dual (thus, it works specically for cellular meshes). Each
edge can be given a direction along which the edge is traversed, and an orienta
tion by which the left side and right side of the edge are welldened when
1
There are a number of variations and renamings for the concept of halfedges adopted in com
mercial modeling systems, such as coedges in ACIS (Spatial Technologies Inc.) [18] and n in
Parasolid (Unigraphics Solutions Inc.) [19].
traversing the edge along the given direction on the 2manifold. Thus, each edge
has four different directed and oriented versions. Each directed and oriented edge
has four attributes: the two endvertices Org and Dest (equivalent to vstart and vend
in the wingededge structure), and the two faces Right and Left on the two sides of
the edge on the 2manifold (equivalent to fcw and fccw in the wingededge struc
ture). An edge algebra is introduced by dening three functions Flip, Onext, and
Rot on the set of the directed and oriented edges, where Flip ips the orientation
of an edge, Onext gives the next edge of an edge based on its Org (thus is sim
ilar to nccw in the wingededge structure); and Rot rotates the edge (which is
a little more technical and we omit its detailed explanation). Both orientable and
nonorientable 2manifolds can be described by edge algebras. Moreover, an edge
algebra gives the structures for both the primary mesh and its dual. A data struc
ture, the quadedge structure, has been introduced to represent the edge algebra for
a mesh structure [10].
When concentrating on orientable 2manifolds, as most modeling applications
do, the edge algebra and its corresponding quadedge structure can be simplied.
Since all edges of a mesh on an orientable 2manifold have consistent orientations,
the edge orientations need not be given explicitly. Thus, each edge of the mesh
has only two different directed versions. Again three functions Onext, Sym, and
Dual are needed to dene an edge algebra on the edge set of a mesh. In this case,
each edge node in the corresponding quadedge structure contains four pointers to
essentially the four edge nodes corresponding to the edge nodes ncw, pcw, pccw,
and nccw in the wingededge structure.
For manifold preserving operations, M antyl a [181] proposed Euler operators,
and Guibas and Stol [10] dened the splice and createedge operators. The com
pleteness, soundness, and efcient implementations of these operators have been
thoroughly studied.
4.2 Data structures and topological validity
Graph rotation systems are vertexbased descriptions of mesh structures. Theo
rem 19.3.1 shows that a valid graph rotation system guarantees the validity of the
underlying 2manifold mesh structure. In this section, we show that based on The
orem 19.3.1 it is in general trivial to check whether a mesh structure gives a valid
2manifold based on any existing mesh representations.
To simplify the discussion, we will assume from now on that our graphs do
not contain multiple edges and selfloops. Thus, edges and directed edges now
can be uniquely specied by pairs of vertices and ordered pairs of vertices, respec
tively (The discussion can be extended to graphs with multiple edges and selfloops
without much technical troubles except using more tedious notations.) According
to Theorem 19.3.1, we have the following simple rules to check whether a mesh
structure represents a valid 2manifold:
Validity Rules. A mesh structure gives a valid 2manifold if and only
if
1. Each edge [u, w] induces exactly two directed edges u, w) and
w, u);
2. For each vertex v, a unique cyclically ordered list is specied that
contains all and only the directed edges from v.
It is easy to see that the Validity Rules above are consistent with those proposed
by Hoffmann [11] when a mesh is triangulated, which claims that a triangulated
mesh represents a valid 2manifold if every edge is shared by exactly two triangles
and each vertex is uniquely associated with a ring of triangles incident on it. The
advantage of our Validity Rules is that we do not restrict the meshes to be trian
gulated. Moreover, our rules seem simpler in the sense that the rules are based
on 1dimensional cells (i.e., directed edges) while Hoffmanns rules are based on
2dimensional cells (i.e., triangles).
We point out that test rules similar to what we propose here may have been used
in modeling practice. However, to our knowledge, this is the rst time that these
rules are formally stated and mathematically proven. These theoretical results grant
the rst time the validity of using these test rules in 2manifold modeling.
In the rest of this section, we demonstrate another advantage of our validity
rules, by showing that our rules are directly applicable to any existing mesh repre
sentations.
4.2.1 Vertexbased data structures
There is a fairly natural data structure for representation of graph rotation systems,
the graph adjacency list structure, which is the most commonly used data structure
for graphs in computer science. Recall that an adjacency list for a graph G is given
by an array A[1..n] of linked lists, where A[v] is a linked list that contains all neigh
bors of the vertex v. Since the graph has no multiple edges and selfloops, each
vertex w in the list A[v] uniquely species the directed edge v, w) from the vertex
v. Since for each edge [v, w], the vertex w appears in the list A[v] and the vertex
v appears in the list A[w], Validity Rule 1 is satised. Moreover, if we interpret
for each vertex v the list A[v] as the cyclic ordering of the directed edges from v,
then the list A[v] species a unique rotation of the directed edges from the vertex v.
Thus, Validity Rule 2 is satised. Thus, we conclude
Theorem 4.2.1 A valid graph adjacency list A[1..n] represents a valid 2manifold
structure.
The drawback of graph adjacency lists for mesh modeling is its time complexity
for supporting modeling operations. For example, when we trace a face boundary
following a directed edge v, w), we need to jump from the list A[v] to the list A[w]
and nd the directed edge following the directed edge w, v) in the list A[w]. The
time for doing this is proportional to the size of the list A[w], which will be time
consuming in particular when the vertex w has a large valence.
4.2.2 Edgebased data structures
Most data structures in mesh modeling are edgebased. We will focus our discus
sion on the wellknown wingededge structure, then extend our discussion to other
structures.
Recall that each edge node in a wingededge structure consists of nine compo
nents: (name, vstart, vend, fcw, fccw, ncw, pcw, nccw, pccw) (see Figure 17.4). By
the denitions, the edge [vend, vstart], and vertex vend, and the edge ncw form
a corner of the face fcw, and the edge [vstart, vend], the vertex vstart, and the
edge nccw form a corner of the face fccw. Thus, if the mesh structure repre
sents a valid 2manifold, then the edges nccw and ncw should induce the next
directed edges from the vertices vstart and vend, respectively, for the directed edges
vstart, vend) and vend, vstart). Thus, whether the wingededge structure gives a
valid 2manifold can be veried based on the components ncw and nccw.
Denote by A[e] the edge node for the edge e in the wingededge structure. By
A[e].vstart, A[e].vend, A[e].ncw, and A[e].nccw, we refer to the corresponding com
ponents vstart, vend, ncw, and nccwin A[e]. Consider the algorithmin Figure 17.11.
Theorem 4.2.2 If a wingededge structure can pass the test of the algorithm E
Validity, then it represents a valid 2manifold. Moreover, the test algorithm runs in
time O(m).
We give a brief explanation for the correctness of the algorithm EValidity, and
refer interested readers to [5] for a formal proof. First note that the vertices are
Subroutine VertexTrace(v
0
, e
0
) {* the vertex v
0
is an end of the edge e
0
*}
1. if (A[e
0
].vstart = v
0
) then e = A[e
0
].nccw else e = A[e
0
].ncw;
2. while (e = e
0
) do
2.1. suppose e = [v
0
, w];
2.2. if (the directed edge v
0
, w has been marked) then Stop(not manifold);
2.3. mark the directed edge v
0
, w;
2.4. if (A[e].vstart = v
0
) then e = A[e].nccw else e = A[e].ncw;
3. suppose e
0
= [v
0
, w
0
]; mark the directed edge v
0
, w
0
.
Algorithm EValidity (A[1..m]) {* A[1..m] is a wingededge structure *}
for each edge node A[e] do
1. u = A[e].vstart; w = A[e].vend;
2. if (u is not marked) { then mark u; VertexTrace(u, e); }
else if (the directed edge u, w has not been marked) then Stop(not manifold);
3. if (w is not marked) then { mark w; VertexTrace(w, e); }
else if (the directed edge w, u has not been marked) then Stop(not manifold).
Figure 4.2: Topological validity testing on wingededge structure
marked in the main algorithm EValidity while directed edges are all marked in the
executions of the subroutine VertexTrace. Thus, a call to VertexTrace on a vertex
v
0
checks the condition that all directed edges from v
0
must form a unique rotation
at v
0
, while steps 2 and 3 in the main algorithm EValidity verify that each edge in
the mesh induces exactly two directed edges.
Remark. Theorem 4.2.2 indicates that the original wingededge structure pro
posed by Baumgart [3], in which only the components name, vstart, vend, ncw, and
nccw are included, will be sufcient for modeling 2manifold mesh structures.
As an example, we show how the algorithm EValidity reports an error on
the wingededge structure given in Figure 19.3. By looking at the edge node
A[e
1
], step 3 of the algorithm will mark the vertex v
2
and call the subroutine
VertexTrace(v
2
, e
1
). The subroutine VertexTrace(v
2
, e
1
) will mark the directed
edges v
2
, v
3
), v
2
, v
4
), and v
2
, v
1
) and return back to the main algorithmEValidity.
Then the main algorithm EValidity looks at the edge node A[e
2
] and nds out that
the vertex v
2
is marked while the directed edge v
2
, v
5
) is not marked, thus correctly
reports an error.
We briey describe the Validity Rules on other edgebased data structures.
In the halfedge structure [181], a halfedge corresponds uniquely to a directed
edge in our rotation system. Moreover, each halfedge has a unique reference to
the next halfedge of the corresponding face, from which we can easily retrieve the
information for the next directed edge based on a vertex. Thus, the verication of
the Validity Rules can be done by checking whether the reference to the next half
edge of each halfedge induces a valid rotation system. It is not difcult to verify
that testing the Validity Rules on a halfedge structure can be done in time O(m),
where m is the number of edges in the mesh.
In the quadedge structure [10] for an edge algebra for an orientable 2manifold,
each edge has two directed versions, corresponding to the two directed edges in
our graph rotation systems. The operation Onext dened in the edge algebra gives
exactly the next directed edge of a given directed edge from a vertex. Thus, again,
based on the directed edges and the Onext operation, we can conveniently verify
whether the quadedge structure gives a valid graph rotation system thus represents
a valid 2manifold structure. Again the Validity Rules on the quadedge structure
can be tested in time O(m), where mis the number of edges. Note in particular that
our validity test on quadedge structure does not need the information for the dual
mesh structure, which is also provided in the quadedge structure and is required
for the validity test using a group of rules proposed in the original research for edge
algebra [10].
4.2.3 Facebased data structures
Facebased data structures have been regarded as the least reliable for modeling
2manifold structures. In particular, a variety of nonmanifold structures, such as
wronglyoriented polygons, overlapping polygons, missing polygons, cracks, and
Tjunctions, can be resulted from a facebased data structure [17].
We have recently reinvestigated facebased data structures for mesh modeling
and proposed a new facebased data structure [2]. The advantage of this new data
structure is its extremely efcient support to a variety of modeling operations. In
this subsection, we show how to test the Validity Rules on this facebased data
structure.
A doubly linked face list (DLFL) for a mesh structure Gconsists of a face list F,
an edge list E, and a vertex list V . Each face node in the face list F is a cyclically
and doubly linked list of directed edges, lined up head to tail to form a boundary
walk of the face. Each vertex node in the vertex list V is a list of pointers to the
corresponding vertices in the face nodes in F. Each edge node in the edge list E
consists of two bidirected pointers to the directed edges induced from the edge in
the face nodes in F.
Figures 4.3 gives a partial part of a DLFL data structure for a tetrahedron.
r
v
4
r
v
1
r
v
3
r
v
2
v
2
v
1
v
3
v
4
v
1
v
2
v
3
v
1
v
4
v
4
v
2
v
3
face list
j
f
1
j
f
2
j
f
3
j
f
4
/ / `` / / `` / / `` / / ``
_ _ _ _ _ _
' '
v
1
v
2
vertex list
v
3
v
4
'
'
'
.
.
.
.
.
.
.
Z
Z
Z
Z
'
e
1
e
2
e
3
e
4
e
5
e
6
`
`
`
`
`"
'
'
Z
Z
Z
e
6 `
`
`
e
5
`
`
e
1
.
..
e
2 '
'
'
'
e
4
a tetrahedron
edge list
Figure 4.3: The DLFL data structure for a tetrahedron
Both vertex list and edge list provide efcient access to directed edges in the
VertexTrace(v
0
, v
0
, w
0
)
1. let v
0
, x be the directed edge following the directed edge w
0
, v
0
in a face node;
2. while (v
0
, x = v
0
, w
0
) do
2.1. let v
0
, y be the directed edge following the directed edge x, v
0
in a face node;
2.2. if (v
0
, y is marked) then stop(not manifold)
2.3. else mark v
0
, y; x = y;
3. mark v
0
, w
0
.
Algorithm FValidity (D) {* D is a DLFL structure *}
1. by scanning the face list, edge list, and vertex list, check that each edge correctly
corresponds to two directed edges;
2. for (each vertex v in D) do
if (v is not an isolated vertex without edge)
then in vs vertex list, nd an directed edge v, w from v; VertexTrace(v, v, w);
3. if (there are still unmarked directed edges) then return(not manifold).
Figure 4.4: Topological validity testing on DLFL structure
face list. The testing algorithm for Validity Rules on the DLFL structure is given in
Figure 14.20.
Theorem 4.2.3 If a DLFL structure D can pass the test of algorithm FValidity,
which takes time O(m), then D represents a valid 2manifold.
PROOF. Validity Rule 1 is tested by step 1 of the main algorithm FValidity.
To verify Validity Rule 2, note that two consecutive directed edges v, w) and
w, x) in a face boundary walk specify precisely that w, x) is the directed edge fol
lowing the directed edge w, v) in the rotation at w. Thus, the subroutine VertexTrace(v
0
, v
0
, w
0
))
starts from a directed edge v
0
, w
0
) and constructs a list of consecutive directed
edges from v
0
. If the face list does not give a valid rotation at a vertex v
0
, then
there are only two possibilities: (1) a directed edge at v
0
follows two different
directed edges at v
0
. This will be detected by step 2.2 in the subroutine Vertex
Trace when the directed edge is encountered the second time; (2) the directed
edges at v
0
form more than one disjoint cyclically ordered lists. This will be de
tected by step 3 of the main algorithm FValidity since the call to the subroutine
VertexTrace(v
0
, v
0
, w
0
)) can trace only one such a list.
In conclusion, if the DLFL structure passes the test of FValidity, then it must
represent a valid graph rotation system. For the complexity of the algorithm, note
that the algorithmFValidity marks each directed edge exactly once. Since the edge
node for an edge [v, w] has two bidirected pointers to the directed edges v, w) and
w, v) in the face list, from an directed edge v, w) in the face list, we can nd the
directed edge w, v) in constant time. Therefore, the algorithm FValidity runs in
time O(m).
Before we close this section, we give a general remark on the implementation
of our validity testing algorithms. Our algorithms check the topological validity
of mesh structures based on directed edges. Therefore, for data structures that ex
plicitly reserve a physical record for each directed edge in their representations,
our algorithms can be directly applied. Note that most modeling data structures,
including the halfedge structure, the quadedge structure, and the DLFL structure,
do this. For these data structures, we can simply attach for each directed edge an
additional bit to its record, which will be used to mark if the directed edge has been
traced in our algorithms. On the other hand, if a data structure does not reserve such
records for directed edges, such as the wingededge structure, then the implementa
tion of our algorithms must be more careful. Weiler [20] has thoroughly studied the
problem of traversing a mesh on the wingededge structure. In particular, since the
wingededge structure does not explicitly give directed edges in its representation,
when a mesh under wingededge structure is traversed, an additional piece of infor
mation must be kept to indicate which directed edge induced by an edge is being
referred. The situation can become even worse when multiple edges and selfloops
are allowed in a mesh [20]. Therefore, for wingededge structures, we suggest that
our algorithms be implemented on the modied wingededge structures in which
directed edges are explicitly recorded, as proposed by Weiler [20].
Also, since graph rotation systems only describe cellular mesh structures, for
systems that also allownoncellular meshes, our algorithms must be used with care.
Chapter 5
Minimal Operators
Operations on mesh modeling are important, in particular for the modeling systems
with a reliable and powerful userinterface. A systematic study on the operator set
on mesh modeling was given by M antyl a [181], and was also considered by other
researchers (e.g., [3, 10]). For 2manifold modeling, three issues in modeling oper
ator sets have turned out to be the most important: the completeness, the soundness,
and the efciency. We say that a set S of operators is complete if any 2manifold
mesh structure can be generated by a sequence of the operators from S, and that the
set S of operators is sound if applying any operator in S on a 2manifold results in
a valid 2manifold structure.
Theorem 19.3.1 provides a solid foundation not only for validity testing of 2
manifold structures, but also for powerful mesh modeling operators. In the previous
studies on operators on 2manifold structures (e.g., [10] and [181]), it is always
needed to verify carefully that a proposed set of operators is sound and complete so
that all and only 2manifold structures can be created using the operators. On the
other hand, by Theorem 19.3.1, the problem of soundness and completeness can be
resolved based on the representation of graph rotation systems: as long as we can
verify that a set of operators can create all and only valid graph rotation systems, the
49
soundness and completeness of the set are guaranteed. Note that validity of graph
rotation systems is a simple graph property, which is in general much easier and
more intuitive than that of mesh topological integrity.
5.1 A complete and sound operator set
We study a set of modeling operators [2] that seems simpler, more intuitive and
userfriendly than the previously proposed ones. We will discuss the soundness and
completeness of the operator set, consider its efcient implementations on a variety
of modeling data structures, and compare it in terms of various aspects with the
existing approaches.
The rst operator is edge insertion, briey INSERTEDGE. Let (G) be a graph
rotation system and let u and v be two vertices in G. By inserting a new edge
[u, v] between two face corners cor(u, x), u, x
)), we mean
inserting the directed edge u, v) in the rotation at u between the directed edges
u, x) and u, x
)) and
cor(w, y), w, y
)), we only need to insert the item w between the items x and x
in the linked list for the vertex u, and insert the item u between the items y and y
in the linked list for the vertex w. DELETEEDGE that deletes an edge [u, w] from
the adjacency list structure is implemented by deleting the item w in the linked list
for u and deleting the item u in the linked list for w. Finally, a CREATEVERTEX
operator corresponds to adding a new vertex with an empty list in the adjacency list,
and DELETEVERTEX corresponds to removing a vertex with an empty list from the
adjacency list.
The CREATEVERTEX and DELETEVERTEX implemented in an adjacency list
59
take constant time. However, the operators INSERTEDGE and DELETEEDGE im
plemented this way may have to search through the linked lists for two vertices,
which can be timeconsuming in particular when the vertices have large valences.
The time complexity of the operators INSERTEDGE and DELETEEDGE can be im
proved if we use a balanced tree instead of a linked list for the directed edges from
each vertex, which supports item insertion and item deletion in the tree in time
logarithmic to the size of the tree [62]. Moreover, in this implementation, a supple
mentary edge list will be needed to support efcient searching of directed edges in
the structure. We leave the detailed implementation of this alternative data structure
to the interested readers.
6.2 Implementation on edgebased data structures
Again we discuss the implementation on the wingededge structure, and describe
briey its extension to other structures such as halfedge structure and quadedge
structure.
In order to implement the CREATEVERTEX and DELETEVERTEX operators, we
need to introduce a supplementary vertex list in the wingededge structure (actually,
such a supplementary vertex list is always needed in an edgebased data structure
when isolated vertices without edges are allowed). Each item v in the vertex list,
called a vertex node, has a pointer to an (arbitrary) edge node whose one end is
v. A vertex node for an isolated vertex without edges has an empty pointer. Now,
CREATEVERTEX simply adds a new vertex node with an empty pointer to the struc
ture, and DELETEVERTEX removes a vertex node with an empty pointer from the
structure.
To implement the operators INSERTEDGE and DELETEEDGE, consider in the
wingededge structure an edge node A[e] with components name, vstart, vend, ncw,
pcw, nccw, pccw, fcw, and fccw (see Figure 17.4). The components nccw and pcw
Subroutine InsertEdge([u, w], cor(u, x, u, x
),
cor(w, y, w, y
))
{* Inserting edge e = [u, w] to face corners cor(u, x, u, x
) and cor(w, y, w, y
). *}
1. create a new edge node A[e] for e = [u, w] with A[e].vstart = u and A[e].vend = w;
2. nd the edge nodes e
1
= [u, x], e
2
= [u, x
], e
3
= [w, y], and e
4
= [w, y
];
{* without loss of generality, assume A[e
1
].vstart = A[e
2
].vstart = u and
A[e
3
].vstart = A[e
4
].vstart = w. Other cases can be handled similarly. *}
3. A[e
1
].nccw = e; A[e
2
].pcw = e; A[e].nccw = e
2
; A[e].pcw = e
1
;
4. A[e
3
].ncw = e; A[e
4
].pccw = e; A[e].ncw = e
4
; A[e].pccw = e
3
;
5. call FaceTrace(u, w) to update the components fcw and fccw;
6. if (the directed edge w, u is not traced in step 5)
then call FaceTrace(w, u) to update the components fcw and fccw.
Subroutine DeleteEdge(e)
1. nd the edge node A[e] for the edge e = [u, w], where A[e].vstart = u and A[e].vend = w;
2. nd the edge nodes e
1
= A[e].pcw, e
2
= A[e].nccw, e
3
= A[e].pccw, and e
4
= A[e].ncw;
{* without loss of generality, assume A[e
1
].vstart = A[e
2
].vstart = u, and
A[e
3
].vstart = A[e
4
].vstart = w. Other cases are handled similarly. *}
3. A[e
1
].nccw = e
2
; A[e
2
].pcw = e
1
; A[e
3
].ncw = e
4
; A[e
4
].pccw = e
3
;
4. remove the edge node A[e];
5. call FaceTrace(u, x
))
and inserts the directed edge w, u) to the face corner c
2
= cor(w, y), w, y
)),
while the operator DELETEEDGE deletes the edge e. The components ncw, pcw,
pcw, and pccw of the related edges are properly updated. The only thing that needs
further explanation is the updating of the components fcw and fccw. Consider IN
SERTEDGE. If the two face corners c
1
and c
2
belong to different faces, then inserting
the edge e = [u, w] between c
1
and c
2
replaces the two faces in the mesh by a sin
gle new face whose boundary contains both directed edges u, w) and w, u) of the
inserted edge e. Therefore, in this case, the subroutine FaceTrace(u, w)) in step 5
will trace the boundary of this new face and properly update the face components
of the related edge nodes. In particular, the subroutine FaceTrace in step 6 will not
be executed. On the other hand, if the face corners c
1
and c
2
belong to the same
face in the mesh, then inserting the edge e between c
1
and c
2
replaces the face by
two new faces whose boundaries contain the two directed edges u, w) and w, u)
of the inserted edge e, respectively. Thus, the subroutine FaceTrace in step 5 traces
one new face and updates the face components for the related edge nodes, while
the subroutine FaceTrace in step 6 traces the other new face and updates the face
components for the related edges nodes.
For the operator DELETEEDGE on an edge e, if the two directed edges of e are
on boundaries of two different faces, then deleting e will merge the two faces into
a single one. Thus, the subroutine FaceTrace in step 5 will trace this new face and
update the face components of the related edge nodes. On the other hand, if the
two directed edges of e are on the boundary of the same face, then deleting e will
split this face into two faces Now the subroutine FaceTrace in step 5 and step
6 will trace the two new faces and update the face components of the related edge
nodes.
Now we consider the complexity of the algorithms INSERTEDGE and DELE
TEEDGE. For updating the components ncw, nccw, pcw, and pccw, since only very
few edges (two or three) are involved, this can be done in constant time. However,
each algorithm contains one or two executions of the subroutine FaceTrace, whose
time complexity is proportional to the size of the involved faces. When the face size
is small (such as on a triangulated mesh), this is ne. However, for faces of large
size, this will be time consuming.
In section 4.2 we remarked that the components name, vstart, vend, ncw, and
nccw in the wingededge structure are sufcient for representing a 2manifold mesh
structure. In particular, a wingededge structure without the components fcw and
fccw is sufcient for describing a 2manifold mesh structure. Moreover, on a
wingededge structure without the components fcw and fccw, step 5 and step 6
in the algorithms INSERTEDGE and DELETEEDGE are not needed. We summarize
this discussion in the following theorem.
Theorem 6.2.1 On a general wingededge structure, the running time of the algo
rithms INSERTEDGE and DELETEEDGE is O(s), where s is the size of the faces
involved, while on a wingededge structure without the components fcw and fcw,
the running time of the algorithms INSERTEDGE and DELETEEDGE is O(1).
The discussion of the implementations of the operators INSERTEDGE and DELE
TEEDGE on the wingededge structure can be easily extended to other edgebased
data structures, such as the halfedge structure and the quadedge structure, since
these data structures have components that are similar to the components ncw, nccw,
pcw, pccw, fcw, and fccw in the wingededge structure.
Finally, we would like to compare our operators INSERTEDGE and DELE
TEEDGE with the SPLICE operator proposed by Guibas and Stol [10]. Roughly
speaking, the SPLICE operator is equivalent to rst inserting an edge between two
face corners then contracting the edge, while the inverse of the SPLICE operator
is equivalent to rst splitting a vertex then deleting the edge between the two new
vertices. Therefore, for the SPLICE operator and our INSERTEDGE operator, and
for the inverse operator of the SPLICE operator and our DELETEEDGE operator,
roughly the same number of edges get involved in the updating of the components
ncw, nccw, pcw, pccw, fcw, and fccw. However, the SPLICE operator and its in
verse operator also need to change the endvertices of the involved edges, which
can be time consuming in particular when the involved vertices have high valence.
Moreover, our operators are purely topological, while SPLICE needs to combine
two vertices, which necessarily requires changing the geometric positions of the
vertices, and in consequence, complicates the modeling process [8].
6.3 Implementation on facebased data structures
As we pointed out, the INSERTEDGE and DELETEEDGE operators implemented
on the adjacency list data structure can become time consuming when the involved
vertices have high valence, while those implemented on the wingededge structure
or its variations can become time consuming when the involved faces have large
size. Removing the components fcw and fccw from the wingededge structure can
speedup the running time, but may make it inconvenient since then directed edges
will not be directly associated with their corresponding faces. In the following, we
consider implementations of our operators on the DLFL structure, and show that
the computation inefciency can be removed.
To implement CREATEVERTEX(v) in DLFL, we create a face node in the face
list with a degenerated boundary of a single vertex v and a vertex node in the vertex
list with a pointer to the new face. Similarly, to implement DELETEVERTEX(v),
we remove the corresponding face node and vertex node in DLFL.
The algorithms for INSERTEDGE and DELETEEDGE are given in Figure 19.5.
The correctness of the algorithm INSERTEDGE implemented on the DLFL structure
follows from the proof of Theorem 19.3.1 (see [5]). The algorithm DELETEEDGE
reverses the process of INSERTEDGE so its correctness also follows. For the com
plexity of the algorithms, since each edge node in the edge list has two pointers
to its two directed edges in the face list, from each edge, its two directed edges in
the face list can be accessed in constant time. If we implement the list of directed
edges in each face node as a balanced tree [1], then testing whether two directed
edges belong to the same face, splitting one directed edge list into two directed edge
lists, and merging two directed edge lists into a single directed edge list can all be
done in time O(log s), where s is the size of the involved faces (for more detailed
description and verication, see [62]). Therefore, under this implementation for
face nodes, the running time of the algorithms INSERTEDGE and DELETEEDGE is
bounded by O(log s). This concludes our discussion.
Theorem 6.3.1 Under the above implementation on DLFL, the operators CREAT
EVERTEX and DELETEVERTEX take time O(1), and the operators INSERTEDGE
and DELETEEDGE take time O(log s), where s is the size of the involved faces.
Chapter 7
Create Pipe and Cut Operators
The two most common topology change operators in computer graphics are CRE
ATEPIPE and CUT). These operators are also used in Hybrid meshes [44]. There
are three problems with these operators for progressive renement schemes.
1. Topological inconsistency. The implementations of these operators generally
result in topological inconsistencies. These operators are generally imple
mented by two step processes.
CUT operator case: the operator cuts off a pipe from the 2manifold and
leaves two open holes (i.e. manifold becomes manifold with boundary) in the
rst step. The second step cut seals the two open holes by two disks (which
are the two new faces).
CREATEPIPE operator case: General implementations of CREATEPIPE oper
ator also follow a similar two step process. In the rst step, operator deletes
the faces f
1
and f
2
, which results in a 2manifold with boundary (with two
open holes). In the second step, the operator creates a pipe (as a shape
of prism) between the two holes and allows the pipe ends to seal the two
67
holes. In some cases, instead of creating a pipe, vertices on pipe ends are
simply merged.
Such implementations that result in topological inconsistency (i.e. creating
manifolds with boundaries as during the operation) are not acceptable for
progressive renement.
2. Continuous change. With CREATEPIPE and CUT operators it is not possible
to achieve gradual change. These operators requires many operations over
the mesh that can create a very visible qualitative change.
3. Flexibility. The concept behind CREATEPIPE and CUT operators is to create
or delete a prism shaped pipe and the operators can reduce or increase the
genus only by 1. However, the topology changes vary much more than simply
creating or deleting prism shaped connections and we may sometime need to
reduce genus more than 1.
For instance, CREATEPIPE and CUT operators are not able to handle cases
such as progressive renement of Sierpinsky tetrahedron as shown in Fig
ure 18.3. In this example, all the tetrahedra are uniformly converted to trun
cated tetrahedra (4 hexagons and 4 triangles) and tetrahedral shaped connec
tions connect the truncated tetrahedra. Moreover, the holes at the centers of
four tetrahedra are octahedral shape and closing these holes requires to reduce
genus more than one.
Among these problems, topological inconsistency can be solved by using a dif
ferent implementation approach as we will show in the next section. However, the
other two cannot be solved
7.1 Sequence of Minimal Operators
Using a sequence of INSERTEDGE and DELETEEDGE operators we can easily ob
tain more familiar topology change operators CREATEPIPE and CUT as shown in
Figure 7.1. As it is clearly shown in these examples there is no need to cut off along
the boundaries of the faces for creating a pipe and there is no need to seal faces af
ter cutting a pipe. The faces will be automatically cut and sealed by INSERTEDGE
and DELETEEDGE operations. Therefore, during topology changes no inconsistent
structure (i.e. manifold with boundary) will be created.
Figure 7.1: CREATEPIPE and CUT operators.
Chapter 8
NonIntuitive Nature of Topology
Changes
One of the reasons behind why the people try to avoid topology changes is that the
topology changes can be perceived as nonintuitive. There are two sources of this
problem: (1) the same operator can both simplify and complicate the topology and
(2) the same operator can both open (or close) holes and create (or delete) handles.
1. The same topology change operator can both simplify and complicate the
topology. Following two example illustrates this problem.
The CREATEPIPE operation can both complicate and simplify the topol
ogy. As shown in Figure 8.1. In 8.1(A) CREATEPIPE operation com
bine two genus0 surfaces creating one genus0 surface by simplifying
the topology. On the other hand, the same CREATEPIPE operation in
8.1(B) changes a genus0 surface into a genus1 surface by complicat
ing topology.
The CUT operation can also both complicate and simplify the topology.
As shown in Figure 8.2. In 8.2(A) CUT operation creates two genus0
71
Figure 8.1: The CREATEPIPE operation can both simplify and complicate the topol
ogy.
surfaces from one genus0 surface by complicating the topology. On
the other hand, the same CUT operation in 8.2(B) changes a genus1
surface into a genus0 surface by simplifying topology.
2. the same operator can both open (or close) holes and create (or delete) han
dles. Following two examples illustrate such cases.
The CREATEPIPE operation can create both handle or hole as shown in
Figure 8.3.
The same operation can delete a handle or a hole as shown in Figure 8.4.
Similar to the operators, CREATEPIPE and CUT, the operators INSERTEDGE
and DELETEEDGE can also both simplify and complicate the topology. Moreover
Figure 8.2: The CUT operation can both simplify and complicate the topology.
the same operator can both open (or close) holes and create (or delete) handles. The
following diagram demonstrates the effect of these operators.
Operator Genus The number
of surfaces
INSERTEDGE Increases Decreases
DELETEEDGE Decreases Increases
Operator Holes Handles
INSERTEDGE Opens Creates
DELETEEDGE Closes Deletes
Since the same operator can both complicate and simplify the topology, using
topology change operators is not as straightforward as using vertex split and edge
collapse operators. Therefore, it is necessary to be careful to guarantee simplica
Figure 8.3: The CREATEPIPE operation can create both hole or handle.
tion.
The above discussions clearly show that the operators INSERTEDGE and DELE
TEEDGE are inverse of each other. Once we obtained the operations for renement
process, to recover the initial mesh we will use the inverse operations. In other
words, although the operations are not really intuitive, once the operations are de
termined, nding the inverse is straightforward. Thus, the problem is reduced to de
veloping an algorithm that guarantees to simplify any 2manifold mesh to a genus0
surface.
Topology changes are not intuitive and therefore a great deal of care is neces
sary for handling topological simplication. We illustrate nonintuitive nature of
topology changes with several examples.
Figure 8.4: The CUT operation can delete either a handle or a hole.
Chapter 9
NonManifold Looking Manifold
Meshes
This chapter presents a simple algorithm to construct 2manifold meshes from ar
bitrary collections of polygons. We form our nal data structure using two very
basic manifoldpreserving operations, thus guaranteeing that the result is a valid
manifold. Our algorithm is purely topological and does not consider the geometric
properties of the underlying shape. Our goal is to provide a method for examining
a wide variety of manifold interpretations from nonmanifold data.
We have implemented this algorithm and we highlight the performance of our
algorithm on a number of sample models. The most signicant application of this
algorithm is to create unusual manifolds from nonmanifolds. To create a wide va
riety of manifold interpretations we intentionally introduce artifacts into a data set
such as wronglyoriented polygons or nonmanifold situations and create a num
ber of strange (but still manifold) objects. Our approach allows us the freedom to
explore a wide variety of manifold object representations that are not generally cre
ated or considered when modeling solids. An additional benet of the algorithm
77
is that it automatically and correctly creates the missing faces of manifolds with
boundaries.
9.1 Introduction and Motivation
When modeling shapes, the construction of a manifold representation is often desir
able, although it can be difcult to achieve. In this paper, we present an algorithm
for constructing manifolds from a given collection of arbitrary polygonal data. Our
algorithm allows one to create unusual manifold meshes.
9.1.1 Motivation
For many shape modeling applications, we desire that the meshes describing object
boundaries be represented as valid and correct 2manifolds in 3D. Certain algo
rithms (e.g. certain subdivision surface and object intersection algorithms) rely on
this property to guarantee correctness. This issue becomes apparent in very practi
cal situations. For instance, any modeling system fails when DooSabin subdivision
[168, 186] is applied to a nonmanifold mesh since DooSabin requires manifold
meshes.
Graphics le formats in particular often omit topological information, as only
the geometric denitions of polygons are necessary for display purposes. Alias
Wavefronts obj le format and the STL format are examples of such common
graphics le formats. In such formats, the geometry is fundamentally stored as just
a collection of oriented polygons. Such a collection of polygons can have a wide
variety of manifold interpretations. Existing methods to convert these unorganized
polygons into manifolds focus on creating a single and sensible representations. We
would like to have a simple and straightforward way to construct a wide variety of
valid manifold meshes.
9.1.2 Algorithm Properties
We present an algorithm for constructing manifold meshes from an arbitrary collec
tion of oriented polygons. This algorithm reads in a collection of oriented polygonal
faces, each described by an ordered sequence of vertices. Using only topological
operations, it constructs a manifold solid from this data. The algorithm has the
following properties:
The output is always a manifold. If the original data corresponds to a single
valid manifold solid, then that is the manifold that will be output.
Each face is oriented in a way consistent with the other faces in the manifold.
There are no twogons (twosided faces).
No new vertices are created.
No looping edges (edges from one vertex to the same vertex) are created.
Note that because our algorithmis based entirely on topology, it ignores the geo
metric properties of the underlying shape. Avoiding geometry has its own benets.
In some applications, nonmanifold input, wronglyoriented faces, or nonplanar
cracks can create problems, such as output polygons for which the vertices are not
coplanar. Although this may be undesirable in certain situations, we view this as
a potential benet it allows us to examine the manifold representations possible
when nonstandard data (such as a wronglyoriented face or nonmanifold situa
tion) is provided.
9.1.3 Main Results
The most signicant result in the work we present here is insight into manifolds
by creating unusual manifolds from nonmanifolds. Given input that corresponds
to a nonmanifold (including cases such as dangling faces), we generate a manifold
interpretation of the data. Note that there might be many possible manifold inter
pretations for the given data. For example, Figure 9.1 shows two usual manifold
interpretations of the nonmanifold shape at the left. Our algorithm creates a com
pletely different and unusual manifold interpretations that cannot be created with
standard modeling techniques. Some of these manifold interpretations can provide
interesting initial shapes for subdivision surfaces.
Figure 9.1: Two 2manifold interpretions of a nonmanifold.
By intentionally introducing artifacts into a data set such as wronglyoriented
polygons or nonmanifold situations, we can create a number of strange (but still
manifold) objects. Our approach allows us the freedom to explore a wide variety of
manifold object representations that are not generally created or considered when
modeling solids.
An additional benet of the algorithm is crack repair. Our algorithm provides
a simple method to automatically ll holes in the input model. That is, if the input
polygons correspond to a manifold with boundary, the output will be a manifold.
We do not need to explicitly determine the boundaries of holes.
9.2 Previous Work
The transfer of data between various systems and le formats can be the cause
of signicant problems when modeling solids. Often the output to an interme
diate le format loses much of the topological information that a particular sys
tem maintains internally. In other cases, data that is valid in one system creates
problems in another. This problem motivated a great deal of work and various
algorithms have been developed for the identication and correction of artifacts.
[129, 120, 128, 125, 130].
Some methods have focused on creating topological information from pure ge
ometric descriptions. An example of this is the work of Rock and Wozny, where un
ordered sets of triangular faces (froman STL le) are cobined into a manifold [129].
Often, such methods are intended to take into account numerical error that has
been introduced during le conversion. Barequet and Kumar, [120] and Murali and
Funkhouser, [128] both have addressed work in this direction. More topologically
oriented approaches have been explored by others, such as Rossignac and Cardoze
[130] and Gu eziec et al. [125]. These approaches generally focus on trying to de
rive a single true manifold representation from a nonmanifold input, such that
the manifold representation is appropriate for a particular application (such as solid
modeling). While some of this work allows for more general shape representa
tions (e.g. that of Gu eziec et al. [125]), it is not oriented toward generating a wide
variety of possible manifold interpretations. Finally, issues of manifold versus non
manifold representations have been addressed in more general settings and applied
to other modeling problems (e.g. the work of Dey et al.[123])
These methods are often quite complicated and rely on geometric information.
While geometric considerations have great usefulness and may address many prac
tical problems, the utility of such techniques will vary depending on the particular
application. Since such geometric techniques are not universally applicable, they
will need to be tuned to particular data sets.
9.2.1 Overview of the Algorithm
The algorithm consists of three steps.
1. Read all vertex positions and create a pointsphere for each vertex using the
CREATEVERTEX operator. Let 1 be the array of pointspheres thus created.
2. Read all faces. Parse each face and create a list of edges present in each face
using the index into the array 1 to denote the edge ends.
3. Go through the list of edges created in step 2 and insert each edge. If an edge
already exists between two vertices it need not be inserted again. If an edge
would cause a selfloop it is not inserted.
The edges created in step 2 will be represented as a pair of corners. Note that
corners in different faces can share the same vertex. Each vertex stores a list of
corners that refer to it.
The edge insertion process uses the INSERTEDGE operator which inserts an
edge between two corners. To insert an edge we rst need to nd the two end
corners. Initially we have only a group of distinct pointspheres each corresponding
to a vertex in the model and each containing one corner. Before any edges are
inserted all these corners are tagged with a marker.
Let the two ends of edge e
1,2
be the corners c
1
= a, v
1
, b and c
2
= c, v
2
, d
referring to vertices v
1
and v
2
respectively. (As we have mentioned earlier, a corner
can be considered as a sequence of three vertices belonging to a face except when
the face is a point sphere.) Inserting an edge involves the following steps:
1. Get the list of corners referring to vertex v
1
and v
2
. We will refer to these lists
as C
v
1
and C
v
2
corresponding to v
1
and v
2
respectively. To nd the corner
corresponding to c
1
, go through C
v
1
and nd the corner which is preceded
by vertex a or followed by vertex b. If C
v
1
contains only 1 corner select that
corner. The corner corresponding to c
2
is found similarly using C
v
2
. If either
of C
v
1
or C
v
2
contains more than one corner and a matching corner for c
1
or
c
2
cannot be found, postpone insertion of this edge.
2. If we can nd matching corners for both c
1
and c
2
in the above step, do the
actual edge insertion using the INSERTEDGE operator.
After the rst pass, we go through the list of postponed edges and repeat the
above steps again.
If in two successive passes no postponed edges could be resolved, it indicates
that the object has multiple 2manifold interpretations. We choose one of the inter
pretations arbitrarily
1
by picking the originally tagged corner during the next pass.
Note that this might need to be done for only one of the postponed edges since other
edges might be resolved after this edge is inserted.
Once no more edges are left to be inserted the algorithm terminates.
9.3 Results
Our algorthm is implemented in C++ and has been incorporated into an existing
manifold mesh modeling system. One of the main uses of the algorithm is to ensure
thatWavefront obj les are always imported as correct manifolds. Corrupt les such
as the ones representing nonmanifolds or manifolds with boundaries could crash a
1
Note that this arbitrary choice depends only on the order of faces in the face list. In other words,
there is a unique manifold interpretation for any given face list order. Thus, a given order will
always give the same output. By arbitrarily choosing the order, we can create a variety of manifold
interpretations.
manifold modeler. The new reader guarantees that we always deal with manifold
meshes.
Our algorithm has been successfully tested on several publicly available models
ranging in size from a few polygons to several thousands. We found that in practical
examples the algorithm appears to be O(nlogn) in terms of the number of edges.
9.3.1 Manifolds
Manifold mesh construction from manifold data is straightforward. It can easily
be seen that if the arbitrary collection of polygons corresponds to a valid manifold,
then the algorithm will create the corresponding manifold mesh. Because each
edge of the manifold will be inserted exactly once, and each edge insertion will be
consistent with the correct manifold representation, the resulting manifold will
be the one described by the input data.
9.3.2 NonManifold Conversion and Insight to Manifolds
The interpretation of nonmanifold cases are more interesting. Using the reader,
we can convert nonmanifolds to manifolds. This conversion gives us a powerful
insight into the nature of manifolds. Some of the manifold shapes we create using
this conversion sometimes defy conventional wisdom.
We present three examples illustrated in Figures 19.1, 9.3 and 9.4. As will
be clear in all three examples, in order to convert a nonmanifold to a manifold,
our algorithm combines some of the faces to create larger faces. The conversion
maintains the integrity of the edge directions in the combined faces.
In each of these gures, the leftmost image shows the nonmanifold shape. The
middle column shows some manifold interpretations of the nonmanifold shape.
The rightmost column shows the result of two iterations of DooSabin subdivi
sion applied to the manifold representations in the middle column. The DooSabin
smoothed versions are included (1) to demonstrate that nonmanifold geometry
has been converted to manifold, since DooSabin can only be applied to mani
fold meshes and (2) to visually show that genus can vary, i.e. different manifold
interpretations can have different genera.
The rst example is shown in Figure 19.1. This nonmanifold shape is given by
the following faces that are represented by cyclic ordered sets:
f
0
= 3, 2, 1, 4 f
1
= 7, 8, 9, 10
f
2
= 2, 3, 6 f
3
= 4, 1, 5
f
4
= 6, 9, 8 f
5
= 5, 7, 10
f
6
= 6, 5, 10, 9 f
7
= 5, 6, 3, 4
f
8
= 6, 8, 7, 5 f
9
= 1, 2, 6, 5
If the faces are given with the order above, our algorithm converts this non
manifold to a manifold by combining faces f
8
and f
9
into one hexagonal face f
10
=
1, 2, 6, 8, 7, 5 as shown in top row of Figure 19.1. Note that the hexagon f
10
is automatically created once we insert all the edges. More interesting cases can
occur when the algorithm reads the faces in different orders. One such case is
shown in the bottom row of Figure 19.1. In this case the faces f
4
, f
5
, f
7
and f
9
are combined into one face f
11
= 9, 8, 6, 3, 4, 5, 7, 10, 5, 1, 2, 6. This large face is
self intersecting and makes the genus of the object 1 as can clearly be seen in the
DooSabin smoothed image.
The second example is shown in Figure 9.3. This nonmanifold shape is given
by the following faces that are represented by cyclic ordered sets:
f
0
= 3, 2, 1, 4 f
1
= 6, 7, 8, 9
f
2
= 1, 2, 5 f
3
= 7, 6, 5
f
4
= 4, 1, 5 f
5
= 6, 9, 5
f
6
= 3, 4, 5 f
7
= 9, 8, 5
f
8
= 2, 3, 5 f
9
= 8, 7, 5
If the faces are given with the order above, our algorithm converts this non
Figure 9.2: Two 2manifold interpretations of a nonmanifold.
manifold to a manifold by combining faces f
8
and f
9
into one hexagonal face f
10
=
2, 3, 5, 8, 7, 5 as shown in top row of Figure 9.3. The second and third rows show
two other interpretations when the algorithm reads the faces in different orders.
In the middle row, f
9
and f
2
are read as the last two polygons and the algorithm
combines them into a new face f
11
= 1, 2, 5, 8, 7, 5. In the last row, f
9
and f
4
are read as the last two polygons and the algorithm combines them into a new face
f
12
= 4, 1, 5, 8, 7, 5. In this example it is clear that the algorithm treats the last
two polygons as if they are missing.
In the next example, we have introduced an aditional face inside of a prism as
shown in Figure 9.4. This shape is given by the following faces that are represented
by cyclic ordered sets.
f
0
= 4, 3, 2, 1 f
1
= 9, 10, 11, 12
f
2
= 7, 8, 12, 11 f
3
= 3, 4, 8, 7
f
4
= 4, 1, 5, 8 f
5
= 8, 5, 9, 12
f
6
= 2, 3, 7, 6 f
7
= 6, 7, 11, 10
f
8
= 1, 2, 6, 5 f
9
= 5, 6, 10, 9
f
10
= 5, 6, 7, 8
Since this visual example is more complicated than earlier ones, we have not
drawn the face f
10
and the initial shape looks like a simple prism. If the faces are
given with the order above, our algorithm simply eliminates the face f
10
as shown
in the top row of Figure 9.4. The more interesting example is shown in the bottom
row of Figure 9.4. In this case, several faces are combined. Since more than one
combined face is created we have not highlighted them to avoid confusion. The
following information can be helpful to understand the manifold structure shown in
the bottom row:
f
4
and f
5
combine and become a hexagon as 4, 1, 5, 9, 12, 8.
f
6
and f
7
combine and become a hexagon as 2, 3, 7, 11, 10, 6.
f
3
, f
8
and f
10
combine and become one octagon as 3, 4, 8, 5, 1, 2, 6, 7.
Although we do not give any examples here, we tested our algorithm on models
that include some wronglyoriented faces. As in the case of nonmanifold input
data, the conversion maintains the integrity of the edge directions by combining
two or more faces into one.
9.3.3 Crack Repair for Manifolds with Boundaries
How the algorithm repairs cracks can be understood by looking at two examples of
manifolds with boundaries that are shown Figure 9.5. As shown in the gure, all the
cracks (i.e. missing polygons) are enclosed by boundary edges. In our algorithm,
when we insert these boundary edges, the missing faces bounded by those edges
are automatically created.
When enough edges are inserted to create a polygon, two faces are effectively
created, a front face and a back face (see Figure 5.3). This back face can be
thought of as lling in the empty area (i.e. the crack) around that polygon. As
additional edges are inserted, this back face continues to ll in the regions not yet
inserted into the model. Note that there may be several of these back faces existing
simultaneously. Once all edges have been inserted, these back faces thus repair the
cracks that might exist in the input data. Note that the orientation of these back
faces will always be consistent with the rest of the model, as one would like.
We give below a simple example to demonstrate how crack repair works. Let
the input data be a tetrahedron with a missing face and the faces be given as f
0
=
v
0
, v
1
, v
2
, f
1
= v
0
, v
3
, v
1
and f
2
= v
0
, v
2
, v
3
. The algorithm rst inserts
edges for the face f
0
, v
0
, v
1
v
1
, v
2
and v
2
, v
0
. After inserting these 3 edges
a back face f
b
= v
0
, v
2
, v
1
will be automatically created. Then, the algorithm
inserts remaining edges for face f
1
, which are v
0
, v
3
and v
3
, v
1
. As a result,
the back face now becomes f
b
= v
0
, v
2
, v
1
, v
3
. In the next step, the algorithm
adds remaining edges for the face f
2
, which involves adding only the edge v
2
, v
3
.
Inserting this edge divides f
b
into two. One part becomes the face f
2
, while the
remaining back face is f
b
= v
2
, v
1
, v
3
. Notice that f
b
now lls in, with correct
orientation, the crack created by the missing face of the tetrahedron.
9.4 Conclusion and Future Work
Manifolds with boundaries, nonmanifolds, and artifacts are very common in com
puter graphics les. Many modeling packages allow manifolds with boundaries
and nonmanifolds. Also, many practical mesh data structures allow arbitrary col
lections of polygons that can include artifacts such as wronglyoriented polygons
and Tjunctions.
In this paper, we have developed an algorithm to convert an unorganized set of
polygons to a manifold mesh. Our algorithm totally ignores the geometric prop
erties of the underlying shape. For instance, self intersections are not considered
and cannot be eliminated by our algorithm. Moreover, two vertices are considered
different if they are declared separately regardless of their position (i.e. even if their
positions are the same, they are considered different). Ignoring the geometry greatly
simplies our algorithm.
While the focus of our approach is strictly topological, a number of geomet
ric operations could be applied as a preprocess or postprocess step. For example,
coincident vertices in the input could be easily merged before applying our algo
rithm. Such techniques are common in many methods that look at both geometry
and topology (e.g.[129]).
9.4.1 Future Work
Our algorithm is useful in other aspects of modeling system implementation. For
example, our technique has been used to create the dual of any 2manifold mesh.
Ignoring twogons and selfloops is extremely useful for le input or transfer since
we do not create unnecessary edges. However, if this algorithm is used for other
operations, this restriction can be a problem. One problemwith the dual operation is
that if the initial mesh has valence2 or valence1 vertices, the dual cannot correctly
be created since it should have twogons and selfloops. Thus, in order to use the
algorithm to simplify programming tasks, we would need to include twogons and
selfloops.
Including geometry can be another improvement. For instance, all the shapes
in Figure 9.3 are the same in terms of topology. However, each shape gives a
different subdivided shape. By augmenting our strictly topological methods with
some geometric constraints, we could provide users additional control.
Figure 9.3: Three 2manifold interpretations of a nonmanifold. Note that in this
case the topological representations are the same for all three cases.
Figure 9.4: Two 2manifold interpretations for a nonmanifold.
Figure 9.5: Examples of manifolds with boundaries.
Chapter 10
Handle and Hole Improvement with
Subdivision
In this paper, we present a new paradigm that allows dynamically changing the
topology of 2manifold polygonal meshes. Our new paradigm always guarantees
topological consistency of polygonal meshes. Based on our paradigm, by simply
adding and deleting edges, handles can be created and deleted, holes can be opened
or closed, polygonal meshes can be connected or disconnected.
These edge insertion and edge deletion operations are highly consistent with
subdivision algorithms. In particular, these operations can be easily included into
a subdivision modeling system such that the topological changes and subdivision
operations can be performed alternatively during model construction.
We demonstrate practical examples of topology changes based on this new
paradigm and show that the new paradigm is convenient, effective, efcient, and
friendly to subdivision surfaces.
93
10.1 Introduction
Parametric representations such as Bezier surfaces, Bsplines and NURBS have
long been popular for designing smooth shapes [70, 58]. The greatest power of
parametric representations is that they allow real time smooth shape design [58].
Unfortunately, these widely used tensor product parametric representations do not
provide a large variety of topologies since the control meshes of tensor product
parametric surfaces must be organized as a regular rectangular structure [83].
Subdivision methods [165, 168, 107, 76, 90, 89, 66] solve the fundamental prob
lem of tensor product parametric surfaces without sacricing the speed of shape
computation. Unlike tensor product surfaces, in subdivision surfaces, the control
meshes do not have to have a regular rectangular structure. Subdivision algorithms
can smooth out 2manifold (or 2manifold with boundary) polygonal meshes [186].
An important property of subdivision surfaces is that they are a generalization
of parametric surfaces. If the control mesh is organized as a regular rectangular
structure, any parametric surface can be represented by subdivision algorithms. For
instance, the DooSabin surface [168] is a generalization of quadric Bsplines and
the CatmullClark surface is a generalization of cubic Bsplines [165] and Non
uniform rational subdivision surfaces [90] are the generalization of NURBS.
The main problemwith subdivision schemes is that they do not support topology
change. This restriction means that with subdivision algorithms the designers can
only change the shape of the objects. They cannot add or delete handles, open
and close holes, connect or disconnect two objects. Since these topology changing
operations are essential for designing unusual and interesting shapes, it is important
to combine these operations with subdivision algorithms.
In this paper, we present a purely polygonal and nonimplicit approach
changing the topology of polygonal meshes. The topological changes we demon
strate include opening and closing holes, creating and deleting handles, connect
ing two disjoint meshes into one, and separating one mesh into two disconnected
ones. These topological changes are simply done by inserting or deleting edges
to a polygonal mesh. During these operations, we also guarantee that polygonal
meshes remain valid 2manifolds. Therefore, unlike implicitly based topological
operations, our operations are subdivision friendly, i.e., subdivision operations can
always smooth out the meshes obtained by our operations.
Our approach to handling topological changes makes a natural partner with the
subdivision approach within a 3D modeling system. Our approach is not only suit
able for modeling initial 2manifold polygonal meshes, but also useful for chang
ing the topology of a 2manifold polygonal mesh that are smoothed by subdivision
operations. Since subdivision operations are essential for the improvement of the
quality of meshes, performing the topological change operations and the subdi
vision operations alternatively provides a powerful shape modeling approach that
supports a hierarchy of topology changes and quality improvements at different
levels of details.
Our approach is based on graph rotation systems. A graph with a rotation sys
tem is embedded to a unique 2manifold shape [169]. It always guarantees the rep
resentation of valid 2manifold polygonal meshes. Moreover, it is easy to change
the topology of meshes by simply inserting or deleting edges in the corresponding
graph rotation system. An edge insert operation can either (1) combine two faces
by inserting a hole, (2) combine two faces by adding a handle, (3) combine two
faces by joining two separate 2manifold meshes, or (4) subdivide a single face into
two. Conversely, an edge delete operation can either (1) separate one face into two
by closing a hole, (2) separate one face into two by deleting a handle, (3) separate
one face into two by disconnecting one 2manifold object into two, or (4) combine
two faces into one. In either operations the rst three cases change the topology of
a mesh. The last one does not change the topology, it only changes the number of
polygons.
In order to represent graph rotation systems and efciently implement edge in
sertion and deletion operations, we have developed the Doubly Linked Face List
(DLFL) data structure. Using DLFL, we demonstrate examples of topology changes
based on this newparadigmand showthat the paradigmis convenient, effective, and
efcient for topological changes for subdivision surfaces.
We rst introduce the concepts behind subdivision methods and topological re
quirements imposed by subdivision methods. We then introduce the previous works
in graph rotation system. Then, we demonstrate why and how edge insert and edge
delete operations work by illustrating each of these cases with gures. The discus
sions in these sections are formal and abstract. The readers who are interested in
only implementation issues can skip them and go directly to the section that covers
implementation issues and examples.
10.2 Topological Consistency and Subdivision Meth
ods
With the introduction of subdivision surfaces and wider usage of implicit surfaces,
topology has become an important element of computer graphics research, devel
opment and production. There has been various studies in topological modeling
during the last decade [171, 183, 91, 173].
Subdivision surfaces assume that the users provide an irregular control mesh.
These initial control meshes can either be created by direct modeling or obtained
by scanning a sculpted real object. A smoother version of this initial mesh without
changing the original topology is obtained by subdivision operations. All subdi
vision schemes can be expressed by a set of linear difference equations. More
formally, each new point is computed as a linear combination of a set of points in a
local topological region. The scheme can be written as a linear system
p
n+1
= Ap
n
where p
n
and p
n+1
are the vectors of respectively the old points and the new points
in the local topological region and A is the transformation matrix [186]. Note here,
the local topological region should correspond to a simple disk (topologically). This
implies that underlying structure must be a valid 2manifold.
Since the quality and topology of the smooth surface resulting from subdivision
rules depend greatly on the initial control mesh, theoretical assurance of the qual
ity of initial control meshes is extremely important. In other words, the process of
obtaining the initial control mesh must be robust and guarantee valid 2manifolds.
Unfortunately, set operations, which are the most commonly used operations in
mesh modeling, can result in nonmanifold surfaces. Moreover, the existing data
structures in mesh modeling are specically developed in such a way that they can
represent nonmanifold surfaces resulting from the set operations. In particular,
they do not guarantee valid 2manifold surfaces. Because of this fundamental prob
lem, in the process of obtaining the initial control mesh, unwanted artifacts can
be generated. These artifacts include wronglyoriented polygons, intersecting or
overlapping polygons, missing polygons, cracks, and Tjunctions. There have been
recent research efforts to correct these artifacts [120, 128].
Besides guaranteeing topological consistency, data structures for mesh model
ing should also support topological operations efciently.
The classical view of mesh representation is based on adjacency relationships
between points, edges and faces. For instance, the vertexedge adjacency relation
ship species two adjacent vertices for each edge. There exist nine such adjacency
relationships, but it is sufcient to maintain only three of the ordered adjacency
relationships to obtain the others [95].
In most practical computer graphics applications, meshes are often represented
with one adjacency relationship. The data structure is generally organized as an
unordered list of polygons where each polygon is specied by an ordered sequence
of vertices, and each vertex is specied by its x, y, and z coordinates [120]. Let
us call this data structure a vertexpolygon list. Vertexpolygon lists do not always
guarantee topological consistency. In addition, they can even create degeneracies
such as cracks, holes and overlaps [120, 128].
These degeneracies can be partly eliminated by adding an additional adjacency
relationship: edge lists to vertexpolygon lists [120]. In a vertexpolygonedge
list structure, a list of vertices, a list of directed edges, and a list of polygons
are described. Vertices are specied by their three coordinates, directed edges
are specied by two vertices, and polygons are specied by an ordered sequence
of edges. Each polygon is oriented in a consistent direction, typically counter
clockwise when viewed from outside of the model. Because of the last condition,
vertexpolygonedge lists are more powerful than vertexpolygon lists. However,
the representation does not guarantee valid manifold surfaces either. It is still pos
sible to specify a nonmanifold surface in terms of the vertexpolygonedge list.
One of the oldest formalized data structures that supports manifold surfaces is
the wingededge representation [163]. Baumgart also suggested using a winged
edge structure and Euler operators in order to obtain coordinate free operations
[60]. Wingededge data structures support 2manifold surfaces, and starting from a
valid 2manifold mesh, wingededge can only create valid 2manifolds with Euler
operators. However, like vertexpolygonedge lists wingededge structures can also
accept nonmanifold surfaces [163, 94]. To represent Voronoi diagrams and De
launey triangulation, Guibas and Stol introduced the quadedge data structure and
two topological operators, makeedge and splice [178]. Like wingededge structure,
quadedge structure creates valid 2manifolds with makeedge and splice operations
if it starts from a valid 2manifold. Unfortunately, quadedge data structures can
still support nonmanifold surfaces.
When using set operations, resulting solids can have nonmanifold boundaries
[180, 79]. It is worthwhile to note that although the data structures, such as winged
edge, can handle some nonmanifold surfaces, they actually complicate the algo
rithms for solid modeling [79, 86]. Therefore, it is interesting to note that data
structures that can support a wider range of nonmanifold surfaces have been later
investigated. Examples of such work are Weilers radialedge structure [96], Kara
sicks staredge structure [85], and Vaneceks edgebased data structure [93].
In the current paper, we propose to return back to the basic concept of coordinate
free operations over 2manifold surfaces by ignoring setoperations. Similar to our
approach, instead of set operations the usage of Morse operators that describe the
changes of crosssectional contours at critical sections (peaks, passes and pits) has
recently been investigated [183, 173]. We use topological graph operations which
are similar to Eulers operations and based on graph embeddings. The biggest ad
vantage of our operations is that they are extremely simple and always guarantee
topological consistency. Only two operations, Insert edge and Delete edge, are
enough to change the topology. If an inserted or deleted edge change the topology,
we can efciently nd the new topology by using graph embeddings. This efcient
computation is due to our Doubly Linked Face List (DLFL) data structure [167].
We propose to use this data structure to support a representation in which the basic
topological operations related to computer graphics, such as surface subdivision,
adding or removing a handle, can all be done very efciently.
DLFL not only supports efcient computations on 2manifolds, but also always
guarantees topological consistency, i.e. it always gives a valid 2manifold.
DLFL structure is based on the classical theory of graph rotation systems. An
extensive research has been done in the study of graph rotation systems. Among the
extensive research in the area by mathematicians, the most remarkable result is that
graph rotation systems provide necessary and sufcient conditions in representing
valid 2manifolds. Our DLFL structure is an efcient implementation of graph
rotation systems.
10.3 Implementation
As we have stated earlier, graph rotation is a mathematical concept. Although, it
can be easily implemented as a set of linked lists, it does not support computer
graphics implementations efciently. One of the main problems using such a graph
in an interactive system is that it requires construction of faces in each rendering
step.
10.3.1 DLFL Structure
In our implementation, we use a Doubly Linked Face List (DLFL), a data structure
we have proposed theoretically earlier [156]. A DLFL structure always corresponds
to a graph rotation system. Therefore, it always guarantees valid topological consis
tency [156]. The main reason that we use DLFL is that it supports logarithmic time
edge insertion and deletion operations with face construction. With the DLFL
data structure, subdivision operations can also be implemented easily.
In DLFL structure, each face is given by a sequence of vertices corresponding
to a boundary traversing of the face.
1
The vertex appearances in the sequence will
be called vertex nodes. Note that two consecutive vertex nodes in the sequence
correspond to an edge side in the rotation system. The sequence is represented by a
cyclically concatenatable data structure.
Formally, let (G) be a rotation system of a graph G = (V, E) with face set
F. A doublylinkedfacelist (DLFL) for the rotation system (G) is a triple L =
T, 1, c), where the face list T consists of a set of [F[ sequences, each is given by
1
To simplify the implementation we use linked lists for the faces. To further improve efciency
of our system, balanced trees for boundary walks of faces can be used instead of linked lists [156].
a linked list and corresponds to the boundary walk of a face in the rotation system
(G). Moreover, these linked lists are connected by a circular doubly linked list.
The vertex array 1 has [V [ items. Each 1[v] is a linked list of pointers to the vertex
nodes of v in the face linked lists in T. The edge array c has [E[ items. Each 1[v]
also includes the 3D position of the related vertex. Each c[e] is doubly linked to
the rst vertex nodes of the two edge sides of the edge e in the face linked list in T.
Figure 10.1 gives an illustration of the DLFL data structure for a tetrahedron.
Figure 10.1: An illustration of the DLFL data structure for a tetrahedron (Only
details for vertex v
1
and edge e
5
are shown).
10.3.2 Examples
To show the feasibility of our approach, we have created various 3D models that
show the connection of several 2manifolds and the creation of handles and holes.
In all our examples, we rst convert irregular meshes into meshes that consist of
only quadrilaterals to obtain initial mesh. We, then, smooth out this initial mesh by
using CatmullClark subdivision scheme [165].
Figure 10.2 shows the connection of four disconnected tetrahedra. All faces
of the tetrahedra are rst subdivided to make each face a quadrilateral. Then,
the inside faces of every two neighboring tetrahedra are connected by an in
nitely small edge. It is interesting to note that these 3D shapes may look
nonmanifold. They are actually 3D representations of a rotation system
which is a representation of a 2manifold. Therefore, we can apply subdi
vision algorithms. On the other hand, if they had been represented by set
operations, even the internal representation would have been nonmanifold.
Figure 10.2: Connecting four tetrahedra.
Figure 10.3 shows the connection of two disconnected toroids. This gure
also gives an example of handle improvement by inserting additional edges.
As can be seen clearly in Figure 10.3, when only one edge is inserted it creates
a C
1
discontinuous extraordinary vertex. Inserting extra edges removes this
C
1
discontinuity.
Figure 19.5 shows an example of the creation of a handle for a cup and
demonstrates handle improvement by inserting additional edges.
Figure 10.5 shows an example of the creation of a hole. As it is clear in this
gure, each additional edge improves the quality of the hole in the cube.
More gures are provided in the color pages. The Figures 10.6, 10.7, 10.8
and 10.9 shows two examples of topological changes. The Figures 10.6 and 10.7
shows the creation of various handles for a small stellated dodecahedron [152] (a
regular polyhedron discovered by Kepler). The Figures 10.8 and 10.9 shows the
creation of several holes in a great dodecahedron [152] (A regular polyhedron dis
covered by DePoinsot, 100 years after Kepler. It is the dual of small stellated do
decahedron).
We offer a few implementation remarks before we close this section.
The topological changes are implemented in our approach by connecting faces
in a polygonal mesh. The type of the topological changes is closely related to the
visibility of the corresponding faces. Generally speaking, if the faces are visible
from each other from the outside of the mesh, then adding an edge to connect
the two faces creates a handle to the mesh. If the faces are visible from each other
from inside of the mesh, then adding an edge to connect the two faces opens a
hole in the mesh. When the two faces are not visible from each other, either from
outside or from inside, adding a straight edge to connect the two faces still gives
a topologically correct mesh but the mesh will be geometrically selfintersected.
Thus, the users can easily avoid such selfintersections based on the face visibility
properties.
Using more than one straight edge to connect two faces creates an extraordi
nary point with very high valance in the face handle since each edge adds 2 to the
valance. Such an extraordinary point with a high valance will most likely be C
1
dis
continuous. It is easy to avoid extra edges by extruding the faces before inserting
an edge as shown in Figure 19.5 as an example of the creation of a handle.
10.4 Conclusion and Future Work
In this paper, we presented a new paradigm for changing topology of 2manifold
meshes without using an implicit approach. Our new paradigm guarantees the 2
manifold property for meshes during these topological changes. The new paradigm
for changing topology is highly consistent with the subdivision approach in a 3D
modeling system. Our approach can be used for modeling initial 2manifold polyg
onal meshes, as well as for changing the topology of 2manifold polygonal meshes
that are smoothed by CatmullClark subdivision operations. Note that smoothing
operations provided by subdivision approach are essential for improving the qual
ity of 2manifolds. Thus, the topological change and subdivision operations per
formed alternatively during model construction provide a powerful shape modeling
paradigm that supports a hierarchy of topology changes and quality improvement
in different levels of details.
Our approach can also be extended to include topological changes into progres
sive meshes [80] and multiresolution representations of meshes [69, 65]. Two major
operations in progressive meshes technique are vertexsplit and edgecollapse. It
can be shown that these operations do not change the topology [177]. The same can
also be easily shown for multiresolution representations of meshes. In fact, one of
the major problem in multiresolution mesh morphing is that source and target must
share the same topology [81]. By including the edge insertion and edge deletion
operations, it is possible to change the topology for progressive meshes and mul
tiresolution representations. Thus, this approach may potentially add new power to
the existing morphing, compression and simplication schemes.
Figure 10.3: Connecting two toroids: the same colored faces connected with edge
insertion.
Figure 10.4: Creation of handle for a cup.
Figure 10.5: Creation of a hole in a cube.
Figure 10.6: Creation of various handles for small stellated dodecahedron.
Figure 10.7: Handles improvement for for small stellated dodecahedron.
Figure 10.8: Creation of various holes for great dodecahedron.
Figure 10.9: Hole improvement for great dodecahedron.
Chapter 11
Corner Cutting Schemes
A recently developed topological mesh modeling approach allows users to change
topology of orientable 2manifold meshes and to create unusual faces. Handle
faces are one of such faces that are commonly created during topology changes.
This paper shows that vertex insertion and corner cutting subdivision schemes can
effectively be used to reconstruct handlefaces. These reconstructions effectively
show the structure of these unusual faces. The paper has three contributions. First,
we develop a new corner cutting scheme, which provides a tension parameter to
control the shape of subdivided surface. Second, we develop careful and efcient
remeshing algorithms for our corner cutting scheme that use only the basic opera
tions provided by our topological mesh modeling approach. This implementation
ensures that our new corner cutting scheme preserves topological robustness. Fi
nally, a comparative study shows that the corner cutting schemes create better han
dles and holes than the wellknown CatmullClark scheme.
111
11.1 Introduction and Motivations
With the introduction of subdivision surfaces and the wider usage of solid mod
eling and implicit surfaces, topology has been becoming an important element of
computer graphics research, development and production. There have been various
studies in topological modeling during the last decade [180, 79, 147, 171, 183, 91,
173].
We have recently introduced topological graph theory [169, 146, 167] to com
puter graphics for effective and robust modeling of 2manifold meshes [156]. We
have also introduced a new data structure Doubly Linked Face List (DLFL), which
guarantees topological consistency and provides topological changes [156, 167].
We have identied two operations INSERTEDGE and DELETEEDGE to change mesh
structure and manifold topology. Our recent investigation suggests that these two
operations with two fundamental Euler operations, MVFS and KVFS [147], which
we call CREATEVERTEX and DELETEVERTEX respectively, form a complete and
minimal set of operations for robust and userfriendly modeling of any orientable
2manifold mesh. In other words, these four operations constitute a necessary and
sufcient minimalset upon which all homeomorphic and topological operations
can be implemented [?].
By using our approach, it is easy to change the topology of polygonal meshes.
The topological changes we demonstrate include opening and closing holes, creat
ing and deleting handles, connecting two disjoint meshes into one, and separating
one mesh into two disjoint ones. During these operations, we also guarantee that
polygonal meshes remain valid 2manifolds.
Motivation for this paper comes from reconstruction of unusual faces that we
encounter during topology changes. These unusual faces which we call handle
faces are created by our INSERTEDGE operation [156, 167] that can combine two
distinct faces with a single edge. In most cases, the resulting handleface cannot
be effectively rendered with current graphics hardware. In order to see the actual
structure of this handlefaces, we need to reconstruct them.
In most cases, these handlefaces are at least octagons and it is difcult to recon
struct them using parametric methods [70, 58, 83]. Instead, subdivision schemes
[165, 168, 107, 90, 66] provide an attractive alternative for the reconstruction of
such handlefaces. In fact, we have recently shown that CatmullClark subdivision
algorithm [165] over the DLFL structure [133] can effectively be used to recon
struct these handlefaces. Reconstruction with CatmullClark subdivision greatly
improves the quality of handlefaces. However, in the rst iteration of Catmull
Clark, high valence extraordinary vertices are created. Limit surfaces around these
vertices generally have ripples that give a G
1
discontinuous look.
In this work, we further study the handleface reconstruction with subdivision
algorithms. We rst develop a new corner cutting algorithm and implement it with
our minimal set of operations [?]. The new algorithm is similar to DooSabin sub
division scheme, and has the property that users can control the shape of subdivided
surface via a parameter. This parameter is independent of the valence of the faces
(the valence of a face is the number of sides of the face).
We have also developed two algorithms to remesh a 2manifold mesh based on
the corner cutting scheme. These algorithms are entirely based on our minimal set
of operations.
In one of the algorithms, the new mesh is constructed by adding and deleting
edges to the old mesh, and the other algorithm creates the new mesh from scratch
starting from a single vertex and keeps the old mesh completely intact. Since both
algorithms are entirely based on our minimal set of operations, they guarantee the
topological robustness of the implementation.
Finally, we compare our newsubdivision algorithms with the wellknown Catmull
Clark algorithm which is also implemented on the DLFL structure, and show that
the new corner cutting and DooSabin algorithms give a better quality handleface
reconstruction.
11.2 Topological Operations and HandleFaces
We have recently identied a minimal set of basic operations on the DLFL structure
that are necessary and sufcient for performing all homeomorphic and topological
operations on orientable 2manifolds [?]. A clear identication of the minimal set
of operations distinguishes the lower level fundamental operations from the higher
level operations, and greatly improves computational efciency, user interactivity,
and topological robustness.
The minimal set consists of four fundamental operations, as follows:
1. CREATEVERTEX(v) creates a 2manifold surface with one vertex v and one
face f which we call a point sphere as shown in Figure 11.1. This operation
is the same as the Euler operation MV FS [147] and effectively adds a new
surface component to the current 2manifold.
Figure 11.1: A pointsphere that consists of only one vertex and one face.
2. DELETEVERTEX(v) is the inverse of the CREATEVERTEX(v) operation, i.e.,
it deletes a point sphere from the current 2manifold. This operation is the
same as the Euler operation KV FS [147].
3. INSERTEDGE(c
1
, c
2
, e) inserts a new edge e to the mesh structure between
two corners c
1
and c
2
(a corner is a subsequence of a face boundary walk con
sisting of two consecutive edges plus the vertex between them. A corner can
also be given as a facevertex pair). According to our current implementation
of the DLFL structure, the operation INSERTEDGE takes time logarithmic in
the number of vertices in the involved faces.
4. DELETEEDGE(e) deletes an edge e from the current 2manifold mesh repre
sented by the DLFL structure. This is the inverse operation of INSERTEDGE
and also takes time logarithmic in the number of vertices in the involved faces
in our current implementation of the DLFL structure.
The above set of operations is minimal and complete in the sense that it is nec
essary and sufcient for performing all kinds of homeomorphic and topological
operations on orientable 2manifold meshes. The CREATEVERTEX operation is es
sential in the initial stage of manipulating 2manifolds and creates a new surface
component in the given 2manifold. In particular, it is necessary when a new sur
face component is created in an empty manifold. Similarly, the DELETEVERTEX
operation is convenient for cleaning up a manifold, and is a necessary operation
when a surface component needs to be completely removed from the 2manifold.
The INSERTEDGE is the only operation among the four basic operations that
can increase the genus of a manifold. In general, if INSERTEDGE inserts an edge
between two corners of the same face, the new edge divides the face into two faces
without changing topology, as shown in Figure 11.2. On the other hand, if IN
SERTEDGE inserts an edge between corners of two different faces (this includes
the situation in which an endpoint or both endpoints of the new edge correspond to
pointspheres), the new edge merges the two faces into one and changes the topol
ogy of the 2manifold. This situation is shown in Figure 19.8. The unusual face
shown at the left in this gure is an example of the type of faces which we call
handlefaces.
In case the operation INSERTEDGE is inserting an edge e to corners of two
different faces f
1
and f
2
, there is an interesting and intuitive interpretation of the
operation as follows: the operation can be decomposed into two steps. In the rst
step, we cut off along the boundaries of the faces f
1
and f
2
, which results in a 2
manifold with two open holes, then the second step runs a new pipe between
the two holes and allows the pipe ends to seal the two holes. An illustration is
shown in Figure 11.4.
Figure 11.2: Inserting an edge between two vertices of the same face divides the
face into two and deleting an edge between two faces merges the two faces into one.
Figure 11.3: Inserting an edge between two different faces merges the two faces
and deleting an edge with both sides in the same face splits the face into two.
Figure 11.4: A multiplestep representative illustration of creating a handle by in
serting an edge. (Note that cutting off a handle can be considered the reverse order
of this process).
DELETEEDGE is the inverse operation of the INSERTEDGE. As shown in Fig
ure 11.2 and Figure 19.8, DELETEEDGE either merges two faces into a bigger face
or splits a handleface (which forms a pipe) into two faces. When DELETEEDGE
splits a handleface into two faces (as shown in Figure 19.8), the situation can be
described by a 2step process in which the rst step cuts off a pipe from the 2
manifold and leaves two open holes and, the second step seals the two open holes
by two disks (which are the two new faces). This operation eliminates either a han
dle or a hole from the 2manifold, which is the only, thus also necessary operation
among the four that decreases the genus of a 2manifold.
One important challenge is to efciently visualize the handlefaces they are
a bit strange looking and current graphics hardware does not support such strange
faces. We notice that subdivision schemes can effectively be used to reconstruct
such faces and make the structure of the handle become apparent as illustrated in
the last gure in Figure 17.11.
Figure 11.5: Handle becomes apparent after subdivision operations.
11.3 HandleFace Reconstruction with Subdivision
The existing subdivision schemes can be classied based on three criteria [186,
154]: (1) the type of renement rule (e.g. vertex insertion [165] or corner cutting
[168]) (2) the type of generated mesh (e.g. triangular [107] or quadrilateral [165])
(3) whether the scheme is approximating or interpolating. We observed that, for the
improvement of handlefaces, triangular or interpolating schemes are not appropri
ate choices. This observation limited our choices to approximating and quadrilat
eral schemes. Earlier we have implemented CatmullClark subdivision algorithm
[165] on the DLFL structure [133] (CatmullClark is a vertex insertion, approximat
ing and quadrilateral scheme [186, 154]). Based on this implementation, we have
demonstrated how the DLFL structure supports efciently and effectively topolog
ical change and subdivision operations. In particular, we showed how a handle can
be added to a cup based on the system (see [133] for details).
One feature that is not completely satisfactory is that the reconstruction of the
handleface based on a vertex insertion subdivision scheme creates an extraordinary
vertex with a high valence. (The valence of a vertex is the number of edges inci
dent on the vertex.) This extraordinary vertex occurs at the middle of the handle as
shown in Figure 17.11 in the rst iteration of vertex insertion scheme. The valence
of the extraordinary vertex on a handle is generally higher than 8. The resulting
surface does not always look smooth around such an extraordinary vertex because
of the ripples created as a result of the unusual structure around the extraordinary
vertex as shown in Figure 14.5
1
.
1
The reconstruction with subdivision is one of the ways to improve the quality of handlefaces.
Inserting new edges to a handleface can also help to remove the ripples and avoid high valence
vertices. If a second edge is inserted to connect any two vertices of a handleface, the new edge
Figure 11.6: Examples of surfaces that do not look smooth near extraordinary ver
tices.
In this paper, we show that the quality of the reconstruction of handlefaces can
be improved by using corner cutting schemes. Corner cutting schemes do not create
additional extraordinary vertices. Under a corner cutting scheme, the handleface
eventually becomes a highvalence planar face, which is a part of C
1
smooth handle
[168]. After a few number of iterations, this highvalence face does not create any
visual distraction since it becomes almost planar.
11.4 Corner Cutting Schemes
The renement rules for a general corner cutting algorithm are as follows:
Step 1 : For each vertex v
n
of a face f = v
0
, v
1
, . . . , v
n
, . . . , v
N1
of the
mesh, create a new vertex v
n
. Compute the position of the new vertex as
v
n
=
N1
m=0
a
n,m
v
m
(11.1)
where a
n,m
are real coefcients described by the corner cutting scheme and
N is the valence of the face.
Step 2 : For each old face, create a new face by connecting all the new points
that have been generated in that face;
Step 3 : For each old vertex, connect all the new points that have been gen
erated for that vertex (in all faces whose boundary contains the vertex);
separates the handleface into two faces without changing the topology of the mesh. By inserting
more edges, the quality of the handle can be improved further [133].
Step 4 : For each old edge, connect the four new points that have been gen
erated for the two ends of the edge.
Step 5 : Remove all old vertices and edges.
For any subdivision scheme using approximation, the coefcients a
n,m
in step
1 in the above algorithm must satisfy the following conditions (we assume that the
vertex indices are given in the order of a face traversing):
1. a
n,m
0 for all n and all m and
2. for all ns
N1
m=0
a
n,m
= 1.
These conditions guarantee convergence of the algorithm and provide C
0
continuity
and afne invariance properties [186, 154].
11.4.1 DooSabin Algorithm
For example, in the wellknown DooSabin subdivision scheme, the coefcients
a
n,m
in equation (16.1) are computed using the following formulas:
a
n,m
=
1
4
+
5
4N
if n = m
a
n,m
=
(3+2 cos(
2(nm)
N
))
4N
otherwise
It is easy to verify that in DooSabin scheme, each coefcient is always greater
than zero and the coefcients add up to 1. By using Fourier analysis, DooSabin
showed that this scheme has three distinct eigenvalues 1, 1/2, 1/4. One eigenvector
has the eigenvalue 1, two eigenvectors correspond to eigenvalue 1/2 and the rest
of the eigenvectors correspond to the smallest eigenvalue 1/4. This structure of
eigenvalues of the DooSabin scheme guarantees that the scheme provides tangent
plane continuity [168, 186, 154].
11.4.2 A New Corner Cutting Algorithm with Tension
Our new corner cutting scheme is inspired by DooSabin algorithm. Let vertex
indices in a face be given by a rotation order, we use the following formula to
compute the coefcients a
n,m
to compute the position of v
n
.
a
n,m
= a if n = m
a
n,m
= M
1 a
3N 5
otherwise
(11.2)
where
M = 3 + 2 cos
2(n m)
N
.
In these equations, parameter a in equation (11.2) is provided by users and it is
used as a tension parameter [58]. The new algorithm gives subdivision rules for
generating quadratic Bspline tensorproduct surfaces for N = 4 and a = 9/16.
Note that, in our case the coefcients add up to 1 and if 0 < a < 1 each coefcient
is greater than zero.
By using Fourier analysis, similar to DooSabins approach, we can show that
the new scheme also has three distinct eigenvalues
1,
(2a + 1)N 5
3N 5
,
3aN 5
3N 5
and if a < 1 then regardless of the value of N the sequence is strictly decreasing.
Similar to DooSabin scheme, only one eigenvector corresponds to eigenvalue 1,
two eigenvectors correspond to the second largest eigenvalue and the rest of the
eigenvectors correspond to the smallest eigenvalue. This result demonstrates that
our scheme also provides tangent plane continuity.
There also exists a lower limit over the value of a. To have positive eigenvalues,
for a triangular face. (i.e., N = 3) a must be larger than 1/3 (Note that in triangle
case, the third eigenvalue will not exist.) For a quadrilateral face (i.e., N = 4) a
must be larger than 5/12. Otherwise, the smallest eigenvalue can become negative.
It is safer to choose 5/12 as a lower bound for a since in corner cutting schemes we
cannot avoid quadrilaterals (each old edge become a quadrilateral after the applica
tion of corner cutting scheme once.)
Figures 11.7 and 11.8 showthe rst four consecutive iterations of the newcorner
cutting scheme for a cube control shape. In these examples, we used the parameters
a = 9/16 and a = 0.9. As shown in the Figures, the larger a values, the less
rounded shape becomes. This is because for larger a values, the position v
n
will
geometrically be closer to the position of v
n
. By using this property, the user can
control the degree of smoothness.
Figure 11.7: The rst four consecutive iterations with a = 9/16.
Figure 11.8: The rst four consecutive iterations with a = 0.9.
11.5 Remeshing Algorithms for Corner Cutting
It is straightforward to implement vertex insertion schemes (such as CatmullClark)
over the DLFL structure by using only minimal set of operations [133] which guar
antee topological robustness during the process. Unfortunately, the same cannot
be directly done for the development of algorithms to implement corner cutting
schemes, since the new mesh structure resulting from corner cutting scheme is com
pletely disjoint from the initial mesh. More seriously, if the new mesh is constructed
by operations that are not provided by DLFL structure, topological inconsistency
might be introduced during the process. In the following, we present two remesh
ing algorithms for corner cutting schemes that only use the operations provided
by DLFL structure. Since DLFL structure and these operations are topologically
robust, our algorithm always guarantee topological consistency.
Let / be a mesh given in the DLFL structure such that we will apply a corner
cutting algorithm on /. If / has n vertices, m edges and f faces, then the new
mesh structure /
n
;
1.2. compute the positions of the new vertices v
0
, v
1
, . . ., v
N1
using the
formulas (16.1), and (11.2);
1.3. for n = 0 to N 1 do
insert the new edges [v
n
, v
(n+1) (mod N)
] into the face;
Remark 1. Traversing the faces of the mesh /can be simply done by calling
the operation FACETRAV provided by the DLFL structure, whose running
time is linear in the valence of the face being traversed.
Remark 2. Each edge [v, w] in / is traversed exactly twice in Step 1, once
from v to w and once from w to v. After the rst traverse, the edge [v, w] of
/ is subdivided into [v, v
and w
], [v
, w
], and [w
, w] (see
Figure 17.6B).
Remark 3. It will be helpful to compare the topological view and geometric
view for Step 1. Topologically, each edge [v, w] in / is subdivided by two
new vertices v
and w
and
w
], [v
, w
], [w
, w] is no longer
on a single straight line but becomes zigzag (see Figure 17.6C).
Remark 4. In Step 1.3, since the new edges [v
n
, v
(n+1) (mod N)
] are all in
serted in the given face F, the face corners for each new inserted edge are
uniquely determined. Also note that after Step 1, each new vertex becomes
of valence 3. (see Figure 17.6D).
Step 2 : Now for each old vertex v in the mesh /, suppose the neighbors
of v, which are all new added vertices, are ordered by the rotation at v as v
0
,
v
1
, . . ., v
r1
. Insert new edges [ v
j
, v
(j+1) (mod r)
] for j = 0, 1, . . . , r 1 (see
Figure 17.6E).
Remark 5. The DLFL structure also provides a VERTEXTRAV operation
that allows to traverse the neighbors of a vertex in the order of the rotation
at the vertex in time linear in the valence of the vertex. Therefore, Step
2 can be done very efciently. Moreover, the face corners for the new in
serted edge [ v
j
, v
(j+1) (mod r)
] are in the face that also contains the face corner
( v
(j+1) (mod r)
, v, v
j
), so they can be found conveniently.
Step 3 : Finally, we delete all edges of form [v
, w
], where v
and w
are the
new vertices subdividing an old edge [v, w] in the mesh /, and delete all old
vertices in / and the edges incident to them (by repeatedly using the edge
delete operation followed by a single vertex delete operation).
Figure 11.9: Illustration of rst remeshing algorithm.
Remark 6. A careful examination shows that the new mesh structure /
shares neither common vertex nor common edge with the old mesh /. Even
the new edges resulted from subdividing the old edges of / are eventually
also removed. Therefore, for implementation convenience, we can simply
create a separate new Vertex list and new Edge list for the new vertices and
edges, respectively, instead of modifying the old Vertex list and old Edge list.
The old Vertex list and Edge list will be entirely deleted at the end of the
algorithm.
It is not difcult to verify that none of the operations we applied in this algorithm
changes the topology of the initial mesh /. Therefore, the resulting structure /
0
, v
1
, . . ., v
N1
using the
formulas (16.1), and (11.2);
1.2. CREATEFACEMANIFOLD(v
0
, v
1
, . . . , v
N1
).
Figure 11.10: Illustration of second remeshing algorithm.
Remark 2. Step 1 creates two new faces f
= (v
0
, v
1
, . . . , v
N1
) and f
=
(v
N1
, v
N2
, . . . , v
1
, v
0
) for each old face f = (v
0
, v
1
, . . . , v
N1
) (see Fig
ure 11.10.B). We call f
and f
i
the adjacent faces are just the fornt face
and back face. Thus, we can talk about the front corner and back corner
at vertex v
i
. More specically, the front corner of v
i
is the vertexface pair
v
i
, f
i
is the vertexface pair v
i
, f
.
Step 2: for each old edge e = u, w the two ends of e induce two pairs of
new vertices v
, v
and w
, w
and v
and w
and /
3, which has
been discovered by three groups simultaneously [101, 104, 115, 102], is a 3valent
conversion scheme that converts any manifold mesh to a mesh with only 3valent
vertices.
Existing subdivision remeshing schemes can also be classied based on what
kind of regularity emerges with the application of the scheme [111, 154]. In other
words, the pattern of regular regions can be used to characterize the scheme. Based
on regular regions, existing subdivision schemes can be classied into three major
categories:
(4, 4) Corner cutting schemes such as DooSabin [168], Vertex insertion schemes
such as CatmullClark [165], Simplest [113] and its dual create regular re
gions that consist of 4valent vertices and 4sided faces. Depending on the
scheme either the number of non4valent vertices or the number non4sided
faces remains constant.
(3, 6) Triangular schemes such as Loop and
3subdivision [106, 107] cre
ate regular regions that consist of 6valent vertices and 3sided faces. In this
case, the number of non6valent vertices remains constant after the rst re
nement.
(6, 3) The schemes that are the dual of
3 [101, 104, 115, 102] and dual of
Loop subdivision [108] create regular regions that consist 3valent vertices
and 6sided faces. In this case, the number of non6sided faces remains
constant after the rst renement.
Regular regions (4, 4) and (3, 6) are particularly useful for the development of
subdivision schemes.
The development remeshing rules. For regular regions, it is easy to develop
remeshing rules to create denser regular regions. For instance, both corner
cutting and vertex insertion create denser (4, 4) regions from (4, 4) regions.
The development subdivision rules. Identication of the weights for a sub
division scheme that corresponds to a specic parametric representation in a
regular region is analytically straightforward. For (4, 4) type, the rules that
are obtained for 1D case can be generalized to 2D. For (3, 6) type, the rules
for regular regions can be derived from Boxsplines.
Constructing the surface. Having a corresponding analytical representation is
also useful for the creation of the subdivision surface since regular regions can
simply be constructed using the corresponding representation. For instance,
since the regular regions of CatmullClark corresponds to cubic Bsplines
and the regular regions of DooSabin corresponds to quadric Bsplines, we
do not have to create these regions with successive iterations of subdivision
rules; they can be constructed simply by using the corresponding analytical
equations.
These advantages are only available for subdivision schemes that create regular
regions (4, 4) and (3, 6). The derivation of rules for the schemes that create reg
ular region (6, 3) is not that straightforward. This problem is harder for schemes
that create semiregular meshes. Since any semiregular tesselation of an innite
plane does not correspond to any analytical representation, it is hard to develop
subdivision schemes that create semiregular regions.
Fortunately, a classical remeshing scheme, dual operation [152], provides an ef
fective solution to this problem. Zorin and Schr oder recently showed that dual oper
ation allows creation of higherorder quadrilateral subdivision surfaces that provide
higherdegree continuity [118]. The same idea is also used to derive the rules for the
schemes that create regular (6, 3) regions [104, 115]. In this paper, dual operation
plays an important role. We do not directly compute the weights for semiregular
subdivisions. Our remeshing operations do not change positions of existing ver
tices and newly created vertices do not change the shape of the initial mesh. We
then apply dual operation even number of times to create a smooth mesh.
The next section discusses the topological existance of semiregular subdivision
remeshings.
12.4 Topological Constraints
The mesh structures of ngonal meshes can easily be identied from Eulers equa
tion by assuming every face has n sides and every vertex has an average valence m.
Since we enforce use of the same type of polygon everywhere, n should be integer.
However, m can be a rational number since it is the average valence of vertices. To
be able to tesselate any genus g manifold shape with ngonal meshes for the given
n regardless of the values of g and v, m should never be smaller than 3. If not, it
means that some vertices are required to have less than valence 3 which corresponds
to trivial cases.
A single manifold mesh satises the following Euler formula
v e + f = 2 2g
where v is the number of vertices, e is the number of edges and f is the number
of faces. Since the mesh represents a manifold, then 2e = nf and 2e = mv. If
we plug in these relationships between edges, vertices and faces, we obtain the
following relationship between m and n.
m =
2n
n 2
1 +
2g 2
v
(12.1)
For any given n, m must be larger than 3 for all g and v. Fortunately, we do
not have to check all possible g and vs. All we need to show that min(m) is larger
than 3. It is clear from the equation 16.1 that regardless of the values of g and v for
g > 0
min(m)
2n
n 2
In other words,
2n
n2
should be larger than 3 to be able to avoid lessthan3valent
vertices. Note that
2n
n2
is a monotone decreasing function that becomes smaller than
(A) (B)
Figure 12.4: Examples of hexagonal meshes for g0.
3 for values of n larger than 6. This also shows that for g > 0, it is always possible
to create hexagonal meshes; two examples are shown in Figure 12.4.
Although, there can be some special ngonal meshes for a small values of v and
large values of g, this result clearly states that a given mesh cannot be converted
to an ngonal mesh where n > 6, i.e. no ngonalization scheme exists for n > 6.
The result also states that no ngon preservation scheme exists for n > 6 since a
preservation scheme that can be used in subdivision must increase v.
Above analysis does not include g = 0 case, since g = 0 is a special case for
hexagonal meshes. For g = 0 and n = 6 the equation 16.1 becomes
m = 3
1
2
v
1
2
v
Here, for values of v larger than 20, we can create pentagonal mesh. Note
that v = 20 corresponds to a dodecahedron (simplest pentagonal mesh with 12
pentagons). We will later show how to convert a tetrahedron to a dodecahedron.
The other inseresting cases are n = 4 and n = 3 for g = 0. In the case of n = 4,
we nd that v must be larger than 8 and the simplest case v = 8 corresponds to an
hexahedron (generalized cube; simplest quadrilateral mesh with 6 quadrilaterals).
In the case of n = 3, v must be larger than 4 and the simplest case v = 4 corresponds
to a tetrahedron (simplest triangular mesh with 4 triangles).
Another insteresting case occurs when v goes to innity.
m
v
2n
n 2
.
This is the same as the value of the m for g = 1, which corresponds to planar
tesselations. In other words, for larger values of v, the value of m approaches a
value that is coming from tesselations of an innite plane that can be represented as
a mapping to a toroid. Possible cases are illustrated by the following chart.
(n, m ) type
(6.00, 3.00 ) Average 6sided faces with average 3valent vertices
(5.00, 3.33 ) Average 5sided faces with average 3.3valent vertices
(4.00, 4.00 ) Average 4sided faces with average 4valent vertices
(3.33, 5.00 ) Average 3.3sided faces with average 5valent vertices
(3.00, 6.00 ) Average 3sided faces with average 6valent vertices
Since the same analysis can be repeated just by replacing v with f, we included
(10/3, 5), the dual of (5, 10/3). If both n and m are integers and every face has
exactly n sides and every vertex has valence m, we call it a regular tesselation. If
only faces or vertices have exactly same number of sides or valences, we call the
corresponding tesselation semiregular. Note that (4, 4) can have both regular and
semiregular tesselations
1
, but, (5, 10/3) can only have semiregular tesselations.
1
Since we are considering only the average valences or number of sides, a (4, 4) mesh can include
pentagons and triangles while having only 4valent vertices.
12.5 New Remeshing Schemes
Our analysis shows that pentagon conversion and pentagon preservation schemes
can exist. We have developed one scheme for each case. The following sections
present the remeshing algorithms for the newschemes. Note that we do not compute
weights. Our remeshing operations provide a simple (afne) subdivision. We then
use dual operation to create smoother (higherorder) meshes. As evidenced by the
examples, the dual turns out to be one of the most powerful tools for development
of subdivision derivation rules.
12.5.1 Pentagonalization Algorithm
Let V be the list of vertices, E the list of edges and F the list of faces in the original
mesh.
1. Subdivide all edges in the mesh into 3 equal parts. Let the set of newly created
points be V
s
.
2. For every face f
i
in F
(a) Create a point sphere [?] at the centroid of the face. A point sphere is a
manifold mesh with one vertex and one face without an edge [?].
(b) Insert an edge between the point sphere and every other newly created
point in that face (from the previous step). That is, starting from a corner
c
j
= v
j
, f
i
, where v
j
belongs to V
s
, insert an edge between the point
sphere and c
j
; then insert an edge between the point sphere and every
third corner from c
j
in the direction of traversal of the face.
3. Apply dual operation an even number of times.
(A) (B)
Figure 12.6: Pentagonalization scheme. (A) is the initial mesh and (B) the resulting
mesh.
Each face in the original mesh would now have been split into as many pen
tagons as the number of edges (or vertices) in the original face. So we will
have only pentagons in the new mesh.
This scheme can convert the simplest triangular mesh (tetrahedron) to the sim
plest pentagonal mesh (dodecahedron) as shown in Figure 16.14. This set of SOC
CERBALLIMAGES also show the role of dual operation; the resulting shape be
comes more and more uniform with each application of dual operation.
If this subdivision is applied to a mesh that includes either (4, 4) or (6, 3) regular
regions, the resulting mesh will have classical (or geometrical) semiregular regions
4.3.3.4.3 (see Figure 12.8.A) or 6.3.3.3.3 (see Figures 12.9.A) (for this notation
see [152]). The dual of these meshes will also include semiregular regions (see
Figure 12.8.B and Figure 12.9.B).
(A) (B) (C)
(D) (E) (F)
Figure 12.7: Conversion of a tetrahedron to a dodecahedron by the pentagonaliza
tion scheme. (A) is the original tetrahedron. (B) is the dodecahedral shape after
the application of pentagonalization scheme. (C) is the icosahedral dual of (B). (D)
is the dodecahedral shape that is the dual of (C). (E) is the 5th ieration of the dual
and (F) is 6th iteration of the dual. The SOCCERBALLIMAGES have been scaled
differently to provide a better view for comparison.
(A) (B)
Figure 12.8: 4.3.3.4.3 semiregular tiling created by pentagon conversion scheme
that is applied to a cube. (A) is one iteration with two dual, (B) is the dual of (A).
(A) (B)
Figure 12.9: 6.3.3.3.3 semiregular tiling created by pentagon conversion scheme
that is applied to the toroidal shape shown in Figure 12.4.A. (A) is one iteration
with two dual, (B) is the dual of (A).
12.5.2 Pentagon preserving algorithm
Let V be the list of vertices, E the list of edges and F the list of faces in the original
mesh.
(A) (B)
Figure 12.10: Pentagon preserving scheme. (A) is the initial mesh and (B) the
resulting mesh.
1. Subdivide all edges in the mesh into 2 equal parts. Let the set of newly created
points be V
s
.
2. For every face f
i
in F
(a) Collect the coordinates of the midpoint of every original edge in f
i
.
These will be the coordinates of the newly created midpoints from the
previous step. Let the list of these midpoints be P
i
. Note that P
i
con
tains only the geometric coordinates of the midpoints and no new entity
(vertex, edge or face) has been created yet.
(b) Scale the points in P
i
around their centroid by a specied amount. The
scale factor should be less than 1.
(c) Create a new face using the scaled points in P
i
.
We will now have a scaled (smaller) face corresponding to each face of the
original mesh. The new faces will have the same number of sides as the
corresponding original face and each vertex of the new face will correspond
to a point in V
s
. Let the list of the new faces be F
n
.
3. For every face f
i
in F
n
(a) For each vertex v
i,j
in f
i
, insert an edge between v
i,j
and the point in V
s
corresponding to v
i,j
.
4. Apply dual operation an even number of times.
Each face in the original mesh would now have been split into as many pen
tagons as the number of edges (or vertices) in the original face plus one cen
tral face with the same number of sides as the original face. If we start with a
pentagonal mesh, the new mesh will contain only pentagons, thus preserving
the pentagonal nature of the original mesh. (see Figure 12.11 for an example.)
12.6 Implementation and Results
The two algorithms above are implemented and included in an existing 2manifold
mesh modeling system as an option. Our system is implemented in C++ and
OpenGL, FLTK. All the examples in this paper were created using this system.
Figure 12.12 shows an example of pentagonalization scheme. As it can be
seen in this example, such complicated models can effectively be smoothed by our
approach. More importantly, even meshes having hard edges can be effectively
smoothed without creating any lateral artifacts (wave patterns) [111, 101] as shown
in earlier gures such as Figures 12.1 and 12.8.
(A) (B)
Figure 12.11: A semiregular tiling created by pentagon preserving scheme that is
applied to a cube. (A) is one iteration with two dual, (B) is the dual of (A).
Although, there exist no hexagonal genus0 meshes, If one applies a honeycomb
subdivision, dual of
3 [101, 104, 115, 102] or dual of Loop [114, 108] , to the pen
tagonal meshes, the resulting meshes do not include any triangle or quadrilateral.
In the case of dual of
i
= (v
i,0
, v
i,1
, . . . , v
i,N1
)
based on the original faces f
1
and f
2
.
3.2. CREATEFACEMANIFOLD(v
i,0
, v
i,1
, . . . , v
i,N1
).
Remark 3. This step creates a set of manifold faces starting from f
1
and
ending at f
k1
as shown in Figure 17.6B.
Remark 4. Note that for the sake of simplicity this explanation implies that
f
1
and f
2
have the same number of vertices. We will later show that f
1
and
f
2
do not have to have the same number of vertices for the implementation of
the algorithm.
Step 2: Starting from f
0
= f
1
and ending at f
k
= f
2
, going through the
sequence of faces f
0
, f
1
, . . . f
k1
, f
k
created above, apply the CREATEPIPE
operator to each pair of adjacent faces whose normals point towards each
other, using the matching corners as dened by the face traversal starting
from c
1
and c
2
(see Figures 17.6C17.6F).
Remark 5. Each face created in step 3.2 is actually two new faces, which
share the same vertices and edges, but point in opposite directions. When
applying the CREATEPIPE operator in Step 2, the corners should be chosen
such that they belong to faces that are adjacent to each other (w.r.t. the se
quence of faces created, but excluding faces which share the same vertices
and edges) and point in opposite directions.
Figure 14.6: Algorithm.
14.4.1 Curved Handles
This subsection presents our method to create curved handles between two distinct
faces of a mesh. This method is used to compute the positions of the vertices in the
intermediate faces (f
i
) described in the previous subsection.
Let two corners c
1
= (v
1
, f
1
) and c
2
= (v
2
, f
2
) and two weights w
1
and w
2
be
given. If f
1
and f
2
are star shaped faces with the same number of vertices, our goal
is to create a multisegment pipe between the two faces f
1
and f
2
such that the two
vertices v
1
and v
2
are directly connected by a series of straight line segments that
approximate a Hermitian curve
H(t) = p
1
h
1
(t) + p
2
h
2
(t) + w
1
n
1
h
3
(t) w
2
n
2
h
4
(t). (14.1)
Here p
1
and p
2
are the centroids and n
1
and n
2
are the average normals of f
1
and f
2
respectively (with [n
1
[ = 1 and [n
2
[ = 1) and h
1
(t), h
2
(t), h
3
(t) and h
4
(t) are the
Hermitian basis functions. This Hermitian curve starts from the centroid of face f
1
in the direction of the face normal (n
1
) and ends at the centroid of face f
2
, in the
opposite direction of the face normal (n
2
). Note that the weights w
1
and w
2
can
be negative, which can be used to create holes instead of handles.
14.4.2 Face Morphing
The Hermitian curve H(t) determines the overall shape of the pipe. To compute the
actual positions of the vertices in the intermediate faces, we need to determine the
shape of the crosssection of the pipe at each segment as it goes from f
1
to f
2
.
This problem strongly resembles the problem of 2D shape blending [148] (more
widely known as 2D morphing). Therefore, our approach is to rst simplify the
problem into a 2D problem. To morph the shape of the faces from f
1
to f
2
in 2D,
we rst determine a reference plane 1and rotate both faces to that reference plane.
The choice of 1 is arbitrary and does not by itself affect the algorithm. We use
the vector from the centroid of the rst face to the centroid of the second face to
determine the unit normal vector n
R
to the reference plane 1. We rotate f
1
onto 1
around its centroid using the rotation axis n
1
n
R
We rotate the face f
2
similarly.
After these rotations, we move each vertex of f
1
and f
2
to the reference plane 1, to
ensure that the transformed f
1
and f
2
are planar. Both f
1
and f
2
are then translated
to make their centroids coincide with the origin of the coordinate system.
2D Morphing
After applying the above operations, the two faces will become coplanar and both
of their centroids will be at the same location. Under the assumption that these faces
are star shaped and centroid is a star center, the morphing problem is simpler than
the general 2D shape blending problem [148, 149]. However, we still need to be
careful to avoid self intersections. For instance, if we perform a linear interpolation
directly between the vertices of the two faces, we can get self intersections.
Instead of linear interpolation between the vertex coordinates directly, we per
form the interpolation in polar coordinates. This interpolation guarantees that in
termediate faces do not selfintersect under the assumption that the transformed f
1
and f
2
are star shaped polygons and their centroids are star centers (i.e. any ray
enamating from centroid intersect with the face no more than once). Using a ref
erence axis system on the plane 1, we resolve every vertex v of f
1
and f
2
into a
distanceangle pair (r, ), where r is the distance of v from the centroid of the face
(which is now the origin) and is the angle that v (treated as a vector) makes with
the X axis. The choice of the reference axis system is arbitrary and has no inuence
on the nal results. We dene the reference axis system as follows. We take the
vector from the origin to the midpoint of the last edge in f
1
to be the X axis. The
Y axis will then be the cross product between n
R
and the X axis.
We ensure that the angles always increase monotonically within the same face
going from the rst vertex to the last one. This is necessary to avoid self inter
sections as we transition from f
1
to f
2
, and also gives a smooth transition. We
also ensure that the difference in angles for the rst vertices is not more than 180
degrees. This prevents unwanted twists in the pipe (along the axis of the pipe).
Let
f
1
= (v
1,0
, v
1,1
, . . . , v
1,N1
)
f
2
= (v
2,0
, v
2,1
, . . . , v
2,N1
)
v
1,j
= (r
1,j
,
1,j
), j = 0 to N 1
v
2,j
= (r
2,j
,
2,j
), j = 0 to N 1
(14.2)
be the resolved representations of the two faces f
1
and f
2
, where N is the number
of vertices in each face.
Remark 6. To simplify the notation, here we assume that f
1
and f
2
have the
same number of vertices. However, this is not a restriction. If f
1
and f
2
do not have
the same number of vertices, we simply bisect the edges of the face that has less
vertices. A short explanation of the procedure can be given as follows. Let N and
M be the number of vertices of f
1
and f
2
respectively. Without loss of generality,
let us assume that N > M. Then, the number of vertices of f
2
can easily be
increased to N by inserting new vertices. After sucha procedure, f
1
and f
2
will
have the same number of vertices. Two examples of creating handles between two
faces with different numbers of vertices are shown in Figure 14.7.
We then performa linear interpolation of the distanceangle pairs using the same
parameter t as used for the Hermitian curve, such that t = 0 corresponds to f
1
and
t = 1 corresponds to f
2
. Let
f
i
= (v
i,0
, v
i,1
, . . . , v
i,N1
) (14.3)
be an interpolated face corresponding to a parameter t, where
v
i,j
= (r
i,j
,
i,j
), j = 0 to N 1
r
i,j
= (1 t)r
1,j
+ tr
1,j
i,j
= (1 t)
1,j
+ t
2,j
(14.4)
Using the Hermitian curve H(t) we get a point p(t) and a tangent vector n(t) for
a given parameter t. We rotate f(t) so that its normal points in the same direction
as n(t) and translate it so that its centroid coincides with p(t).
We now have a sequence of faces dening the ends of the segments which make
up the handle. We nish the process by connecting the corresponding vertices be
tween adjacent faces to create the handle. Three examples of face morphing for
different choices of corners are shown in Figure 14.8. Although, this morphing al
gorithm cannot guarantee nonself intersection for nonstar faces, it can still be used
in some applications that include nonstar faces. Some examples of such applica
tions are shown in Figure 14.9. Note that in the examples in Figure 14.9 handle do
not selfintersect itself although the initial faces are not star shaped.
Figure 14.7: Two examples of creating handles between two faces with different
number of vertices. Corners are indicated as white dots and faces to be connected
have a darker shade.
Figure 14.8: Examples that shows face morphing for different choice of corners.
Corners are indicated as white dots and faces to be connected have a darker shade.
Note that it is possible to control rotation simply by choosing different corners.
Remark 7. To create segments of a handle, we sample the Hermitian curve
simply using t = i/k. To improve the quality of the handles we tested alternative
sampling strategies such as using an appropriate step length with respect to the
Figure 14.9: Examples that shows face morphings between two nonstar shaped
faces. Corners are indicated as white dots and faces to be connected have a darker
shade. Note that it is possible to control rotation simply by choosing different cor
ners.
curvature of the Hermitian curve. However, we concluded that there is no need
for any elaborate scheme for interactive handle construction. The main problem
occurs when handle intersects itself. However, if the Hermitian curve intersects
with itself for the user selected weight values w
1
and w
2
, there is no solution to
this problem. Since both high curvature and curve self intersection occur for larger
values of w
1
and w
2
, it is easier to reduce the values of these parameters. Moreover,
a very small number of segments is usually sufcient to construct handles. If the
curvature is not extremely high, a small number of segments do not intersect with
other. Therefore, in our interactive applications users easily avoid self intersection
by either decreasing the values of w
1
and w
2
or using less segments.
14.5 Implementation
The following outlines the implementation of the algorithm to create multsegment
curved pipes, using the methods outlined in the previous sections.
Step 1:
1.1. If the number of corners of f
1
and f
2
are not equal, until f
1
and f
2
have
the same number of vertices, insert new vertices to the face with less vertices.
Step 2:
2.2. Reverse face f
2
.
2.3. Using the centroids p
1
and p
2
and weighted normals n
1
and n
2
of the two
faces, compute a Hermitian curve H
Step 3:
3.1. Compute the reference plane 1with normal n
R
.
3.2. Transform f
1
and f
2
so that their normals are in the same direction as n
R
and their centroids are at the origin.
3.3. Resolve f
1
and f
2
into distanceangle pairs (Equation 14.2).
Step 4: for i = 1 to k 1 where k is the number of segments required in the
handle
4.1. Compute t = i/k
4.2. Compute a point p
i
and tangent n
i
on the curve H for t
4.3. Perform a linear interpolation between the resolved representations of
f
1
and f
2
using t as the parameter to obtain the resolved representation of f
i
(Equations 14.3 and 14.4 )
4.4. Compute the positions of the vertices in face f
i
= (v
i,0
, v
i,1
, . . . , v
i,N1
)
corresponding to the resolved representation calculated in the previous step.
4.5. Transform the vertex coordinates of f
i
computed above so that the nor
mal to f
i
points in the direction of n
i
and its centroid coincides with p
i
.
4.6. CREATEFACEMANIFOLD(v
i,0
, v
i,1
, . . . , v
i,N1
)
Step 5: Starting from f
0
= f
1
and ending at f
k
= f
2
, going through the
sequence of faces created above, apply the CREATEPIPE operator to each pair
of adjacent faces whose normals point towards each other, using the matching
corners as dened by the face traversal starting from c
1
and c
2
.
We have developed a prototype system for creating multisegment curved han
dles based on the above algorithm. The users of the system can control the number
of segments, weight values w
1
and w
2
using sliders. All the examples in this paper
are created interactively using this prototype system. The usability of the system
was also tested in a graduate level shape modeling course in which majority of
the students had an architecture undergraduate background. Although none of the
students had any idea about topology before, they easily learned the software and
created a wide variety of high genus manifold meshes as one of their weekly class
project. Figure 14.10 shows an example of how students use handle creation in
modeling. In this example, the legs of the horse are constructed as multi segment
curved handles. Another example of a shape created by a student had been shown
in Figure 14.3.
Figure 14.10: A manifold horse model created by a student. The legs of the horse
are constructed as multi segment curved handle by connecting manifold meshes.
14.6 Role of Subdivision
Subdivision schemes play an important role in our approach. Our system provides
various subdivision schemes including CatmullClark [165] and DooSabin [168].
Subdivision schemes and our approach to constructing multisegment curved han
dles support each other in various ways.
1. Control mesh modeling. Subdivision control meshes can easily be modeled
by our handle construction method. The shapes in Figure 14.11A show two
examples of highgenus control meshes that are constructed starting from a
simple convex polyhedron. The shapes in Figure 14.11B are obtained by
applying CatmullClark subdivision to the shapes in Figure 14.11A. Con
trol shapes for knots can also be obtained with multisegment handles. Fig
ure 14.12 shows how to create a control shape starting from four identical
cubes. The control shape shown in Figure 14.12B is obtained by connect
ing these four cubes with multisegment curved handles as shown in Fig
ure 14.12A. The Figures 14.12C and D show two views of the knot surface
that is obtained by applying CatmullClark subdivision [165] to the control
shape.
Figure 14.11: Two examples of manifold meshes created by our method and
smoothed by CatmullClark subdivision [165].
Figure 14.12: A knot surface created by connecting four cubes.
2. Handle improvement. With the usage of subdivision, we do not have to use
a high number of segments to create high resolution and smooth handles.
In fact, handles with a very high number of segments that are part of low
resolution meshes may not be desirable in most cases. Such handles can
create an inconsistency between the resolution of the handle and the rest of
the shape. Therefore, it is better to rst construct a handle with a reason
able number of segments and then apply a subdivision algorithm to increase
the resolution of the overall shape. For this purpose, subdivision smoothing
schemes are extremely useful to improve the quality of the handles. For in
stance, the examples in Figures 14.7, 14.8, and 14.9 give an idea of how the
handles are constructed consistent with the rest of the mesh, but the handle
shapes are not easily perceived because of the low number of segments. Fig
ure 14.13 show smoothed versions of the shapes shown in Figures 14.7, 14.8,
and 14.9 respectively. The shapes of the handles become more visible after
the subdivision as shown in Figure 14.13.
Figure 14.13: Examples of handle improvement with subdivision. In these exam
ples, we applied CatmullClark twice to the original meshes.
14.7 Discussion, Conclusion and Future Work
In this paper we have demonstrated an algorithm to create multisegment, curved
handles between two distinct faces of an orientable 2manifold mesh. The algorithm
allows us to create high genus, smooth surfaces. The handle creation process is
robust and produces a smooth transition from one face to another without any self
intersections.
Although the algorithm can only work on orientable surfaces, nonorientable
looking surfaces can easily be obtained with the method. Figure 14.14 shows
the creation of twice twisted M obiuslike surface by connecting two prisms. Fig
ure 14.3 also showed one such example. Figure 14.15 shows another nonorientable
like shapes, a Kleinbottle that is constructed by (1) duplicating one manifold sur
face, (2) reversing the normals of the second surface, and (3) connecting two sur
faces with a curved handle.
Figure 14.14: A M obiuslike surface with two twists created by our approach.
Figure 14.15: A Klein Bottle like surface created by our approach. We cut a portion
of the surface to show the structure.
Although the morphing algorithm guarantees nonselfintersection only for star
shaped faces, it is still possible to use the algorithm for the cases such as the ones
shown in Figure 14.9. Using a 2D morphing scheme such as the one described in
[148, 149, 139] it is possible to handle more general nonstar shaped faces. More
over, some of the advanced algorithms used for extruded or swept surfaces can
also be used to create better sampling of segments to avoid self intersections. Al
though there is no need to use more complicated morphing and extrusion schemes
for interactive applications, for offline applications any elaborate morphing or ex
trusion scheme can easily be implemented into the current framework without a
major change.
One of the biggest remaining challenges is to be able to construct handles from
multiple faces to multiple faces. Aspecic case of the problemone to many curved
handles is in modeling trees. Unfortunately, trees cannot be modeled with our cur
rent approach since branches are generally tangent (not perpendicular) to the trunks
of the trees. This problem can be solved with a more general curves than Hermitian
curves dened by face normals. Such an extension requires the development of user
friendly methods that would allow direct control of the shape and properties of the
curved handles.
If a smoothing subdivision scheme is applied after connecting the nearest faces
of two surfaces with a handle, the resulting shapes strongly resemble smoothly
blended implicit surfaces. Such implicit surfaces are essential for modeling the
shapes such as chemical molecules [137, 153] and topologically changing shapes
such as water particles [138]. A future application of combination of this method
with subdivision schemes can be representing such smoothly blended and topolog
ically changing shapes.
14.8 Rind Modeling
In this paper, we describe a technique, with roots in topological graph theory, that
we call rind modeling. It provides for the easy creation of surfaces resembling
peeled and punctured rinds. We show how the methods two main steps of 1) cre
ation of a shell or crust like the rind of an orange, and 2) opening holes in the
crust by punching or peeling can be encapsulated into a real time semiautomatic
interactive algorithm. We include a number of worked examples, some by students
in a rst modeling course, that demonstrate the ease with which a large variety of
intricate rind shapes can be created.
14.9 Motivation
The inspiration for this paper came from Eschers drawings of rind shapes [170],
and the intricate nested carved sculptures of the Far East. Figure 14.16A is an
example of a nested elephant sculpture from India. A second elephant can be seen
inside the rst through the holes on outer surface. We have also seen nested balls
from China that consist of up to 16 rotateable balls carved inside of each other.
Figure 14.16: An example of nested sculptures from India. (A) shows a real nested
elephant sculpture. (B) is a rind model created using our system and rendered with
bump mapped textures.
Although our inspiration came from art, such rind shapes are extremely use
ful in industrial applications. Many manmade objects are rind shaped. Examples
are endless and include bottles, teapots, masks, boxes and even houses. Also, rind
shaped surface meshes can be functional models and therefore can be used in phys
ical simulations.
Figure 14.17: Three examples of spherical rind shapes. The nested structures are
obtained by scaling and rotating the outer rind shapes.
We have developed a user friendly manifold modeling method that we call rind
modeling. It allows us to construct easily very high genus rind shaped manifold
surfaces. For example, the outer shape in Figure 14.16B is a rind model created
using our method and rendered with bump mapped textures. Figure 14.17 shows
examples of spherical rind shapes. As seen in the gure, shapes similar to nested
chinese ball sculptures can be obtained by scaling and rotating the spherical rind
shapes. The shapes in Figure 14.17(B) and (C) are motivated by Eschers rind
objects [170].
Rind modeling consists of two steps: in the rst (automatic) step, for any given
2manifold mesh surface an offset surface is created based on a user dened thick
ness parameter. As a result of this step, from one surface two similar surfaces,
which can be considered as a shell or a crust are created. The second (interactive)
step consists of two modes, hole punching and peeling, similar to punching holes
in a coconut husk or peeling an orange rind. Holes are punched by single mouse
clicks.
The rind modeling method can also be used to create shapes that do not neces
sarily look like rind shapes. An example of such uses is shown in Figure 14.18. The
surface in this gure looks more like an extruded surface than a rind surface, but it
cannot be created as a simple extrusion because of its branching structure.
Figure 14.18: Two views of a shape that can be created by our method, but does not
look like a rind shape.
The teapot shown in Figure 14.19 is an example of a functional model that can
be created by our method. As can be seen from the xray and cut away images,
this teapot has a real not just an apparent hole to let the water pour from the spout.
Because of the hole in the spout, this teapot could be used in physical simulations.
Moreover, as can also be seen in the images, there exists an additional hole inside
of the handle of the teapot, i.e., this model has a rind shape.
Figure 14.19: A rindshaped teapot created using our system. (A) and (B) show two
different views of the manifold mesh. (C) is an xray image using transparency. (D)
is sliced to show the interior. (This slice was created using our system in peeling
mode.)
14.10 Previous Work
Creation of very high genus manifold surfaces has always been a research interest in
computer graphics and shape modeling. Ferguson, Rockwood and Cox used Bezier
patches to create high genus 2manifold surfaces [171]. Welch and Witkins used
handles to design triangulated freeform surfaces [185]. Using Morse operators and
Reeb graphs, Takahashi, Shinagawa and Kunii developed a featurebased approach
to create smooth 2manifold surfaces with high genus [183].
We recently introduced Doubly Linked face List (DLFL) data structure and a
topologically robust mesh modeling approach [155, 156, 166]
2
based on topological
graph theory [167, 177]. Our EDGEINSERT and EDGEDELETE [156] operators
can effectively change the topology of a manifold mesh by inserting and deleting
handles. They can be used to effectively implement subdivision schemes and allow
topology change during subdivision modeling [157, 158, 159]. We have recently
developed a user interface [160, 161] and theoretically shown [162, 166] that all
and only orientable 2manifold structures can be created using two simplest Euler
operations MVFS (make a surface with a single vertex and a single face) and KVFS
(inverse of MVFS) [181] along with EDGEINSERT and EDGEDELETE. Moreover,
these four operators can be efciently implemented [166] on almost every mesh
data structure including wingededge, [163], halfedge [181] and quadedge[178].
2
For detailed discussions and theoretical comparisons with Solid Modeling, Euler operators,
and existing data structures see [156] and [166]. These papers are also available at www
viz.tamu.edu/faculty/ergun/topology.
These results suggest that software development for mesh modeling with a topo
logically guaranteed orientable manifold property can be greatly simplied and
high level and intuitive topology change operators can be constructed using only
these four operators. A recently introduced highlevel operator called CREATEPIPE
[161] is an example of such intuitive topology change operators. Let / denote a
2manifold mesh and let v, f and e denote a vertex, a face and an edge respectively.
We dene a corner of the mesh to be a vertexface pair, c = v, f if f contains
the vertex v. The CREATEPIPE(c
1
, c
2
) operator connects two faces which contain
the corners c
1
and c
2
such that there is an edge between c
1
and c
2
and there is an
edge between other matching corners (in traversal order starting from c
1
and c
2
)
of the two faces, as shown in Figure 14.20. In effect this operation automatically
creates a pipe made up of only one segment whose ends are dened by the original
faces. This automatic process helps the users to intuitively understand the topology
change as creating a pipe between two faces.
Figure 14.20: An example of creation of a pipe (a high quality handle/hole) by
inserting a set of edges. If this pipe goes through the inside of the manifold surface
(as happens in our application in this paper), it punches a hole.
The CREATEPIPE operator is extremely useful for developing mesh design meth
ods to create very high genus manifold surfaces. For instance, by combining the
CREATEPIPE operator with subdivision schemes, shapes that resemble implicit sur
faces can be created [162, 161]. The CREATEPIPE operator can also be extended
to construct multisegment, curved handles [184]. In this paper, we use the CRE
ATEPIPE operator to construct rind shaped highgenus manifold surfaces. We have
rst created rind shaped manifold meshes using a naive algorithm [161], as an ex
ample see the cover image of Proceedings of International Conference on Shape
Modeling and Applications 2002, SMI02.
14.11 Problem Description
It is straightforward to develop a naive algorithm for the construction of highgenus
rind surfaces based on the CREATEPIPE operator. This algorithm would proceed in
two stages.
Stage 1: Offset surface creation. This stage consists of two steps.
1. Duplicate the initial mesh and move the vertices of the new mesh so that
they will lie completely inside the rst mesh (if the object is not convex or
starlike, it may be necessary to further move some vertices). This operation
creates two nested surfaces, which consist of the initial mesh and the newly
created offset mesh.
2. Reverse the normals of the faces of the offset mesh. This operation changes
the inside and outside of a 2manifold mesh by changing the rotation orders
of faces.
Using only this stage, it is possible to create rind models. Although such a
model would be valid, in the sense that both outside (initial) and inside (offset)
surfaces are manifold, it will not be interesting without punching holes or peeling
away parts of the rind. Without those holes, it is not possible to see inside of the
shapes or create nested structures such as those shown in Figures 14.16 and 14.17.
The second stage of the naive algorithm is needed to create such high genus
shapes. In this stage, the users can choose to either simulate punching holes or
peeling away parts of the rind.
Stage 2A: Hole punching. This stage consists of two topologically different steps.
However, users perceive both steps as being same, namely, punching holes.
1. Connect two corresponding faces using the CREATEPIPE operation. This
operation connects initial and offset surfaces and makes thema single surface.
Formally, this rst CREATEPIPE operation connects the two surfaces (i.e.
changes the topology) but does not increase the genus [161, 166].
2. Using the CREATEPIPE operation, create additional holes. The CREATEPIPE
operation after the rst one both changes the topology and increases the genus
by one [161, 166].
Stage 2B: Peeling. Punching holes does not automatically create a peeled effect.
Punching holes in two neighboring faces leaves an innitely thin wall or slab (like a
thin membrane) between two neighboring holes. Users have to delete such innitely
thin walls to create a peeled look as shown in Figure 14.21.
Figure 14.21: An example of the need for peeling. (A) shows an initial mesh and
(B) shows innitely thin walls left over by hole punching. The peeling effect shown
in (C) is obtained only after deleting these innitely thin walls.
An example of shapes we have created with the naive algorithm using hole
punching from our earlier paper is shown in Figure 14.22. One might think that al
most any very highgenus manifold rind shape can be created by a skilled user with
this naive algorithm. This observation is theoretically correct, but, practically, be
cause of several usability problems it is not easy to create complicated rind surfaces
even by skilled users. The usability problems we have identied can be summarized
as follows.
Figure 14.22: A rind teapot model that is constructed with the naive algorithm. (A)
is actual rendering with bump mapped textures and (B) is an xray image.
1. Usability problem with offset surface creation.
It is not easy to create an offset surface by hand for complicated initial meshes.
Although the model that is shown Figure 14.22 is valid, in the sense that the
surface is manifold and the teapot could hold water, the model is disappoint
ing because the thickness of the rind is highly nonuniform.
To create a uniform rind thickness by hand is almost impossible for high
genus initial meshes. For instance, in the teapot shapes in Figure 14.22 the
initial mesh already had a handle. It is very difcult to create an offset surface
that gives an additional hole inside this handle of the teapot.
2. Usability problem with hole punching.
It is not easy to select two corners of two related faces in both the initial and
offset surfaces for opening holes with the CREATEPIPE operator. It is espe
cially difcult to select a correct corner in the offset surface since this surface
is inside and partially visible only through holes. This difculty is even more
pronounced in the application of the rst CREATEPIPE operation that con
nects two surfaces since initially the offset surface is completely invisible.
(One reviewer pointed that this problem is not essential since it could simply
be solved using transparency to see the interior of a rind model.)
3. Usability problem with peeling.
The peeling stage of the naive algorithm requires users eliminates the walls .
Each of these walls consists of two quadrilaterals like a folded paper. Since
all edges are straight, this wall looks like a two sided quadrilateral but it is
not (note that we only deal with orientable 2manifolds without a boundary.
A two sided quadrilateral is not a legal face and cannot be created use of the
four fundamental operations.)
Having said that, now, let us assume that two edges of one of the quadrilat
erals are curved as shown in Figure 14.23A. Although this gure geometri
cally does not make sense, it helps to conceptually visualize the structure of
the innitely thin wall. Note that this innitely thin wall is in fact a handle
and this handle can be deleted by deleting two edges e
1
and e
2
as shown in
Figure 14.23. Deletion of e
1
combines the two quadrilaterals and creates a
hexagonal face [161]. As we have mentioned earlier, this hexagon is still a
handle. Only after the deletion of e
2
, separating this hexagon into two two
gons, is the handle eliminated.
Figure 14.23: Deletion of a an innitely thin pipe by deleting only two edges.
Initially this innitely thin pipe consists of two quadrilaterals.
Note that this deletion process is hard for the users. The requirement to delete
the rst two edges e
1
and e
2
shown in Figure 14.23 can be done during an
interactive session since the pipe deletion is a visual change. Moreover, dele
tion of the rst of such edges, e
1
, can be easily performed. However, after the
rst edge deletion, as shown in Figure 14.23, a strange hexagon which cannot
be adequately rendered is created. Because of this rendering problem, it can
be difcult to delete the second edge which becomes visible only from some
viewpoints.
The resulting two twogons, which are created after e
1
and e
2
are deleted,
do not carry any extra visual (or geometric) information (they look exactly
like straight edges). If these leftover twogons are not deleted subdivision
schemes would not be able to adequately smooth out the meshes. Therefore,
it is important to delete these leftover twogons. Figure 14.24 illustrates how
deletion of one edge of a twogon eliminates it. In the case of Figure 14.23
deleting e
3
and e
4
will eliminate twogons. However, deleting e
3
and e
4
is not
easy. Twogons are not visible as they look exactly like straight edges. It is
not easy to delete something that could not be visible or detected. Moreover,
the edges of twogons are usually very short and therefore it is very difcult
to select and delete these edges by hand. In other words, even if the users
try to delete all such edges, some may still be overlooked. As we mentioned
earlier, such leftover edges later create a problem when a subdivision scheme
is applied as shown in Figure 14.25. As a result, it is better to delete pipes
automatically, preferably with a very simple and fast operation.
Figure 14.24: Twogons sre removed by deleting one of their edges. In order to
show the actual mesh structure, one of the edges of every twogon is drawn curved.
Figure 14.25: The effect of twogons in smoothing with subdivision. (A) shows a
subdivided version of 14.21B and (B) and (C) show subdivided versions of 14.21C
with and without twogons. Note that the version with twogons shows tangent
discontinuities. In all cases, we applied CatmullClark [165] subdivision twice.
The approach we present below solves all of these problems with a very simple
real time interactive method.
14.12 Methodology
We solve the usability problems with a semiautomatic approach. When the user se
lects a manifold surface and then chooses rind modeling mode, the system automat
ically creates an offset surface based on the value of a user set thickness parameter.
Then users either punch holes or peel by simply selecting faces. While peeling, the
innitely thin pipes between neighboring holes are automatically eliminated.
The following is our semiautomatic method:
Automatic step: Offset surface creation. This is the rst operation after the user
selects rind modeling mode.
1. Duplicate the initial mesh to create an offset mesh, reverse the normals and
compute average unit normals for each vertex.
2. Create a correspondence table that records the corresponding faces of the
initial and offset meshes. The correspondence table also includes one corre
sponding corner for each face.
3. Move each vertex of the offset mesh in the direction of its average normal
vector a distance equal to the thickness value.
Remark. The offset surface construction problem for 2manifold meshes
is very different from offset surfaces in solid modeling [175, 174] since the
shapes of faces of 2manifold meshes do not have to be welldened. For
2manifold meshes we cannot describe a distance function and, therefore, we
cannot really dene a theoretically correct offset surface. Thus, any pro
cedure to create offset surfaces for 2manifold meshes must be somewhat ad
hoc. This procedure is practically useful and succesfully creates a practically
acceptable offset surface for small enough values of thickness parameter.
The procedure may result in self intersection for high values of the thick
ness parameter. It is possible to accomodate the self intersection by chang
ing topology and mesh structure as shown in Figure 14.26. However, for
hole punching we want both the initial and offset surfaces to have exactly
the same mesh structure. Thus, we avoid self intersections by simply using
smaller thickness values. Of course, another advantage of this procedure is
that it is extremely simple, and therefore, suitable for real time applications.
Figure 14.26: Avoiding the self intersection that is shown in (A) requires a change
in topology as shown in (B).
After the offset surface has been (automatically) created, the interactive step
is initiated. During the interactive step, the system can be in two modes: hole
punching and peeling. The user can change the mode during the interactive process.
As soon as the offset surface is created users see a message that says select a face
to punch holes or select a face to peel depending on the chosen mode. Then they
can either punch holes (or peel depending on mode) by simply selecting faces of
either the initial or offset surfaces.
Interactive step: Hole punching mode. The algorithm for punching one hole is
extremely simple.
1. Find the selected face in the correspondence table.
2. Using the two faces and two corners obtained from the table, apply CRE
ATEPIPE.
Remark. If the users select a face that is not in the correspondence table,
the procedure ignores the selection. Note that each hole creation operation
deletes two old faces and creates k new faces (quadrilaterals) where k is the
number of sides of the selected face. These newly created quadrilaterals must
be ignored, but, since these new faces will not be in the correspondence table,
this is easy.
Interactive step: Peeling mode. In peeling mode, every innitely thin pipe cre
ated as a result of punching holes is deleted. The procedure for cleaning such
unwanted pipes also turned out to be extremely simple based on topological graph
theory.
1. Find the selected face in the correspondence table.
2. Using the two faces and two corners obtained from the table, apply CRE
ATEPIPE.
3. For every corresponding two edges of the old (recently deleted) faces of the
initial and offset surfaces, check adjacent polygons. If the adjacent polygons
are the same, delete all the edges of the quadrilateral face that includes the
two corresponding edges.
14.13 Implementation and Testing
The procedure above is included in our existing 2manifold mesh modeling system
[161] as an option. Our system is implemented in C++ and FLTK [172]. All of our
interactive examples were run on an SGIO2. All the examples in this paper were
created interactively using this prototype system. Most images that show wireframe
are screen snapshots from our system.
The usability of the system was tested in a graduate level shape modeling course
in which a majority of the students had an architecture undergraduate background.
Some examples of these students work is shown in Figure 14.27. Although none
of the students had any previous idea about topology, they easily learned to use the
software and created a wide variety of high genus manifold meshes as one of their
weekly class projects. Figure 14.27A shows a students work also motivated by
the elephant sculpture shown in Figure 14.16A. Figures 14.27B and C show shapes
that are created by a student motivated by the shapes of seashells and chinese nested
balls. Figure 14.27D shows two of Eschers rind shaped objects [170] constructed
by two other students. The rind shape on the right in Figure 14.27D is used to create
image in Figure 14.17C.
Figure 14.27: Student work
14.14 Remeshing
To create interesting looking rind shapes, the mesh structure of the initial manifold
surface is very important. Eschers rind shaped objects shown in Figure 14.27D
motivated us to develop remeshing strategies that can create interesting mesh struc
tures.
One of the most useful remeshing strategies turned out to be cornercutting sub
division schemes [186, 168]. In corner cutting schemes the faces in the rst mesh
become smaller and connected by quadrilateral paths. Escher used this property
to conceptualize the shape on the left in Figure 14.27D. In terms of rind model
ing, Eschers algorithm to create this shape could be formulated (or generalized) as
follows:
1. Apply the DooSabin subdivision scheme [168] a few times to a convex poly
hedral shape (Escher conceptually started from an Archimedean truncated
cuboctahedron.)
2. (Optional) Spheralize the shape (move the vertices of a mesh to a sphere.
Since Escher drew a spherical shape, after the application of DooSabin al
gorithm, there is a need for this spheralization step.)
3. Peel everything except the initial faces and the quadrilateral paths that con
nect them.
Figure 14.28 shows a rind shape created starting from a dodecahedron using Es
chers algorithm. Ignoring the optional spheralization step in this procedure, com
plicated rind shapes such as the one in Figure 14.29 can be created. The shape in
Figure 14.29C is the same as the one in Figure 14.18.
Spiral shaped peeling such as shown in Figures 14.21 and 14.27D requires a
mesh structure that can be obtained by remeshing a regular fourconnected quadri
Figure 14.28: An example of a rind shape created using Eschers algorithm. The
initial manifold mesh for rind modeling shown in (B) is obtained by applying Doo
Sabin [168] and spheralization schemes to the dodecahedron shown in (A). We
created the shape shown in (C) by peeling everything except the initial faces and
the quadrilateral paths that connect them. The subdivided version of (C) is shown
in Figure 14.17B.
Figure 14.29: Another example of rind shape created using Eschers idea. The
initial manifold mesh for rind modeling shown in (A) is obtained by applying the
DooSabin scheme [168] a genus 6 surface. We created the shape shown in (B) by
peeling. The shape in (C) is obtained by applying CatmullClark [165] to the shape
shown in (B). The mesh in (C) is the same as the one that is shown in Figure 14.18.
lateral mesh as shown in Figure 14.30. Figure 14.31 shows a spiral peeled rind
shape created from a torus.
We have also developed and implemented two new schemes which we call
Honeycomb 1 and 2, that can create useful mesh structures for rind modeling.
The new schemes are illustrated in Figures 14.32 and 14.34. In both schemes, the
algorithms to compute the positions of new vertices give C
1
continuity and allows
for shape control with a tension parameter. Honeycomb 1 subdivision scheme is
useful for creating ower patterns. This scheme creates ower patterns around
extraordinary vertices (which include vertices higher than valence three and faces
higher than six sides). Examples of rind shapes that are created by using this prop
erty are shown in Figure 14.33. The honeycomb 2 scheme is useful for creating
frames around each face of a mesh structure. Examples of rind shapes that are
created by using this property are shown in Figure 14.35.
Figure 14.30: An example of the creation of a mesh structure for spiral shaped
peeling from a regular fourconnected quadrilateral mesh. Either of the remeshes
shown in (B) or (C) can be used.
Figure 14.31: An example of spiral peeling after remeshing the torus shown in (A).
(B) is the initial mesh to create the spiral rind shapes shown in (C).
14.15 Conclusion and Future Work
In this paper, we presented a user friendly manifold modeling method to easily
construct very high genus rind shapes. Our semiautomatic method is simple and
easy to implement. We have also introduced various remeshing strategies to create
initial surfaces that allow the creation of interesting rind surfaces. Development of
new remeshing strategies that allow various types of artistic applications might be
an interesting future research direction.
Our semiautomatic method simplies the modeling process, but there are many
applications that can be done with complete user control but not with our approach.
For instance, users can easily open holes using offset surfaces that do not have the
same mesh structure as the initial surfaces as shown in Figure 14.36. The creation
of offset surfaces that do not have the same mesh structure as the initial surfaces is
just one part of the problem. It is also necessary to identify corresponding faces for
the initial and offset surfaces. This identication can be especially interesting since
it may sometimes require onetomany correspondence between each face of the
offset surface and more than one face of the initial surface. If there exists oneto
many correspondence, another interesting problem would be to create a hole from
one face to multiple faces.
Figure 14.32: Illustration of honeycomb 1 remeshing algorithm.
Figure 14.33: An example of ower pattern creation with honecomb 1 algorithm.
To create this pattern, each edge of the dodecahedron shown in (A) is subdivided
twice. The ower patterns are obtained by applying honeycomb 1 algorithm twice
to the resulting mesh.
Figure 14.34: Illustration of honeycomb 2 algorithm.
Figure 14.35: An example of frame creation with honeycomb 2 algorithm. The
mesh shown in (B) is created by using honeycomb 2 algorithmfromthe mesh shown
in (A). The subdivided version of the rind shape in (C) is used to create image in
Figure 14.17A.
Figure 14.36: An example of limitations of semiautomatic approach. The offset
mesh shown in (B) cannot be created without changing mesh structure of initial
mesh shown (A). Users can easily create rind shapes in such cases as shown in (C).
Chapter 15
Very HighGenus Modeling
15.1 Introduction
15.2 Wire Modeling
15.3 Column Modeling
15.4 Questions
193
Chapter 16
Fractal Modeling
Fractal geometry has emerged as one of the major mathematical approaches for de
signing unusual 3Dshapes during the last two decades. Examples of such shapes in
troduced by fractal geometry include the Sierpinski tetrahedron, the Menger sponge,
the Mandelbrot set and Julia sets [14].
Fractal geometry shapes are artistically intriguing and aesthetically pleasing
[14]. Moreover, they provide unique challenges for the development of robust and
computationally efcient shape construction approaches. Most shape construction
algorithms for fractal geometry are given by a set of rules that are applied to an
initial shape (see [3]). The problem with these shape construction algorithms is that
they are hard to generalize. Each algorithm approaches its target shape regardless
of the shape of the initial object. These algorithms do not allow construction of
different target shapes from different initial shapes.
Although this approach is not the only method for constructing fractal shapes.
These alternative approaches are usually not dimension independent and are hard
to implement in 3D, so they have not been widely used in 3D applications.
Subdivision schemes provide a fresh alternative to fractal construction algo
rithms. They are conceptually similar to fractal constructions, i.e., they are also
195
given by a set of rules that are applied to an initial shape. However, the subdivision
schemes have three advantages: (1) their underlying rules (remeshing schemes) are
mesh topological in nature, (2) the rules can simply be applied to any manifold
polygonal mesh, (3) the limit shapes depend on initial shapes.
In this chapter, we present three remeshing/subdivision schemes that can cre
ate unusually interesting shapes when it is successively applied to any manifold
meshes, especially, to planar faced polyhedra in which all vertices 3valence. Our
subdivision scheme is a variant of polyhedral vertex truncation scheme.
16.1 Introduction
One of the major mathematical approaches to design unusual shapes is Fractal ge
ometry. As told by Mandelbrot [14], Fractal geometry are often described as a
New Form of Art. Mandelbrot not only does not reject this idea, but he sup
port it by saying that [with fractal geometry] all we do deal with a new form of
the controversial but ancient theme that all graphical representations of mathemat
ical concepts are a form of art. Fractal geometry also introduced many new 3D
forms such as Sierpinski tetrahedron, Menger sponge, Mandelbrot and Julia sets.
Shortly after their introduction by Mandelbrot, fractals have been widely used in
contemporary architectural design. A large number of international architects such
as Peter Eisenmann, Greg Lynn, Asymptote, Charles Correa, Coop Himmelblau,
Carlos Ferrater, Arata Isozaki, Charles Jencks, Morphosis, Eric Owen Moss have
produced fractal rich contemporary architectural designs [1, 12, 16, 17, 18, 19].
We can add some other designers like Karl Chu [24, 15] who are concerned with
genetic algorithms like Lsystems or cellular automata. Architecture researchers
also discovered that even before introduction of fractals, there existed many archi
tectural examples that are rich in fractal aspects like facade environment relation
in some vernacular dwellings [4], plan layouts and mass structures in the styles of
modernistic architects such as Frank Lloyd Wwright, Mies Van Der Rohe [17]
In this chapter, we present a computationally efcient, robust and simple to
implement subdivision schemes that allows construction of polygonal meshes that
have Fractal property.
16.2 Motivation
A large class of fractal geometrical shapes, including the Sierpinski tetrahedron
are selfsimilar. Such shapes can be constructed with a simple procedure that ex
ploits their selfsimilarity property (introduced by Barnsley [3]). The most common
approach is to repetitively take the union of transformed (e.g. scaled, rotated, trans
lated and mirrored) copies of an initial shape. For instance, if a selfsimilar Fractal
shape can be given as
S = U
K
k=0
A
k
S
where A
k
is a 4 4 transformation matrix in homogenous coordinate system and U
is the union operator, then, an algorithm to construct such a shape involves creating
a series of shapes starting from an initial shape S
0
as
S
n
= U
K
k=0
A
k
S
n1
In practice, it is possible to ignore the union operation since using disconnected
copies will visually give the same results. As a result, the number of the copies
increases K times in each iteration. Since the number of copies increases very
quickly, after a few iterations a good approximation of S can be obtained. Because
of its simplicity, this approach is widely used to create fractal shapes. Another
important property of this approach is that it is dimension independent, i.e. the
same conceptual algorithm can be used both for 2D and 3D shape construction.
Moreover, this algorithm is independent of the way the shape is represented, e.g, S
0
can be a set of points, an implicit surface, a polygonal surface, or a NURBS surface.
Regardless of the type of the initial shape, the same algorithm can be used.
However, these algorithms do not allow construction of different target shapes
from different initial shapes. The algorithms are specic to the target (limit) shapes.
Each algorithm approaches its target shape regardless of the shape of the initial
object. These algorithms do not allow construction of different target shapes from
different initial shapes.
16.3 Generalized Sierpinsky Polyhedra
This section presents a computationally efcient, robust and simple to implement
subdivision scheme that allows construction of connected & manifold polyhedra
that have the Sierpinsky property. Two shapes created by using our approach are
shown in Figure 16.1. As seen in this gure, our scheme is dependent on the initial
shapes, i.e., different initial shapes give different (but similar looking) limit shapes.
Moreover, some of these shapes cannot be constructed by geometrically combin
ing afne copies of a Sierpinsky tetrahedron. For instance, although the shape in
Figure 16.1(B) can be assembled from afne copies of (A), (C) is topologically dif
ferent from the Sierpinsky polyhedron in (A) and cannot be created by afne copies
of (A).
16.3.1 Generalization of Mandelbrots Alternative Sierpinski Tri
angle Construction
However, several of these approaches allow construction of a variety of fractal
shapes from different initial shapes. A notable example is one of Mandelbrots
alternative Sierpinski triangle constructions that relies upon cutting out tremas
as dened by Mandelbrot [14].
(A) (B) (C)
Figure 16.1: Two shapes created by using our approach. Initial shapes are (A) a
tetrahedron (B) a cube and (C) an octahedron.
We observe that an attractive property of the above construction is that the ini
tial shape does not have to be a uniform triangle (Mandelbrot did not explicitly
mention it [14]). The initial shape can be a convex polygon by simply restating the
construction algorithm as from each convex polygon cut a convex polygon that is
created by connecting the midpoints of each edge as shown in Figure 16.2. After
rst application of this algorithm, all polygons become triangles. The algorithm
also works for nonconvex polygons, however, some parts of the initial polygon
can be removed by cut operation as shown in Figure 16.3. If we interpret the cut
operation as an exclusiveor operation instead of a setdifference, we can safely
apply this construction to even nonconvex shapes as shown in Figure 16.4.
Figure 16.2: Generalization of Mandelbrots alternative Sierpinski triangle con
struction to convex polygons.
16.3.2 Extension to 3D
It is hard to extend this algorithm to three dimensions using set operations. To
construct a generalized Sierpinski polyhedron, we need to take a setdifference (or
exor) of the initial polyhedron with a polyhedron that is constructed by connecting
midpoints of each edge in the original polyhedron. There exist two problems:
1. Unlike the union operation, which can be visually implied without any im
plementation as such (we simply have to render all the objects), the set differ
ence operation needs to be implemented. In this particular case set difference
is particularly hard to implement since it creates nonmanifold shapes [180].
2. Construction of a polyhedron by connecting the midpoints of each edge of
the initial polyhedron can also be hard in solid modeling. In the case of a
tetrahedron, the problem is easy since the shape that is constructed is an octa
hedron; i.e. the faces are triangular and therefore planar. But for most cases,
the faces may not be triangular and hence may not be planar, complicating
the setdifference procedure even further.
Figure 16.3: Mandelbrots alternative Sierpinski triangle construction for non
convex polygons.
In this paper, we present an algorithm that provides a 3D version of the gener
alized Sierpinski triangle construction. Our 3D construction scheme is very similar
Figure 16.4: Mandelbrots alternative Sierpinski triangle construction for non
convex polygons by using ExclusiveOr instead of setdifference.
to subdivision schemes [168, 165, 107, 113, 106, 154, 111], although we do not
construct a smooth shape, .
Like every subdivision scheme, our algorithm is based on a simple remeshing
scheme.
Similar to subdivision schemes, our algorithm can be applied to any polygo
nal manifold mesh
Subdivision schemes create locally regular regions that approach parametric
surfaces such as cubic BSpline surfaces. Our algorithm also creates regular
regions that approach Sierpinski tetrahedra.
Similar to subdivision schemes, our scheme has extraordinary points. Initial
valencen vertices continue to exist as a part of nsided pyramids. The newly
created pyramids are all 3sided, i.e., tetrahedral.
However, unlike subdivision schemes, we change the topology of the initial mesh.
Unlike popular algorithms for selfsimilar fractals, we do not create distinct sur
faces. Instead each connected component in our initial manifold mesh remains
connected. After the rst iteration, each iteration increases the genus of the shape
four times.
16.3.3 Sierpinski Subdivision Algorithm
Let V be the list of vertices, E the list of edges and F the list of faces in the original
mesh. Moreover, let an edge whose end points (vertices) are the same be referred
to as a selfloop. Then the algorithm is given as follows:
1. For every edge e
i
in E that is not a selfloop, subdivide e
i
at its midpoint.
Let V
m
be the list of all newly created edge midpoints.
2. For every vertex v
i
in V
(a) For every corner c
i
= a, v
i
, b which points to v
i
, insert an edge
(shown as blue edges in Figure 17.6.B) between the corners c, a, v
i
and v
i
, b, d, where c, a, v
i
, b, d forms a subsequence of vertices
dening a face in the mesh.
This will subdivide each face f in the original mesh into as many triangles as
the number of vertices in f plus one central face (shown as yellow faces in
Figure 17.6.D) which will have the same number of vertices as f.
3. For each vertex v
i
in V
m
(a) Find the corners c
1
and c
2
pointing to v
i
that are also part of one of the
central faces created in the previous step.
(b) Insert an edge (shown as red edges in Figure 17.6.C) between c
1
and c
2
.
After step 3 in the above process, all the central faces created in step 2 will no
longer exist and we will have holes in their place. The restriction on edges not being
selfloops in step 1 is necessary for recursive operation, since the edges inserted in
step 3 above will all be selfloops.
(A) (B) (C) (D)
Figure 16.5: Visual presentation of the algorithm. (A) is the initial mesh, in (B),
each edge is subdivided and midpoints are connected by inserting edges (shown as
blue) to create new faces. In (C), an edge (shown as red) is inserted between two
corners of each midpoint vertex. The yellow faces are automatically eliminated and
new (white) faces are created.
The most important part of this algorithm is that the back faces (shown as white
faces Figure 17.6.D) are automatically created. Each one of these faces has one self
loop on each one of its own vertices. Since (in practice) the selfloop edges have
zero length, resulting faces look like they have n number of sides instead of 2n. For
instance a triangle looking face is actually a hexagon as shown in Figure 16.6(A)
and (B). (Selfloops do not form separate faces, but they belong to the triangle
looking backfaces. Holes can appear becomes visible only after all the selfloops
are inserted.)
These selfloops act like boundaries that allows connection of each pyramid to
another. The topological structure of one such connection between two hexagons
(that look like triangles) is illustrated in Figure 16.6(C). Since these selfloops cover
zero area, the resulting shapes look like nonmanifolds, although they are mani
folds.
Note that this algorithm does not provide a setdifference or an exclusiveor
operation. It gives acceptable results only for this particular problem. The algorithm
is attractive mainly because of its computational efciency and simplicity.
(A) (B) (C)
Figure 16.6: (A) and (B) are two topological renderings of a hexagonal face that
looks like a triangle. (C) shows how to create a nonmanifold looking manifold
structure by appropriately connecting trianglelooking hexagonal faces in (A) and
(B). .
16.3.4 Results
Although we assume that the faces and edges can have any shape, in practice, their
shapes are dened by OpenGL; i.e., edges are straight lines and faces are hardware
rendered polygons. Therefore, although the algorithm can be applied to any man
ifold mesh, the quality of the results depends on properties of the initial manifold
mesh.
In the discussion of the evaluation of the results, we ignore selfloops since
they are only useful for simplication of the algorithm and otherwise invisible to
viewers. For instance, we would call a face a triangle even if it is actually a hexagon
with three selfloops.
To evaluate the results, we have classied vertices into 5 categories. Our classi
cation of a vertex is based on the pyramid created by the straight edges (ignoring
selfloops) that share that particular vertex: (1) Convex vertex. The tip of the pyra
mid is convex. (2) Star vertex. The tip of the pyramid is star. (3) Concave vertex.
The tip of the pyramid is concave. (4) Planar vertex. The tip of the pyramid is
attened. (5) Saddle vertex. The tip of the pyramid is saddle shaped. Based on this
classication, we identied the following cases.
If the initial mesh consists of only 3valence convex vertices such as in a
dodecahedron or a cube [152], after the rst iteration of the algorithm, the re
sulting mesh consists of only tetrahedral shapes. Since in a tetrahedral shape,
each face is a triangle there is no problem in rendering. The faces of the con
vex polyhedron with 3valence vertices do not have to be planar.as shown in
Figure 16.18.
(A) (B)
Figure 16.7: (A) An initial mesh (deformed cube) that consists of only 3valence
convex vertices with nonplanar faces (B) the resulting shape after 4 iterations.
If the initial mesh includes some non3valence convex vertices such as in an
icosahedron or an octahedron [152], the resulting mesh always includes non
triangular faces. The planarity of these faces depends on the vertex positions
in the initial mesh. This is not a grave problem since with each iteration such
nonplanar faces become more and more planar even if they were not planar
initially.
If the initial mesh includes some star vertices, the resulting mesh always in
cludes star shaped faces. Even if these faces are planar, hardware rendering
can sometimes create visual problems when star shapes are converted to tri
angles. However, again this is not an important issue since many interactive
renderers do not create any problems. as shown in Figure 16.8.
If the initial mesh includes some concave vertices, each one of these concave
vertices creates a geometrically inverted pyramid, i.e. normal vectors points
inside of the pyramid instead of outside. This problem is not easy to see and
can be corrected easily by inverting normals.
If the initial mesh includes some planar vertices, each one of these planar
vertices creates a attened pyramid. This problem can be visually annoying
but cannot be corrected. Unfortunately, the number of attened pyramids
increases with each iteration. as shown in Figure 16.9. Therefore, it is better
to avoid planar vertices.
(A) (B)
Figure 16.8: (A) An initial mesh that includes both star and concave vertices (B)
the resulting shape after 4 iterations.
(A) (B)
Figure 16.9: (A) An initial mesh that includes some planar vertices (B) the resulting
shape after 4 iterations.
If the initial mesh includes some saddle vertices, each one of these saddle
vertices creates a selfintersecting pyramid. This problem can also be be
visually annoying and cannot be corrected. However, the number of self
intersecting pyramids stays the same in each iteration and in every iteration
they become smaller and less annoying.
One of the advantages of our approach is that our algorithm produces connected
and manifold polyhedra. If we smooth these polyhedra by applying DooSabin or
CatmullClark [168, 165], the smoothed shape remains connnected as shown in
Figure 16.10. We have used DooSabin scheme since it is particularly useful for
smoothing such nonmanifold looking manifold meshes (see [157, 159] for detailed
discussions). The Figure 16.11 shows examples of other subdivision schemes that
can effectively smooth these Sierpinsky polyhedra.
16.4 Generalized Leibnitz Polyhedra
Generalized Leibnitz Polyhedra is an unusual class of semiregular polyhedra that
are contradictorily interesting, i.e. they are smooth but yet C
1
discontinuous. To
create these shapes we apply a polyhedral truncation algorithm based on Chaikins
scheme to any initial manifold mesh. Figure 16.12 shows two shapes that are cre
ated by using our approach.
Our polyhedra are closely related one of the earliest known 2D fractal forms
called Leibnitz packing of a circle (which themselves are a special case of an earlier
form called Apollonian nets and gaskets) [14]. According to Mandelbrot, Leibnitz
described it in a letter saying that Imagine a circle; inscribe within it three other
circles congruent to each other and of maximum radius; proceed similarly within
each of these circles and within each interval between them, and imagine that the
process continues to innity... Our operations converts each vertex of an initial
(A1) (B1) (C1)
(A2) (B2) (C2)
(A3) (B3) (C3)
Figure 16.10: Examples of smoothed Sierpinsky polyhedra. Column (A) is tetra
hedron, (B) is cube and (C) is octahedron. First, second and third rows shows
DooSabin smoothing after one, two and three iterations of our Sierpinsky scheme.
(A) (B) (C)
Figure 16.11: An example of smoothing effects of subdivision schemes over a sim
ple Sierpinsky octahedron. (A) DooSabin (B) CatmullClark and (C) extended
Loop (modied to include nontrinagles).
Figure 16.12: Two examples of smoothfractal polyhedra that is created by our
system.
polyhedron to a 3D form which looks similar to Leibnitz packing.
16.4.1 Polyhedral Vertex Truncation
Vertex truncation scheme is commonly used in Archimedean polyhedra construc
tion [152]. Vertex truncation simply cuts each vertex with a planar surface. Mesh
topological (remeshing) effect of vertex truncation is shown in Figure 17.6.
Figure 16.13: Remeshing effect of vertex truncation.
As seen from this gure, After the application of a vertex truncation scheme,
each polygon with n number of sides converts to an equilateral polygon with
2n number of sides;
each vertex with valence m becomes an equilateral polygon with m number
of sides; and
all the new vertices become 3valence.
In addition to these topological conditions, the polyhedral vertex truncation must
satisfy one geometric condition: every initial and newly created polygonal face
must be an equilateral and planar [152]. If the polyhedral vertex truncation is
applied successively, because of the geometric condition each face eventually be
comes a circle. And moreover the limit polyhedra closely resemble Leibnitz pack
ing (in this case, the circles are not in the same plane).
Although, the surface of the limit shape is not fractal, the edges of limit polyhe
dra shows fractal property. Note that a shape is fractal if its HausdorfBesicovitch
(or fractal) dimension is not an integer (This condition is sufcient but not neces
sary, i.e. a shape can be a fractal even when its fractal dimension is an integer)[14].
To compute fractal dimension, we need to nd out how much the length of the
edges is scaled, S, and how many more edges, N, are needed in each iteration.
Then, the fractal dimension, D is computed as
D =
ln(N)
ln(1/S)
when n, the number of the sides of largest polygon goes to infty
Using the fact that in each iteration a regular n sided polygon goes to a regular
2n sided polygon, we can nd that the length of the edges is scaled by
S =
1
2 cos(
2
n
)
where n is the number of the sides of the largest circle. Although, this number is
not constant, note that when n goes to , it approaches a constant number
S
n
1
2
To compute N, rst note that after the rst iteration, all vertices becomes 3
valence and in each iteration the number of vertices increases by 3. In manifold
surfaces in which every vertex is 3valence, the following relationship exists be
tween the number of vertices and edges:
3V
k
= 2E
k
. (16.1)
In this equation, V
k
and E
k
are the number of vertices and edges in iteration k
respectively. Since, in each iteration the number of vertices increases by 3, the
number of edges must also increase by 3 to satisfy the equation 16.1. As a result,
the dimension of polyhedral edges is found to be a noninteger
D =
ln(N)
ln(
1
S
)
=
ln(3)
ln(2)
= 1.5849;
this number is the same as the the dimension of Sierpinski triangle.
16.4.2 New Vertex Truncation Scheme
There are three problems using polyhedral vertex truncation to create smooth fractal
polyhedra.
1. Initial polyhedra that can be used for such an operation are extremely limited.
All ve Platonic polyhedra and some Archimedean polyhedra.
2. Polyhedral vertex truncation scheme is not stationary, i.e. it changes with
each iteration.
To solve these problems we simply adapt Chaikins algorithm to vertex trunca
tion. We use Chaikins algorithm to determine the positions of the new vertices after
a cut operation, i.e., we cut each line from 1/4 and 3/4. Figure 16.14 shows ve
iterations of this scheme when it is applied to uniform tetrahedron. Figure 16.15
shows the effect of ve iterations of the scheme when it is applied to uniform cube
and dodecahedron respectively.
Unlike polyhedral vertex truncation, with this scheme, the faces, in the limit, do
not go to circles; Chaikin algorithm approaches quadratic Bsplines [111, 154] and
parametric polynomials cannot represent circles [58]. Similar to polyhedral vertex
truncation, we can show that the dimension of the edges will also be D = 1.5849.
Figure 16.14: A tetrahedron and 5 successive vertex truncation operations applied
to the tetrahedron.
(A
1
) (A
2
) (A
3
) (B
1
) (B
2
)
Figure 16.15: (A
1
), (A
2
) and (A
3
) are a cube and two views of its smooth fractal
polyhedra that is created by 5 successive operation of vertex truncation. (B
1
) is a
dodecahedron and (B
2
) is its smooth fractal counterpart created by 5 iterations of
vertex truncation.
Comparing to polyhedral vertex truncation, this new vertex truncation scheme has
several advantages. It is stationary and simple to implement. Moreover, the scheme
is robust, i.e. it can be applied to any manifold mesh.
Although, the new scheme can be applied to any manifold mesh, if each face of
initial mesh is planar and each vertex is 3valence, then in each iteration we con
struct only planar faced polyhedral meshes, which can be very useful for Architec
tural applications. Initial 3valence vertex condition guarantees that newly created
faces after rst application of the vertex truncation are planar faces. But, this is not
necessary condition, i.e. for some special planar polyhedra such as regular octa
hedron and icosahedron as shown in Figure 16.16, the scheme still creates planar
faces even with valence otherthan3 vertices. (Since all the vertices are 3valence
after the rst iteration, all the faces created after second iteration are automatically
planar.) To create interesting polyhedra with planar faces, the initial faces have to
be planar, but they not have to be uniform. They can have any shape, e.g. stars and
other nonconvex shapes.The Figure 16.17 show two such examples.
(A
1
) (A
2
) (B
1
) (B
2
)
Figure 16.16: (A
1
) is an octahedron and (A
2
) is its 5 times vertex truncated version.
(B
1
) and (B
2
) are an icosahedron and its 5 times vertex truncated counterpart. No
tice that the faces are still planar despite the fact that 4valent and 5valence vertices
of octahedra and icosahedra respectively.
If the initial meshes do not have only planar faces and 3valence vertices, some
faces of the constructed polyhedra may not be planar. The problem with such non
planar faces is that they may not be meaningfully reconstructed during rendering
process. The problem can be theoretically worse during hardware rendering, but,
as it can be seen in the screenshot images shown in Figure 16.18, these nonplanar
faces with curved boundaries can be acceptably rendered (On the other hand, one
of the bilinear quadrilateral faces of the deformed cube in Figure 16.18 does not
look like a quadrilateral because or the triangulization in rendering stage). To built
a real solid shape, the nonplanar faces with curved boundaries need to be be recon
structed by using a boundary interpolating subdivision scheme [154, ?].
(A
1
) (A
2
) (B
1
) (B
2
)
Figure 16.17: (A
1
) is a nonconvex polyhedron with nonconvex planar faces and
(A
2
) is its 5 times vertex truncated counterpart. (B
1
) is another nonconvex polyhe
dron with nonconvex planar faces and (B
2
) is its 5 times vertex truncated version.
16.4.3 Stone Wall Creation with Vertex Truncation
An unexpected usage of this approach is modeling walls that are made up stone as
seen in Figure 16.19.D. To create such stone walls, we rst subdivide a planar face
into a set of polygons with valence3 vertices (see Figure 16.19.A) and applied a
(A
1
) (A
2
) (B
1
) (B
2
) (C
1
) (C
2
)
Figure 16.18: (A
1
) and (A
2
) are a deformed cube with nonplanar faces and its 4
times vertex truncated version. (B
1
) is a genus1 shape with 4 valent5 vertices that
cause to construct nonplanar faces in the rst iteration and (B
2
) is its 4 times vertex
truncated version. (C
1
) and (C
2
) are a shape that is created by connecting eight
spacepacking polyhedra, truncated octahedron, and its 4 times vertex truncated
version.
few iteration of vertex cutting algorithm (see Figure 16.19.B). Then, using standard
extrusion operation, we extrude each rounded face a few times with decreasing
amount scaling and translation (see Figure 16.19.C).
16.5 Generalized Koch Polyhedra
16.6 Questions
(A) (B) (C) (D)
Figure 16.19: A stone wall created by using our approach.
Chapter 17
Tiled Textures
The chapter present a simple and practical method for seamlessly texturing any
manifold mesh. The resulting textures provide aperiodicity on the surface of the
mesh and yields singularity free textures regardless of the singularities existing in
the quadrilateral mesh. The method consists of four steps:
1. Convert given manifold mesh into a quadrilateral mesh by using a quadrilat
eralization scheme such as CatmullClark.
2. From a given image, create a set of tiles that satisfy specic boundary condi
tions to cover any quadrilateral mesh without any discontinuity or singularity.
3. Organize the tiles into one texture image le which is called a tiled texture.
4. Assigns one tile to every quadrilateral in the given quadrilateral mesh.
17.1 Introduction
Texture mapping, introduced by Catmull [6], is very popular in computer graph
ics applications since it allows the creation of complicated looking images with
219
out increasing the complexity of the surface geometry. There are three main chal
lenges that people face when mapping homogeneous textures to arbitrary polyhe
dral meshes: (1) avoiding noticeable seams between texture patches, (2) avoiding
texture singularities even when the underlying mesh has geometric singularities,
and (3) minimizing the amount of distortion of the texture.
Neyret and Cani [29] recently developed a texture mapping method to provide
an effective solution to these problems. Their method, which is based on triangular
tiles with specic boundaries, avoids singularities regardless of the topology of the
underlying triangular mesh. Their method also provides seamless and continuous
boundaries across the surface. This method is similar in spirit to the method de
veloped by Stam [31] for aperiodically texturing planes and toroids. However, the
NeyretCani method is more general since it can be used to seamlessly texture any
triangular mesh and avoids periodicity.
To achieve this, their rst step was to create triangular tiles that obey specic
boundary conditions.They showed that if one can create a minimum number of
tiles, that with rotation can provide all possible tile boundaries, it is possible to
seamlessly cover any triangular mesh with these tiles. The simplicity and the power
of the NeyretCani method makes it very attractive for texture mapping applica
tions. From a practical point of view, there are two challenges with this method:(1)
The artist cannot automatically create tiles from existing images. To create homo
geneous textures that look like those of natural objects, several different texture
samples have to be handdesigned, which can be difcult. (2) Using a set of trian
gular texture images is not compatible with current texture mapping methods and
requires special programming. Most commercial renderers (like those in Maya,
Softimage etc), allow only one single rectangular texture image to be read for each
parameter of a shader.
Soler, Cani and Angelidis have recently introduced a very powerful extension
to the NeyretCani method [30]. Their new method not only solves the challenges
mentioned above but also provides anisotropic texturing. However, their algorithm
is complicated and can be quite hard to implement. Although their implementa
tion is very efcient, it still takes several minutes to compute a texture mapping.
Moreover, if the texture image is changed there is a need to recompute the texture
mapping.
In this chapter we present an alternative extension to the NeyretCani method.
Our method also provides an effective solution to the challenges mentioned above.
Moreover, it is simple to implement. The texture mapping algorithm consists of just
a few lines of code and is extremely fast. In addition, once texture coordinates are
computed, these coordinates can be used for any tiled texture image, i.e., there is
no need to recompute texture coordinates for different textures.
Using our method, users interactively synthesize texture image les from exist
ing images with a simple interface (see Figures 17.1 and 17.3) . Our texture image
les consist of a set of square tiles. Consistent organization of these tiles in the tex
ture image yields an extremely simple texture mapping algorithm. Our algorithm
assigns texture coordinates to each corner of the mesh while providing seamless
and continuous boundaries across the surface. Once the texture coordinates are
assigned, the resulting textured mesh can be used in any commercial modeling or
animation system such as Maya or Softimage. Figure 17.2 shows two tiled texture
images created from Miro and Kandinsky paintings that are mapped to a surface of
a sphere.
17.2 Methodology
Our fundamental simplifying breakthrough came from(1) using numbers to identify
the boundary types instead of labels, (2) using square tiles instead of triangular tiles,
and (3) using all possible tiles instead of only a minimal set.
Neyret and Cani use labels such as E and E
1
to denote boundary types. Fig
(A) (B)
Figure 17.1: Reproductions of (A) Miro and (B) Kandinsky paintings that are
used to create tiled textures in Figure 17.3. (These reproduction are from
www.artsunframed.com.)
Figure 17.2: Mapping two tiled texture images (see Figure 17.3) created from (A)
Miro and (B) Kandinsky paintings to a spherical shaped mesh.
(A) (B)
Figure 17.3: Tiled texture images created from (A) Miro and (B) Kandinsky paint
ings. These tiled textures were used to create the images in Figure 17.2.
ure 17.4(A) shows their labeling scheme, in which the boundary cuts through an ar
row image. It turns out that if we use numbers instead of labels to denote boundary
types we can organize the tiles into a texture image and develop simple and efcient
algorithms for texture mapping. Figure 17.4(B) shows our numbering scheme. As
seen in this gure, we use 0 instead of E and 1 instead of E
1
. A counterclockwise
walk starting fromthe lowerleft corner of a square tile gives each tile a unique name
which is a fourdigit binary number as shown in Figure 17.4(C). These names are
also useful to relate the tiles to each other. A cyclic shift of the name corresponds
to a 90
0
rotation of the boundaries.
To seamlessly cover a quadrilateral mesh, we need at least six tiles, such as
0000, 1000, 1100, 1110, 1010, 1111. The main problem with any such minimal set
is that it is difcult to develop a simple scheme to meaningfully organize these tiles
Figure 17.4: Numbering the boundary types and naming the tiles with these number.
into one texture le. However, if we use all possible tiles instead of a minimal set,
the organization problem greatly simplies and our numbering scheme allows us
to organize these tiles in a texture map in a meaningful way. As shown in Fig
ure 17.5(A) we can use their names as if they were positions in a matrix. Here, the
rst two digits of the name give the column number and the second two digits give
the row number.
(A) (B)
Figure 17.5: (A). An example of tiled texture image that shows how tiles are orga
nized in a matrix. (B). A hand created tiled texture image.
In this case, the tiles with rotationally identical boundaries can be different. For
instance 1010 and 0101 do not have to be rotated versions of each other. If we allow
1010 and 0101 to be different then we can use our 2D texture space more efciently
since having more variety of tiles helps to obtain better aperiodicity. A hand created
example is shown in Figure 17.5(B). In this gure, we show the tile boundary edges
so that separate tiles are visible.
The example above has one distinct boundary condition, but this concept can
easily be generalized to n distinct boundary conditions (see section 17.6).
17.3 Mapping Tiled Texture Images
Based on the convention presented in Section 17.2, it is extremely easy to develop
a texture mapping algorithm for tiled texture images. Our algorithm assigns one
tile from a tiled texture image to each quadrilateral in such a way that all boundary
conditions are satised. The texture mapping algorithm consists of two procedures
(see Figure 17.6). The rst procedure AssignBoundaries(G, n) guarantees that
boundary conditions are satised. This procedure randomly assigns 0 or 1 to each
halfedge [147] of every edge of the mesh by using two random variables. We use
the halfedge concept since it helps to explain the algorithm more concisely. How
ever, implementation of the algorithm does not require a halfedge data structure.
Once AssignBoundaries(G, n) is completed, four boundary types e
0
, e
1
, e
2
, e
3
are assigned to each quadrilateral of the mesh G. Note that the sequence e
0
e
1
e
2
e
3
is actually the name of the tile to be assigned to each quadrilateral. Since the name
of each tile also gives the tiles position in the texture image le, it is straightfor
ward to compute these texture coordinates as it is detailed in the second procedure
AssignTextureCoordinates(G, n) (see Figure 17.6). The equations to compute tex
ture coordinates turn out to be quite simple since the tiles are placed in logically
consistent locations. In these equations we assume that the texture image is stored
with the origin at the bottomleft, texture coordinate (0,0), the width and height of
the texture image is one unit (i.e. the coordinate of upperleft is (1,1)), and the
edges of each qudrilateral are given in counterclockwise order. Figures 17.7 and
17.8 show two examples of the results of our texture mapping algorithm.
17.4 Tiled Texture Image Synthesis
Since it is hard to create a wide variety of tiled texture images by hand, we have
developed a simple approach to automatically create tiled textures from any given
image. Our approach can be considered a variant of image quilting [27]. To cre
ate each tile of a tiled texture image we composite a background image with four
images that includes the desired boundaries.
To allow users to select the desired boundaries and background images, we have
developed a simple interface shown in Figure 19.8. Users have control over two
templates to effect the nal result. The rst template consists of two squares. The
edge that connects the two squares gives the desired boundary condition and the two
squares correspond to the 0 and 1 boundary types. We will call these images 0XXX
and XX1X to precisely identify the location of the desired boundary types. Note
that X is a place holder for undetermined boundary types. The second template is
used to dene a region from which a background image is chosen. This background
image is placed in the center of the tile, so none of its boundaries will be used in
forming the nal tiles. Therefore, we call such background images XXXX. Note
that for each tile a different background image is chosen from the region dened by
the second template.
To create each of the tiles in the tiled texture image, we composite the back
ground image XXXX and rotated versions of 0XXX and XX1X, assigning an ap
propriate map to each image. Let ABCD be the tile to be created where A, B, C
and D are binary digits. The tile
ABCD = AXXXoverXBXXoverXXCXoverXXXDoverXXXX. is composited by
using maps.
To create an acceptable tile, the rst step is to appropriately rotate 0XXX and
XX1X. Remember that in our notation a 90
0
counterclockwise rotation of an im
age corresponds to one cyclic shift operation. Thus, in order to create the tile 1001
in Figure 17.11, image XX1X must be shifted two times to get 1XXX which cor
responds to a 180
0
counterclockwise rotation. Similarly, to get X0XX we need
to rotate 0XXX 90
0
counterclockwise, XX0X can be obtained by a 180
0
counter
clockwise rotation of 0XXX, and nally XXX1 is a 90
0
counterclockwise rotation
of XX1X.
The second step is to assign appropriate opacity values for each of these im
ages. We compute opacity value = f
1
f
2
f
3
f
4
as the product of four functions. Fig
ure 17.10 shows the functions that are used to compute map 0XXX or 1XXX.
To compute opacity values for other images such as X0XX, rotated versions of
these functions are used. Note that if either one of these functions is 0 in a region,
the foreground image will be transparent in that region. Functions, f
1
, f
2
and f
3
,
guarantee that near X boundaries the image becomes transparent. Function f
4
guar
antees that for every column, once color values of two image layers become similar,
the foreground image becomes transparent. In Figure 17.11, we show an example
of how a tile is created with our method.
17.5 Implementation and Results
The texture synthesis algorithm is implemented as a standalone system in C++ and
FLTK. The texture mapping algorithm is implemented in C++ and included in an
existing 2manifold mesh modeling systemas an option. Both systems currently run
on SGI, Linux and Windows platforms. All of our interactive examples were run on
an SGIO2. All of the examples in this paper were created using these two systems.
The modeling system allows the creation of models with texture coordinates and
the resulting mesh can be exported to any commercial software package using the
obj le format. Similarly, the texture synthesis program creates a texture image in
a common image format such as jpeg and these image les can be exported to any
commercial software. As a proof of concept, we have created all nal images and
animations in Maya
1
The usability of the system was tested in a graduate level computer graphics
course. 25 students with diverse backgrounds including art, architecture and com
puter science took the course. All the students, regardless of their background, were
able to successfully texture a wide variety of very high genus quadrilateral meshes
with a wide varity of textures. Some examples of this are shown in Figures 17.12,
17.13, 17.14 and 17.15.
17.6 Discussion and Conclusion
In this paper we have presented a simple and practical technique for seamlessly
texturing quadrilateral meshes. Quadrilateral meshes are very common in computer
graphics and any mesh can easily be converted to a quadrilateral mesh using a vertex
insertion scheme such as CatmullClark subdivision [165]. Our approach does not
guarantee to minimize the amount of stretching/distortion of the texture. However,
application of the CatmullClark scheme reduces distortion signicantly.
The examples above have one distinct boundary condition, but this concept can
be easily generalized to n distinct conditions by using fourdigit 2nary numbers.
A boundary k will be represented by two boundary types that will be denoted by
2k and 2k + 1 where k = 0, 1, . . . , n 1 and a tiled texture image will consist of
(2n)
4
tiles. Similarly, the tile boundaries will be used as their names and respective
positions in the texture. Again, the rst two digits give the column number and
1
CatmullClark subdivision in Maya [165] provides bilinear interpolation of texture coordinates.
We used this property to obtain large quadrilateral curved patches.
the second two digits give the row number. The texture mapping algorithm can be
converted to support n distinct conditions by adding only one additional line to the
AssignBoundaries procedure and changing the equations in AssignTextureCoor
dinates
2
.
Our scheme, as presented in this paper, does not provide anisotropic textures.
However, by using more than one boundary condition and changing the texture
mapping algorithmsuch that it can properly arrange each tile, we can obtain anisotropic
textures.
Although, our texture synthesis approach succesfully converts any image to a
tiled texture, the method is somewhat ad hoc, and there is a need for more control
over nal results. Promising future extentions would be to develop a painting ap
proach for tiled textures, and to provide more precise control over the background
image for each tile.
2
In equations, e
0
and e
2
will be multiplied by 2n instead of 2 and the equations will be divided
by 4n
2
instead of 4.
Subroutine AssignBoundaries(G)
for each edge e in G do
i rand() mod 2
e
0
i
e
1
(i + 1) mod 2
Comment: e
0
and e
1
are two integers representing boundary
types of two halfedges of e
Subroutine AssignTextureCoordinates(G)
for each quadrilateral f in G do
for i 0, 1, 2, 3 do
j ((i + 1) mod 4)/2
u
i
(2e
0
+ e
1
+j/2) /4
v
i
(2e
2
+ e
3
+i/2) /4
Comment: u
i
, v
i
are texture coordinates of each corner of f and
e
i
are boundary types assigned to f where i = 0, 1, 2, 3.
Relative positions of the texture coordinates and boundary types
of halfedges are shown in the example below.
Algorithm TiledTextureMapping(G)
AssignBoundaries(G)
AssignTextureCoordinates(G)
Comment: G is a quadrilateral manifold mesh.
Figure 17.6: Texture Mapping Algorithm
Figure 17.7: Asimple texture mapping example. Here all vertices are valence 3. We
have applied the texture to a cube and then smoothed the cube using CatmullClark
subdivision [165] in Maya.
Figure 17.8: This example shows a genus2 surface that includes valence 3, 4, 5
and 6 vertices. The original shape is also smoothed by CatmullClark [165] after
mapping the texture.
Figure 17.9: The interface of the tiled texture image synthesis system. To show the
interface concept more effectively, we articially reduced the contrast and increased
the brightness outside of template areas.
Figure 17.10: The functions that are used to compute opacity maps for either
0XXX or 1XXX.
Figure 17.11: Creation of the tile 1001 by compositing ve images.
A tiled texture created from a photograph of cracked earth.
The object textured by above tiled texture.
A detailed view that shows how the texture is mapped.
Here the same texture is also used as a bump map.
Figure 17.12: Example 1.
A tiled texture created from a photograph of rusted iron.
The object textured by above tiled texture.
A detailed view that shows how the texture is mapped.
Here the same texture is also used as a bump map.
Figure 17.13: Example 2.
A tiled texture created from a photograph of a rusted metal surface.
The object textured by above tiled texture.
A detailed view that shows how the texture is mapped.
Figure 17.14: Example 3. Note that although there is a wide range of difference
between the sizes of quadrilaterals, there is no visible stretching effect, partly due
to the fractal nature of the underlying texture.
A tiled texture created from a photograph of rusted iron.
The object textured by above tiled texture.
A detailed view that shows how the texture is mapped.
Figure 17.15: Example 4.
Chapter 18
Progressive Renement with
Topological Simplication
This chapter presents a theoretical framework for progressive renement of man
ifold meshes with topological simplication. We also show how to use the non
intutive nature of the topology changes as an advantage and develop a theretical
framework for progressive renement with topological simplication.
18.1 Introduction
Our goal in this paper is to develop a theoretical framework for progressive rene
ment schemes with topological simplications. Levelofdetail (LOD) representa
tions have recently become popular in computer graphics [41, 46, 42, 51, 80, 49].
Among the LOD representations progressive renement is particularly useful since
it allows continuous change [80, 49]. Although topological simplication can pro
vide better simplication and efcient representation, there exists no framework
that provides both progressive renement and topological simplication. Ignor
239
ing topological simplication is not special to progressive meshes. In fact, ex
cept one recent development (Hybrid meshes) [44] topological simplication is not
even considered in other LOD representations. Moreover, Hybrid meshes is a user
assisted LOD approach and cannot automatically guarantee topological simplica
tion.
As an example of application of progressive renement with topology simpli
cation, let us consider a city that consists of huge number of buildings or a forest
that is made up of lots of trees. It is not really helpful to simplify each building or
each tree to a simple polyhedron. At the end, there will still be a huge number of
polyhedra. The most viable alternative is to combine several buildings to create one
composite building and to combine a group of trees to create one composite tree.
In this way, from the distance a city block that consists of a set of buildings will
be represented by one composite building and a cluster of trees will be represented
by one composite tree. Moreover, this renement should be progressive, i.e. the
change must be gradual. For instance, let us say that the forest has 100 trees. The
number of trees should gradually reduce; 99, 98, 97, . . . , 5, 6, 4 and so on. At the
simplest level the whole city or forest should be represented by a single building or
tree. Then this building or tree should further be progressively rened into simplest
polyhedra that resemble the shape of the building or tree.
This example demonstrate progressive renement with topology simplication
will denitely be benecial for a wide variety of applications that includes games,
mesh data transmission, rendering.
In this paper, we develop a theoretical framework for progressive renement
with topological simplication. We will demonstrate that topology changes are not
intuitive and therefore a great deal of care is necessary for handling topological
simplication. We show that the same operation can both close a hole and cut a
handle. Moreover, all topology change operators can both complicate and simplify
the topology. Our framework uses the nonintutive nature of topology changes as
its advantage and guarantees high compression rates with topological simplication.
18.1.1 Previous Work
Rendering complex geometric models at interactive rates has always been a chal
lenging problem in computer graphics. Improving the rendering performance alone
could not solve this problem since the complexity of geometric models increases
with rendering performance. In other words, as the rendering performance im
proves, more and more complicated geometric models will be used. It is observed
that signicant computational gains can be obtained by automatically adapting the
complexity of a geometric model [41]. One common heuristic technique is to con
struct several versions of a model at various levels of details (LOD), i.e. a detailed
mesh is used when the object is close to the viewer, and coarser approximations
are substituted as the object recedes [41, 46]. Such LOD meshes can be computed
automatically using mesh simplication application techniques [42, 80].
There has been extensive research on the development of effective LOD repre
sentations [41, 46, 42, 51, 80, 49]. Existing LOD representations can be classied
as hierarchical and progressive. Hierarchical LOD methods are similar to wavelet
representations [65], in which there exists only a distinct number of versions of a
model. Despite their simplicity the most important problem with hierarchical LOD
representations is that the instantaneous switching between LOD meshes may lead
to perceptible popping artifacts. Moreover, hierarchical methods require a regu
lar mesh structure (e.g., every face is quadrilateral and every vertex is valence 4; or
every face is a triangle and every vertex is valence 6) [44].
Progressive meshes are developed to solve the problems of hierarchical method
[80]. In progressive meshes, unlike hierarchical LOD representations, there is no
distinct number of simplied shapes. Instead, the simplication is described as a
continuous function. Because of this property a shape can gradually be simplied.
Gradual simplication is very useful since a user can continuously zoom in the
shape without seeing sudden changes in the shape of the 3D mesh. Moreover,
the underlying mesh structure does not have to be regular. In progressive meshes
[80], only triangular faces are allowed but there is no restriction over the valence
of the vertices. Moreover, progressive representations naturally support progressive
transmission, offers a concise encoding of polygonal mesh itself, permits selective
renement [80]. In short, progressive representations offer an efcient, lossless and
continuousresolution representation.
18.1.2 Topology Simplication
In order to talk about topology simplication we assume that initial meshes are
2manifold and they stay 2manifold in each stage of rerement process. This re
quirement is important for developing consistent framework. The requirement is
not restrictive since any mesh that is given as a collection of polygon can be con
verted to a 2manifold [166, 54].
Topological simplication refers the capability of gradually simplifying any
given 2manifold mesh to a simplest genus0 surface, namely a tetrahedron. It is
important to note that topological simplication does not require reducing of genus
or combining surfaces (i.e. combining shells
1
) in every stage of renement. During
the renement genus may increase but mesh will eventually simplify to a tetrahe
dron. However, the majority of topology changes will consist of either reducing of
genus or combining surfaces.
As we have discussed earlier combining surfaces will be most common appli
cations of topology simplication since in current graphics applications manifold
meshes that consists of huge number of separate surfaces are extremely common.
1
In topology, a surface is a connected 2manifold [177]. In solid modeling literature, it is often
called as shell [181, 180].
Genus reduction will probably not be a prevailing application in the near future
since very highgenus manifold meshes are not very common in graphics applica
tions. However, we predict that high genus meshes will eventually be common and
widely available. Especially, our current research involves to develop a wide variety
of methods to easily create very high genus meshes [162, 36, 37, 45].
It is very easy to demonstrate that topological simplication can provide ef
cient simplication. Consider a Sierpinsky tetrahedra that consists of innite num
ber (in practice, a huge number) of tetrahedra. A Sierpinsky tetrahedra cannot be
simplied by any LOD scheme since its every element is already a simplest genus0
mesh. However, common sense tells us a Sierpinsky tetrahedra should be able to be
simplied into one tetrahedron. A simplied example is shown in Figure 18.1.
Figure 18.1: By allowing topology changes these 16 tetrahedra can be simplication
into one tetrahedron.
18.1.3 Topological Simplication under Progessive Renement
The topological simplication can be useful regardless of the choice of renement
approaches. Figures 18.2 and 18.3 show examples of topological simplication un
der two different renement approaches. As these two gures illustrate, progressive
renement can provide a more natural looking simplication of topological fea
tures. However, topology simplication under a progressive renement scheme in
troduces additional challenges that will not exist under hierarchical LOD schemes.
Figure 18.2: Hierarchical LOD with progressive renement
Figure 18.3: Progressive renement with topology simplication
Our approach will be extension to progressive meshes. Thus, we will rst in
troduce progressive mesh representations. Let / be an arbitrary triangular man
ifold mesh that can be represented by rotation system of a graph ((c, 1) where
c = e
0
, e
1
, . . . , e
m
is a set of edges and and 1 = v
0
, v
1
, . . . , v
k
is a set of
vertices.
A progressive representation (PM) of a manifold mesh / is stored as a much
coarser power network /
0
together with a sequence of n detailed records that in
dicate how to incrementally rene the coarse power network /
0
exactly back into
the original power network such that /
n
= /. Each of these records will store
the information associated with a mesh transformation operation. In progressive
meshes this is VERTEXSPLIT operation.
The progressive representation (PM) of the mesh / thus denes a continuous
sequence of power networks /
0
, /
1
, . . . , /
n
of increasing accuracy, from which
the LOD approximation of any desired complexity can be efciently retrieved.
Moreover, geomorphs (continuous shape changes) can efciently constructed be
tween any two of these power networks.
To create continuous sequence of manifold meshes /
0
, /
1
, . . . , /
n
, inverse
of VERTEXSPLIT operation, EDGE COLLAPSE, is used. Since initial mesh is tri
angular, each EDGE COLLAPSE operation simplies the mesh by eliminating two
triangles, one edge and two vertices.
One of the great power of progressive mesh framework is that each direction
(simplication and complication) requires only one type of operator. However, this
theoretical framework creates two problems for topological simplication.
1. Vertex split and edge collapse cannot change the topology
2
.
2. The current progressive renement framework only allows triangles but topol
ogy changes can require faces other than triangles.
18.2 Equidistance Surfaces to Simplify Topology
Since a manifold mesh is a closed and bounded shape equidistance surfaces to this
manifold mesh will eventually simplies to a genus0 ball while distance is increas
ing regardless of the choice of distance function [164, 182, 176, 155]. The problem
with equidistance surfaces is that they eventually become much larger than initial
manifold shape. This problem can be solved by carefully scaling the shape.
Figures 18.4 and 18.5 illustrate the concept by using 2D representations. Note
that Figure 18.5 clearly shows that genus can increase while distance increases.
However, as it is clear in this example the genus will eventually simplify to 0.
2
Moreover, edge collapse can create nonmanifold. Therefore, a lot of care is needed in order to
ensure that the result is manifold [166].
Figure 18.4: An 2D representation of combining surfaces by using equidistance
shapes.
One possible implementation of topological simplication with equidistance
surfaces can be done by using offset surfaces [36]. As an example here we dis
cuss how to create progressive meshes using offset surfaces. Let /
0
be the initial
mesh. We rst need to compute a series of offset surfaces /
1
, /
2
, . . . , /
n
. Here
/
k+1
will directly be computed from /
k
. If the offset surface does not have any
selfintersection then /
k+1
will simply be progressively rened version of /
k
. If
there is a self intersection, we will remesh /
k+1
by changing the topology. We will
then apply the inverse of offset operation to /
k+1
to scale the shape back to original
size.
The scaling will generally be a nonlinear deformation. First of all, all the ver
tices that are not effected by topology change or renement should return back to
their original position. If we do not move such vertices into their original positions,
we would have to provide their positional changes in every step of progressive re
nement. Of course, this is not desired. The initial positions of newly created and
nal positions of deleted vertices correspond the Morse points of distance function
and can be computed. The interesting problem is to develop a nonlinear scaling
to compute the change in this positions. This nonlinear scaling will be given by a
Figure 18.5: An 2D representation of genus simplication by using equidistance
shapes.
deformation that minimizes the changes of positions all the other vertices.
We will continue this process until /
k+1
becomes a genus0 surface, preferably
a tetrahedron. Then /
0
/
n
and inverse of the operations will be used to get
initial mesh /
n
.
Chapter 19
Topologically Robust Mesh
Modeling:
Concepts, Data Structures and
Operations
19.1 Abstract
We extend the theory of graph rotation systems and provide a solid foundation for
2manifold mesh modeling. Based on this theory, we identify a group of simple va
lidity rules, and show that the validity of 2manifold structures can be tested very
efciently on all existing data structures for mesh modeling. Moreover, the new
theory enables us to develop very efcient implementations for manifold preserv
ing operations, which are essential for a robust interactive modeling system. Our
results can be adopted by any existing modeling softwares without a major change.
249
19.2 Introduction
Modeling 2manifold meshes with a simple user interface has been an important
issue in computer graphics and computer aided geometric design. Modeling with
2manifold meshes has its obvious advantages, including: (1) dealing with non
manifold structures greatly complicates modeling algorithms [12, 14]; and (2) many
subdivision algorithms [21] specically require 2manifold mesh structures. More
over, nonmanifold looking geometric shapes can be effectively represented using
2manifold mesh structures [11].
Although the importance of 2manifolds is widely recognized in modeling com
munity [10, 12], most commercial modeling systems allownonmanifold structures,
because of the following reasons: (1) certain popular modeling operations, such as
set operations, can easily introduce nonmanifold structures; and (2) users may in
tentionally want to create nonmanifold structures.
We take a widely used modeling system, MAYA [16] as an example. Con
sider the shapes in Figure 19.1. From the 2manifold shape in Figure 19.1(A),
Figure 19.1: Examples of nonmanifolds that can be created in Maya.
nonmanifold structures in Figure 19.1(B) and Figure 19.1(C) can be created in
MAYA by using the MERGEVERTICES operator, and the nonmanifold structure in
Figure 19.1(D) can be created in MAYA by using EXTRUDEEDGE operator. More
over, MAYA allows users to reverse normal of a face, which can also result in non
manifold structures.
Figure 19.2: An extended modeling system
This exibility of the commercial modelers can be considered an advantage for
novice users, but it eventually becomes a hurdle for experienced users in model
ing shapes with complicated topology. For instance, changing topology to create a
very high genus surface requires a great deal of work in such commercial systems.
Moreover, certain important and popular modeling operations that specically re
quire 2manifold structures now become unreliable and system may crash when a
manifold operation is applied on a nonmanifold shape that was created uninten
tionally.
Since complete redesign of the existing systems will be extremely expensive
and difcult, a solution for solving the above problem is to augment the systems
with a 2manifold modeling environment, as shown in Figure 19.2. Such an exten
sion will keep the exibility of the current modeling systems while providing high
efciency and reliability for modeling processes dealing with 2manifold shapes of
complicated topological structures.
Such an extension is involved in two important issues (see Figure 19.2): (1)
effective verications of 2manifold structures, which is necessary to make sure
that the shapes passed to the 2manifold modeler are valid 2manifold structures;
and (2) manifold preserving operations, which are employed by the 2manifold
modeler so that the 2manifold modeler can deal with all 2manifold structures but
will never create nonmanifold structures. We point out that these issues have also
been important in the research of mesh simplications (see, for example [8]).
The problem of verifying 2manifold validity of a given mesh structure has been
studied by a number of researchers. Hoffmann presented an algorithm [12] for ver
ication of the 2manifold validity of triangulated mesh structures. Guibas and
Stol gave a set of rules for deciding whether an edge algebra describes a valid
2manifold structure [10]. Unfortunately, all previous approaches have their limi
tations. For example, to apply Hoffmanns algorithm to a general mesh, the mesh
must be rst triangulated, while to apply Guibas and Stols algorithm, which is
applicable to general mesh structures, a mesh must be rst converted into the edge
algebra representation (such as the quadedge structure [10]). The study of mani
fold preserving operations has been closely related to that for 2manifold validity
verication [8, 10, 14], which has been centered on the completeness (i.e., the abil
ity of creating all 2manifold mesh structures), soundness (i.e., the robustness of
not generating nonmanifold structures), and efciency.
Our main contribution in the current paper is to establish a universal framework
for the theory and practice of 2manifold modeling systems. Based on the classical
theory of graph rotation systems studied in topological graph theory, we rst build a
solid theoretical foundation for 2manifold modeling. Our theoretical work enables
us to give very simple rules for testing topological validity of mesh structures. Our
validity rules are universal in the sense that they are independent of mesh structures
and representations. We also study a set of manifold preserving operations that can
be easily implemented in any existing system. Theory, data structures, and algo
rithms related to our new framework are thoroughly discussed. More specically,
our contributions include:
We establish a solid theoretical foundation for topologically robust mesh
modeling, by extending the classical theory of graph rotation systems;
Based on the established theoretical foundation, we propose new testing rules
for topological validity of mesh modeling: a mesh structure represents a valid
2manifold if and only if (1) each edge in the mesh induces exactly two di
rected edges; and (2) each vertex in the mesh is uniquely associated with a
cyclically ordered list containing all directed edges from the vertex;
We present efcient topological validity testing algorithms based on various
modeling data structures and representations that have been widely used in
mesh modeling. This demonstrates that the new testing rules for topological
validity are universal and can be easily incorporated in any existing modeling
systems;
We propose new data structures for topologically robust mesh modeling, de
velop efcient modeling algorithms on the new data structures, and compare
the new data structures and algorithms with those employed in existing mod
eling systems;
We study the set of modeling operators proposed by Akleman and Chen [2],
and show that the operators can be easily implemented for any mesh repre
sentation. We prove that the operator set can create all 2manifold meshes
but never result in nonmanifold structures. The operator set is simple, in
tuitive, and more effective, from the viewpoints of both theoretical concepts
and practical implementations.
In conclusion, our research provides strong evidence for the feasibility of augment
ing the existing modeling systems with a 2manifold modeler, without involvement
of any major changes, which will greatly enhance the efciency and reliability of
the current modeling technology.
r
v
2
r
v
3
r
v
4
r
v
1
r
v
6
r
v
7
r
v
5
`
`
`
e
6
/
/
/
e
3
e
4
~
~~
e
5
e
1
Z
Z
Z
e
8 `
`
`
e
9
`
`
e
7
.
..
e
10 '
'
'
'
e
2
name
e
1
e
2
vstart
v
1
v
2
vend
v
2
v
5
fcw
f
1
f
3
fccw
f
2
f
4
ncw
e
6
e
7
pcw
e
4
e
8
nccw
e
5
e
9
pccw
e
3
e
10
where the faces are: f
1
= {v
1
v
3
v
2
}, f
2
= {v
1
v
2
v
4
},
f
3
= {v
2
v
6
v
5
}, f
4
= {v
2
v
5
v
7
}.
Figure 19.3: A nonmanifold under wingededge structure
19.3 Testing topological validity
We observe that most existing mesh representations and data structures may accept
nonmanifold structures. For example, the left shape in Figure 19.3 is not a 2
manifold (the point v
2
does not have a neighborhood homeomorphic to an open
disk). However, the right table in the gure is a valid wingededge data structure
for the corresponding mesh. It is not difcult to verify that other data structures,
such as the halfedge data structure and quadedge data structure, can also describe
the mesh structure in Figure 19.3.
As we have discussed earlier, there has no universal solution yet for the veri
cation of 2manifold validity for mesh structures. Existing methods either require a
special mesh representation [10] or are only applicable to meshes of special struc
tures [12]. In this section, we propose a new approach for verication of 2manifold
validity, by extending the classical theory of rotation systems studied in topologi
cal graph theory [146]. We show that this approach can be adopted by all existing
representations and data structures for verication of 2manifold validity of mesh
structures.
Let G be a mesh on a 2manifold S. First note that since the mesh is cellular,
each connected component of the graph G corresponds to a unique surface in S
[10]. Since each point on S has a neighborhood homeomorphic to an open disk, if
one stands at a vertex v on S, then he can see in a small neighborhood of v on S
that the edges from v are cyclically ordered. Thus, two consecutive edges from v
form a face corner for a face of the mesh. This induces two important concepts: (1)
each edge incident on v is given a direction starting from v (note that a selfloop
at v then induces two directed edges of opposite directions from v); and (2) these
directed edges from v form a natural rotation. If v is an isolated vertex without
any incident edges, then since the mesh G is cellular, the surface containing v must
be a genus 0 sphere S
2
. Note that S
2
v is homeomorphic to an open disk
whose boundary degenerates into a single point v, i.e., v is a valid cellular mesh
on the sphere S
2
. The sphere S
2
will be called a pointsphere containing the vertex
v. Since the isolated vertex v has no incident edges, we dene that v has a empty
rotation that is an empty list of directed edges.
Thus, the mesh G on the 2manifold S induces a rotation system on the cor
responding graph G, in which each vertex is given a unique rotation of directed
edges. Based on this observation, we introduce the following important concept.
Denition Let G be a graph of n vertices. Each edge in G induces two directed
edges of opposite directions. A rotation at a vertex v of G is a cyclic ordering of
the directed edges from v (an isolated vertex without incident edges always has the
empty rotation). A rotation system of the graph G consists of a set of n rotations,
each for a vertex in G.
Remark 1. The above denition is an extension of the same concept dened
on graphs without isolated vertices. The original concept of graph rotation systems
on graphs without isolated vertices has been extensively used in topological graph
theory [146]. We will see that the extension of graph rotation systems to including
isolated vertices without incident edges is fundamentally important in the study of
2manifold mesh modeling.
Subroutine FaceTrace(u
0
, w
0
) {* u
0
, w
0
is a directed edge *}
1. trace u
0
, w
0
;
2. let u, w be the directed edge next to w
0
, u
0
in the rotation at w
0
, where u = w
0
;
3. while (u, w = u
0
, w
0
) do
let w, x be the directed edge next to w, u in the rotation at w;
trace u, w; u, w = w, x.
Algorithm Facing ((G)) {* (G) is a graph rotation system *}
1. for each isolated vertex v without incident edges in G do
construct a face with a degenerated boundary v;
2. while there is a directed edge u
0
, w
0
not traced yet do FaceTrace(u
0
, w
0
).
Figure 19.4: Face reconstruction based on graph rotation systems
Remark 2. Note that in the denition of graph rotation systems, the graph
G is not necessarily connected. Moreover, multiple edges and selfloops are also
allowed. Of course, in case of multiple edges, the edges with the same ends must be
distinguishable, and in case of selfloops, the two directions of the selfloop must
be specied.
Remark 3. If the two endvertices u and w of an edge [u, w] are different, then
the induced directed edges can be simply given by u, w) and w, u). We will put
a above a symbol such as e to refer to a directed edge. For a directed edge
e, we also denote by r( e) the corresponding reversed directed edge. Therefore, if
e = u, w), then r( e) = w, u).
For graphs without isolated vertices, it has been proved [7] that a graph rotation
system uniquely determines an embedding of the graph on a 2manifold. We extend
this important result to include the cases of isolated vertices. Moreover, our proofs
are more constructive and more algorithmic, which clearly illustrate how this new
structure is used in 2manifold modeling. We state the main result here without
proof and refer interested readers to [5] for the formal and detailed discussions on
these theoretical results.
Theorem 19.3.1 A mesh structure denes a valid 2manifold if and only if it uniquely
species a graph rotation system (G), whose face set is constructed by the algo
rithm Facing((G)) given in Figure 19.4.
19.4 Conclusions and nal remarks
In this paper, we have investigated some fundamental issues, including representa
tions, data structures, and operators, for 2manifold mesh modeling. We extended
the theory of graph rotation systems and showed that the extended theory provides
a solid foundation for 2manifold mesh modeling. Based on this fundamental re
sult, we examined existing data structures and proposed a new data structure for
2manifold mesh modeling. These data structures are either vertexbased, edge
based, or facebased. We developed simple and efcient algorithms for testing the
topological validity of meshes on these data structures. We also proposed a new set
of operators on 2manifold mesh modeling and proved that all and only 2manifold
mesh structures can be constructed by sequences of these operators. Efcient im
plementations of our operators on vertexbased, edgebased, and facebased data
structures were presented. Advantages of our operator set over the operator sets
previously proposed in the literature were indicated. To close the paper, we offer
some further remarks.
Our fundamental theorem was proved for meshes in which multiple edges and
selfloops are allowed. For simplicity, most our algorithms were presented only for
meshes without multiple edges and selfloops. It is very straightforward to extend
our algorithms to mesh structures with multiple edges and selfloops. In fact, in
a mesh with no multiple edges and selfloops, a directed edge is given as u, w),
where u and w are the two endvertices of the edge. When multiple edges and self
loops are allowed, then we only need to give each edge two distinguishable directed
edges. With this modication, all algorithms can be translated to work on meshes
with multiple edges and selfloops.
In some applications, it is also desired that the dual mesh is given in a data
structure for a mesh structure [10]. Briey speaking, each face in the original mesh
corresponds to a vertex in the dual mesh and each vertex in the original mesh corre
sponds to a face in the dual mesh. Two vertices in the dual mesh are adjacent if and
only if the two corresponding faces in the original mesh share a common boundary
edge. Most importantly, traveling the boundary of a face in the original mesh corre
sponds to traveling the directed edges in the rotation at the corresponding vertex in
the dual mesh (and vice versa). Our fundamental Theorem 19.3.1 points out that in
fact, for most existing data structures for mesh modeling, the dual mesh structure is
already given, explicitly and implicitly. For example, in the vertexbased adjacency
list data structure for meshes, the rotation given in the linked list for each vertex
actually gives the boundary traveling of the corresponding face in the dual mesh,
while the rotation at each vertex of the dual mesh can be recovered by calling the
algorithm FaceTrace on the corresponding face in the original mesh. In the edge
based wingededge structure, we only need to reinterpret the components vstart,
vend, fcw and fccw, and exchange the vertex components and the face components.
Note that the components ncw, nccw, pcw, and pccw provide sufcient information
not only for the involved vertices but also for the involved faces. Finally, in the
facebased DLFL structure, each face node in the face list, which is a cyclically
linked list of boundary directed edges of the face, gives exactly the rotation at the
corresponding vertex in the dual mesh. Therefore, the facebased face list in the
DLFL structure for the original mesh in fact gives a vertexbased adjacency list for
the dual mesh. By Theorem 4.2.1, the dual mesh structure can be constructed based
on this list.
So far we have been focused on modeling orientable manifolds. Our research
can be extended to modeling orientable manifolds with boundaries and to model
ing nonorientable manifolds. First, as described in [181] (chapter 3), modeling
Subroutine InsertEdge([u, w], cor( e
1
, e
2
), cor( e
1
, e
2
))
1. make two directed edges e = u, w and r( e) = w, u of the edge e = [u, w];
2. if (the face corners cor( e
1
, e
2
) and cor( e
1
, e
2
) belong to the same face
f = (r( e
1
), e
2
,
d
1
, . . . ,
d
s
, r( e
1
), e
2
,
d
1
, . . . ,
d
t
))
then delete the face node f from the face list;
add two new face nodes to the face list:
f
= (r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
)) and f
= ( e, e
2
,
d
1
, . . . ,
d
t
, r( e
1
));
add an edge node [u, w] in the edge list and set its two pointers properly;
else {* the face corners cor( e
1
, e
2
) and cor( e
1
, e
2
) belong to the two different faces
f
1
= (r( e
1
), e
2
,
d
1
, . . . ,
d
s
) and f
2
= (r( e
1
), e
2
,
d
1
, . . . ,
d
t
) *}
delete the face nodes f
1
and f
2
from the face list;
add a new face node to the face list:
f = ( e, e
2
,
d
1
, . . . ,
d
t
, r( e
1
), r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
));
add an edge node [u, w] in the edge list and set its two pointers properly.
Subroutine DeleteEdge(e)
1. nd the two directed edges e and r( e) of the edge e in the face list;
2. if (the two directed edges e and r( e) belong to two different faces
f
= (r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
)) and f
= ( e, e
2
,
d
1
, . . . ,
d
t
, r( e
1
));
then delete the face nodes f
and f
1
), e
2
,
d
1
, . . . ,
d
s
, r( e
1
), e
2
,
d
1
, . . . ,
d
t
);
delete the edge node e from the edge list;
else {* the two directed edges e and r( e) belong to the same face
f = ( e, e
2
,
d
1
, . . . ,
d
t
, r( e
1
), r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
)). *};
delete the face node f from the face list;
add two new face nodes to the face list:
f
1
= (r( e
1
), e
2
,
d
1
, . . . ,
d
s
) and f
2
= (r( e
1
), e
2
,
d
1
, . . . ,
d
t
);
delete the edge node e in the edge list.
Figure 19.5: INSERTEDGE and DELETEEDGE on DLFL structure
2manifolds can be extended to handle 2manifolds with boundaries. For modeling
nonorientable manifolds, we point out that the edge algebra model and its com
pany quadedge data structure [10] can handle both orientable and nonorientable
surfaces. For our models, there is a simple extension based on graph rotation sys
tems to represent nonorientable surfaces. Roughly speaking, if we also label each
edge in a graph rotation system by a twisted/untwisted mark, then the extended
rotation system can be used to represent nonorientable manifolds. Following the
same manner, we can prove that this extension always represents valid (orientable
and nonorientable) 2manifold structures, that the existing data structures for ori
entable 2manifold mesh modeling can be augmented to deal with nonorientable
2manifold mesh modeling, and that slight modications on the operators in our op
erator set form a complete and sound operator set for orientable and nonorientable
mesh modeling. See [167] for some related theoretical results.
19.5 Proofs for Theorem 19.3.1 and Theorem 4.2.2
We rst show how to reconstruct faces on a given graph rotation system. Let (G)
be a rotation system of the graph G. The algorithm presented in Figure 19.4 is re
given in Figure 19.6, where tracing a directed edge is either to mark or to store
the directed edge, in its given direction.
Lemma A.1 The algorithm Facing traces each directed edge in (G) exactly once.
PROOF. First of all, each directed edge is traced at least once. This is because if
any directed edge e is not traced, then the main algorithm will call the subroutine
FaceTrace on e, which will trace the edge. Thus, it sufces to show that no directed
edge is traced more than once.
Consider the subroutine FaceTrace( e
0
), where e
0
= u
0
, w
0
). Let e = u, w) be
Subroutine FaceTrace(u
0
, w
0
) {* u
0
, w
0
is a directed edge *}
1. trace u
0
, w
0
;
2. let u, w be the directed edge next to w
0
, u
0
in the rotation at w
0
, where u = w
0
;
3. while (u, w = u
0
, w
0
) do
let w, x be the directed edge next to w, u in the rotation at w;
trace u, w; u, w = w, x.
Algorithm Facing ((G)) {* (G) is a graph rotation system *}
1. for each isolated vertex v without incident edges in G do
construct a face with a degenerated boundary v;
2. while there is a directed edge u
0
, w
0
not traced yet do FaceTrace(u
0
, w
0
).
Figure 19.6: Face reconstruction based on graph rotation systems
a directed edge and let e
) = x, u).
Now assume that some of the directed edges in (G) are traced more than once
by the algorithm Facing. Suppose that e is the directed edge that receives the ear
liest second time trace. First note that the second time trace on the directed edge e
cannot be the rst edge trace of a subroutine execution FaceTrace( e
0
): in this case
e would be e
0
and the second time trace on e is the rst edge trace of FaceTrace( e
0
),
but when FaceTrace( e
0
) is called, the directed edge e
0
should have not been traced
at all.
Suppose that the directed edge e receives the rst time trace in FaceTrace( e
1
),
and receives the second time trace in FaceTrace( e
2
). Let e = u, w), and let e
=
u, x) be the directed edge right before e in the rotation at the vertex u. We consider
two cases.
If e
1
,= e
2
, then by the above remarks, the directed edge r( e
) = x, u) also
receives a trace in FaceTrace( e
1
). Now since the second time trace on e cannot be
the rst edge trace in FaceTrace( e
2
), the second time trace on e in FaceTrace( e
2
)
must follow a trace on the directed edge r( e
) would
receive the second time trace earlier than e.
If e
1
= e
2
, then the directed edge e cannot be e
1
since the subroutine FaceTrace( e
1
)
stops immediately when the edge e
1
is encountered the second time. Thus, the rst
time trace and the second time trace on the directed edge e must both follow traces
on the directed edge r( e
)
would receive the second time trace before the second time trace on the directed
edge e.
Thus, in any case, we would derive that the directed edge r( e
) would receive
the second time trace before the second time trace on the directed edge e. This
contradicts the assumption that the directed edge e receives the earliest second time
trace, thus showing that no edge should receive a second time trace. The lemma is
proved.
By Lemma A.1, each subroutine execution FaceTrac( e
0
) produces a sequence
of directed edges that line up head to tail and form a polygonal closed walk. One
thing we should show is that this construction is robust, i.e., the order in which
the main algorithm Facing picks untraced edges should not affect the output of the
algorithm.
Lemma A.2 On a directed edge e
1
, the subroutine FaceTrace( e
1
) produces a se
quence S of directed edges that form a polygonal closed walk. Moreover, for any
directed edge e
2
in the sequence S, the subroutine FaceTrace( e
2
) on e
2
will produce
the same polygonal closed walk.
PROOF. By the algorithm, if a directed edge u, w) is traced in FaceTrace, then
the next edge in the closed walk is uniquely determined, which must be the directed
edge right after w, u) in the rotation at the vertex w. Moreover, the rst edge
u, w) traced by FaceTrace must be the directed edge right after the last directed
edge traced by FaceTrace in the rotation at vertex u. Therefore, regardless of the
starting directed edge in the closed walk, the same polygonal closed walk will be
produced.
Therefore, for a given graph rotation system (G), the algorithm Facing will
produce a unique set of pointspheres, each for an isolated vertex in G, and a unique
set of polygonal closed walks. We will regard each of the polygonal closed walks as
the boundary of a face. According to Lemma A.1 and Lemma A.2, the set of faces
constructed this way is uniquely determined. Thus, the graph rotation system (G)
plus the algorithm Facing species a unique mesh structure by giving the vertex set
(that is the vertex set of the graph G), the edge set (that is the edge set of the graph
G), and the face set (that is given by the algorithm Facing). We show below that the
mesh structure constructed by this process is cellular and gives a unique and valid
2manifold structure. For this purpose, we need to rst discuss two operations on
graph rotation systems.
Let v be a vertex in the graph G. For any two consecutive directed edges e
1
=
v, u) and e
2
= v, w) in the rotation at v, the two directed edges r( e
1
) and e
2
are
consecutive on the boundary of a face f constructed by the algorithm Facing. we
say that the directed edges e
1
and e
2
form a face corner (of the face f) at v, written
either as cor( e
1
, e
2
) or cor(u, v, w). In case v is an isolated vertex without incident
edges, we dene that v has a unique face corner cor(v). Note that the two directed
edges may belong to the same edge (e.g., both of them are from the same selfloop).
In an extreme case, the two directed edges e
1
and e
2
can even be the same directed
edge (i.e., when the vertex v is of valence 1).
Let (G) be a rotation system of a graph G, and let e = [u, w] be an edge in
G. By deleting the edge from (G), we obtain naturally a rotation system for the
graph G e. More formally, let e
= u, w) and e
1
e
2
e
n
and w : e
1
e
2
e
m
where e
i
and e
j
are directed edges. Then the resulting rotation system after deleting
e from (G) has the identical rotation at each vertex x ,= u, w, and at u and w, the
rotations are
u : e
1
e
2
e
n
and w : e
1
e
2
e
m
Conversely, suppose in the rotation system (G), the directed edges e
1
and e
2
form a face corner at a vertex u, and the directed edges e
1
and e
2
form a face corner
at a vertex w, then we can insert a new edge e = [u, w] between the face corners
cor( e
1
, e
2
) and cor( e
1
, e
2
) in the rotation system (G) to make a rotation system
for the graph G + e. More formally, suppose that in the rotation system (G), the
rotations at the vertices u and w are
u : e
1
e
2
e
n
and w : e
1
e
2
e
m
respectively. After inserting the edge e between the face corners cor( e
1
, e
2
) and
cor( e
1
, e
2
), we obtain a rotation system (G + e) for the graph G + e that has the
identical rotation at each vertex x ,= u, w, and at the vertices u and w, the rotations
are
u : e
1
e
2
e
n
and w : e
1
e
2
e
m
where e
= u, w) and e
1
, e
2
) and
the directed edge e
1
, e
2
)).
Lemma A.3 A graph rotation system (G) plus the face set constructed by the
algorithm Facing on (G) gives a cellular mesh structure on a unique and valid
2manifold.
PROOF. We prove the lemma by induction on the number of edges in the graph
G. Suppose the graph G has n vertices.
If the graph G has no edges, then all vertices of G are isolated. Thus, the algo
rithm Facing uniquely produces n pointspheres, which form a valid 2manifold on
which (G) gives a valid cellular mesh structure.
Now assume that the graph G has m > 0 edges. Let e = [u, w] be an edge in
G (u and w may belong to the same vertex if e is a selfloop). Suppose that in the
rotation system (G), the rotations at the vertices u and w are:
u : e
1
e e
2
e
n
and w : e
1
r( e) e
2
e
m
where e = u, w) and r( e) = w, u) are the two directed edges of the edge e.
By deleting the edge e = [u, w] in the rotation system (G), we obtain a rotation
system (Ge) for the graph Ge of m1 edges. In particular, the rotations at
the vertices u and w in the rotation system (Ge) become
u : e
1
e
2
e
n
and w : e
1
e
2
e
m
(it is possible that one or both of the rotations become an empty rotation now).
By the inductive hypothesis, the rotation system (G e) plus the algorithm
Facing uniquely gives a valid 2manifold structure S
. Let F
1
, e
2
)
and let f
2
F
1
, e
2
). By inserting the
edge e = [u, w] between the face corners cor( e
1
, e
2
) and cor( e
1
, e
2
) in (Ge), we
get back the rotation system(G). We show that (G) also gives a valid 2manifold
structure.
Apply the algorithm Facing on the rotation system (G). Note that since the
only difference between (G e) and (G) is at the face corners cor( e
1
, e
2
) and
cor( e
1
, e
2
), the algorithm Facing on (G) will produce all faces in F
f
1
, f
2
.
Since the set of faces produced by Facing is independent of the order of the edges,
we can assume that the algorithm Facing on (G) rst constructs all faces in F
f
1
, f
2
. Note that after the construction of these faces, the only directed edges that
have not been traced are those on the boundaries of the faces f
1
and f
2
, and the two
directed edges e and r( e) induced by the edge e = [u, w]. There are two possible
cases.
Case 1. The two face corners cor( e
1
, e
2
) and cor( e
1
, e
2
) belong to the same
face in (Ge), that is f
1
= f
2
. Let the boundary of the face f
1
= f
2
be
f
1
= f
2
= (r( e
1
), e
2
,
d
1
, . . . ,
d
s
, r( e
1
), e
2
,
d
1
, . . . ,
d
t
)
where
d
i
and
d
j
are directed edges. Since the rotations at any vertex x ,= u, w are
identical in the rotation systems (Ge) and (G), and the rotations at u and w in
(G) are
u : e
1
e e
2
e
n
and w : e
1
r( e) e
2
e
m
,
the procedure FaceTrace(r( e)) on the rotation system (G) will produce the face
f
= (r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
))
and the procedure FaceTrace( e) on (G) produces the face
f
= ( e, e
2
,
d
1
, . . . ,
d
t
, r( e
1
))
(see the left gure in Figure 19.7 for illustration). Therefore, the difference of the
u
e
2
\
\

*
s
..
r( e
1
)
w
2
\
\t

r
t
. .r( e
1
)
e
_
e
2
\
\

*
s
..
r( e
1
)
'
e
2
\
\t

r
t
. .r( e
1
) '
r( e)
u

r
s
. .r( e
1
)
e
2
\
\
1

*
t
..
r( e
1
)
w
2
\
\t
1
e
_

r
s
. .r( e
1
)
e
2
\
\
1

*
t
..
r( e
1
)
'
r( e)
2
\
\t
1
'
e
Figure 19.7: Left: inserting an edge between two corners of the same face; Right:
inserting an edge to face corners of two different faces
two meshes (G) and (G e) is that the face f
1
= f
2
in (G e) is replaced by
the faces f
and f
and f
along the
edge e. Therefore, adding the face f
1
= f
2
to the mesh and adding the two faces f
and f
to the mesh should give the same structure. Since the mesh constructed from
(Ge) represents the valid 2manifold S
1
, e
2
) and cor( e
1
, e
2
) belong to two different
faces f
1
and f
2
, f
1
,= f
2
, in (Ge). Let the boundaries of the two faces f
1
and f
2
be
f
1
= (r( e
1
), e
2
,
d
1
, . . . ,
d
s
) and f
2
= (r( e
1
), e
2
,
d
1
, . . . ,
d
t
)
Again since the rotation system (G) is obtained from the rotation system (Ge)
by inserting the edge e between the two face corners cor( e
1
, e
2
) and cor( e
1
, e
2
),
when the procedure FaceTrace( e
2
,
d
1
, . . . ,
d
t
, r( e
1
), r( e), e
2
,
d
1
, . . . ,
d
s
, r( e
1
))
_
e
2_
1
_
s_
r( e
1
)
'
e
_
e
2
_
1
_
t
_
r( e
1
)
'
r( e)
_
e
2
`
1
z
r( e
1
)
r( e
1
)
Figure 19.8: Pasting the two directed edges of an edge to get a cylinder
(see the right gure in Figure 19.7 for illustration.) Note that the boundary of the
face f has contained all directed edges on the boundaries of the faces f
1
and f
2
, plus
the two directed edges of the edge e. Therefore, the difference between the mesh
(G) and the mesh (Ge) is that the faces f
1
and f
2
in (Ge) are replaced by the
face f in (G). Now if we past along the edge e in the face f, we will get a cylinder
Y with two open ends. (See Figure 19.8 in which we have redrawn the face f then
pasted along the two directed edges e and r( e).) Observe that if we traverse the two
open ends of the cylinder Y , we get exactly the boundary traversings of the faces f
1
and f
2
in (G e). Therefore, the structure represented by the mesh (G) can be
obtained from the 2manifold S
ANTYL
ANTYL
ANTYL
ANTYL
ANTYL