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 Infinity . . . . . . . . . . . . . . . . . 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 Efficient 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 Classification 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 Mandelbrot’s 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 Refinement with Topological Simplification 239

18.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

18.1.1 Previous Work . . . . . . . . . . . . . . . . . . . . . . . . 241

18.1.2 Topology Simplification . . . . . . . . . . . . . . . . . . . 242

18.1.3 Topological Simplification under Progessive Refinement . . 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 final 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 Sequin [22] who successfully combines art and math-

ematics to create unusual sculptures. These mathematical sculptors, who have a

very noticeable presence in today’s 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 Gehry’s 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 find 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-defined. With

geometrically ill-defined 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 new tools 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 file structure, can represent all

manifolds.

1.4 Mesh Operators

Forming a complete set of operators requires a careful study. We have identified

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 calledfaces. 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-sewn12

pentagonal patches1 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 are1-dimensional entities that represent the

boundaries between pairs of faces. Vertices, on the other hand, are0-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.)

1I found this unusual dodecahedral ball in Germany when we visited my wife’s sister.

13

Figure 2.1: Two views of a ball created by sewing pentagonal patches.

Formally, ameshon a 2-manifoldS specifies an embeddingρ(G) of a graphG

on the 2-manifoldS. Each connected component ofS − ρ(G) plus the bounding

edges inG makes afaceof 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 iscellular 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 verticesv. 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)

whereg 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 are6

faces,12 edges,8 vertices and no holes, i.e.f = 6, e = 12, v = 8 andg = 0. If we

replace these values in equation 2.4, we can observe that they satisfy the equation

as6− 12 + 8 = 2.

The dodecahedral manifold in Figure 2.2 has12 faces,20 vertices and30 edges.

These numbers also satisfy Euler’s equation as12− 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 Euler’s equation as1− 0 + 1 = 2.

The equation 2.4 can also apply polygonal meshes that represent manifold sur-

faces. This equation is extremely useful to identify specific class of polygonal sur-

faces.

2.2 Topologically Regular Meshes

We will define topological regularity as all faces and vertices have the same prop-

erty. A regular mesh is given as(n,m) wheren is the number of the sides of faces,

andm is the valence of vertices.

The valence of a vertex is defined 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 is0. On the other hand, the vertex of

the self-loop in Figure 2.3 has valence2, 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 sidesn and all vertices

has the same valencem, 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-

fied 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 defined as meshes in which all vertices has the valence2. If

we plug inm = 2 to the equation 2.5, we simply get

e = n

If we plug in this value ofe, to the equations 2.2 and 2.3, we find thatf = 2

andv = n. In other words, in this case, there exist exactlyn 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

defined by a set of geometric conditions. However, we do not need any geometric

condition to find mesh structures of regular polyhedra. For bothn andm larger 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 bothn andm larger than2.

2.2.3 Regular Genus-1 Meshes

Forg = 1 the Euler-Poincare equation greatly simplifies

nm− 2n− 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 infinite plane.

For (4, 4) case, value ofe should be an even number sincee = 2v = 2f . For

v = f = 1 ande = 2, we get the simplest genus-1 mesh shown in Figure 2.8(A).

For (6, 3) case,2e = 6f = 3v, sov should be an even number,f should be

twice of v. For f = 1, v = 2 ande = 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

nm− 2n− 2m(g − 1) (2.7)


f =4m

nm− 2n− 2m(g − 1) (2.8)

v =4n

nm− 2n− 2m(g − 1) (2.9)

If all these equations are integer, than there exist a regular mesh. Ifg > 1,

multiplication withg − 1 does not affect integer condition. Thus, we only have to

check the first term.

If we check integer solutions, we found the following regular meshes. These

regular meshes exist in any genus that is larger than1, 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 Infinity

When genus goes to infinity, can can further simplify the equation 2.7 as,

e

g=

2nm

nm− 2n− 2m(2.10)

In other words, in this case for any anyn andm, if eg

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 first 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 efficiently implement edge in-

sertion and deletion operations, we have developed theDoubly Linked Face List

(DLFL) data structure. Using DLFL, we demonstrate examples of topology changes

based on this new paradigm and show that the paradigm is convenient, effective, and

25

efficient for topological changes for subdivision surfaces.

We first 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 figures. 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 first to call attention explicitly to studying rotation systems of a graph.

Let G be a graph. Arotation at a vertexv of G is a cyclic permutation of the

edge-ends incident onv. A rotation systemof G is a list of rotations, one for each

vertex ofG. Given a rotation system of a graphG, to each oriented edge(u, v) in G

one assigns the oriented edge(v, w) such that vertexw is the immediate successor of

vertexu in the rotation at vertexv. 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 arer oriented edges in an orbit, then anr-sided polygon

can be fitted 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 aunique

orientable 2-manifold. Moreover, the corresponding orientable 2-manifold is con-

structible, as we described above. For any 2-manifoldS, there is a graphG and a

rotation systemρ of G such thatρ corresponds to an embedding ofG onS [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 efficient 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:

v1 : v4v2v3, v2 : v3v1v4,

v3 : v1v2v4, v4 : v1v3v2,

and the rotation system of the graph in Figure 19.7 is given by ordered lists:

v1 : v4v3v2, v2 : v3v1v4,

v3 : v4v2v1, v4 : v1v3v2.

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 aface-cornerof 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:

v1 : v3v2α, v4 : v6v5β

whereα andβ are any sequence of vertices. Let an edge be inserted betweenv1 and

v4 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 ofv1 andv4 as follows:

v1 : v3v4v2α, v4 : v6v1v5β

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〈v3, v1, v2〉 and〈v6, v4, v5〉 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〈v3, v1, v2〉 and〈v6, v4, v5〉 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 beC1 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

LetG be a mesh on a 2-manifoldS. Because each vertexv of G has a neighborhood

in S homeomorphic to an open disk, the edges incident onv are cyclically ordered

in this neighborhood. This observation has turned out to be extremely important in

representing a 2-manifold mesh. The classicalwinged-edge data structureproposed

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 ofedge

nodes. Each edge node consists of nine components: (name, vstart, vend, fcw, fccw,

ncw, pcw, nccw, pccw), wherenameis the name of the edge;vstart andvendare

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;ncwandpccwgive the next edges in the faces

fcw andfccwwhen traversing along the edge direction; andpcwandnccwgive the

next edges in the facesfcw andfccwwhen traversing along the reversed direction

of the edge. See Figure 17.4 for illustration.

rvend@@ncw

��pccw

rvstart��pcw

��HH@

@nccw

fcw

fccw

name

Figure 4.1: A edge node in the winged-edge structure

Thus, the winged-edge structure isedge-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 thehalf-edgedata 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 ofhalf-edges1. 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 Stolfi [10] studied mesh structures by defining an algebra on the

edges of a mesh and its dual (thus, it works specifically for cellular meshes). Each

edge can be given adirection along which the edge is traversed, and anorienta-

tion by which the “left side” and “right side” of the edge are well-defined when

1There 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 “fin” 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-verticesOrg andDest(equivalent tovstartandvend

in the winged-edge structure), and the two facesRightandLeft on the two sides of

the edge on the 2-manifold (equivalent tofcw and fccw in the winged-edge struc-

ture). Anedge algebrais introduced by defining three functionsFlip, Onext, and

Rot on the set of the directed and oriented edges, whereFlip flips the orientation

of an edge,Onextgives the “next” edge of an edge based on itsOrg (thus is sim-

ilar to nccw in the winged-edge structure); andRot “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, thequad-edgestructure, 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 simplified.

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 functionsOnext, Sym, and

Dual are needed to define 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 nodesncw, pcw, pccw,

andnccwin the winged-edge structure.

For manifold preserving operations, Mantyla [181] proposed Euler operators,

and Guibas and Stolfi [10] defined the splice and create-edge operators. The com-

pleteness, soundness, and efficient implementations of these operators have been

thoroughly studied.

4.2 Data structures and topological validity

Graph rotation systems arevertex-baseddescriptions 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 specified 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 vertexv, a unique cyclically ordered list is specified that

contains all and only the directed edges fromv.

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 Hoffmann’s 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 first time that these

rules are formally stated and mathematically proven. These theoretical results grant

the first 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,

thegraph adjacency liststructure, which is the most commonly used data structure

for graphs in computer science. Recall that an adjacency list for a graphG is given

by an arrayA[1..n] of linked lists, whereA[v] is a linked list that contains all neigh-

bors of the vertexv. Since the graph has no multiple edges and self-loops, each

vertexw in the listA[v] uniquely specifies the directed edge〈v, w〉 from the vertex

v. Since for each edge[v, w], the vertexw appears in the listA[v] and the vertex

v appears in the listA[w], Validity Rule 1 is satisfied. Moreover, if we interpret

for each vertexv the listA[v] as the cyclic ordering of the directed edges fromv,

then the listA[v] specifies a unique rotation of the directed edges from the vertexv.

Thus, Validity Rule 2 is satisfied. Thus, we conclude

Theorem 4.2.1 A valid graph adjacency listA[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 listA[v] to the listA[w]

and find the directed edge following the directed edge〈w, v〉 in the listA[w]. The

time for doing this is proportional to the size of the listA[w], which will be time

consuming in particular when the vertexw 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 definitions, the edge[vend, vstart], and vertexvend, and the edgencw form

a corner of the facefcw, and the edge[vstart, vend], the vertexvstart, and the

edgenccw form a corner of the facefccw. Thus, if the mesh structure repre-

sents a valid 2-manifold, then the edgesnccwandncw should induce the “next”

directed edges from the verticesvstartandvend, respectively, for the directed edges

〈vstart, vend〉 and〈vend, vstart〉. Thus, whether the winged-edge structure gives a

valid 2-manifold can be verified based on the componentsncwandnccw.

Denote byA[e] the edge node for the edgee in the winged-edge structure. By

A[e].vstart, A[e].vend, A[e].ncw, andA[e].nccw, we refer to the corresponding com-

ponentsvstart, vend, ncw, andnccwin A[e]. Consider the algorithm in Figure 17.11.

Theorem 4.2.2 If a winged-edge structure can pass the test of the algorithmE-

Validity , then it represents a valid 2-manifold. Moreover, the test algorithm runs in

timeO(m).

We give a brief explanation for the correctness of the algorithmE-Validity , and

refer interested readers to [5] for a formal proof. First note that the vertices are

Subroutine VertexTrace(v0, e0) {* the vertexv0 is an end of the edgee0 *}

1. if (A[e0].vstart= v0) then e = A[e0].nccw else e = A[e0].ncw;

2. while (e 6= e0) do

2.1. supposee = [v0, w];

2.2. if (the directed edge〈v0, w〉 has been marked)then Stop(‘not manifold’);

2.3. mark the directed edge〈v0, w〉;2.4. if (A[e].vstart= v0) then e = A[e].nccw else e = A[e].ncw;

3. supposee0 = [v0, w0]; mark the directed edge〈v0, w0〉.

Algorithm E-Validity ( A[1..m]) {* A[1..m] is a winged-edge structure *}

for each edge nodeA[e] do

1. u = A[e].vstart; w = A[e].vend;

2. if (u is not marked){ then marku; 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 { markw; 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 algorithmE-Validity while directed edges are all marked in the

executions of the subroutineVertexTrace. Thus, a call toVertexTrace on a vertex

v0 checks the condition that all directed edges fromv0 must form a unique rotation

atv0, while steps 2 and 3 in the main algorithmE-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 componentsname, vstart, vend, ncw, and

nccware included, will be sufficient for modeling 2-manifold mesh structures.

As an example, we show how the algorithmE-Validity reports an error on

the winged-edge structure given in Figure 19.3. By looking at the edge node

A[e1], step 3 of the algorithm will mark the vertexv2 and call the subroutine

VertexTrace(v2, e1). The subroutineVertexTrace(v2, e1) will mark the directed

edges〈v2, v3〉, 〈v2, v4〉, and〈v2, v1〉 and return back to the main algorithmE-Validity .

Then the main algorithmE-Validity looks at the edge nodeA[e2] and finds out that

the vertexv2 is marked while the directed edge〈v2, v5〉 is not marked, thus correctly

reports an error.

We briefly 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 verification 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 difficult to verify

that testing the Validity Rules on a half-edge structure can be done in timeO(m),

wherem 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 operationOnextdefined 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 theOnextoperation, 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 timeO(m), wherem is 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 efficient 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 structureG consists of aface listF ,

anedge listE, and avertex listV . Eachface nodein the face listF is a cyclically

and doubly linked list of directed edges, lined up head to tail to form a boundary

walk of the face. Eachvertex nodein the vertex listV is a list of pointers to the

corresponding vertices in the face nodes inF . Eachedge nodein the edge listE

consists of two bi-directed pointers to the directed edges induced from the edge in

the face nodes inF .

Figures 4.3 gives a partial part of a DLFL data structure for a tetrahedron.

rv4

rv1 rv3rv2

v2v1 v3 v4v1 v2 v3v1 v4 v4v2 v3

face listjf1 jf2 jf3 jf4

JJ JJ JJ JJ

-� -� -�� ? ?

v1 v2

vertex listv3 v46

66

•��

��

��3

•��

��•6

e1 e2 e3 e4 e5 e6J

JJ

JJ]

^

6

?

��

e6 TTT

e5

cce1 ��e2�

��e4

a tetrahedronedge list

Figure 4.3: The DLFL data structure for a tetrahedron

Both vertex list and edge list provide efficient access to directed edges in the

VertexTrace(v0, 〈v0, w0〉)

1. let〈v0, x〉 be the directed edge following the directed edge〈w0, v0〉 in a face node;

2. while (〈v0, x〉 6= 〈v0, w0〉) do

2.1. let〈v0, y〉 be the directed edge following the directed edge〈x, v0〉 in a face node;

2.2. if (〈v0, y〉 is marked)then stop(‘not manifold’)

2.3. elsemark〈v0, y〉; x = y;

3. mark〈v0, w0〉.

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 vertexv in D) do

if (v is not an isolated vertex without edge)

then in v’s vertex list, find 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 structureD can pass the test of algorithmF-Validity ,

which takes timeO(m), thenD represents a valid 2-manifold.

PROOF. Validity Rule 1 is tested by step 1 of the main algorithmF-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 atw. Thus, the subroutineVertexTrace(v0, 〈v0, w0〉)starts from a directed edge〈v0, w0〉 and constructs a list of consecutive directed

edges fromv0. If the face list does not give a valid rotation at a vertexv0, then

there are only two possibilities: (1) a directed edge atv0 follows two different

directed edges atv0. This will be detected by step 2.2 in the subroutineVertex-

Trace when the directed edge is encountered the second time; (2) the directed

edges atv0 form more than one disjoint cyclically ordered lists. This will be de-

tected by step 3 of the main algorithmF-Validity since the call to the subroutine

VertexTrace(v0, 〈v0, w0〉) can trace only one such a list.

In conclusion, if the DLFL structure passes the test ofF-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 find the

directed edge〈w, v〉 in constant time. Therefore, the algorithmF-Validity runs in

timeO(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 modified 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 allow non-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 Mantyla [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 efficiency. We say that a setS of operators iscompleteif any 2-manifold

mesh structure can be generated by a sequence of the operators fromS, and that the

setS of operators issoundif applying any operator inS 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 efficient implementations on a variety

of modeling data structures, and compare it in terms of various aspects with the

existing approaches.

The first operator isedge insertion, briefly INSERTEDGE. Let ρ(G) be a graph

rotation system and letu and v be two vertices inG. By inserting a new edge

[u, v] between two face cornerscor(〈u, x〉, 〈u, x′〉) andcor(〈v, y〉, 〈v, y′〉), we mean

inserting the directed edge〈u, v〉 in the rotation atu between the directed edges

〈u, x〉 and〈u, x′〉, and inserting the directed edge〈v, u〉 in the rotation atv 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 theedge deletionoperator, briefly DELETEEDGE. Let ρ(G) be a rotation system

and lete = [u, v] be an edge inG, by deleting the edgee, we mean deleting the

directed edge〈u, v〉 from the rotation at the vertexu and deleting the directed edge

〈v, u〉 from the rotation at the vertexv.

The other primary operator isvertex creation, briefly 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 operatorsINSERTEDGE/DELETEEDGE

andCREATEVERTEX/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 verified 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 Stolfi

[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 difficulties 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 sufficient

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 vertexv and its corresponding face, which we simply call apoint-

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(c1, c2, e) inserts a new edgee to the mesh structure between

two cornersc1 and c2 (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 edgee 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 edgee = [v1, v2] completely

disconnects the verticesv1 andv2 so that there is no further path connecting

the verticesv1 andv2 in the mesh, then the surface that contains both vertices

v1 andv2 is actually split into two disjointed surfaces, one containing vertex

v1 and the other containing vertexv2.

These four operators are necessary and sufficient 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 efficiently

implemented on almost every mesh data structure including winged-edge, [163],

half-edge [181] and quad-edge[178].

We first give a short overview of these operators and then present our new algo-

rithm.

5.3.1 Background

Among the four operators, two are sufficient to construct our algorithm. These are

INSERTEDGE and CREATEVERTEX:

1. CREATEVERTEX(v) is similar to the Euler operator MVFS. It creates a new

isolated vertexv 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.


two cornersc1 andc2. Formally, acorneris a subsequence of a face boundary

walk consisting of two consecutive edges plus the vertex between them except

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{fi, vj}. We can also consider a corner as a

subsequence of a face boundary walk consisting of three consecutive vertices.

For example iff = {v1, v2, v3, v4} is a face,{v1, v2, v3} is a corner referring

to the vertexv2 in facef and{v3, v4, v1} is the corner referring to the vertex

v4 in facef .

If I NSERTEDGE 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 figures in [156] for visual explanation.

When the operator INSERTEDGE is inserting an edgee between corners of

two different facesf1 andf2, there is an interesting and intuitive interpretation

of the operation as two steps. In the first step, we delete the facesf1 andf2,

which results in a 2-manifold with boundaries because of two “open” holes

left by deleted facesf1 and f2. 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 facesf0 andf1 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 combiningn number of point spheres withn number of

inserted edges.

Figure 5.4: A tetrahedron can be obtained by combining four point spheres with six

insert edge operations.

Chapter 6

Efficient 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 cornerscor(〈u, x〉, 〈u, x′〉) and

cor(〈w, y〉, 〈w, y′〉), we only need to insert the itemw between the itemsx andx′

in the linked list for the vertexu, and insert the itemu between the itemsy andy′

in the linked list for the vertexw. DELETEEDGE that deletes an edge[u, w] from

the adjacency list structure is implemented by deleting the itemw in the linked list

for u and deleting the itemu in the linked list forw. 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 efficient 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

briefly 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 itemv in the vertex list,

called avertex 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 nodeA[e] with componentsname, vstart, vend, ncw,

pcw, nccw, pccw, fcw, andfccw (see Figure 17.4). The componentsnccwandpcw

Subroutine InsertEdge([u, w], cor(〈u, x〉, 〈u, x′〉),cor(〈w, y〉, 〈w, y′〉)){* Inserting edgee = [u, w] to face cornerscor(〈u, x〉, 〈u, x′〉) andcor(〈w, y〉, 〈w, y′〉). *}

1. create a new edge nodeA[e] for e = [u, w] with A[e].vstart= u andA[e].vend= w;

2. find the edge nodese1 = [u, x], e2 = [u, x′], e3 = [w, y], ande4 = [w, y′];

{* without loss of generality, assumeA[e1].vstart= A[e2].vstart= u and

A[e3].vstart= A[e4].vstart= w. Other cases can be handled similarly. *}3. A[e1].nccw= e; A[e2].pcw= e; A[e].nccw= e2; A[e].pcw= e1;

4. A[e3].ncw= e; A[e4].pccw= e; A[e].ncw= e4; A[e].pccw= e3;

5. callFaceTrace(〈u, w〉) to update the componentsfcw andfccw;

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

then call FaceTrace(〈w, u〉) to update the componentsfcw andfccw.

Subroutine DeleteEdge(e)

1. find the edge nodeA[e] for the edgee = [u, w], whereA[e].vstart= u andA[e].vend= w;

2. find the edge nodese1 = A[e].pcw, e2 = A[e].nccw, e3 = A[e].pccw, ande4 = A[e].ncw;

{* without loss of generality, assumeA[e1].vstart= A[e2].vstart= u, and

A[e3].vstart= A[e4].vstart= w. Other cases are handled similarly. *}3. A[e1].nccw= e2; A[e2].pcw= e1; A[e3].ncw= e4; A[e4].pccw= e3;

4. remove the edge nodeA[e];

5. callFaceTrace(〈u, x′〉) to undate the face componentsfcw andfccw;

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

then call FaceTrace(〈w, y′〉) to update the componentsfcwandfccw.

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 componentsncw andpccwgive the “next” and “previous”

directed edges to the directed edge〈vend, vstart〉, respectively. Finally, the compo-

nentsfcw andfccwgive the “right face” and “left face” while traveling from vertex

vstartto vertexvendalong the edge.

Implementations of the operators INSERTEDGEand DELETEEDGEon a winged-

edge structure are given in Figure 10.3. By the definitions of the componentsncw,

pcw, nccw, andpccw(see Figure 17.4), it is easy to verify that the operator INSERT-

EDGE inserts the directed edge〈u, w〉 to the face cornerc1 = cor(〈u, x〉, 〈u, x′〉)

and inserts the directed edge〈w, u〉 to the face cornerc2 = cor(〈w, y〉, 〈w, y′〉),while the operator DELETEEDGE deletes the edgee. The componentsncw, pcw,

pcw, andpccwof the related edges are properly updated. The only thing that needs

further explanation is the updating of the componentsfcw andfccw. Consider IN-

SERTEDGE. If the two face cornersc1 andc2 belong to different faces, then inserting

the edgee = [u, w] betweenc1 andc2 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 edgee. Therefore, in this case, the subroutineFaceTrace(〈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 subroutineFaceTracein step 6 will not

be executed. On the other hand, if the face cornersc1 andc2 belong to the same

face in the mesh, then inserting the edgee betweenc1 andc2 replaces the face by

two new faces whose boundaries contain the two directed edges〈u, w〉 and〈w, u〉of the inserted edgee, respectively. Thus, the subroutineFaceTracein step 5 traces

one new face and updates the face components for the related edge nodes, while

the subroutineFaceTracein step 6 traces the other new face and updates the face

components for the related edges nodes.

For the operator DELETEEDGE on an edgee, if the two directed edges ofe are

on boundaries of two different faces, then deletinge will “merge” the two faces into

a single one. Thus, the subroutineFaceTracein 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 ofe are on the boundary of the same face, then deletinge will

“split” this face into two faces Now the subroutineFaceTracein 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 componentsncw, nccw, pcw, andpccw, 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 subroutineFaceTrace, 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 fine. However, for faces of large

size, this will be time consuming.

In section 4.2 we remarked that the componentsname, vstart, vend, ncw, and

nccwin the winged-edge structure are sufficient for representing a 2-manifold mesh

structure. In particular, a winged-edge structure without the componentsfcw and

fccw is sufficient for describing a 2-manifold mesh structure. Moreover, on a

winged-edge structure without the componentsfcw 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), wheres is the size of the faces

involved, while on a winged-edge structure without the components fcw and fcw,

the running time of the algorithmsINSERTEDGE andDELETEEDGE is O(1).

The discussion of the implementations of the operators INSERTEDGEand 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 componentsncw, nccw,

pcw, pccw, fcw, andfccw 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 Stolfi [10]. Roughly

speaking, the SPLICE operator is equivalent to first inserting an edge between two

face corners then “contracting” the edge, while the inverse of the SPLICE operator

is equivalent to first 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, andfccw. 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 componentsfcw andfccw 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 inefficiency 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 vertexv 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 timeO(log s), wheres is the size of the involved faces (for more detailed

description and verification, see [62]). Therefore, under this implementation for

face nodes, the running time of the algorithms INSERTEDGE and DELETEEDGE is

bounded byO(log s). This concludes our discussion.

Theorem 6.3.1 Under the above implementation on DLFL, the operatorsCREAT-

EVERTEX and DELETEVERTEX take timeO(1), and the operatorsINSERTEDGE

andDELETEEDGE take timeO(log s), wheres 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 refinement 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

first 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 first step, operator deletes

the facesf1 andf2, 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 refinement.

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 refinement 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 simplifica-

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 refinement

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, finding 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 simplification. 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 final 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 significant 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 benefit 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 difficult 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 file formats in particular often omit topological information, as only

the geometric definitions of polygons are necessary for display purposes. Alias-

Wavefront’s obj file format and the STL format are examples of such common

graphics file 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 algorithm is based entirely on topology, it ignores the geo-

metric properties of the underlying shape. Avoiding geometry has its own benefits.

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 benefit —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 significant result in the work we present here is insight into manifolds

by creatingunusual 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 benefit of the algorithm is crack repair. Our algorithm provides

a simple method to automatically fill 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 file formats can be the cause

of significant problems when modeling solids. Often the output to an interme-

diate file 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 identification 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 (from an STL file) are cobined into a manifold [129].

Often, such methods are intended to take into account numerical error that has

been introduced during file 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 Gueziec 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 Gueziec 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. LetV 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 arrayV 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 first need to find 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 edgee1,2 be the cornersc1 = {a, v1, b} andc2 = {c, v2, d}referring to verticesv1 andv2 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 vertexv1 andv2. We will refer to these lists

asCv1 andCv2 corresponding tov1 andv2 respectively. To find the corner

corresponding toc1, go throughCv1 and find the corner which is preceded

by vertexa or followed by vertexb. If Cv1 contains only 1 corner select that

corner. The corner corresponding toc2 is found similarly usingCv2 . If either

of Cv1 or Cv2 contains more than one corner and a matching corner forc1 or

c2 cannot be found, postpone insertion of this edge.

2. If we can find matching corners for bothc1 andc2 in the above step, do the

actual edge insertion using the INSERTEDGE operator.

After the first 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 arbitrarily1 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 files are always imported as correct manifolds. Corrupt files such

as the ones representing non-manifolds or manifolds with boundaries could crash a

1Note 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 beO(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 figures, 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 first example is shown in Figure 19.1. This nonmanifold shape is given by

the following faces that are represented by cyclic ordered sets:

f0 = {3, 2, 1, 4} f1 = {7, 8, 9, 10}f2 = {2, 3, 6} f3 = {4, 1, 5}f4 = {6, 9, 8} f5 = {5, 7, 10}f6 = {6, 5, 10, 9} f7 = {5, 6, 3, 4}f8 = {6, 8, 7, 5} f9 = {1, 2, 6, 5}

If the faces are given with the order above, our algorithm converts this non-

manifold to a manifold by combining facesf8 andf9 into one hexagonal facef10 =

{1, 2, 6, 8, 7, 5} as shown in top row of Figure 19.1. Note that the hexagonf10

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 facesf4, f5, f7 andf9

are combined into one facef11 = {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:

f0 = {3, 2, 1, 4} f1 = {6, 7, 8, 9}f2 = {1, 2, 5} f3 = {7, 6, 5}f4 = {4, 1, 5} f5 = {6, 9, 5}f6 = {3, 4, 5} f7 = {9, 8, 5}f8 = {2, 3, 5} f9 = {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 facesf8 andf9 into one hexagonal facef10 =

{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,f9 andf2 are read as the last two polygons and the algorithm

combines them into a new facef11 = {1, 2, 5, 8, 7, 5}. In the last row,f9 andf4

are read as the last two polygons and the algorithm combines them into a new face

f12 = {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.

f0 = {4, 3, 2, 1} f1 = {9, 10, 11, 12}f2 = {7, 8, 12, 11} f3 = {3, 4, 8, 7}f4 = {4, 1, 5, 8} f5 = {8, 5, 9, 12}f6 = {2, 3, 7, 6} f7 = {6, 7, 11, 10}f8 = {1, 2, 6, 5} f9 = {5, 6, 10, 9}f10 = {5, 6, 7, 8}

Since this visual example is more complicated than earlier ones, we have not

drawn the facef10 and the initial shape looks like a simple prism. If the faces are

given with the order above, our algorithm simply eliminates the facef10 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:

• f4 andf5 combine and become a hexagon as{4, 1, 5, 9, 12, 8}.

• f6 andf7 combine and become a hexagon as{2, 3, 7, 11, 10, 6}.

• f3, f8 andf10 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 figure, 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 filling in the empty area (i.e. the crack) around that polygon. As

additional edges are inserted, this back face continues to fill 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 asf0 =

{v0, v1, v2}, f1 = {v0, v3, v1} andf2 = {v0, v2, v3}. The algorithm first inserts

edges for the facef0, {v0, v1} {v1, v2} and{v2, v0}. After inserting these3 edges

a “back” facefb = {v0, v2, v1} will be automatically created. Then, the algorithm

inserts remaining edges for facef1, which are{v0, v3} and{v3, v1}. As a result,

the back face now becomesfb = {v0, v2, v1, v3}. In the next step, the algorithm

adds remaining edges for the facef2, which involves adding only the edge{v2, v3}.Inserting this edge dividesfb into two. One part becomes the facef2, while the

remaining back face isfb = {v2, v1, v3}. Notice thatfb now fills 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 files. 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

simplifies 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 file 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 problem with 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, efficient, 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 sacrificing 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 problem with 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 first 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 efficiently implement edge in-

sertion and deletion operations, we have developed theDoubly Linked Face List

(DLFL) data structure. Using DLFL, we demonstrate examples of topology changes

based on this new paradigm and show that the paradigm is convenient, effective, and

efficient for topological changes for subdivision surfaces.

We first 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 figures. 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

pn+1 = Apn

wherepn andpn+1 are the vectors of respectively the old points and the new points

in the local topological region andA 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 specifically 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 efficiently.

The classical view of mesh representation is based on adjacency relationships

between points, edges and faces. For instance, the vertex-edge adjacency relation-

ship specifies two adjacent vertices for each edge. There exist nine such adjacency

relationships, but it is sufficient 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 specified by an ordered sequence

of vertices, and each vertex is specified by itsx, y, andz coordinates [120]. Let

us call this data structure avertex-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 avertex-polygon-edge

list structure, a list of vertices, a list of directed edges, and a list of polygons

are described. Vertices are specified by their three coordinates, directed edges

are specified by two vertices, and polygons are specified 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-edgerepresentation [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 Stolfi introduced thequad-edgedata 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 Weiler’sradial-edgestructure [96], Kara-

sick’sstar-edgestructure [85], and Vanecek’sedge-baseddata 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 Euler’s 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 edgeand Delete edge, are

enough to change the topology. If an inserted or deleted edge change the topology,

we can efficiently find the new topology by using graph embeddings. This efficient

computation is due to ourDoubly 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 efficiently.

DLFL not only supports efficient 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 ofgraph 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 providenecessary and sufficient conditionsin representing

valid 2-manifolds. Our DLFL structure is an efficient 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 efficiently. 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 calledvertex 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 graphG = (V, E) with face set

F . A doubly-linked-face-list(DLFL) for the rotation systemρ(G) is a tripleL =

〈F ,V , E〉, where theface listF consists of a set of|F | sequences, each is given by

1To simplify the implementation we use linked lists for the faces. To further improve efficiency

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.

Thevertex arrayV has|V | items. EachV [v] is a linked list of pointers to the vertex

nodes ofv in the face linked lists inF . Theedge arrayE has|E| items. EachV [v]

also includes the 3D position of the related vertex. EachE [e] is doubly linked to

the first vertex nodes of the two edge sides of the edgee in the face linked list inF .

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 vertexv1 and edgee5 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 first 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 first subdivided to make each face a quadrilateral. Then,

the inside faces of every two neighboring tetrahedra are connected by an in-

finitely 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 figure

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 C1 discontinuous extraordinary vertex. Inserting extra edges removes this

C1 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

figure, each additional edge improves the quality of the hole in the cube.

More figures 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 adds2 to the

valance. Such an extraordinary point with a high valance will most likely beC1 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 simplification 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 efficient

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 structureDoubly Linked Face List(DLFL), which

guarantees topological consistency and provides topological changes [156, 167].

We have identified two operations INSERTEDGEand 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

sufficient 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 difficult 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 first iteration of Catmull-

Clark, high valence extraordinary vertices are created. Limit surfaces around these

vertices generally have ripples that give aG1 discontinuous look.

In this work, we further study the handle-face reconstruction with subdivision

algorithms. We first 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 new subdivision 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 identified a minimal set of basic operations on the DLFL structure

that are necessary and sufficient for performing all homeomorphic and topological

operations on orientable 2-manifolds [?]. A clear identification of the minimal set

of operations distinguishes the lower level fundamental operations from the higher

level operations, and greatly improves computational efficiency, 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 vertexv and one

facef which we call apoint sphereas shown in Figure 11.1. This operation

is the same as the Euler operationMV 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 operationKV FS [147].


two cornersc1 andc2 (acorneris 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 edgee 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 sufficient 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 figure is an example of the type of faces which we call

“handle-faces”.

In case the operation INSERTEDGE is inserting an edgee to corners of two

different facesf1 andf2, there is an interesting and intuitive interpretation of the

operation as follows: the operation can be decomposed into two steps. In the first

step, we cut off along the boundaries of the facesf1 andf2, 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 first 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 efficiently 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 figure 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 classified based on three criteria [186,

154]: (1) the type of refinement 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 efficiently 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 first iteration of vertex insertion scheme. The valence

of the extraordinary vertex on a handle is generally higher than8. 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.51.

1The 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 ofC1 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 refinement rules for a general corner cutting algorithm are as follows:

• Step 1 : For each vertexvn of a facef = {v0, v1, . . . , vn, . . . , vN−1} of the

mesh, create a new vertexv′n. Compute the position of the new vertex as

v′n =N−1∑m=0

an,mvm (11.1)

wherean,m are real coefficients 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 coefficientsan,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. an,m ≥ 0 for all n and allm and

2. for all n’sN−1∑m=0

an,m = 1.

These conditions guarantee convergence of the algorithm and provideC0 continuity

and affine invariance properties [186, 154].

11.4.1 Doo-Sabin Algorithm

For example, in the well-known Doo-Sabin subdivision scheme, the coefficients

an,m in equation (16.1) are computed using the following formulas:

an,m = 14

+ 54N

if n = m

an,m =(3+2 cos( 2(n−m)π

N ))4N

otherwise

It is easy to verify that in Doo-Sabin scheme, each coefficient is always greater

than zero and the coefficients add up to1. By using Fourier analysis, Doo-Sabin

showed that this scheme has three distinct eigenvalues1, 1/2, 1/4. One eigenvector

has the eigenvalue1, two eigenvectors correspond to eigenvalue1/2 and the rest

of the eigenvectors correspond to the smallest eigenvalue1/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 coefficientsan,m to compute the position ofv′n.

an,m = a if n = m

an,m = M1− a

3N − 5otherwise

(11.2)

where

M = 3 + 2 cos

(2(n−m)π

N

).

In these equations, parametera 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 forN = 4 anda = 9/16.

Note that, in our case the coefficients add up to1 and if0 < a < 1 each coefficient

is greater than zero.

By using Fourier analysis, similar to Doo-Sabin’s 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 ofN the sequence is strictly decreasing.

Similar to Doo-Sabin scheme, only one eigenvector corresponds to eigenvalue1,

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 ofa. To have positive eigenvalues,

for a triangular face. (i.e.,N = 3) a must be larger than1/3 (Note that in triangle

case, the third eigenvalue will not exist.) For a quadrilateral face (i.e.,N = 4) a

must be larger than5/12. Otherwise, the smallest eigenvalue can become negative.

It is safer to choose5/12 as a lower bound fora 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 show the first four consecutive iterations of the new corner

cutting scheme for a cube control shape. In these examples, we used the parameters

a = 9/16 anda = 0.9. As shown in the Figures, the largera values, the less

rounded shape becomes. This is because for largera values, the positionv′n will

geometrically be closer to the position ofvn. By using this property, the user can

control the degree of smoothness.

Figure 11.7: The first four consecutive iterations witha = 9/16.

Figure 11.8: The first four consecutive iterations witha = 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.

LetM be a mesh given in the DLFL structure such that we will apply a corner

cutting algorithm onM. If M hasn vertices,m edges andf faces, then the new

mesh structureM′ after corner cutting algorithm will haven + m + f faces: each

face inM induces a new face of the same valence inM′ (see Step 2 of the general

description of the corner cutting scheme); each edge inM induces a new face of

valence4 in M′ (see Step 4 of the description); and each vertex inM induces a

new face of valencer inM′, wherer is the valence of the vertex (see Step 3 of the

description).

11.5.1 Remeshing Algorithm - 1

For the development of the first remeshing algorithm we use one high-level opera-

tion to simplify the steps of the algorithm:

SUBDIV(e, v) subdivides the edgee = (u, w) by a new vertexv of valence2

so that the edgee becomes two new edges(u, v) and(v, w). This operation can be

implemented with the minimal set of operations (first delete the edge(u, w), then

create an isolated vertexv, then insert edges betweenu andv, and betweenv and

w. In our work, since it is an extremely simple operation, we have implemented it

as a stand alone operation.

The first remeshing algorithm proceeds as follows for a given meshM under

the DLFL structure,

• Step 1: for each facef = {v0, v1, . . . , vN−1} in the meshM

1.1. fori = 0 to N − 1 do

subdivide edge[vn, v(n+1) (mod N)] by a new vertexv′n;

1.2. compute the positions of the new verticesv′0, v′1, . . ., v′N−1 using the

formulas (16.1), and (11.2);

1.3. forn = 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 meshM 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] inM is traversed exactly twice in Step 1, once

from v to w and once fromw to v. After the first traverse, the edge[v, w] of

M is subdivided into[v, v′, w]. In consequence, when the edge is traversed

in the second time, the new vertexv′ is also encountered. Therefore, in the

above face traversing, the new added vertices should be simply ignored when

faces inM are traversed. In particular, after Step 1, each edge[v, w] in the

meshM is subdivided by two new verticesv′ andw′ 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] inM is subdivided by two

new verticesv′ andw′ of valence 2 (See Figure 17.6B). On the other hand,

from geometric point of view, since the locations of the new verticesv′ 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 faceF , 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 vertexv in the meshM, suppose the neighbors

of v, which are all new added vertices, are ordered by the rotation atv asv0,

v1, . . ., vr−1. Insert new edges[vj, 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 efficiently. Moreover, the face corners for the new in-

serted edge[vj, v(j+1) (mod r)] are in the face that also contains the face corner

(v(j+1) (mod r), v, vj), so they can be found conveniently.

• Step 3 : Finally, we delete all edges of form[v′, w′], wherev′ andw′ are the

new vertices subdividing an old edge[v, w] in the meshM, and delete all old

vertices inM 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 first remeshing algorithm.

Remark 6. A careful examination shows that the new mesh structureM′

shares neither common vertex nor common edge with the old meshM. Even

the new edges resulted from subdividing the old edges ofM 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 difficult to verify that none of the operations we applied in this algorithm

changes the topology of the initial meshM. Therefore, the resulting structureM′

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 meshM is completely lost. In order to allow opera-

tions such as undo, it is better to preserve the initial meshM. The following second

remeshing algorithm in this section preserve the initial meshM 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 simplifies the steps of the algorithm. This high level

operation given below has been implemented efficiently with the minimal set of

operations and thus guarantees topological consistency.

CREATEFACEMANIFOLD(v0, v1, . . . , vN−1). This operation creates a two sided

face (a manifold surface) by the following procedure.

1. for i = 0 to N − 1 do

CREATEVERTEX(vi);

2. for i = 0 to N − 1 do

INSERTEDGE(vi, 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 meshM under the DLFL struc-

ture (see Figure 11.10):

• Step 1: for each faceF = {v0, v1, . . . , vN−1} in the meshM

1.1. compute the positions of the new verticesv′0, v′1, . . ., v′N−1 using the

formulas (16.1), and (11.2);

1.2. CREATEFACEMANIFOLD(v′0, v′1, . . . , v

′N−1).

Figure 11.10: Illustration of second remeshing algorithm.

Remark 2. Step 1 creates two new facesf ′ = (v′0, v′1, . . . , v

′N−1) andf ′′ =

(v′N−1, v′N−2, . . . , v

′1, v

′0) for each old facef = (v0, v1, . . . , vN−1) (see Fig-

ure 11.10.B). We callf ′ andf ′′ “the front face” and“the back face”respec-

tively. Note that each new vertexv′i the adjacent faces are just the fornt face

and back face. Thus, we can talk about the“front corner” and“back corner”

at vertexv′i. More specifically, the front corner ofv′i is the vertex-face pair

{v′i, f ′}, while back corner atv′i is the vertex-face pair{v′i, f ′′}.

• Step 2: for each old edgee = {u, w} the two ends ofe induce two pairs of

new vertices{v′, v′′} and{w′, w′′}. Insert an edge between the back corners

of the verticesv′ andv′′, and insert another edge between the back corners of

the verticesw′ andw′′ (see Figure 11.10.C).

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

us compareM′′ with the mesh structureM′ created by the remeshing algorithm 1

(see Figure 17.6). It is not difficult 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 structuresM′ andM′′ 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 witha = 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 witha = 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 wheren is greater than4 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 five 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 Schlafli symbol and(3, 6)

means meshes that consist of triangles with 6-valent vertices and(4, 4) represent

131

meshes that consist of quadrilaterals with4-valent vertices). Regular meshes are

generally sufficient 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 callpentagonalization 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 first iteration can

create a wave pattern that does not exist in the original data and the final 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 callpentagonal preservation scheme, creates

only pentagons and the number of non-pentagonal faces remains constant after the

first refinement. 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 show that only man-

ifold meshes with a genus higher than0 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 using5-valent meshes, i.e. meshes

with only 5-valent vertices. Moreover, the duals of our remeshing algorithms create

5-valent meshes.

12.3 Classification 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 first 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 first 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 give3-valent and 4-valent conversion

and preservation algorithms. For instance, the dual of vertex insertion, corner cut-

ting [168, 134], is a4-valent conversion scheme. After one application of corner

cutting the valence of all the vertices become4. Similarly, the dual of√

3, which has

been discovered by three groups simultaneously [101, 104, 115, 102], is a3-valent

conversion scheme that converts any manifold mesh to a mesh with only3-valent

vertices.

Existing subdivision remeshing schemes can also be classified 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 classified 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 first re-

finement.

• (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 first refinement.

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. Identification of the weights for a sub-

division scheme that corresponds to a specific 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 infinite

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 Schroder 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 ofn-gonal meshes can easily be identified from Euler’s equa-

tion by assuming every face hasn sides and every vertex has an average valencem.

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 genusg manifold shape withn-gonal meshes for the given

n regardless of the values ofg andv, m should never be smaller than3. If not, it

means that some vertices are required to have less than valence3 which corresponds

to trivial cases.

A single manifold mesh satisfies the following Euler formula

v − e + f = 2− 2g

wherev is the number of vertices,e is the number of edges andf is the number

of faces. Since the mesh represents a manifold, then2e = nf and2e = mv. If

we plug in these relationships between edges, vertices and faces, we obtain the

following relationship betweenm andn.

m =2n

n− 2

(1 +

2g − 2

v

)(12.1)

For any givenn, m must be larger than3 for all g andv. Fortunately, we do

not have to check all possibleg andv’s. All we need to show thatmin(m) is larger

than3. It is clear from the equation 16.1 that regardless of the values ofg andv for

g > 0

min(m) ≤ 2n

n− 2

In other words, 2nn−2

should be larger than3 to be able to avoid less-than-3-valent

vertices. Note that2nn−2

is a monotone decreasing function that becomes smaller than

(A) (B)

Figure 12.4: Examples of hexagonal meshes for g¿0.

3 for values ofn larger than6. This also shows that forg > 0, it is always possible

to create hexagonal meshes; two examples are shown in Figure 12.4.

Although, there can be some specialn-gonal meshes for a small values ofv and

large values ofg, this result clearly states that a given mesh cannot be converted

to ann-gonal mesh wheren > 6, i.e. non-gonalization scheme exists forn > 6.

The result also states that non-gon preservation scheme exists forn > 6 since a

preservation scheme that can be used in subdivision must increasev.

Above analysis does not includeg = 0 case, sinceg = 0 is a special case for

hexagonal meshes. Forg = 0 andn = 6 the equation 16.1 becomes

m = 3(1− 2

v

)In this equationm is always smaller than3 regardless of the value ofv. This

shows that it is not possible to create a hexagonal mesh forg = 0. In other words,

it is not possible to develop an hexagonalization scheme since such a scheme must

also work forg = 0 case. On the other hand, it is possible to develop an hexagonal

preservation scheme since hexagonal meshes exist forg > 0 [108]. Figure 12.5

shows two examples of an hexagon preserving scheme applied tog > 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.

Forg = 0 andn = 5 the equation 16.1 becomes

m =10

3

(1− 2

v

)Here, for values ofv larger than20, we can create pentagonal mesh. Note

that v = 20 corresponds to a dodecahedron (simplest pentagonal mesh with12

pentagons). We will later show how to convert a tetrahedron to a dodecahedron.

The other inseresting cases aren = 4 andn = 3 for g = 0. In the case ofn = 4,

we find thatv must be larger than8 and the simplest casev = 8 corresponds to an

hexahedron (generalized cube; simplest quadrilateral mesh with6 quadrilaterals).

In the case ofn = 3, v must be larger than4 and the simplest casev = 4 corresponds

to a tetrahedron (simplest triangular mesh with4 triangles).

Another insteresting case occurs whenv goes to infinity.

mv→∞ −→2n

n− 2.

This is the same as the value of them for g = 1, which corresponds to planar

tesselations. In other words, for larger values ofv, the value ofm approaches a

value that is coming from tesselations of an infinite 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 replacingv with f , we included

(10/3, 5), the dual of(5, 10/3). If both n andm are integers and every face has

exactlyn sides and every vertex has valencem, 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 tesselations1 , but,(5, 10/3) can only have semi-regular tesselations.

1Since we are considering only the average valences or number of sides, a(4, 4) mesh can include

pentagons and triangles while having only4-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 new schemes. Note that we do not compute

weights. Our remeshing operations provide a simple (affine) 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 andF 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 beVs.

2. For every facefi 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

cj = {vj, fi}, wherevj belongs toVs, insert an edge between the point

sphere andcj; then insert an edge between the point sphere and every

third corner fromcj 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) or6.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 beVs.

2. For every facefi in F

(a) Collect the coordinates of the midpoint of every original edge infi.

These will be the coordinates of the newly created midpoints from the

previous step. Let the list of these midpoints bePi. Note thatPi 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 inPi around their centroid by a specified amount. The

scale factor should be less than 1.

(c) Create a new face using the scaled points inPi.

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 inVs. Let the list of the new faces beFn.

3. For every facefi in Fn

(a) For each vertexvi,j in fi, insert an edge betweenvi,j and the point inVs

corresponding tovi,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 figures 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 average4-valent or6-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 identified five 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 identified 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.

(A1) (A2) (B1) (B2)

Figure 13.1:(A1) Classical (hexahedral) extrusion and(A2) its Shegel diagram.

(B1) Stellation (Tetrahedral extrusion) and(B2) 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 final 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 first 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 “Mobius band looking” shape shown in Figure 14.3 The

student learned how to use the software and finished the model in one week. (Ant

model was created earlier.)

Figure 14.3: An homage to Escher:Band Van Mobius 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 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].

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 operators1 [156] that is simple, intuitive and user-friendly.

It has recently been shown that their operators can be efficiently 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]. LetM denote a 2-manifold mesh and letv, f ande denote a vertex,

a face and an edge respectively. We define acorner of the mesh to be a vertex-

face pair,c = (v, f) if f contains the vertexv. The CREATEPIPE(c1, c2) operator

1Patent pending.

connects two faces which contain the cornersc1 andc2 such that there is an edge

betweenc1 andc2 and there is an edge between other matching corners (in traversal

order starting fromc1 andc2) 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 defined

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 meshM, 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 first 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 sufficient to develop the algorithm.

1. CREATEVERTEX(v) creates a 2-manifold surface with one vertexv and one

facef which we call apoint sphere. The operation is the same as the Euler

operationMV 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(c1, c2, e) inserts a new edgee into the mesh structure between

two cornersc1 andc2.

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

efficiently using the two fundamental operators given above.

3. CREATEFACEMANIFOLD(v0, v1, . . . , vN−1). 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(vi);

(b) for i = 0 to N − 1 do

INSERTEDGE(vi, 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(c1, c2) This operator is the same as the one described in the

introduction. It connects the two faces which contain the cornersc1 andc2

such that there is an edge betweenc1 andc2 and there is an edge between other

matching corners (with reference toc1 andc2) 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 meshM and cornersc1 = (v1, f1) andc2 = (v2, f2):

• Step 1: for i = 1 to k − 1 wherek is the number of segments required in the

handle

3.1. Compute the positions of the vertices in facef ′i = (v′i,0, v′i,1, . . . , v

′i,N−1)

based on the original facesf1 andf2.

3.2. CREATEFACEMANIFOLD(v′i,0, v′i,1, . . . , v

′i,N−1).

Remark 3. This step creates a set of manifold faces starting fromf ′1 and

ending atf ′k−1 as shown in Figure 17.6B.

Remark 4. Note that for the sake of simplicity this explanation implies that

f1 andf2 have the same number of vertices. We will later show thatf1 and

f2 do not have to have the same number of vertices for the implementation of

the algorithm.

• Step 2: Starting fromf ′0 = f1 and ending atf ′k = f2, going through the

sequence of facesf ′0, f′1, . . . f

′k−1, 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 defined by the face traversal starting

from c1 andc2 (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 cornersc1 = (v1, f1) andc2 = (v2, f2) and two weightsw1 andw2 be

given. If f1 andf2 are star shaped faces with the same number of vertices, our goal

is to create a multi-segment pipe between the two facesf1 andf2 such that the two

verticesv1 andv2 are directly connected by a series of straight line segments that

approximate a Hermitian curve

H(t) = p1h1(t) + p2h2(t) + w1n1h3(t)− w2n2h4(t). (14.1)

Herep1 andp2 are the centroids andn1 andn2 are the average normals off1 andf2

respectively (with|n1| = 1 and|n2| = 1) andh1(t), h2(t), h3(t) andh4(t) are the

Hermitian basis functions. This Hermitian curve starts from the centroid of facef1

in the direction of the face normal (n1) and ends at the centroid of facef2, in the

opposite direction of the face normal (−n2). Note that the weightsw1 andw2 can

be negative, which can be used to create holes instead of handles.

14.4.2 Face Morphing

The Hermitian curveH(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 fromf1 to f2.

This problem strongly resembles the problem of 2D shape blending [148] (more

widely known as 2D morphing). Therefore, our approach is to first simplify the

problem into a 2D problem. To morph the shape of the faces fromf1 to f2 in 2D,

we first determine a reference planeR and rotate both faces to that reference plane.

The choice ofR is arbitrary and does not by itself affect the algorithm. We use

the vector from the centroid of the first face to the centroid of the second face to

determine the unit normal vectornR to the reference planeR. We rotatef1 ontoRaround its centroid using the rotation axisn1 × nR We rotate the facef2 similarly.

After these rotations, we move each vertex off1 andf2 to the reference planeR, to

ensure that the transformedf1 andf2 are planar. Bothf1 andf2 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 transformedf1

andf2 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 planeR, we resolve every vertexv of f1 andf2 into a

distance-angle pair (r, θ), wherer is the distance ofv from the centroid of the face

(which is now the origin) andθ is the angle thatv (treated as a vector) makes with

the X axis. The choice of the reference axis system is arbitrary and has no influence

on the final results. We define the reference axis system as follows. We take the

vector from the origin to the mid-point of the last edge inf1 to be the X axis. The

Y axis will then be the cross product betweennR and the X axis.

We ensure that the angles always increase monotonically within the same face

going from the first vertex to the last one. This is necessary to avoid self inter-

sections as we transition fromf1 to f2, and also gives a smooth transition. We

also ensure that the difference in angles for the first vertices is not more than 180

degrees. This prevents unwanted twists in the pipe (along the axis of the pipe).

Let

f1 = (v1,0, v1,1, . . . , v1,N−1)

f2 = (v2,0, v2,1, . . . , v2,N−1)

v1,j = (r1,j, θ1,j), j = 0 to N − 1

v2,j = (r2,j, θ2,j), j = 0 to N − 1

(14.2)

be the resolved representations of the two facesf1 andf2, whereN is the number

of vertices in each face.

Remark 6. To simplify the notation, here we assume thatf1 andf2 have the

same number of vertices. However, this is not a restriction. Iff1 andf2 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. LetN and

M be the number of vertices off1 andf2 respectively. Without loss of generality,

let us assume thatN > M . Then, the number of vertices off2 can easily be

increased toN by inserting new vertices. After sucha procedure,f1 andf2 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 perform a linear interpolation of the distance-angle pairs using the same

parametert as used for the Hermitian curve, such thatt = 0 corresponds tof1 and

t = 1 corresponds tof2. Let

f ′i = (v′i,0, v′i,1, . . . , v

′i,N−1) (14.3)

be an interpolated face corresponding to a parametert, where

v′i,j = (r′i,j, θ′i,j), j = 0 to N − 1

r′i,j = (1− t)r1,j + tr1,j

θ′i,j = (1− t)θ1,j + tθ2,j

(14.4)

Using the Hermitian curveH(t) we get a pointp(t) and a tangent vectorn(t) for

a given parametert. We rotatef(t) so that its normal points in the same direction

asn(t) and translate it so that its centroid coincides withp(t).

We now have a sequence of faces defining the ends of the segments which make

up the handle. We finish 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 usingt = 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 valuesw1 andw2, there is no solution to

this problem. Since both high curvature and curve self intersection occur for larger

values ofw1 andw2, it is easier to reduce the values of these parameters. Moreover,

a very small number of segments is usually sufficient 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 ofw1 andw2 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 off1 andf2 are not equal, untilf1 andf2 have

the same number of vertices, insert new vertices to the face with less vertices.

• Step 2:

2.2. Reverse facef2.

2.3. Using the centroidsp1 andp2 and weighted normalsn1 andn2 of the two

faces, compute a Hermitian curveH

• Step 3:

3.1. Compute the reference planeR with normalnR.

3.2. Transformf1 andf2 so that their normals are in the same direction asnR

and their centroids are at the origin.

3.3. Resolvef1 andf2 into distance-angle pairs (Equation 14.2).

• Step 4: for i = 1 to k − 1 wherek is the number of segments required in the

handle

4.1. Computet = i/k

4.2. Compute a pointpi and tangentni on the curveH for t

4.3. Perform a linear interpolation between the resolved representations of

f1 andf2 usingt as the parameter to obtain the resolved representation off ′i

(Equations 14.3 and 14.4 )

4.4. Compute the positions of the vertices in facef ′i = (v′i,0, v′i,1, . . . , v

′i,N−1)

corresponding to the resolved representation calculated in the previous step.

4.5. Transform the vertex coordinates off ′i computed above so that the nor-

mal tof ′i points in the direction ofni and its centroid coincides withpi.

4.6. CREATEFACEMANIFOLD(v′i,0, v′i,1, . . . , v

′i,N−1)

• Step 5: Starting fromf ′0 = f1 and ending atf ′k = f2, 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 defined by the face traversal starting fromc1 andc2.

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 valuesw1 andw2 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 first 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 Mobius-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 Mobius-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. A specific case of the problem “one 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 defined 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 method’s 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 first 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 Escher’s 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 first 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 callrind

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 figure, 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 Escher’s rind

objects [170].

Rind modeling consists of two steps: in the first (automatic) step, for any given

2-manifold mesh surface an offset surface is created based on a user defined 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 figure 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 areal 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 EDGEINSERTand EDGEDELETE. Moreover,

these four operators can be efficiently implemented [166] on almost every mesh

data structure including winged-edge, [163], half-edge [181] and quad-edge[178].

2For 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 simplified 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. LetM denote a

2-manifold mesh and letv, f ande denote a vertex, a face and an edge respectively.

We define acorner of the mesh to be a vertex-face pair,c = {v, f} if f contains

the vertexv. The CREATEPIPE(c1, c2) operator connects two faces which contain

the cornersc1 andc2 such that there is an edge betweenc1 andc2 and there is an

edge between other matching corners (in traversal order starting fromc1 andc2)

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 defined 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

first 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,SMI’02.

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 first 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 theinitial meshand the newly

createdoffset 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 them a single surface.

Formally, this first 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 first 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 infinitely thin wall or slab (like a

thin membrane) between two neighboring holes. Users have to delete such infinitely

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 infinitely thin walls left over by hole punching. The peeling effect shown

in (C) is obtained only after deleting these infinitely 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 identified 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 difficult 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 difficult to select a correct corner in the offset surface since this surface

is inside and partially visible only through holes. This difficulty is even more

pronounced in the application of the first 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 figure geometri-

cally does not make sense, it helps to conceptually visualize the structure of

the infinitely thin wall. Note that this infinitely thin wall is in fact a handle

and this handle can be deleted by deleting two edgese1 ande2 as shown in

Figure 14.23. Deletion ofe1 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 ofe2, separating this hexagon into two two-

gons, is the handle eliminated.

Figure 14.23: Deletion of a an infinitely thin pipe by deleting only two edges.

Initially this infinitely thin pipe consists of two quadrilaterals.

Note that this deletion process is hard for the users. The requirement to delete

the first two edgese1 ande2 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 first of such edges,e1, can be easily performed. However, after the

first 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 difficult to delete the second edge which becomes visible only from some

viewpoints.

The resulting two two-gons, which are created aftere1 ande2 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

deletinge3 ande4 will eliminate two-gons. However, deletinge3 ande4 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 difficult

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

infinitely thin pipes between neighboring holes are automatically eliminated.

The following is our semi-automatic method:

Automatic step: Offset surface creation.This is the first 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 acorrespondence tablethat 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-defined. For

2-manifold meshes we cannot describe a distance function and, therefore, we

cannot really define 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 createsk new faces (quadrilaterals) wherek 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 infinitely 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 student’s 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 Escher’s 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. Escher’s 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 first 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, Escher’s 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-

cher’s 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 Escher’s 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 Escher’s 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 giveC1 continuity and allows

for shape control with a tension parameter. Honeycomb 1 subdivision scheme is

useful for creating flower patterns. This scheme creates flower 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 simplifies 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 identification 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 flower pattern creation with honecomb 1 algorithm.

To create this pattern, each edge of the dodecahedron shown in (A) is subdivided

twice. The flower 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 algorithm from the 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 3D shapes 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 efficient 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 efficient, 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 = UKk=0 Ak S

whereAk is a4×4 transformation matrix in homogenous coordinate system andU

is the union operator, then, an algorithm to construct such a shape involves creating

a series of shapes starting from an initial shapeS0 as

Sn = UKk=0 Ak Sn−1

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

increasesK times in each iteration. Since the number of copies increases very

quickly, after a few iterations a good approximation ofS 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,S0

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 specific 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 efficient, 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 figure, 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 affine copies of a Sierpinsky tetrahedron. For instance, although the shape in

Figure 16.1(B) can be assembled from affine copies of (A), (C) is topologically dif-

ferent from the Sierpinsky polyhedron in (A) and cannot be created by affine copies

of (A).

16.3.1 Generalization of Mandelbrot’s 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 Mandelbrot’s

alternative Sierpinski triangle constructions that relies upon “cutting out ‘tremas’”

as defined 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 asfrom each convex polygon cut a convex polygon that is

created by connecting the midpoints of each edgeas shown in Figure 16.2. After

first 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 Mandelbrot’s 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: Mandelbrot’s 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: Mandelbrot’s 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 ofn-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 first 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 aself-loop. Then the algorithm is given as follows:

1. For every edgeei in E that is not a self-loop, subdivideei at its mid-point.

Let Vm be the list of all newly created edge mid-points.

2. For every vertexvi in V

(a) For every cornerci = {a, vi, b} which points tovi, insert an edge

(shown as blue edges in Figure 17.6.B) between the corners{c, a, vi}and {vi, b, d}, where{c, a, vi, b, d} forms a sub-sequence of vertices

defining a face in the mesh.

This will subdivide each facef in the original mesh into as many triangles as

the number of vertices inf plus one central face (shown as yellow faces in

Figure 17.6.D) which will have the same number of vertices asf .

3. For each vertexvi in Vm

(a) Find the cornersc1 andc2 pointing tovi 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) betweenc1 andc2.

After step3 in the above process, all the central faces created in step2 will no

longer exist and we will have holes in their place. The restriction on edges not being

self-loops in step1 is necessary for recursive operation, since the edges inserted in

step3 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 haven number of sides instead of2n. 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 efficiency 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 defined 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 simplification 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 classified vertices into5 categories. Our classi-

fication 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

flattened. (5)Saddle vertex. The tip of the pyramid is saddle shaped. Based on this

classification, we identified 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 first 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 flattened pyramid. This problem can be visually annoying

but cannot be corrected. Unfortunately, the number of flattened 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 yetC1 discontinuous. To

create these shapes we apply a polyhedral truncation algorithm based on Chaikin’s

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 infinity...”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 (modified 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 figure, After the application of a vertex truncation scheme,

• each polygon withn number of sides converts to an equilateral polygon with

2n number of sides;

• each vertex with valencem becomes an equilateral polygon withm 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 sufficient 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 find 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)

whenn, the number of the sides of largest polygon goes toinfty

Using the fact that in each iteration a regularn sided polygon goes to a regular

2n sided polygon, we can find that the length of the edges is scaled by

S =1

2 cos(2πn

)

wheren is the number of the sides of the largest circle. Although, this number is

not constant, note that whenn goes to∞, it approaches a constant number

Sn→∞ −→1

2

To computeN , first note that after the first iteration, all vertices becomes3-

valence and in each iteration the number of vertices increases by3. In manifold

surfaces in which every vertex is3-valence, the following relationship exists be-

tween the number of vertices and edges:

3Vk = 2Ek. (16.1)

In this equation,Vk and Ek are the number of vertices and edges in iterationk

respectively. Since, in each iteration the number of vertices increases by3, the

number of edges must also increase by3 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( 1S)

=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 five 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 Chaikin’s algorithm to vertex trunca-

tion. We use Chaikin’s algorithm to determine the positions of the new vertices after

a cut operation, i.e., we cut each line from1/4 and3/4. Figure 16.14 shows five

iterations of this scheme when it is applied to uniform tetrahedron. Figure 16.15

shows the effect of five 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 beD = 1.5849.

Figure 16.14: A tetrahedron and5 successive vertex truncation operations applied

to the tetrahedron.

(A1) (A2) (A3) (B1) (B2)

Figure 16.15:(A1), (A2) and(A3) are a cube and two views of its smooth fractal

polyhedra that is created by5 successive operation of vertex truncation.(B1) is a

dodecahedron and(B2) is its smooth fractal counterpart created by5 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 first 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 first 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.

(A1) (A2) (B1) (B2)

Figure 16.16:(A1) is an octahedron and(A2) is its5 times vertex truncated version.

(B1) and(B2) are an icosahedron and its5 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,?].

(A1) (A2) (B1) (B2)

Figure 16.17:(A1) is a non-convex polyhedron with non-convex planar faces and

(A2) is its5 times vertex truncated counterpart.(B1) is another non-convex polyhe-

dron with non-convex planar faces and(B2) is its5 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 first subdivide a planar face

into a set of polygons with valence-3 vertices (see Figure 16.19.A) and applied a

(A1) (A2) (B1) (B2) (C1) (C2)

Figure 16.18:(A1) and(A2) are a deformed cube with non-planar faces and its 4

times vertex truncated version.(B1) is a genus-1 shape with 4 valent-5 vertices that

cause to construct non-planar faces in the first iteration and(B2) is its 4 times vertex

truncated version.(C1) and (C2) 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 oftiles that satisfy specific boundary condi-

tions to cover any quadrilateral mesh without any discontinuity or singularity.

3. Organize thetiles into one texture image file which is called atiled 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 specific 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 first step was to create triangular tiles that obey specific

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 difficult. (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 efficient, 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 files from exist-

ing images with a simple interface (see Figures 17.1 and 17.3) . Our texture image

files 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 asE andE1 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 efficient

algorithms for texture mapping. Figure 17.4(B) shows our numbering scheme. As

seen in this figure, we use0 instead ofE and1 instead ofE1. A counter-clockwise

walk starting from the 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 a900 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 difficult 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 file. However, if we use all possible tiles instead of a minimal set,

the organization problem greatly simplifies 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

first 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

instance1010 and0101 do not have to be rotated versions of each other. If we allow

1010 and0101 to be different then we can use our 2D texture space more efficiently

since having more variety of tiles helps to obtain better aperiodicity. A hand created

example is shown in Figure 17.5(B). In this figure, 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 ton 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 satisfied. The texture mapping algorithm consists of two procedures

(see Figure 17.6). The first procedureAssignBoundaries(G, n) guarantees that

boundary conditions are satisfied. This procedure randomly assigns0 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.

OnceAssignBoundaries(G, n) is completed, four boundary typese0, e1, e2, e3

are assigned to each quadrilateral of the meshG. Note that the sequencee0e1e2e3

is actually the name of the tile to be assigned to each quadrilateral. Since the name

of each tile also gives the tile’s position in the texture image file, 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 final result. The first template consists of two squares. The

edge that connects the two squares gives the desired boundary condition and the two

squares correspond to the0 and1 boundary types. We will call these images0XXX

andXX1X to precisely identify the location of the desired boundary types. Note

thatX is a place holder for undetermined boundary types. The second template is

used to define 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 final tiles. Therefore, we call such background imagesXXXX. Note

that for each tile a different background image is chosen from the region defined by

the second template.

To create each of the tiles in the tiled texture image, we composite the back-

ground imageXXXX and rotated versions of0XXX andXX1X, assigning an ap-

propriateα map to each image. LetABCD be the tile to be created whereA, B, C

andD are binary digits. The tile

ABCD = AXXXoverXBXXoverXXCXoverXXXDoverXXXX. is composited by

usingα maps.

To create an acceptable tile, the first step is to appropriately rotate0XXX and

XX1X. Remember that in our notation a900 counter-clockwise rotation of an im-

age corresponds to one cyclic shift operation. Thus, in order to create the tile1001

in Figure 17.11, imageXX1X must be shifted two times to get1XXX which cor-

responds to a1800 counter-clockwise rotation. Similarly, to getX0XX we need

to rotate0XXX 900 counter-clockwise,XX0X can be obtained by a1800 counter-

clockwise rotation of0XXX, and finallyXXX1 is a900 counter-clockwise rotation

of XX1X.

The second step is to assign appropriate opacityα values for each of these im-

ages. We compute opacity valueα = f1f2f3f4 as the product of four functions. Fig-

ure 17.10 shows the functions that are used to computeα map0XXX or 1XXX.

To compute opacity values for other images such asX0XX, rotated versions of

these functions are used. Note that if either one of these functions is0 in a region,

the foreground image will be transparent in that region. Functions,f1, f2 andf3,

guarantee that nearX boundaries the image becomes transparent. Functionf4 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 system as 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 file format. Similarly, the texture synthesis program creates a texture image in

a common image format such asjpeg and these image files can be exported to any

commercial software. As a proof of concept, we have created all final images and

animations in Maya1

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 significantly.

The examples above have one distinct boundary condition, but this concept can

be easily generalized ton distinct conditions by using four-digit2n-ary numbers.

A boundaryk will be represented by two boundary types that will be denoted by

2k and2k + 1 wherek = 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 first two digits give the column number and

1Catmull-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 supportn distinct conditions by adding only one additional line to the

AssignBoundariesprocedure and changing the equations inAssignTextureCoor-

dinates2.

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 algorithm such 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 final 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.

2In equations,e0 ande2 will be multiplied by2n instead of2 and the equations will be divided

by 4n2 instead of4.

Subroutine AssignBoundaries(G)

for each edgee in G do

i← rand() mod 2

e0 ← i

e1 ← (i + 1) mod 2

Comment: e0 ande1 are two integers representing boundary

types of two half-edges ofe

Subroutine AssignTextureCoordinates(G)

for each quadrilateralf in G do

for ∀i ∈ {0, 1, 2, 3} do

j ← b((i + 1) mod 4)/2cui ← (2e0 + e1 + bj/2c) /4

vi ← (2e2 + e3 + bi/2c) /4

Comment: ui, vi are texture coordinates of each corner off and

ei are boundary types assigned tof wherei = 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: A simple 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 artificially 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 tile1001 by compositing five 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 Refinement with

Topological Simplification

This chapter presents a theoretical framework for progressive refinement of man-

ifold meshes with topological simplification. We also show how to use the non-

intutive nature of the topology changes as an advantage and develop a theretical

framework for progressive refinement with topological simplification.

18.1 Introduction

Our goal in this paper is to develop a theoretical framework for progressive refine-

ment schemes with topological simplifications. Level-of-detail (LOD) representa-

tions have recently become popular in computer graphics [41, 46, 42, 51, 80, 49].

Among the LOD representations progressive refinement is particularly useful since

it allows continuous change [80, 49]. Although topological simplification can pro-

vide better simplification and efficient representation, there exists no framework

that provides both progressive refinement and topological simplification. Ignor-

239

ing topological simplification is not special to progressive meshes. In fact, ex-

cept one recent development (Hybrid meshes) [44] topological simplification is not

even considered in other LOD representations. Moreover, Hybrid meshes is a user-

assisted LOD approach and cannot automatically guarantee topological simplifica-

tion.

As an example of application of progressive refinement with topology simplifi-

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 refinement 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 refined into simplest

polyhedra that resemble the shape of the building or tree.

This example demonstrate progressive refinement with topology simplification

will definitely be beneficial for a wide variety of applications that includes games,

mesh data transmission, rendering.

In this paper, we develop a theoretical framework for progressive refinement

with topological simplification. We will demonstrate that topology changes are not

intuitive and therefore a great deal of care is necessary for handling topological

simplification. 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 significant 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 simplification 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 classified

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 simplified shapes. Instead, the simplification is described as a

continuous function. Because of this property a shape can gradually be simplified.

Gradual simplification 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

refinement [80]. In short, progressive representations offer an efficient, lossless and

continuous-resolution representation.

18.1.2 Topology Simplification

In order to talk about topology simplification we assume that initial meshes are

2-manifold and they stay 2-manifold in each stage of refirement 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 simplification 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 simplification does not require reducing of genus

or combining surfaces (i.e. combining shells1) in every stage of refinement. During

the refinement 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 simplification since in current graphics applications manifold

meshes that consists of huge number of separate surfaces are extremely common.

1In topology, a surface is a connected 2-manifold [177]. In solid modeling literature, it is often

called asshell[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 simplification can provide effi-

cient simplification. Consider a Sierpinsky tetrahedra that consists of infinite num-

ber (in practice, a huge number) of tetrahedra. A Sierpinsky tetrahedra cannot be

simplified 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

simplified into one tetrahedron. A simplified example is shown in Figure 18.1.

Figure 18.1: By allowing topology changes these 16 tetrahedra can be simplification

into one tetrahedron.

18.1.3 Topological Simplification under Progessive Refinement

The topological simplification can be useful regardless of the choice of refinement

approaches. Figures 18.2 and 18.3 show examples of topological simplification un-

der two different refinement approaches. As these two figures illustrate, progressive

refinement can provide a more natural looking simplification of topological fea-

tures. However, topology simplification under a progressive refinement scheme in-

troduces additional challenges that will not exist under hierarchical LOD schemes.

Figure 18.2: Hierarchical LOD with progressive refinement

Figure 18.3: Progressive refinement with topology simplification

Our approach will be extension to progressive meshes. Thus, we will first in-

troduce progressive mesh representations. LetM be an arbitrary triangular man-

ifold mesh that can be represented by rotation system of a graphG(E ,V) where

E = {e0, e1, . . . , em} is a set of edges and andV = {v0, v1, . . . , vk} is a set of

vertices.

A progressive representation (PM) of a manifold meshM is stored as a much

coarser power networkM0 together with a sequence ofn detailed records that in-

dicate how to incrementally refine the coarse power networkM0 exactly back into

the original power network such thatMn = M. 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 meshM thus defines a continuous

sequence of power networksM0,M1, . . . ,Mn of increasing accuracy, from which

the LOD approximation of any desired complexity can be efficiently retrieved.

Moreover, geomorphs (continuous shape changes) can efficiently constructed be-

tween any two of these power networks.

To create continuous sequence of manifold meshesM0,M1, . . . ,Mn, inverse

of VERTEXSPLIT operation, EDGE COLLAPSE, is used. Since initial mesh is tri-

angular, each EDGE COLLAPSE operation simplifies the mesh by eliminating two

triangles, one edge and two vertices.

One of the great power of progressive mesh framework is that each direction

(simplification and complication) requires only one type of operator. However, this

theoretical framework creates two problems for topological simplification.

1. Vertex split and edge collapse cannot change the topology2.

2. The current progressive refinement 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 simplifies 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.

2Moreover, 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 simplification 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. LetA0 be the initial

mesh. We first need to compute a series of offset surfacesA1,A2, . . . ,An. Here

Ak+1 will directly be computed fromAk. If the offset surface does not have any

self-intersection thenAk+1 will simply be progressively refined version ofAk. If

there is a self intersection, we will remeshAk+1 by changing the topology. We will

then apply the inverse of offset operation toAk+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 refinement 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-

finement. Of course, this is not desired. The initial positions of newly created and

final 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 simplification by using equidistance

shapes.

deformation that minimizes the changes of positions all the other vertices.

We will continue this process untilAk+1 becomes a genus-0 surface, preferably

a tetrahedron. ThenM0 ← An and inverse of the operations will be used to get

initial meshMn.

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

efficiently on all existing data structures for mesh modeling. Moreover, the new

theory enables us to develop very efficient 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] specifically 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 allow non-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 MERGEVERTICESoperator, 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 flexibility 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 specifically 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 difficult, 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 flexibility of the current modeling systems while providing high

efficiency 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 verifications 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 simplifications (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-

ification of the 2-manifold validity of triangulated mesh structures. Guibas and

Stolfi 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 Hoffmann’s algorithm to a general mesh, the mesh

must be first triangulated, while to apply Guibas and Stolfi’s algorithm, which is

applicable to general mesh structures, a mesh must be first 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

verification [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 efficiency.

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 first 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 specifically,

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 efficient 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 efficient 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 efficiency and reliability of

the current modeling technology.

rv2

rv3

rv4

rv1

rv6 rv7rv5

@@@e6

��e3

##e4 PPP

e5EEEE

e1

��

e8 TTT

e9

cce7 ��e10�

��e2

namee1e2

vstartv1v2

vendv2v5

fcwf1f3

fccwf2f4

ncwe6e7

pcwe4e8

nccwe5e9

pccwe3e10

where the faces are:f1 = {v1v3v2}, f2 = {v1v2v4},f3 = {v2v6v5}, f4 = {v2v5v7}.

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 pointv2 does not have a neighborhood homeomorphic to an open

disk). However, the right table in the figure is a valid winged-edge data structure

for the corresponding mesh. It is not difficult 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 verifi-

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 verification 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 verification of 2-manifold validity of mesh

structures.

Let G be a mesh on a 2-manifoldS. First note that since the mesh is cellular,

each connected component of the graphG corresponds to a unique surface inS

[10]. Since each point onS has a neighborhood homeomorphic to an open disk, if

one stands at a vertexv on S, then he can see in a small neighborhood ofv on S

that the edges fromv are cyclically ordered. Thus, two consecutive edges fromv

form aface cornerfor a face of the mesh. This induces two important concepts: (1)

each edge incident onv is given a “direction” starting fromv (note that a self-loop

at v then induces two directed edges of opposite directions fromv); and (2) these

directed edges fromv form a natural “rotation”. Ifv is an isolated vertex without

any incident edges, then since the meshG is cellular, the surface containingv must

be a genus 0 sphereS2. Note thatS2 − {v} is homeomorphic to an open disk

whose boundary degenerates into a single pointv, i.e., v is a valid cellular mesh

on the sphereS2. The sphereS2 will be called apoint-spherecontaining the vertex

v. Since the isolated vertexv has no incident edges, we define thatv has aempty

rotation that is an empty list of directed edges.

Thus, the meshG on the 2-manifoldS induces a “rotation system” on the cor-

responding graphG, in which each vertex is given a unique rotation of directed

edges. Based on this observation, we introduce the following important concept.

Definition Let G be a graph ofn vertices. Each edge inG induces twodirected

edgesof opposite directions. Arotation at a vertexv of G is a cyclic ordering of

the directed edges fromv (an isolated vertex without incident edges always has the

empty rotation). Arotation systemof the graphG consists of a set ofn rotations,

each for a vertex inG.

Remark 1. The above definition is an extension of the same concept defined

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(〈u0, w0〉) {* 〈u0, w0〉 is a directed edge *}

1. trace〈u0, w0〉;2. let〈u, w〉 be the directed edge next to〈w0, u0〉 in the rotation atw0, whereu = w0;

3. while (〈u, w〉 6= 〈u0, w0〉) do

let 〈w, x〉 be the directed edge next to〈w, u〉 in the rotation atw;

trace〈u, w〉; 〈u, w〉 = 〈w, x〉.

Algorithm Facing (ρ(G)) {* ρ(G) is a graph rotation system *}

1. for each isolated vertexv without incident edges inG do

construct a face with a degenerated boundaryv;

2. while there is a directed edge〈u0, w0〉 not traced yetdo FaceTrace(〈u0, w0〉).

Figure 19.4: Face reconstruction based on graph rotation systems

Remark 2. Note that in the definition 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 specified.

Remark 3. If the two end-verticesu andw 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 ase to refer to a directed edge. For a directed edge

e, we also denote byr(e) the corresponding reversed directed edge. Therefore, if

e = 〈u, w〉, thenr(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.1A mesh structure defines a valid 2-manifold if and only if it uniquely

specifies 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 final 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 efficient 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. Efficient 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〉,whereu andw 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 modification, 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]. Briefly 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

algorithmFaceTraceon the corresponding face in the original mesh. In the edge-

based winged-edge structure, we only need to re-interpret the componentsvstart,

vend, fcwandfccw, and exchange the vertex components and the face components.

Note that the componentsncw, nccw, pcw, andpccwprovide sufficient 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 edgese = 〈u, w〉 andr(e) = 〈w, u〉 of the edgee = [u, w];

2. if (the face cornerscor(e′1, e′2) andcor(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 nodef 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 )) andf ′′ = (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 cornerscor(e′1, e′2) andcor(e′′1 , e′′2 ) belong to the two different faces

f1 = (r(e′1), e′2, d′1, . . . , d′s) andf2 = (r(e′′1 ), e′′2 , d′′1 , . . . , d′′t ) *}delete the face nodesf1 andf2 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. find the two directed edgese andr(e) of the edgee in the face list;

2. if (the two directed edgese andr(e) belong to two different faces

f ′ = (r(e), e′2, d′1, . . . , d′s, r(e′′1 )) andf ′′ = (e, e′′2 , d′′1 , . . . , d′′t , r(e′1));

then delete the face nodesf ′ andf ′′ 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 nodee from the edge list;

else {* the two directed edgese andr(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 nodef from the face list;

add two new face nodes to the face list:

f1 = (r(e′1), e′2, d′1, . . . , d′s) andf2 = (r(e′′1 ), e′′2 , d′′1 , . . . , d′′t );

delete the edge nodee 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 theedge algebramodel 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 modifications 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 first show how to reconstruct faces on a given graph rotation system. Letρ(G)

be a rotation system of the graphG. 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 algorithmFacing 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 edgee is not traced, then the main algorithm will call the subroutine

FaceTraceon e, which will trace the edge. Thus, it suffices to show that no directed

edge is traced more than once.

Consider the subroutineFaceTrace(e0), wheree0 = 〈u0, w0〉. Let e = 〈u, w〉 be

Subroutine FaceTrace(〈u0, w0〉) {* 〈u0, w0〉 is a directed edge *}

1. trace〈u0, w0〉;2. let〈u, w〉 be the directed edge next to〈w0, u0〉 in the rotation atw0, whereu = w0;

3. while (〈u, w〉 6= 〈u0, w0〉) do

let 〈w, x〉 be the directed edge next to〈w, u〉 in the rotation atw;

trace〈u, w〉; 〈u, w〉 = 〈w, x〉.

Algorithm Facing (ρ(G)) {* ρ(G) is a graph rotation system *}

1. for each isolated vertexv without incident edges inG do

construct a face with a degenerated boundaryv;

2. while there is a directed edge〈u0, w0〉 not traced yetdo FaceTrace(〈u0, w0〉).

Figure 19.6: Face reconstruction based on graph rotation systems

a directed edge and lete′ = 〈u, x〉 be the directed edge right beforee in the rotation

at the vertexu. If e is traced byFaceTrace(e0) and e 6= e0, then it is clear by the

algorithmFaceTrace(e0) that the directed edger(e′) = 〈x, u〉 must be also traced

by FaceTrace(e0), right before the tracing of the directed edgee. On the other hand,

if e = e0, then the directed edgee = e0 is traced at beginning ofFaceTrace(e0) and

FaceTrace(e0) stops when the directed edgee = e0 is encountered the second time.

Thus, whene = e0, the last edge traced byFaceTrace(e0) 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 algorithmFacing. Suppose thate is the directed edge that receives the ear-

liest second time trace. First note that the second time trace on the directed edgee

cannot be the first edge trace of a subroutine executionFaceTrace(e0): in this case

e would bee0 and the second time trace one is the first edge trace ofFaceTrace(e0),

but whenFaceTrace(e0) is called, the directed edgee0 should have not been traced

at all.

Suppose that the directed edgee receives the first time trace inFaceTrace(e1),

and receives the second time trace inFaceTrace(e2). Let e = 〈u, w〉, and lete′ =

〈u, x〉 be the directed edge right beforee in the rotation at the vertexu. We consider

two cases.

If e1 6= e2, then by the above remarks, the directed edger(e′) = 〈x, u〉 also

receives a trace inFaceTrace(e1). Now since the second time trace one cannot be

the first edge trace inFaceTrace(e2), the second time trace one in FaceTrace(e2)

must follow a trace on the directed edger(e′). Thus, the directed edger(e′) would

receive the second time trace earlier thane.

If e1 = e2, then the directed edgee cannot bee1 since the subroutineFaceTrace(e1)

stops immediately when the edgee1 is encountered the second time. Thus, the first

time trace and the second time trace on the directed edgee must both follow traces

on the directed edger(e′) = 〈x, u〉. This, again, shows that the directed edger(e′)

would receive the second time trace before the second time trace on the directed

edgee.

Thus, in any case, we would derive that the directed edger(e′) would receive

the second time trace before the second time trace on the directed edgee. This

contradicts the assumption that the directed edgee 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 executionFaceTrac(e0) 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 algorithmFacing picks untraced edges should not affect the output of the

algorithm.

Lemma A.2 On a directed edgee1, the subroutineFaceTrace(e1) produces a se-

quenceS of directed edges that form a polygonal closed walk. Moreover, for any

directed edgee2 in the sequenceS, the subroutineFaceTrace(e2) on e2 will produce

the same polygonal closed walk.

PROOF. By the algorithm, if a directed edge〈u, w〉 is traced inFaceTrace, 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 vertexw. Moreover, the first edge

〈u, w〉 traced byFaceTracemust be the directed edge right after the last directed

edge traced byFaceTracein the rotation at vertexu. 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 algorithmFacing will

produce a unique set of point-spheres, each for an isolated vertex inG, 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 algorithmFacingspecifies a unique mesh structure by giving the vertex set

(that is the vertex set of the graphG), the edge set (that is the edge set of the graph

G), and the face set (that is given by the algorithmFacing). 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 first discuss two operations on

graph rotation systems.

Let v be a vertex in the graphG. For any two consecutive directed edgese1 =

〈v, u〉 ande2 = 〈v, w〉 in the rotation atv, the two directed edgesr(e1) ande2 are

consecutive on the boundary of a facef constructed by the algorithmFacing. we

say that the directed edgese1 ande2 form aface corner(of the facef ) atv, written

either ascor(e1, e2) or cor(u, v, w). In casev is an isolated vertex without incident

edges, we define thatv has a unique face cornercor(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 edgese1 ande2 can even be the same directed

edge (i.e., when the vertexv is of valence1).

Let ρ(G) be a rotation system of a graphG, and lete = [u, w] be an edge in

G. By deleting the edge fromρ(G), we obtain naturally a rotation system for the

graphG − e. More formally, lete′ = 〈u, w〉 and e′′ = 〈w, u〉 be the two directed

edges induced from the edgee in ρ(G), and suppose that the rotations inρ(G) at

u andw are (recall that the directed edges are cyclically ordered in the rotation at

each vertex):

u : e′e′1e′2 · · · e′n and w : e′′e′′1 e

′′2 · · · e′′m

wheree′i ande′′j are directed edges. Then the resulting rotation system after deleting

e from ρ(G) has the identical rotation at each vertexx 6= u, w, and atu andw, the

rotations are

u : e′1e′2 · · · e′n and w : e′′1 e

′′2 · · · e′′m

Conversely, suppose in the rotation systemρ(G), the directed edgese′1 and e′2

form a face corner at a vertexu, and the directed edgese′′1 ande′′2 form a face corner

at a vertexw, then we caninserta new edgee = [u, w] between the face corners

cor(e′1, e′2) andcor(e′′1, e

′′2) in the rotation systemρ(G) to make a rotation system

for the graphG + e. More formally, suppose that in the rotation systemρ(G), the

rotations at the verticesu andw are

u : e′1e′2 · · · e′n and w : e′′1 e

′′2 · · · e′′m

respectively. After inserting the edgee between the face cornerscor(e′1, e′2) and

cor(e′′1, e′′2), we obtain a rotation systemρ(G + e) for the graphG + e that has the

identical rotation at each vertexx 6= u, w, and at the verticesu andw, the rotations

are

u : e′1e′e′2 · · · e′n and w : e′′1 e

′′e′′2 · · · e′′m

wheree′ = 〈u, w〉 ande′′ = 〈w, u〉 are the two directed edges of the edgee (or more

precisely, we actually inserted the directed edgee′ to the face cornercor(e′1, e′2) and

the directed edgee′′ to the face cornercor(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 graphG hasn vertices.

If the graphG has no edges, then all vertices ofG are isolated. Thus, the algo-

rithm Facinguniquely producesn point-spheres, which form a valid 2-manifold on

whichρ(G) gives a valid cellular mesh structure.

Now assume that the graphG hasm > 0 edges. Lete = [u, w] be an edge in

G (u andw may belong to the same vertex ife is a self-loop). Suppose that in the

rotation systemρ(G), the rotations at the verticesu andw are:

u : e′1ee′2 · · · e′n and w : e′′1r(e)e

′′2 · · · e′′m

where e = 〈u, w〉 and r(e) = 〈w, u〉 are the two directed edges of the edgee.

By deleting the edgee = [u, w] in the rotation systemρ(G), we obtain a rotation

systemρ(G− e) for the graphG− e of m− 1 edges. In particular, the rotations at

the verticesu andw in the rotation systemρ(G− e) become

u : e′1e′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

Facinguniquely gives a valid 2-manifold structureS−. LetF− be the set of faces in

the meshρ(G − e). Let f1 ∈ F− be the face containing the face cornercor(e′1, e′2)

and letf2 ∈ F− be the face containing the face cornercor(e′′1, e′′2). By inserting the

edgee = [u, w] between the face cornerscor(e′1, e′2) andcor(e′′1, e

′′2) in ρ(G−e), we

get back the rotation systemρ(G). We show thatρ(G) also gives a valid 2-manifold

structure.

Apply the algorithmFacing on the rotation systemρ(G). Note that since the

only difference betweenρ(G − e) andρ(G) is at the face cornerscor(e′1, e′2) and

cor(e′′1, e′′2), the algorithmFacing on ρ(G) will produce all faces inF− − {f1, f2}.

Since the set of faces produced byFacing is independent of the order of the edges,

we can assume that the algorithmFacingonρ(G) first constructs all faces inF− −{f1, f2}. Note that after the construction of these faces, the only directed edges that

have not been traced are those on the boundaries of the facesf1 andf2, and the two

directed edgese andr(e) induced by the edgee = [u, w]. There are two possible

cases.

Case 1. The two face cornerscor(e′1, e′2) andcor(e′′1, e

′′2) belong to the same

face inρ(G− e), that isf1 = f2. Let the boundary of the facef1 = f2 be

f1 = f2 = (r(e′1), e′2, d

′1, . . . , d

′s, r(e

′′1), e

′′2, d

′′1, . . . , d

′′t )

whered′i andd′′j are directed edges. Since the rotations at any vertexx 6= u, w are

identical in the rotation systemsρ(G− e) andρ(G), and the rotations atu andw in

ρ(G) are

u : e′1ee′2 · · · e′n and w : e′′1r(e)e

′′2 · · · e′′m,

the procedureFaceTrace(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 procedureFaceTrace(e) onρ(G) produces the face

f ′′ = (e, e′′2, d′′1, . . . , d

′′t , r(e

′1))

(see the left figure in Figure 19.7 for illustration). Therefore, the difference of the

uHHYe′2CCOd′1

o��d′s��*

r(e′′1 )wHHje′′2

CCWd′′1

o

��d′′t

��r(e′1)

e -

HHYe′2CCOd′1

o��d′s��*

r(e′′1 )6

e

HHje′′2

CCWd′′1

o

��d′′t

��r(e′1)?

r(e)

u

��d′s

��r(e′1)HHYe′2CCOd′1

∼ ∼

��d′′t��*

r(e′′1 )wHHje′′2

CCWd′′1∼ ∼

e -

��d′s

��r(e′1)HHYe′2CCOd′1

∼ ∼

��d′′t��*

r(e′′1 )

?

r(e)

HHje′′2

CCWd′′1∼ ∼

6

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 facef1 = f2 in ρ(G − e) is replaced by

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

that the facef1 = f2 can be obtained by “pasting” the facesf ′ andf ′′ along the

edgee. Therefore, adding the facef1 = f2 to the mesh and adding the two facesf ′

andf ′′ to the mesh should give the same structure. Since the mesh constructed from

ρ(G−e) represents the valid 2-manifoldS−, we conclude that the mesh constructed

from ρ(G) should also represent the same 2-manifoldS−. In fact, it is not difficult

to see that the meshρ(G) can be obtained from the meshρ(G − e) by adding a

crossing edgee on the facef1 = f2. Thus, in this case, the meshρ(G) andρ(G−e)

represent the same manifold. In other word, inserting the edgee to ρ(G − e) does

not change the manifold topology.

Case 2.The two face cornerscor(e′1, e′2) andcor(e′′1, e

′′2) belong to two different

facesf1 andf2, f1 6= f2, in ρ(G− e). Let the boundaries of the two facesf1 andf2

be

f1 = (r(e′1), e′2, d

′1, . . . , d

′s) and f2 = (r(e′′1), e

′′2, d

′′1, . . . , d

′′t )

Again since the rotation systemρ(G) is obtained from the rotation systemρ(G− e)

by inserting the edgee between the two face cornerscor(e′1, e′2) andcor(e′′1, e

′′2),

when the procedureFaceTrace(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-d

′1 ∼ -d

′s-r(e

′1)

?

e

�e′′2

�d′′1

∼�d′′t

�r(e′′1 )

6

r(e) -e

ie′′2Id′′1 )r(e′′1 )

d′′t

Rd′sqr(e′1)

1e′2�d′1

∼

Figure 19.8: Pasting the two directed edges of an edge to get a cylinder

(see the right figure in Figure 19.7 for illustration.) Note that the boundary of the

facef has contained all directed edges on the boundaries of the facesf1 andf2, plus

the two directed edges of the edgee. Therefore, the difference between the mesh

ρ(G) and the meshρ(G−e) is that the facesf1 andf2 in ρ(G−e) are replaced by the

facef in ρ(G). Now if we past along the edgee in the facef , we will get a cylinder

Y with two open ends. (See Figure 19.8 in which we have re-drawn the facef then

pasted along the two directed edgese andr(e).) Observe that if we traverse the two

open ends of the cylinderY , we get exactly the boundary traversings of the facesf1

andf2 in ρ(G − e). Therefore, the structure represented by the meshρ(G) can be

obtained from the 2-manifoldS− represented byρ(G − e) as follows: first cut the

two facesf1 andf2 off along their boundaries inS−, then on the resulting structure

past the boundaries of the two open ends of the cylinderY along the boundaries

of the two facesf1 andf2. 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 facesf1 andf2 belong to the same surface in the manifold – in

this subcase, inserting the edgee to ρ(G− e) (i.e., running a tube between the two

facesf1 andf2) adds a handle to the surface, thus the number of surfaces in the

manifold is unchanged while the manifold genus is increased by1; (2) the faces

f1 andf2 belong to different surfaces in the manifold – in this subcase, inserting

the edgee connects the two surfaces by a tube, thus the number of surfaces in the

manifold is decreased by1 while the manifold genus is unchanged. In any case,

inserting the edgee 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 defines a valid 2-manifold if and only if it uniquely

specifies 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 algorithmE-Validity presented in Fig-

ure 17.11 is re-given in Figure 19.9.

Theorem 4.2 If a winged-edge structureA[1..m] can pass the test of the algorithm

E-Validity in Figure 19.9, thenA[1..m] represents a valid 2-manifold structure.

Moreover, the test algorithm runs in timeO(m).

PROOF. An edge nodeA[e] uniquely induces two directed edges〈A[e].vstart, A[e].vend〉and〈A[e].vend, A[e].vstart〉. Thus, Validity Rule 1 is satisfied.

For each edge nodeA[e], the componentA[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 componentA[e].ncw uniquely induces the directed edge next

to the directed edge〈A[e].vend, A[e].vstart〉 in the rotation atA[e].vend. Therefore,

Subroutine VertexTrace(v0, e0) {* the vertexv0 is an end of the edgee0 *}

1. if (A[e0].vstart= v0) then e = A[e0].nccw else e = A[e0].ncw;

2. while (e 6= e0) do

2.1. supposee = [v0, w];

2.2. if (the directed edge〈v0, w〉 has been marked)then Stop(‘not manifold’);

2.3. mark the directed edge〈v0, w〉;2.4. if (A[e].vstart= v0) then e = A[e].nccw else e = A[e].ncw;

3. supposee0 = [v0, w0]; mark the directed edge〈v0, w0〉.

Algorithm E-Validity ( A[1..m]) {* A[1..m] is a winged-edge structure *}

for each edge nodeA[e] do

1. u = A[e].vstart; w = A[e].vend;

2. if (u is not marked){ then marku; 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 { markw; 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 structureA[1..m] defines 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 vertexv. 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 edgee, 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 vertexv into a cyclic ordering: (1) a directed edgee is

next to two different directed edgese1 ande2, i.e., NEXT(e1) = NEXT(e2) = 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 identified effectively

by the algorithmE-Validity , as follows. If for two different directed edgese1 and

e2, we have NEXT(e1) = NEXT(e2) = e, then the directed edgee (or some other

directed edge) will be encountered again after its first marking. Thus, step 2.2 in the

subroutineVertexTrace will detect this and correctly report an error. If the NEXT

operation arranges the directed edges at a vertexv into more than one disjoint cycli-

cally ordered lists, then after the first call on the subroutineVertexTrace(v, e), the

vertexv is marked while some directed edges fromv are not marked. This situation

will be detected by either step 2 or step 3 of the main algorithmE-Validity , which

will report correctly the error.

On the other hand, if the componentsncwandnccwcorrectly describe a valid

graph rotation system, then each execution of the subroutineVertexTrace(v, e) will

mark the vertexv as well as all directed edges fromv, which can in fact also pro-

duce the cyclic order of the directed edges fromv (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 algorithmE-Validity .

Thus, if the winged-edge structureA[1..m] passes the test ofE-Validity , then

the componentsvstart, vend, ncwandnccwof 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 edgee, the edge nodeA[e] can be accessed

in constant time (this condition can be easily met if the edge nodes are arranged

in an arrayA[1..m] where the edge names are given by the array indices), then

the algorithmE-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 algorithmE-Validity is bounded by

O(m + n) = O(m), wherem is the number of edges andn is the number of ver-

tices in the winged-edge structure.

Bibliography

[1] A. V. A HO, 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

atwww-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 simplification,Ph.D. Dis-

sertation, Computer Science Department, Carnegie Mellon Univ., CMU-CS-

99-105, May 1999.

[9] J. L. GROSS ANDT. 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-

GRAPH’03(Art and Design Sketch), to appear, San Diego, CA (2003).

[14] M. M ANTYL A, Boolean operations on 2-manifolds through vertex neighbor-

hood classification,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] UNIGRAPHICSSOLUTIONS 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-

GRAPH’2000 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 JournalVolume 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 Acadia’2000, 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 Scientific Definitions”, 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. Schroder, editor,Subdivision for Modeling and Animation,

ACM SIGGRAPH’2000 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. Mantyla, 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 International’99, (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 Pacific Conference

on Computer Graphics and Applications, (PG’2000), (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, SIGGRAPH’2003, 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 Surfaces’96,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, “Simplification 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 Refinement”,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 Refinement 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 A, An Introduction to Solid Modeling, Computer Science Press,


[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 ModelingVol-

ume 5, No 2, pp. 149-177.

[57] G. Barequet and S. Kumar, “Repairing CAD models”, inProceedings of IEEE

Visualization’97, (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”, in44th

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. Stolfi, “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, “Efficient, 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”, Master’s 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 classification”,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”, inProceedings 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”, inProceedings 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. Schroder, co-editors,Subdivision for Modeling and Animation,

ACM SIGGRAPH’99 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

ISCIS’02, 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 International’2002

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”, Master’s 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.


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. Schroder, “Composite primal/dual√

3-subdivision

schemes”,Computer Aided Geometric Design, CAGD20, 3, 2003, 135–164





[118] D. Zorin and P. Schroder, “A Unified Framework for Primal/Dual Quadrilat-

eral Subdivision Schemes”,Computer Aided Geometric Design, CAGD18, 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”, inProceedings of

IEEE Visualization’97, (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. Gueziec, 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. MANTYL A, An Introduction to Solid Modeling, Computer Science Press,


[128] T. M. Murali and T. A. Funkhouser, “Consistent solid and boundary repre-

sentations from arbitrary polygonal data”, inProceedings 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-SetsProceedings of the fifth ACM symposium on Solid modeling

and applicationspp. 31 - 41, 1999

[131] D. Zorin and P. Schroder, co-editors,Subdivision for Modeling and Anima-

tion, ACM SIGGRAPH’2000 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 ModelingVol-

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,”Pacific 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 ModelingVolume 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 Mobius II), Barnes and Nobles Books, New York,

1994.





[146] J. L. Gross and T. W. Tucker,Topological Graph Theory, Wiley Interscience,

New York, 1987.


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 Pacific Conference

on Computer Graphics and Applications, (PG’2000), (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,

(SMI’01), (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-

GRAPH’2001, 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,(SMI’02), (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 ofGraphical 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 Surfaces’96,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.fltk.org/



[174] M. Forsyth, “Shelling and Offsetting Bodies”,Proceedings of Solid Model-

ing’95, 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. MANTYL A, An Introduction to Solid Modeling, Computer Science Press,


[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 Pacific 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. Schroder, co-editors,Subdivision for Modeling and Anima-

tion, ACM SIGGRAPH’2000 Course Notes no. 23, July, 2000.

ergun akleman- topological mesh modeling

Documents