Hierarchical Editing and Rendering of Subdivision

Hierarchical Editing and Rendering of Subdivision Surfaces Kari Pulli Alias Wavefront University of Washington Seattle, WA j

Michael Lounsbery Alias Wavefront Seattle, WA j

Abstract

We describe a system for hierarchical editing of subdivision surfaces based on direct manipulation of control points on the surface. As an improvement over spline-based hierarchical editing, our system is capable of naturally designing piecewise smooth surfaces over arbitrary topological types. Our system is able to naturally model sharp features, and eases the burden of understanding the math when compared to spline-based systems. Because fast display is crucial for interactive editing, we also describe algorithms for eciently displaying the resulting surface.

1 Introduction 1.1 Motivation

We intend to provide an editing system that allows the user to quickly design free-form shapes of any detail, without his needing to worry about mathematical esoterica of continuity, parametrization, or topology. Previous methods of hierarchical editing based on re nement rules of B-spline control vertices [4] or wavelets [3] have proven themselves well suited for editing complex detail on a single B-spline patch. However, in order to competently construct a complete surface made from a network of B-spline patches, the designer must often manage subtle mathematical rules. We believe that subdivision surfaces, with their freedom of topological type and built-in continuity, are easier to implement in a way that frees the user from having to learn such detail. We believe that our implementation can allow the user the freedom to shape more directly the idea he has in mind.

1.2 Contributions

We have implemented a hierarchical method of editing subdivision surfaces of arbitrary topological type. We have chosen to use direct manipulation of control points as a means of providing the user with many advantages of interpolation without many of its drawbacks. Our system can build surfaces that are everywhere 1 (and nearly everywhere 2), or that have selected local discontinuities. For a hierarchical editor to be ecient for interactive design, it is important that the surface representation should not be overly expensive to display after a few edits at a very ne level. We describe an adaptive surface tessellation algorithm that adds more triangles around ne details and uses fewer triangles for smoother areas. To minimize display time, our algorithm only updates the portions of the surface which are involved in a particular edit. Our algorithm can also be used for automatic level-of-detail control when displaying subdivision surfaces in general. C

C

1.3 Subdivision surfaces

Subdivision schemes apply a series of local re nements to a polygonal mesh, where new vertices are computed and old vertices are modi ed as a local ane combination of neighboring vertices. The limit of this process is

a subdivision surface. The beauty of subdivision surfaces is that the local re nement rules apply regardless of the local connectivity. This allows them to work for surfaces of any topological type. Although subdivision surfaces are the limit of an in nite process, and the overall surface has no closed analytic form, the resulting surface may still be eciently displayed [10] and even integrated over [5]. There is a wide variety of subdivision schemes, including some which interpolate the polygonal mesh [14] and some which converge locally to 2 B-spline surfaces [1, 8]. Recent work by Zorin [13] indicates that subdivision surfaces of arbitrary continuity are possible. Modi cations by Hoppe et al. [6] permit subdivision surfaces with local creases and other discontinuities. Subdivision surfaces provide several advantages over splines. The chief among these is the ability to naturally model smooth shapes of arbitrary topological type. Although individual rectangular B-spline patches may be connected end-to-end with arbitrary continuity, it can be tricky for a designer to connect more complex con gurations of individual patches into even a 1 surface for some topologies. In general, building a smooth NURBS surface for an arbitrary shape requires a subtle understanding of how to manipulate the math behind B-spline continuity and parametrization. Moreover, these elaborate constructions are particularly dicult to maintain during animation, when the relative positions of constituent patches change within a model. In contrast, tangent-plane smooth subdivision surfaces of any realistic topology may be constructed with ease. Subdivision surfaces naturally maintain their overall smoothness by construction throughout the course of an animation, and require no additional constraints or expensive surface blends. Most objects in the real world are only piecewise smooth, and exhibit corners, sharp grooves, and creases. In spline surfaces, such features must be modeled using expensive trim operations or carefully constructed parametrizations. It can be dicult to model darts (disappearing discontinuities) in B-splines, and it can be dicult to isolate the eects of local parametrization tweaks. Relatively simple variants of subdivision surfaces naturally allow sharp features on otherwise smooth surfaces, and thus achieve a more compact and local representation of interesting geometry. We have chosen to implement our system using Loop's subdivision method [8]. Hoppe et al. [6] provide additional modi cations to Loop subdivision to provide sharp features such as creases and corners. Although their work does not describe surface editing, we nd their modi cations useful for selectively changing local continuity while editing a surface. Because Loop's subdivision scheme is a superset of triangular quartic 2 box splines, one can transfer most results of spline analysis when one restricts the construction so that all vertices in the control mesh are regular (regular vertices have exactly six neighbors, or four if the vertex is at a boundary) and no vertices and edges are tagged as discontinuous. C

C

C

1.4 Related work

Forsey and Bartels [4] describe a hierarchical method of editing B-spline patches. Their work allows the user to locally subdivide a rectangular B-spline patch to provide additional detail for modeling. This paper extends the ideas of Forsey and Bartels to subdivision surfaces. Finkelstein and Salesin [3] describe a waveletbased interface for hierarchical editing of B-spline curves and demonstrate that the same idea may be applied to editing a rectangular B-spline surface patch. Related subdivision surface work includes that of Halstead et al. [5], Lounsbery [9], Kurihara [7], and Zorin et al. [14, 15]. Halstead et al. describe a method for interactively editing Catmull-Clark surfaces [1] based on rectangular patches. They do not include a means for hierarchical editing or for changing continuity. Lounsbery's dissertation demonstrates an application of wavelets for hierarchical editing of subdivision surfaces; section 5.2 of this paper compares our method with wavelet-based methods of editing. Many of the above implementations are designed for interpolating subdivision schemes. Although interpolation of control points is often desired for editing, the resulting surfaces tend to have problems with their

visual appearance, or fairness. Halstead et al. require an additional optimization step to remove these unwanted side eects of interpolation. Non-interpolating subdivision schemes include the Loop method [8]. Based on triangular patches, the Loop scheme is everywhere tangent-plane smooth. It also converges nearly everywhere to curvature-continuous uniform B-splines, and thus retains their pleasing fairness properties. Although Loop's scheme is not interpolating, our direct manipulation interface can make it seem to the user as if it were. Kurihara [7] describes a system for hierarchical editing of Doo-Sabin surfaces [2] using direct manipulation. However, the only way that he adds detail and displays the result is to simply subdivide the entire surface up to at least the level of the nest edit, even in areas of the surface where there is no ne detail. As an improvement over this costly method, we use a more sophisticated triangulation scheme that adapts itself to regions of detail. Kurihara also does not consider local modi cation of subdivision rules to create sharp and smooth edges, and thus can only create the appearance of creases by constraining control points to lie near each other. In contrast, our surfaces can produce true creases on any edge without such arti cial constraints. Zorin et al. [15] have independently developed a multiresolution surface editor, also based on Loop subdivision surfaces. There are a few dierences between their work and ours. Their methods coalesces several ne level edits into fewer coarse level edits using Taubin's method for smoothing polygon meshes; our system currently does not have such capability. Their system implements only the basic smooth Loop surface, ours implements extensions to Loop's method that provide sharp features [6, 12]. Also, the methods for tessellating the surface for rendering dier.

2 Editing the surface

2.1 Setting the topological type

Our system is intended to be used for ab initio surface editing. The rst step in the design process is to lay out the topological type as a polygonal mesh. We rely on the existence of a separate system for interactively editing the initial polygonal mesh; any polygonal modeler with the basic operations of edge swap, split, collapse, connection and face removal will suce. The initial polygonal mesh, which we term the base mesh, is the topological frame on which we build our smooth surface. Any triangular mesh, of any topological type, is acceptable as a base mesh. In order to change the topological type of the surface, such as creating or lling a hole or joining separate parts of the surface, the designer must explicitly make the change in the base mesh.

2.2 Direct surface manipulation

The user is presented with two views of the surface being edited. One view shows the control mesh, while the other shows the shaded subdivision surface that results from evaluating in the limit the control mesh and the ner-level edits. The user may toggle the edge continuity types between smooth and sharp in the control mesh view, change the vertex type, and modify surface geometry by moving control points in either view. As shown in Color Plate 1(a){(c), the control points in the limit surface view are shown in their limit positions. This provides the user the appearance and feel of direct manipulation: rather than grabbing and moving a control vertex and observing indirectly how that aects the surface, one grabs directly a point on the surface and pulls it. Note, however, that the user can only pick the projection of a control vertex to the nal surface, not any arbitrary surface point. The eect of the edit is limited to the region of the surface immediately surrounding the point being moved. Editing a point at a deep subdivision level only changes the limit surface in the narrow neighborhood immediately close to the point, while editing at a coarse level has the eect of changing the surface (including its ner-level descendant detail) over a much wider region.

The limit position 0 of a control vertex 0 at subdivisionPlevel is calculated as an ane combination of n and its immediate level neighbors 1 , where the weights i sum to one. To n: 0 = i i i=0 achieve direct manipulation, we turn this equation around and solve for the control vertex location from the P known neighbors and the edited limit position: 0 = ( 0 ? ni=1 i i) 0 . Applying this for a single vertex is straightforward. If the user, however, selects several vertices that are moved in concert, this calculation is only applied to one of the vertices, while the other vertices are moved by the same amount. Under the Loop scheme, the in uence of a subdivision vertex extends to its same-level neighbors, and ends just short of their neighbors. Therefore, as Fig. 1(a) shows, the surface that results from our direct manipulation edit interpolates the desired position of the edited vertex, changes slightly at the neighboring vertices, and has no eect on any other same-level vertices. Alternatively, to strictly enforce interpolation at all level vertices (even when disregarding problems introduced by previous edits at ner levels), one would have to solve a global system, rather than our simple local equation. Even worse, strict interpolation can often cause unsightly wiggles and \ringing," as illustrated in Fig. 1(b). Our direct manipulation method avoids these problems. l

c

c0

j

j

c ; : : :; c

c

l

w c

l

w c

w

=w

j

0

1

2

3

4

(a)

0

1

2

3

4

(b)

Alternate methods of handling direct manipulation. Vertex 2 is being modi ed. Its same-level neighbors are vertices 1 and 3. (a) Our system adds to the surface a basis function that interpolates vertex 2 only. (b) Strict interpolation of vertices 1 and 3 would cause ringing.

Figure 1

2.3 Hierarchical editing

Following Forsey and Bartels, we store the ne-level data as an oset from the coarser-level data. Thus, it is possible for the user to place detail at a ne level, and have the detail move along relative to a change at a coarser level. This is convenient for changing the underlying ow of a shape while preserving its detail. It is also useful for an animation, where, for example, the entire limb can move or bend without distorting the detail it contains.

2.4 Selected discontinuity

While Loop's original method produces surfaces that are tangent plane continuous everywhere, Hoppe et al. [6] and Schweitzer [12] extended the method by introducing new local subdivision rules that produce sharp features. In our system all the edges and vertices are smooth by default. The user can change the type of a smooth vertex to be a cusp, a single point of 0 continuity surrounded by a 2 neighborhood like the tip of a cone. Also, any smooth edge can be changed into a sharp edge (a 0 crease between smooth sections) and vice versa. If there are at least three sharp edges incident to a vertex, the vertex type is a corner. If there is only one incident sharp edge, the vertex type is dart, and the crease there blends smoothly into the smooth surface. Our system allows changing the vertex and edge continuity types at any level of subdivision. Normally, ner-level vertices and edges inherit the types of their parents, and vertices derive their types based on the C

C

C

incident edges. When the user overrides an inherited type, the resulting change is similarly inherited at deeper levels.

3 Rendering issues

Subdivision surfaces are de ned through a process where an increasingly dense polygon mesh converges towards a limiting surface. Although in non-interpolating subdivision schemes, such as the extended Loop's scheme, the vertices of the mesh do not in general interpolate the actual surface we can easily calculate a nal position and normal vector for each vertex. This allows us to render a relatively sparse mesh such that the result hardly diers from a denser version [10]. Although rendering a surface at a global uniform subdivision level is practical for normal subdivision surface de ned by a control mesh, it is not practical in a system that allows the surface to be re ned at a ner level. In such a case, a single edit four levels deep would force a triangulation with 44 = 256 times the number of triangles required otherwise. In this section, we describe rules for adaptively subdividing the surface in areas of ne detail. Because naive adaptive tessellation leads to cracks in the surface, we also describe how to ll these cracks.

3.1 Adaptive tessellation

3.1.1 Separate the in uence of an edit

Figure 2(a) displays a 2D view of the smooth basis function that is added to the surface when a vertex is edited. The surface within a 2-ring (illustrated in Color Plate 1(d)) changes, and most of the change concentrates around the modi ed vertex. Outside the 2-ring the surface is not aected by the modi cation, so we only need to retriangulate the aected surface area. Figures 2(b) and (c) present two possible tessellations around an edit. In both cases, we assume that vertices 0{4 exist in the current tessellation, and vertex 2 is edited. In the rst case subdivide the triangles immediately surrounding the vertex once (in the 2D image the edges incident to vertex 2 are subdivided), producing a relatively crude polygonal approximation of the basis function. In the second case we rst subdivide all triangles within 2-ring once, and then the immediately neighboring triangles once more, producing a fairly good polygonal approximation of the basis function. The two choices provide provide a trade-o between the speed of interaction and the delity of rendering. On a graphics workstation one could subdivide the base mesh uniformly twice as a default, and use the ner tessellation around an edit, while on a more modest computer one could choose to display fewer triangles by subdividing the base mesh only once and subdividing only the triangles immediately around an edit. 0.6

0.6

0.6

0.5

0.5

0.5

0.4

0.4

0.4

0.3

0.3

0.3

0.2

0.2

0.2

0.1

0.1

0.1

0

1

2

3

4

0

1

2

3

4

0

1

2

3

A 2D diagram of tessellation: the subdivision basis function, a sparse tessellation, a possible better approximation.

Figure 2

4

3.1.2 Other subdivision heuristics

In addition to displaying the eects of ne detail edits, another reason to subdivide triangles is to balance rendering quality versus quantity of triangles for the desired level of detail of the output. One heuristic towards this end is to compare the limit normal vectors at the vertices at either end of an edge. When the normal directions dier by more than a given threshold, we subdivide the triangles on both sides of the edge. This threshold can be xed, or it can change depending, for example, on the viewing distance or the relative size of the object on the screen. This heuristic works best on the smooth parts of the surface. Color Plate 1(h) shows that at a sharp crease comparing surface normals is not enough. Imagine two almost planar surface regions connected by curved crease. With a sparse tessellation the surfaces may be approximated quite well and the neighboring normals are almost paralle. However, the connecting crease may appear quite jagged, as emphasized by the red arrows in the gure. Therefore, we also compare the tangents in the direction of the crease, and subdivide when the tangents dier by more than our threshold.

3.2 Closing cracks

If we simply render all the triangles introduced by the editing operations, cracks appear at

T-vertices, locations where a neighbor of a triangle is more nely subdivided (see Fig. 3).

We considered three possible approaches to ll the cracks: (1) projecting the ner level vertices to the coarser level edges, (2) adding extra vertices to the coarser level triangles and performing an irregular tessellation, and (3) lling the crack with an extra polygon. Figure 3: Cracks After experimenting with the rst and second approaches, we nally settled on choice may appear at T(2)|irregular tessellation; the third approach is clearly inferior to either of the other vertices. approaches. 3.2.1 Projecting points to edges

Figure 4 illustrates how the cracks can be closed by projecting a ne level vertex to a coarse level edge. This projection can be incorporated very naturally in our subdivision algorithm. When calculating the limit location of a vertex rendered on the limit surface, we rst check whether the vertex lies on the edge of a coarser level neighbor. If it does not, we calculate the true limit location using an appropriate weighted sum of the vertex and its neighbors. If it does lie on such edge, we linearly interpolate the nal locations of the parent vertices. Because the parent vertices Figure 4: Filling a crack by are either the endpoints of the shared edge, or have themselves been projected projecting a vertex to an edge. to the edge, the new vertex must lie on the edge as well. It is easy to see that this recursive method works no matter how many levels of dierence exist across the edge. Although this method correctly closes all the cracks and works naturally with our regular subdivision method, but there are two drawbacks that are illustrated in Color Plate 1(i){(l). The rst drawback is obvious but not very serious: since we constrain vertices to lie on a straight line, the surface geometry becomes atter than necessary, although this is only apparent at silhouettes. The second drawback is more serious. Individual triangles are Gouraud shaded by calculating rst the color at the triangle corners and then interpolating the colors across the triangle. If we consider an edge with diering triangle resolutions, the pixel colors on the coarser side are interpolated from the vertex colors. The ner side shares the colors at the end vertices (in case of a smooth edge), but introduces new colors at the intermediate vertex locations. With a curved surface and any arbitrary (but xed) normal vector at a ner level vertex, the interpolated color on one side of the edge is not likely to match the shaded color on the other side. If by chance they should match, small rotation of the object with respect to light sources is enough to cause mismatch. The result is that the vertex appears to have separate normal vectors on each side of the edge, making a smooth edge appear as if it were a crease.

3.2.2 Irregular tessellation

The second approach produces much better results with only a slight increase in implementation complexity and nal polygon count. In this method, every vertex is rendered using the true limit locations and normals, and the tessellation has no T-vertices. The previous approach performed the extra work while traversing the ner level triangles. Now the ner triangles are rendered as they are, and their coarser neighbors are split into smaller triangles. First, we recursively collect all the ner level vertices on the edges. Figure 5 shows how the triangle is then covered by either one or two triangle fans. If only one of the neighbors has ne level vertices one triangle fan centered at the opposite vertex is enough, otherwise two fans centered at vertices next to corner vertices is enough. The irregular tessellation is also illustrated in Figure 5: Using one or two triangle fans can prevent cracks. Color Plate 1(f) and (g).

4 Implementation 4.1 Data structures

We implement the base mesh as a double-edged data structure that stores the base control vertices and the vertex and edge continuity types. Within faces of the base mesh, we have quadtrees of triangles, one tree per base mesh face. For storing and indexing the quadtree, we use data structures similar to those of Schroder and Sweldens [11]. Because each quadtree also points to its neighbor at the base mesh level, we can traverse the recursive data structures without referring explicitly to the base mesh structure. This is illustrated in Figure 6. Each node in the triangle quadtree contains six vertices: three old vertices in the corners that are inherited from the immediately coarser level, and the three vertices that are introduced at the current level on the edges Figure 6: A connected forest of the triangle. of triangle quadtrees. The forest of triangle quadtrees contains all the vertices that are displayed, along with their ancestors. However, since we need the 1-ring neighbors for calculating the nal location and normal vector for each displayed vertex, we also have to include those (and their ancestors). Note that each vertex is in general replicated at a deeper level, whereas Schroder and Sweldens store each vertex only once. In our case, however, the same vertex can be edited at any level of resolution, and therefore requires explicit representation at all levels down to the display level. The overhead of multiply storing coarser-level vertices is really quite small, and is never more than 1 3 the number of vertices at the nest level. We believe that the overhead pays for itself by acting as a cache of the surface calculations. =

4.2 Updating local edits

A vertex or edge may be modi ed by changing its position or continuity. When this happens, the surface in the neighborhood of the change needs to be updated and redrawn. When a vertex is modi ed, that vertex, its immediate neighbors, and their immediate neighbors are all invalidated, together with their descendants. To display the next frame, we need to recalculate only the invalidated vertices. When a level vertex is modi ed, it is not necessary to update information at levels . j

j

0

< j

4.3 Storing the edits as osets

Forsey and Bartels [4] and Kurihara [7] store the local edits as osets that are expressed in a local coordinate system based on the surface normal. This causes the details to retain their relative shape when the surface is later edited at a coarser level. However, this approach depends on each vertex having a unique normal vector around which to build the local frame. In our case, the vertices and edges that are speci ed by the user as being only 0 do not have a unique normal. However, we do not need to attach the local frame to an actual normal, we only need to attach it to something that naturally follows the surface.1 Hence, we can calculate the normal vector using the smooth normal rule, regardless of the vertex type, and use that to create the local frame. The normal vector alone is not enough to build a frame { another vector is needed to x the rotation around the normal. The smooth normal of Loop's method is calculated from two tangent vectors, which again are calculated from a weighted sum of the neighboring vertices. If we can consistently determine from which neighbor we begin the tangent calculations, we have a consistent way for building the frame. Within a single editing session, we can start from the neighbor with the smallest index or storage location. Because this method is not likely to stay consistent across storing and reading the model back from a le, the edit coordinates may be stored in object-centered coordinate system and converted back to local coordinates upon reconstruction from a le. The local coordinate system is only an abstraction that allows the details to follow coarse level changes. If we were to store the edits in local coordinates, then whenever we need the vertex positions we could recalculate the local frame (or consult a cache of local frames we have saved) and transform the edit into local frame. However, we can save computation and avoid the need to save the frame by storing the edits always in global coordinates. When an edit is applied that would change the local frame, we only need to calculate how the edit rotates the local frame and apply the same rotation to the stored edit. Detecting this is easy: the local frames change exactly at vertices whose local normals are invalidated (as described in Section 4.2). C

4.4 Summary of the subdivision algorithm Figure 7 presents a summary of our method. First, we start with a base level mesh. The user then selects a subset of control vertices at a particular level of subdivision to be available for editing. Once a vertex is grabbed and moved, we calculate a new edit oset based on the location indicated by the user. All the information that is in uenced by that vertex are invalidated. If any of the invalidated vertices contains an edit oset, we temporarily calculate the old local frame. The next step is to redo the subdivision process for the invalidated vertices, one level at a time. The surface is rendered by traversing the forest of quadtrees top-down. If a triangle has been marked for rendering and none of its neighbors is rendered at a ner level, we simply render the triangle. Otherwise, we collect the vertices on the edges of the triangle and render the triangle as one or two triangle fans. The system repeatedly makes vertices available for editing, edits them, and displays the results. 1

Thanks to D. Zorin for pointing this out.

(0) Create a base mesh (1) Display the limit surface and a collection of control vertices on it (2) Grab a vertex and move it • Calculate an edit offset • Invalidate limit locations and normals for all the vertices affected by the edit at the edit level and for their descendants • Calculate new control vertex locations for vertices that were invalidated by the edit • Calculate new final locations and normals (3) Render the surface • Recursively traverse the data structure and render the triangles that have been marked for rendering using the final locations and normals If the triangle has finer level neighbors, collect vertices on the edges and render as 1 or 2 triangle fans

Figure 7:

Summary of the subdivision algorithm.

5 Discussion

5.1 A modeling example

Color Plates 2 and 3 illustrate the process of modeling a detailed hand using our system. Color Plate 2(a) shows a simple frame of triangles laid out with a polygonal modeler. Connecting the ngers to the main part of the hand is a dicult problem when modeling with B-splines, but it is handled naturally using a polygonal frame. Color Plate 2(b) shows the smooth subdivision surface that is displayed immediately after importing the polygonal frame, before any editing work has been done by our system. In Color Plate 2(c), we have formed knuckles by subdividing the base mesh and bending it upward; in Color Plate 2(d), we have modeled wrinkles by tagging selected edges as sharp. Color Plate 2(e) shows the control mesh for these features. Color Plate 2(f) shows the nal hand, with detailed ngernails. Color Plate 3(a) shows the result of our triangulation algorithm on the completed hand model. It shows the tessellation at the ngertips and the coarser subdivision elsewhere. The detail possible with our hierarchical system is seen up close in Color Plate 3(b)|the nail itself is modeled by a 0 crease at the tip, while the cuticle is modeled by a smooth groove modeled at a ne level. Color Plate 3 also shows an example of adding detail to a previously modeled subdivision surface. The input mannequin head of Color Plate 3(c) was built by Hoppe et al. [6] from scanned data. We imported it into our system to model more realistic detail in the eyes. Color Plate 3(d) shows the result. C

5.2 Comparison with wavelet-based methods

Wavelets have several advantages that make them attractive for function approximation and surface tting. As compared to a collection of nested families of basis functions, wavelets provide a unique representation for the function or surface and provide ecient least-squares (or close to it) approximations. Nevertheless, we feel that a system that is built directly from the basis functions at dierent levels of resolutions avoids several disadvantages that result from a purely wavelet-based system. An explicit wavelet representation of shape could be built into our system relatively easily. However, we believe that the user would prefer not to deal directly with the wiggly shape of the bare wavelet. In order to mask this, several wavelet coecients must be modi ed in concert, producing a result that is qualitatively similar to modifying a single basis function coecient. When more coecients are thus modi ed, relatively simple surface tessellation and rendering methods necessarily aect more vertices and require an update of more triangles in the model. One could of course try to obtain a relatively accurate approximation for rendering purposes by dropping some of the small magnitude wavelet components, but there are still more modi ed coecients than result from directly editing the basis functions. Moreover, it seems roundabout to have to translate the basis function shape that the user controls into a wavelet representation, and then back into a basis function for display. We can still combine wavelet methods with our present system to compress the result and to provide a unique representation of the shape (non-uniqueness of our present system comes from the fact that a single coarse basis function could identically represent a collection of ner level edits). As a post-process, we could perform a wavelet analysis of the surface to obtain a unique representation, then convert the result to a sum of scaled basis functions in a coarse-to- ne order. The main reason why we cannot do this now is that we want to use the sharp features provided by the extensions of Hoppe et al. to the Loop scheme. Combining these with wavelets would seem to require the development of special wavelet techniques. For this reason, we are unable to implement our system with wavelets alone. To summarize, we believe that although wavelet-based methods may have some advantages when tting a preexisting complex surface, we can get a simpler and faster implementation and a simpler surface representation in our interactive editing environment. Further, we don't know how to perform wavelet analysis for sharp and smooth features.

5.3 Future work

Even though we have provided a rendering method to adaptively re ne the surface tessellation, we don't yet have a similar mechanism for concisely presenting the control vertices to the designer while modeling. Thus, when the user edits the surface at the th level of re nement, the current implementation subdivides globally times, showing all control points on the th level. Clearly this ineciency is not practical in a production editor|it is more useful to only subdivide the surface locally in the region being edited. It should be no great diculty to provide this improvement with our current structures. Algorithms to render subdivision surfaces are no more complicated in essence than algorithms that currently render B-spline surfaces in hardware [10]. We believe that hardware-supported rendering of subdivision surfaces would make these surfaces even more ecient for interactive design. j

j

j

5.4 Conclusion

In this paper, we have described a system for hierarchical editing of subdivision surfaces. We have demonstrated that our system may be used to eectively model shapes of complex topology and ne detail without requiring a complex understanding of math on the part of the designer. Fast surface display is important for interactive editing. Therefore, we have designed algorithms for quickly drawing subdivision surfaces. We have demonstrated that the result of these algorithms leads to a more ecient display of surfaces designed at multiple levels of detail.

References

[1] E. Catmull and J. Clark. Recursively generated B-spline surfaces on arbitrary topological meshes. ComputerAided Design, 10(6):350{355, September 1978. [2] D. Doo and M. Sabin. Behavior of recursive division surfaces near extraordinary points. Computer-Aided Design, 10(6):356{360, September 1978. [3] A. Finkelstein and D. Salesin. Multiresolution curves. In Proceedings of SIGGRAPH '94, July 1994. [4] D. Forsey and R. Bartels. Hierarchical B-spline re nement. In Proceedings of SIGGRAPH '88, August 1988. [5] M. Halstead, M. Kass, and T. DeRose. Ecient, fair interpolation using Catmull-Clark surfaces. In Proceedings of SIGGRAPH '93, August 1993. [6] H. Hoppe, T. DeRose, T. Duchamp, M. Halstead, H. Jin, J. McDonald, J. Schweitzer, and W. Stuetzle. Piecewise smooth surface reconstruction. In Proceedings of SIGGRAPH '94, July 1994. [7] T. Kurihara. Interactive surface design using recursive subdivision. In Proc. Communicating with Virtual Worlds. Springer-Verlag, June 1993. [8] C. Loop. Smooth subdivision surfaces based on triangles. Master's thesis, Department of Mathematics, Univ. of Utah, 1987. [9] M. Lounsbery. Multiresolution analysis for surfaces of arbitrary topological type. PhD thesis, Department of Computer Science and Engineering, Univ. of Washington, September 1994. [10] K. Pulli and M. Segal. Fast rendering of subdivision surfaces. In Proc. 7th Eurographics Workshop on Rendering, June 1996. [11] P. Schroder and W. Sweldens. Spherical wavelets: Eciently representing functions on the sphere. In Proceedings of SIGGRAPH '95, August 1995. [12] J. Schweitzer. Analysis and application of subdivision surfaces. PhD thesis, Department of Computer Science and Engineering, Univ. of Washington, 1996. [13] D. Zorin. C k continuity of subdivision surfaces. Technical Report CS-TR-96-23, Dept. of Computer Science, California Institute of Technology, Pasadena,CA, 1996.

[14] D. Zorin, P. Schroder, and W. Sweldens. Interpolating subdivision for meshes with arbitrary topology. In Proceedings of SIGGRAPH '96, August 1996. [15] D. Zorin, P. Schroder, and W. Sweldens. Interactive multiresolution mesh editing. Technical Report CS-TR-9706, Dept. of Computer Science, California Institute of Technology, Pasadena,CA, 1997.