Citation |

- Permanent Link:
- https://ufdc.ufl.edu/UF00100800/00001
## Material Information- Title:
- Designing and implementing a surface modeling system
- Creator:
- Shiue, Le-Jeng, 1972- (
*Dissertant*) Peters, Jorg (*Thesis advisor*) Fishwick, Paul A. (*Reviewer*) Vemuri, Baba C. (*Reviewer*) - Place of Publication:
- Gainesville, Fla.
- Publisher:
- University of Florida
- Publication Date:
- 2001
- Copyright Date:
- 2001
- Language:
- English
## Subjects- Subjects / Keywords:
- Algorithms ( jstor )
Connectivity ( jstor ) Data models ( jstor ) Data smoothing ( jstor ) Geometry ( jstor ) Interactive systems ( jstor ) Libraries ( jstor ) Mathematical vectors ( jstor ) Polyhedrons ( jstor ) Vertices ( jstor ) Computer and Information Science and Engineering thesis, M.S ( lcsh ) Computer graphics -- Mathematical models ( lcsh ) Dissertations, Academic -- Computer and Information Science and Engineering -- UF ( lcsh ) - Genre:
- bibliography ( marcgt )
theses ( marcgt ) government publication (state, provincial, terriorial, dependent) ( marcgt ) non-fiction ( marcgt )
## Notes- Abstract:
- Subdivision surfaces and spline surfaces are widely used surface modeling techniques. Both techniques have some drawbacks when used in interactive modeling systems. Reevaluation of subdivision surfaces from start is prohibitively slow when updating small areas. For spline surfaces, the challenge is to maintain the smoothness across patches during the manipulation of control points of the individual patch. In this thesis, I designed and implemented a new modeling system that supports interactive smooth free-form 3D modeling. The system uses the PCCM algorithm (Patching Catmull-Clark Meshes) to transform an intermediate mesh of Catmull-Clark subdivision to a parametric surface consisting of NURBS (Non-Uniform rational B-Spline) patches. The PCCM algorithm is extended to support interactive surface modeling and to update the surface instantly while still enforcing the smoothness of the surface. This thesis also introduces a simple scheme for supporting the hierarchically subdivided polyhedron that serves as input to the PCCM algorithm and a new data structure that makes implementation of PCCM more natural. In addition, the new data structure supports the local updates of PCCM surface and makes the implementation easy and efficient. ( , )
- Subject:
- KEYWORDS: computer graphics, PCCM, surface modeling
- Thesis:
- Thesis (M.S.)--University of Florida, 2001.
- Bibliography:
- Includes bibliographical references (p. 47).
- System Details:
- System requirements: World Wide Web browser and PDF reader.
- System Details:
- Mode of access: World Wide Web.
- General Note:
- Title from first page of PDF file.
- General Note:
- Document formatted into pages; contains viii, 48 p.; also contains graphics.
- General Note:
- Vita.
- Statement of Responsibility:
- by Le-Jeng Shiue.
## Record Information- Source Institution:
- University of Florida
- Holding Location:
- University of Florida
- Rights Management:
- All applicable rights reserved by the source institution and holding location.
- Resource Identifier:
- 49877041 ( OCLC )
002729364 ( AlephBibNum ) ANK7128 ( NOTIS )
## UFDC Membership |

Downloads |

## This item has the following downloads: |

Full Text |

DESIGNING AND IMPLEMENTING A SURFACE MODELING SYSTEM By LE-JENG SHIUE A THESIS PRESENTED TO THE GRADUATE SCHOOL OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF MASTER OF SCIENCE UNIVERSITY OF FLORIDA 2001 Copyright 2001 by Le-Jeng Shiue ACKNOWLEDGEMENTS I owe my success in the research work and my career in computer science to my research advisor, Dr.Jorg Peters I benefited from his vision, his broad and deep knowledge and his rich experiences in computer graphics. I would also like to express my sincere gratitude to Dr. Paul A. Fishwick and Dr. Baba C. Vemuri for serving on my supervisory committee. I am especially grateful to my parents for their emotional support and encour- agement throughout my academic career. TABLE OF CONTENTS ACKNOWLEDGEMENTS ... ............. .......... iii LIST OF FIGURES ..................... .......... vi ABSTRACT ................... ....... ....... viii CHAPTERS 1 INTRODUCTION ............................. 1 1.1 Overview of Major Parametric Surface Representations ..... 1 1.2 Overview of The Surface Modeling System ............ 2 1.3 Contributions of The Thesis .......... .......... 4 2 BACKGROUND............ ....... .. ... ...... 5 2.1 Overview of CGAL ........................ 5 2.1.1 Halfedge Data Structure in CGAL ............. 6 2.1.2 Representation of CGAL Polyhedron ............ 8 2.2 Catmull-Clark Subdivision .......... ........ ... 9 2.3 Patching Catmull-Clark Meshes ....... ......... 13 2.3.1 Overview of PCCM ............... . . .. 13 2.3.2 Patch Transformation .............. .. .. 14 3 DESIGN OF THE REFINEMENT ALGORITHM . . . . ... 18 3.1 Design Issues ................ .... ....... 18 3.1.1 User Extended CGAL Polyhedron . . . . ... 18 3.1.2 Geometry Rules ................ ...... 18 3.1.3 Hierarchical Subdivision Polyhedron . . . . .... 19 3.2 Catmull-Clark Subdivision with CC scheme . . . . .... 23 4 DESIGN OF INTERACTIVE SURFACE MODELING . . ... 25 4.1 Design Issues ........ ........... ... ...... 25 4.2 Quad Polyhedron-Halfedge Data Structure + Quad ...... . 26 4.2.1 Quad Map .................. ..... .. 26 4.2.2 Quad Polyhedron ................... . . 27 4.3 Interactive Modeling with PCCM . . . . . . 32 4.3.1 Effect of Knot Insertion .................. .. 35 4.3.2 Effect of Corner Smoothing . . . . . ..... 40 4.3.3 Algorithm for Local Updating . . . . . ..... 40 5 CONCLUSION AND FUTURE WORK ....... .......... 42 5.1 Conclusion ................... ........ 42 5.2 Future W ork ............................. 46 REFERENCES ................... .............. 47 BIOGRAPHICAL SKETCH ............................ 48 LIST OF FIGURES 1.1 System diagram .............................. 3 2.1 Halfedge data structure .................. ..... 7 2.2 Structure of CGAL halfedge data structure. ..... . . . . 7 2.3 Incidental operations of halfedges in the halfedge data structure. .. 9 2.4 Structure of CGAL polyhedron. ............... .. .. 10 2.5 Euler operations .................. ........... .. 10 2.6 Catmull-Clark subdivision .................. ... .. 12 2.7 O-m esh ................................. .. 14 2.8 PCCM mesh ................ .. ... ........ 15 3.1 Mipmap polyhedron .................. ........ .. 20 3.2 Storage State .. .. .. .. .. ... .. .. .. ... .... .. . 21 4.1 Quad polyhedron .................. .......... .. 29 4.2 Initialization of the quad polyhedron ..... . . . . ..... 31 4.3 Knot insertion .................. ............ .. 32 4.4 Relations between I-mesh, O-mesh and quad polyhderon ...... ..34 4.5 Interactive Modeler .................. ......... .. 36 4.6 Influence region .................. ........... .. 37 4.7 Influence region of knot insertion ............... . .. . 39 5.1 Examples of the different steps of the surface modeling. . . ... 43 5.2 O-mesh and interactive modeling surfaces. . . . . . ..... 44 5.3 An example of modeling surfaces ............. . .. .. 45 Abstract of Thesis Presented to the Graduate School of the University of Florida in Partial Fulfillment of the Requirements for the Degree of Master Of Science DESIGNING AND IMPLEMENTING A SURFACE MODELING SYSTEM By Le-Jeng Shiue May 2001 Chairman: Dr. Jorg Peters Major Department: Computer and Information Science and Engineering Subdivision surfaces and spline surfaces are widely used surface modeling tech- niques. Both techniques have some drawbacks when used in interactive modeling systems. Reevaluation of subdivision surfaces from start is prohibitively slow when updating small areas. For spline surfaces, the challenge is to maintain the smoothness across patches during the manipulation of control points of the individual patch. In this thesis, I designed and implemented a new modeling system that sup- ports interactive smooth free-form 3D modeling. The system uses the PCCM al- gorithm (Patching Catmull-Clark Meshes) to transform an intermediate mesh of Catmull-Clark subdivision to a parametric surface consisting of NURBS (Non-Uniform rational B-Spline) patches. The PCCM algorithm is extended to support interactive surface modeling and to update the surface instantly while still enforcing the smooth- ness of the surface. This thesis also introduces a simple scheme for supporting the hierarchically subdivided polyhedron that serves as input to the PCCM algorithm and a new data structure that makes implementation of PCCM more natural. In addition, the new data structure supports the local updates of PCCM surface and makes the imple- mentation easy and efficient. CHAPTER 1 INTRODUCTION Applications such as special effects and animations require creation and ma- nipulation of complex geometric models of arbitrary topology. These models can be created by digitization or complex modeling packages. To represent different scales of detail, these models are often composed of high resolution meshes. These high resolution meshes cause the difficulty of interactive modeling and user interface of manipulating of the models. The contribution of this thesis is to create a new, simple and intuitive tool for a interactive modeling system. The focuses of the design of the system are the creation of simple mesh, intuitive modeling operations and instant 'i,, f.n : f' i'J.lt;li 1.1 Overview of Major Parametric Surface Representations The popular techniques for modeling smooth parametric surface can be broadly classified into two distinct categories: spline surfaces and subdivision surfaces. Spline surfaces usually consist of a set of smoothly joining individual paramet- ric patches. When treated individually and manipulated via separate control meshes, enforcing the continuity across the patches becomes very complicated. Subdivision surfaces are generated by recursively applying a set of mesh refine- ment rules. It can easily produce a tangent continuous limit surface. Users have to carefully select the initial mesh and manipulate the control points at different levels of the subdivision hierarchy since there is no direct and intuitive way to manipulate the limit surface. PCCM(Patching Catmull-Clark Meshes) [5] provides another way to generate and represent the smooth and complex surface. The PCCM algorithm transforms intermediate meshes of subdivision surfaces to parametric surfaces that consist of smoothly joining NURBS (Non-Uniform rational B-Spline) patches. Chapter 2 pro- vides the details of the algorithm and the representation. 1.2 Overview of The Surface Modeling System Figure 1.1 illustrates our surface modeling system. The system is subdivided into five sub-systems. 1. Mesh editor: For an initial mesh of arbitrary shape and topology, users can modify it by using geometry and connectivity operations. This stage will output the input mesh. 2. PCCM preprocessor: To build the mesh with required connectivity for PCCM algorithm, the preprocessor first checks if the input mesh only consists of quadrilateral facets. If not, it refines the input mesh to become all rectangles by calling a general quadralization function or one step of the Catmull-Clark subdivision. The result mesh of this step is called I-mesh. The preproces- sor then executes two steps of the Catmull-Clark subdivision generating the O-mesh as the input mesh for the PCCM algorithm. 3. PCCM transformer: Transform the I-mesh into the PCCM mesh consisting of the control nets of the parametric surfaces. 4. Surface generator: The surface generator evaluates the PCCM mesh as a set of NURBS patches and displays the resulting PCCM ,,,, f.i., PCCM Preprocessor I-Mesh Geometry Operations Connectivity Operations All facets quadrilateral ? Yes No Quadralization Surface Generator IPCCM Transformer ] Two Steps PCCM NURBS -Tw o-Step s -.... .......... .. ......... Catmull-Clark Subdivision Transformation Evaluation -O-Mesh PCCM Mesh-- - 0-Mesh PCCM Mesh f PCCM Surface Interactive Modeler Figure 1.1: System diagram of the modeling system(see Figure 5.1 for instances). Mesh Editor Initial Mesh Input Mesh 5. Interactive modeler: While users manipulate the O-mesh, the interactive modeler defines the influence regions of the manipulated vertices, then it "re- PCCM"s these regions and locally updates the PCCM mesh and the PCCM 1.3 Contributions of The Thesis The objectives of this thesis are the study of the PCCM algorithm, the ex- tension to the interactive modeling using PCCM and the extension of the CGAL library(see Chapter 2) to support the Catmull-Clark subdivision and the PCCM al- gorithm. This thesis describes an encoding/decoding scheme for supporting the hier- archically subdivided polyhedron that can apply to any generic CGAL polyhderon. The hierarchical polyhderon also serves as the input to the PCCM algorithm and sep- arates the algorithm and the data structure of refinement and transformation steps in PCCM. This thesis also introduces a new data structure, called quad polyhedron, and an interactive modeling scheme that make the local updating of the PCCM surface easy and efficient. CHAPTER 2 BACKGROUND In this thesis, the CGAL(Computational Geometry Algorithm Library) pro- vides core data structures. Modeling algorithms include Catmull-Clark subdivision[1] and Patching Catmull-Clark Meshes(PCCM) algorithm [5]. This chapter gives a brief overview of the CGAL and details of the modeling algorithms. 2.1 Overview of CGAL CGAL is a Computational Geometry Algorithm Library[6] that contains prim- itives, data structures, and algorithms for computational geometry. It was started six years ago in Europe in order to provide correct, efficient and reusable implemen- tations. CGAL consists of three 1 ,\' i-[G 4] and each layer is divided into smaller mod- ular units. The core library consists of basic functionalities such as configuration, assertions, iterators and enumerations. The second layer, the kernel library, con- sists of constant size non-modifiable geometric primitives such as points and lines and operations on these primitives. The third layer, the basic library, consists of basic geometric data structures and algorithms. CGAL also has a support library which contains functionality with non-geometric aspects such as visualization, circulator, number types, etc. The design goals for CGAL include robustness, generality, efficiency and ease- of-use. To fulfill these goals, developers of the CGAL opted for the generic pro- ,1,/,i,;i,,,i ,j'.ih, II L[3] in most of the design of CGAL. Hence, C++ templates[7] parameterized data types and functions-are heavily used and users have to specialize (specify template parameters of the data types or functions) the CGAL data struc- tures or algorithms with specific template arguments. After being specialized, CGAL classes can be used as normal C++ classes. By replacing the template parameters, users can horizontally extend the classes of the CGAL library. Users can also 'i, i; ..,//li extend CGAL classes by inheriting the classes to build an object oriented classes hierarchy. There are two different ways of extending CGAL by inheritance. First, a new class can be inherited from a special- ized class by treating it as a normal C++ class. Second, a new inheritated template class passes the template parameters) to the base CGAL template class. In the implementation of our system, CGAL classes are extended both hori- zontally and *, t //..,/// to support the modeling algorithms. 2.1.1 Halfedge Data Structure in CGAL Halfedge data structure[8] is an edge-centered data structure which main- tains the connectivity of the primitives-vertices, edges and facets (shown in Figure 2.1). Each edge is decomposed into two opposite oriented halfedges which store the pointers to the incident vertices and facets. Each facet is surrounded by a set of halfedges which are oriented counterclockwise as seen from the outside. CGAL separates the connectivity and geometry in the halfedge data structure as well as the primitive classes which specialize the halfedge data structure. CGAL halfedge data structure acts as a container which stores and maintains the connec- tivity information and the primitives store both the connectivity and/or geometry information. Figure 2.2 illustrates the design. The CGAL halfedge data structure, acting as a black box, stores three lists or vectors-depending on the type of the storage ci,,iiii .,li.,, users have chosen-of the primitives and maintains the inci- dent relation of the halfedge. On the other hand, the primitive bases are replaceable template parameters and can carry the geometry data, user defined data or even \ \, \\ I \ \ I I Incident Vertex OQ . - / / I I C)s Opposite Halfedge Halfedge Incident Facet 'o C) (-o "3 c) X =2 0 C) 0 0-------------------------- 0 Figure 2.1: In a halfedge data structure, each halfedge has five incident primitives. Users can traverse the mesh by using these incident relations. void pointer. Users can define their own primitive bases either by inheriting prim- itive bases from CGAL or by building new classes that comply with the functional requirements of the halfedge data structure. CGAL currently supports two types of halfedge data structure with different internal storage organizations. One is a dooli-lhi ., .l list and the other one is an STL std::vector[3]. A halfedge data structure using list has dynamic capacity and hence can easily add or remove the primitives. On the other side, a halfedge data structure Halfedge Data Structure * Storage Type * Type-Safe Pointer SVertex ---- Halfedge Facet Figure 2.2: Structure of CGAL halfedge data structure. Primitive Bases * Geometry Information * User Defined Information Vertex Base Halfedge Base Facet Base * Void Pointer using vector is efficient for pre-defined size of the primitives yet is very slow at adding or removing any primitives after the structure is created. Since vector structure does not use extra space to store pointer to the next element and can randomly access the elements in constant time, using vector is usually more efficient than using list on aspect of time and space. Both types of the halfedge data structures always add new primitives in the end of the internal storage structure. CGAL provides a set of primitive base classes for different level of functional requirements. Users can directly use these bases or adapt them to fulfill some special demands and functionalities. For example, users can instantiate a halfedge data structure that has only connectivity information by using CGAL::Vertexmin_base, CGAL::Halfedge_min_base and CGAL::Facetmin_base in which no geometry data are stored. Or, users can create a new vertex class, say with color, by inheriting CGAL::Vertex_min_base and adding a new member variable as the color tag. In CGAL halfedge data structure, operations are provided to access the prim- itives and to traverse the data structure. Although iterator and circulator are the primal interfaces of these operations, users can directly use the incidental operations of the halfedge to access and traverse the primitives of the data structure (shown in Figure 2.3). 2.1.2 Representation of CGAL Polyhedron A polyhedron is a 3-dimensional solid bounded by not necessarily planar facets. A polyhedron surface is a set of connected facets that bound a polyhedron. For simplicity, we will use polyhedron instead of polyhedron surface throughout the thesis. A polyhedron in CGAL is based on the halfedge data structure plus the ge- ometric constraints, internal data protections and high level operations (see Figure 2.4). CGAL polyhedron is also a template class of the halfedge data structure with specific storage model-vector or linked list. To maintain combinatorial consistency, A Sprev on vertex() \I \ \ \ I / '\ /f ,opposite() vertex() O AHalfedge I (facet() ) 0 w --------------------------O Figure 2.3: Incidental operations of halfedges in the halfedge data structure. a CGAL polyhedron only provides Euler operations as the modification interface (a subset is shown in Figure 2.5). 2.2 Catmull-Clark Subdivision Catmull-Clark subdivision[1] is an algorithm for i,. ,i,, bi generating limit surfaces. In each pass, the algorithm generates more regular vertices, which are valence 4, and consequently approaches the limit surface. For regular meshes that have only regular vertices, the algorithm generates a standard B-spline surface with C2 continuity. For irregular meshes, it generates a sequence of standard B-spline surface rings with C2 continuity except at the extraordinary vertices. After each pass of the Catmull-Clark subdivision, the result mesh is formed by a new set of vertices. Classified by the subdivision rules and the connectivity relation with the previous mesh, there are three types of the vertices in the refined mesh: facet vertices, edge vertices, and vertex vertices. Polyhedron * Combinatorial Integrity Vertex Halfedge Facet * Handles, Iterators, Circulators Halfedge Data Structure * Storage Type Vertex -Halfedge Facet * Type-Safe Pointer Primitive Bases * Geometry Information * User Defined Information Vertex Base (Halfedge Base Facet Base * Void Pointer Figure 2.4: Structure of CGAL polyhedron. . -.. Q-. AU split_facet(hl, h2) join_facet(h) .<0--. h split vertex(hl, h2) join_vertex(h) Figure 2.5: Only four Euler operations are shown here hl o0 vrO h 0 -4 O Denote the input mesh as 0-mesh and the mesh after the d-th pass be d-mesh. To generate the d-mesh, the 0-mesh needs to be refined d times generating the new geometry data and build the refined connectivity. To generate the geometry data of the vertices of d+-mesh, which is refined from d-mesh, Catmull-Clark subdivision has the following rules shown in Figure 2.6: Facet-vertex FVd+ = the average of all vertices surrounding the corresponding facets Fd of d-mesh. Edge-vertex EVd+ = the average of the midpoints of the corresponding edges Ed of d-mesh with the average of the two facet vertices of d+-mesh whose corresponding facets share the corresponding edges. Vertex-vertex Q 2R S(n 3) VVd+ = + -+ n n n where Q = the average of the facet-vertices of all facets adjacent to the vertex V. R = the average of the midpoints of all edges incident on the vertex V. -S = the corresponding vertex V. n = the valence of the corresponding vertex V. To build the connectivity of d+-mesh, Catmull-Clark subdivision has the following rules: Connect each facet-vertex to the edge-vertices of the edges surrounding the facet. Connect each vertex-vertex to the edge-vertices of the incident edges of the vertex. d mesh Catmull-Clark Subdivision d +mesh (a) Facet-vertex rule vl fv 1 EV fv2 fl E f2 ---------- ------ ------- -- ----- - v2 (b) Edge-vertex rule fvy1 ev1 fvn fl e1 fn ---------- ---- ------- ------ -- V I VV ev2 evn f2 ---- ---------- --... fv2 (c) Vertex-vertex rule O Geometry data Newly generated vertex Newly generated edge Figure 2.6: Catmull-Clark subdivision. FV 2.3 Patching Catmull-Clark Meshes 2.3.1 Overview of PCCM Patching Catmull-Clark Meshes(PCCM) [5] creates a set of large, smoothly joining bicubic NURBS patches from an input mesh consisting of all four-sided facets. The PCCM algorithm transforms each facet of the input mesh to a bicubic NURBS patch. The patches forming the output surface join parametrically C2 except at the extraordinary patch corners where they join with C1 continuity. The PCCM algorithm consists two procedures of generating the PCCM mesh from the input mesh. Mesh refinement, the first procedure, refines the input mesh, called I-mesh in the modeling system, to an O-mesh. An O-mesh consists a set of sub-meshes, called qmeshes, that one-to-one map to the facets of the I- mesh(see Figure 2.7). Each qmesh can be transformed to a quad-an array containing (2i + 1) x (2i + 1) entries, where i > 2. These array entries store the positions of the vertices of the corresponding qmesh. To generate the O-mesh, we use Catmull- Clark subdivision as the refinement algorithm. The number of the passes of the subdivision, denoted as i in previous equation, defines the size of the quad arrays. Since the patch transformation, the second procedure of the PCCM algorithm, accepts the quad arrays with arbitrary geometry data, the geometry rules of the Catmull-Clark subdivision are not mandatory and users can directly manipulate the vertices of the O-mesh. Patch transformation uses a quad structure initialized from O-mesh as the input data to generate the control nets of the patches forming the PCCM surface and ensures the boundary continuity across the patches. The transformation consists of two steps-knot insertion and corner smoothing. The first step ensures C2 continuity across the boundary of the patches except for extraordinary corners. The second step ensures the C1 continuity around the extraordinary corners. After patch 14 u: -3 0 3 6 3 0 0 -3 ... 30-------------------- 3- 6- 03 33 3- 3 ........................ .. .... ... .......... ........... ............ ........ ............ 00 30 0 -3 -3-------- -.......-...............................-............. Figure 2.7: The O-mesh consists of a set of connected qmeshes(shaded area). Each qmesh subdivides an I-Mesh facet(blue rectangle). The I-mesh corresponds to heavy black lines. The initial data of the quad array corresponds to the positions in the qmesh. A quad array contains (2i+ 1) x (2i+ 1) control points indexed by the Greville abscissa which are scaled by 3. transformation, the quad array contains (2i + 5) x (2i + 5) NURBS control points and would be input to gluNurbsSurface[9]. 2.3.2 Patch Transformation After refinement of the I-mesh, we will have the O-mesh structured as shown in Figure 2.7. Each quad, or P-mesh, corresponds to a facet in the I-mesh, and is a sub-mesh of the O-mesh. The quads surrounding a corner point, a vertex in the I-mesh, are arranged in counterclockwise order indexed by i, and the nodes Puv(i) is the uv node of ith quad. The double subscripts uv are the Greville abscissa, scaled 4 --------------------------- ---------- 2 - -- - -- --. -- --- -- - -- - --- - - - - - -- - .- - - 0 1- 2- 4- 4 - -- -- - -- -- - -- ---- -- - - 2 ----- -- --- --- -:------ ----I-------- 4 ----------- ------------ -- 2 -------------- --------- I i''''''''7 'T -y -- ---- ------- ---- 01 11 21 41 Figure 2.8: PCCM mesh: the enlargement shows the indices of the control points relevant for corner smoothing. Different corners have different orientation which is significant to the indices. The shaded area indicates the control points used and modified for corner smoothing. by 3, of the PCCM surface. After the knot insertion of the PCCM transformation, the refined mesh, called Q-mesh, looks like in Figure 2.8. The same indexing of the P-mesh is used for the Q-mesh except it is denoted by Quv(i) and the double subscripts uv are no more scaled by 3. The mesh without extraordinary vertex will stay unchanged after the corner smoothing, which is mandatory only when the corners of the quad are extraordinary vertices. After the transformation, the result mesh is called PCCM mesh It can be evaluated as the control points of a set of NURBS patches. These NURBS patches form the PCCM surface and are C2 continuity everywhere except at the extraordinary patch corners where are C1 continuity. Required O-mesh Connectivity An O-mesh consists of a set of chess board sub-meshes of equal size that contain at least (5 x 5) vertices. These sub-meshes should only intersect to each other on the boundary and cover the whole O-mesh. Each sub-mesh plus one ring of the facets surround it corresponds to a quad array in the PCCM mesh. Figure 2.7 shows an example of an O-mesh. Knot Insertion For each quad, we initialize the array with the qmesh which is one ring larger than the sub-mesh inside the corresponding facet boundary: we borrow one layer of nodes from all direct and diagonal neighbor sub-mesh(shown in Figure 2.7). To make each quad into standard interpolating form of an order 4 NURBS patch with uniform knots sequence, we insert three knots for Q1, Q2, and Q4-first at u direction and then insert other three knots at v direction. The new points Qui are obtained from the old points Pui via Qo = (P-3 + 4Po + P3)/6 Qi = (2Po + P3)/3 Q2 =(Po + 2P3)/3 Q4= (2P3+ P6)/3 All remaining Q3i,3j = P3i,3j, except for the corner point Qoo which we place directly on the Catmull-Clark limit surface: E nPoo (i) + 4P30( )+P33(i) Qoo = 4P3o(i) + P33(i) where n is the valence of the corner point n(n + 5) Corner Smoothing To obtain the tangent continuity instead of position continuity at the extraor- dinary corners, we need to modify the control points at the corners. The enlargement of Figure 2.8 shows the relevant double subscripts of Q-mesh after knot insertion. We define, for every n, two n by n matrices A, and B, with rows i = 1,... n and columns j = 1,... n and entries 2a 2 A,(i,j) = -cos( (i- j)) a = 1(default) and B (-1) ni-j = mod (n + i j, n). We collect the points Quv(i) E R3 generated by Knot Insertion for i = 1,... ,n and uv {00, 10, 20, 40} into Quv E RnX3. Only if n is even and greater than 4, do we compute r = (-1)Q40(i)/n and if r / 0 we add, for each i, hi = --l)r to Q40(i) = Q04(i- 1), 41(i) and Q14(i 1) so that E~ (-1)i4o(i) = 0 and Q40(i) = (Q41(i)+ 14(i 1))/2. Otherwise all coefficients remain unchanged except Qio = Qoo + AnQo, Q2o = (40 + 6Qo0 2Qoo)/5, 11 = Bn (Qi + c(2/) (40 Q20)) 6 For = 1,... ,n, we copy Qvo(i+ 1) = Qov(i) for v {1, 2, 4} and add Q20o(i)- 20o(i) to Q21(i) and Q1(i- 1). CHAPTER 3 DESIGN OF THE REFINEMENT ALGORITHM To build the required O-mesh connectivity, we use the Catmull-Clark subdi- vision as the refinement algorithm since it is widely implemented and used in current modeling systems. My design separates the connectivity and geometry rules in order to add more flexibility of changing the geometry rules dynamically. 3.1 Design Issues There are three goals of the design. First, the subdivision function must be able to apply to any user extended CGAL polyhedron. Second, the user can change the geometry rules of the subdivision by simply replacing the rule object. Third, the subdivision function must support a hierarchical polyhedron that allows tracing the relation of the primitives in different layers of the subdivided polyhedron. 3.1.1 User Extended CGAL Polyhedron To fulfill this goal, the subdivision is implemented as a template class in C++. Users can instantiate the subdivision class with their own specialized polyhedron class as the template parameter. The only requirement on the user extended polyhedron is that it must support a subset of Euler operations with the same interface(function names) as them in the CGAL(see Figure 2.5). 3.1.2 Geometry Rules To give the users more control of the shape of the O-mesh and PCCM mesh, users are allowed to extend the subdivision with different geometry rules. By plugging new geometry rules classes when calling the subdivision function, users can easily add more feature controls on the O-mesh. For example, blend ratio which controls the edge on the surface is one good feature that users can add to the subdivision implementation. To achieve this goal, I template the subdivision functions of the subdivi- sion class. A generic subdivision function-called quadralize _polyhedron in our implementation-in the subdivision class accepts a RULE class as the geometry rules. Two rule classes are currently supported. One is the average rule-every new gen- erated vertex is the average of all its incident vertices in the previous layer. The other is the standard Catmull-Clark rule that I mentioned in the previous chapter. Both rule classes provide three operations vertex-vertex rule, edge-vertex rule and facet-vertex rule. These three operations are mandatory for all user defined classes of the geometry rules. 3.1.3 Hierarchical Subdivision Polyhedron For PCCM, users need to collect the geometry data of the vertices into their corresponding quad (see next chapter) before transforming the patches. To collect the data, the system need some functions to trace back the hierarchical relation of the primitives between different layers of the subdivision polyhedron. For instance, given a vertex of layer i, the tracing function should return the corresponding vertex of layer i + 2. By building a 1y.p -l,, .,ron container, called mipmap polyhedron, which stores the subdivided polyhedron through the subdivision process, we can ;i,,i'l. ;tti, make the tractability available by storing the primitives in a specific order. A mipmap polyhedron is a simple vector which stores the sequence of the subdivided polyhedrons(see Figure 3.1). Every time the mipmap polyhedron gets subdivided, it adds a new layer-the subdivided polyhedron from previous layer-at the end of the vector. Hence, for an n-times subdivided mipmap polyhedron, it has n + 1 7,,, -, stored in the vector and the initial 1.~ 1;1,, ,Jron is at 7.'1, 1 0. To support tracing operations, we can build the tracing table that ,1 i/. ';tl registers the primitive Mipmap Polyhedron I Vertex List PO Layer 0 S+ : Edge List Subdivision Tracing I Facet List Operations Layer uPl Layer 1 I : Subdivision Figure 3.1: A mipmap polyhedron consists of a list of polyhedrons starting with the input polyhedron Po. A polyhedron Pj+i is subdivided from the polyhedron P in the mipmap polyhedron. Each polyhedron contains three primitive lists. The shaded areas in the primitive lists indicate the newly generated primitives by the subdivision. relation for every two layers in the mipmap polyhedron. Or we can i',, lI. Itll decode the tracing information by encoding the newly generated primitives with a specific storage scheme. Considering the saving of memory space and slightly sacrificing the speed, I chose the implicit scheme as the solution to support the tracing operations. The implicit scheme requires a specific storage order for initial and newly generated primitives. In any user extended CGAL polyhedron, these primitives are stored in three separate lists or vectors (vectors have speed advantage over lists) vertex list, edge list (edge is represented by 2 consequently stored halfedges) and facet list(see Figure 3.2(a)). After one step of Catmull-Clark subdivision, all the newly generated primitives will be added at the end of each list and have the same storage order as shown in the Figure 3.2(b). We call this storage scheme CC scheme since it is specific to Catmull-Clark subdivision. Definition 3.1 A primitive list can be represented as a string of indices of the primitives. For the p'.'ili ron of 'ii,, I in the mipmap p. 1',1, iron, VLi, ELi, and FLi are the vertex, edge and facet list of the y.1'.l;h, Jron and #vi, #e6 and #fi are vertex list (size = v) edge list (size = e) facet list (size = f) 1 2 ... v 1 2 ... e 1 2 ... f (a) Normal state vertex list (size = V = v + e +f) 1 2 ... v 1 2 ... e 1 2 ... f 1 2 ......... V edge list (size = E = 2e + 4f) 1 2 ... e 1 2 ... e 1 1 1 1 2 2 2 2 ... f f 1 2 ......... E -------------------------------------------- _' facet list (size = F = f+ 3f) 12 ... f 111222 2 ... f f f 1 2 F ---- (b) After one-step subdivision (b) After one-step subdivision Figure 3.2: The storage state of the primitive lists. Table 3.1: Tracing operations: the input of the tracing operations is the index of the primitive and the output is the index of the corresponding primitive or a set of the primitives. the size of each list. A primitive list with CC scheme has following storage state with the tracing operations defined in Table 3.1, AL = {VV2. } subdivision VLI+ = VLI O ELi o FLi ELi = {eie2...e } subdl"soi ELI+ = ELi o EL o FL4 FLi = {flf2 ...f##f} subision FLI1 = FLi o FLI where FLn = {fofo...fo fl...f#f n o is the string concatenation. Definition 3.2 If a p 1,1il, iron Ps subdivided from a p 1,1il, iron P stores the prim- itive lists ... -ni jtin CC scheme, Ps and P are CC scheme compatible and have complete tracing relations between them. For a mipmap polyhedron of depth L, we define the tracing operations for layer I as 'trac(pi) -+ pi+l' and 'trac(pi) -+ pl' where pi is the primitive index of layer I and 0 < I < L. There are 2 categories of the tracing operation-up-tracing and down- tracing-and each category has six operations (see Table 3.1). 1. Up-tracing operations Up-Tracing Down-Tracing Upvv(Ul) Vl+1 '" "'" (Vl) Vl-1 ], r'' f (vi) -- e_-1 l,,,,',, f(vi) -+ fi-i upe"(C) -+ v{i+1,'i } (ci) -- ef_1 upfv(fi) vi+ downff(fi) fi_1 upfe(fi) -f {el+1,el+i + 1, el+i + 2, el+ + 3} upff(fi) {fi +, fJ'+1, fJ+l 1, fi I + 2} (a) upvv(vi) -> v+1 : vi+l = vi (b) upev(el) -- v+1 : vl+l = el + #vi (c) upee(el) {ie+1,e' 1} : el+1 = el, e l = el + #el (d) Upfv(fi) v1+1 : v1+1 = fi + #vi + #e (e) upfe(fi) {ei+l, e+1i + 1, ei+1 + 2, ei+1 + 3} : ei+1 = el + #el + #e (f) upff(f/) --- {f+i, fl+1, f+1 + f1+1 + 2} : fl+1 = fl, fl = fi + #fi 2. Down-tracing operations (a) downv,(vi) -> vi-1 : v-1 = vi (b) downve(v ) -> e_ : 1el1 = vl #1-_1 (c) downvf(vi) fi- : fi-1 = vi #il-1 #el-1 Sezi, if el < #el_1 (d) downee(el) el-1i = #ei, if e #e_ ei #ei 1, if e > #ei-1 (e) downef (el) fi 1: fi- = (ei #ei-1 #ei-)/4 + 1 (f) down(fi) f f, Iif :f < #f f- (ft #fi-1)/3 + 1, if fi > #fj-i 3.2 Catmull-Clark Subdivision with CC scheme To make the subdivided polyhedron CC scheme compatible in the modeling system, the subdivision algorithm first ..'/,'i the initial polyhedron P, to the sub- divided polyhedron P1+1 and preserves the index order of the primitives. This step ensures VLi+1 = VLi ELI+1 = ELi FLi+1 = FLi Then, following the sequence of the edges stored in the edge list, add an edge vertex on each edge. Adding the edge vertex on a edge is equivalent to splitting the edge into two edges. Hence, the new edge is one-to-one mapped to the split edge. So far the lists become VLi+1 = VLi oELi ELI+1 = ELi o ELL FL+1+ = FLi Next step, the algorithm quadralize the facets following the sequence of the facets stored in the list. For each facet, it randomly select two neighbor edge-vertices and connect them with a new edge. On this new edge, it add a new facet-vertex and then connect the new vertex to all remaining edge-vertices around this facet. After this step, the primitive lists have one new vertex, four new edges and three new facets stored with facets storing order. Now, the lists become VL1+1 = VLi o ELi o FLi ELi+1 = ELi o ELi o FLf FLi+1 = FLi o FL and all the CC scheme operations are well defined. Algorithm 1 shows the pseudo code for this procedure. addVertex() and addEdge () can be implemented by using the Euler operations described in Figure 2.5. Algorithm 1 Catmull-Clark subdivision with CC scheme Require: input polyhedron (Pi-1) Require: output polyhedron (P1) Ensure: CC scheme primitive lists (VLI, ELI and FLi) in Pi P1 = P-_1 for i = 1 to size(ELI) do addVertex(EL [i]) end for for i = 1 to size(FLI) do vertex vl, v2 = randomly selected edge vertices of FLi[i] edge e = addEdge(vl, v2) vertex v = addVertex(e) addEdge(v, all remaining edge vertices) end for CHAPTER 4 DESIGN OF INTERACTIVE SURFACE MODELING For an interactive modeling system, real time feedback is the basic require- ment. To fulfill this requirement, the system needs a surface representation that not only provides a smooth surface but also can locally update a deformed region of the surface. In this chapter, I will introduce a new data structure-quad polyhedron-to be the surface representation and illustrate how to implement the PCCM algorithm and the local update of the surface using the new data structure. 4.1 Design Issues PCCM surfaces consist of a set of smoothly joining NURBS patches; hence, users can manipulate the control points of the meshes that reprented the PCCM surfaces to sculpture the surface. But this direct manipulation on the control points might destroy the smoothness condition across the boundaries of the patches. Instead of manipulating the PCCM mesh, the system will only allow users to manipulate the O-mesh and "re-PCCM" the O-mesh in order to enforce the smoothness conditions. To acheive the real-time feedback for an interactive system, we cannot afford to re- PCCM the complete O-mesh. Hence, the update region decided by the manipulation region must be restricted as small as possible yet still maintains the smoothness condition across the boundaries. The goals of my design will be as follows, 1. Maintain the smoothness condition: the patches should join paramet- rically C2 everywhere except at the extraordinary patch corners where they should join with C1 continuity. 2. Minimize the update region: only re-PCCM and update the smallest region that maintains the smoothness conditions. 4.2 Quad Polyhedron-Halfedge Data Structure + Quad The PCCM algorithm can be naturally implemented with an arr il-l.i,, data structure-the quad map[5]. But considering the requirements of the interactive system and the deficiencies of quad map listed below, an extended data structure the quad polyhedron will be introduced. 4.2.1 Quad Map A quad map contains a quad list storing the geometry data and a vertex list supporting the connectivity of the represented mesh. Each quad in the quad list stores a (2' + 5) x (2' + 5) array, where i is the number of passes of Catmull-Clark subdivision and i > 2, containing the geometry data of the vertices. The state of valid entries of the array will be varied along the PCCM transformation(see Figure 4.3). Each entry in the vertex list stores the indices of incident quads and the corner index of the incident quad corresponding to this entry. A quad map can be used to implement the Catmull-Clark subdivisionand then as the input of the PCCM transformation. The initial state of each quad contains a 4 x 4 array centered in the quad array. The initial array maps to the sub-mesh centered to the facet of the input mesh which has only four-sided facets. After i-times subdivision, the size of array grows up to (2' + 3) x (2' + 3) and has the valid data to proceed PCCM transformation. By enlarging the array to (2' + 5) x (2' + 5) in order to reserve the space for newly inserted knots, the structure is ready for PCCM. PCCM with this structure consists of two potentially parallel steps: a. For each quad, apply Knot Insertion. b. For each extraordinary mesh node, use the vertex list to collect Qoo(1) and Qv(i), uv e {10, 20, 40}. compute Quv(i), uv E {10, 20, 11}, Q20 2o and possibly Q40 40. distribute Quv(i), uv E {10,01,20,02, 11} and add to {21, 12} and possibly {04,40,14,41}. The quad arrays can be input directly to gluNurbsSurface or displayed as the quad mesh. There are some disadvantages in using the structure for PCCM: Weak connectivity information. Different orientation of the indices for different corners. Need to collect and distribute the data. A quad array is the smallest updating unit. The first two disadvantages make the code hard to implement and extend. The last two cause the inefficiency of the transformation and updating. 4.2.2 Quad Polyhedron Considering the disadvantages of the quad map, I build a new data struc- ture, named quad polyhedron, which combines the quad structure and the CGAL polyhedron(see Figure 4.1). Each facet in the quad polyhedron is a quad array just as it in the quad map. The initial quad array contains the vertices in the sub-mesh corresponding to the facet of the I-mesh. The halfedges in the quad polyhedron not only maintain the connectivity of the I-mesh but also a corner view and a shadow array corresponding to the incident corner of the halfedge. The corner view is an index reference array that does not store any valid geometry information but redirects the access to the actual position in the quad array. It works like an index mapping function for quad arrays. By using the corner view, accessing to the four corner regions of the quad array can be simplified to the same index orientation that is consistent to the incidental halfedge. The size of corner view is one quarter of the quad array and can be treated as an independent transformation unit. The shadow array has the same size as well as the same indexing scheme of the corresponding corner view, but it only exists when incident corner is an extraordinary vertex. The shadow array is an internal buffer which stores the geometry data right after applying knot insertion in quad array. It is used to speed up the update of the PCCM mesh and localize the influence region caused by corner smoothing. The first step of the algorithm to build the quad polyhedron is to build the same connectivity of the I-mesh. Then it initializes the quad array associated with each facet in the quad polyhedron. The initialization can be done parallelly for all quad arrays. Assume that we have an I-mesh IM generated form the input mesh I and a quad polyhedron QP having the same connectivity of IM. After locating facets F, in I, F,, in IM and Fqp in QP by traversing the corresponding facet lists concurrently, we can initialize the quad array of Fqp by using the CC scheme operations and polyhedron traversing operations. To initialize the quad array of Fqp, my algorithm first locates the center vertex and the corner vertices of F,,. Since the IM was i-times subdivided from I, all the center vertex and the corner vertices can be traced by CC scheme operations on F,. After locating the center vertex and the corner vertices, the algorithm sw. 1,.1i ,', , the orientation of the facets (F, and F,,) by matching the corner vertices in F, and Fi,. It then defines a pivot edge that always points to the first corner vertex in F,,. By traversing the IM starting with the pivot edge, the algorithm collects the - Shadow array ~~OZ NY[0 -- -0Z 0-- 1 0 f-----O )4- 11 11 21 1) 10 20 40 - Comer view Figure 4.1: Each facet in the quad polyhedron contains a quad array that has four corner views associated with each halfedge. The orientation of the indices in the corner view is consistent with the halfedge. A shadow array is only associated with the extraordinary corner and has the same size and indices of the corresponding corner view. O - I T 0 geometry data into the center region of the quad array. This procedure is shown in Figure 4.2. Algorithm 2 Building Quad Polyhedron Require: facet list in input mesh I: FLi Require: facet list in I-mesh IM: FLim Ensure: facet list in quad polyhedron QP: FLqp Build QP from I with the same connectivity for i = 1 to size(FLi) do vertex cv = downf,(FLi[i]) {v1, Vv 2, V 3, V {lst,2nd,3rd,4th} corner of FLi[i] {viT1n, vi2, Vim3, Vi 4} = Il'l {1, v V U4}) vim = the corner vertex traversed from cv by up and then left. synchronize the orientation between FLi[i] and FLim[i] by matching vim and {V V 3, V locate pivot edge pe that points to the corner vertex matching vim travse the submesh started from pe and collect the data into quad array of FLqp[i] end for Each quad array can be processed by PCCM transformation in parallel. The first step of PCCM algorithm applys the knot insertion in each quad array. First, it vertically and then horizontally scans and inserts new knots in the quad array. It then circulates the edge around each vertex using traverse functions of CGAL polyhedron and inserts the new value of corner knots. Since the corner views associated with each edge give us the unified accessing to the knots, the corner insertion can be very simple without synchronizing the orientation of indices. Figure 4.3 shows the change of the region of the valid data in the quad array through different steps of the knot insertion. In the second step of PCCM algorithm, it applys the corner smoothing in the vertex list and skips the ordinary vertices. Similar to the corner insertion, it uses the vertex circulator around the extraordinary vertex and the corner views to directly access the necessary data-it does not need to collect and then distribute the data as the quad map does. Before applying the corner smoothing, for each corner view associating the extraordinary vertex, the algorithm preserves the state of the corner -. Quad Polyhedron Quad:Arfay .. - / '' \ - - --- - - - - -- - ./ \ / / :::: \ / :::: \ : 4 . . . . . . . . . . . . . . . . . ..- - : - -- -- -- -- -1 -- --- -- -- -- --- -- -- -- -- ----- - /, \ .. / . ,- : : / : ^ : ^ --:--- ... x -- 7^7 . . .- -.-.-. . 1. . : .. : \\ - x Comer Vertex / 0-mesh * Pivot edge .- I - - - - - - - --.. . ; . . . . . - - - - - - - - Read in the data Figure 4.2: Initialization of the quad polyhedron: only the shaded region in the quad array has valid data after initialization and the valid region will grow up to whole array after the first step of the PCCM transformation. 2-time subdivision ;7 S I_ .. . . I ; I. . I-mesh Vertical Pass Pu Qu -3 0 3 6 3 0-3 0 1 2 4 6 4 2 1 0 -3 -3 0 0 3 3 Pv 6 Pv 6 3 3 0 0 -3 -3 Horizontal Pass Qu Qu 0 1 2 4 6 4 2 1 0 0 1 2 4 6 4 2 1 0 0 0 1 1- 4- ------ --- 4 ---- --- -- Qv 6 Qv 6 4 4 2 2 1 1 0 0 0----------- 0-------- Corer Insertion Figure 4.3: Knot insertion: the shaded area indicates the valid data. view by storing it in the corresponding shadow array. Since the shadow array has the same size of the corner view, the preservation only needs to call the copy operation from the corner view to the shadow array. 4.3 Interactive Modeling with PCCM For each facet f, of the input mesh, exists a corresponding submesh fmi in the I-mesh, called fmesh. frmi is a (2d + 1) x (2d + 1) array centered by the facet vertex FLi of fi, where d indicates the number of passes of the Catmull-Clark subdivision. Algorithm 3 PCCM using quad polyhedron Require: initialized quad polyhedron: QP Ensure: smoothly joining patches for each quad array QA in QP do apply vertical pass of the knot insertion apply horizontal pass of the knot insertion end for for each vertex v in QP do apply corner insertion of the knot insertion update all corresponded corners in quad arrays end for for each vertex v in QP do if v is an extraordinary vertex then apply corner smoothing in v using operation of the corner view end if end for For fmi, I define a qmesh qmi as the submesh that is one layer of the facet larger than fmi. Each qmi has a corresponding quad array qi of the quad polyhedron and the vertices of qmT specify the initial data in q;. Figure 4.4 illustrates these definitions. Apparently, any modification of the vertices of qmi will invalidate qi and trig- ger the updating of the corresponding patch. However, since the intersection of all qmeshes of the I-mesh is not empty, any change of a single vertex might cause the update of several quad arrays. To make the update region as small as possible, I equally divide the quad array into four sub-arrays adjacent to the center vertex and make these sub-arrays the update units for the update procedure. I call these sub-arrays corner quads since each of them associates with a corner vertex of the quads. --- corer - facet corer vertex ... O-mesh: quad initialization -- facet vertex fmesh qmesh Figure 4.4: Relations between I-mesh, O-mesh and quad polyhderon. I-mesh 2-times subdivision My update procedure is defined by two mapping functions: ki:V- C cs : C EV where V is a set of the vertices of the O-mesh, C is a set of the corner quads of the quad polyhderon, EV is a set of the extraordinary vertices of the quad polyhedron. Figure 4.5 illustrates the functionality of ki and cs functions in the interactive modeler. 4.3.1 Effect of Knot Insertion For each qmesh, I define nine exclusive equivalent sets of vertices, called in- fluence region, which are classified into three types V region, E region, and F region(see Figure 4.6). Each region contains a set of vertices and affects a set of cor- ner quads that define the update region. All vertices belonged to the same influence region should define the same update region. Definition 4.1 Primitive meshes and regions V mesh: a ring of incident facets to the corner vertex. E mesh: a 3 x (d2 3) array along the quad edge. The center of the region resides in the center of the quad edge. F mesh: a (d2 3) x (d2 3) array centered inside the fmesh. V region: the vertices in the V mesh. E region: the vertices in the E mesh. * F region: the vertices in the F mesh. - - -- - ---- - - -- - -i - PCCM -..:.. I...:..:. .. NURBS Transformation .... ... ..:. Evaluation O-Mesh PCCM Mesh PCCM Surface t Interactive Modeler t No, Local Surface Update Scorner smoothing Figure 4.5: Interactive Modeler U F Region Comer Quad Figure 4.6: For each quad, there four E regions and one F region. - I-Mesh O-Mesh are nine exclusive influence regions four V regions, V Region E Region For a set of manipulated vertices V = {vi, v2, ..., Vn, we define ki(V) = ki(vi) U ki(v2) U ...ki(vn). Let RV = {vl, v2, ..., v,} be one of these region vertex sets and a function rv(v) = RV, if vertex v in the O-mesh e RV. Since ki(RV) = ki(vi) U ki(v) U ...ki(vn) and ki(v) = ki(v) = ... = ki(vn), then ki(RV) = ki(v), where v i RV. Hence, ki(v) = ki(rv(v)) = ki(RV). Definition 4.2 ki function ki(v) = ki(rv(v)) = ki(RV) = the set of overlapped corner quads. ki({v, ...,Vn}) = ki(vi) U ki(v2) U ...ki(vn). ki(V region) = all corner quads that are adjacent to the corner vertex. ki(E region) = four corner quads that are adjacent to the quad edge. ki(F region) = four corner quads v,,i.i 11;, up the corresponding quad. Figure 4.7 details each influence region. For the two-pass knot insertion, an F region sits inside the center of the sub-mesh and intersects four corner quads making up the quad. Four E regions sit along the four edges and each intersects a pair of corner quads of two incident quads. Four V regions sit around the four corners and each intersects all corner quads around each corners. For corner insertion, since we need all P3 around the Po and Po itself, the influence region covers all these needed knots and has the same intersection as the V region in two-pass knot insertion. 0 3 6 3 6 3 6 3 0 3 6 I 0 3 -7 . . . . . ~~ - - -.. .-. . . . . . . . . . ~~ - - -.. .-. . . . . 6 3 0 3 6 I U F Region -Quad E Region - Sub Quad V Region Pre-Mesh Figure 4.7: Influence region of knot insertion: (a),(b),(c) indicate the three different influence regions caused by the two-pass knot insertion. (d) indicates the influence region caused by the corner insertion. i i - - - - .. . - - - - - - - - --.- - - - - - - - - - - - - - - - - - - - - - - 4.3.2 Effect of Corner Smoothing For an extraordinary vertex of valence n, there are n corner quads around the vertex. If any one of these corner quads gets updated by knot insertion, every one in these corner quads need to be updated by corner smoothing. Definition 4.3 cs function For a set of corner quads CQ q= {,q2, *..., qm} Sc() the corner vertex cv of q if cv is an extraordinary vertex. S0c otherwise. cs(CQ) = cs(ql) U cs(q2) ...cs(q,). Let CQ = {ql, q2, ..., q } be the update region of knot insertion, cs(CQ) re- turns a set of extraordinary vertices EV. Then we update the corner quads around the vertices in the EV by applying corner smoothing on EV. To speed up the updat- ing, we use shadow arrays that preserve the Q-mesh data before corner smoothing instead of applying the quad initialization and knot insertion on the corner quads that are not in the CQ. 4.3.3 Algorithm for Local Updating Algorithm.4 gives us the systematic look of how to use the functions we defined in previous sections to locally update the PCCM surface. Algorithm 4 Local updating Require: modified vertices MV = {mvi, mv2, ..., n} Ensure: smooth PCCM surface corner quads CQ = ki(MV) = ki(rv(mvi)) U ki(rv(mr2)) U ...ki(rv(mTV)) for each corner quad q in CQ do initialize q from the modified O-mesh apply knot insertion on q update corresponding shadow quad end for extraordinary vertices EV = cs(CQ) for each vertex v in EV do apply corner smoothing on v using shadow quads around v update corner quads around v end for update the PCCM surface CHAPTER 5 CONCLUSION AND FUTURE WORK 5.1 Conclusion In this thesis I presented an extension of the PCCM algorithm supporting the interactive manipulation of the surface. To make this PCCM algorithm and its extension easy and efficient, I designed the quad ,p.Ih,, ,ron and applied it to the implementation. This thesis introduced a simple encoding/decoding scheme, the CC scheme, that helps to trace the primitives relation of different level in a sequence of Catmull- Clark subdivided polyhedrons. I also presented a specific Catmull-Clark subdivision algorithm for generating the CC scheme compatible subdivided polyhedron. Using the tracing operations supported by the CC scheme, I introduced an initialization algorithm for the quad polyhedron. And then by applying PCCM transformation, we generate the PCCM surface represented by the quad polyhedron. Finally, this thesis talked about the interactive modeling PCCM surfaces. I define an influence region as a set of manipulated vertices in the O-mesh. Influence regions localize the update region of the PCCM mesh and surface and hence make the interactive modeling possible. Figure 1.1 illustrates the result mesh/surface of the different steps in my sys- tem. Figure 5.2 and Figure 5.3 show the resulting surfaces of interactive modeling. Initial mesh / Input mesh I-Mesh after one step subdivision O-mesh PCCM mesh PCCM surface Figure 5.1: Examples of the different steps of the surface modeling. I-Mesh Figure 5.2: O-mesh and interactive modeling surfaces. Figure 5.3: An example of modeling surfaces. 5.2 Future Work Much more work remains to be done to build a user-friendly interactive mod- eling system. Future work might include using the extension of LeSS(localized- hierarchy surface splines) [2] to support finer control of the surface, designing the boundary rules for the PCCM transformation and extending the manipulation to change the genus of the object. Another avenue of exploration, virtual tools are to be explored in my system. Currently, my system only supports a vertex displacement tool. Other virtual tools like edge sharpening, facet twisting and extrusion remain to be implemented. And the intuitive operations that do not require high precision are also good candidates to be supported in future system. REFERENCES [1] E. Catmull and J. Clark. Recursively generated B-spline surfaces on arbitrary topological meshes. Computer Aided Design, 10:350-355, Oct 1978. [2] C. Gonzalez-Ochoa and J. Peters. Localized-hierarchy surface splines. In S.N. Spencer J. Rossignac, editor, ACM S~, ,iumi'II on Interactive 3D Graph- ics, pages 7-15, 1999. http://www.cise.ufl.edu/research/SurfLab/papers/. [3] Nicolai M. Josuttis. The C++ Standard Library-A Tutorial and Reference. Addison-Wesley, Berkeley Califorina, 1999. [4] Lutz Kettner. Algorithm library design. Class notes of comp 290-001, U. of North Carolina, Spring 2000. http://www.cs.unc.edu/-kettner/courses/. [5] J. Peters. Patching Catmull-Clark meshes. SIGGRAPH 2000 Conference Proceed- ings, pages 255-258, 2000. http://www.cise.ufl.edu/research/SurfLab/papers/. [6] Stefan Schirra, Remco Veltkamp, and Mariette Yvinec, editors. Computational Geometry Algorithms Library online reference. 1999. http://www.cgal.org/. [7] Bjarne Stroustrup. The C++ P,. .ii.,,,,i,,.i L.,.I,.,i Addison-Wesley, Berkeley Califorina, 3rd edition, 1997. [8] K. Weiler. Edge-based data structures for solid modeling in curved-surface en- vironments. IEEE Computer Graphics and Applications, pages 21-40, January 1985. [9] Mason Woo, Jackie Neider, and Tom Davis. OpenGL Pi., .i/,immii.i Guide. Addison-Wesley, Berkeley Califorina, 2nd edition, 1997. BIOGRAPHICAL SKETCH Le-Jeng Shiue was born on December 1st, 1972, in Keelung, Taiwan. He received his B.S degree in electronic engineering from the National Taiwan Institute of Technology in 1994. He joined the University of Florida in August 1999 and started to pursue a master's degree in computer science. He is currently a research assistant of computer graphics and surface modeling for Dr. Jorg Peters and worked as a teaching assistant for the class of computer graphics in 2000. His research interests include data structure, algorithm, computer graphics and surface modeling. |