NURBS in VRML

NURBS in VRMLHolger Grahn, Thomas Volk, Hans J. Wolters*blaxxun interactive*Hewlett Packard LaboratoriesABSTRACTIn the days of VRML 1.0, NURBS seemed to be too complex tobe adapted to the specification. Current development of hardwarecompels us to reevaluate this idea: While CPU clocks break the 1-GHz barrier, users still have to cope with 56K modems. NURBSmeet exactly these demands. A NURBS description is a compactstorage form, but its evaluation requires more computationaleffort. In addition, NURBS can be utilized for morphing effectsand they provide a means for a smooth LOD. Adopting trimmedNURBS allows visualization of complex CAD models in VRML.This paper gives an overview of the proposed nodes and theirimplementation and applications. We take a closer look at LOD,animations and trimmed NURBS. Finally, we look ahead andbriefly touch on an emerging new representation, subdivisionsurfaces.Keywords: NURBS, trimmed NURBS, parametric surfaces,subdivision surfaces1. INTRODUCTIONDuring the design of VRML 1.0, the specification was closelyaligned with OpenInventor [sgi]. A lot of concepts of Inventorwere adopted in VRML 1.0 and passed on to VRML 2.0.Nevertheless, the NURBS primitives of Inventor were left out,because NURBS had been too CPU-intensive at the time and thedescription was seen as too complex compared to conventionalprimitives. Nowadays the average Internet connection cannot feedthe CPU and the modern graphics subsystems a sufficient amountof data to keep them busy. That means that the applications arebandwidth-limited. Hence, adopting NURBS to the VRMLspecification seems to be the next logical step in the furtherdevelopment of Web-based graphics when taking into account thecurrent development of hardware and infrastructure._____________________________________________________Holger Grahn, holger.grahn@blaxxun.de, blaxxun interactive,Elsenheimerstr. 61-63, 80687 Munich, Germany.Hans J. Wolters, wolters@hpl.hp.com, Hewlett PackardLaboratories, 1501 Page Mill Rd, Palo Alto, CA 94304Thomas Volk, thomas.volk@blaxxun.de, blaxxun interactive,Elsenheimerstr. 61-63, 80687 Munich, Germany.In the first section, we will give a short introduction to NURBSand trimmed NURBS. A comprehensive description of NURBScan be found in [PT95] and [Far96]. In the second section, theproposed nodes are introduced; the complete nodes proposal canbe found at [bla1]. In the third section, we will addressimplementation issues. The results of our implementation areshown in the following section.NURBSA point on a NURBS surface is defined by:∑Q(u,v)=u,vBkVwmu mvi= 0∑j = 0Bi, ( u)B ku j,( v)w kv i , j Vi, jmu m∑vi= 0∑j = 0 Bi, k u( u)Bj, k ( v)wv i , jparameters of the surfacebasis functionsorders in u and v directionmesh of control pointsweightsThe basis functions are defined as follows:B i {( , 1u) =1 0ui≤ u

The normals are computed by taking the cross product of thesurface derivatives∂ ∂n = Q( u,v)× Q(u,v)∂u∂vand normalizing the resulting vector.This evaluation scheme is referred to in the literature as uniformtessellation. This method is staightforward to implement, lessCPU-intensive and suitable for parallel computing. For a fixedtessellation it is possible to precompute all the necessary basisfunctions B i (u) and B j (v). In addition, some properties of NURBScan be exploited. The control points are invariant totransformations. Thus the small number of control points can betransformed instead of the huge number of output vertices. Thevertices are lighted in screen space afterwards. Furthermore, theconvex hull property of NURBS states that the surface or curvelies completely within the convex hull formed by its controlpolygon. Hence the control polygon can be used as bounding boxfor culling. It is also known that by repeatedly performingsubdividision via knot insertion [Far96] the control polygonconverges quadratically to the surface [Dahmen86]. By exploitingthis fact, we can compute very tight bounding hulls.As a drawback of a fixed step size the surfaces can beoversampled or undersampled: a flat surface may be broken upinto a very fine mesh, or a surface of high curvature may berepresented by a coarse mesh. This problem is adressed in theadaptive subdivision scheme as described in [Pet94]. Adaptivetessellation approximates the surface more accurately, especiallyin cases of highly varying curvature, but is more CPU-intensive.In our approach, we use a uniform tessellation due to its lessercomputational requirements. If the NURBS surface isparametrized appropriately, then the placement of the knot linesreflects the surface properties well. In areas of dense knot lines thesurface will be more complex than in areas with sparse knotlines.Hence a tessellation formed by dividing knot intervals into a fixednumber of subintervals will sample the surface accurately.for intersection to find out if they are identical [KML95].Especially when rendering trimmed NURBS, the trimming curveshave to be checked. Patches may have different trimming curvesin terms of control points representing the curve.Trimmed NURBSTo describe arbitrary shapes, we have to introduce trimmedNURBS patches. Here, so-called trimming loops which arespecified in parameter space of a surface mark invalid regions ofthe NURBS patch domain. Especially in the CAD domain,trimmed NURBS are used to design objects with fluid shapes likeship hulls and aircraft or car bodies. Also in solid modellingpatches containing holes are represented in trimmed form.Trimming loops consist of one or more trimming curves, whichare 2D NURBS curves or piecewise linear curves, lying inparameter space of the surface and forming a closed loop.Degeneracies like selfintersecting trimming loops and intersectingloops need special attention, in that they have to be split up intonon intersecting loops.Two different approaches of tessellating trimmed surfaces can befound in literature: In [Luk93] and [LC93] the B-Splinerepresentation is used for rendering. The rendering algorithminvolves the computation of intersections of trimming curves withthe iso-lines and triangulation. Since these operations are simplerand faster to perform on Bezier-representations than on B-Splines,algorithms presented in [RHD89], [KML96] and [AES94] firstconvert NURBS surfaces to Bezier surfaces. The algorithm in[RHD89] partitions each trimming curve into monotonic segmentsfollowed by a special triangulation at the patch boundaries. Weshare this approach in our implementation which is stable andstraightforward to implement. The monotonic subdivision and thetriangulation may become a bottleneck [RHD89]. More recentresults as [KML96] present more efficient algorithms for thetriangulation, the computation of tight bounds and the exploitationof frame coherence.Boundary computationThere is considerable literature on step size computation foruniform tessellation such as [RHD89], [FMM86], [AES91],[KML96]. There are two categories of algorithms, the sizecriterion and the deviation criterion. The size criterion determinesthe bound based on the size of the resulting triangles in screenspace. Applying this step size to uniform tessellation still meansthat smooth areas are oversampled because the step size is relatedto the maximum curvature. The deviation criterion computes abound on the maximum deviation of the tessellated surface fromthe NURBS surface. The deviation criterion produces good resultsbut is computationally expensive.CracksSince adjacent surfaces need not necessarily be tessellated withthe same step size, cracks will appear at the patch boundaries. Ifthe boundary curve of two surfaces has an identical parametricrepresentation, a strip of coving triangles can be generated at theboundary as described in [FMM86, RHD89]. If the control pointsof the boundary do not match, boundary curves have to be testedFigure 1: Trimmed NURBS patch rendered with the glutessellator.

2. PROPOSED NODESNurbsSurfaceNurbsSurface {field SFInt32 uDimension 0 # [0, ∞)field SFInt32 vDimension 0 # [0, ∞)field MFFloat uKnot [] # (-∞,∞)field MFFloat vKnot [] # (-∞,∞)field SFInt32 uOrder 3 # [2, ∞)field SFInt32 vOrder 3 # [2, ∞)exposedField MFVec3f controlPoint [] # (-∞,∞)exposedField MFFloat weight [] # (0, ∞)exposedField SFInt32 uTessellation 0 # (-∞,∞)exposedField SFInt32 vTessellation 0 # (-∞,∞)exposedField SFNode texCoord []field SFBool ccw TRUEfield SFBool solid TRUE}uDimension and vDimension define the number of control pointsin the u and v dimensions.uOrder and vOrder define the order of surface. From amathematical point of view, the surface is defined by polynomialsof the degree order-1. The order of the curves uOrder and vOrdermust be greater than or equal to 2. An implementation may limituOrder and vOrder to a certain number. The most common ordersare 3 (quadratic polynomial) and 4 (cubic polynomial), which aresufficient to achieve the desired curvature in most cases.The number of control points must be at least equal to the order ofthe curve. The order defines the number of adjacent control pointsthat influence a given control point.controlPoint defines a set of control points of dimensionuDimension * vDimension. This set of points defines a meshsimilar to the grid of an ElevationGrid, whereas the points do nothave a uniform spacing. Depending on the weight values and theorder, this hull is approximated by the resulting surface. Thenumber of uDimension points define a polyline in u-directionfollowed by further u-polylines with the v-parameter in ascendingorder. The number of control points must be equal to or greaterthan the order. A closed B-Spline surface can be specified byrepeating the limiting control points and by specifying a periodicknot vectorThe control vertex corresponding to the control point P[i, j] on thecontrol grid is:P[i,j].x = controlPoints[i + ( j × uDimension)].xP[i,j].y = controlPoints[i + ( j × uDimension)].yP[i,j].z = controlPoints[i + ( j × uDimension)].zP[i,j].w = weight[ i + (j × uDimension)]where 0

necessary to resolve the set of the surface control points as a 2dimensional area.NurbsGroupNurbsGroup {eventIn MFNode addChildreneventIn MFNode removeChildrenexposedField MFNode children []field SFVec3f bboxCenter 0 0 0 # (-∞,∞)field SFVec3f bboxSize -1 -1 -1 # (0,∞)or -1,-1,-1exposedField SFFloat tessellationScale 1.0}The NurbsGroup node groups a set of NurbsSurface nodes to acommon group. This provides a hint to the browser to treat the setof NurbsSurface as a unit during tessellation to enforcetessellation continuity along borders. The tessellationScaleparameter scales the tessellation values in lower-levelNurbsSurface nodes. If a set of NurbsSurfaces uses a matching setof controlPoints along the borders, this results in a commontessellation stepping.NurbsPositionInterpolatorNurbsPositionInterpolator {}eventIn SFFloat set_fractionexposedField SFBool fractionAbsolute TRUEexposedField SFInt32 dimension 0exposedField MFFloat knot []exposedField SFInt32 order 4exposedField MFVec3f keyValue []exposedField MFFloat keyWeight []eventOut SFVec3f value_changedNurbsPositionInterpolator describes a 3D NURBS Curve usingdimension keyValue, keyWeight, knot and order. Sending aset_fraction input computes a 3D position on the curve, which issent by value_changed. The set_fraction value is used as the inputvalue for the tessellation function. Thereby the knot coresponds tothe key field of a conventional interpolator node, i.e. if theset_fraction value is within [0;1] and the knot vector within [0;2]only the half of the curve is computed. To traverse an arbitraryknot span with the normal input span of [0;1] of a TimeSensornode a mapping function can be activated by setting thefractionAbsolute to FALSE.It is under consideration to expand the functionality to alsocompute tangents:exposedField SFBool computeTangent FALSEeventOut SFVec3f tangent_changedThe tangent is computed if the computeTangent field is TRUE.This eventOut can be used to compute a frame of reference at thecurrent position along the curve.Using a VRML PositionInterpolator, it is not possible to specify asmooth movement like a path along a circle until the curve issampled to a very fine resolution. In a lot of existing VRMLcontent, the data for Interpolators make up a substantial portion ofthe total size of the VRML file. Using Spline- (NURBS-) basedinterpolation, we hope that this amount of data can be reduced.Feedback from content developers and tool vendors is required toevaluate this node and its usability and data reduction capabilities.NurbsTextureSurfaceNurbsTextureSurface {field SFInt32 uDimension 0 # [0, ∞)field SFInt32 vDimension 0 # [0, ∞)field MFFloat uKnot [] # (-∞,∞)field MFFloat vKnot [] # (-∞,∞)field SFInt32 uOrder 3 # [2, ∞)field SFInt32 vOrder 3 # [2, ∞)exposedField MFVec2f controlPoint [] # (-∞,∞)exposedField MFFloat weight [] # (0, ∞)}The NurbsTextureSurface node is a NURBS surface existing inthe parametric domain of its surface host specifying the mappingof the texture onto the surface. The tessellation process generates2D texture coordinates, which means additional computationaleffort in a frame-by-frame tessellation. If theNurbsTextureSurface is undefined, texture coordinates arecomputed by the client on the basis of parametric step sizewithout any performance penalty. Conventional vertex parametersdo not apply on NURBS because triangles are only available afterpolygonization, but the conventional texture transform may beused.TrimmedSurfaceTrimmedSurface {eventIn MFNode addTrimmingContoureventIn MFNode removeTrimmingContourexposedField MFNode trimmingContour []exposedField SFNode surfaceNULL}The TrimmedSurface node defines a NURBS surface that istrimmed by a set of trimming loops. The surface field containsthe NurbsSurface that shall be trimmed. The trimmingContourfield, if specified, shall contain a set of Contour2D nodes. Thecontours specify the area to trim out following the trimming rulealigned to the Open Inventor definition [Wer94]. A area inside aloop is discarded if the loop is defined in a clockwise direction. Ifthe loop is defined in a counterclockwise direction the area insideis retained and outside is discarded. The outermost contour mustbe defined in a counterclockwise direction. The contours may notbe self-intersecting or intersect other contours.Contour2DContour2D {eventIn MFNode addChildreneventIn MFNode removeChildrenexposedField MFNode children []field SFVec3f bboxCenter 0 0 0 # (-∞,∞)field SFVec3f bboxSize -1 -1 -1 # (0, ∞)or -1,-1,-1}The Contour2D node groups a set of curve segments to acomposite contour. The children have to form a closed loop withthe first point of the first child repeated as the last point of the lastchild and the last point of a segmet repeated as the first point ofthe consecutive one. The segments must be of the type

NurbsCurve2D or Polyline2D and must be enumerated in thechild field in consecutive order according to the topology of thecontour.NurbsCurve2DNurbsCurve2D {field MFFloat knot []field SFInt32 order 3exposedField MFVec2f controlPoint []exposedField MFFloat weight []exposedField SFInt32 tessellation 0}suitable tessellation bound simply based on the desiredsmoothness. In addition, this value can be used to weight thepolygon budget of objects. Essential objects are given a hightessellation value to ensure a smooth surface; less importantobjects get a lower tessellation value because some coarseness istolerable.The NurbsCurve2D node defines a trimming segment that is partof a trimming contour in the u-v domain of the surface. If theNurbsCurve2D forms a closed contour, it may be used as aContour2D node.Polyline2DPolyline2D {exposedField MFVec2f point []}The Polyline2D node defines a linear curve segment as a part of atrimming contour in the u-v domain of a surface.3. IMPLEMENTATIONOur implementation in the VRML browser blaxxun Contact [bla2,web] proves the usage of NURBS in the VRML domain. Allproposed nodes except the NurbsTextureSurface have beensuccessfully implemented. In favour of fast and stable processinga uniform tessellation was applied as recommended in [KML96].Various rendering pipelines fullfill the requirements of differentplatforms (Figure 2). As a reference implementation we used theOpenGL tessellator located in the glu-library. The NURBSsurface parameters are directly handed over to the correspondingOpenGL functions. This method is easy to implement, butperformance is low.To use the built in rendering pipline in our client, we polygonizeNURBS models and store the resulting mesh data. If no dynamictessellation is required, the performance penalty is avoidedalltogether. For low-end CPUs or complex models, this methodcan be used to tessellate NURBS surfaces in a preprocessing step.In case of dynamic tessellation (view-depended rendering) theintroduction of thresholds for the tessellation values minimizes thecomputational load. If the tessellation value is altered by morethan 10% the vertex cache is flushed and a new tessellation cycleis invoked.Current chip architectures like the Intel ISSE or the AMD3DNow! allow to parallelize the computations involved in thepolygonization. An ISSE optimized tessellation with additionallyoptimized lighting and transformation showed best results. Thispipeline exploits the fact that CVs are invariant undertransformations. Transform is sped up by applying the costlymatrix multiplication to the small amount of CVs. After thetessellation process the transformed vertices are lit.In the current implementation stage no step size computation isperformed. As a first step we encourage the content author to set aFigure 2: pipelines for tessellation and renderingView dependent renderingThe implementation is targeted to dynamic tessellation whichallows view-dependend rendering. Like the classical LOD,NURBS objects can be scaled down according to the viewer’sdistance from the object. We have introduced a quality factordescribing the rendering quality by means of triangles per screensize of the object. This value is comparable with the screen basedtolerance shown in section 1, because both values specify theresolution of an object. In contrast to the screen based tolerancethe computation is very simple but is not directly related to thecurvature of the objecttriangles(scale)Quality =bbox(dist)Withtriangles ( scale)= ( uTess + 1) * scale*(vTess + 1) * scale* 2Quality:triangles(scale):bbox(dist):Describes rendering quality of an objectNumber of triangles of an objectDiameter of the bounding box in screen spaceThe quality factor is specified by the tessellation values in VRML.If the quality is assumed to be constant the scale value alters withthe distance of the viewer to the object. An additional feedbackloop can scale the quality factor according to the CPU speedreflecting in the frame rate. The algorithm keeps the framerateconstant by scaling the NURBS content at any given CPU speed.Of course, this implies that the whole scene has to be designed forscaling: There has to be reasonable space for upscaling anddownscaling the tessellation and thus the appearance of an objectif moving away from the target platform. However, scalability isnot unlimited: In the average scene NURBS content is scaleddown very fast with CPU frequency since certain portions of theoverall computational effort do not decrease. The drawbacks ofCPU based scaling are that the authors lose control over theappearance of the object since the client itself continuously altersthe object’s resolution. Proper lower bounds have to be defined to

avoid intolerable undersampling of the model. To overcome theseshortcomings additional parameters could be introduced: Authorscould specify the tessellation strategy or the lower boundary of thequality.Other parametric shapes like cylinders, cones and spheres canprofit from the NURBS LOD as well. A client could composethese shapes with NURBS “behind the scenes,“ allowing seamlessscaling of the objects.Large-scale NURBS surfaces are not addressed in this approachand have to be subdivided by hand. In the worst case, a hugesurface is very coarse nearby while totally oversampled in itsremote parts. To avoid boundary cracks of adjacent surfaces dueto the view dependent rendering NURBS objects have to begrouped in a NurbsGroup node.Trimmed NURBSThe usage of the NURBS tessellator of OpenGL for the presentednodes in the context of trimmed NURBS is straightforward. TheContour2D node signals OpenGL the beginning and the end of atrimming loop. The NurbsCurve2D coresponds to agluNurbsCurve and the Polyline2D is the VRML counterpart ofgluPwlCurve. The performance of glu's NURBS implementationon the average PC (table 1) is low. In the trimmed NURBS caseperformance decreased considerably in comparison to theuntrimmed one, reserving the OpenGL implementation to highend workstations, at least until graphic boards supporting NURBSin hardware on basis of the OpenGL API arise on the market.Therefore in our implementation the performance penalty oftessellation was avoided by caching the tessellated model. Torender even complex CAD models an optimal polygon count isachieved by employing adaptive tessellation. Techniques relyingon realtime tessellation such as the animation of control verticesand view depended rendering are out of the scope in thisimplementation, but various LOD modells could be generated in apreprocessing step. Further work has to be done in using trimmedNURBS for LODs.4. ResultsFor testing we take as a common scenario a scene with multipleNURBS objects shown at high resolution and exploiting theadvantage of arbitrary resolution for a LOD. Multiuser worldswith a huge number of avatars moving around or a shopping mallcontaining a large number of products show this behaviour.A sample implementation [bla2] of file exporters for 3d StudioMax 2.5 and 3.0 respectively supports the new nodes. TheNURBS export function is fully integrated in the conventionalVRML97 file exporter in the 3.0 version. In another approach weconvert Open Inventor files to VRML. This method isstraightforward since the specification of the proposed nodes isclosely related to the one of Open Inventor NURBS. Supportingauthoring tools like 3d Studio Max seems to be more complex:Internal NURBS data structures like ruled, loft and blendedsurfaces have to be reduced to the basic NURBS surface. Varioustools especially in the CAD domain support the Open Inventor fileformat. For professional modelling Alias Wavefront can be used.IFS in D3D OpenGL Preprocessing ISSE60fps 5fps 38fps 45fpsTable 1: Comparison between tessellation pipelines. The scenecontained an animated NURBS patch. Uniform tessellationwas configured to 5000 triangles. The frame rate increasesnoticeable if the patch is stored as a IndexedFaceSet.Animation with NURBSThe frame-by-frame tessellation allows us to alter the position ofthe control points on the fly. To achieve effects like movingwaves with conventional meshes, many points have to beanimated at the cost of huge data size of CoordinateInterpolatorsor complex scripts. By transferring this problem to NURBS, onlysingle control points have to be animated. Data size is kept verysmall and scripts are very simple.Currently this technique is only limited by the lack of suitableauthoring tools. Awesome effects can be achieved by-hand editingthe VRML file, but as the complexity of objects increases, toolshave to be used. A sample implementation based on 3D StudioMAX shows the power of NURBS animations. The sampledanimation path is approximated by a spline and exported as aNurbsPositionInterpolator.CompressionThe figures presented in this section can only give a idea of thecompression factor, since the factor largly depends on the degreeof curvature of the model. A NURBS model in 3d Studio Maxwas exported to the VRML97 NURBS format and to aconventional IndexedFaceSet with a resolution such that themodel did not show any rendering artefacts. However, thiscomparison assumes that the NURBS model is shown at itsoptimal resolution.Figure 3 Triangulation of a trimmed NURBS patch byadaptive tessellation

Figure 4 The Knight NURBS avatar composed of severalNURBS patches. Even at close ups the avatar stays smooth.The avatar is taken out of the Knight NURBS demo ofLunatic Interactive (www.lunatic.de).IFSNURBSa) curved surface 66K (6.8K Polygons) 7Kb) Knight NURBS 2MB (40K Polygons) 200KTable 2 File size in KByte. a) A tool generated sphererepresenting an average curved surface was exported asNURBS surface (without expoiting the special characteristicsof a sphere) and as a mesh. b) A NURBS avatar shown in fig.4.Speed improvement with LODDepending on the scene, the LOD can speed up the renderingprocess tremendously. Especially in a multiuser sceneario wheremany avatars are moving in a scene, the LOD has a tremendousimpact on the performance. In a typical multiuser scenario, thecomplexity of the environment is negligible in comparison to thatof 50 or even 100 avatars. Typically, avatars are tool-generatedand thus only poorly VRML-optimized. Experiments withNURBS avatars have shown acceleration of at least 2x. Authoringvarious LOD models for the conventional LOD node of VRML isa time-consuming process whereas with NURBS the LODs comefor free.IFSNURBSfps 8 24polygons 150K 35KTable 3 Frame rate increases by factor 3 in this example whenemploying NURBS avatars with LOD instead ofIndexedFaceSet based avatars. The overall polygon load of thescene decreased from 150K polygons to 35K since only theavatars close to the camera are of high resolution.Figure 5 A scene with 10 high resolution avatars (15KPolygons) positioned in different distances to the viewer wasrendered as IndexedFaceSet and as NURBS model with LOD.The avatar was provided by the courtesy of okupi(www.okupi.com).5.SUBDIVISION SURFACESRecently, subdivision surfaces have gained more attention as apossible alternatives to NURBS. In particular, in areas such asanimation and entertainment, subdivision surfaces have beenemployed. The reason for their increasing popularity is the factthat it is possible to generate geometry with arbitrary topologywithout introducing trimming. This simplifies the user interactionconsiderably and also eliminates the robustness problems whichare inherent to trimmed NURBS.The basic idea of subdivision surfaces is the following: Given is apolygonal mesh M 0 . A refined mesh M 1 is created by subdividingeach face into a collection of subfaces. Typically, the vertices ofthe new mesh M 1 are computed as weighted averages of thevertices of the old mesh. Repeated application of this subdivisionstep leads to a smooth limit surface. The most popular schemesare Catmull-Clark subdivision [CC78] and Loop subdivision[Loo87]. The two schemes differ in that Catmull-Clark is basedon rectangles and the limit surface is a bicubic B-Spline. Loop‘sscheme is based on triangles. For commercial applications,Catmull-Clark is favored since it directly generalizes the bicubictensor product B-Splines.This scheme has been used at Pixar for the creation of geometry inthe short film Geri‘s game. In [DKT98] , the authors describetechniques developed by Pixar for modelling sharp creases and fortexture mapping subdivision surfaces. Catmull-Clark subdivisionsurfaces are also implemented in Alias/Wavefront Maya.Evaluation of Subdivision SurfacesIt was a long-held belief that there is no direct way of evaluating asubdivision surface efficiently. Looking at Figure 6 we can seethat almost everywhere the subdivision surface consists ofquadrilaterals which forms the control net of a bicubic B-Spline.Only around the extraordinary vertices (vertices of valence notequal 4) does the surface not correspond to a B-Spline. Stam[Sta98] showed that even around extraordinary vertices, it is

possible to evaluate the surface directly and efficiently. This canbe achieved by transforming to a suitable basis, the eigenbasiswhich correpsonds to the power basis in regular regions. Hence, itis now much more practical to incorporate subdivision surfacesinto a modeling framework and to have them coexist withstandard NURBS.effective with current hardware and can save considerablebandwidth. Besides this obvious advantage of data compression,the LOD is a key feature. Defining various levels of detail of amodel is not left up to the author but computed automatically bythe application.As a first step, work on the standardization of the proposedNURBS nodes needs to be done. Secondly, a standard for thetessellation and for the LOD technique have to be agreed upon toguarantee same visual appearance of objects in variousimplementations.Further work has to do be done in the field of authoring solutions.Due to the complexity of NURBS, objects cannot be modeled byhand in a text editor. We have to develop file exporters and fileconverters for the majority of the authoring tools to increase theacceptance of NURBS in the community of content developers.Looking farther ahead, one can imagine to incorporate subdivisionsurfaces as well. Again, the issue of authoring solutions will haveto be addressed.Figure 6 Subdivision mesh with extraordinary vertices. Onlythe marked patches can not be evaluated directly as bicubic B-Splines.Level of Detail ControlOne of the strengths of subdivision surfaces is the built-inmultiresolution hierarchy. A mesh can be refined by performingadditional subdivision steps. Conversely, it is also possible tocoarsen the mesh by applying mesh decimation techniques. In[ZSS97], the authors describe techniques for adding detail locally,which allows to edit the model in a restricted region. It is alsoshown how one can traverse the multiresolution hierarchy inorder to perform adaptive rendering. This enables the applicationto trade off frame rates for level of detail as described in Section3.SummaryIt is possible to put forth a proposal for subdivision surfaces in thefuture which can make use of the NURBS standard proposed inthis paper. Subdivision surfaces address some issue which areproblematic for NURBS such as the modeling of arbitrarytopology. On the other hand, NURBS are well-established in theengineering community and they are superior for modeling in anengineering context. It is difficult to compare the storage andhence the transmission requirements. A model which has lots ofdetail in a local region favors a subdivision surface since it allowsto add detail locally, whereas in NURBS we have to modify thepatch globally. On the other hand, storing a full multiresolutionhierarchy can increase the transmission cost for subdivisionsurfaces, whereas LOD control comes essentially for free whenrendering NURBS. In any case, both respresentations yieldsignificant compression ratios when compared to tessellatedmodels.6. CONCLUSIONNURBS present a great opportunity to meet the requirements ofcurrent hardware and the Internet. With NURBS scalable webapplication can be created which react to the configuration of theclient system. Practical experience has proven that NURBS are

REFERENCES[AES91] S.S. Abi-Ezzi, L.A. Shirman. Tessellation of curvedsurfaces under highliy vaying transformations. Proceedings ofEurographics 91, pages 385-397, 1991[AES94] S.S. Abi-Ezzi, S. Subramaniam, Fast DynamicTessellation of Trimmed NURBS Surfaces, Compter GraphicsForum, Vol. 13 (3), 1994[bla1]http://www.blaxxun.com/developer/contact/3d/nurbs/overview.html[Sta98] J. Stam, Exact Evaluation of Catmull-Clark SubdivisionSurfaces at Arbitrary Parameter Values. Computer GraphicsProceedings (SIGGRAPH 98) pp 395-404, 1998[web] source code of blaxxun Contact:http://www.web3d.org/TaskGroups/source/blaxindex.html[Wer94] J. Wernecke, The Inventor Mentor, Addison-Wesley,1994[ZSS97] D. Zorin, P. Schroeder, W. Sweldens, InteractiveMultiresolution Mesh Editing. Computer Graphics Proceedings(SIGGRAPH 97) pp. 259-268, 1997[bla2] blaxxun contact:http://www.blaxxun.de/download/contact/index.html[Dah86] W. Dahmen: Subdivision algorithms convergequadratically, J. Comp. Appl. Math., Vol 16., pp. 125-158, 1986[DKT98] T. DeRose, M. Kass, T. Truong, Subdivision Surfaces inCharacter Animation. Computer Graphics Proceedings(SIGGRAPH 98), pp 85-94, 1998[Far96] G. Farin, Curves and Surfaces for Compter AidedGeometric Design: A Practical Guide, 4 th Edition, AcademicPress, Boston 1996[FMM86] D. Filip, R. Magedson, R. Markot. Surface algorithmsusing bounds on derivatives. CAGD (3), 295-311, 1986[KML96] S. Kumar, D. Manocha, A. Lastra, Interactive Displayof large scale NURBS models, IEEE Transactions onvisualization and Computer Graphics, Vol. 2, December, 1996[LC93] W.L. Luken and Fuhua Cheng, Rendering TrimmedNURB Surfaces, Computer Science Research Report18669(81711), IBM Research Division, 1993[Luk93] W.L. Luken, Tessellation of Trimmed NURB Surfaces,Computer Science Research Report 19322(84059), IBM ResearchDivision, 1993[Loo87] C. Loop, Smooth Subdivision Surfaces Based onTriangles. Master‘s thesis, University of Utah, Department ofMathematics, 1987[Pet94] J.W. Peterson, Tessellation of NURBS Surfaces, GraphicGems IV, Academic Press, p.286-320, Boston, 1994[PT95] L. Piegl, W. Tiller, The NURBS Book, Springer,Heidelberg, 1995[RHD89] A. Rockwood, K. Heaton, T. Davis. Realtime renderingof trimmed surfaces. In Proceedings of ACM Siggraph, pages107-117, 1989[sgi]http://www.sgi.com/Technology/Inventor/VRML/VRMLDesign.html