Topologically Robust Mesh Modeling: Concepts, Data Structures, and Operations

Transcription

1 1 Topologically Robust Mesh Modeling: Concepts, Data Structures, and Operations JIANER CHEN and ERGUN AKLEMAN Abstract Modeling 2-manifold meshes with a simple user interface is an important problem in computer graphics and computer aided-geometric design because certain widespread used modeling operations, such as the popular subdivision algorithms require specifically 2-manifold structures and because modeling non-manifold structures greatly complicates modeling algorithms. Unfortunately, most current modeling systems do not guarantee the 2-manifold structure and can introduce nonmanifold structures. In this paper, we propose a new vertexbased representation for mesh structures and give a formal proof that this representation characterizes precisely 2-manifold structures. Based on this theoretical result, we identify a group of simple validity rules, and show that the validity of 2-manifold structures can actually be tested very efficiently on most existing data structures for mesh modeling, including the adjacency list structure in computer graph algorithms, the winged-edge structure by Baumgart, the half-edge structure by Mäntylä, and the quad-edge structure by Guibas and Stolfi. A new data structure, the DLFL structure, and a new complete set of mesh modeling operations are also proposed. We show that the new proposed data structure and mesh modeling operations are more intuitive, more efficient, and more user-friendly compared with those proposed in the literature. Index Terms mesh, shape modeling, topological robustness, topological graph theory I. INTRODUCTION MESHES, which generalize polyhedra by allowing nonplanar faces, are one of the most commonly used objects in computer graphics [15], [17]. Modeling 2-manifold meshes with a simple user interface is an important problem in computer graphics and computer aided geometric design. Modeling with 2-manifolds has its obvious advantages. First, dealing with non-manifold structures greatly complicates modeling algorithms [15], [16]. Moreover, certain widespread used modeling operations, such as the popular subdivision algorithms [21], require specifically 2-manifold structures. For instance, the top-of-line modeling system MAYA may crush when applying subdivision operations on a mesh structure that is not a valid 2-manifold. Conceptually, a mesh structure on a 2-manifold consists of three Primary components: the vertex set, the edge set, and the face set, plus nine adjacency relationships among these components (e.g., the face-vertex adjacency relationship specifies for each face the adjacent vertices. Some of the adjacency relationships are redundant and can be derived This work was supported in part by the National Science Foundation under the Grant CCR J. Chen is with the Department of Computer Science, Texas A&M University, College Station, TX chen@cs.tamu.edu. E. Akleman is with the Department of Architecture, Texas A&M University, College Station, TX ergun@viz.tamu.edu. from the other adjacency relationships [19]. There has been extensive research in the literature on how effectively and efficiently the mesh components and adjacency relationships can determine the corresponding surface or solid, and in particular, on what kind of adjacency relationships will ensure the 2-manifold structure of the corresponding surface [13], [15], [17], [19]. A number of data structures have been proposed for representations for mesh structures, in particular for 2-manifold mesh structures. Some of these data structures are facebased in which mesh faces are explicitly given in consistent and oriented directions [6], [18], [19], while others are edge-based in which adjacency relationships around each edge are given. The most well-known edge-based representation is Baumgart s winged-edge structure [7]. Many variants and alternatives of the winged-edge structure have been proposed since then, including Braid-Hillyard-Stroud s extended winged-edge structure [8], Yamaguchi and Tokieda s bridge-edge structure [20], Weiler s edge-based structure [19], Mäntylä s half-edge structure [17], Guibas and Stolfi s quadedge structure [13], Hanrahan s face-edge structure [14], and others. Another important issue is the set of operations applied on a mesh structure. It is well-known that the set operations, which are the most commonly used operations in solid modeling, may result in structures that are not valid 2-manifolds [15]. Mäntylä [17] studied the Euler operations and proved that they form a complete set of primitives for modeling 2- manifold structures. That is, every valid 2-manifold can be constructed using a finite sequence of Euler operations, and Euler operations applied to a valid 2-dimensional manifold result in only valid 2-dimensional manifold. Guibas and Stolfi [13] proposed an operation splice together with a primitive for creation of isolated edges based their quad-edge structure, and showed that the operations also form a complete set of primitives for modeling 2-manifold structures. There have also been other researches in this direction [15], [17]. Certain criteria have been proposed for evaluating the quality and performance of a mesh modeling schema [15], [17]. The criteria include, among the most important ones, the validity (are the representations always for valid 2-manifold structures?, describability (are the representations and operations simply describable?, completeness of the operations (do the operations result in all and only all valid representations?, and computation efficiency and effectiveness (how efficient and effective are the algorithms for the operations and representations? In this paper, we will further study mesh modeling structures in terms of the above criteria. We will be mainly focusing

2 2 on the study of the topological integrity and coordinate free operations on the structures. Instead of following the existing mesh structure representations that are in general face-based or edge-based, we consider a vertex-based representation, the graph rotation systems studied in the classical topological graph theory [12]. We verify that graph rotation systems provide a necessary and sufficient condition for a mesh structure to represent valid 2-manifold structures. That is, every 2-manifold can be represented by a graph rotation system and every graph rotation system represents a valid 2- manifold. This theoretical result greatly simplifies the process of verification of validity of a mesh structure for representing a 2-manifold for the existing mesh presentations such as the winged-edge structure [7] and the half-edge structure [17]. Three new data structures, which are vertex-based, edgebased, and face-based, respectively, are studied for the representation of graph rotation systems. We also propose a single topological operation, edge insertion/deletion, together with a single primitive for creation of an isolated vertex, on the graph rotation system. We show that these operations form a complete set of modeling primitives for 2-manifold mesh modeling. These new data structures and operations are compared with the previously existing data structures and operations proposed in the literature. We show that our new structures and operations are simpler, from the viewpoint of both theoretical concepts and practical implementation. This will greatly increase the user friendliness when a interactive modeling system is built up based on our structures. Also, we show that our structures and operations permit extremely efficient and effective implementation, which is also important in an interactive modeling system. A number of interesting figures will be demonstrated which were constructed by an interactive modeling system developed based on our structures proposed in this paper. II. PRELIMINARIES A 2-manifold (or more precisely, a 2-dimensional manifold is a topological space where every point has a neighborhood topologically equivalent, i.e., homeomorphic to an open disk in the 2-dimensional Euclidean space. A 2-manifold is orientable if it does not contain a Möbius band [12]. In this paper, we will assume, unless explicitly stated, that all 2-manifolds in our discussion are orientable 2-manifolds. A connected 2-manifold is called a surface. Thus, a 2-manifold in general consists of a number of surfaces. An example of a surface is a sphere in the 3-dimensional Euclidean space. By Euler s Characteristic Theorem [12], each surface is homeomorphic to the sphere with zero or more handles (or equivalently, homeomorphic to the surface of a solid with zero or more holes. The number of handles on the sphere (or the number of holes on the solid is called the genus of the surface. The genus of a 2-manifold is the sum of genera of its component surfaces. A mesh on a 2-manifold specifies an embedding of a graph on the 2-manifold, or more formally, a oneto-one continuous mapping from the graph to the 2- manifold. The graph does not have to be necessarily Fig. 1. vend ncw pccw fcw name fccw A edge node in the winged-edge structure pcw vstart nccw connected. Multiple edges (i.e., more than one edge connecting the same pair of vertices and selfloops (i.e., edges with both end at the same vertex are allowed. For most purposes, it is natural to abuse the terminology by referring to the mesh as the graph. The vertices and edges of the mesh are the corresponding vertices and edges of the graph, and each connected component of plus the bounding edges in is called a face of the mesh. The mesh is cellular if each connected component of is homeomorphic to an open disk in. Non-cellular meshes have also been studied in the literature but the corresponding modeling algorithms are more complicated [15], [17]. In this paper, we only consider cellular meshes. For a cellular mesh on a 2-manifold of genus, if the number of connected components, the number of vertices, the number of edges, and the number of faces of are,,, and, respectively, then Euler-Poincare Theorem [17] relates these parameters by "!$#%&'(. Let be a mesh on a 2-manifold. Because for each point on there is a neighborhood homeomorphic to a 2- dimensional open disk, at each vertex of on the 2-manifold, the edges incident on are cyclically ordered (in, say, the counterclockwise order. In particular, for the edges incident on the vertex, we can talk about the edges that are after or before a given edge. This order has turned out to be extremely important in representing a 2-manifold mesh. The classical winged-edge data structure proposed by Baumgart [7] for mesh representations was essentially developed based on this observation. Formally, the main component of a winged-edge data structure is a list of edge nodes. Each edge node consists of nine components: (name, vstart, vend, fcw, fccw, ncw, pcw, nccw, pccw, where name is the name of the edge vstart and vend are the starting and ending end-vertices of the edge (which thus give a direction to the edge fcw and fccw indicate the left face and right face of the edge when traversing along the edge direction ncw and pccw give the next edges in the faces fcw and fccw, respectively, when traversing along the edge direction and pcw and nccw give the next edges in the faces fcw and fccw, respectively, when traversing along the reversed direction of the edge. See Figure 1 for an illustration. Thus, the winged-edge structure is edge-based, which describes the mesh structure in terms of the adjacency information on each edge of the mesh. An adaptation of the wingededge structure is the half-edge data structure [17], which is a hierarchical data structure. The major difference between the half-edge data structure and other structures is the introduction of the concept of half-edges. A half-edge describes one-side of an edge of the mesh, thus is uniquely associated with a face

3 3 of the mesh. A half-edge node consists of references to the face, to its starting vertex, 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. Guibus and Stolfi [13] studied mesh structure by defining an algebra on the edges of a mesh and its dual (thus, it works specifically for cellular meshes only. Each edge can be given a direction along which the edge is traversed, and an orientation by which the left side and right side of the edge are well-defined when traversing the edge along the given direction on the 2-manifold. Thus, each edge has four different directed and oriented versions. Each directed and oriented edge has four attributes: the two end-vertices Org and Dest (equivalent to vstart and vend in the wingededge structure, and the two faces Left and Right on the two sides of the edge on the 2-manifold (equivalent to fcw and fccw in the winged-edge structure. An edge algebra is introduced by defining three functions Flip, Onext, and Rot on the set of the directed and oriented edges, where Flip flips the orientation of an edge, Onext gives the next edge of an edge based on its Org, in counterclockwise order in terms of its orientation (thus is similar to nccw in the wingededge structure and Rot rotates the edge (which is a little more technical and we omit its detailed explanation. Both orientable 2-manifolds and nonorientable 2-manifolds can be described by edge algebra. Moreover, an edge algebra gives the structures for both the primary mesh and its dual. A data structure, quad-edge structure, has been introduced to represent the edge algebra for a mesh structure [13]. When concentrating on orientable 2-manifolds, as most modeling applications do, the edge algebra and its corresponding quad-edge structure can be simplified. In particular, since all edges of a mesh on an orientable 2-manifold have consistent orientations, the edge orientations need not be given explicitly. Thus, each edge of the mesh has only two different directed versions. Again three functions Onext, Sym, and Dual are needed to define an edge algebra on the edge set of a mesh (if we do not need the description of the dual mesh, then the function Dual can also be omitted. In this case, each edge node in the corresponding quad-edge structure contains four pointers to essentially the four edge nodes corresponding to the edge nodes ncw, pcw, pccw, and nccw in the winged-edge structure. Another issue is the operations on mesh structures. Mäntylä [17] proposed Erler operations. Guilbas and Stolfi [13] defined splice operation. We say that a set of operations is complete for 2-manifold modeling if every 2-manifold structure can be constructed by a finite sequence of operations in this set, and when an operation in the set is applied to a valid manifold, the result remains a valid 2-manifold. III. VALIDITY: A NEW VERTEX-BASED REPRESENTATION Given a mesh structure, does it represent a valid 2-manifold structure? This problem has become fairly important. First, certain popular modeling operations require specifically that Fig. 2. name vstart vend where the faces are: fcw fccw ncw pcw nccw "! # $, %! # #$, &"! $, '%! $. A non-manifold under winged-edge structure pccw the underlying mesh represent a valid 2-manifold. On the other hand, a mesh structure, in particular an initial mesh structure, is in general constructed by a CSG system or solid modeling system, which can easily generate non-manifold structures. Most existing representations and data structures may describe non-manifold structures. For example, the top shape in Figure 2 is not a 2-manifold (the point does not have a neighborhood that is homeomorphic to an open disk. However, the table given in the bottom 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 2. The problem of verifying 2-manifold validity of a given mesh structure has been studied by a number of researchers. Hoffmann presented an algorithm [15] for verification of 2- manifold validity of triangulated mesh structures. Guibas and Stolfi gave a set of rules for a given edge algebra to verify whether the edge algebra describes a valid 2-manifold structure [13]. Unfortunately, Hoffmann s algorithm is not applicable to non-triangulated meshes, in particular not applicable to mesh structures with curved faces. Guibas and Stolfi s algorithm works for general mesh structures, but requires at the same time also the description of the dual mesh and is only applicable to edge algebra representations. Moreover, Guibas and Stolfi s rules seem not intuitive. We propose a completely different approach for verification of 2-manifold validity, by extending the classical theory of rotation systems studied in topological graph theory [12]. We show this approach can be adopted by almost all existing representations and data structures for verification of 2-manifold validity of mesh structures. Let be a mesh on a 2-manifold. First note that since the mesh is cellular, each connected component of the graph corresponds to a unique surface in [13]. Since each point on has a neighborhood homeomorphic to an open disk, if one stands at a vertex on, then he can see in a small

4 4 neighborhood of on that the edge-ends incident on are cyclically ordered, which give a natural rotation of the edge-ends incident on. If is an isolated vertex without any incident edges, then since the mesh is cellular, the surface containing must be a genus 0 sphere. Note that is homeomorphic to an open disk whose boundary degenerates into a single point, i.e., is a valid cellular mesh on the sphere. The sphere will be called a point-sphere containing the vertex. Since the isolated vertex has no incident edges, we define that has a unique rotation with an empty list of cyclically ordered edge-ends. This rotation will be called the empty rotation at the vertex. Thus, the mesh on the 2-manifold induces a rotation system on the corresponding graph, in which each vertex is given a unique rotation. Based on this observation, we introduce the following important concept. Definition: Let be a graph of vertices. Each edge in is given a fixed direction so that the two ends of each edge can be distinguished. A rotation at a vertex of is a cyclic ordering of the edge-ends incident on (in particular, an isolated vertex without incident edges always has the empty rotation. A rotation system of the graph consists of a set of rotations, each for a vertex in. 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 [12]. 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. Remark 2. Note that in the definition of graph rotation systems, the graph is not necessarily connected. Moreover, multiple edges (i.e., multiple edges with the same ends and selfloops (i.e., edges whose two ends are at the same vertex are also allowed. Of course, in case of multiple edges, the edges with the same ends must be distinguishable, and in case of selfloops, the two ends of the selfloop should be distinguishable. Remark 3. Since each edge in a graph rotation system is given a direction, each edge has two different directed versions, one follows the given direction and the other is in the reversed direction. Each directed version (called a directed are the end-vertices edge is given by where and of the edge. If the two end-vertices of the edge are different, then the vertices are sufficient to specify the edge-ends. If the edge is a selfloop, then by Remark 2, we assume that the two edge-ends are distinguishable. Thus, each directed edge uniquely specifies an edge-end on the corresponding edge. We will interchangeably use the names of a directed edge and of an edge-end in case there is no confusion. We will put a above a symbol such as to refer to a directed edge. For a directed edge, we also denote by ( the corresponding reversed directed edge. Therefore, if!, then (!. For graphs without isolated vertices, it has been proved [11] that a graph rotation system uniquely determines an embedding of the graph on a 2-manifold, thus uniquely determines *!%+$#&,-( be the edge-end next to.$/ / 6-$#&%'(20 do 7"6%8#&,-( be the edge-end next to.$/ 016%8#2 "( Subroutine FaceTrace( 1. trace 2. let %' in the rotation at 3. while / /!3#2%4(&0+5 let % in the rotation at trace 7.! "$#&%'( is a directed edge 01*!%'$#2-( Algorithm Facing (9:/< 0 =9:/> 0 is a graph rotation system 1. for each isolated vertex? without incident edges in do construct a face with a degenerated boundary? 2. while there is a directed edge not traced yet do FaceTrace(. Fig. 3. Face reconstruction based on graph rotation systems a 2-manifold. The proof heavily requires the familiarity with topological graph theory. In the following, we present a new proof for this result, which will also cover the case of isolated vertices. Moreover, our proofs are more constructive in the language of computer graphics and modeling, which clearly illustrates how this new structure is used in a 2-manifold modeling system. We first show how to reconstruct faces on a given graph rotation system. Let be a rotation system of the graph. The algorithm is presented in Figure 3, where tracing a directed edge, is either to print or to store the directed edge, in its given direction. Lemma 3.1: The algorithm Facing traces each directed edge in exactly once. Proof: First of all, each directed edge is traced at least once. This is because if any directed edge is not traced, then the main algorithm will call the subroutine FaceTrace on, which will trace the edge. Thus, it suffices to show that no directed edge is traced more than once. Consider the subroutine FaceTrace( A@. Let!B&+ be a directed edge and let :C!&+DE be the directed edge right before in the rotation at the vertex. If is traced by FaceTrace( A@ and GF!H $@, then it is clear by the algorithm that the directed edge ( AC!I&D'J must be also traced by right before the tracing of the directed edge. On the other hand, then the directed is traced at beginning of and stops when the directed edge is encountered the second time. Thus, the last edge traced by must be on the directed edge ( AC!O&D'. Now assume that some of the directed edges in are traced more than once by the algorithm Facing. Suppose that is the directed edge that receives the earliest second time trace. First note that the second time trace on the directed edge cannot be the first edge trace of a subroutine execution : in this case would and the second time trace on is the first edge trace of but when is called, the directed should have not been traced at all. Suppose that the directed edge receives the first time trace in FaceTrace( -P, and receives the second time trace in FaceTrace(. Let!Q, and let AC!Q DE be the

5 5 directed edge right before in the rotation at the vertex. We consider two different cases. If PF!, then by the above remarks, the directed edge AC! D+J also receives a trace in FaceTrace( -P. Now since the second time trace on cannot be the first edge trace in FaceTrace(, the second time trace on in FaceTrace( must follow a trace on the directed edge ( C. Thus, the directed edge ( :C would receive the second time trace earlier than. If P!L, then the directed edge cannot be P since the subroutine FaceTrace( P stops immediately when the edge P is encountered the second time. Thus, the first time trace and the second time trace on the directed edge must both follow traces on the directed edge ( C! &D'J. This, again, shows that the directed edge ( C would receive the second time trace before the second time trace on the directed edge. Thus, in any case, we would derive that the directed edge AC would receive the second time trace before the second time trace on the directed edge. This contradicts the assumption that the directed edge receives the earliest second time trace. This contradiction shows that no edge should receive a second time trace. The lemma is proved. By Lemma 3.1, each subroutine execution produces a sequence of directed edges that line up head to tail and form a polygonal closed walk. One thing we should show is that this construction is robust, i.e., the order in which the main algorithm Facing picks untraced edges should not affect the output of the algorithm. Lemma 3.2: On a directed edge -P, the subroutine FaceTrace( P produces a sequence of directed edges that form a polygonal closed walk. Moreover, for any directed edge in the sequence, the subroutine FaceTrace( on will produces the same polygonal closed walk. Proof: By the algorithm, if a directed edge is traced in FaceTrace, then the next edge in the closed walk is uniquely determined, which must be the directed edge right after J in the rotation at the vertex. Moreover, the first edge &+ traced by FaceTrace must be the directed edge right after the last directed edge traced by FaceTrace in the rotation at vertex. Therefore, it is easy to see that 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, the algorithm Facing will produces a unique set of point-spheres, each for an isolated vertex in, 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 3.1 and Lemma 3.2, the set of faces constructed this way is uniquely determined. Thus, the graph rotation system plus the algorithm Facing specifies a unique mesh structure by giving the vertex set (that is the vertex set of the graph, the edge set (that is the edge set of the graph, and the face set (that is given by the algorithm Facing. We show below that the mesh structure constructed by this process is cellular and gives a unique and valid 2-manifold structure. For this purpose, we need to first discuss two operations on graph rotation systems. Let be a vertex in the graph. For any two consecutive edge-ends P! and! E in the rotation at, the two directed edges ( -P and are consecutive on the boundary of a face constructed by the algorithm Facing. we say that the edge-ends -P and form a face corner (of the face at, written either as ( -P - or ( E. In case is an isolated vertex without incident edges, we define that has a unique face corner (. Note that the two edgeends may belong to the same edge (e.g., both of them are from the same selfloop. In an extreme case, the two edge-ends P and can even be the same edge-end (i.e., when the vertex is of valence. Let be a rotation system of a graph, and let! + be an edge in. By deleting the edge from, we obtain naturally a rotation system for the graph. More formally, let AC! and AC C! &J be the two edgeends induced from the edge in, and suppose that the rotations in at and are (recall that the edge-ends are cyclically ordered in the rotation at each vertex: C CP C C and CP C C C respectively, where :C and AC C are edge-ends. Then the rotation of the graph has the identical rotation at each vertex D! F, and at and, the rotations in are CP C C and CP C Conversely, suppose in the rotation system, the edgeends CP and C form a face corner at a vertex, and the edge-ends :C P C and AC C form a face corner at a vertex, then we can insert a new edge! + between the face corners ACP - AC and ACP C - $ in the rotation system to make a rotation system for the graph. More formally, suppose that in the rotation system, the rotations at the vertices CP C C CP C and are and respectively, then after inserting the edge between the face corners ( ACP - AC and ( ACP C - $, we obtain a rotation system for the graph that has the identical rotation at each vertex D! F +, and at the vertices and, the rotations in are CP C C C and CP C AC! and AC C! are the two edge-ends of (so more precisely, we actually inserted the edge- where the edge end AC to the face corner ( ACP " AC and the edge-end :C C to the face corner ( CP C -. Now we are ready for our main theorem for this section. Theorem 3.3: A graph rotation system plus the face set constructed by the algorithm Facing on gives a cellular mesh structure on a unique and valid 2-manifold. Proof: We prove the theorem by induction on the number of edges in the graph. Suppose the graph has vertices. If the graph has no edges, then all vertices of are isolated. Thus, the algorithm Facing uniquely produces point-spheres, which form a valid 2-manifold on which gives a valid cellular mesh structure. Now assume that the graph has edges. Let! + be an edge in ( and may belong to the same

6 " " & & ( ( ' ' " " vertex if is a selfloop. Suppose that in the rotation system are:, the rotations at the vertices and CP E C C and CP C ( : where "! and (! J are the two edge-ends of the edge. By deleting the edge! in the rotation system, we obtain a rotation system for the graph of edges. In particular, the rotations at the vertices and in the rotation systme become CP C C and CP C C C (it is possible that one or both of the rotations become an empty rotation now. By the inductive hypothesis, the rotation system plus the algorithm Facing uniquely gives a valid 2-manifold structure. Let be the set of faces in the mesh. Let P be the face containing the face corner :CP - AC and let be the face containing the face corner in. By inserting the edge! ( ACP C - A between the face corners ( :CP - AC and ( ACP C - $ in ', we get back the rotation system. We show that also gives a valid 2-manifold structure. Apply the algorithm Facing on the rotation system. Note that since the only difference between and, the algorithm is at the face corners ( CP - C and ( CP C - Facing on will produces all faces in -PA. Since the set of faces produced by Facing is independent of the order of the edges, we can assume that the algorithm Facing on first constructs all faces in P. Note that after the construction of these faces, the only directed edges that have not been traced are those on the boundaries of the faces P and, and the two directed edges and ( induced by the edge! +. There are two possible cases. Case 1. The two face corners CP - C and ( CP C - belong to the same face in $, that is P!$. Let the boundary of the face P!$ be &( CP " C CP C ( CP C - CP C P!$! where C and "C C are directed edges. Since the rotations at any vertex D! F are identical in the rotation systems " in are and, and the rotations at and CP E C C and CP C ( : C C It is not difficult to verify that the procedure FaceTrace(( on the rotation system will produces the face ( " C CP C ( C! P and the procedure FaceTrace( on produces the face! - CP C ( CP (see Figure 4 for an illustration. Therefore, the difference of the two meshes and $ is that the face P! in is replaced by the faces JC and in. By looking at the face structures, we can easily see that the face -P! can be obtained by pasting the faces C and along the edge. Therefore, adding the face P! to the mesh and adding the two faces JC and to the mesh Fig. 4. Fig. 5. $ %! # $ %! Inserting an edge between two corners of the same face # $ %! # $ % #! Inserting an edge to face corners of two different faces should give the same structure. Since the mesh constructed from represents the valid 2-manifold, we conclude that the mesh constructed from should also represent the same 2-manifold. In fact, it is not difficult to see that the mesh can be obtained from the mesh by adding a crossing edge on the face P!$. Case 2. The two face corners ( :CP - AC and ( ACP C - A belong to two different faces P and, P!$ F, in ". Let the boundaries of the two faces P and be and P!! & CP " C CP C ( CP C CP C Again since the rotation system is obtained from the rotation system $ by inserting the edge between the two face corners ( :CP - AC and ( ACP C - $, when the procedure FaceTrace( :C is called, we will get the face:! - $ CP C ACP C ( " AC "CP "C ( ACP (see Figure 5 for an illustration. Note that the boundary of the face has contained all directed edges on the boundaries of the faces P and, plus the two directed edges of the edge. Therefore, the difference between the mesh and the mesh is that the faces P and in are replaced by the face in. Now if we past along the edge in the face, we will get a cylinder * with two open ends. (See Figure 6 in which we have re-drawn the face then pasted along the two directed edges and (. Observe that if we traverse the two open ends of the cylinder *, we get exactly the boundary traversings of the faces P and in. Therefore, the structure represented by the mesh can be obtained from the 2-manifold represented by 6

7 ' & & & ( & Fig. 6. & # % % Pasting the two directed edges of an edge to get a cylinder $ as follows: first cut the two faces P and off along their boundaries in, then on the resulting structure past the boundaries of the two open ends of the cylinder * along the boundaries of the two faces P and. It is wellknown that such a topological surgery on a 2-manifold results in a 2-manifold [12]. Thus, in this case, the mesh also represents a valid manifold structure. In consequence, we have proved that in any case, the mesh represents a valid 2-manifold structure. This completes the proof of the theorem. IV. DATA STRUCTURES: VERTEX, EDGE, OR FACE BASED Theorem 3.3 shows that the vertex-based representation, the graph rotation systems, guarantees the validility of the underlying 2-manifold mesh structures. In this section, we consider a variety of implementations of different mesh representations. Based on Theorem 3.3, we show that it is in general trivial to check whether a mesh structure represents a valid 2- manifold structure based on most existing data structures for mesh modeling. Moreover, we propose a new representation that is face-based. We will discuss the efficiency of these data structures terms of user interface operations in the next section. To simplify the discussion, we will assume from now on that our graphs do not contain multiple edges and selfloops. Thus, edges and directed edges now can be uniquely specified by pairs of vertices and ordered pairs of vertices, respectively (The discussion can be extended to graphs with multiple edges and selfloops without much technical troubles except using more tedious notations. According to Theorem 3.3, we have the following simple rules to check whether a mesh structure represents a valid 2-manifold structure: Validity Rules. A mesh structure gives a representation for a valid 2-mainfold if 1 Each edge induces exactly two edgeends &+ and &J 2 For each vertex, a unique cyclically ordered list is specified that contains all and only the edge-ends based on (each edge-end appears exactly once in the list 3 No part in the mesh representation conflicts conditions 1 and 2. # A. Vertex-based data structures There is a fairly natural data structure for representation of graph rotation systems, the graph adjacency list structure, which is the most commonly used data structure for graphs in computer science. Recall that an adjacency list for a graph is given by an array of linked lists, where is a linked list that contains all neighbors of the vertex. Since the graph has no multiple edges and selfloops, each vertex in the list uniquely specifies the edge-end E of the edge at. Since for each edge E, the vertex appears in the list and the vertex appears in the list, condition 1 of the Validity Rules is satisfied. Moreover, if we interpret for each vertex the list as the cyclic ordering the edgeends at, then the list specifies a unique rotation (of the edge-ends at the vertex. Thus, condition 2 of the Validity Rules is satisfied. Condition 3 of the Validity Rules is satisfied trivially. Thus, we conclude 7 repre- Theorem 4.1: A valid graph adjacency list sents a valid 2-manifold structure. The graph adjacency list structure gives the most space efficient representation for modeling 2-manifold meshes. For a mesh of edges, the corresponding graph adjacency list uses only # pointers. The drawback of graph adjacency list for mesh modeling is its time complexity for supporting modeling operations. For example, consider the algorithm Facing in Figure 3. The opeartion of finding the next edge-end for a given edge-end is heavily used for reconstructing the faces of the mesh. In order to find the next edge-end of an edgeend in the rotation at, we need to search through the to find the item for list (corresponding to the edge then pick the next item in the list. The time for doing this is proportional to the size of the list, which will be time consuming in particular when the vertex has a large valence. B. Edge-based data structures Most data structures in mesh modeling are edge-based. We will focus our discussion on the well-known wingededge structure, then extend our discussion to other edge-based structures. Recall that a winged-edge structure for a mesh is a list of edge nodes [7]. Each edge node consists of nine components: (name, vstart, vend, fcw, fccw, ncw, pcw, nccw, pccw, where name is the name of the edge vstart and vend are the starting and ending end-vertices of the edge (which thus give a direction to the edge fcw and fccw indicate the left face and right face of the edge when traversing along the edge direction ncw and pccw give the next edges in the faces fcw and fccw, respectively, when traversing along the edge direction and pcw and nccw give the next edges in the faces fcw and fccw, respectively, when traversing along the reversed direction of the edge. See Figure 1 for a review. By the definition and intention of the winged-edge structure, the edge vstart vend and the edge ncw are two consecutive edges when we traverse the boundary of the face fcw (starting from vstart, and the edge vend vstart and the edge nccw are two consecutive edges when we traverse the boundary of the face fccw. Thus, if the mesh structure represents a

8 8 Subroutine VertexTrace(?, =? is an end of the edge 1. if ( + vstart? then + nccw else ncw 2. while / do 2.1. suppose? # % 2.2. if (the edge-end? #2%( is marked then Stop( error 2.3. mark the edge-end? A#&%4( 2.4. if ( vstart? then 4 nccw else ncw 3. suppose? #2%' mark the edge-end? $#&%'(. Algorithm E-Validity ( is a winged-end structure for each edge node do 1. vstart % vend 2. if ( is not marked 6 then #&%4( mark VertexTrace(, else if (the edge-end has not been marked then % Stop( error 3. if ( is not marked 6%8#& then ( % % mark VertexTrace(, else if (the edge-end has not been marked then Stop( error. Fig. 7. Vertex rotation reconstruction based on winged-end structure valid 2-manifold, then the edges nccw and ncw should give the next edge-ends of the edge-ends vstart vend at vstart and vend vstart at vend, respectively. Thus, whether the winged-edge structure gives a valid 2-manifold, i.e., whether the winged-edge structure represents a valid graph rotation system, can be verified based on the information provided by the components ncw and nccw. Denote by the edge node corresponding to the edge in the winged-end structure. By vstart, vend, ncw, and nccw, we refer to the corresponding components vstart, vend, ncw, and nccw in the edge node. Consider the algorithm given in Figure 7. We give some remarks on the algorithm. First note that the vertices are marked in the main algorithm E-Validity while edge-ends are all marked in the executions of the subroutine VertexTrace. By the definitions of the components ncw and nccw in the winged-edge structure, edge-ends marked in a subroutine execution VertexTrace -@: $@ must all have the as their base vertex. In particular, if a vertex is unmarked, then no edge-ends based on can be marked. Thus, when the subroutine VertexTrace-@: $@ is called, the edgeend of $@ at :@ must be unmarked. Theorem 4.2: If a winged-edge structure the test of algorithm E-Validity and if the components fcw, fccw, pcw, and pccw are consistent with the components vstart, vend, ncw, and nccw of its edge nodes, then represents a valid 2-manifold structure. Moreover, all these can be checked in time. Proof: Since each edge node uniquely induces two edge-ends vstart vend and vend vstart, condition 1 of the Validity Rules is satisfied. For each edge node, the component nccw uniquely describes the edge-end next to the edge-end vstart vend, and the component ncw uniquely describes the edge-end next to the edge-end vend vstart. Therefore, the winged-edge structure can pass defines a next operation on edge-ends in such that if next E! ED, then DE is the edge-end next to E in the rotation at the vertex. To verify condition 2 in the Validity Rules, we only need to check whether this next operation arranges the edge-ends at each vertex into a cyclic ordering. Since the operation next gives a unique next edge-end for each edge-end, and since for an edge-end, next and have the same base vertex, there are only two possibilities that the next operation does not arrange the edge-ends at a vertex into a cyclic ordering: (1 an edge-end is next to two different edge-ends P and, i.e., next P! next! or (2 the next operation arranges the edge-ends at a vertex into more than one disjoint cyclically ordered lists. Both these conditions can be identified effectively by the algorithm E-Validity. If for two different edge-ends P and, we have next -P! next!, then the edge-end (or some other edge-end will be encountered again after its first marking. Thus, step 2.2 in the subroutine VertexTrace will detect this and correctly reports an error. If the next operation arranges the edge-ends at a vertex into more than one disjoint cyclically ordered lists, then after the first call on the subroutine VertexTrace E, the vertex is marked while some edge-ends based on are not marked. This situation will be detected by either step 2 or step 4 of the main algorithm E-Validity, which will report correctly the error. On the other hand, if the components ncw and nccw correctly describe a valid graph rotation system, then each execution of the subroutine VertexTrace E will mark the vertex as well as all edge-ends based on, which can in fact also produce the cyclic order of the edge-ends based on (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 steps 2 or 4 in the main algorithm E-Validity. passes the test of Thus, if the winged-edge structure E-Validity, then the components vstart, vend, ncw and nccw of the edge nodes in the winged-edge structure describe a valid graph rotation systems. Condition 3 of the Validity Rules is satisfied as long as the other components fcw, fccw, pcw, and pccw are consistent with the components vstart, vend, ncw, and nccw of the edge nodes in the winged-end structure. By the Validity Rules, the theorem is proved. Now we consider the complexity of the test for the validity of a winged-edge structure. Suppose that for a given edge, the edge node can be accessed in constant time (this condition can be easily met if the edge nodes are arranged in an array where the edge names are given by the array indices, then the algorithm E-Validity marks each vertex and each edge-end in constant time. Recording whether a vertex or an edge-end has been marked can be easily done by using a supplementary vertex array and a supplementary edge array. Thus, the running time of the algorithm E-Validity is bounded by!, where is the number of edges and is the number of vertices in the winged-edge structure. To check whether the components pcw and pccw are consistent with the components vstart, vend, ncw, and nccw, note that the components pcw and pccw actually give the rotation at each vertex in the reversed cyclic order. Therefore, an algorithm

9 9 very similar to E-Validity, thus also running in time, can be developed based on the components vstart, vend, pcw and pccw, which will produce the reversed cyclically ordered edge-ends at each vertex. The outcome of this algorithm can be compared with the rotation system produced by the algorithm E-Validity to check the consistence. In order to check the consistence of the components fcw and fccw, we run the algorithm Facing on the winged-edge structure to reconstruct the faces in the mesh, which will be sufficient for testing the consistence of the components fcw and fccw. Note that since the winged-edge structure supports the operation of finding the next edge-end for a give edge-end in constant time (via the components ncw and nccw, the running time of the algorithm Facing is also bounded by. In conclusion, the test of Validity Rules based on the winged-edge structure can be done in time. This completes the proof of the theorem. Remark. Theorem 4.2 indicate that the original wingededge structure proposed by Baumgart [7], in which only the components name, vstart, vend, ncw, and nccw are included, is sufficient and very effective for modeling 2-manifold structures. Note that the original winged-edge structure is very space efficient and requires storage space of only pointers edges. As an example, we show how the algorithm E-Validity reports an error on the winged-edge structure given in Figure 2. By looking at the edge node P, step 3 of the algorithm will mark the vertex and call the subroutine or an array of size for a mesh structure of VertexTrace P. The subroutine VertexTrace P will mark the edge-ends, $, and "P and return back to the main algorithm E-Validity. Then the main algorithm E-Validity looks at the edge node and finds out that the vertex is marked while the edge-end is not marked, thus correctly reports an error. We now briefly describe how the Validity Rules are tested on other edge-based data structures for mesh modeling. In the half-edge data structure [17], a half-edge corresponds uniquely to an edge-end 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 edge-end 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. Moreover, testing of the consistence of the other components in a half-edge data structure, such as the references to faces, starting vertices, the corresponding edges, and the previous half-edges, can also be done efficiently. It can be shown that testing the Validity Rules on a half-edge data structure can be done in time, where is the number of edges in the mesh. In the quad-edge structure [13] for an edge algebra for an orientable 2-manifold, each edge has two directed versions, corresponding to the two edge-ends in our graph rotation systems. The operation Onext defined in the edge algebra gives exactly the next edge-end of a given edge-end in the rotation at the base vertex. Thus, again, based on the directed edges and the Onext operation, we can conveniently verify whether the quad-edge structure gives a valid graph rotation system thus represents a valid 2-manifold structure. Again, the consistence of the other components in the quad-edge structure can be verified. In a proper implementation, such as the one suggested in [13], the Validity Rules on the quad-edge structure can be tested in time, where 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 [13]. C. A new face-based data structure 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 [18]. The authors have recently re-investigated the face-based data structure for mesh modeling and proposed a new facebased data structure, the doubly linked face list (DLFL for modeling 2-manifold structures [2]. The advantage of this data structure is its extremely efficient support to a variety of modeling operations. The DLFL structure has been implemented in our 2-manifold modeling system. We will show in the conclusion section a number of impressive figures generated by our modeling system based on the DLFL structure. In this subsection, we show how to test the Validity Rules on a DLFL data structure. A doubly linked face list (DLFL for a mesh structure consists of a face list, a edge list, and a vertex list. Each face in the face list, called a face node, is a cyclically and doubly linked list of edge-ends, lined up head to tail to form a closed walk. Note that a face node can be simply represented by a cyclically and doubly linked list of vertices P, indicating that it consists of the edge-ends "P,,, P-, and "P. Each vertex in the vertex list, called a vertex node is a list of pointers to the corresponding vertices in the face nodes in. Each edge in the edge list, called an edge node, consists of two bidirected pointers to the edge-ends induced from the edge in the face nodes in. Figures 8 gives a partial part of a DLFL data structure for a tetrahedron. Both vertex list and edge list provide efficient access to propoer edge-ends in the face list. Since each edge node corresponds to two edge-ends in the face list, condition 1 of the Validity Rules is satisfied. Now consider two consecutive edge-ends &+ and in a face node. Note that they give explicitly that E is the edge-end following the edge-end EJ in the rotation at. Thus, checking whether this relation induces a graph rotation system is again reduced the testing whether this relation induces a single cyclically ordered list of edge-ends at each vertex. We present the test of Validity Rules for the DLFL structure in Figure 9. Theorem 4.3: If a DLFL structure can pass the test of algorithm F-Validity, then represents a valid 2- manifold structure. This can be checked in time. Proof: Condition 1 and condition 3 of the Validity Rules can be tested on a DLFL structure as follows: (1 each edge

10 ' ' ' ' ' ( 10 A Tetrahedron ( face list ( & & & # Fig. 8. vertex list The DLFL Structure The DLFL data structure for a tetrahedron edge list Subroutine VertexTrace/6? #? #&% (&0 1. let? $#&,-( 6%+ # be the edge-end following the edge-end? ( in a face node 2. while /? A#,-('5? $#2%+(20 do 2.1. let? $#A(!, # be the edge-end following the edge-end? ( in a face node 2.2. if (? $#$( is marked then stop( error 2.3. else mark? :#$(, 3. mark? $#&%'(. Algorithm F-Validity ( is a DLFL structure 1. by scanning the face list, edge list, and vertex list, to check that each edge correctly corresponds to two end-ends 2. for (each vertex? in do if (? is not an isolated vertex without edge then in? s vertex list, find an edge-end based on? VertexTrace/!? # 0 3. if (there are still unmarked edge-ends then return( error. Fig. 9. Vertex rotation reconstruction based on a DLFL structure node should be associated with exactly two edge-ends in the face list (2 each edge-end in the face list should be associated with exactly on edge node in the edge list (3 each vertex node should consist of a sequence of pointers to the corresponding vertex in the face list (4 each vertex in the face list should be pointed by exactly one vertex in the vertex list and (5 each face node in the face list should be a sequence of edge-ends that forms a closed walk. It is not hard to see that all these can be verified in time. To verify condition 2 of the Validity Rules, note that two consecutive edge-ends E and &D specify precisely that DE is the edge-end following the edge-end DE in the rotation at. Thus, the subroutine VertexTrace-@: starts from and constructs a list of consecutive edge-ends based If the face list does not give a valid rotation at a vertex -@, then there are only two possiblities: (1 an edge-end follows two different edgeends This will be detected by step 2.2 in the subroutine VertexTrace when the edge-end is encountered the second time (2 the edge-ends at -@ form more than one disjoint cyclically ordered lists. This will be detected by step 3 of the main algorithm F-Validity since the call to the subroutine can trace only one such a list. - In conclusion, if the DLFL structure passes the test of F-Validity, then it must represent a valid graph rotation system. What remains is the discussion of the running time of the algorithm F-Validity. Note that the algorithm F-Validity marks each edge-end exactly once. Since the edge node for an edge has two bi-directed pointers to the edge-ends E and, in the face list, from an edge-end E in the face list, we can find the edge-end in constant time. Therefore, it is easy to see that the algorithm F-Validity runs in time. The theorem follows. V. OPERATIONS: COMPLETENESS, SOUNDNESS, AND IMPLEMENTATIONS Operations on mesh modeling are important, in particular for the modeling systems with a reliable and powerful userinterface. A systematic study on mesh modeling operations was given by Mäntylä [17], and was also considered by other researchers (e.g., [7], [13]. For 2-manifold modeling, three issues in modeling operations, the completeness, the soundness, and the efficiency, turn out to be the most important. We say that a set of operations is complete if any 2-manifold structure can be generated by a sequence of the operations from, and that the set of operations is sound if applying any operation in on a 2-manifold results in a valid 2- manifold structure. Theorem 3.3 provides a solid foundation not only for validity testing of 2-manifold structures, but also for powerful mesh modeling operations. In the previous studies on operations on 2-manifold structures (e.g., [13] and [17], it is always needed to verify carefully that a proposed set of operations is sound and complete so that all and only 2-manifold structures can be created using the operations. On the other hand, by Theorem 3.3, the problem of soundness and completeness becomes based on the representation of graph rotation systems: as long as we can verify that the proposed set of operations can creat all and only valid graph rotation systems, the soundness and completeness are guaranteed. Note that validity of graph rotation systems is a simply a graph property, which is in general much easier and more intuitive than the validity of mesh topological integrity. A. A complete and sound operation set we propose a set of modeling operations that seems simpler, more intuitive and user-friendly than the previously proposed schemes. We will discuss the soundness and completeness of the operation set, consider its efficient implmentations on a variety of modeling data structures, and compare it in terms of various aspects with the existing modeling schemes. The first operation is the edge insertion operation, briefly E- INSERT, described in section 3. Let be a graph rotation

11 11 system and let and be two vertices in. By inserting an edge between two face corners DE &+DC> and E E C>, we mean inserting the edge-end in the rotation at between the edge-ends D and DC<, and inserting the edge-end in the rotation at between the edge-ends and C6. The inverse of the EINSERT operation is the edge deletion operation, briefly EDELETE. Let be a rotation system and let! + be an edge in, by deleting the edge, we mean deleting the edge-end D from the rotation at the vertex and deleting the edge-end EJ from the rotation at the vertex. The other primary operation is vertex creation, briefly written as V-CREATE, which creates a new isolated vertex without edge in the rotation system. The inverse operation of V-CREATE is vertex removing, V-REMOVE, which removes an isolated vertex without edge from the rotation system. Remark. Compared to the Euler operations studied by Mäntylä [17], the V-CREATE/V-REMOVE operations are identical to the Euler operations MVFS/KVFS, the E-INSERT/E- DELETE operations are a combination of the Euler operations MEF/KEF and MEKR/KEMR (in some sense, also include the operations MFKRH/KFMRH. The other Euler operations, such as MEV/KEV, have no Correspondence in our proposed set of operations. Theorem 5.1: The operation set consisting of E-INSERT/E- DELETE and V-CREATE/V-REMOVE is complete and sound. Proof: The soundness of the operation set is obvious: applying each of the four operations on a graph rotation system that represents a valid 2-manifold strucutre results in a valid graph rotation system, which by Theorem 3.3 is a valid 2- manifold structure. The completeness can also be verified easily. As explained in section 3, any cellular mesh structure for a 2-manifold induces a unique rotation system. By a sequence of E- DELETE operations followed by a sequence of V-REMOVE operations, we can obtain an empty rotation system with no vertices and edges. Reversing this sequence of operations, and replacing each V-REMOVE in the sequence by V-CREATE and each E-DELETE in the sequence by E-INSERT. The resulting sequence starting from an empty rotation system without vertices and edges should re-construct the rotation system. Therefore, any cellular mesh structure can be obtained by a sequence of operations in the set. This proves the completeness. For readers who are curious why a surface of any given genus can be constructed by a sequence of the proposed set of operations, our explanation is as follows. Let be a rotation system, which represents a surface of genus, and let C be the rotation system obtained from by inserting a new edge between two face corners P and in. Suppose that the genus of C is C. Let the number of vertices, the number of edges, and the number of faces in be,, and, respectively, and let those in C be C, C, and JC, respectively. If the two face corners P and belong to the same face in, then as described in the proof of Theorem 3.3 (see Figure 4 for an illustration, inserting the edge between P and splits the face into two. By faces. Thus, we have 'C!, C!, and C! Euler-Poincare Theorem (see section 2, we must have C!. Thus, in this case, the surface represented by C have the same genus as. On the other hand, suppose that the two face corners P and belong to different faces in. Then by the discussion in the proof of Theorem 3.3 (see Figure 5 for illustration, Inserting the edge between P and merges the two faces into a single one. Thus in this case, we have, and C!. Again by Euler- C!, C! Poincare Theorem, the genus C of C is larger than that of. Thus, in order to construct a mesh structure for a surface of genus, we start with a V-CREATE operation that creates without a rotation of a single isolated vertex edge, corresponding to a sphere (a point-sphere of genus. Note that the rotation has one vertex, one face, and no edge, and the unique face has only one face corner. Now apply E-INSERT to insert an edge P and obtain a rotation system P. Since there was only one face, the two edgeends of P were inserted between corners of the same face. Thus, the rotation system P also corresponds a sphere of genus. The rotation system P has two faces. Thus, if we inserrt another edge between two corners of these two faces, we obtain a rotation system corresponding to a surface of genus. The rotation system has only one face. So we can insert a third edge between two corners of the face, split the face into two faces, and obtain a 2-face rotation system of genus. Now inserting the fourth edge into two corners of the two faces in results in again a 1-face rotation system of genus #, and so on. By inserting # edges in this way, we will obtain a rotation system corresponding to a surface of genus. Our operation set seems simpler, more intuitive and uniform, and more user-friendly than the previously proposed schemes. Compared to the Euler operations proposed and studied in [7], [17], our set consists of much fewer operations. Compared with the operation set proposed by Guibas and Stolfi [13], our set consists of the same number of operations but seems more intuitive (readers are suggeested to compare our E-INSERT/E-DELETE operations with the SPLICE operation proposed in [13] to have an impression on this fact. Moreover, our set of operations seems to be more uniform, either from a viewpoint of modeling systems or from the viewpoint of users. A modeling system using our operations only need to deal with its internal representation on graph rotation systems, without any concern of the topological integrity of the underlying mesh, while a user using our operations only needs to identify face corners on the mesh structure, without any need of understanding its internal implementation. On the other hand, most previously proposed operation 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. B. Implementation on vertex-based data structures The implementation of the operations E-INSERT, E- DELETE, V-CREATE, and V-REMOVE on an adjacency list structure are fairly straightforward. In order to E-INSERT an

12 12 edge between two face corners (&+DE$ D C and ( $ C2 (so the item DEC follows the item D in the linked list for, and the item C follows the item in the linked list for, we only need to insert the item between the items D and DEC in the linked list for the vertex, and insert the item between the items and C in the linked list for the vertex. E-DELETE an edge + from the adjacency list structure is implemented by deleting the item in the linked list for and deleting the item in the linked list for. Finally, a V-CREATE operation corresponds to adding a new vertex with an empty list in the adjacency list structure, and V-REMOVE corresponds to removing a vertex with an empty list from the adjacency list structure. The V-CREATE and V-REMOVE implemented in an adjacency list take constant time. Howeverr, the operations E- INSERT and E-DELETE implemented 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 operations E-INSERT and E-DELETE can be improved if we use a balanced tree instead of a linked list for the edge-ends at each vertex, which supports item insertion and item deletion in the tree in time logarithmic to the size of the tree [9]. Moreover, in this implementation, a supplementary edge list will be needed to support efficient searching of edge-ends in the structure. We leave the detailed implementation of this alternative data structure to the interested readers. C. Implementation on edge-based data structures Again we concentrate on discussions of 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 V-CREATE and V-REMOVE operations, we need to introduce a supplementary vertex list in the winged-edge structure (actually, such a supplementary vertex list is always needed in an edge-based data structure when isolated vertices without edges are allowed. Each item in the vertex list, called a vertex node, has a pointer to an (arbitrary edge node whose one end is. A vertex node for an isolated vertex without edges has an empty pointer. Now, V- CREATE simply adds a new vertex node with an empty pointer to the structure, and V-REMOVE removes a vertex node with an empty pointer from the structure. The implementation of the operations E-INSERT and E- DELETE is more involved. Consider in the winged-edge structure an edge node with components name, vstart, vend, ncw, pcw, nccw, pccw, fcw, and fccw (see Figure 1 for an illustration. The components nccw and pcw give the next and previous edge-ends to the edge-end vstart vend, respectively, while the components ncw and pccw give the next and previous edge-ends to the edge-end vend vstart, respectively. Finally, the components fcw and fccw give the left face and right face while traveling from vertex vstart to vertex vend along the edge. Implementations of the operations E-INSERT and E- DELETE on a winged-edge structure are given in Figure 10. Subroutine E-Insert( # %>#.$/ 6 #2,-( #! #, 7 (&0 #.$/ 6%8#A( #!%=# 7 (&0 + Inserting an edge #&% between face corners.$/! #,-( # 6 #2,:7<(&0 and.$/!%=# A( #!%=# 7<(&0. 1. create a new edge node for the edge #&% with vstart and % vend 2. find 4 the edge nodes #&,, #2,:7, %=#, and %8# 7 without loss of generality, assume vstart vstart and vstart % vstart. Other cases can be handled similarly. 3. nccw pcw nccw pcw 4. ncw pccw ncw pccw 5. call FaceTrace/ 6!%=#& # %4(&0 "( to update the components fcw and fccw 6. if (the edge-end is not traced in step 5 then call FaceTrace/!%=# "(20 to update the components fcw and fccw. Subroutine E-Delete( 1. find the edge node for the edge #&%, where vstart and % vend 2. find the edge nodes pcw, nccw, 4 pccw, and ncw without loss of generality, assume vstart vstart, and vstart % vstart. Other cases can be handled similarly. 3. nccw pcw ncw pccw 4. remove the edge node 5. call FaceTrace/ 6 #, 76(&0 to undate the face components and fcw and fccw 6. if (the edge-end!%=# 7 ( is not traced in step 5 then call FaceTrace/!%=# 7>(&0 to update the components fcw and fccw. Fig. 10. E-INSERT and E-DELETE on winged-edge structure By the definitions of the components ncw, pcw, nccw, and pccw (see Figure 1 for an illustration, it is easy to verify that the operation E-INSERT inserts the edge-end &+ between the face corners P! ( D$ D C and! (& C&, while the operation E-DELETE deletes the edge. The components NCW, pcw, pcw, and pccw of the related edges are properly updated. The only thing that may need further explanation is the updating of the components fcw and fccw. First consider E-INSERT. As shown in the proof of Theorem 3.3, if the two face corners P and belong to two different faces, then inserting the edge! between P and replaces the two faces in the mesh by a single new face whose boundary contains both edge-ends &+ and J of the inserted edge (see Figure 5. Therefore, in this case, the subroutine FaceTrace in step 5 will trace the boundary of this new face and properly update the face components of the related edge nodes. In particular, the subroutine FaceTrace in step 6 will not be executed. On the other hand, if the face corners P and belong to the same face in the mesh, then inserting the edge between P and replaces the face by two new faces whose boundaries contain the two edge-ends &+ and &J of the inserted edge, respectively (see Figure 4. Thus, the subroutine FaceTrace in step 5 traces one new face and updates the face components for the related edge nodes, while the subroutine FaceTrace in step 6 traces the other new face and updates the face components for the related edges nodes. For the operation E-DELETE of an edge, if the two

13 13 edge-ends of are on boundaries of two different faces, then deleting will merge the two faces into a single one (this corresponds to the reversed operation given in Figure 4. Thus, the subroutine FaceTrace in step 5 will trace this new face and update the face components of the related edge nodes. On the other hand, if the two edge-ends of are on the boundary of the same face, then deleting will split this face into two faces. Now the subroutine FaceTrace in step 5 and step 6 will trace the two new faces and update the face components of the related edge nodes. Now we consider the complexity of the algorithms E- INSERT and E-DELETE. For updating the components ncw, nccw, pcw, and pccw, since only very few edges (two or three are involved, this can be done in constant time. However, each algorithm contains one or two executions of the subroutine FaceTrace, whose time complexity is proportional to the size of the involved faces. When the face size is small (such as on a triangulated mesh, this is fine. However, for faces of large size, this will be time consuming. Recall that we pointed out in section 4 that the components name, vstart, vend, ncw, and nccw in the winged-edge structure are sufficient for representing a 2-manifold mesh structure. In particular, a winged-edge structure without the components fcw and fccw gives the complete information for a 2-manifold mesh structure. Moreover, on a winged-edge structure without the components fcw and fccw, step 5 and step 6 in the algorithms E-INSERT and E-DELETE are not needed. We summarize this discussion in the following theorem. Theorem 5.2: On a general winged-edge structure, the running time of the algorithms E-INSERT and E-DELETE is, where is the size of the faces involved, while on a winged-edge structure without the components fcw and fcw, the running time of the algorithms E-INSERT and E-DELETE is. The discussion of the implementations of the operations E-INSERT and E-DELETE on the winged-edge structure can be easily extended to other edge-based data structures, such as the half-edge structure proposed by Mäntylä [17] and the quad-edge structure proposed by Guibas and Stolfi [13], since these data structures have components that are similar to the components ncw, nccw, pcw, pccw, fcw, and fccw in the winged-edge structure. We omit the details. Finally, we would like to compare our operations E-INSERT and E-DELETE with the SPLICE operation proposed by Guibas and Stolfi [13]. Roughly speaking, the SPLICE operation is equivalent to first inserting an edge between two face corners then contracting the edge, while the inverse of the SPLICE operation is equivalent to first spliting a vertex then deleting the edge between the two new vertices. Therefore, for the SPLICE operation and our E-INSERT operation, and for the inverse operation of the SPLICE operation and our E-DELETE operation, roughly the same number of edges get involved in the updating of the components ncw, nccw, pcw, pccw, fcw, and fccw. However, the SPLICE operation and its inverse operation 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 E-INSERT and E-DELETE seem also more intuitive than the SPLICE operation and its inversion operations. D. The operations on face-based data structures As we have discussed in the previous subsections, the E- INSERT and E-DELETE operations implemented on the adjacency list data structure can become time consuming when the involved vertices have high valence, while those implemented on the winged-edge structure or its variations can become time consuming when the involved faces have large size. Removing the components fcw and fccw from the winged-edge structure can speedup the running time, but may become inconvenient for some applications since the edge-ends are not directly associated with their corresponding faces. In this subsection, we consider implementations of our operations on the DLFL structure, and show that the computation inefficiency can be removed. Recall that a DLFL structure has a face list, an edge list, and a vertex list. Each face node in the face list is a sequence of edge-ends corresponding to the boundary of the face, each edge node in the edge list has two pointers to the two corresponding edge-ends in the face list, and each vertex node in the vertex list has a pointer to an edge-end in the face list that uses the vertex as its base. Again, the implementation of the operations V-CREATE and V-REMOVE are simple. V-CREATE( creates a face node in the face list with a degenerated boundary of a single vertex and creates a vertex node in the vertex list with a pointer to the new face while V-REMOVE( removes a face node in the face list with a degenerated boundary of a single vertex and removes the vertex node for in the vertex list. Now consider the operations E-INSERT and E-DELETE. The algorithms are presented in Figure 11. The correctness of the algorithm E-INSERT implemented on the DLFL structure follows directly from the proof of Theorem 3.3 (see Figure 5 and Figure 6 for intuitive illustrations. The algorithm E-DELETE reverses the process of E-INSERT so the correctness of its implementation on the DLFL structure also follows from the proof of Theorem 3.3. Now we consider the complexity of the algorithms. Since each edge node in the edge list has two pointers to its two edge-ends in the face list, from each edge, its two edgeends in the face list can be accessed in constant time. For each face node in the face list, we have a cyclically linked list of edge-ends that corresponds to the boundary of the face. If this cyclically linked list is implemented using a balanced tree structure (such as a 2-3 tree structure [1], then testing whether two edge-ends belong to the same face, spliting one edge-end list into two edge-end lists, and merging two edge-end lists into a single edge-end list can all be done in time, where is the size of the involved faces (for more detailed description and verification, see [9]. Note that each execution of the algorithms E-INSERT and E-DELETE implemented on the DLFL structure consists of a couple of such edge-end list testing, spliting and merging operations. Therefore, under this implementation of the cyclically linked list of edge-ends for face nodes, the running time of the algorithms E-INSERT and E-DELETE is bounded by discussion.. This concludes our

14 14 Subroutine E-Insert( #2% >#.$/ 7 # 7 0 #.$/ 7 7 # inserting an edge # % between the face corners.$/ 7 # 7 0 and.$/ 7 7 # make two edge-ends +6 #2%4( and.$/ 0 6%8# "( of the edge #&% 2. if (the face corners.$/ 7 # 7 0 and.$/ 7 7 # belong to the same face /6. / 7 0 # 7 # 7 # # 7 #.$/ # 7 7 # 7 7 # # then 2.1 delete the face node from the face list 2.2 add two new face nodes to the face list: 7 /6. / 0 # 7 # 7 ## 7 #.$/ 7 7 0&0 and 7 7 / # 7 7 # 7 7 ## 7 7 #. / add an edge node #2% in the edge list and set its two pointers properly else the face corners.$/ 7 # 7 0 and.$/ 7 7 # 7 7 to the two different faces /6. / 0 # 7 # 7 # # 7 0 and /6. / # 7 7 # 7 7 # # delete the face nodes and from the face list 2.5 add a new face node to the face list: 0 belong / # 7 7 # 7 7 # # 7 7 #.$/ #. / 0 # 7 # 7 # # 7 #.$/ add an edge node #2% in the edge list and set its two pointers properly. Subroutine E-Delete( 1. find the two edge-ends 2. if (the two edge-ends and. / 0 of the edge in the face list and.$/ 0 belong to two different faces 7 /!.$/ 0 # 7 # 7 # # 7 #.$/ and 7 7 / # 7 7 # 7 7 ## 7 7 #.$/ 7 0&0 then 2.1 delete the face nodes 7 and 7 7 from the face list 2.2 add a new face node to the face list: /!.$/ 7 0 # 7 # 7 # # 7 #.$/ # 7 7 # 7 7 ## delete the edge node from the edge list else 0 belong to the same face the two edge-ends and.$/ / # 7 7 # 7 7 ## 7 7 #. / #.$/ 0 # 7 # 7 # # 7 #.$/ 7 0& delete the face node from the face list 2.5 add two new face nodes to the face list: ' /!.$/ 7 0 # 7 # 7 ## 7 0 and /!.$/ # 7 7 # 7 7 ## delete the edge node in the edge list. Fig. 11. E-INSERT and E-DELETE on DLFL structure Theorem 5.3: Under the implementation on the DLFL structure, the running time of the operations V-CREATE and V-REMOVE is bounded by, while the running time of the operations E-INSERT and E-DELETE is bounded by, where is size of the involved faces (at most two faces get involved. We also point out that the operations V-CREATE, V- REMOVE, E-INSERT, and E-DELETE implemented on the DLFL structure have their running time independent of the valence of the involved vertices. VI. CONCLUSIONS AND FINAL REMARKS Topologically robust mesh modeling with a simple and powerful user interface has been important in computer graphics and computer aided-geometric design. In this paper, we have investigated some fundamental issues, including representations, data structures, and operations, for 2-manifold mesh modeling. We extended the theory of graph rotation systems studied in topological graph theory and showed the extended theory of graph rotation systems provides a solid foundation for 2-manifold mesh modeling. In particular, a mesh structure gives a valid 2-manifold structure if and only if it induces a valid graph rotation system. Based on this fundamental results, we examined previousely 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 validity of 2-manifold mesh structure on these data structures. We have also proposed a new set of operations on 2-manifold mesh modeling and proved that our operation set is complete and sound in the sense that all and only 2-manifold mesh structures can be constructed by sequences of operations from our set. Efficient implementations of our operations on vertex-based, edge-based, and face-based data structures are presented. Advantages of our operation set over the operation sets previously proposed in the literature are indicated. To close the paper, we offer some further remarks. Our fundamental theorem was proved for meshes in which multiple edges and selfloops are allowed. For simplicity, most our algorithms were presented only for meshes with no multiple edges and selfloops. It is very straightforward to extend our algorithms to mesh structures with multiple edges and selfloops. In fact, in a mesh with no multiple edges and selfloops, an edge-end is given as &+, where and are the two end-vertices of the edge. When multiple edges and selfloops are allowed, then we only need to give each edge two distinguisheable ends. An edge-end can still be written as, but now and are interpreted as the two ends of the edge. With this modification, all algorithms can be translated to work on meshes with multiple edges and selfloops. In some applications, it is also desired that the dual mesh is also given in a data structure for a mesh structure [13]. Briefly speaking, each face in the original mesh corresponds to a vertex in the dual mesh and each vertex in the original mesh corresponds 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 corresponds to traveling the edge-ends in the rotation at the corresponding vertex in the dual mesh (and vice versa. Our fundamental Theorem 3.3 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, while the vertices of the dual mesh can be recovered by call the algorithm FaceTrace to construct the corresponding face in the original mesh. In the edge-based winged-edge structure, we only need to re-interprete the components vstart, vend, fcw and fccw, and exchange the vertex components and the face components. Note that the components ncw, nccw, pcw, and pccw provide 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 edge-ends of the face, gives exactly the rotation at the corresponding vertex in the dual mesh. Therefore, the face-based face list in the DLFL

15 15 structure for the original mesh in fact gives an a vertex-based adjacency list for the dual mesh. By Theorem 4.1, the dual mesh structure can be constructed based on this list. So far our discussion is focused on modeling orientable manifolds. A surface is non-orientable if it contains a Möbius band [12]. There has been research interest in modeling nonorientable surfaces. For example, the edge algebra model and its company quad-edge data structure proposed by Guibas and Stolfi [13] can deal with both orientable and non-orientable surfaces. For our models, there is a simple extension based on graph rotation systems to represent non-orientable surfaces. Roughly speaking, if we also label each edge in a graph rotation system by either a twisted mark or a untwisted mark, then the extended rotation systems can be used to represent non-orientable surfaces. Intuitively, if we travel from one vertex to another vertex by following a twisted edge, we need to change the surface orientation. It is possible to revise our algorithms Facing and FaceTrace so that on an extended graph rotation system, it reconstructs the faces for the corresponding mesh. Following the same matter, we can prove that the extended graph rotation systems always represent valid (orientable and non-orientable 2-manifold structure, that the existing data structures for orientable 2-manifold mesh modeling can be augmented to deal with non-orientable 2- manifold mesh modeling, and that slight modifications on the operations in our operation set form a complete and sound operation set for orientable and non-orientable mesh modeling. We will deliberate this extension and development in a subsequent paper. The authors have obtained some related theoretical results recently [10]. The operation set proposed in the current not only is topologically robust and has efficient implementation, but also has the advantages that its operations are intuitive and closely related to common user-interface operations for mesh modeling, such as face subdivision, handle and hole creations, and connection of disjoint surfaces. Therefore, based on the efficient implementations of the operation set developed in this paper, many user-interface operations can be conveniently and efficiently implemented. Examples of such implementations on popular subdivision algorithms, such as Catmull-Clark scheme and Boo-Sabin scheme, can be found in our recent work [3], [4]. The main results in this paper provide a solid foundation for topologically robust mesh modeling systems. The systems are guaranteed that all structures during the modeling process are valid 2-manifold structures and that topological operations on meshes can be done very efficiently. Therefore, the powerful mesh modeler can be developed based on our theoretical work in which topological surgery operations and other modeling operations can be applied alternatively and efficiently. This is particularly useful for modeling operations that require valid 2-manifold structures such as most subdivision algorithms. Using the DLFL structure as a base data structure and the operation set proposed in this paper as the base operation set, we have developed a mesh modeler with a powerful and userfriendly user interface. We demonstrate a few examples of figures developed by our mesh modeler in Figure VI, which show how effectively and conveniently our mesh modeler can Fig. 12. Fig. 13. First group of images Creating a handle, creating a hole, and connecting two surfaces More images generated by our mesh modeler perform the topological operations such as creating a handle, creating a hole, and connecting two disjoint surfaces all these can be done by inserting a single edge to the underlying graph rotation system! Note that a high valent vertex may be generated by applying subdivision algorithms after inserting the single edge, as shown in the images in the middle colume in the figure. However, this can be easily improved by some local modification, as shown in the images in the right colume in the figure. Figure 13 gives some more delicate images generated by our mesh modeler. REFERENCES [1] A. V. AHO, J. E. HOPCROFT, AND J. D. ULLMAN, The Design and Analysis of Computer Algorithms, Addison-Wesley, Reading, MA, [2] 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 [3] E. AKLEMAN, J. CHEN, F. ERYOLDAS, AND V. SRINIVASAN, Handle and hole improvement by using new corner cutting subdivision scheme with tension, Proc. International Conference on Shape Modeling and Applications, (SM 01, (2001, pp [4] E. AKLEMAN, J. CHEN, F. ERYOLDAS, AND V. SRINIVASAN, Face reconstruction with subdivision schemes, International Journal of Shape Modeling, accepted. [5] E. AKLEMAN, J. CHEN, AND V. SRINIVASAN, A new paradigm for changing topology during subdivision modeling, Proc. 8th Pacific Conference on Computer Graphics and Applications, (PG 2000, (2000, pp [6] G. BAREQUET AND S. KUMAR, Repairing CAD models, Proc. IEEE Visualization 97, (1997, pp [7] B. J. BAUMGART, Winged-edge polyhedron representation Technical Report CS-320, (1972, Stanford University. [8] I. BRAID, R. HILLYARD, AND I. STROUD, Stepwise construction of polyhedra in geometric modeling, pp Academic Press, New York/London, [9] J. CHEN, Algorithmic graph embeddings, Theoretical Computer Science 181, (1997, pp [10] J. CHEN, J. L. GROSS, AND R. G. RIEPER, Overlap matrices and total imbedding distributions, Discrete Mathematics 128, (1994, pp