Efficient Collision Detection Using a Dual Bounding Volume Hierarchy

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

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.

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.

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.

Due to the recent enriched micro-level hardware and advanced computer software technology, portable yet powerful smart devices draw fervent responses from users and consequently the world’s smart device market has been rapidly expanded. In addition, since smart devices can be used anytime and anywhere using the wireless internet environment, the traditional PC-oriented works are swiftly moving to smart devices. Recently, the demands for representing more realistic 3D deformable objects have been increased for smart device based 3D game, virtual reality, 3D mobile advertisement, augmented reality and so on. However, current smart devices cannot sufficiently process the details of complex 3D object representation and associated physics based animation yet. This paper proposes a new optimized 3D object simulation and collision handling method specifically targeted for smart devices. The proposed hierarchical bounding sphere FFD- AABB (Free Form Deformation -- Axis Aligned Bounding Box) algorithm provides efficient 3D object simulation, since it quickly rejects unnecessary complex collision tasks by executing simple hierarchical bounding sphere distance tests. We have conducted experimental tests under various iOS environments and have performed comparative performance analysis with previous methods. The proposed method shows on average 34% improvement in dynamic simulation and collision handling procedures.

Performing collision detection between convex objects in virtual environment simulation is one of vital problems in computer visualization research area. Given a set of two or more colliding objects, in order to determine the exact point of contact between object we need to undergo various high computation algorithm. In this paper, we describes our current work of determining the precise contact by measuring the distance between near colliding objects in order to maintain the accuracy and improve the speed of collision detection algorithm. Common method determine the distance by checking for vertices and edges point between objects in brute force condition. Compared to our method, by given set of objects in virtual environment world, we find the closest point between near colliding objects and bound the potential colliding area with an Axis-Aligned Bounding-Box. Then, we approximate the distance by measuring the distance of the box itself and hence recognize potential colliding area faster than the common method. Our method proven to most effective and efficient for narrow phase collision detection by removing unnecessary testing and reduced computational cost.

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.

The computational bottleneck in a ray tracer using bounding volume hierarchies is often the ray intersection routine with axis-aligned bounding boxes. We describe a version of this routine that uses IEEE numerical properties to ensure that those tests are both robust and efficient. Sample source code is available online.

We revisit the idea of using hierarchies of k-sided discrete orientation polytopes (k-DOPs) for ray tracing. We propose a method for building a k-DOP-based bounding volume hierarchy while optimizing its topology using the surface area heuristic. The key component of our method is a fast and exact algorithm for evaluating the surface area of a 14-DOP combined with the parallel locally ordered clustering algorithm (PLOC). Our k-DOP PLOC builder has about 40% longer build times than AABB PLOC, but for scenes with oblong slanted objects, the resulting BVH provides up to 2.5x ray tracing speedup over AABB BVH. We also show that k-DOPs can be used in combination with other techniques, such as oriented bounding boxes (OBBs). Transforming k-DOP BVH into OBB BVH is straightforward and provides up to 12% better trace times than the transformation from AABB to OBB BVH.

We present a novel approach to using Bounding Volume Hierarchies (BVHs) for collision detection of volumetric meshes for digital prototyping based on accurate simulation. In general, volumetric meshes contain more primitives than surface meshes, which in turn means larger BVHs. To manage these larger BVHs, we propose an algorithm for splitting meshes into smaller chunks with a limited-size BVH each. Limited-height BVHs make guided, all-pairs testing of two chunked meshes well-suited for GPU implementation. This is because the dynamically generated work during BVH traversal becomes bounded. Chunking is simple to implement compared to dynamic load balancing methods and can result in an overall two orders of magnitude speedup on GPUs. This indicates that dynamic load balancing may not be a well suited scheme for the GPU. The overall application timings showed that data transfers were not the bottleneck. Instead, the conversion to and from OpenCL friendly data structures was causing serious performance impediments. Still, a simple OpenMP acceleration of the conversion allowed the GPU solution to beat the CPU solution by 20 percent. We demonstrate our results using rigid and deformable body scenes of varying complexities on a variety of GPUs.

The quality of collision detection algorithm directly affects the performance of the whole simulation system. To address the low efficiency and low accuracy in detecting the collisions of flexible cloths in virtual environments, this paper proposes an oriented bounding box (OBB) algorithm with a simplified model, tree structure for a root-node double bounding box, and continuous collision detection algorithm incorporating an OpenNN-based neural network optimization. First, for objects interacting with the cloths with more complex modeling, the model is simplified with a surface simplification algorithm based on the quadric error metrics, and the simplified model is used to construct an OBB. Second, a bounding box technique commonly used for collision detection is improved, and a root-node double bounding box algorithm is proposed to reduce the construction time for the bounding box. Finally, neural networks are used to optimize the continuous collision detection algorithm, as neural networks can efficiently process large amounts of data and remove disjoint collision pairs. An experiment shows that the construction of an OBB using the simplified model is almost identical to that of the original model, but the taken to construct the OBB is reduced by a factor of approximately 2.7. For the same cloth, it takes 5.51%–11.32% less time to run the root-node double bounding box algorithm than the traditional-hybrid bounding box algorithm. With an average removal rate nearly identical to that of the traditional filtering method, the elapsed time is reduced by 7%–11% by using the continuous collision detection algorithm based on an OpenNN neural network optimization. The simulation results are realistic and in line with the requirements for real-time cloth simulations.

Collision detection in Vega Prime is based on the simple line segment, and collision detection based on bounding box is not realized. By studying the composition of three-dimensional object, we define a collision detection class, which inherits from vpIsector. After finding out all vertices of geometry in object, we connect these vertices one by one and constitute a trend line. The trend line constitutes our bounding box. Now, our collision detection is based on three-dimensional objects, but not the simple line segment. Additionally, we can expand x, y, z in all vertices in proportion and achieve early warning mechanism in virtual reality

We present an approach MSIL-CRF that incorporates multiple instance learning (MIL) into conditional random fields (CRFs). It can generalize CRFs to work on training data with uncertain labels by the principle of MIL. In this work, it is applied to saving manual efforts on annotating training data for semantic segmentation. Specifically, we consider the setting in which the training dataset for semantic segmentation is a mixture of a few object segments and an abundant set of objects' bounding boxes. Our goal is to infer the unknown object segments enclosed by the bounding boxes so that they can serve as training data for semantic segmentation. To this end, we generate multiple segment hypotheses for each bounding box with the assumption that at least one hypothesis is close to the ground truth. By treating a bounding box as a bag with its segment hypotheses as structured instances, MSIL-CRF selects the most likely segment hypotheses by leveraging the knowledge derived from both the labeled and uncertain training data. The experimental results on the Pascal VOC segmentation task demonstrate that MSIL-CRF can provide effective alternatives to manually labeled segments for semantic segmentation.

embark initiative Investing in People and Ideas Algorithm Myriad broad phase collision detection data structures and algorithms exist. We chose the simplest data structure, the Axis-Aligned Bounding Box (AABB), as its simplicity permits efficient hardware implementation. In software, AABBs are typically tested for collision using a sweep and prune algorithm (Cohen, Lin, Manocha & Ponamgi 1995), which achieves efficiency by considering spatial coherence between frames. However, we chose the more elementary O(n2) brute force method as it permits a more optimized hardware implementation. The brute force algorithm is Input: n AABBs Output: Indices of colliding AABB pairs

It is challenging to accurately detect flexible objects with arbitrary orientation from monitoring images in power grid maintenance and inspection sites. This is because these images exhibit a significant imbalance between the foreground and background, which can lead to low detection accuracy when using a horizontal bounding box (HBB) as the detector in general object detection algorithms. Existing multi-oriented detection algorithms that use irregular polygons as the detector can improve accuracy to some extent, but their accuracy is limited due to boundary problems during the training process. This paper proposes a rotation-adaptive YOLOv5 (R_YOLOv5) with a rotated bounding box (RBB) to detect flexible objects with arbitrary orientation, effectively addressing the above issues and achieving high accuracy. Firstly, a long-side representation method is used to add the degree of freedom (DOF) for bounding boxes, enabling accurate detection of flexible objects with large spans, deformable shapes, and small foreground-to-background ratios. Furthermore, the further boundary problem induced by the proposed bounding box strategy is overcome by using classification discretization and symmetric function mapping methods. Finally, the loss function is optimized to ensure training convergence for the new bounding box. To meet various practical requirements, we propose four models with different scales based on YOLOv5, namely R_YOLOv5s, R_YOLOv5m, R_YOLOv5l, and R_YOLOv5x. Experimental results demonstrate that these four models achieve mean average precision (mAP) values of 0.712, 0.731, 0.736, and 0.745 on the DOTA-v1.5 dataset and 0.579, 0.629, 0.689, and 0.713 on our self-built FO dataset, exhibiting higher recognition accuracy and a stronger generalization ability. Among them, R_YOLOv5x achieves a mAP that is about 6.84% higher than ReDet on the DOTAv-1.5 dataset and at least 2% higher than the original YOLOv5 model on the FO dataset.