Efficient stack-less BVH traversal for ray tracing

Language models (LMs) are an essential element in statistical approaches to natural language processing for tasks such as speech recognition and machine translation (MT). The advent of big data leads to the availability of massive amounts of data to build LMs, and in fact, for the most prominent languages, using current techniques and hardware, it is not feasible to train LMs with all the data available nowadays. At the same time, it has been shown that the more data is used for a LM the better the performance, e.g. for MT, without any indication yet of reaching a plateau. This paper presents CloudLM, an open-source cloud-based LM intended for MT, which allows to query distributed LMs. CloudLM relies on Apache Solr and provides the functionality of state-of-the-art language modelling (it builds upon KenLM), while allowing to query massive LMs (as the use of local memory is drastically reduced), at the expense of slower decoding speed.

This paper reports results of a study to determine and compare the effectiveness of various techniques aimed at reducing memory interference in multiprocessor multi memory systems. A simulation model of a multiprocessor, driven by address traces, is used for evaluation purposes. Two approaches to interference reduction are considered, being the reduction of overlapping memory requirements through various memory allocation methods, and the use of local memory to reduce the request rate to shared memory. Both private and cache memory are considered for this purpose.

Reduced precision bounding volume hierarchies and ray traversal can significantly improve the efficiency of ray tracing through low-cost dedicated hardware. A key approach to enabling reduced precision computations during traversal is to translate the ray origin closer to the bounding volume hierarchy node after each traversal step. However, this approach precludes sharing of intersection computations between a parent node and its two children, which is an important optimization. In this paper, we introduce a novel traversal algorithm that addresses this limitation and achieves a significant reduction in the computational complexity of traversal compared to previous approaches. We also include an analysis that shows how our algorithm guarantees watertight intersections which is a key requirement for robust image quality, especially with reduced precision traversal where numerical errors can be large.

Presents an algorithm which aims at reducing the execution time and memory requirements of the synthesis of plants which are generated by a D0L system (deterministic context-free Lindenmayer system) and rendered by ray tracing. We propose a new method that carries out an intersection test directly with the production obtained by a D0L system, and thus attain considerable size reduction in the database. To reduce the computation time, the method works with a bounding volume hierarchy and adapts to the available memory by storing the hierarchy as far as a certain depth. Both the graphical primitives and those bounding volumes that have not been stored in memory are calculated at tracing time when they are required. We have compared our intersection test with a classical intersection test and with the commercial ray tracer PovRay, obtaining important reductions in computation time and memory in both cases.

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.

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.

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 new conservative image-space occlusion culling method to increase the rendering speed of very large general scenes on today's available hardware without time-expensive preprocessing. The method is based on a low-resolution grid upon a conventional z-buffer. The occlusion information in the grid is updated in a lazy manner. In comparison to related methods this significantly reduces the number of pixels that have to be read from the z-buffer. The grid allows fast decisions if an object is occluded or potentially visible. It is used together with a bounding volume hierarchy that is traversed in a front-to-back order and which allows to cull large parts of the scene at once. A special front-to-back traversal is used if no pixel-level query for the furthest z-value of an image area is available. We show that the method works efficiently on today's available hardware and we compare it with related methods.

This paper proposes an efficient ray-tracing scheme to render dynamic scenes by exploring the coherence between consecutive frames. By assuming that only few objects in a scene may move from frame to frame, the rays emitted from the same pixels of two consecutive frames may hit the same object with high possibility. By using extra buffers to store the index of triangle each ray intersects for the current scene, the trace of each ray for the following scene can start by testing if this ray intersects the same triangle. Once the ray hits the same triangle, the intersection depth can then be used to exclude the test operation of the other nodes during the tree traversal. In addition, instead of rebuilding the bounding volume hierarchies (BVH) tree structure of the next scene, it can also be obtained by updating the current one. The unmodified nodes can be annotated such that their intersection test can be simply skipped during the tree traversal for those rays which hit the same primitives in the current scene. For our own test scenes whose total number of modified triangles is less than 5% of the overall triangle count, our experimental results show that more than one half of ray-node and ray-triangle intersection operations can be saved, which can result in more than 50% reduction in the software ray-tracing time. For the common test scene TOASTER where more than 90% of triangles have been moved in consecutive scenes, the proposed scheme can still achieve the saving of trace time up to 24%.

Collision detection in radiotherapy: A comprehensive software approach using depth camera and separating axis theorem.

Tracing a ray through a scene and finding the closest intersection with the scene geometry is a fundamental operation in computer graphics. During the last two decades, significant efforts have been made to accelerate this operation, with interactive ray tracing as one of the major driving forces. At the heart of a fast method for intersecting a scene with a ray lies the acceleration structure. Many different acceleration structures exist, but research has focused almost exclusively on a few well-tried and well-established techniques: regular and hierarchical grids, bounding volume hierarchies and kd-trees. Spectacular advances have been made, which have contributed significantly to making interactive ray tracing a possibility. However, despite the success of these acceleration structures, several problems remain open. Handling deforming and dynamic geometry still poses significant challenges, and the local vs. global complexity of acceleration structures is still not entirely understood. One therefore wonders whether other acceleration structures, that leave the beaten path of efficient grids, bounding volume hierarchies and kd-trees, can provide viable alternatives.Next to computer graphics, the ray shooting problem is also studied in computational geometry. Ray shooting queries against a large collection of polyhedra are answered by tracing the ray through a simplicial complex such as a constrained tetrahedralization. This is a well-known technique, see e.g. the chapter Ray shooting and lines in space by Pellegrini in Handbook of Discrete and Computational Geometry. However, relevant work in computational geometry is usually theoretical, and practical implementations and experimental results are typically not available.In this work we explore the idea of accelerating the operation of intersecting a scene with a ray using constrained tetrahedralizations. This is illustrated in figure 1. A constrained tetrahedralization of a scene is a tetrahedralization that respects the faces of the scene geometry. The closest intersection of a ray with a scene is found by traversing this tetrahedralization along the ray, one tetrahedron at a time, until a constrained face is encountered. We show that constrained tetrahedralizations are a viable alternative to state-of-the-art acceleration structures, such as kd-trees, and that constrained tetrahedralizations have a number of interesting and unique properties that set them apart from traditional acceleration structures. Constrained tetrahedralizations are not hierarchical yet adaptive; the complexity of traversing them is a function of local geometric complexity rather than global geometric complexity; constrained tetrahedralizations support deforming geometry without any effort (see figure 2); and they have the potential to unify several data structures currently used in global illumination.Although constrained tetrahedralizations are not a silver bullet, and although they are in general not yet faster than the most optimized kd-trees, constrained tetrahedralizations offer several new perspectives on acceleration structures for ray tracing and deserve attention.

We present an algorithm for collision detection between multiple deformable objects translating in a large environment. We use Spatial Partitioning to subdivide the scene and a Bounding Volume Hierarchy to decompose the objects, using octrees in both cases. The algorithm is divided in two parts, the Broad and Narrow Phases, with objects that can be rigid or deformable. In the Broad Phase, an octree is used to partition the scene and cull away the object’s Bounding Volumes that are distant. In the Narrow Phase, a hierarchical decomposition of Axis Aligned Bounding Boxes or spheres is employed to reduce the number of primitives in the pairwise comparisons. In summary this work is a general-purpose collision detection technique for performing real time collision detection of deformable bodies in interactive 3D applications.

A chain tree is a data structure for representing changing protein conformations. It enables very fast detection of clashes and free potential energy calculations. The efficiency of chain trees is closely related to the bounding volumes associated with chain tree nodes. A protein subchain associated with a node of a chain tree will clash with another subchain only if their bounding volumes intersect. It is therefore essential that bounding volumes are as tight as possible while intersection tests can be carried out efficiently. We compare the performance of four different types of bounding volumes in connection with the rotation of protein bonds. It is observed that oriented bounding boxes are not as good as could be expected judging by their extensive use in various applications. Both rectangular- and line-swept spheres are shown to have very good tightness of fit but the line-swept, or even simple spheres, are shown to be significantly faster because of quick overlap checks. We also investigate how the performance of the recently introduced adjustable chain trees is affected by different bounding volume types.

The design-for-assembly technique requires realistic physically based simulation algorithms and in particular efficient geometric collision detection routines. Instead of approximating mechanical parts by large polygonal models, we work with the much smaller original CAD-data directly, thus avoiding precision and tolerance problems. We present a generic algorithm, which can decide whether two solids intersect or not. We identify classes of objects for which this algorithm can be efficiently specialized, and describe in detail how this specialization is done. These classes are objects that are bounded by quadric surface patches and conic arcs, objects that are bounded by natural quadric patches, torus patches, line segments and circular arcs, and objects that are bounded by quadric surface patches, segments of quadric intersection curves and segments of cubic spline curves. We show that all necessary geometric predicates can be evaluated by finding the roots of univariate polynomials of degree at most 4 for the first two classes, and at most 8 for the third class. In order to speed up the intersection tests we use bounding volume hierarchies. With the help of numerical optimization techniques we succeed in calculating smallest enclosing spheres and bounding boxes for a given set of surface patches fulfilling the properties mentioned above.

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.