Tessellation and rendering of trimmed NURBS models in scene graph systems

Dissertation, Universität Bonn, Sept. 2008
 

Abstract

Today scene graphs are ubiquitous in computer graphics: since they provide both a well suited data structure and an abstraction layer, almost all modern graphics applications employ some sort of scene graph. Unfortunately most scene graphs do not support higher order primitives (such as trimmed NURBS) adequately, even though in Computer Aided Design (CAD) systems the de facto standard surface representation is trimmed NURBS surfaces. This thesis describes how the trimmed NURBS representation can be seamlessly integrated into a scene graph system.

For rendering purposes, geometries in the trimmed NURBS representation are almost always transformed into a polygonal representation. However, since this process is quite complicated if trimming is involved, creating a robust implementation is not straightforward. Another related problem is that when exporting complex NURBS models from CAD/CAM systems the topology information is sometimes lost and is usually very hard to reconstruct. This may result in annoying rendering artifacts when two adjacent surfaces do not join seamlessly.

If rendering is fillrate-limited (e.g. because of the usage of expensive fragment shaders) overdraw can also become a significant problem. One solution for example is to use the occlusion culling capabilities of modern graphics hardware. However, due to the fact that occlusion queries require a complete pipeline flush using too many such queries can even slow down rendering, if the depth complexity of the scene is low.

This thesis focuses on these problems: First a robust tessellation method for individual trimmed NURBS surfaces is presented which guarantees a geometric error threshold between the polygonal representation and the original analytic surface. For dealing with the rendering artifacts caused by incompatible patch boundaries two methods are presented: the first method is based on reconstructing the topological information using the guaranteed geometric tolerance of the tessellation method, and sewing the adjacent surfaces together, producing a watertight (but possibly non-manifold) mesh. The second presented method avoids rendering artifacts between adjacent surfaces by rendering small billboards at surface boundaries using programmable graphics hardware. This method keeps the scene graph hierarchy intact and allows further modifications, but does not produce a single watertight mesh. To deal with the overdraw problem an occlusion culling method is presented, which performs well even in extremely low depth complexity situations and performs at least on par with state of the art occlusion culling methods for high depth complexity scenes. Finally an overview is given on how the most widely used scene graphs support high level primitives (e.g. trimmed NURBS) and the integration into the OpenSG scene graph is discussed.

Download: http://nbn-resolving.de/urn:nbn:de:hbz:5N-16145

Bibtex

@PHDTHESIS{balazs-2008-dissertation,
    author = {Bal{\'a}zs, {\'A}kos},
     title = {Tessellation and rendering of trimmed NURBS models in scene graph systems},
      type = {Dissertation},
      year = {2008},
     month = sep,
    school = {Universit{\"a}t Bonn},
  abstract = {Today scene graphs are ubiquitous in computer graphics: since they provide both a well suited data
              structure and an abstraction layer, almost all modern graphics applications employ some sort of
              scene graph. Unfortunately most scene graphs do not support higher order primitives (such as trimmed
              NURBS) adequately, even though in Computer Aided Design (CAD) systems the de facto standard surface
              representation is trimmed NURBS surfaces.
              This thesis describes how the trimmed NURBS representation can be seamlessly integrated into a scene
              graph system.
              
              For rendering purposes, geometries in the trimmed NURBS representation are almost always transformed
              into a polygonal representation. However, since this process is quite complicated if trimming is
              involved, creating a robust implementation is not straightforward. Another related problem is that
              when exporting complex NURBS models from CAD/CAM systems the topology information is sometimes lost
              and is usually very hard to reconstruct. This may result in annoying rendering artifacts when two
              adjacent surfaces do not join seamlessly.
              
              If rendering is fillrate-limited (e.g. because of the usage of expensive fragment shaders) overdraw
              can also become a significant problem. One solution for example is to use the occlusion culling
              capabilities of modern graphics hardware. However, due to the fact that occlusion queries require a
              complete pipeline flush using too many such queries can even slow down rendering, if the depth
              complexity of the scene is low.
              
              This thesis focuses on these problems: First a robust tessellation method for individual trimmed
              NURBS surfaces is presented which guarantees a geometric error threshold between the polygonal
              representation and the original analytic surface. For dealing with the rendering artifacts caused by
              incompatible patch boundaries two methods are presented: the first method is based on reconstructing
              the topological information using the guaranteed geometric tolerance of the tessellation method, and
              sewing the adjacent surfaces together, producing a watertight (but possibly non-manifold) mesh. The
              second presented method avoids rendering artifacts between adjacent surfaces by rendering small
              billboards at surface boundaries using programmable graphics hardware. This method keeps the scene
              graph hierarchy intact and allows further modifications, but does not produce a single watertight
              mesh. To deal with the overdraw problem an occlusion culling method is presented, which performs
              well even in extremely low depth complexity situations and performs at least on par with state of
              the art occlusion culling methods for high depth complexity scenes. Finally an overview is given on
              how the most widely used scene graphs support high level primitives (e.g. trimmed NURBS) and the
              integration into the OpenSG scene graph is discussed.},
       url = {http://nbn-resolving.de/urn:nbn:de:hbz:5N-16145}
}