GPU accelerated convex hull computation

Abstract

We present a hybrid algorithm to compute the convex hull of points in three or higher dimensional spaces. Our formulation uses a GPU-based interior point filter to cull away many of the points that do not lie on the boundary. The convex hull of remaining points is computed on a CPU. The GPU-based filter proceeds in an incremental manner and computes a pseudo-hull that is contained inside the convex hull of the original points. The pseudo-hull computation involves only localized operations and maps well to GPU architectures. Furthermore, the underlying approach extends to high dimensional point sets and deforming points. In practice, our culling filter can reduce the number of candidate points by two orders of magnitude. We have implemented the hybrid algorithm on commodity GPUs, and evaluated its performance on several large point sets. In practice, the GPU-based filtering algorithm can cull up to 85 M interior points per second on an NVIDIA GeForce GTX 580 and the hybrid algorithm improves the overall performance of convex hull computation by 10–27 times (for static point sets) and 22–46 times (for deforming point sets).

Introduction

The problem of computing the convex hull of a set of points is fundamental in computational geometry, computer graphics and shape modeling. Given a set of points in d-dimensional space, the convex hull is the minimal convex set that contains all the points. Convex hull computation is frequently used for collision detection, interference computation, shape analysis, pattern recognition, statistics, GIS, etc.

The problem of computing the convex hull of points is well studied in geometric computing. Many optimal theoretical algorithms have been proposed for low- and high-dimensional point sets. There are also many known practical methods and robust software implementations addressing this problem [1], [2], [3].

While many theoretical algorithms have been proposed for parallel convex hull computation, there is relatively little work on fast, practical algorithms that can exploit parallel cores on the GPUs. In this paper, our goal is to design practical convex hull algorithms that can exploit GPU parallelism, as most prior practical and robust algorithms [1], [4], [5], [6] to compute convex hulls are relatively hard to parallelize.

Main results: We present a hybrid GPU–CPU based convex hull algorithm. Given a set of points, we use a novel GPU-based filter that can cull away most of the interior points that do not lie on the boundary of the convex hull. The convex hull of the remaining points is computed using well-known CPU-based algorithms such as QuickHull [5], [3]. The GPU-based filter computes a pseudo-hull in an incremental manner which involves only localized operations and maps well to GPU architectures. Our approach ensures that the pseudo-hull lies inside the convex hull of the original points and serves as a conservative bounding shape to cull away interior points. We exploit spatial and temporal coherence between successive time steps to incrementally compute the pseudo-hull for deforming point sets and thereby reduce the runtime computation. The overall interior point filter, which exploits the parallel cores of GPUs, can cull up to 85 M points on an NVIDIA GeForce GTX 580, and can reduce the number of points by almost two orders of magnitude.

Furthermore, the algorithm scales almost linearly with the number of cores. The overall approach is quite simple and the GPU-based filter can be used as a preprocess with any other convex hull algorithm or software package.

The hybrid algorithm makes no assumption about the order of input points or the underlying deformation, and easily extends to higher-dimensional point sets. We have tested its performance on 3D and 4D large point sets corresponding to static and deforming point sets on different GPUs (e.g. NVIDIA GeForce GTX 285, GTX 480 and GTX 580). Our preliminary results indicate that the hybrid algorithm can speed up the computation by 27× (static point sets) and 46× (deforming point sets) as compared to an optimized CPU-based algorithm.

Organization: The rest of the paper is organized as follows: Section 2 gives a brief survey of prior work on convex hull computation. We present our CPU–GPU based hybrid algorithm and GPU-based interior point filter in Section 3. We present the implementation details and highlight the performance in Section 4. We compare our approach with prior algorithms and point out its limitations in Section 5.