Accelerating ray tracing using constrained tetrahedralizations

A major factor for the efficiency of ray tracing is the use of good acceleration structures. Recently, bounding volume hierarchies (BVHs) have become the preferred acceleration structures, due to their competitive performance and greater flexibility compared to KD trees. In this paper, we present a study on algorithms for the construction of optimal BVHs. Due to the exponential nature of the problem, constructing optimal BVHs for ray tracing remains an open topic. By exploiting the linearity of the surface area heuristic (SAH), we develop an algorithm that can find optimal partitions in polynomial time. We further generalize this algorithm and show that every SAH-based KD tree or BVH construction algorithm is a special case of the generic algorithm. Based on a number of experiments with the generic algorithm, we conclude that the assumption of non-terminating rays in the surface area cost model becomes a major obstacle for using the full potential of BVHs. We also observe that enforcing space partitioning helps to improve BVH performance. Finally, we develop a simple space partitioning algorithm for building efficient BVHs.

In many interactive computer graphics applications, users are represented as virtual characters called avatars. Collision detection is a pre-requisite in interactive computer graphics application so that appropriate response and realistic behaviour can be generated. However, it will not be easy to anticipate collisions since objects' motion are dependant on user interaction and avatar manipulation. Ideally, collision detection needs to be done efficiently, with accurate result in the shortest time possible. However, due to its computationally intensive nature, collision detection could cause a bottleneck to the system. A variety of techniques, data structures and algorithms were proposed to accelerate the collision detection process. Acceleration data structures are widely used not only to promote faster collision detection, but also in the field of ray tracing and deformable objects simulation. This paper discusses the use of bounding volume hierarchy as an acceleration data structure in collision detection for avatar in virtual environment, as well as similar methods used in interactive ray tracing and deformable objects simulation. Based on these findings, method for fast bounding volume hierarchy construction is proposed as a first step towards efficient avatar collision detection.

Despite their algorithmic elegance and robustness, bounding volume hierarchies (BVHs) have not reached the performance of kd- trees for ray tracing. BVHs do not adapt well to scenes containing large triangles with overlapping bounding boxes. A node cannot be smaller than the bounding box of the primitives it contains. Consequently, the leafs and internal nodes will overlap substantially. This slows down ray tracing, because the number of traversal steps and ray-primitive intersections is increased. Unfortunately, this kind of geometry is common in architectural scenes and low-poly CAD models. In this paper, we present a building algorithm for BVHs that handles such scenes more efficiently. The restriction that each primitive must be contained in exactly one leaf node is relaxed. Bounding boxes of large primitives are refined with recursive split clipping before constructing the hierarchy. The resulting volumes are used as input for a regular BVH building algorithm. Neither scene geometry nor traversal or building algorithms must be modified in any way. The resulting hierarchies are superior for a wide range of data sets, leading to speed-ups of more than a factor of three.

We present a performance comparison of bounding volume hierarchies and kd-trees for ray tracing on many-core architectures (GPUs). The comparison is focused on rendering times and traversal characteristics on the GPU using data structures that were optimized for maximum performance of tracing rays irrespective of the time needed for their build. We show that for a contemporary GPU architecture (NVIDIA Kepler) bounding volume hierarchies have higher ray tracing performance than kd-trees for simple and moderately complex scenes. Kd-trees, on the other hand, have higher performance for complex scenes, in particular for those with occlusion.

Spatial data structures form a core ingredient of many geometric algorithms, both in theory and in practice. Many of these data structures, especially the ones used in practice, are based on partitioning the underlying space (examples are binary space partitions and decompositions of polygons) or partitioning the set of objects (examples are bounding-volume hierarchies). The efficiency of such data structures---and, hence, of the algorithms that use them---depends on certain characteristics of the partitioning. For example the performance of many algorithms that use binary space partitions (BSPs) depends on the size of the BSPs. Similarly, the performance of answering range queries using bounding-volume hierarchies (BVHs) depends on the so-called crossing number that can be associated with the partitioning on which the BVH is based. Much research has been done on the problem of computing partitioning whose characteristics are good in the worst case. In this thesis, we studied the problem from a different point of view, namely instance-optimality. In particular, we considered the following question: given a class of geometric partitioning structures---like BSPs, simplicial partitions, polygon triangulations, …---and a cost function---like size or crossing number---can we design an algorithm that computes a structure whose cost is optimal or close to optimal for any input instance (rather than only worst-case optimal). We studied the problem of finding optimal data structures for some of the most important spatial data structures. As an example having a set of n points and an input parameter r, It has been proved that there are input sets for which any simplicial partitions has crossing number ¿(vr). It has also been shown that for any set of n input points and the parameter r one can make a simplicial partition with stabbing number O(vr). However, there are input point sets for which one can make simplicial partition with lower stabbing number. As an example when the points are on a diagonal, one can always make a simplicial partition with stabbing number 1. We started our research by studying BSPs for line segments in the plane, where the cost function is the size of the BSPs. A popular type of BSPs for line segments are the so-called auto-partitions. We proved that finding an optimal auto-partition is NP-hard. In fact, finding out if a set of input segments admits an auto-partition without any cuts is already NP-hard. We also studied the relation between two other types of BSPs, called free and restricted BSPs, and showed that the number of cuts of an optimal restricted BSP for a set of segments in R2 is at most twice the number of cuts of an optimal free BSP for that set. The details are being represented in Chapter 1 of the thesis. Then we turned our attention to so-called rectilinear r-partitions for planar point sets, with the crossing number as cost function. A rectilinear r-partition of a point set P is a partitioning of P into r subsets, each having roughly |P|/r points. The crossing number of the partition is defined using the bounding boxes of the subsets; in particular, it is the maximum number of bounding boxes that can be intersected by any horizontal or vertical line. We performed some theoretical as well as experimental studies on rectilinear r-partitions. On the theoretical side, we proved that computing a rectilinear r-partition with optimal stabbing number for a given set of points and parameter r is NP-hard. We also proposed an exact algorithm for finding optimal rectilinear r-partitions whose running time is polynomial when r is a constant, and a faster 2-approximation algorithm. Our last theoretical result showed that considering only partitions whose bounding boxes are disjoint is not sufficient for finding optimal rectilinear r-partitions. On the experimental side, we performed a comparison between four different heuristics for constructing rectilinear r-partitions. The so-called windmill KD-tree gave the best results. Chapter 2 of the thesis describes all the details of our research on rectilinear r-partitions. We studied another spatial data structure in Chapter 3 of the thesis. Decomposition of the interior of polygons is one of the fundamental problems in computational geometry. In case of a simple polygon one usually wants to make a Steiner triangulation of it, and when we have a rectilinear polygon at hand, one typically wants to make a rectilinear decomposition for it. Due to this reason there are algorithms which make Steiner triangulations and rectangular decompositions with low stabbing number. These algorithms are worst-case optimal. However, similar to the two previous data structures, there are polygons for which one can make decompositions with lower stabbing numbers. In 3 we proposed a 3-approximation for finding an optimal rectangular decomposition of a rectilinear polygon. We also proposed an O(1)-approximation for finding optimal Steiner triangulation of a simple polygon. Finally, in Chapter 4 of the thesis, we considered another optimization problem, namely how to approximate a piecewise-linear function F: R ¿R with another piecewise-linear function with fewer pieces. Here one can distinguish two versions of the problem. The first one is called the min-k problem; the goal is then to approximate the function within a given error e such that the resulting function has the minimum number of links. The second one is called the min-e problem; here the goal is to find an approximation with at most k links (for a given k) such that the error is minimized. These problems have already been studied before. Our contribution is to consider the problem for so-called uncertain functions, where the value of the input function F at its vertices is given as a discrete set of different values, each with an associated probability. We show how to compute an approximation that minimizes the expected error.

We present a performance comparison of bounding volume hierarchies and kd‐trees for ray tracing on many‐core architectures (GPUs). The comparison is focused on rendering times and traversal characteristics on the GPU using data structures that were optimized for very high performance of tracing rays. To achieve low rendering times, we extensively examine the constants used in termination criteria for the two data structures. We show that for a contemporary GPU architecture (NVIDIA Kepler) bounding volume hierarchies have higher ray tracing performance than kd‐trees for simple and moderately complex scenes. On the other hand, kd‐trees have higher performance for complex scenes, in particular for those with high depth complexity. Finally, we analyse the causes of the performance discrepancies using the profiling characteristics of the ray tracing kernels.

Ray tracing is an essential operation for realistic image synthesis. The acceleration of ray tracing has been studied for a long period of time because algorithms such as light transport simulations require a large amount of ray tracing. One of the major approaches to accelerate the intersections is to use bounding volumes for early pruning for primitives in the volume. The axis-aligned bounding box is a popular bounding volume for ray tracing because of its simplicity and efficiency. However, the conservative bounding volume may produce extra empty space in addition to its content. Especially, primitives that are thin and diagonal to the axis give false-positive hits on the box volume due to the extra space. Although more complex bounding volumes such as oriented bounding boxes may reduce more false-positive hits, they are computationally expensive. In this paper, we propose a novel culling approach to reduce false-positive hits for the bounding box by embedding a binary voxel data structure to the volume. As a ray is represented as a conservative voxel volume as well in our approach, the ray--voxel intersection is cheaply done by bitwise AND operations. Our method is applicable to hierarchical data structures such as bounding volume hierarchy (BVH). It reduces false-positive hits due to the ray--box test and reduces the number of intersections during the traversal of BVH in ray tracing. We evaluate the reduction of intersections with several scenes and show the possibility of performance improvement despite the culling overhead. We also introduce a compression approach with a lookup table for our voxel data. We show that our compressed voxel data achieves significant false-positive reductions with a small amount of memory.

Utilizing the vector units of current processors for ray tracing single rays through Bounding Volume Hierarchies has been accomplished by increasing the branching factor of the acceleration structure to match the vector width. A high branching factor allows vectorized bounding box tests but requires a complex control flow for the calculation of a front-to-back traversal order. We propose a novel algorithm for single rays entirely based on vector operations that performs a complete traversal iteration in constant time, ideally suited for current and future micro architectures featuring wide vector units. In addition we use our single ray technique as a building block to construct a fast packet traversal for coherent rays. We validate our algorithms with implementations utilizing the AVX2 and AVX-512 instruction sets and demonstrate significant performance gains over state-of-the-art solutions.

We are delighted to present the proceedings of High Performance Graphics 2013. This is the fifth year of the conference, which has become the leading international conference on graphics hardware, systems, and algorithms. The conference brings together researchers, engineers, and architects to discuss the complex interactions of parallel hardware, novel programming models, efficient graphics algorithms, and innovative applications. High Performance Graphics (HPG) was founded in 2009 to synthesize and expand on two important and well-respected conferences in computer graphics: Graphics Hardware, an annual conference focusing on graphics hardware, architecture, and systems since 1986; and Interactive Ray Tracing, an innovative symposium begun in 2006 focusing on the emerging field of interactive ray tracing and global illumination. By combining and expanding these two communities, we bring to authors and attendees the best of both fields and a conference covering a broad range of interactive 3D graphics systems and algorithm research. This year's proceedings continue to reflect this tradition of synthesis. Ray tracing has again emerged as a popular topic, and HPG 2013 includes papers on new algorithms for efficiently constructing and traversing ray tracing acceleration structures as well as complementary papers detailing specialized hardware designs for ray tracing. The conference includes papers on classic graphics hardware topics, such as advanced rasterization and real-time shadowing, as well as increasingly important topics such as interactive voxelization and reconstruction. In all 44 papers were submitted to HPG 2013, of which 15 were accepted for an acceptance rate of about 34%.

Ray tracing is a largely employed technique for generating computer images with high fidelity and realism. However, this technique is very costly, mainly because of the intersection calculations made by the algorithm. Still, ray tracing is a highly parallelizable algorithm, since the calculations for a single light ray are independent from the others. This way, the implementation of the ray tracing on the GPU is a natural process. Data structures can be employed for reducing the processing load of the ray tracing algorithm, minimizing the number of intersection calculations. In recent works, these structures are being ported to the GPU, so they can be used to accelerate various parallel algorithms. In this work, we proposed a GPU ray tracing implementation using an octree as acceleration structure. Every single step of the algorithm runs in parallel on the GPU, so the communication bottleneck between the GPU and the CPU is eliminated. This work also proposes the study of which is the best way to represent the octree on the GPU, by comparing two different approaches.

With the recent addition of hardware ray tracing capabilities, GPUs have become incredibly efficient at ray tracing both triangular geometry, and instances thereof. However, the bounding volume hierarchies that current ray tracing hardware relies on are known to struggle with long, thin primitives like cylinders and curves, because the axis-aligned bounding boxes that these hierarchies rely on cannot tightly bound such primitives. In this paper, we evaluate the use of RTX ray tracing capabilities to accelerate these primitives by tricking the GPU's instancing units into executing a hardware-accelerated oriented bounding box (OBB) rejection test before calling the user's intersection program. We show that this can be done with minimal changes to the intersection programs and demonstrate speedups of up to 5.9× on a variety of data sets.

Modern ray tracing APIs allow developers to easily build acceleration structures (AS) with various optimization techniques. However, the visibility-driven on-demand build can not be implemented with the current APIs due to the lack of flexibility during ray traversal. In this paper, we propose a new algorithm to lazily build ASes for real-time ray tracing with an extended programming model supporting flexible ray traversal. The core idea of our approach is a multi-pass build-traversal, which computes instance visibility and builds the visible ASes in different passes. This allows us to lazily build the entire AS only when necessary without hardware implication. Applying our algorithm to dynamic scenes, we demonstrate that the build cost is significantly reduced with minimal overhead.

Octrees with near optimal cost for ray-shooting

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. Categories and Subject Descriptors (according to ACM CCS): I.3.5 [Computer Graphics]: Computational Geometry and Object Modeling—Geometric algorithms, languages, and systems; Splines; I.3.7 [Computer Graphics]: Three‐Dimensional Graphics and Realism—Virtual reality

Octrees are attractive data structures for rendering of volumes, as they provide simultaneously uniform and hierarchical data encapsulation. We present a simple and efficient algorithm for interactive ray tracing on a hybrid architectures, which takes advantage of the parallelism present by heavily exploiting the hardware for the CPU and GPU, which has been observed to give superior performance in ray tracing compared to other acceleration structures. Instead of alternating between phases of rendering and (potentially infrequent) building, our approach exploits the parallelism inherent in a multi-core system by continuously and asynchronously rebuilding new octree (potentially over the course of multiple frames) while the threads in the GPU concurrently update and traverse the most recently built octree.