Ergun Akleman - Topological Mesh Modeling

Contents
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 Genus-1 Meshes . . . . . . . . . . . . . . . . . . . 19
2.2.4 Regular Genus-larger-than-1 Meshes . . . . . . . . . . . . 20
2.2.5 When Genus goes to Innity . . . . . . . . . . . . . . . . . 21
2.3 Topologically Semi-Regular 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 Vertex-based data structures . . . . . . . . . . . . . . . . . 41
4.2.2 Edge-based data structures . . . . . . . . . . . . . . . . . . 42
4.2.3 Face-based 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 vertex-based data structures . . . . . . . . . . . 59
6.2 Implementation on edge-based data structures . . . . . . . . . . . . 60
6.3 Implementation on face-based data structures . . . . . . . . . . . . 64
7 Create Pipe and Cut Operators 67
7.1 Sequence of Minimal Operators . . . . . . . . . . . . . . . . . . . 69
8 Non-Intuitive Nature of Topology Changes 71
9 Non-Manifold 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 Non-Manifold 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
11 Corner Cutting Schemes 111
11.1 Introduction and Motivations . . . . . . . . . . . . . . . . . . . . . 112
11.2 Topological Operations and Handle-Faces . . . . . . . . . . . . . . 114
11.3 Handle-Face Reconstruction with Subdivision . . . . . . . . . . . . 117
11.4 Corner Cutting Schemes . . . . . . . . . . . . . . . . . . . . . . . 118
11.4.1 Doo-Sabin 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
13 Extrusions & Stellations 153
13.2 Methodology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
14 Interactive High-Genus Modeling 159
14.1 Multi-Segment Curved Handles . . . . . . . . . . . . . . . . . . . 159
14.3 Minimal Operators . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.4 Creating Multi-Segment 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 High-Genus 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.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
titanium-clad 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
under-appreciated advantages over other modeling approaches. If the polygons are
not triangles or quadrilaterals, the faces are not geometrically well-dened. With
geometrically ill-dened faces, self-intersection becomes meaningless. So, any
commercial system that allows general polygons does not check self-intersection
and avoids the cost of self-intersection computation which can considerably slow
down the application during interactive modeling.
The omission of automatic self-intersection avoidance is typically not of con-
cern to most users, since they can easily avoid self-intersection 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 non-manifold 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 non-manifolds and allowing all possible manifold meshes can greatly
simplify the algorithms and help develop newtools for interactive modeling. Avoid-
ance of non-manifolds 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 edge-based data structures such as half-edge, quad-edge and
winged-edge [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 real-time interaction. Since
we largely ignore the geometry of the shapes, we do not have to deal with hard
problems such as self-interactions or set operations. Moreover, we can represent
non-manifold 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 hand-sewn 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 1-dimensional entities that represent the
boundaries between pairs of faces. Vertices, on the other hand, are 0-dimensional
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 hand-sewn dodecahedral-ball 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 2-manifold S species an embedding (G) of a graph G
on the 2-manifold 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 self-loops (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. Non-cellular 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.
Point-Sphere Self-Loop Line-Manifold Triangle-Manifold
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 Euler-Poincare equation, without using
geometric properties, we can identify some essential properties of manifold meshes.
Euler-Poincare 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 genus-0 surfaces where
g = 0.
As an example of genus-0 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 edge-ends that emanates
from that vertex. For instance, the vertex of a point-sphere 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 self-loop in Figure 2.3 has valence 2, since two edge-ends 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
line-manifold in Figure 2.3 is a two-gon in which the edge counted twice since both
sides of the edge belong to the same face.
Point-sphere 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, line-manifold is (2, 1), self-loop, which is the dual of line-manifold is
(1, 2) and triangle-manifold is (3, 2).
It is possible to systematically search for regular meshes using Euler-Poincare
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 Euler-Poincare equation, we obtain a simpli-
ed equation
1
n
+
1
m

1
2
e = 1 g. (2.4)
For genus-0 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 genus-0 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 two-sided (manifold) polygons. Some examples of manifold polygons
are shown in Figure 2.4
2.2.2 Regular Platonic Meshes
Regular genus-0 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)
Two-gon Triangle Quadrilateral Pentagon
Figure 2.4: Polygon-manifolds.
(3, 3) (3, 4) (3, 5) (4, 3) (5, 3)
Tetrahedron Octahedron Icosahedron Cube Dodecahedron
Figure 2.5: Regular genus-0 meshes with both n and m larger than 2.
2.2.3 Regular Genus-1 Meshes
For g = 1 the Euler-Poincare 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 genus-1 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) genus-1 mesh
shown in Figure ??(A).
(A) (B) (C)
2.2.4 Regular Genus-larger-than-1 Meshes
e =
2nm
nm2n 2m
(g 1) (2.7)
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 genus-2 (4, 6) regular mesh.
2.3 Topologically Semi-Regular Surfaces
2.4 Curious Cases
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 2-manifold shape [169]. It always guaran-
tees the representation of valid 2-manifold 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 2-manifold 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 2-manifold 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
edge-ends 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 edge-orbit 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 r-sided polygon
can be tted into it. Fitting a polygon to every such edge-orbit results in polygons
on both sides of each edge, and collectively the polygons form a 2-manifold.
Edmonds [169] has shown that every rotation system of a graph gives a unique
orientable 2-manifold. Moreover, the corresponding orientable 2-manifold is con-
structible, as we described above. For any 2-manifold 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 2-manifolds and graph rotation systems enables us to represent
topological objects by combinatorial ones. In particular, every 2-manifold can be
represented by a rotation system of a graph, and every rotation system of a graph
corresponds to a valid 2-manifold. 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 2-manifold [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 2-manifold 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 counter-clockwise order. These are
two different rotation systems for the same graph. When we consider the rotation
order they correspond to two different 2-manifold 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 face-corner 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 2-manifold 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
2-manifold 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 face-corners 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 face-corners 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 2-manifolds. 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 2-manifold shapes, after the insert
edge operation these two 2-manifold shapes become connected by the new inserted
edge. If the faces belong to the same 2-manifold, the edge insert operation increases
the genus of the 2-manifold 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 face-handle. It is
not easy to visualize this face-handle, 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 2-manifold, it becomes a hole. If the
handle goes outside of the 2-manifold, 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 face-handles.
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 face-handle, the new edge separates the face-handle 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 2-manifold 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 2-manifold mesh. The classical winged-edge data structure proposed
by Baumgart [3] for mesh representations was essentially developed based on this
observation.
Formally, the main component of a winged-edge 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 end-vertices 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 winged-edge structure
Thus, the winged-edge structure is edge-based, which describes the mesh struc-
ture in terms of the adjacency information on each edge of the mesh. An adaptation
of the winged-edge structure is the half-edge data structure [181], which is a hier-
archical data structure. The major difference between the half-edge data structure
and other structures is the introduction of the concept of half-edges
1
. A half-edge
describes one-side of an edge of the mesh, thus is uniquely associated with a face
of the mesh. A half-edge node consists of references to the face, to its starting ver-
tex, to the corresponding edge, and to the previous and the next half-edges of the
face. The half-edge data structure indicates very clearly a property of the mesh on
a 2-manifold 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 well-dened when
1
There are a number of variations and renamings for the concept of half-edges adopted in com-
mercial modeling systems, such as co-edges in ACIS (Spatial Technologies Inc.) [18] and n in
Parasolid (Unigraphics Solutions Inc.) [19].
traversing the edge along the given direction on the 2-manifold. Thus, each edge
has four different directed and oriented versions. Each directed and oriented edge
has four attributes: the two end-vertices Org and Dest (equivalent to vstart and vend
in the winged-edge structure), and the two faces Right and Left on the two sides of
the edge on the 2-manifold (equivalent to fcw and fccw in the winged-edge 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 winged-edge structure); and Rot rotates the edge (which is
a little more technical and we omit its detailed explanation). Both orientable and
non-orientable 2-manifolds 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 quad-edge structure, has been introduced to represent the edge algebra for
a mesh structure [10].
When concentrating on orientable 2-manifolds, as most modeling applications
do, the edge algebra and its corresponding quad-edge structure can be simplied.
Since all edges of a mesh on an orientable 2-manifold 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 quad-edge structure contains four pointers to
essentially the four edge nodes corresponding to the edge nodes ncw, pcw, pccw,
and nccw in the winged-edge structure.
For manifold preserving operations, M antyl a [181] proposed Euler operators,
and Guibas and Stol [10] dened the splice and create-edge 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 vertex-based descriptions of mesh structures. Theo-
rem 19.3.1 shows that a valid graph rotation system guarantees the validity of the
underlying 2-manifold 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
2-manifold 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 self-loops. 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 self-loops
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 2-manifold:
Validity Rules. A mesh structure gives a valid 2-manifold 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 2-manifold 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 1-dimensional cells (i.e., directed edges) while Hoffmanns rules are based on
2-dimensional 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 2-manifold 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 Vertex-based 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 self-loops, 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 2-manifold
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 Edge-based data structures
Most data structures in mesh modeling are edge-based. We will focus our discus-
sion on the well-known winged-edge structure, then extend our discussion to other
structures.
Recall that each edge node in a winged-edge 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 2-manifold, 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 winged-edge structure gives a
valid 2-manifold can be veried based on the components ncw and nccw.
Denote by A[e] the edge node for the edge e in the winged-edge 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 winged-edge structure can pass the test of the algorithm E-
Validity, then it represents a valid 2-manifold. Moreover, the test algorithm runs in
time O(m).
We give a brief explanation for the correctness of the algorithm E-Validity, 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 E-Validity (A[1..m]) {* A[1..m] is a winged-edge 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 winged-edge structure
marked in the main algorithm E-Validity 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 E-Validity verify that each edge in
the mesh induces exactly two directed edges.
Remark. Theorem 4.2.2 indicates that the original winged-edge structure pro-
posed by Baumgart [3], in which only the components name, vstart, vend, ncw, and
nccw are included, will be sufcient for modeling 2-manifold mesh structures.
As an example, we show how the algorithm E-Validity reports an error on
the winged-edge 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 algorithmE-Validity.
Then the main algorithm E-Validity 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 edge-based data structures.
In the half-edge structure [181], a half-edge corresponds uniquely to a directed
edge in our rotation system. Moreover, each half-edge has a unique reference to
the next half-edge 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 half-edge induces a valid rotation system. It is not difcult to verify
that testing the Validity Rules on a half-edge structure can be done in time O(m),
where m is the number of edges in the mesh.
In the quad-edge structure [10] for an edge algebra for an orientable 2-manifold,
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 quad-edge structure gives a valid graph rotation system thus represents
a valid 2-manifold structure. Again the Validity Rules on the quad-edge structure
can be tested in time O(m), where mis the number of edges. Note in particular that
our validity test on quad-edge structure does not need the information for the dual
mesh structure, which is also provided in the quad-edge 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 Face-based data structures
Face-based data structures have been regarded as the least reliable for modeling
2-manifold structures. In particular, a variety of non-manifold structures, such as
wrongly-oriented polygons, overlapping polygons, missing polygons, cracks, and
T-junctions, can be resulted from a face-based data structure [17].
We have recently re-investigated face-based data structures for mesh modeling
and proposed a new face-based 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 face-based 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 bi-directed 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 F-Validity (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 F-Validity,
which takes time O(m), then D represents a valid 2-manifold.
PROOF. Validity Rule 1 is tested by step 1 of the main algorithm F-Validity.
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 F-Validity 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 F-Validity, then it must
represent a valid graph rotation system. For the complexity of the algorithm, note
that the algorithmF-Validity marks each directed edge exactly once. Since the edge
node for an edge [v, w] has two bi-directed 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 F-Validity 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 half-edge structure, the quad-edge 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 winged-edge 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 winged-edge structure. In particular, since the
winged-edge structure does not explicitly give directed edges in its representation,
when a mesh under winged-edge 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 self-loops
are allowed in a mesh [20]. Therefore, for winged-edge structures, we suggest that
our algorithms be implemented on the modied winged-edge 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 allownon-cellular 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 user-interface. 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 2-manifold 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 2-manifold
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 2-manifold results in
a valid 2-manifold 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 2-manifold 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 2-manifold 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
user-friendly 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
)) and cor(v, y), v, y
)), we mean
inserting the directed edge u, v) in the rotation at u between the directed edges
u, x) and u, x
), and inserting the directed edge v, u) in the rotation at v between

the directed edges v, y) and v, y
). Note that if the two face corners belong to the

same face, then the new inserted edge splits the face into two faces On the other
hand, if the two face corners belong to different faces, then the new inserted edge
merges the two faces into a single face. The inverse of the INSERTEDGE operator
is the edge deletion operator, briey DELETEEDGE. Let (G) be a rotation system
and let e = [u, v] be an edge in G, by deleting the edge e, we mean deleting the
directed edge u, v) from the rotation at the vertex u and deleting the directed edge
v, u) from the rotation at the vertex v.
The other primary operator is vertex creation, briey CREATEVERTEX, which
creates a new vertex without edge in the rotation system. The inverse of CREATEV-
ERTEX is DELETEVERTEX, which removes a vertex without edge from the rotation
system.
Remark. Compared to the Euler operators studied in [181], CREATEVERTEX
and DELETEVERTEX are similar to the Euler operators MVFS and KVFS, and
INSERTEDGE and DELETEEDGE are similar to the Euler operators MEF and KEF,
and MEKR and KEMR (in some sense, also MFKRH and KFMRH). The other
Euler operators, such as MEV and KEV, have no correspondence in our proposed
set of operators (see [181] for more detailed explanations for Euler operators).
Theorem 5.1.1 The operator set consisting of the operators INSERTEDGE/DELETEEDGE
and CREATEVERTEX/DELETEVERTEX is complete and sound.
PROOF. The soundness of the operator set is obvious: applying each of the four
operators on a graph rotation system that represents a valid 2-manifold structure
results in a valid graph rotation system, which by Theorem 19.3.1 is a valid 2-
manifold structure.
The completeness can also be veried easily. Any cellular mesh structure in-
duces a unique rotation system (G). By a sequence of DELETEEDGE followed by
a sequence of DELETEVERTEX, we can obtain an empty rotation system. Reverse
this sequence of operators, and replace in the sequence each DELETEVERTEX by
a CREATEVERTEX and each DELETEEDGE by an INSERTEDGE. The resulting
sequence starting from an empty rotation system should re-construct the rotation
system (G). Therefore, any cellular mesh structure can be obtained by a sequence
of operators in the set.
Compared to the Euler operators proposed in [3, 181], our set consists of far
fewer operators. Compared with the operator set proposed by Guibas and Stol
[10], our set consists of the same number of operators but seems more intuitive (we
suggest that readers compare our INSERTEDGE/DELETEEDGE operators with the
SPLICE operator proposed in [10]). Moreover, our set of operators seems more uni-
form, from either the viewpoint of modeling systems or the viewpoint of users. A
modeling system using our operators only needs to deal with its internal represen-
tation on graph rotation systems, without any concern of the topological integrity
of the underlying mesh, while a user using our operators only needs to identify face
corners on the mesh structure, without any need of understanding its internal im-
plementation. Most previously proposed operator sets seem to have difculties to
completely avoid the interlacing between the system level and the user level, and
between the internal representations and the topological integrity.
5.2 Properties of Minimal Operators
As a result, we propose to use CREATEVERTEX, DELETEVERTEX, INSERTEDGE
and DELETEEDGE operators [162]. It has recently been proven that all and only
manifold meshes can be created by these four operators [166]. Moreover, this set
of operators is minimal and complete in the sense that it is necessary and sufcient
for performing any homeomorphic and topological operation on any orientable 2-
manifold meshes [166]. The properties of these operators can be summarized as
follows:
1. CREATEVERTEX(v) is similar to Euler operation MVFS. It creates a new
isolated vertex v and its corresponding face, which we simply call a point-
sphere. This operator is essential to add a new surface component in the
given 2-manifold and to create a surface in an empty manifold.
2. DELETEVERTEX(v) is similar to Euler operation KVFS. It deletes an iso-
lated vertex and its corresponding point-sphere from the current 2-manifold.
This operator is necessary to remove a surface component from the current
manifold.
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
consisting of two consecutive edges plus the vertex between them). If IN-
SERTEDGE Inserts an edge between two corners of the same face, the new
edge divides the face into two faces [156]. On the other hand, if INSERT-
EDGE inserts an edge between corners of two different faces, the new edge
merges the two faces into one [156, 157].
4. DELETEEDGE(e) deletes an edge e from the current 2-manifold mesh. This
is the inverse operator of INSERTEDGE. DELETEEDGE either merges two
faces into a bigger face or splits a face (which forms a pipe) into two faces. An
important function of the DELETEEDGE operator is to split a surface into two
surfaces: If the DELETEEDGE operator on an edge e = [v
1
, v
2
] completely
disconnects the vertices v
1
and v
2
so that there is no further path connecting
the vertices v
1
and v
2
in the mesh, then the surface that contains both vertices
v
1
and v
2
is actually split into two disjointed surfaces, one containing vertex
v
1
and the other containing vertex v
2
.
These four operators are necessary and sufcient to implement all homoemor-
phic and topological changes on a given 2-manifold mesh [166]. For consistent
topological change, it is important to apply only these operators. For instance,
in order to create a pipe there is no need to cut off along the boundaries of the
faces, which would result in a 2-manifold with boundary that will be topologically
inconsistent. INSERTEDGE operator implicitly make the change without creating
topological inconsistency.
5.3 Methodology
Topologically robust mesh modeling operators INSERTEDGE, DELETEEDGE, [156]
along with Euler operators CREATEVERTEX and REMOVEVERTEX have recently
been introduced as a minimal set of operators that can effectively change the topol-
ogy of a manifold mesh by inserting and deleting handles and can be efciently
implemented on almost every mesh data structure including winged-edge, [163],
half-edge [181] and quad-edge[178].
We rst give a short overview of these operators and then present our new algo-
rithm.
5.3.1 Background
Among the four operators, two are sufcient to construct our algorithm. These are
INSERTEDGE and CREATEVERTEX:
1. CREATEVERTEX(v) is similar to the Euler operator MVFS. It creates a new
isolated vertex v and its corresponding face; we call this a point-sphere (see
Figure 11.1.) This operator effectively adds a new surface component to the
current 2-manifold.
Figure 5.1: A point sphere is a manifold that consists of only one vertex and one
face without an edge.
The CREATEVERTEX operator is essential in the initial stage of manipulating
2-manifolds since it is needed to create and add a new surface component in
an empty manifold.
2. INSERTEDGE(c
1
, c
2
two corners c
1
and c
2
. Formally, a corner is a subsequence of a face boundary
walk consisting of two consecutive edges plus the vertex between themexcept
in the case of a point sphere, in which the vertex itself is the corner. If a face
has only one instance of each vertex, then we can consider a corner as a
face-vertex pair which is given as f
i
, v
j
. We can also consider a corner as a
subsequence of a face boundary walk consisting of three consecutive vertices.
For example if f = v
1
, v
2
, v
3
, v
4
is a face, v
1
, v
2
, v
3
is a corner referring
to the vertex v
2
in face f and v
3
, v
4
, v
1
is the corner referring to the vertex
v
4
in face f.
If INSERTEDGE inserts an edge between two corners of the same face, the
new edge divides the face into two faces. On the other hand, if INSERTEDGE
inserts an edge between corners of two different faces, the new edge merges
the two faces into one. See the gures in [156] for visual explanation.
When the operator INSERTEDGE is inserting an edge e between corners of
two different faces f
1
and f
2
, there is an interesting and intuitive interpretation
of the operation as two steps. In the rst step, we delete the faces f
1
and f
2
,
which results in a 2-manifold with boundaries because of two open holes
left by deleted faces f
1
and f
2
. In the second step we run a new pipe
between these two holes and allow the pipe ends to seal the two holes.
Note that the choice of corners is extremely important for the INSERTEDGE
operation. An edge inserted between two vertices may combine two faces
into one or separate one face into two depending on the choice of corners.
Figures 5.2, 5.3 and 5.4 show how a tetrahedron can be constructed by a series
of CREATEVERTEX and INSERTEDGE operations. The following section presents
an algorithm that uses only the above mentioned operators to construct a 2-manifold
mesh from a list of vertex positions and a list of oriented polygons given as a se-
quence of vertex indices.
Figure 5.2: A line manifold can be obtained by combining two point spheres with
an insert edge operation. Note that the insert edge operation combines the two
initial faces f
0
and f
1
and the result has only one face.
Figure 5.3: A triangle manifold (two-sided triangle) can be obtained by combining
three point spheres with three insert edge operations. A face manifold (two sided
face) can be obtained by combining n number of point spheres with n number of
inserted edges.
Figure 5.4: A tetrahedron can be obtained by combining four point spheres with six
insert edge operations.
Chapter 6
Efcient Implementation of Minimal
Operators
6.1 Implementation on vertex-based data structures
The implementation of the operators INSERTEDGE, DELETEEDGE, CREATEVER-
TEX, and DELETEVERTEX on an adjacency list structure is fairly simple. For IN-
SERTEDGE to insert an edge [u, w] between face corners cor(u, x), 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 time-consuming 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 edge-based data structures
Again we discuss the implementation on the winged-edge structure, and describe
briey its extension to other structures such as half-edge structure and quad-edge
structure.
In order to implement the CREATEVERTEX and DELETEVERTEX operators, we
need to introduce a supplementary vertex list in the winged-edge structure (actually,
such a supplementary vertex list is always needed in an edge-based 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
winged-edge 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
) to undate the face components fcw and fccw;

6. if (the directed edge w, y
is not traced in step 5)

then call FaceTrace(w, y
) to update the components fcw and fccw.

Figure 6.1: INSERTEDGE and DELETEEDGE on winged-edge structure
give the next and previous directed edges to the directed edge vstart, vend),
respectively, while the components ncw and pccw give the next and previous
directed edges to the directed edge vend, vstart), respectively. Finally, the compo-
nents fcw and fccw give the right face and left face while traveling from vertex
vstart to vertex vend along the edge.
Implementations of the operators INSERTEDGE and DELETEEDGE on a winged-
edge structure are given in Figure 10.3. By the denitions of the components ncw,
pcw, nccw, and pccw (see Figure 17.4), it is easy to verify that the operator INSERT-
EDGE inserts the directed edge u, w) to the face corner c
1
= cor(u, x), 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 winged-edge structure are sufcient for representing a 2-manifold mesh
structure. In particular, a winged-edge structure without the components fcw and
fccw is sufcient for describing a 2-manifold mesh structure. Moreover, on a
winged-edge 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 winged-edge 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 winged-edge 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 winged-edge structure can be easily extended to other edge-based
data structures, such as the half-edge structure and the quad-edge structure, since
these data structures have components that are similar to the components ncw, nccw,
pcw, pccw, fcw, and fccw in the winged-edge 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 end-vertices 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 face-based 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 winged-edge structure
or its variations can become time consuming when the involved faces have large
size. Removing the components fcw and fccw from the winged-edge 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 2-manifold 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 2-manifold 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
Non-Intuitive 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 non-intuitive. 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 genus-0 surfaces creating one genus-0 surface by simplifying
the topology. On the other hand, the same CREATEPIPE operation in
8.1(B) changes a genus-0 surface into a genus-1 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 genus-0
71
Figure 8.1: The CREATEPIPE operation can both simplify and complicate the topol-
ogy.
surfaces from one genus-0 surface by complicating the topology. On
the other hand, the same CUT operation in 8.2(B) changes a genus-1
surface into a genus-0 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 2-manifold mesh to a genus-0
surface.
Topology changes are not intuitive and therefore a great deal of care is neces-
sary for handling topological simplication. We illustrate non-intuitive nature of
topology changes with several examples.
Figure 8.4: The CUT operation can delete either a handle or a hole.
Chapter 9
Non-Manifold Looking Manifold
Meshes
This chapter presents a simple algorithm to construct 2-manifold meshes from ar-
bitrary collections of polygons. We form our nal data structure using two very
basic manifold-preserving 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 non-manifold 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 non-manifolds. To create a wide va-
riety of manifold interpretations we intentionally introduce artifacts into a data set
such as wrongly-oriented polygons or non-manifold 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 2-manifolds 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 Doo-Sabin subdivision
[168, 186] is applied to a non-manifold mesh since Doo-Sabin 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 (two-sided 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, non-manifold input, wrongly-oriented faces, or non-planar
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 non-standard data (such as a wrongly-oriented face or non-manifold 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 non-manifolds. Given input that corresponds
to a non-manifold (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 non-manifold 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 2-manifold interpretions of a non-manifold.
By intentionally introducing artifacts into a data set such as wrongly-oriented
polygons or non-manifold 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 non-manifold 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 point-sphere for each vertex using the
CREATEVERTEX operator. Let 1 be the array of point-spheres 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 self-loop 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 point-spheres 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 2-manifold 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 non-manifolds 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 Non-Manifold Conversion and Insight to Manifolds
The interpretation of non-manifold cases are more interesting. Using the reader,
we can convert non-manifolds 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 non-manifold 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 non-manifold shape. The
middle column shows some manifold interpretations of the non-manifold shape.
The rightmost column shows the result of two iterations of Doo-Sabin subdivi-
sion applied to the manifold representations in the middle column. The Doo-Sabin
smoothed versions are included (1) to demonstrate that non-manifold geometry
has been converted to manifold, since Doo-Sabin 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
Doo-Sabin 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 2-manifold interpretations of a non-manifold.
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 wrongly-oriented faces. As in the case of non-manifold 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, non-manifolds, and artifacts are very common in com-
puter graphics les. Many modeling packages allow manifolds with boundaries
and non-manifolds. Also, many practical mesh data structures allow arbitrary col-
lections of polygons that can include artifacts such as wrongly-oriented polygons
and T-junctions.
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 2-manifold mesh.
Ignoring twogons and self-loops 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 valence-2 or valence-1 vertices, the dual cannot correctly
be created since it should have twogons and self-loops. Thus, in order to use the
algorithm to simplify programming tasks, we would need to include twogons and
self-loops.
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 2-manifold interpretations of a non-manifold. Note that in this
case the topological representations are the same for all three cases.
Figure 9.4: Two 2-manifold interpretations for a non-manifold.
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 2-manifold 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, B-splines 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 2-manifold (or 2-manifold 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 Doo-Sabin surface [168] is a generalization of quadric B-splines and
the Catmull-Clark surface is a generalization of cubic B-splines [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 non-implicit 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 2-manifolds. 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 2-manifold polygonal meshes, but also useful for chang-
ing the topology of a 2-manifold 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 2-manifold shape [169]. It always guarantees the rep-
resentation of valid 2-manifold 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 2-manifold 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 2-manifold 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 2-manifold.
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 2-manifolds.
Unfortunately, set operations, which are the most commonly used operations in
mesh modeling, can result in non-manifold surfaces. Moreover, the existing data
structures in mesh modeling are specically developed in such a way that they can
represent non-manifold surfaces resulting from the set operations. In particular,
they do not guarantee valid 2-manifold surfaces. Because of this fundamental prob-
lem, in the process of obtaining the initial control mesh, unwanted artifacts can
be generated. These artifacts include wrongly-oriented polygons, intersecting or
overlapping polygons, missing polygons, cracks, and T-junctions. 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 vertex-edge 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 vertex-polygon list. Vertex-polygon 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 vertex-polygon lists [120]. In a vertex-polygon-edge
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,
vertex-polygon-edge lists are more powerful than vertex-polygon lists. However,
the representation does not guarantee valid manifold surfaces either. It is still pos-
sible to specify a non-manifold surface in terms of the vertex-polygon-edge list.
One of the oldest formalized data structures that supports manifold surfaces is
the winged-edge representation [163]. Baumgart also suggested using a winged-
edge structure and Euler operators in order to obtain coordinate free operations
[60]. Winged-edge data structures support 2-manifold surfaces, and starting from a
valid 2-manifold mesh, winged-edge can only create valid 2-manifolds with Euler
operators. However, like vertex-polygon-edge lists winged-edge structures can also
accept non-manifold surfaces [163, 94]. To represent Voronoi diagrams and De-
launey triangulation, Guibas and Stol introduced the quad-edge data structure and
two topological operators, make-edge and splice [178]. Like winged-edge structure,
quad-edge structure creates valid 2-manifolds with make-edge and splice operations
if it starts from a valid 2-manifold. Unfortunately, quad-edge data structures can
still support non-manifold surfaces.
When using set operations, resulting solids can have non-manifold boundaries
[180, 79]. It is worthwhile to note that although the data structures, such as winged-
edge, can handle some non-manifold 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 non-manifold surfaces have been later
investigated. Examples of such work are Weilers radial-edge structure [96], Kara-
sicks star-edge structure [85], and Vaneceks edge-based data structure [93].
In the current paper, we propose to return back to the basic concept of coordinate
free operations over 2-manifold surfaces by ignoring set-operations. Similar to our
approach, instead of set operations the usage of Morse operators that describe the
changes of cross-sectional 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 2-manifolds, but also always
guarantees topological consistency, i.e. it always gives a valid 2-manifold.
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 2-manifolds. 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 doubly-linked-face-list (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 2-manifolds 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 Catmull-Clark 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
non-manifold. They are actually 3D representations of a rotation system
which is a representation of a 2-manifold. 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 non-manifold.
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 self-intersected.
Thus, the users can easily avoid such self-intersections 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.
In this paper, we presented a new paradigm for changing topology of 2-manifold
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 2-manifold polyg-
onal meshes, as well as for changing the topology of 2-manifold polygonal meshes
that are smoothed by Catmull-Clark subdivision operations. Note that smoothing
operations provided by subdivision approach are essential for improving the qual-
ity of 2-manifolds. 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 vertex-split and edge-collapse. 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 2-manifold 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 handle-faces. 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 well-known Catmull-Clark 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 2-manifold 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 user-friendly modeling of any orientable
2-manifold mesh. In other words, these four operations constitute a necessary and
sufcient minimal-set 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 2-manifolds.
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 handle-face cannot
be effectively rendered with current graphics hardware. In order to see the actual
structure of this handle-faces, we need to reconstruct them.
In most cases, these handle-faces 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 handle-faces. In fact, we have recently shown that Catmull-Clark subdivision
algorithm [165] over the DLFL structure [133] can effectively be used to recon-
struct these handle-faces. Reconstruction with Catmull-Clark subdivision greatly
improves the quality of handle-faces. 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 handle-face 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 Doo-Sabin 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 2-manifold 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 well-known Catmull-
Clark algorithm which is also implemented on the DLFL structure, and show that
the new corner cutting and Doo-Sabin algorithms give a better quality handle-face
reconstruction.
11.2 Topological Operations and Handle-Faces
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 2-manifolds [?]. 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 2-manifold 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 2-manifold.
Figure 11.1: A point-sphere 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 2-manifold. This operation is the
same as the Euler operation KV FS [147].
3. INSERTEDGE(c
1
, c
2
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 face-vertex 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 2-manifold 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 2-manifold meshes. The CREATEVERTEX operation is es-
sential in the initial stage of manipulating 2-manifolds and creates a new surface
component in the given 2-manifold. 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 2-manifold.
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
point-spheres), the new edge merges the two faces into one and changes the topol-
ogy of the 2-manifold. 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
handle-faces.
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 multiple-step 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 handle-face (which forms a pipe) into two faces. When DELETEEDGE
splits a handle-face into two faces (as shown in Figure 19.8), the situation can be
described by a 2-step 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 2-manifold, which is the only, thus also necessary operation
among the four that decreases the genus of a 2-manifold.
One important challenge is to efciently visualize the handle-faces 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 Handle-Face 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 handle-faces, triangular or interpolating schemes are not appropri-
ate choices. This observation limited our choices to approximating and quadrilat-
eral schemes. Earlier we have implemented Catmull-Clark subdivision algorithm
[165] on the DLFL structure [133] (Catmull-Clark 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
handle-face 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 handle-faces.
Inserting new edges to a handle-face 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 handle-face, 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 handle-faces can
be improved by using corner cutting schemes. Corner cutting schemes do not create
additional extraordinary vertices. Under a corner cutting scheme, the handle-face
eventually becomes a high-valence planar face, which is a part of C
1
smooth handle
[168]. After a few number of iterations, this high-valence 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 handle-face 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 Doo-Sabin Algorithm
For example, in the well-known Doo-Sabin 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 Doo-Sabin scheme, each coefcient is always greater
than zero and the coefcients add up to 1. By using Fourier analysis, Doo-Sabin
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 Doo-Sabin 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 Doo-Sabin 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 B-spline tensor-product 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 Doo-Sabins 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 Doo-Sabin 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 Catmull-Clark)
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 /
after corner cutting algorithm will have n + m + f faces: each

face in /induces a new face of the same valence in /
(see Step 2 of the general

description of the corner cutting scheme); each edge in / induces a new face of
valence 4 in /
(see Step 4 of the description); and each vertex in / induces a

new face of valence r in /
, where r is the valence of the vertex (see Step 3 of the

description).
11.5.1 Remeshing Algorithm - 1
For the development of the rst remeshing algorithm we use one high-level opera-
tion to simplify the steps of the algorithm:
SUBDIV(e, v) subdivides the edge e = (u, w) by a new vertex v of valence 2
so that the edge e becomes two new edges (u, v) and (v, w). This operation can be
implemented with the minimal set of operations (rst delete the edge (u, w), then
create an isolated vertex v, then insert edges between u and v, and between v and
w. In our work, since it is an extremely simple operation, we have implemented it
as a stand alone operation.
The rst remeshing algorithm proceeds as follows for a given mesh / under
the DLFL structure,
Step 1: for each face f = v
0
, v
1
, . . . , v
N1
in the mesh /
1.1. for i = 0 to N 1 do
subdivide edge [v
n
, v
(n+1) (mod N)
] by a new vertex v
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
, w]. In consequence, when the edge is traversed

in the second time, the new vertex v
is also encountered. Therefore, in the

above face traversing, the new added vertices should be simply ignored when
faces in / are traversed. In particular, after Step 1, each edge [v, w] in the
mesh / is subdivided by two new vertices v
and w
of valence 2 and the

edge [v, w] becomes three consecutive edges [v, v
], [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
of valence 2 (See Figure 17.6B). On the other hand,

from geometric point of view, since the locations of the new vertices v
and
w
are recomputed, the segment sequence [v, v
], [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 /
must be a corner cutting remesh of the original manifold structure.

11.5.2 Remeshing Algorithm - 2
One of the problem with the previous remeshing algorithm is that when the algo-
rithm is completed the initial mesh / is completely lost. In order to allow opera-
tions such as undo, it is better to preserve the initial mesh /. The following second
remeshing algorithm in this section preserve the initial mesh /and it is also based
on our topology operations.
For the development of the second remeshing algorithm we have developed
a high-level operation that simplies the steps of the algorithm. This high level
operation given below has been implemented efciently with the minimal set of
operations and thus guarantees topological consistency.
CREATEFACEMANIFOLD(v
0
, v
1
, . . . , v
N1
). This operation creates a two sided
face (a manifold surface) by the following procedure.
1. for i = 0 to N 1 do
CREATEVERTEX(v
i
);
2. for i = 0 to N 1 do
INSERTEDGE(v
i
, v
(i+1) (mod N)
, e).
Remark 1. Each of these vertices before the insert edge operation has a
valence less than 2. Therefore, we do not have to specify the corners.
The algorithm proceeds as follows for a given mesh / under the DLFL struc-
ture (see Figure 11.10):
Step 1: for each face F = v
0
, v
1
, . . . , v
N1
in the mesh /
1.1. compute the positions of the new vertices v
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
the front face and the back face respec-

tively. Note that each new vertex v
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 vertex-face pair
v
i
, f
, while back corner at v
i
is the vertex-face 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
. Insert an edge between the back corners

of the vertices v
and v
, and insert another edge between the back corners of

the vertices w
and w
(see Figure 11.10.C).

Let /
denote the new mesh structure created by remeshing algorithm 2. Let

us compare /
with the mesh structure /
created by the remeshing algorithm 1

(see Figure 17.6). It is not difcult to verify that they have the same vertex position
and the same edge set (because the vertex positions are computed using the same
formulas (16.1) and (11.2)). Moreover the rotation at each vertex (i.e. the cyclic
order of the edges incident to the vertex) is also identical in the two mesh structures.
According to the principle of rotation systems (see [156, 167] for further explana-
tion) the mesh structures /
and /
have exactly the same topological structure.

In consequence, they give exactly the same mesh structure (both topologically and
geometrically).
11.6 Implementation and Results
Both algorithms have been implemented in a C++ program. We applied the new
corner cutting algorithm to the control shapes we used for Catmull-Clark subdivi-
sion to obtain smooth handles and holes [133]. It is interesting to note that the cor-
ner cutting algorithm creates better looking handles and holes than Catmull-Clark
algorithm as shown in Figure 11.11 and Figure 14.36. Note that in these examples,
unlike in the Catmull-Clark case, handles and holes look smoother even for only
one edge insertion. Inserting additional edges further improves the quality of the
handles and holes.
11.7 Discussion, Conclusion and Future Work
In this paper, we continue to study the relationship between the topological mesh
modeling and subdivision algorithms. We have developed a new corner cutting
algorithm, which provides a tension parameter to control the shape of subdivided
surface. We have also implemented the new corner cutting algorithm, over the
DLFL structure.
We have observed that the corner cutting schemes are more appropriate for the
reconstruction of handle-faces as they create better handles and holes than Catmull-
Clark. It can also be informative to compare reconstruction of other types of un-
usual faces that are created during topological modeling. Our initial investigation
strongly suggest that for other types of unusual faces, limit surfaces created by
the Doo-Sabin scheme also behave better than those created by the Catmull-Clark
scheme. It can be interesting to develop vertex insertion schemes that can effec-
tively reconstruct such unusual faces.
This paper, along with [133], shows that the DLFL structure is subdivision
friendly. Since subdivision operations are essential for the improvement of the
Figure 11.11: Comparison of handle reconstruction with vertex insertion and corner
cutting. (A1) is the control mesh and (A2) shows the handle-face in (A1). (B1)
and (B2) are the result of Catmull Clark and give two different views of the same
objects. (C1) and (C2) are the result of corner cutting scheme with a = 9/16 and
give two different views of the same objects.
Figure 11.12: Comparison of handle reconstruction with vertex insertion and corner
cutting. (A1) is the control mesh and (A2) shows the handle-face in (A1). (B1)
and (B2) are the result of Catmull Clark and give two different views of the same
objects. (C1) and (C2) are the result of corner cutting scheme with a = 9/16 and
give two different views of the same objects.
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.
Chapter 12
Remeshing and Subdivision Schemes
Triangular and quadrilateral meshes are commonly used in computer graphics ap-
plications. In this paper, we analyze the topological existence of meshes that consist
of n-sided faces where n is greater than 4 such as pentagonal and hexagonal meshes.
We show that it is possible to represent any 2-manifold with a mesh that is made
up of only pentagons. We also show that the meshes that consist of only polygons
with more than ve sides cannot represent all 2-manifolds.
We present a pentagonalization (or pentagonal conversion) scheme that can cre-
ate a pentagonal mesh from any arbitrary mesh structure. We also introduce a pen-
tagonal preservation scheme that can create a pentagonal mesh from any pentagonal
mesh.
12.1 Introduction
Topologically regular meshes, (3, 6) and (4, 4), are extremely useful and popular
in computer graphics applications. ((n, m) is called the Schlai symbol and (3, 6)
means meshes that consist of triangles with 6-valent vertices and (4, 4) represent
131
meshes that consist of quadrilaterals with 4-valent vertices). Regular meshes are
generally sufcient for engineering applications, but in sculptural and architectural
shapes, we often need semi-regular meshes that correspond to interesting tilings.
In this paper, we present two new schemes that can create smooth semi-regular
meshes. One of this subidvision schemes, which we call pentagonalization or pen-
tagonal conversion scheme, converts any arbitrary mesh structure to a pentagonal
mesh. Figure 12.1 shows an example that can be hard problem for such schemes: if
a non-quadrilateral or non-triangular subdivision is applied to such a cube, it is hard
to represent boundary edges. Although, the edge is straight, the rst iteration can
create a wave pattern that does not exist in the original data and the nal smooth
surface include a smooth wave pattern (see [111, 101]). As shown in Figure 12.1.C,
the new subdivision does not create any lateral artifact.
The second scheme, which we call pentagonal preservation scheme, creates
only pentagons and the number of non-pentagonal faces remains constant after the
rst renement. This scheme creates a pentagonal mesh when applied to a pentag-
onal mesh as shown in Figure 12.1.D.
12.2 Motivation
In computer graphics applications meshes that consist of only triangles or only
quadrilaterals, i.e. triangular and quadrilateral meshes, are extremely popular. Al-
though, we can give very strong geometric arguments for using only triangular and
quadrilateral meshes, we do not see obvious topological reason to avoid pentago-
nal, hexagonal or octagonal meshes. There also exist a large variety of remeshing
schemes of existing subdivision algorithms that can create triangular or quadrilat-
eral meshes. However, we do not see schemes that can create similar types of reg-
ular meshes such as pentagonal, hexagonal or octagonal meshes. Although, there
exist some schemes that can create partially hexagonal meshes [114, 101, 104, 102,
(A) (B)
(C) (D)
Figure 12.1: Pentagonal subdivision examples. (A) is the initial mesh, (B) is one
application of pentagonalization scheme, (C) is two iterations of pentagonalization
scheme, (D) is obtained by applying pentagonal preserving scheme to the pentago-
nal mesh in (B).
115, 108], they cannot make all polygons hexagonal. In terms of pentagons and
polygons with more than six sides, no scheme exists that converts a majority of
polygons to the same type of polygons.
An interesting question is whether there exist any schemes that can convert any
polygonal meshes to meshes that consist of only one polygonal types that are not
triangles or quadrilaterals. In this paper, we show that it is possible represent any
manifold shape with pentagonal meshes. On the other hand, we showthat only man-
ifold meshes with a genus higher than 0 can be represented by hexagonal meshes.
We develop schemes that can create meshes that are made up of only pentagons.
Without loss of generality, we ignore the dual schemes, i.e. schemes that create
only n-valent vertices. However, our results are also applicable to dual schemes,
i.e. it is possible to represent manifold shapes using 5-valent meshes, i.e. meshes
with only 5-valent vertices. Moreover, the duals of our remeshing algorithms create
5-valent meshes.
12.3 Classication of Existing Subdivision Remesh-
ing Algorithms
In this paper, we only consider remeshing algorithms that can be used in a subdivi-
sion, i.e. the remeshing schemes we consider must increase the number of vertices.
For instance, we do not consider the remeshing algorithm shown in Figure 12.2,
since it cannot be iteratively applied to a mesh, after the rst iteration it does not
change the mesh.
We categorize existing subdivision remeshing algorithms that are used in sub-
division into two main classes.
Conversion algorithms: These remeshing algorithms, which we will call tri-
angulization and quadrilateralization algorithms, convert any given mesh to
(A) (B)
Figure 12.2: An example of simplest triangulization that cannot be used iteratively.
(A) is the initial mesh and (B) is obtained by subdividing each non-triangular face
into triangles.
a triangular or a quadrilateral mesh respectively. The remeshing scheme of
3 subdivision [106] is a triangulization algorithm. On the other hand, the

remeshing scheme of Catmull-Clark subdivision [165], which is also called
the vertex insertion, is a quadrilateralization scheme. The dual of the remesh-
ing algorithm of Simplest subdivision is also a quadrilateralization scheme
[113] .
Preservation algorithms: These remeshing algorithms preserve triangular and
quadrilateral property of the given mesh, e.g., if a mesh is already triangu-
lated, a triangle preserving remeshing creates a triangular mesh. However,
if the original mesh has some non-triangles, the resulting mesh does not be-
come a triangular mesh. The remeshing algorithm of Loop subdivision is
a good example of a preserving algorithm. Although, Loop subdivision is
only applied to triangular meshes, its remeshing scheme can be applied to
any mesh as shown in Figure 12.3. We do not know of any quadrilateral pre-
serving remeshing approach among published subdivision schemes, but, we
know that several such remeshings exist. An hexagonal preservation scheme,
which is the dual of Loop subdivision has recently been discovered by two
groups [108, 114, 115].
(A) (B)
Figure 12.3: A triangle preserving remeshing: The remeshing scheme of Loop
subdivision. Here, we rst subdivide every edge at its mid-point and connect these
midpoints to create a central face in the middle of each original face and triangles
in each corner. (A) is the initial mesh and (B) the resulting mesh.
The duals of these remeshing algorithms give 3-valent and 4-valent conversion
and preservation algorithms. For instance, the dual of vertex insertion, corner cut-
ting [168, 134], is a 4-valent conversion scheme. After one application of corner
cutting the valence of all the vertices become 4. Similarly, the dual of
3, which has
been discovered by three groups simultaneously [101, 104, 115, 102], is a 3-valent
conversion scheme that converts any manifold mesh to a mesh with only 3-valent
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 Doo-Sabin [168], Vertex insertion schemes
such as Catmull-Clark [165], Simplest [113] and its dual create regular re-
gions that consist of 4-valent vertices and 4-sided faces. Depending on the
scheme either the number of non-4-valent vertices or the number non-4-sided
faces remains constant.
(3, 6) Triangular schemes such as Loop and

3-subdivision [106, 107] cre-
ate regular regions that consist of 6-valent vertices and 3-sided faces. In this
case, the number of non-6-valent 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 3-valent vertices
and 6-sided faces. In this case, the number of non-6-sided 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 Box-splines.
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 Catmull-Clark corresponds to cubic B-splines
and the regular regions of Doo-Sabin corresponds to quadric B-splines, 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 semi-regular meshes. Since any semi-regular tesselation of an innite
plane does not correspond to any analytical representation, it is hard to develop
subdivision schemes that create semi-regular 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 higher-order quadrilateral subdivision surfaces that provide
higher-degree 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 semi-regular
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 semi-regular subdivision
remeshings.
12.4 Topological Constraints
The mesh structures of n-gonal 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 n-gonal 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 less-than-3-valent
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 n-gonal 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 n-gonal mesh where n > 6, i.e. no n-gonalization scheme exists for n > 6.
The result also states that no n-gon 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
In this equation m is always smaller than 3 regardless of the value of v. This

shows that it is not possible to create a hexagonal mesh for g = 0. In other words,
it is not possible to develop an hexagonalization scheme since such a scheme must
also work for g = 0 case. On the other hand, it is possible to develop an hexagonal
preservation scheme since hexagonal meshes exist for g > 0 [108]. Figure 12.5
shows two examples of an hexagon preserving scheme applied to g > 0 hexagonal
meshes.
(A) (B)
Figure 12.5: Two iterations of an hexagon preserving scheme applied to the hexag-
onal meshes shown in Figure 12.4.
For g = 0 and n = 5 the equation 16.1 becomes
m =
10
3
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 6-sided faces with average 3-valent vertices
(5.00, 3.33 ) Average 5-sided faces with average 3.3-valent vertices
(3.33, 5.00 ) Average 3.3-sided faces with average 5-valent 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 semi-regular. Note that (4, 4) can have both regular and
semi-regular tesselations
1
, but, (5, 10/3) can only have semi-regular 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 4-valent 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 (higher-order) 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) semi-regular 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 semi-regular 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 semi-regular 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
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.)
The two algorithms above are implemented and included in an existing 2-manifold
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 semi-regular 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 genus-0 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
3 each vertex becomes valence three and each face becomes

rounder, similar to cells of living organisms. In other words, the portions of the
resulting mesh resemble geodesic domes [112] (also called buckyballs, fullerenes
or soccerballs). As demonstrated by architect Buckminster Fuller, such shapes can
be particularly useful in construction of large structures. Figure 12.13 shows some
examples.
In this paper, we have discussed the topological existence of meshes that consist of
only one type of polygons and shown that it is possible to represent any 2-manifold
(A) (B) (C)
Figure 12.12: (A) An initial mesh (B) pentagonalization scheme applied twice to
the initial mesh, (C) shaded model without wireframe. The initial rabbit mesh in
(A) is modeled by Esan Mandal.
(A) (B)
Figure 12.13: An example of soccerball subdivision.
with a mesh that is made up of only pentagons. We have presented two pentagonal
schemes. One of these schemes can create a pentagonal mesh from any arbitrary
mesh structure, and the other scheme can create a pentagonal mesh from any pen-
tagonal mesh. We have also shown that the dual operation can be a very powerful
tool for development of subdivision derivation rules.
Our work opens the door to a wide variety of semi-regular subdivision schemes.
For instance, it is possible to develop semi-regular schemes that can provide quadri-
lateral or triangular meshes with average 4-valent or 6-valent vertices. Such schemes,
since they produce interesting tiling patterns, can particularly be useful in architec-
tural applications where the shapes of the tiles are an essential part of the aesthetic
shape design.
Chapter 13
Extrusions & Stellations
This chapter presents a set of operators that are applied to only one face of the mesh.
These operators do not affect the rest of the mesh, i.e. boundary edges of the chosen
face stay the same. We have two types of such operators: (1) Extrusions that are
generalized cylinders in which bottom and top polygons have the same number of
sides, and (2) Stellations that are generalized pyramids, where there is a top vertex
instead of top polygon. Stellations are also useful to create generalized versions of
Kepler and Depoinsot solids.
In this paper, we present a set of operators that are applied to only one face of the
mesh. These operators do not affect the rest of the mesh, i.e. boundary edges of
the chosen face stay the same. We have two types of such operators: (1) Extrusions
that are generalized cylinders in which bottom and top polygons have the same
number of sides, and (2) Stellations that are generalized pyramids, where there is a
top vertex instead of top polygon. Stellations are also useful to create generalized
153
versions of Kepler and Depoinsot solids.
13.2 Methodology
Our extrusions and stellations are a generalization of classical extrusion shown
in Figure ??. Classical extrusion has always been one of the most under-rated
yet commonly-used operator in modeling. With the advent of Catmull-Clark sub-
division, it became especially useful in modeling subdivision control meshes. This
extrusion operator is a natural choice for quadrilateral meshes. For other mesh types
and subdivision schemes such as triangular meshes and Loop subdivision, it is use-
ful to have other types of operations that can be applied to only one face of the
mesh.
We have identied ve new extrusions and stellations; four of them are based
on platonic solids. When a classical extrusion is applied to a square, it can give a
cube as shown in Figure 13.1A. Similarly, when a dodecahedral extrusion is applied
to a pentagon, it should give a dodecahedron as shown in Figure 13.3. Based on
this observation, we have identied the four operators as tetrahedral, octahedral,
dodecahedral and icosahedral extrusions.
The Figures 13.1B, 13.2, 13.3 and 13.4 show how the these extrusions affect a
square. The left images are Schlegel diagrams of extrusions [152]. Among these
operators, tetrahedral extrusion is also known as a stellation operation in polyhedral
modeling [152]; and it is used to create Kepler solids such as a small stellated
dodecahedron. We also introduced a double stellation operator shown in Figure ??
to create star shaped ornaments. Double stellation is also useful to create faux-
DePoinsot solids such as the great dodecahedron and great icosahedron. (These are
not real DePoinsot solids, since the real ones have to be self-intersected.)
Among these extrusions, tetrahedral and octahedral extrusions are particularly
useful for mesh manipulations.
(A
1
) (A
2
) (B
1
) (B
2
)
Figure 13.1: (A
1
) Classical (hexahedral) extrusion and (A
2
) its Shegel diagram.
(B
1
) Stellation (Tetrahedral extrusion) and (B
2
) its Shegel diagram.
Figure 13.2: Octahedral extrusion.
Figure 13.3: Dodecahedral extrusion.
Figure 13.4: Icosahedral extrusion.
Figure 13.5: Double-stellation extrusion.
Chapter 14
Interactive High-Genus Modeling
14.1 Multi-Segment Curved Handles
In this paper, we present a method to interactively create multi-segment, curved
handles between two star-shaped faces of an orientable 2-manifold mesh or to con-
nect two 2-manifold meshes along such faces. The presented algorithm combines
a very simple 2D morping algorithm with a Hermite interpolation to construct the
handle. Based on the method, we have developed a user interface tool that allows
users to simply and easily create multi-segment curved handles.
This paper presents a new modeling approach for interactively creating very high
genus 2-manifold smooth meshes, based on creation of free-form handles. The
method can be used for handle creation (i.e., adding a handle to a surface) and for
surface blending (i.e. connecting two distinct surfaces). Both applications of the
algorithm are useful to designers for creating manifolds of high genus.
159
A handle is not an extrusion (or lofting) and handle creation is not simply an
extrusion method. Handle creation is a topological operation and it requires topo-
logical consistency. Therefore, handle creation methods are different than extrusion
methods since they are required to guarantee topological consistency. Our method
not only guarantees 2-manifold property of nal mesh, in every stage of our handle
creation costructed meshes continue to be 2-manifold.
The meshes constructed by our method can be smoothed by any subdivision
scheme since the manifold property is preserved after handle creation. Figure 14.1
shows two views of a genus-6 shape created by our approach combined by subdivi-
sion schemes. To create this object, we rst created 6 multi-segment curved handles
by connecting pairs of neighboring faces of a dodecahedron, and then smoothed
the resulting mesh using one iteration of the Doo-Sabin and two iterations of the
Catmull-Clark subdivision schemes [165, 168, 154].
Figure 14.1: Two views of a genus-6 manifold mesh created by our approach.
Handle creation can also be applied after a subdivision operation, since most
subdivision schemes also preserve the manifold property. As a result, subdivision
schemes and handle creation operators can alternatively be applied to hierarchi-
cally construct high genus manifold meshes. An example of such a hierarchically
constructed mesh is shown in Figure 14.2.
Figure 14.2: Two views of a manifold mesh created by alternatively creating han-
dles and applying Catmull-Clark subdivision scheme.
A prototype system for creating multi-segment curved handles was tested in
a graduate level shape modeling course in which majority of the students had an
architecture undergraduate background. An example of a shape created by the stu-
dents is the high genus M obius band looking shape shown in Figure 14.3 The
student learned how to use the software and nished the model in one week. (Ant
model was created earlier.)
Figure 14.3: An homage to Escher: Band Van M obius II [170].
The creation of very high genus smooth 2-manifold surfaces has always been
a research interest in computer graphics and shape modeling [173]. Ferguson,
Rockwood and Cox used B ezier patches to create high genus 2-manifold surfaces
[171]. Welch and Witkins used handles to design triangulated free-form surfaces
[185]. Using morse operators and Reeb graphs, Takahashi, Shinagawa and Kunii
developed a feature-based approach to create smooth 2-manifold surfaces with high
genus [183].
Akleman and Chen recently introduced a topologically robust mesh modeling
approach to computer graphics and shape modeling [156] by adopting topological
graph theory [167, 146], a relatively obscure mathematical theory that was intro-
duced almost 100 years ago and known by only a handful of graph topologists.
They have shown that their method and subdivision schemes reinforce each other
[133, 134]. Their 2-manifold mesh modeling scheme is based on a minimal set of
manifold preserving operators
1
[156] that is simple, intuitive and user-friendly.
It has recently been shown that their operators can be efciently implemented
on almost every mesh data structure including winged-edge and half-edge [136].
Based on this minimal operator set, a user interface is developed and user friendly
high level operators to interactively model orientable 2-manifold meshes are in-
troduced [161]. One of the most useful high-level operators is the CREATEPIPE
operator [161]. Let /denote a 2-manifold 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 vertex-
face pair, c = (v, f) if f contains the vertex v. The CREATEPIPE(c
1
, c
2
) operator
1
Patent pending.
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 creates a pipe made up of only one segment whose ends are dened
by the original faces.
The main problem with the CREATEPIPE operator is that the length of each
edge in a handle can be much longer than other edges in the mesh /, as shown
in Figure 14.5B. In this paper, we present preliminary results which demonstrate
a solution to this problem. Instead of one pipe segment to connect the two faces,
we use a pipe with multiple segments. This pipe approximates a curve that starts
from the centroid of the rst face, in the direction of the face normal with a given
magnitude and ends at the centroid of the second face in the opposite direction of
the face normal with another given magnitude. The quality of the handle improves
considerably with the new approach, as shown in Figures 14.5C and 14.5D.
Figure 14.4: Creation of a pipe by inserting a set of edges.
Figure 14.5: Problem of long edges and our piecewise straight solution. A is the
original mesh, B was obtained using the CREATEPIPE operator, C and D were ob-
tained using our new approach with different weights for the normals in the Hermi-
tian curve equation.
The remainder of this paper is organized as follows. In Section 14.3, we in-
troduce a minimal set of operators to implement an algorithm to create handles
with multiple segments. Section 14.4 presents an algorithm to create multi-segment
pipes. In Section 14.5, we describe the implementation of the algorithm presented
in Section 14.4. Section 14.6 shows the role of subdivision and gives several exam-
ples of shapes created using our method and discusses the results obtained. Finally,
our conclusions are given in Section 17.6.
14.3 Minimal Operators
In this section, we describe the operators that are used to implement the handle cre-
ation algorithm. These operators can be implemented in any data structure [136]
and allow us to change the topology of a 2-manifold mesh [167, 156, 133]. These
operators are topologically robust; therefore our algorithm always guarantees topo-
logical consistency of 2-manifold meshes. Two fundamental topology change op-
erations and two high level operations are sufcient to develop the algorithm.
1. CREATEVERTEX(v) creates a 2-manifold surface with one vertex v and one
face f which we call a point sphere. The operation is the same as the Euler
operation MV FS [147] and effectively adds a new surface component to the
current 2-manifold. The CREATEVERTEX operator is essential in the initial
stage of the creation of a new mesh and creates a new surface component
in the given 2-manifold. In particular, it is necessary when a new surface
component is created in an empty manifold.
2. INSERTEDGE(c
1
, c
2
, e) inserts a new edge e into the mesh structure between
two corners c
1
and c
2
.
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.
On the other hand, if INSERTEDGE inserts an edge between corners of two
different faces (this includes the situation in which an endpoint or both end-
points of the new edge correspond to point-spheres), the new edge merges the
two faces into one and changes the topology of the 2-manifold.
For the development of the handle creation algorithm we also use two high-level
operators that simplify the steps of algorithm. Both of these can be implemented
efciently using the two fundamental operators given above.
3. CREATEFACEMANIFOLD(v
0
, v
1
, . . . , v
N1
). creates a two sided face (a man-
ifold surface). This operation can be implemented by the following proce-
dure.
(a) for i = 0 to N 1 do
CREATEVERTEX(v
i
);
(b) for i = 0 to N 1 do
INSERTEDGE(v
i
, v
(i+1) (mod N)
, e).
Remark 1. Each of these vertices before the insert edge operation is valence
1. Therefore, we do not have to specify the corners.
4. CREATEPIPE(c
1
, c
2
) This operator is the same as the one described in the
introduction. It connects the 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 (with reference to c
1
and c
2
) of the two faces as shown in
Figure 14.20.
Implementation of this operation based on the fundamental operations is also
straightforward: instead of a single call to the fundamental operator INSERT-
EDGE that inserts a single new edge, we make multiple calls to INSERTEDGE
to insert edges between all the corresponding corners of the two faces.
Remark 2. For the implementation of this operator, the two faces do not have
to have the same number of corners [161].
An algorithm based on these operators is described in the next section.
14.4 Creating Multi-Segment Pipes
Our algorithm to create multi-segment pipes, shown in Figure 17.6, proceeds as
follows for a given mesh /and corners c
1
= (v
1
, f
1
) and c
2
= (v
2
, f
2
):
Step 1: for i = 1 to k 1 where k is the number of segments required in the
handle
3.1. Compute the positions of the vertices in face f
i
= (v
i,0
, v
i,1
, . . . , v
i,N1
)
based on the original faces f
1
and f
2
.
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.6C-17.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 multi-segment 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 cross-section 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 self-intersect 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
distance-angle 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 mid-point 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 distance-angle 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 non-self intersection for non-star faces, it can still be used
in some applications that include non-star 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 self-intersect 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 non-star 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 mult-segment
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 distance-angle 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
.
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 multi-segment 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 Catmull-Clark [165] and Doo-Sabin [168].
Subdivision schemes and our approach to constructing multi-segment 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 high-genus control meshes that are constructed starting from a
simple convex polyhedron. The shapes in Figure 14.11B are obtained by
applying Catmull-Clark subdivision to the shapes in Figure 14.11A. Con-
trol shapes for knots can also be obtained with multi-segment 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 multi-segment 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 Catmull-Clark subdivision [165] to the control
shape.
Figure 14.11: Two examples of manifold meshes created by our method and
smoothed by Catmull-Clark 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 Catmull-Clark twice to the original meshes.
14.7 Discussion, Conclusion and Future Work
In this paper we have demonstrated an algorithm to create multi-segment, curved
handles between two distinct faces of an orientable 2-manifold 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, non-orientable
looking surfaces can easily be obtained with the method. Figure 14.14 shows
the creation of twice twisted M obius-like surface by connecting two prisms. Fig-
ure 14.3 also showed one such example. Figure 14.15 shows another non-orientable
like shapes, a Klein-bottle 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 obius-like 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 non-self-intersection 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 non-star 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 off-line 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 semi-automatic
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 man-made 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
2-manifold 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 x-ray 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 rind-shaped teapot created using our system. (A) and (B) show two
different views of the manifold mesh. (C) is an x-ray 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 2-manifold surfaces [171]. Welch and Witkins used
handles to design triangulated free-form surfaces [185]. Using Morse operators and
Reeb graphs, Takahashi, Shinagawa and Kunii developed a feature-based approach
to create smooth 2-manifold 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 2-manifold 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 winged-edge, [163], half-edge [181] and quad-edge[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 high-level operator called CREATEPIPE
[161] is an example of such intuitive topology change operators. Let / denote a
2-manifold 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 vertex-face 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 multi-segment, curved handles [184]. In this paper, we use the CRE-
ATEPIPE operator to construct rind shaped high-genus 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 high-genus
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
star-like, 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 2-manifold 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 high-genus 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 x-ray 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 2-manifolds 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 two-gons, 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 left-over two-gons are not deleted subdivision
schemes would not be able to adequately smooth out the meshes. Therefore,
it is important to delete these left-over two-gons. Figure 14.24 illustrates how
deletion of one edge of a two-gon eliminates it. In the case of Figure 14.23
deleting e
3
and e
4
will eliminate two-gons. However, deleting e
3
and e
4
is not
easy. Two-gons 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 two-gons 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 left-over 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: Two-gons sre removed by deleting one of their edges. In order to
show the actual mesh structure, one of the edges of every two-gon is drawn curved.
Figure 14.25: The effect of two-gons 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 two-gons. Note that the version with two-gons shows tangent
discontinuities. In all cases, we applied Catmull-Clark [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 semi-automatic 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 semi-automatic 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 2-manifold meshes
is very different from offset surfaces in solid modeling [175, 174] since the
shapes of faces of 2-manifold meshes do not have to be well-dened. For
2-manifold 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 2-manifold 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 2-manifold 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 SGI-O2. 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 corner-cutting 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 Doo-Sabin 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 Doo-Sabin 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 four-connected 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
Doo-Sabin scheme [168] a genus 6 surface. We created the shape shown in (B) by
peeling. The shape in (C) is obtained by applying Catmull-Clark [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 four-connected 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).
In this paper, we presented a user friendly manifold modeling method to easily
construct very high genus rind shapes. Our semi-automatic 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 semi-automatic 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 one-to-many correspondence between each face of the
offset surface and more than one face of the initial surface. If there exists one-to-
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 semi-automatic 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 High-Genus 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 3-valence. 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 L-systems 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 self-similar. Such shapes can be constructed with a simple procedure that ex-
ploits their self-similarity 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 self-similar 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 non-convex 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 exclusive-or operation instead of a set-difference, we can safely
apply this construction to even non-convex 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 set-difference (or
ex-or) 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 non-manifold 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 set-difference 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 Exclusive-Or instead of set-difference.
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 B-Spline surfaces. Our algorithm also creates regular
regions that approach Sierpinski tetrahedra.
Similar to subdivision schemes, our scheme has extraordinary points. Initial
valence-n vertices continue to exist as a part of n-sided pyramids. The newly
created pyramids are all 3-sided, i.e., tetrahedral.
However, unlike subdivision schemes, we change the topology of the initial mesh.
Unlike popular algorithms for self-similar 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
mesh. Moreover, let an edge whose end points (vertices) are the same be referred
to as a self-loop. Then the algorithm is given as follows:
1. For every edge e
i
in E that is not a self-loop, subdivide e
i
at its mid-point.
Let V
m
be the list of all newly created edge mid-points.
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 sub-sequence 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
self-loops in step 1 is necessary for recursive operation, since the edges inserted in
step 3 above will all be self-loops.
(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 self-loop 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). (Self-loops do not form separate faces, but they belong to the triangle
looking backfaces. Holes can appear -becomes visible- only after all the self-loops
are inserted.)
These self-loops 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 self-loops cover
zero area, the resulting shapes look like non-manifolds, although they are mani-
folds.
Note that this algorithm does not provide a set-difference or an exclusive-or
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 non-manifold looking manifold
structure by appropriately connecting triangle-looking 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 self-loops 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 self-loops.
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
self-loops) 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 3-valence 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 3-valence 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 3-valence
convex vertices with non-planar faces (B) the resulting shape after 4 iterations.
If the initial mesh includes some non-3-valence 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
non-planar 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 self-intersecting 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 Doo-Sabin or
Catmull-Clark [168, 165], the smoothed shape remains connnected as shown in
Figure 16.10. We have used Doo-Sabin scheme since it is particularly useful for
smoothing such non-manifold 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 semi-regular 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
Doo-Sabin 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) Doo-Sabin (B) Catmull-Clark and (C) extended
Loop (modied to include non-trinagles).
Figure 16.12: Two examples of smooth-fractal 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 3-valence.
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 Hausdorf-Besicovitch
(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 3-valence, 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 non-integer
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 B-splines [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 3-valence, then in each iteration we con-
struct only planar faced polyhedral meshes, which can be very useful for Architec-
tural applications. Initial 3-valence 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 other-than-3 vertices. (Since all the vertices are 3-valence
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 non-convex 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 4-valent and 5-valence vertices
of octahedra and icosahedra respectively.
If the initial meshes do not have only planar faces and 3-valence 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 screen-shot images shown in Figure 16.18, these non-planar
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 non-planar 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 non-convex polyhedron with non-convex planar faces and
(A
2
) is its 5 times vertex truncated counterpart. (B
1
) is another non-convex polyhe-
dron with non-convex 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 valence-3 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 non-planar faces and its 4
times vertex truncated version. (B
1
) is a genus-1 shape with 4 valent-5 vertices that
cause to construct non-planar 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
space-packing 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 Catmull-Clark.
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
Neyret-Cani 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 Neyret-Cani 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 hand-designed, 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 Neyret-Cani 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 Neyret-Cani 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 counter-clockwise
walk starting fromthe lower-left corner of a square tile gives each tile a unique name
which is a four-digit 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
half-edge [147] of every edge of the mesh by using two random variables. We use
the half-edge concept since it helps to explain the algorithm more concisely. How-
ever, implementation of the algorithm does not require a half-edge 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 bottom-left, texture coordinate (0,0), the width and height of
the texture image is one unit (i.e. the coordinate of upper-left is (1,1)), and the
edges of each qudrilateral are given in counter-clockwise 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
counter-clockwise 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
counter-clockwise rotation. Similarly, to get X0XX we need
to rotate 0XXX 90
0
counter-clockwise, XX0X can be obtained by a 180
0
counter-
clockwise rotation of 0XXX, and nally XXX1 is a 90
0
counter-clockwise 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.
The texture synthesis algorithm is implemented as a stand-alone system in C++ and
FLTK. The texture mapping algorithm is implemented in C++ and included in an
existing 2-manifold mesh modeling systemas an option. Both systems currently run
on SGI, Linux and Windows platforms. All of our interactive examples were run on
an SGI-O2. 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 Catmull-Clark subdivision [165]. Our approach does not
guarantee to minimize the amount of stretching/distortion of the texture. However,
application of the Catmull-Clark 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 four-digit 2n-ary 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
Catmull-Clark 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 half-edges 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 half-edges 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 Catmull-Clark
subdivision [165] in Maya.
Figure 17.8: This example shows a genus-2 surface that includes valence 3, 4, 5
and 6 vertices. The original shape is also smoothed by Catmull-Clark [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.
Here the same texture is also used as a bump map.
A tiled texture created from a photograph of a rusted metal surface.
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.
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. Level-of-detail (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 non-intutive 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
continuous-resolution representation.
18.1.2 Topology Simplication
In order to talk about topology simplication we assume that initial meshes are
2-manifold and they stay 2-manifold 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 2-manifold [166, 54].
Topological simplication refers the capability of gradually simplifying any
given 2-manifold mesh to a simplest genus-0 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 2-manifold [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 high-genus 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 genus-0
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 genus-0 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 non-manifold. 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
self-intersection 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 non-linear 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 non-linear scaling
to compute the change in this positions. This non-linear 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 genus-0 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
2-manifold mesh modeling. Based on this theory, we identify a group of simple va-
lidity rules, and show that the validity of 2-manifold 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 2-manifold meshes with a simple user interface has been an important
issue in computer graphics and computer aided geometric design. Modeling with
2-manifold 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 2-manifold mesh structures. More-
over, non-manifold looking geometric shapes can be effectively represented using
2-manifold mesh structures [11].
Although the importance of 2-manifolds is widely recognized in modeling com-
munity [10, 12], most commercial modeling systems allownon-manifold structures,
because of the following reasons: (1) certain popular modeling operations, such as
set operations, can easily introduce non-manifold structures; and (2) users may in-
tentionally want to create non-manifold structures.
We take a widely used modeling system, MAYA [16] as an example. Con-
sider the shapes in Figure 19.1. From the 2-manifold shape in Figure 19.1(A),
Figure 19.1: Examples of non-manifolds that can be created in Maya.
non-manifold structures in Figure 19.1(B) and Figure 19.1(C) can be created in
MAYA by using the MERGEVERTICES operator, and the non-manifold 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 2-manifold structures now become unreliable and system may crash when a
manifold operation is applied on a non-manifold shape that was created uninten-
tionally.
Since complete re-design of the existing systems will be extremely expensive
and difcult, a solution for solving the above problem is to augment the systems
with a 2-manifold 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 2-manifold shapes of
complicated topological structures.
Such an extension is involved in two important issues (see Figure 19.2): (1)
effective verications of 2-manifold structures, which is necessary to make sure
that the shapes passed to the 2-manifold modeler are valid 2-manifold structures;
and (2) manifold preserving operations, which are employed by the 2-manifold
modeler so that the 2-manifold modeler can deal with all 2-manifold structures but
will never create non-manifold 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 2-manifold validity of a given mesh structure has been
studied by a number of researchers. Hoffmann presented an algorithm [12] for ver-
ication of the 2-manifold validity of triangulated mesh structures. Guibas and
Stol gave a set of rules for deciding whether an edge algebra describes a valid
2-manifold 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 quad-edge structure [10]). The study of mani-
fold preserving operations has been closely related to that for 2-manifold validity
verication [8, 10, 14], which has been centered on the completeness (i.e., the abil-
ity of creating all 2-manifold mesh structures), soundness (i.e., the robustness of
not generating non-manifold structures), and efciency.
Our main contribution in the current paper is to establish a universal framework
for the theory and practice of 2-manifold modeling systems. Based on the classical
theory of graph rotation systems studied in topological graph theory, we rst build a
solid theoretical foundation for 2-manifold 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
2-manifold 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 2-manifold meshes
but never result in non-manifold 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 2-manifold 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 non-manifold under winged-edge structure
19.3 Testing topological validity
We observe that most existing mesh representations and data structures may accept
non-manifold 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 winged-edge data structure
for the corresponding mesh. It is not difcult to verify that other data structures,
such as the half-edge data structure and quad-edge 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 2-manifold 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 2-manifold
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 2-manifold validity of mesh
structures.
Let G be a mesh on a 2-manifold 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 self-loop
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 point-sphere 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 2-manifold 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
2-manifold 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 self-loops are also
allowed. Of course, in case of multiple edges, the edges with the same ends must be
distinguishable, and in case of self-loops, the two directions of the self-loop must
be specied.
Remark 3. If the two end-vertices 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 2-manifold. 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 2-manifold 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 2-manifold 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 2-manifold mesh modeling. We extended
the theory of graph rotation systems and showed that the extended theory provides
a solid foundation for 2-manifold mesh modeling. Based on this fundamental re-
sult, we examined existing data structures and proposed a new data structure for
2-manifold mesh modeling. These data structures are either vertex-based, edge-
based, or face-based. 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 2-manifold mesh modeling and proved that all and only 2-manifold
mesh structures can be constructed by sequences of these operators. Efcient im-
plementations of our operators on vertex-based, edge-based, and face-based 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
self-loops are allowed. For simplicity, most our algorithms were presented only for
meshes without multiple edges and self-loops. It is very straightforward to extend
our algorithms to mesh structures with multiple edges and self-loops. In fact, in
a mesh with no multiple edges and self-loops, a directed edge is given as u, w),
where u and w are the two end-vertices 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 self-loops.
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 vertex-based 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 winged-edge structure, we only need to re-interpret 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
face-based 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 face-based face list in the
DLFL structure for the original mesh in fact gives a vertex-based 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 non-orientable 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
from the face list;

add a new face node to the face list:
f = (r( e
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
2-manifolds can be extended to handle 2-manifolds with boundaries. For modeling
non-orientable manifolds, we point out that the edge algebra model and its com-
pany quad-edge data structure [10] can handle both orientable and non-orientable
surfaces. For our models, there is a simple extension based on graph rotation sys-
tems to represent non-orientable 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 non-orientable manifolds. Following the
same manner, we can prove that this extension always represents valid (orientable
and non-orientable) 2-manifold structures, that the existing data structures for ori-
entable 2-manifold mesh modeling can be augmented to deal with non-orientable
2-manifold mesh modeling, and that slight modications on the operators in our op-
erator set form a complete and sound operator set for orientable and non-orientable
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
= u, x) be the directed edge right before e in the rotation

at the vertex u. If e is traced by FaceTrace( e
0
) and e ,= e
0
, then it is clear by the
algorithm FaceTrace( e
0
) that the directed edge r( e
) = x, u) must be also traced

by FaceTrace( e
0
), right before the tracing of the directed edge e. On the other hand,
if e = e
0
, then the directed edge e = e
0
is traced at beginning of FaceTrace( e
0
) and
FaceTrace( e
0
) stops when the directed edge e = e
0
is encountered the second time.
Thus, when e = e
0
, the last edge traced by FaceTrace( e
0
) must be the directed edge
r( 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
). Thus, 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
) = x, u). This, again, shows that 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 point-spheres, 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
2-manifold 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 self-loop).
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
= w, u) be the two directed

edges induced from the edge e in (G), and suppose that the rotations in (G) at
u and w are (recall that the directed edges are cyclically ordered in the rotation at
each vertex):
u : 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
= w, u) are the two directed edges of the edge e (or more

precisely, we actually inserted the directed edge e
to the face corner cor( e
1
, e
2
) and
the directed edge e
to the face corner cor( 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
2-manifold.
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 point-spheres, which form a valid 2-manifold 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 self-loop). 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 2-manifold structure S
. Let F
be the set of faces in

the mesh (G e). Let f
1
F
be the face containing the face corner cor( e
1
, e
2
)
and let f
2
F
be the face containing the face corner cor( e
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 2-manifold
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
in (G). By looking at the face structures, we can easily see

that the face f
1
= f
2
can be obtained by pasting the faces 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 2-manifold S
, we conclude that the mesh constructed

from (G) should also represent the same 2-manifold S
. In fact, it is not difcult

to see that the mesh (G) can be obtained from the mesh (G e) by adding a
crossing edge e on the face f
1
= f
2
. Thus, in this case, the mesh (G) and (Ge)
represent the same manifold. In other word, inserting the edge e to (G e) does
not change the manifold topology.
Case 2. The two face corners cor( e
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
) is called, we will get the face:

f = ( e, 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 re-drawn 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 2-manifold S
represented by (G e) as follows: rst cut the

two faces f
1
and f
2
off along their boundaries in S
, then on the resulting structure

past the boundaries of the two open ends of the cylinder Y along the boundaries
of the two faces f
1
and f
2
. It is well-known that such a topological surgery on a
2-manifold results in a 2-manifold [146]. Thus, in this case, the mesh (G) also
represents a valid manifold structure.
In terms of the topological structure, case 2 can be further divided into two
subcases: (1) the faces f
1
and f
2
belong to the same surface in the manifold in
this subcase, inserting the edge e to (Ge) (i.e., running a tube between the two
faces f
1
and f
2
) adds a handle to the surface, thus the number of surfaces in the
manifold is unchanged while the manifold genus is increased by 1; (2) the faces
f
1
and f
2
belong to different surfaces in the manifold in this subcase, inserting
the edge e connects the two surfaces by a tube, thus the number of surfaces in the
manifold is decreased by 1 while the manifold genus is unchanged. In any case,
inserting the edge e in case 2 changes the manifold topology.
Summarizing the above discussion, we have proved that in any case, the mesh
(G) represents a valid 2-manifold structure. This completes the proof of the
lemma.
As we described before, each mesh structure on a 2-manifold also naturally
induces a graph rotation system. Combining this fact with Lemma A.3, we have
completed the proof for the following fundamental theorem.
Theorem 3.1 A mesh structure denes a valid 2-manifold if and only if it uniquely
species a graph rotation system (G), whose face set is constructed by the algo-
rithm Facing((G)) in Figure 19.6.
Now we prove Theorem 4.2.2. The algorithm E-Validity presented in Fig-
ure 17.11 is re-given in Figure 19.9.
Theorem 4.2 If a winged-edge structure A[1..m] can pass the test of the algorithm
E-Validity in Figure 19.9, then A[1..m] represents a valid 2-manifold structure.
Moreover, the test algorithm runs in time O(m).
PROOF. An edge node A[e] uniquely induces two directed edges A[e].vstart, A[e].vend)
and A[e].vend, A[e].vstart). Thus, Validity Rule 1 is satised.
For each edge node A[e], the component A[e].nccw uniquely induces the di-
rected edge next to the directed edge A[e].vstart, A[e].vend) in the rotation at
A[e].vstart, and the component A[e].ncw uniquely induces the directed edge next
to the directed edge A[e].vend, A[e].vstart) in the rotation at A[e].vend. Therefore,
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 E-Validity (A[1..m]) {* A[1..m] is a winged-edge 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 19.9: Topological validity testing on winged-edge structure
the winged-edge structure A[1..m] denes a NEXT operation on directed edges
in A[1..m] such that if NEXT(v, w)) = v, x), then v, x) is the directed edge next
to v, w) in the rotation at the vertex v. To verify Validity Rule 2, we only need to
check whether this NEXT operation arranges the directed edges at each vertex into
a cyclic ordering. Since the operation NEXT gives a unique next directed edge for
each directed edge, and since for a directed edge e, NEXT( e) and e are from the
same vertex, there are only two possibilities that the NEXT operation does not ar-
range the directed edges at a vertex v into a cyclic ordering: (1) a directed edge e is
next to two different directed edges e
1
and e
2
, i.e., NEXT( e
1
) = NEXT( e
2
) = e; or
(2) the NEXT operation arranges the directed edges at a vertex into more than one
disjoint cyclically ordered lists. Both these conditions can be identied effectively
by the algorithm E-Validity, as follows. If for two different directed edges e
1
and
e
2
, we have NEXT( e
1
) = NEXT( e
2
) = e, then the directed edge e (or some other
directed edge) will be encountered again after its rst marking. Thus, step 2.2 in the
subroutine VertexTrace will detect this and correctly report an error. If the NEXT
operation arranges the directed edges at a vertex v into more than one disjoint cycli-
cally ordered lists, then after the rst call on the subroutine VertexTrace(v, e), the
vertex v is marked while some directed edges from v are not marked. This situation
will be detected by either step 2 or step 3 of the main algorithm E-Validity, which
will report correctly the error.
On the other hand, if the components ncw and nccw correctly describe a valid
graph rotation system, then each execution of the subroutine VertexTrace(v, e) will
mark the vertex v as well as all directed edges from v, which can in fact also pro-
duce the cyclic order of the directed edges from v (this part is not presented in
the algorithm). Thus, no error will be reported by either step 2.2 in the subroutine
VertexTrace or by the step 2 or step 3 in the main algorithm E-Validity.
Thus, if the winged-edge structure A[1..m] passes the test of E-Validity, then
the components vstart, vend, ncw and nccw of the edge nodes in the winged-edge
structure describe a valid graph rotation system. By the Validity Rules, the theorem
is proved.
Now we consider the complexity of the test for the validity of a winged-edge
structure. Suppose that for a given edge e, the edge node A[e] can be accessed
in constant time (this condition can be easily met if the edge nodes are arranged
in an array A[1..m] where the edge names are given by the array indices), then
the algorithm E-Validity marks each vertex and each directed edge in constant
time. Recording whether a vertex or a directed edge has been marked can be
easily done by using a supplementary vertex array and a supplementary edge ar-
ray). In conclusion, the running time of the algorithm E-Validity is bounded by
O(m + n) = O(m), where m is the number of edges and n is the number of ver-
tices in the winged-edge structure.
Bibliography
[1] A. V. AHO, J. E. HOPCROFT, AND J. D. ULLMAN, The Design and Analysis
of Computer Algorithms, Addison-Wesley, Reading, MA, 1974.
[2] E. AKLEMAN AND J. CHEN, Guaranteeing the 2-manifold property for
meshes with doubly linked face list, International J. of Shape Modeling 5,
(1999), pp. 149-177.
[3] B. J. BAUMGART, Winged-edge polyhedron representation, Technical Report
CS-320, (1972), Stanford University.
[4] J. CHEN, Algorithmic graph embeddings, Theoretical Computer Science 181,
(1997), pp. 247-266.
[5] J. CHEN AND E. AKLEMAN, Topologically robust mesh modeling: concepts,
data structures and operations, Technical Report, Department of Computer
Science, Texas A&M University, College Station, TX (2003), also available
at www-viz.tamu.edu/faculty/ergun/topology.
[6] J. CHEN, J. L. GROSS, AND R. G. RIEPER, Overlap matrices and total
imbedding distributions, Discrete Mathematics 128, (1994), pp. 73-94.
[7] J. EDMONDS, A combinatorial representation for polyhedral surfaces, No-
tices American Mathematics Society 7, (1960), p. 646.
273
[8] M. GARLAND, Quadric-based polygonal surface simplication, Ph.D. Dis-
sertation, Computer Science Department, Carnegie Mellon Univ., CMU-CS-
99-105, May 1999.
[9] J. L. GROSS AND T. W. TUCKER, Topological Graph Theory, Wiley Inter-
science, New York, 1987.
[10] L. GUIBAS AND J. STOLFI, Primitives for the manipulation of general subdi-
vision and computation of Voronoi diagrams, ACM Transaction on Graphics
4, (1985), pp. 74-123.
[11] C. M. HOFFMANN, Geometric & Solid Modeling, An Introduction, Morgan
Kaufman Publishers, Inc., San Mateo, Ca., 1989.
[12] C. M. HOFFMANN AND G. VANECEK, Fundamental techniques for geomet-
ric and solid modeling, Manufacturing and Automation Systems: Techniques
and Technologies 48, (1990), pp. 101-165.
[13] E. MANDAL AND E. AKLEMAN, Wire modeling, Visual Proc. of SIG-
GRAPH03 (Art and Design Sketch), to appear, San Diego, CA (2003).
[14] M. M
ANTYL
A, Boolean operations on 2-manifolds through vertex neighbor-

hood classication, ACM Transaction on Graphics 5, (1986), pp. 1-29.
[15] M. M
ANTYL
A, An Introduction to Solid Modeling, Computer Science Press,

Rockville, MA, 1988.
[16] MAYA, Maya Manual, Alias Wavefront, Toronto, Canada, 1999.
[17] T. M. MURALI AND T. A. FUNKHOUSER, Consistent solid and boundary
representations from arbitrary polygonal data, Proc. 1997 Symposium on In-
teractive 3D Graphics, (1997), pp. 155-162.
[18] SPATIAL TECHNOLOGY INC., ACIS 3D Toolkit 5.0, (1999).
[19] UNIGRAPHICS SOLUTIONS INC., http://www.parasolid.com.
[20] K. WEILER, Topological structures for geometric modeling, Ph.D. Disserta-
tion, Rensselaer Polytechnic Institute, Troy, NY, 1986.
[21] D. ZORIN, ed., Subdivision for Modeling and Animation, ACM SIG-
GRAPH2000 Course Notes no.23, 2000.
Bibliography
[1] B. Aaron, Violated Perfection: Architecture and the Fragmentation of the
Modern, (January 1991) Rizzoli.
[2] R. H. Bartels, J. C. Beatty, and B. A. Barsky, An Introduction to Splines for
use in Computer Graphics and Geometric Modeling, Morgan Kaufmann Pub-
lishers, Los Altos, CA, 1987.
[3] M. Barnsley, Fractals Everywhere, Academic Press, Inc. San Diego Ca. 1988.
[4] W. Bechhoefer and C. Bovill, Fractal Analysis of Traditional Housing in
Amasya, Turkey, IASTE international association for the study of traditional
environments Journal Volume 61, 1995.
[5] B. Carl, Fractal Geometry in Architecture & Design Springer Verlag,
(September 1995).
[6] E. Catmull, A Subdivision Algorithm for Computer Display of Curved Sur-
faces, Ph. D. Thesis, Department of Computer Science, University of Utah,
December 1974.
[7] E. Catmull and J. Clark, Recursively Generated B-spline Surfaces on Ar-
bitrary Topological Meshes, Computer Aided Design, No. 10, pp. 350-355,
September 1978.
277
[8] M. C. Escher, The graphic works: introduced and explained by the artist
Barnes and Nobles Books, New York, (1994).
[9] www.helasculpt.com
[10] www.georgehart.com
[11] www.bathsheba.com/
[12] L. Greg, Das erneuerte Neue der Symmetrie, Arch+ number 128 (1995),
Arch+ Verlag GmbH Aachen, ISSN 0587-3452, p.49.
[13] B Kolarevic, Digital Architecture, it Proceedings of Acadia2000, Washing-
ton DC, October 2000.
[14] B. Mandelbrot, The Fractal Geometry of Nature, W. H. Freeman and Co., New
York, 1980.
[15] L. Neal (Ed) Designing for a Digital World, Academy Editions (UK),
(March 15, 2002)
[16] M. J. Ostwald and R. John Moore, Charting the Occurrence of Non-Linear
Dynamical Systems into Architecture. In Simon Hayman ed. Architectural
Science: Past, Present and Future. (Sydney: Department of Architectural and
Design Science, University of Sydney, 1993), 223-235
[17] M. J. Ostwald and R. J. Moore, Fractalesque Architecture: An Analysis of
the Grounds for Excluding Mies van der Rohe from the Oeuvre. In A. Kelly,
K. Bieda, J. F. Zhu, and W. Dewanto, eds. Traditions and Modernity, (Jakarta:
Mercu Buana University, 1996), 437-453;
[18] M. J. Ostwald and R. J. Moore, Fractal Architecture: A Critical Evaluation
Of Proposed Architectural And Scientic Denitions, in Kan, W. T. ed., Ar-
chitectural Science, Informatics and Design (Shan-Ti: Chinese University in
Hong Kong, (1996), 137-148
[19] M. J. Ostwald Fractal Architecture: Late Twentieth Century Connections
Between Architecture and Fractal Geometry, Nexus Network Journal, vol. 3.
No. 1.
[20] G. Proctor, and J. Glymph, 2002 George Proctor with James Glymph FAIA,
in ACADIA 2002 - Thresholds: Design, Research, Education and Practice,
George Proctor, editor, xi - xiv. The Association for Computer Aided Design
in Architecture.
[21] M. Sabin, Subdivision: Tutorial Notes, Shape Modeling International 2001,
Tutorial, May 2000.
[22] www.cs.berkeley.edu/ sequin/
[23] Topological mesh modeling site: All related papers are available online at
www-viz.tamu.edu/faculty/ergun/topology.
[24] SHoP/Sharples Holden Pasquarelli, Versioning : Evolutionary Techniques in
Architecture Academy Editions (UK); (December 20, 2002).
[25] R. Williams, The Geometrical Foundation of Natural Structures, Dover Pub-
lications, Inc., 1972.
[26] D. Zorin and P. Schr oder, editor, Subdivision for Modeling and Animation,
ACM SIGGRAPH2000 Course Notes no. 23, July, 2000.
[27] A. A. Efros and W. T. Freeman, Image Quilting for Texture Synthesis and
Transfer, Proceedings of ACM Siggraph 2001, pp. 341-346, August 2001.
[28] M. M antyl a, An Introduction to Solid Modeling, Computer Science Press,
[29] F. Neyret and M.P. Cani, Pattern Based Texturing Revisited, Proceedings of
ACM Siggraph 1999, pp. 235-242, August 1999.
[30] C. Soler, M. P. Cani and A. Angelidis, Hierarchical Pattern Mapping, Pro-
ceedings of ACM Siggraph 2002, pp. 673-680, July 2002.
[31] J. Stam, Aperiodic Texture Mapping. Technical Report R046, European Re-
search Consortium for Informatics and Mathematics (ERCIM), January 1997.
[32] E. Akleman and J. Chen, Generalized Distance Functions, Proceedings of
Shape Modeling International99, (March 1999), pp. 72-79, Aizu, japan.
[33] E. Akleman and J. Chen, Guaranteeing the 2-manifold property for meshes
with doubly linked face list, International Journal of Shape Modeling 5,
(1999), pp. 149-177.
[34] E. Akleman, J. Chen, and V. Srinivasan, A new paradigm for changing
topology during subdivision modeling, Proceedings 8th Pacic Conference
on Computer Graphics and Applications, (PG2000), (2000), pp. 192-201.
[35] E. Akleman, J. Chen and V. Srinivasan, A Minimal and Complete Set of Op-
erators for the Development of Robust Manifold Mesh Modelers, Graphical
Models Journal, (Special issue on International Conference on Shape Model-
ing and Applications 2002) 65, (2003) pp. 286-304.
[36] E. Akleman, V. Srinivasan and J. Chen, Interactive Rind Modeling, Pro-
ceedings of International Conference on Shape Modeling and Applications
2003, pp. 23-32, Seoul, Korea, May. 2003.
[37] E. Mandal, E. Akleman and V. Srinivasan, Wire Modeling, Art & Applica-
tions Sketch, SIGGRAPH2003, San Diego, California, August 2003.
[38] A. Bottino, W. Nuij and C. W. A. M. van Overveld, How to Shrinkwrap
through a Critical Point: An Algorithm for Adaptive Triangulation of Iso-
Surfaces with Arbitrary Topology, Proceedings of Implicit Surfaces96, pp.
53-72, October 1996.
[39] A. Certain, J. Popovic, T. DeRose, T. Duchamp, D. Salesin and W. Stuet-
zle, Interactive Multiresolution Surface Viewing, Computer Graphics SIG-
GRAPH, pp 91-99, August, 1996.
[40] J. Chen and E. Akleman, Topologically robust mesh modeling:
concepts, structures and operations, Submitted.(See http://www-
viz.tamu.edu/faculty/ergun/research/topology/ to get a copy).
[41] J. Clark, Hierarchical Geometric Models for Visible Surface Algorithms,
Communications of ACM, Vol. 19, No. 10, pp 547-554, October 1976.
[42] J. Cohen, A. Varshney, D. Manocha, G. Turk, H. Weber, P. Agarwal, F. Brooks
and W. Wright, Simplication Envelopes, Computer Graphics SIGGRAPH,
pp 119-128, August, 1996.
[43] S. F. Frisken, R. N. Perry, A. P. Rockwood and T. R. Jones, Adaptively
Sampled Distance Fields: A General Representation of Shape for Computer
Graphics, Computer Graphics, No. 34, pp. 249-254, August 2000.
[44] I. Guskov, A. Kodakovsky, P. Schroder and W. Sweldens, Hybrid Meshes:
Multiresolution Using Regular and Irregular Renement, Proceedings of
ACM Symposium on Computational Geometry 2002, pp. 264-272, June 2002.
[45] I. Guskov and Z. Woods, Topological Noise Removal, Proceedings of
Graphics Interface 2001, pp. 19-26, June 2001.
[46] T. Funkhouser and C. Sequin Adaptive Display Algorithm for Interactive
Frame Rates During Visualization of Complex Virtual Environments, Com-
puter Graphics SIGGRAPH, pp 247-254, August, 1993.
[47] J. L. Gross and T. W. Tucker, Topological Graph Theory, (Wiley Interscience,
New York, 1987).
[48] C. M. Hoffmann, Geometric & Solid Modeling, An Introduction, (Morgan
Kaufman Publishers, Inc., San Mateo, Ca., 1989).
[49] H. Hoppe, View Dependent Renement of Progressive Meshes, Computer
Graphics SIGGRAPH, pp 189-198, August, 1997.
[50] H. Hoppe, Progressive Meshes, Computer Graphics SIGGRAPH, pp 99-
108, August, 1996.
[51] P. Lindstrom, D. Koller, W. Ribarsky, L. F. Hodges, N. Faust and G. A. Turner,
Real-Time Continuous Level of Detail Rendering of Height Fields, Com-
puter Graphics SIGGRAPH, pp 109-118, August, 1996.
[52] M. M
ANTYL

[53] C. W. A. M. van Overveld and B. Wyvill, Shrinkwrap: An Adaptive Al-
gorithm for Polygonizing an Implicit Surface, The University of Calgary,
Department of Computer Science, Research Report, no. 93/514/19, 1993 .
[54] V. Srinivasan, E. Akleman and J. Keyser, Topological Construction of 2-
Manifold Meshes from Arbitrary Polygonal Data, Submitted.
[55] A. V. Aho, J. E. Hopcroft, and J. D. Ullman, The Design and Analysis of
Computer Algorithms, (Addison-Wesley, Reading, MA, 1974).
[56] E. Akleman and J. Chen, Guaranteeing the 2-Manifold Property for meshes
with Doubly Linked Face List, International Journal of Shape Modeling Vol-
ume 5, No 2, pp. 149-177.
[57] G. Barequet and S. Kumar, Repairing CAD models, in Proceedings of IEEE
Visualization97, (October 1997) pp. 363-370.
[58] R. H. Bartels, J. C. Beatty, and B. A. Barsky, An Introduction to Splines
for Use in Computer Graphics and Geometric Modeling, (Morgan Kaufmann
Publishers, Los Altos, CA, 1987).
[59] B. J. Baumgart, Winged-edge polyhedron representation, Technical Report
CS-320, Stanford University, 1972.
[60] B. J. Baumgart, A polyhedron representation for computer vision, in 44th
AFIPS National Computer Conference, (1975) pp. 589-596.
bitrary Topological Meshes, Computer Aided Design, 10 (September 1978)
350-355.
[62] J. Chen, D. Archdeacon, and J. Gross, Maximum Genus and Connectivity,
Discrete Mathematics, 149 (1996) 19-29.
[63] J. Chen, J. Gross and R. Riper, Overlap Matrices and Imbedding Distribu-
tions, Discrete Mathematics, 128 (1994) 73-94.
[64] J. Chen, Algorithmic Graph Embeddings, Theoretical Computer Science,
181 (1997) 247-266.
[65] A. Certain, J. Popovic, T. DeRose., T. Duchamp, D. Salesin, and W. Stuet-
zle, Interactive Multiresolution Surface Viewing, Computer Graphics, 30
(August 1996) 91-98.
[66] T. DeRose. M. Kass and T. Truong, Subdivision Surfaces in Character Ani-
mation, Computer Graphics, 32 (August 1998) 85-94.
[67] D. Doo and M. Sabin, Behavior of Recursive Subdivision Surfaces Near Ex-
traordinary Points, Computer Aided Design, 10 (September 1978) 356-360.
[68] J. Edmonds, A Combinatorial Representation for Polyhedral Surfaces, No-
tices American Mathematics Society, 7 (1960) 646.
[69] M. Eck, T. DeRose. T. Duchamp, H. Hoppe, M. Lounsbery and W. Stuet-
zle, Multiresolution Analysis of Arbitrary Meshes, Computer Graphics, 29
(August 1995) 173-182.
[70] G. Farin, Curves and Surfaces for Computer Aided geometric Design, A Prac-
tical Guide, (Academic Press, Inc, London, 1988).
[71] H. Ferguson, A. Rockwood and J. Cox, Topological Design of Sculptured
Surfaces, Computer Graphics, 26 (August 1992) 149-156.
[72] P. A. Firby and C. F. Gardiner, Surface Topology, (John Wiley & Sons, 1982).
[73] A. T. Fomenko and T. L. Kunii, Topological Modeling for Visualization,
(Springer-Verlag, New York, 1997).
[74] J. L. Gross and T. W. Tucker, Topological Graph Theory, (Wiley Interscience,
New York, 1987).
[75] L. Guibas, J. Stol, Primitives for the manipulation of general subdivisions
and computation of Voronoi diagrams, ACM Transaction on Graphics, 4
(1985) 74-123.
[76] M. Halstead, M. Kass, and T. DeRose, Efcient, Fair Interpolation using
Catmull-Clark Surfaces, Computer Graphics, 27 (August 1993) 35-44.
[77] L. Heffter, Uber das Problem der Nachbargebiete, Math. Annalen, 38 (1891)
477-508.
[79] C. M. Hoffmann and G. Vanecek, Fundamental techniques for geometric and
solid modeling, Manufacturing and Automation Systems: Techniques and
Technologies, 48 (1990) 347-356.
[80] H. Hoppes, Progressive Meshes, Computer Graphics, 30 (August 1996) 99-
108.
[81] A. W. F. Lee, D. Dobkin, W. Sweldens and P. Schroder, Multiresolution Mesh
Morphing, Computer Graphics, 33 (August 1996) 343-350.
[82] C. Loop, Smooth Subdivision Surfaces Based on Triangles, Masters Thesis,
Department of Mathematics, University of Utah (1987).
[83] C. Loop and T. DeRose, Generalized B-spline Surfaces with Arbitrary Topol-
ogy, Computer Graphics, 24 (August 1991) 101-165.
[84] C. Loop, Smooth Spline Surfaces over Irregular Meshes, Computer Graph-
ics, 28 (August 1994) 303-310.
[85] M. Karasick, On the representation and manipulation of rigid solids, Ph.D.
Thesis, McGill University, 1988.
[86] M. Mantyla, Boolean operations on 2-manifolds through vertex neighbor-
hood classication, ACM Transaction on Graphics, 5 (January 1986) 1-29.
[87] T. M. Murali and T. A. Funkhouser, Consistent solid and boundary represen-
tations from arbitrary polygonal data, in Proceedings of 1997 Symposium on
Interactive 3D Graphics , (1997) pp. 155-162.
[88] F. P. Preparata and M. I. Shamos, Computational Geometry: An Introduction,
(Springer-Verlag, 1985).
[89] J. Stam, Exact Evaluation of Catmull-Clark Subdivision Surfaces at Arbitrary
Parameter Values, Computer Graphics, 32 (August 1998) 395-404.
[90] T. W. Sederberg, D. Sewell, and M. Sabin, Non-Uniform recursive Subdivi-
sion Surfaces, Computer Graphics, 32 (August 1998) 387-394.
[91] B. T. Stander and J. C. Hart, Guaranteeing the Topology of an Implicit Sur-
face Polygonization for Interactive Modeling, Computer Graphics, 31 (Au-
gust 1997) 279-286.
[92] S. Takahashi, Y. Shinagawa and T. L. Kunii, A Feature-Based Approach for
Smooth Surfaces, in Proceedings of Fourth Symposium on Solid Modeling,
(1997) pp. 97-110.
[93] . G. Vanecek, Set operations on polyhedra using decomposition methods,
Ph.D. Thesis, University of Maryland, 1989.
[94] K. Weiler Polygon comparison using a graph representation, Computer
Graphics, 13 (August 1980) 10-18.
[95] K. Weiler Edge-based data structures for solid modeling in curved-surface
environments , IEEE Computer Graphics and Applications, (January 1985)
21-40.
[96] K. Weiler, Topological structures for geometric modeling, Ph.D. Thesis,
Rensselaer Polytechnic Institute, N. Y., August 1986.
[97] R. Williams, The Geometrical Foundation of Natural Structures, (Dover Pub-
lications, Inc., 1972).
[98] D. Zorin and P. Schr oder, co-editors, Subdivision for Modeling and Animation,
ACM SIGGRAPH99 Course Notes no. 37, August, 1999.
with doubly linked face list, International Journal of Shape Modeling (Special
issue on International Conference on Shape Modeling and Applications 1999),
Volume 5, No. 2, pp. 149-177, 1999.
[100] E. Akleman, J. Chen, V. Srinivasan and F. Eryoldas, A New Corner Cutting
Scheme with Tension and Handle-Face Reconstruction, International Jour-
nal of Shape Modeling, (Special issue on International Conference on Shape
Modeling and Applications 2001), Volume 7, No. 2, pp. 111-121, 2001.
[101] E. Akleman and V. Srinivasan, Honeycomb Subdivision, Proceedings of
ISCIS02, 17th International Symposium on Computer and Information Sci-
ences, pp. 137-141, November 2002, Orlando, Florida.
[102] K. Beets, J. Claes, F. Van Reeth, Borders, Semi-sharp Edges and Adaptiv-
ity for Hexagonal Subdivision Surface Schemes Proceedings of Computer
Graphics International, Bradford 2002. GB, 1-5 July 2002, Vince J. [edit.],
e.a., Berlin, Springer, 2002, p. 151-166
[103] E. Catmull and J. Clark, Recursively Generated B-spline Surfaces on Arbi-
trary Topological Meshes, Computer Aided Design, No. 10, September 1978,
pp. 350-355.
[104] J. Claes, K. Beets and F. V. Reeth, A Corner-Cutting Scheme for Hexagonal
Subdivision Surfaces, Proceedings of Shape Modeling International2002
pp. 13-17, Banff, Canada, May 2002.
[105] D. Doo and M. Sabin, Behavior of Recursive Subdivision Surfaces Near
Extraordinary Points, Computer Aided Design, No. 10, September 1978, pp.
356-360.
[106] Kobbelt L.,
3-Subdivision, Computer Graphics, No. 34, August 2000,

pp. 103-112.
[107] C. Loop, Smooth Subdivision Surfaces Based on Triangles, Masters The-
sis, Department of Mathematics, University of Utah, 1987.
[108] N. Dyn, D. Levin, and J. Simoens. Face-Value Subdivision Schemes on
Triangulations by Repeated Averaging. In A. Cohen, J.-L. Merrien and L.L.
Schumaker, eds., Curve and Surface Fitting: Saint-Malo 2002, pp. 129-138.
Nashboro Press, 2003.
[109] C. Loop, Smooth spline surfaces over irregular meshes, Computer Graph-
ics, No. 28, August 1994, pp. 303-310.
[110] M. Mantyla, An Introduction to Solid Modeling, Computer Science Press,
Rockville, Ma., 1988.
[111] M. Sabin, Subdivision: Tutorial Notes, Shape Modeling International
2001, Tutorial, May 2000.
[112] I. Stewart, Game, Set and Math: Enigmas and Conundrums, Penguin Books,
London, 1991.
[113] J. Peters and U. Reif, The Simplest Subdivision Scheme for Smoothing
Polyhedra, ACM Transactions on Graphics, Vol. 16, No. 4, pp. 420-431,
October 1997.
[114] H. Prautzsch and W. Boehm, Chapter: Box Splines, The Hanbook of Com-
puter Aided Geometric Design, Elsevier, 2000.
[115] P. Oswald and P. Schr oder, Composite primal/dual

3-subdivision
schemes, Computer Aided Geometric Design, CAGD 20, 3, 2003, 135164
[118] D. Zorin and P. Schr oder, A Unied Framework for Primal/Dual Quadrilat-
eral Subdivision Schemes, Computer Aided Geometric Design, CAGD 18, 5,
2002, pp 429-454.
with doubly linked face list, International Journal of Shape Modeling, Volume
5, no. 2, pp. 149-177, 1999.
[120] G. Barequet and S. Kumar, Repairing CAD models, in Proceedings of
IEEE Visualization97, (October 1997) pp. 363-370.
Extraordinary Points, Computer Aided Design, 10 (September 1978) 356-
360.
[123] T. K. Dey, H. Edelsbrunner, S. Guha and D. Nekhayev. Topology preserv-
ing edge contraction. Publications de l Institut Mathematique (Beograd), Vol.
60 (80), 1999. Aslo, Technical Report RGI-Tech-98-018, Raindrop geomagic
Inc., Research Triangle Park, North Carolina, 1998.
(1985) 74-123.
[125] A. Gu eziec, G. Taubin, F. Lazarus, B. Horn, Cutting and Stitching: Convert-
ing Sets of Polygons to Manifold Surfaces IEEE Transaction on Visualization
and Computer Graphics, Vol. 7, No. 2, April-June 2001.
[127] M. M
ANTYL

[128] T. M. Murali and T. A. Funkhouser, Consistent solid and boundary repre-
sentations from arbitrary polygonal data, in Proceedings of 1997 Symposium
on Interactive 3D Graphics , (1997) pp. 155-162.
[129] S. J. Rock and M. J. Wozny, Generating Topological Information from a
Bucket of Facets, Proceedings of Source Solid Freeform Fabrication, 1992,
pp 251-259
[130] J. Rossignac and D. Cardoze, Matchmaker: Manifold BReps for Non-
Manifold R-Sets Proceedings of the fth ACM symposium on Solid modeling
and applications pp. 31 - 41, 1999
[131] D. Zorin and P. Schr oder, co-editors, Subdivision for Modeling and Anima-
tion, ACM SIGGRAPH2000 Course Notes no. 23, July, 2000.
[132] E. Akleman and J. Chen, Guaranteeing the 2-Manifold Property for meshes
with Doubly Linked Face List, International Journal of Shape Modeling Vol-
ume 5, No 2, pp. 149-177, 2000.
[133] E. Akleman, J. Chen, and V. Srinivasan, A New Paradigm for Changing
Topology During Subdivision Modeling, Pacic Graphics 2000, October
2000, pp. 192-201.
[134] E. Akleman, J. Chen, F. Eryoldas and V. Srinivasan, A New Corner Cutting
Scheme with Tension and Handle-Face Reconstruction, International Jour-
nal of Shape Modeling Volume 7, No 2, pp. 111-128, 2001.
[135] E. Akleman, J. Chen, and V. Srinivasan, , A Prototype System for Ro-
bust,Interactive and User-Friendly
Modeling of Orientable 2-Manifold Meshes, Accepted, Shape Modeling
2002.
[136] J. Chen and E. Akleman, Topologically Robust Mesh Modeling: Con-
cepts, Data Structures and Operations, Manuscript available at http://www-
viz.tamu.edu/faculty/ergun/research/topology/tr02a.ps.gz
[137] J. I. Blinn, A Generalization of Algebraic Surface Drawing, ACM Trans-
action on Graphics, vol. 1, no. 3, pp. 235-256, 1982.
[138] J. Bloomenthal, editor, Introduction to Implicit Surfaces, Morgan Kaufman,
July 1997.
[139] E. Carmel and D. Cohen-Or, Warp-Guided Object-Space Morphing, The
Visual Computer, Vol. 13, 1997, pp. 465-478.
[140] E. Catmull and J. Clark, Recursively Generated B-spline Surfaces on Arbi-
trary Topological Meshes, Computer Aided Design, No. 10, September 1978,
pp. 350-355.
No. 181, 1997, pp. 247-266.
Extraordinary Points, Computer Aided Design, No. 10, September 1978, pp.
356-360.
[143] M. C. Escher, The graphic works: introduced and explained by the artist,,
(image plate 40: Band Van M obius II), Barnes and Nobles Books, New York,
1994.
[146] J. L. Gross and T. W. Tucker, Topological Graph Theory, Wiley Interscience,
New York, 1987.
[147] M. Mantyla, An Introduction to Solid Modeling, Computer Science Press,
Rockville, Ma., 1988.
[148] T. W. Sederberg and E. Greenwood, A Physically Based Approach to 2D
Shape Blending, Computer Graphics, No. 26, July 1992, pp. 25-34.
[149] T. W. Sederberg, P. Gao, G. Wang and H. Mu, 2D Shape Blending: An
Intrinsic Solution to the Vertex Path Problem, Computer Graphics, No. 27,
August 1993, pp. 15-18.
(1997) pp. 97-110.
[151] W. Welch and A. Witkin, Free-Form Shape Design Using Triangulated Sur-
faces, Computer Graphics, 28 (August 1994) 247-256.
[153] G. Wyvill, C. McPheeters, and B. Wyvill, Data Structure for Soft Objects,
The Visual Computer, vol 2, no. 4, pp. 227-234, 1997.
[155] E. Akleman, J. Chen, Guaranteeing 2-Manifold Property for Meshes, Pro-
ceedings International Conference on Shape Modeling and Applications 1999,
pp. 18-25, Aizu, Japan, March 1999.
with doubly linked face list, (Extended version of [155] selected for special
issue) International Journal of Shape Modeling, Volume 5, No. 2 pp. 149-177,
1999.
[157] E. Akleman, J. Chen, and V. Srinivasan, A new paradigm for changing
topology during subdivision modeling, Proceedings 8th Pacic Conference
on Computer Graphics and Applications, (PG2000), (2000), pp. 192-201,
HongKong, China. Oct. 2000.
[158] E. Akleman, J. Chen, F. Eryoldas and V. Srinivasan, Handle and hole im-
provement by using new corner cutting subdivision scheme with tension, Pro-
ceedings International Conference on Shape Modeling and Applications 2001,
(SMI01), (2001), pp. 32-41, Genova, Italy, May 2001.
[159] E. Akleman, J. Chen, V. Srinivasan and F. Eryoldas, A New Corner Cutting
Scheme with Tension and Handle-Face Reconstruction, (Extended version
of [158] selected for special issue) International Journal of Shape Modeling,
Volume 7, No. 2, pp. 111-121, 2001.
[160] E. Akleman, J. Chen and V. Srinivasan, An Interactive System for Ro-
bust Topological Modeling of Meshes, Visual Proceedings of ACM SIG-
GRAPH2001, Los Angeles, California, August 2001.
[161] E. Akleman, J. Chen and V. Srinivasan, A Prototype System for Robust, In-
teractive and User-Friendly Modeling of Orientable 2-Manifold Meshes, Pro-
ceedings of International Conference on Shape Modeling and Applications
2002, (SMI02), (2002), pp. 43-50, Banff, Canada, May 2002
[162] E. Akleman, J. Chen and V. Srinivasan, A Minimal and Complete Set of
Operators for the Development of Robust Manifold Mesh Modelers, (extended
version of [161] selected and submitted to special issue of Graphical Models
Journal).
[164] A. Bottino, W. Nuij and C. W. A. M. van Overveld, How to Shrinkwrap
through a Critical Point: An Algorithm for Adaptive Triangulation of Iso-
Surfaces with Arbitrary Topology, Proceedings of Implicit Surfaces96, pp.
53-72, October 1996.
bitrary Topological Meshes, Computer Aided Design, 10 (September 1978)
350-355.
[166] J. Chen and E. Akleman, Topologically robust mesh modeling: concepts,
structures and operations, Submitted to a journal. Technical report is available
at www-viz.tamu.edu/faculty/ergun/topology.
181 (1997) 247-266.
Extraordinary Points, Computer Aided Design, 10 (September 1978) 356-
360.
[169] J. Edmonds, A Combinatorial Representation for Polyhedral Surfaces, No-
tices American Mathematics Society, 7 (1960) 646.
[170] M. C. Escher, The graphic works: introduced and explained by the artist,,
(image plate 41 and 43, Barnes and Nobles Books, New York, 1994.
[172] The Fast Light Toolkit Home Page: http://www.tk.org/
[174] M. Forsyth, Shelling and Offsetting Bodies, Proceedings of Solid Model-
ing95, pp. 373-381, Salt Lake City, Utah, May 1995.
[175] J. R. Rossignac and A. A. Requicha Offset Operation in Solid Modeling,
Computer Aided Geometric Design, No. 3, pp. 15-43, 1985.
[176] S. F. Frisken, R. N. Perry, A. P. Rockwood and T. R. Jones, Adaptively
Sampled Distance Fields: A General Representation of Shape for Computer
Graphics, Computer Graphics, No. 34, pp. 249-254, August 2000.
[177] J. L. Gross and T. W. Tucker, Topological Graph Theory, (Wiley Inter-
science, New York, 1987).
(1985) 74-123.
[179] L. Heffter, Uber das Problem der Nachbargebiete, Math. Annalen, 38
(1891) 477-508.
[181] M. M
ANTYL

[182] C. W. A. M. van Overveld and B. Wyvill, Shrinkwrap: An Adaptive Al-
gorithm for Polygonizing an Implicit Surface, The University of Calgary,
Department of Computer Science, Research Report, no. 93/514/19, 1993 .
(1997) pp. 97-110.
[184] V. Srinivasan, E. Akleman and J. Chen, Interactive and user friendly con-
struction of multi-segment curved handles, Proceedings of Pacic Graphics
2003, October 2003.
[185] W. Welch and A. Witkin, Free-Form Shape Design Using Triangulated Sur-
faces, Computer Graphics, 28 (August 1994) 247-256.
[186] D. Zorin and P. Schr oder, co-editors, Subdivision for Modeling and Anima-
tion, ACM SIGGRAPH2000 Course Notes no. 23, July, 2000.

Ergun Akleman - Topological Mesh Modeling

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ergun Akleman - Topological Mesh Modeling

Uploaded by

Copyright:

Available Formats

Contents

)) and cor(v, y), v, y

), and inserting the directed edge v, u) in the rotation at v between

). Note that if the two face corners belong to the

) to undate the face components fcw and fccw;

is not traced in step 5)

) to update the components fcw and fccw.

after corner cutting algorithm will have n + m + f faces: each

(see Step 2 of the general

(see Step 4 of the description); and each vertex in / induces a

, where r is the valence of the vertex (see Step 3 of the

, w]. In consequence, when the edge is traversed

is also encountered. Therefore, in the

of valence 2 and the

of valence 2 (See Figure 17.6B). On the other hand,

are recomputed, the segment sequence [v, v

must be a corner cutting remesh of the original manifold structure.

the front face and the back face respec-

, while back corner at v

. Insert an edge between the back corners

, and insert another edge between the back corners of

(see Figure 11.10.C).

denote the new mesh structure created by remeshing algorithm 2. Let

with the mesh structure /

created by the remeshing algorithm 1

have exactly the same topological structure.

3 subdivision [106] is a triangulization algorithm. On the other hand, the

In this equation m is always smaller than 3 regardless of the value of v. This

3 each vertex becomes valence three and each face becomes

from the face list;

= u, x) be the directed edge right before e in the rotation

) = x, u) must be also traced

). Thus, the directed edge r( e

) = x, u). This, again, shows that the directed edge r( e

= w, u) be the two directed

= w, u) are the two directed edges of the edge e (or more

to the face corner cor( e

to the face corner cor( e

be the set of faces in

be the face containing the face corner cor( e

be the face containing the face corner cor( e

in (G). By looking at the face structures, we can easily see

, we conclude that the mesh constructed

. In fact, it is not difcult

) is called, we will get the face:

represented by (G e) as follows: rst cut the

, then on the resulting structure

A, Boolean operations on 2-manifolds through vertex neighbor-

A, An Introduction to Solid Modeling, Computer Science Press,

A, An Introduction to Solid Modeling, Computer Science Press,

3-Subdivision, Computer Graphics, No. 34, August 2000,

A, An Introduction to Solid Modeling, Computer Science Press,

A, An Introduction to Solid Modeling, Computer Science Press,

You might also like