http://gamma.cs.unc.edu/volccd/ghull/paper.pdf

SMI 2012: Full GPU accelerated convex hull computation

The randomized incremental convex hull algorithm is one of the most practical and important geometric algorithms in the literature. Due to its simplicity, and the fact that many points or facets can be added independently, it is also widely used in parallel convex hull implementations. However, to date there have been no non-trivial theoretical bounds on the parallelism available in these implementations. In this paper, we provide a strong theoretical analysis showing that the standard incremental algorithm is inherently parallel. In particular, we show that for n points in any constant dimension, the algorithm has O(log n) dependence depth with high probability. This leads to a simple work-optimal parallel algorithm with polylogarithmic span with high probability. Our key technical contribution is a new definition and analysis of the configuration dependence graph extending the traditional configuration space, which allows for asynchrony in adding configurations. To capture the "true" dependence between configurations, we define the support set of configuration c to be the set of already added configurations that it depends on. We show that for problems where the size of the support set can be bounded by a constant, the depth of the configuration dependence graph is shallow (O(log n) with high probability for input size n). In addition to convex hull, our approach also extends to several related problems, including half-space intersection and finding the intersection of a set of unit circles. We believe that the configuration dependence graph and its analysis is a general idea that could potentially be applied to more problems.

https://dl.acm.org/doi/pdf/10.1145/3350755.3400255

Randomized Incremental Convex Hull is Highly Parallel

A novel algorithm is presented to compute the convex hull of a point set in ℝ3 using the graphics processing unit (GPU). By exploiting the relationship between the Voronoi diagram and the convex hull, the algorithm derives the approximation of the convex hull from the former. The other extreme vertices of the convex hull are then found by using a two-round checking in the digital and the continuous space successively. The algorithm does not need explicit locking or any other concurrency control mechanism, thus it can maximize the parallelism available on the modern GPU.The implementation using the CUDA programming model on NVIDIA GPUs is exact and efficient. The experiments show that it is up to an order of magnitude faster than other sequential convex hull implementations running on the CPU for inputs of millions of points. The works demonstrate that the GPU can be used to solve nontrivial computational geometry problems with significant performance benefit.

gHull: A GPU algorithm for 3D convex hull

This paper is composed of two parts: the generation of the sand particulate system and insights into the grain-level response under static and dynamic loadings. First, the algorithms for the generation of sand particles are presented, considering the randomness in their shape and distribution. Improvements to the robustness of the algorithms are obtained using controlling parameters. Second, we employ the take-and-place algorithm, placing sand grains into the specimen and checking how they overlap to form the initial model. In order to improve the porosity of the specimen, we develop the compaction algorithm: self-compaction by gravity and artificial compaction by mechanical vibration and pressure. The steps for the generation of a finite element grid are also introduced. Third, the grain-level configurations of the dry sand particulate system (aspects such as porosity, friction and contact) are taken into account in modelling. Results show that the grain-level responses of grains, i.e. deformation, fracture and damage of sand grains, impose significant effects on the mechanical behavior of dry sand under static and dynamic loadings.

https://iopscience.iop.org/article/10.1088/0965-0393/22/5/055021/pdf

An algorithm for the grain-level modelling of a dry sand particulate system

Flipping is a local and efficient operation to construct the convex hull in an incremental fashion. However, it is known that the traditional flip algorithm is not able to compute the convex hull when applied to a polyhedron in R3. Our novel Flip-Flop algorithm is a variant of the flip algorithm. It overcomes the deficiency of the traditional one to always compute the convex hull of a given star-shaped polyhedron with provable correctness. Applying this to construct convex hull of a point set in R3, we develop ffHull, a flip algorithm that allows nonrestrictive insertion of many vertices before any flipping of edges. This is unlike the well-known incremental fashion of strictly alternating between inserting a single vertex and flipping. The new approach is not only simpler and more efficient for CPU implementation but also maps well to the massively parallel nature of the modern GPU. As shown in our experiments, ffHull running on the CPU is as fast as the best-known convex hull implementation, qHull. As for the GPU, ffHull also outperforms all known prior work. From this, we further obtain the first known solution to computing the 2D regular triangulation on the GPU.

/pdf/flip-flop-convex-hull-construction-via-star-shaped-3yonle0yus.pdf

Eran Geva

Papers

Applications of Geometry Processing: CudaHull: Fast parallel 3D convex hull on the GPU