4,872 research outputs found
gScan: Accelerating Graham Scan on the GPU
This paper presents a fast implementation of the Graham scan on the GPU. The
proposed algorithm is composed of two stages: (1) two rounds of preprocessing
performed on the GPU and (2) the finalization of finding the convex hull on the
CPU. We first discard the interior points that locate inside a quadrilateral
formed by four extreme points, sort the remaining points according to the
angles, and then divide them into the left and the right regions. For each
region, we perform a second round of filtering using the proposed preprocessing
approach to discard the interior points in further. We finally obtain the
expected convex hull by calculating the convex hull of the remaining points on
the CPU. We directly employ the parallel sorting, reduction, and partitioning
provided by the library Thrust for better efficiency and simplicity.
Experimental results show that our implementation achieves 6x ~ 7x speedups
over the Qhull implementation for 20M points.Comment: arXiv admin note: text overlap with arXiv:1508.0548
A Practical Algorithm for Enumerating Collinear Points
This paper studies the problem of enumerating all maximal collinear subsets
of size at least three in a given set of points. An algorithm for this
problem, besides solving degeneracy testing and the exact fitting problem, can
also help with other problems, such as point line cover and general position
subset selection. The classic \emph{topological sweeping} algorithm of
Edelsbrunner and Guibas can find these subsets in time in the dual
plane. We present an alternative algorithm that, although asymptotically slower
than their algorithm in the worst case, is simpler to implement and more
amenable to parallelization. If the input points are decomposed into convex
polygons, our algorithm has time complexity and space
complexity . Our algorithm can be parallelized on the CREW PRAM with time
complexity using processors
Optimal Compression of a Polyline with Segments and Arcs
This paper describes an efficient approach to constructing a resultant
polyline with a minimum number of segments and arcs. While fitting an arc can
be done with complexity O(1) (see [1] and [2]), the main complexity is in
checking that the resultant arc is within the specified tolerance. There are
additional tests to check for the ends and for changes in direction (see [3,
section 3] and [4, sections II.C and II.D]). However, the most important part
in reducing complexity is the ability to subdivide the polyline in order to
limit the number of arc fittings [2]. The approach described in this paper
finds a compressed polyline with a minimum number of segments and arcs.Comment: 40 pages, 34 figures, 3 table
DataGrinder: Fast, Accurate, Fully non-Parametric Classification Approach Using 2D Convex Hulls
It has been a long time, since data mining technologies have made their ways
to the field of data management. Classification is one of the most important
data mining tasks for label prediction, categorization of objects into groups,
advertisement and data management. In this paper, we focus on the standard
classification problem which is predicting unknown labels in Euclidean space.
Most efforts in Machine Learning communities are devoted to methods that use
probabilistic algorithms which are heavy on Calculus and Linear Algebra. Most
of these techniques have scalability issues for big data, and are hardly
parallelizable if they are to maintain their high accuracies in their standard
form. Sampling is a new direction for improving scalability, using many small
parallel classifiers. In this paper, rather than conventional sampling methods,
we focus on a discrete classification algorithm with O(n) expected running
time. Our approach performs a similar task as sampling methods. However, we use
column-wise sampling of data, rather than the row-wise sampling used in the
literature. In either case, our algorithm is completely deterministic. Our
algorithm, proposes a way of combining 2D convex hulls in order to achieve high
classification accuracy as well as scalability in the same time. First, we
thoroughly describe and prove our O(n) algorithm for finding the convex hull of
a point set in 2D. Then, we show with experiments our classifier model built
based on this idea is very competitive compared with existing sophisticated
classification algorithms included in commercial statistical applications such
as MATLAB
CudaChain: A Practical GPU-accelerated 2D Convex Hull Algorithm
This paper presents a practical GPU-accelerated convex hull algorithm and a
novel Sorting-based Preprocessing Approach (SPA) for planar point sets. The
proposed algorithm consists of two stages: (1) two rounds of preprocessing
performed on the GPU and (2) the finalization of calculating the expected
convex hull on the CPU. We first discard the interior points that locate inside
a quadrilateral formed by four extreme points, and then distribute the
remaining points into several (typically four) sub regions. For each subset of
points, we first sort them in parallel, then perform the second round of
discarding using SPA, and finally form a simple chain for the current remaining
points. A simple polygon can be easily generated by directly connecting all the
chains in sub regions. We at last obtain the expected convex hull of the input
points by calculating the convex hull of the simple polygon. We use the library
Thrust to realize the parallel sorting, reduction, and partitioning for better
efficiency and simplicity. Experimental results show that our algorithm
achieves 5x ~ 6x speedups over the Qhull implementation for 20M points. Thus,
this algorithm is competitive in practical applications for its simplicity and
satisfied efficiency
Synergistic Computation of Planar Maxima and Convex Hull
Refinements of the worst case complexity over instances of fixed input size
consider the input order or the input structure, but rarely both at the same
time. Barbay et al. [2016] described ``synergistic'' solutions on multisets,
which take advantage of the input order and the input structure, such as to
asymptotically outperform any comparable solution which takes advantage only of
one of those features. We consider the extension of their results to the
computation of the \textsc{Maxima Set} and the \textsc{Convex Hull} of a set of
planar points. After revisiting and improving previous approaches taking
advantage only of the input order or of the input structure, we describe
synergistic solutions taking optimally advantage of various notions of the
input order and input structure in the plane. As intermediate results, we
describe and analyze the first adaptive algorithms for \textsc{Merging Maxima}
and \textsc{Merging Convex Hulls}
An Algorithm for Finding Convex Hulls of Planar Point Sets
This paper presents an alternate choice of computing the convex hulls (CHs)
for planar point sets. We firstly discard the interior points and then sort the
remaining vertices by x- / y- coordinates separately, and later create a group
ofquadrilaterals (e-Quads) recursively according to the sequences ofthe sorted
lists of points. Finally, the desired CH is built based on a simple polygon
derived from all e-Quads. Besides the preprocessing for original planar point
sets, this algorithm has another mechanism of discarding interior point when
form e-Quads and assemble the simple polygon. Compared with three popular CH
algorithms, the proposed algorithm can generate CHs faster thanthe three but
has a penalty in space cost.Comment: Proceedings of IEEE Conference, ICCSNT 2012, in Pres
Convex Hull and Linear Programming in Read-only Setup with Limited Work-space
Prune-and-search is an important paradigm for solving many important
geometric problems. We show that the general prune-and-search technique can be
implemented where the objects are given in read-only memory. As examples we
consider convex-hull in 2D, and linear programming in 2D and 3D. For the
convex-hull problem, designing sub-quadratic algorithm in a read-only setup
with sub-linear space is an open problem for a long time. We first propose a
simple algorithm for this problem that runs in time and
space. Next, we consider a restricted version of the problem where
the points in are given in sorted order with respect to their
-coordinates in a read-only array. For the linear programming problems, the
constraints are given in the read-only array. The last three algorithms use
{\it prune-and-search}, and their time and extra work-space complexities are
and respectively, where is a small
constant satisfying
Efficient cache oblivious algorithms for randomized divide-and-conquer on the multicore model
In this paper we present randomized algorithms for sorting and convex hull
that achieves optimal performance (for speed-up and cache misses) on the
multicore model with private cache model. Our algorithms are cache oblivious
and generalize the randomized divide and conquer strategy given by Reischuk and
Reif and Sen. Although the approach yielded optimal speed-up in the PRAM model,
we require additional techniques to optimize cache-misses in an oblivious
setting. Under a mild assumption on input and number of processors our
algorithm will have optimal time and cache misses with high probability.
Although similar results have been obtained recently for sorting, we feel that
our approach is simpler and general and we apply it to obtain an optimal
parallel algorithm for 3D convex hulls with similar bounds. We also present a
simple randomized processor allocation technique without the explicit knowledge
of the number of processors that is likely to find additional applications in
resource oblivious environments
A Novel Implementation of QuickHull Algorithm on the GPU
We present a novel GPU-accelerated implementation of the QuickHull algorihtm
for calculating convex hulls of planar point sets. We also describe a practical
solution to demonstrate how to efficiently implement a typical
Divide-and-Conquer algorithm on the GPU. We highly utilize the parallel
primitives provided by the library Thrust such as the parallel segmented scan
for better efficiency and simplicity. To evaluate the performance of our
implementation, we carry out four groups of experimental tests using two groups
of point sets in two modes on the GPU K20c. Experimental results indicate that:
our implementation can achieve the speedups of up to 10.98x over the
state-of-art CPU-based convex hull implementation Qhull [16]. In addition, our
implementation can find the convex hull of 20M points in about 0.2 seconds.Comment: 10 pages, 5 figure
- …