Michael Guthe

GPU-based trimming and tessellation of NURBS and T-Spline surfaces

As there is no hardware support neither for rendering trimmed NURBS -- the standard surface representation in CAD -- nor for T-Spline surfaces the usability of existing rendering APIs like OpenGL, where a run-time tessellation is performed on the CPU, is limited to simple scenes. Due to the irregular mesh data structures required for trimming no algorithms exists that exploit the GPU for tessellation. Therefore, recent approaches perform a pretessellation and use level-of-detail techniques. In contrast to a simple API these methods require tedious preparation of the models before rendering and hinder interactive editing. Furthermore, due to the tremendous amount of triangle data smooth zoom-ins from long shot to close-up are not possible, In this paper we show how the trimming region can be defined by a trim-texture that is dynamically adapted to the required resolution and allows for an efficient trimming of surfaces on the GPU. Combining this new method with GPU-based tessellation of cubic rational surfaces allows a new rendering algorithm for arbitrary trimmed NURBS and T-Spline surfaces with prescribed error in screen space on the GPU. The performance exceeds current CPU-based techniques by a factor of up to 1000 and makes real-time visualization of real-world trimmed NURBS and T-Spline models possible on consumer-level graphics cards.

GPU‐based Collision Detection for Deformable Parameterized Surfaces

Based on the potential of current programmable GPUs, recently several approaches were developed that use the GPU to calculate deformations of surfaces like the folding of cloth or to convert higher level geometry to renderable primitives like NURBS or subdivision surfaces. These algorithms are realized as a per‐frame operation and take advantage of the parallel processing power of the GPU. Unfortunately, an efficient accurate collision detection, that is necessary for the simulation itself or for the interaction with and editing of the objects, can currently not be integrated seamlessly into these GPU‐based approaches without switching back to the CPU. In this paper we describe a novel GPU‐based collision detection method for deformable parameterized surfaces that can easily be combined with the aforementioned approaches. Representing the individual parameterized surfaces by stenciled geometry images allows to generate GPU‐optimized bounding volume hierarchies in real‐time that serve as a basis for an optimized GPU‐based hierarchical collision detection algorithm. As a test case we applied our algorithm to the collision detection of deformable trimmed NURBS models, which is an important problem in industry. For the trimming and tessellation of the NURBS on the GPU we used a recent approach [GBK05] and combined it with our collision detection algorithm. This way we are able to render and check collisions for deformable models consisting of several thousands of trimmed NURBS patches in real‐time.

Near optimal hierarchical culling: performance driven use of hardware occlusion queries

The most efficient general occlusion culling techniques are based on hardware accelerated occlusion queries. Although in many cases these techniques can considerably improve performance, they may still reduce efficiency compared to simple view frustum culling, especially in the case of low depth complexity. This prevented the broad use of occlusion culling in most commercial applications. In this paper we present a new conservative method to solve this problem, where the main idea is to use a statistical model describing the occlusion probability for each occlusion query in order to reduce the number of wasted queries which are the reason for the reduction in rendering speed. We also describe an abstract parameterized model for the graphics hardware performance. The parameters are easily measurable at startup and thus the model can be adapted to the graphics hardware in use. Combining this model with the estimated occlusion probability our method is able to achieve a near optimal scheduling of the occlusion queries. The implementation of the algorithm is straightforward and it can be easily integrated in existing real-time rendering packages based on common hierarchical data structures.

BTF-CIELab: A Perceptual Difference Measure for Quality Assessment and Compression of BTFs

Driven by the advances in lossy compression of bidirectional texture functions (BTFs), there is a growing need for reliable methods to numerically measure the visual quality of the various compressed representations. Based on the CIE ΔE00 colour difference equation and concepts of its spatio‐temporal extension ST‐CIELab for video quality assessment, this paper presents a numerical quality measure for compressed BTF representations. By analysing the BTF in its full six‐dimensional (6D) space, light and view transition effects are integrated into the measure. In addition to the compressed representation, the method only requires the source BTF images as input and thus aids the objective evaluation of different compression techniques by means of a simple numerical comparison. By separating the spatial and angular components of the difference measure and linearizing each of them, the measure can be incorporated into any linear or multi‐linear compression technique. Using a per‐colour‐channel principal component analysis (PCA), compression rates of about 500:1 can be achieved at excellent visual quality.

Real-time appearance preserving out-of-core rendering with shadows

Despite recent advances in finding efficient LOD-representations for gigantic 3D objects, rendering of complex, gigabyte-sized models and environments is still a challenging task, especially under real-time constraints and high demands on the visual accuracy. The two general approaches are using either a polygon- or a point-based representation for the simplified geometry. With the polygon-based approaches high frame rates can be achieved by sacrificing the exact appearance and thus the image quality. Point-based approaches on the other hand preserve higher image quality at the cost of higher primitive counts and therefore lower frame rates. In this paper we present a new hybrid point-polygon LOD algorithm for real-time rendering of complex models and environments including shadows. While rendering different LODs, we preserve the appearance of an object by using a novel error measure for simplification which allows us to steer the LOD generation in such a way that the geometric as well as the appearance deviation is bounded in image space. Additionally, to enhance the perception of the models shadows should be used. We present a novel LOD selection and prefetching method for real-time rendering of hard shadows. In contrast to the only currently available method for out-of-core shadow generation, our approach entirely runs on a single CPU system.

Fast and memory efficient view-dependent trimmed NURBS rendering

The problem of rendering large trimmed NURBS models at interactive frame rates is of great interest for industry, since nearly all their models are designed on the basis of this surface type. Most existing approaches first transform the NURBS surfaces into polygonal representation and subsequently build static levels of detail upon them, as current graphics hardware is optimized for rendering triangles. lit this work, we present a method for memory efficient, view-dependent rendering of trimmed NURBS surfaces that yields high-quality results at interactive frame rates. In contrast to existing algorithms, our approach needs not store hierarchies of triangles, since utilizing our special multiresolution seam graph data structure, we are able to generate required triangulations on the fly.

Towards Perceptual Simplification of Models with Arbitrary Materials

Real‐time rendering of models with high polygon count is still an important issue in interactive computer graphics. A common way to improve rendering performance is to generate different levels of detail of a model. These are mostly computed using polygonal simplification techniques, which aim to reduce the number of polygons without significant loss of visual fidelity. Most existing algorithms use geometric error bounds, which are well‐suited for silhouette preservation. They ignore the fact that a much more aggressive simplification is possible in low‐contrast areas inside the model. The main contribution of this paper is an efficient simplification algorithm based on the human visual system. The key idea is to move the domain of error computation from image‐space to vertex‐space to avoid a costly per‐pixel comparison. This way the error estimation of a simplification operation can be accelerated significantly. To account for the human vision, we introduce a perceptually based metric depending on the contrast and spatial frequency of the model at a single vertex. Finally, we validate our approach with a user study.

Fat borders: gap filling for efficient view-dependent LOD NURBS rendering

Abstract Real-time high-quality rendering of complex NURBS models remains a big challenge. Simply splitting the models into several parts which can be simplified and rendered independently introduces disturbing gaps along the common borders. Recent approaches for view-dependent rendering of huge models either neglect the artifacts introduced by the gaps or try to maintain the connectivity of the models. Unfortunately, in the second case the computational complexity and storage requirements of the algorithms are high. In this work we present a novel solution to the gap problem. Vertex programs are used to generate appropriately shaded fat borders that fill the gaps between neighboring patches.

Efficient view-dependent out-of-core visualization

Hierarchical levels of details (HLODs) have proven to be an efficient way to visualize complex environments and models even in an out-of-core system. Large objects are partitioned into a spatial hierarchy and on each node a level of detail is generated for efficient view-dependent rendering. To ensure correct matching between adjacent nodes in the hierarchy care has to be taken to prevent cracks along the cuts. This either leads to severe simplification constraints at the cuts and thus to a significantly higher number of triangles or the need for a costly runtime stitching of thse nodes. In this paper we present an out-of-core visualization algorithm that overcomes this problem by filling the cracks generated by the simplification algorithm with appropriately shaded fat borders. Furthermore, several minor yet important improvements of previous approaches are made. This way we come up with a simple nevertheless efficient view-dependent rendering technique which allows for the natural incorporation of state-of-the-art culling, simplification, compression and prefetching techniques.

Dependency-Free Parallel Progressive Meshes

The constantly increasing complexity of polygonal models in interactive applications poses two major problems. First, the number of primitives that can be rendered at real‐time frame rates is currently limited to a few million. Secondly, less than 45 million triangles—with vertices and normal—can be stored per gigabyte. Although the rendering time can be reduced using level‐of‐detail (LOD) algorithms, representing a model at different complexity levels, these often even increase memory consumption. Out‐of‐core algorithms solve this problem by transferring the data currently required for rendering from external devices. Compression techniques are commonly used because of the limited bandwidth. The main problem of compression and decompression algorithms is the only coarse‐grained random access. A similar problem occurs in view‐dependent LOD techniques. Because of the interdependency of split operations, the adaption rate is reduced leading to visible popping artefacts during fast movements. In this paper, we propose a novel algorithm for real‐time view‐dependent rendering of gigabyte‐sized models. It is based on a neighbourhood dependency‐free progressive mesh data structure. Using a per operation compression method, it is suitable for parallel random‐access decompression and out‐of‐core memory management without storing decompressed data.