2017 19th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC)
Effective construction of convex hull algorithms
P. Mitura, I. Šimeček, I. Kotenkov
Department of Computer Systems, Faculty of Information Technology,
Czech Technical University in Prague, Prague, Czech Republic Email: miturpet,xsimecek,koteniv1@fit.cvut.cz
Abstract—Finding the convex hull of a set of points in
a plane is one of the most common problems in computa-
tional geometry. We survey known algorithms for solving this
problem and look into methods of their effective and parallel
implementation. A simple generator of random input datasets
is created, with an option to control the number of points
on the resulting hull. We implement all surveyed algorithms
along with their optimizations and compare them using our
generator. Our measurements show, that Quickhull algorithm
using optimizations proposed by Hoang and Linh [1] has the
best performance among the implemented methods and is
faster than the current state of the art libraries.
Keywords-computational geometry, convex hull, Quickhull,
parallel processing, OpenMP
I. I NTRODUCTION
The convex hull of a set of points S is defined as the
smallest convex set containing all points in S. In this paper,
we limit ourselves to finding the convex hull of points in a
plane, which is the most common version of this problem.
It is known that convex hull is a polygon, with all of its
vertices being elements of the input set S [2]. We denote
the number of points in S as n and the number of points on
the resulting hull as h.
Throughout this paper, we will represent convex hulls as
a list of their vertices, sorted in counterclockwise order as
they appear on the perimeter. This prompts us to define
orientation of three points:
Definition 1. ([2, pp. 11–12]) For a given triplet of points
{a, b, c} ∈ R2 with coordinates (ax , ay ), (bx , by ), (cx , cy ),
we define operation O RIENT(a, b, c) as:
 
ax ay 1
 
O RIENT(a, b, c) =  bx by 1
 cx cy 1
furthermore, we will call the triplet {a, b, c}:
• counterclockwise, if O RIENT (a, b, c) < 0
• clockwise, if O RIENT (a, b, c) > 0
• collinear, if O RIENT (a, b, c) = 0
Which leads to a more formal definition of counterclock-
wise ordering:
Definition 2. We call a list of vertices V = {v1 , . . . , vn }
sorted in counterclockwise order, if for each i ≤ n − 2
we have O RIENT(vi , vi+1 , vi+2 ) ≤ 0 and specifically for
978-1-5386-2626-9/17/31.00 ©2017 IEEE
DOI 10.1109/SYNASC.2017.00028
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
last two vertices, we have O RIENT(vn−1 , vn , v1 ) ≤ 0 and
O RIENT(vn , v1 , v2 ) ≤ 0.
As we are going to focus on time performance of known
algorithms, the first thing we are concerned with is their
asymptotic time complexity. It has been shown, that in case
the output is ordered in counterclockwise (or clockwise)
order, the best asymptotic lower bound for time complexity
of finding the convex hull of n points in the Euclidean plane
is Ω(n log n) [3, pp. 33–37].
It is also important to note that if we take output sensitivity
into account, there are algorithms which can solve this
problem in O(n log h), where h is the number of points
on resulting hull [4] [5].
II. K NOWN SOLUTIONS
We have selected 5 algorithms for comparison and imple-
mentation, representing different existing approaches to the
problem. Short description of each algorithm follows, along
with the reason why we decided to include it. In all following
algorithms analysis, we will presume we were given a set
V = {v1 , v2 , . . . , vn } of n points in R2 as an input, and the
size of resulting convex hull for this set is h.
A. Compared algorithms
Jarvis Scan: Also known as the gift wrapping algorithm,
Jarvis Scan is one of the most straightforward solutions to
the convex hull problem. It was presented by Jarvis in 1973
[6] and is a specialization and simplification of earlier work
by Chand and Kapur in 1970 [7].
Its basic principle is to start with a point that is guaranteed
to appear on the hull (which for example applies to the point
with smallest y coordinate, selecting the one with greater x
coordinate in case of ties). We will denote this point p1 and
proceed by finding the next point on hull p2 , such that for
each point v ∈ V \{p1 , p2 }, we have O RIENT(p1 , p2 , v) ≤ 0.
This process can be then repeated for finding the pi+1 using
pi , until we find p1 again as the next point, which means
we have found the convex hull {p1 , . . . , ph }.
Searching for the next point can be done in O(n) time
in several ways (which will be further discussed in Section
III), leading to overall time complexity of O(nh). In most
cases, this is worse than using an algorithm which runs in
O(n log n) or better, but it is important to note that the
simplicity of this approach means it will have relatively
small complexity constants and could be easily parallelized.
105
 Graham Scan and Andrew’s algorithm: Graham Scan is
an algorithm shown by Graham in 1972 [8], being able to
solve the convex hull problem in O(n log n) time.
As in Jarvis Scan, it starts by finding the initial point p1
on the convex hull using the same criteria. Then, it sorts all
points in V \ {p1 } in ascending order by their polar angle
with respect to p1 as the coordinate center. Finally, it iterates
over the sorted points starting with the point that has the
smallest polar angle, which is guaranteed to follow p1 on
the perimeter, so we can denote it p2 .
During all remaining iterations, it will consider the ori-
entation of points ph−1 , ph , x, where h is the number
of points found on hull so far (initially set to h = 2
after adding p2 ) and x is the currently considered point.
If triplet {ph−1 , ph , x} is clockwise, it repeatedly removes
the last found point ph and decreases h by one until
O RIENT(ph−1 , ph , x) ≤ 0 is satisfied. Then, it increases h
by one and sets ph = x.
The time complexity of this algorithm is dominated by
sorting the points, which takes O(n log n) time. The iterative
phase can only manipulate with each point in V twice,
adding or removing it from the partial hull. That means
it takes only O(n) time and the overall complexity is
O(n log n), making it asymptotically worse than output-
sensitive algorithms, but with fairly small constant factors.
There is also an algorithm shown by Andrew in 1979
[9], that resembles Graham Scan with key difference in sort
order: Andrew’s algorithm sorts points by their x coordinate,
then proceeds with similar iterative phase, but does it twice
for upper and bottom half of the hull.
The complexity of this algorithm is obviously the same
and we also expect its performance to be very similar to
Graham Scan.
Quickhull: This algorithm was presented in 1996 by
Barber, Dobkin and Huhdanpaa [10]. Its name yields to the
fact that its time complexity analysis closely resembles the
one of Quicksort, and it also runs in O(n log n) time on
average, and O(n2 ) in worst case.
It is based on the idea, that if we take two points a, b lying
on the convex hull, and one of the halfplanes defined by line
ab, then the point c on this halfplane that is farthest from
ab also lies on the hull. Once again, initial points a, b can
be found as points with the mimimum and the maximum
coordinate on x axis.
This means we first divide the points in V into two
halfplanes defined by ab, and process each one separately.
For each partition, we find the point c farthest from ab,
add it to the hull and then discard all points inside the
triangle abc. Remaining points are divided to two groups,
one that lies on the halfplane defined by line ac, that does
not intersect with abc except for the segment ac, and the
rest is assigned to the group above the cb line. For both
of these groups and their corresponding lines, we proceed
recursively using the same logics as with the ab line. Points
106
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
found by recursive calls are put on the hull between points
a, c and c, b respectively.
Time complexity of this algorithm can be formulated
recursively as T (n) = T (n − x) + T (x) + O(n), with
0 ≤ x ≤ n. Analogously to Quicksort analysis, T (n) equals
O(n2 ) if x = 0 in every instance, but it can be shown that
in case of uniformly random choice of x from range [0, n],
the expected value of T (n) is only O(n log n).
Furthermore, the worst case scenario would have to rely
on repeatedly dividing coordinates of initial points on the
hull by some costant factor. In case of implementation
using some form of finite precision floating point arithmetic,
this would be practically unrepresentable for large input
data sets. Unlike Quicksort, Quickhull also achieves some
speedup by deleting unusable points from triangle abc,
which means it could even approach linear runtime in certain
cases (like diamond shaped dataset).
Chan’s algorithm: Named by its author, Chan’s algorithm
was presented by Chan in 1996 [5] and it falls into the class
of algorithms for convex hull problem, which could solve it
in better time than O(n log n) by being output sensitive, in
this case having the overall time complexity of O(n log h).
The basic principle of this algorithm lies in guessing
the number of points h lying on resulting convex hull,
which allows us to split the input set into n/h  disjoint
subsets of size at most h and find the convex hull of each
of these subsets using one of the conventional O(n log n)
algorithms. Using these partial hulls, we can find the overall
hull using similar approach as we have seen in Jarvis Scan,
but considering only one point per partition, found by binary
search over its convex hull.
B. Unused solutions
There are numerous approaches that were left off from
this comparison. Various preprocessing heuristics are being
used, the most common is known as the Akl-Toussaint
heuristic [11], which is based on pruning points outside
the quadrilateral formed by extremal points. However, these
techniques almost always depend on the shape or some
other property of input point set, making their performance
entirely dependend on chosen testing methodology.
Another possibility is the use of approximation algorithm,
the most famous of them being the BFP Approximation [12].
These allow solving the convex hull problem in linear time,
with fixed constraints on the margin of error in area of the
resulting hull.
C. Existing implementations
We have selected three commonly used implementations
of convex hull finding algorithms for comparison:
• Qhull [13] computes the convex hull using Quickhull,
is written by the original authors of this algorithm.
Provides a wide range of other tools, such as Delaunay
triangulation and Voronoi diagram.
 • CGAL [14] is a collection of computational geometry
algorithms, presenting its users with a choice of five
different algorithms for computing the planar convex
hull.
• Boost [15] is a widely used C++ library, containing
numerous solutions for common problems. Includes
a convex_hull function for computing 2D convex
hulls.
III. S EQUENTIAL OPTIMIZATIONS
All algorithms were implemented in the C++ program-
ming language. Besides automatic compiler optimizations,
we survey or propose series of improvements targeted at
reducing hidden constants in algorithm runtimes. These
mainly include reductions in number of trigonometric func-
tions, and reuse of previously computed results for other
purposes.
A. Jarvis Scan
Beginning with the Jarvis Scan algorithm, we can observe
that the dominant operation in terms of runtime is finding
the next point on the hull pi+1 , such that no other point lies
on the right of line segment pi pi+1 . This could be naively
done by computing the polar angles of all points (assuming
we shift the coordinate center to pi ), and use the line pi pi−1
as our x axis (we choose the original x axis for i = 1). With
all of these conditions satisfied, point pi+1 is the one with
the minimum polar angle in V \ {pi }.
However, this approach demands use of expensive
trigonometric operation such as the arctangent in order to
compute these angles, typically costing hundreds of CPU
cycles. This could be reduced by chosing any point as the
initial candidate pi+1 and iterating over all remaining points
v ∈ V \ {pi , pi+1 }. For each of them, we find out whether
the points pi , pi+1 and v make clockwise turn, and if they
do, v is assigned as the new pi+1 .
B. Graham Scan
Graham Scan also uses trigonometric operations to sort
points in the input set by their polar angle, and it could
be optimized in a similar way by comparing orientations of
points. That still means we have to compute cross product
in each comparison, which costs us several floating point
operations in a section that dominates the time complexity.
We propose to further improve the point sorting phase
by precomupting the polar angle of each point This means
the number of expensive floating point operations related to
angle computations would be reduced to O(n) and all of
the O(n log n) comparisons in sorting algorithm could be
implemented only by comparing two precomputed values.
It can also be observed that all points in V \ {p1 } have
their polar angle in the range [0, π) (we use p1 as an origin
of coordinate system, and it has the lowest y coordinate of
all points in V ). Thus we can limit ourselves to comparing
107
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
the cotangent of their polar angles, which is monotonic on
the given interval and computable only using floating point
division (as opposed to computing inverse tangent to get
exact angles).
These optimizations allow Graham Scan to catch up
to Andrew’s algorithm in terms of performace, detailed
comparison would be done later on in Section V.
C. Quickhull
In case of Quickhull optimizations, our main source was
the “Quicker than Quickhull” paper published in 2015 [1].
Authors of this work present several modifications to this
algorithm, claiming their version is three times faster than
the naive implementation.
The first trick presented in [1] reduces the number of
operations needed to find orientation of three points. By
default, the O RIENT function requires at least seven real
number instructions:
O RIENT(a, b, c) = (ax − bx )(by − cy ) − (ay − by )(bx − cx )
The key observation here is that every time Quickhull
iterates over the set of points in some partition, it only
changes the third point c in the computation, points a and b
are fixed. This allows us to precompute parts of the formula
by transforming it to the following form:
cy (bx − ax ) + cx (ay − by ) + bx (by − ay ) + by (ax − bx )
and then expressing it as
α = ay − by β = a x − bx γ = βby − αbx
O RIENT(a, b, c) = αcx − βcy + γ
where α β and γ are evaluated before the cycle, and all
orientations computed while iterating over each possible
point c only use the reduced formula, utilizing only four
floating point instructions.
Another modification proposed by [1] takes advantage of
the fact that finding the farthest point from line segment ab
in current partition can be done by computing cross product
 and bc
of ab  (denoted by ab  × bc)
 for each considered point
c. Cross product gives us the area of parallelogram with
the vectors for sides and this area could be also expressed
as distance between a and b (which is fixed) multiplied by
distance from line segment ab to the point c. That means the
point c with the maximal value |ab × bc|
 is also the farthest
from ab.
It also stands that ab  × bc
 is equal to the value of
O RIENT(a, b, c), which is already computed while partition-
ing points to recursive instances, before the farthest point
is needed. This means we could only store the point with
maximal O RIENT value in each partition, and send it to the
corresponding recursive instance as the farthest point.
Third improvement is taken from Section 4.2 of [1], its
basic idea is to limit the maximum count of orientation calls
while partitioning points from two to one. Assuming the
point a has smalled x coordinate than b, a point could only
be placed in the part above the ac segment if its x coordinate
is smaller than the one of c, an only above the cb segment
otherwise. The case of a having higher x coordinate than b
is similar.
D. Chan’s algorithm
Regarding the Chan’s algorithm, the main optimization
point is the choice of algorithm for finding partial convex
hulls. All of the algorithms mentioned above are applicable,
with the possibility of using different algorithms for partial
hulls based on their size. We will base the choice of algo-
rithms on their measured performance, especially on small
input set sizes. This will be further discussed in Section V.
IV. PARALLELIZATION
Along with sequential optimizations, we have explored
and implemented methods of parallelization for all surveyed
algorithms. All parallel programming is done under shared
memory model, using the OpenMP [16] library.
A. Jarvis Scan
In case of Jarvis Scan, there are two general ways of
parallelization to be considered. First we can observe, that
the algorithm can be started from up to four distinct points,
as any extremal point on both x and y axis is guaranteed
to lie on the convex hull. As computations between these
points could run independently, we can split the algorithm
into four parallel sections, each of them operating until it
finds the next extremal point. This is an easy solution with
minimal overhead, but it does not scale beyond 4 threads
and is highly dependent on the distribution of the points on
the hull.
We can also observe, that an extremal point could be
found in an arbitrary direction, making it possible to extend
this approach to any number of threads. However, this
technique is meant to provide an alternative with lower
overhead than the second option discussed below. Adding
a linear number of non-trivial distance checks per thread
may negatively affect the performance of the algorithm, and
considering that values of h where Jarvis Scan is worth
running are usually low, the dependence on distribution of
points on the hull would also increase significantly. Because
of this, we have decided to use the simpler 4 threads version.
The second option is to parallelize the search for the next
point on convex hull, by splitting the input set uniformly
among threads and finding one candidate point for each
partition. Candidate points are them scanned sequentially.
This approach ensures good load balancing and scales well
into any number of threads, but also comes with slightly
higher overhead.
It is also possible to use both of these methods at
once, ensuring the more expensive inner cycle parallelization
108
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
would be only used if the simple quadrant splitting does not
utilize all processing units.
B. Graham Scan
As the time complexity of both Graham Scan and An-
drew’s algorithm is dominated by sorting the input point
set, and parallelization of sorting is very common task, we
decided to use the parallel extension of the GNU C++ library
[17] for this purpose. More specifically, we have used the
__gnu_parallel::sort function in both algorithms.
Parallelization of linear parts of these algorithms was also
considered, finding the upper and lower hull in Andrew’s
algorithm in two threads being the obvious candidate. How-
ever, there are few opportunities beyond that, as paralleliza-
tion of incremental pass at the end of both algorithms would
be complicated at best, and speeding up the linear parts
would not have large impact on overall runtime anyway.
C. Quickhull
Quickhull is a typical example of divide and conquer
algorithm, and task parallelism is used in majority of such
cases. Every time the algorithm recursively branches into
two subproblems, each partition is saved into shared task
pool, and assigned a thread to do its work as soon as there is
a free one. In order to prevent overcrowding of the task pool
with small problem instances and consequentively increasing
the overhead, a sequential of algorithm version is used for
subproblems below certain size.
D. Chan’s algorithm
Chan’s algorithm also allows some degree of paralleliza-
tion. Finding partial hulls in the first step can be done
independently for each of the hulls, which means it could
be easily divided between threads. Using parallel versions of
convex hull algoritms for subhulls may be also considered,
although it would presumably cause larger overhead and
possibly poor balancing.
Combining partial hulls could be parallelized as well,
in the same manner as we have seen in the Jarvis March
algorithm.
V. M EASUREMENTS
All measurements have been performed on a server with
following configuration:
• 2 × CPU Intel Xeon Processor E5-2620 v2 (15MB L3
cache per CPU),
• CPU cores: 6 per CPU, 12 in total,
• Memory size: 32 GB RAM, total max. memory band-
width: 51.2 GB/s,
• Peak single precision floating point performance 0.48
Tflops (using base clocks),
• OS Linux, C++ compiler (g++) version 5.4.0 with
switches -O3 -march=native -mavx -fopenmp.
 JSPA QHN
15 JSO QHPC
4 QHFAR
Time [s]

Time [s]
QHALL
10

2
5

0 0
1 · 106 2 · 106 3 · 106 4 · 106 1 · 107 2 · 107
Input point set size Input point set size

Figure 1. Jarvis Scan version comparison Figure 3. Quickhull version comparison

GSPA CAGS
GSO
10 CAQH
GSPRE 10 CACOMB
Time [s]

AA

Time [s]
5 5

0 0
1 · 106 3 · 106 5 · 106 1.5 · 106 3 · 106 4.5 · 106 6 · 106
Input point set size Input point set size

Figure 2. Graham Scan version comparison Figure 4. Chan’s algorithm version comparison

Utilization of cores for testing parallel speedup has been polygon and time performance of tested algorithms. Tests
limited by omp_set_num_threads() function, wall with variable input set size have fixed size of output convex
clock times have been measured by omp_get_wtime(). hull, with 50 points being the default value (unless stated
A. Methods of testing otherwise).
Jarvis Scan: In Section III-A, we have described the
Since runtime of at least Jarvis Scan and Chan’s algorithm
common trick of using orientation checks (we will denote
is directly dependent on number of points on resulting
this version as JSO) instead of finding the polar angles
convex hull, we have designed a generator of input sets that
(denoted JSPA). The speedup achieved thanks to this change
has control over this parameter. More speciffically, it can
is documented in Figure 1.
generate random sets of points that are uniformly distributed
Graham Scan: Regarding Graham Scan, in Section III-B,
inside of regular or irregular convex polygons with given
we have proposed to speed up comparisons in point sorting
number of vertices. As these vertices are also parts of the
by precomputing the cosine of each point (version GSPRE).
input set, the number of points on convex hull is guaranteed
Speed comparison with polar angle based (GSPA) and
to be equal to their count, which means we can observe
dependency on this parameter in addition to the size of
the input set and number of cores. An example of dataset
generared inside a regular and irregular hexagon is shown
on Figure 5.
B. Sequential results
Before we mutually compare the optimized implementa-
tions of algorithms, the effect of individual improvements
is tested. This allows us to assess whether the change was
successful, and how significantly has it reduced the runtime.
All tests were conducted on regular polygons, since we
haven’t found any connection between the shape of the Figure 5. Example of generated regular and irregular hexagonal point set.

109

Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
 30
20
Time [s]
10
0
1 2 4 8
Figure 6. Comparison of parallel implementation runtimes.
15
GSO
Time [s]
QHFAR
10 CACOMB
5 the version without this change, presumably due to needed
0 extra orientation check.
250 500 750
Output convex hull size
Figure 7. Comparison of sequential implementations, 107 input points.
orientation comparison based (GSO) version is shown in
Figure 2. We can see that both GSPRE and GSO variants
are visibly faster than the naive GSPA implementation, with
the GSPRE being even faster than the common orientation
version. Furthermore, we have compared the Andrew’s al-
gorithm implementation (AA), which exhibits slightly worse
performance than improved Graham Scan. Since the time
complexity of both algorithms is dominated by sorting, it
means the linear precomputation step in Graham Scan runs
faster than the extra linear pass in Andrew’s algorithm.
Quickhull: In Quickhull, we have tested effects of three
improvements taken from [1] described in Section III-C
and compared them with the results provided in the source
article. Our results are visualised in Figure 3. Partial cross
product precumputing (QHPC) does not exhibit significant
improvements over naive implementation (QHN), which is
different than conclusions in [1]. The reason for this might
be in the version and flags of the used compiler, which have
not been stated in the source paper. After compiling our code
without the -O3 flag, improvements in comparison with the
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
Jarvis March
Graham Scan
Quickhull
Chan
12 16 24
Number of threads
naive version started to show up, although both algorithms
exhibited significant slowdown. Version with added farthest
point precomputation (QHFAR) is more than two times
faster than the naive implementation. Variant that cuts some
orientation computations based on coordinates (QHALL) on
the top of improvements in QHFAR is slightly slower than
comparisons being more time consuming than an occasional
1,000
Chan’s algorithm: For Chan’s algorithm, we have com-
pared results of Jarvis Scan, Graham Scan and Quickhull on
small hull sizes. They have shown Quickhull passes Graham
scan in terms of speed at approximately 500 points in the
input set, with Jarvis Scan being the slowest for practially
all cases. We have implemented three variants, using solely
Graham Scan (CAGS), Quickhull (CAQH) and one that
switches from Graham Scan to Quickhull on point sets
larger than 500 points (CACOMB). Tests in Figure 4 were
conducted with increased output hull size of 1000 points
in order to cover the effects of these improvements. We
can observe that the performance of CACOMB is slightly
improved in comparison with other versions.
Finally, we have compared all implemented algorithms
together. Measurements with respect to input set size are
visualised in Figure 8, using fixed output convex hull size of
100 points. Results with varying output convex hull size are
shown on Figure 7, conducted on input sets with 107 points
(Jarvis Scan excluded). Both tests show that Quickhull is
significantly faster than all other options. Chan’s algorithm,
despite its output sensitivity, is slower than Quickhull on
every convex hull size, probably because of its large hidden
constants in time complexity.
Dependence on the output size of Jarvis Scan is not
visualized, since its runtimes are too high for the scale. It
110

JSO
10 GSPRE
QHFAR
Time [s]
CACOMB
5 single thread version.
0
2 · 106 4 · 106 6 · 106
Input point set size
Figure 8. Comparison of sequential optimized implementations, h = 100.
is faster than Graham Scan for up to 50 points on hull and
does not surpass Quickhull even on the smallest hull sizes.
Quickhull also exhibits some amount of dependence on
output hull size, even though it is not enough to be slower
than Graham Scan. It has to be noted it is not possible to
consider much larger output hull sizes with the current im-
plementation, as 64 bit floating point number representation
is used for point coordinates, causing the triplets of points
on the hull to be considered collinear after passing certain
amount.
C. Parallel results
Our parallel implementations of surveyed algorithms have
been compared in terms of runtime on input with 1.5 · 107
points, 300 of them lying on the convex hull.
Sequential improvements from Section III are used as
a base for all parallelized algorithms. Figure 6 displays
algorithm runtimes depending on number of cores used.
Parallel speedups for the same data are visualized in Figure
10.
Experiments have shown that the best way of parallelizing
Jarvis Scan uses the combination of both methods described
in Section IV-A. Figure 10 shows that significant speedup
is only achieved with up to four threads, which is under-
standable in case of first method, and possibly caused by
increasing overhead in the second described method.
The lower bound for using parallel task for a Quickhull
subproblem was set to 10 000 points. Results in Figure 6
show that while Quickhull has the worst speedup of all tested
algorithms, its runtime still beats any other variant, even if
all 12 cores of our setup were utilized.
Chan’s algorithm is using sequential versions of convex
hull algorithms for computing subhulls, as use of parallel
ones only caused mild slowdown.
D. Comparison with state of the art libraries
We have compared the most widely used implementations
for solving the planar convex hulls with our best performing
implementation, being the QHFAR variant of Quickhull.
Namely, we have tested the performance of solvers from
Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.
Qhull and CGAL libraries using Quickhull (CGAL provides
a total of five algorithms for the problem, Quickhull always
performed the best of them), and the Boost library utilizing
Graham Scan. As all of the state of the art libraries use
sequential algorithms, our implementation also runs in its
Results are shown in Figure 9, our implementation has
more than 2 times shorter runtimes than the second best
tested implementation from the CGAL library. Closer in-
8 · 106 spection of these libraries’ source code shows, that Qhull
uses more general version of the algorithm scalable to
three dimensions, which may have affected its performance.
CGAL, however, uses fairly straightforward implementation
of Quickhull, and its slower runtimes could likely be at-
tributed to the lack of optimizations.
VI. C ONCLUSION
We have studied and implemented improvements for five
commonly used planar convex hull algorithms. Results of
our measurements show that even naive implementation
of Quickhull is faster than any other tested algorithm in
most tested cases. This is mainly caused by its ability to
prune points in the process, which significantly reduces time
complexity constants. As we have mentioned in Section
II, the only input sets where pruning is not possible, or
Quickhull reaches its quadratic upper bound, require all
points in the input set to lie on the convex hull. Dataset like
that is practically unrepresentable using a finite precision
arithmetics for n larger than several tens of thousands.
All considered, the only cases where we recommend to
consider algorithms other than Quickhull are large batches
of very small datasets, and inputs with extreme numbers of
points on the hull are expected, possibly combined with high
or arbitrary precision arithmetics.
Moreover, we have found out that the sequential optimiza-
tions by [1] can reduce runtime of Quickhull to less than
half of its original values. Our optimized implementation
is more than two times faster than any algorithm used
in CGAL and four times faster than Qhull, making it an
interesting candidate for future uses in time performace
focused applications.
In terms of parallelization, Quickhull has failed to match
the speedup of much simpler solutions used in other al-
gorithms. Additional tests observing the number of points
processed by each core suggest, that this is not just an
issue of uneven work distribution. The overhead of a task
pool based parallel solution seems to be too large for an
algorithm with so short sequential runtimes. Despite these
shortcomings, Quickhull was still the best performer at any
tested number of threads.
ACKNOWLEDGEMENT
This research has been supported by CTU internal grant
SGS17/215/OHK3/3T/18.
111
 2 Our implementation
Boost
CGAL
Qhull
1.5
Time [s]

0.5

0
2 · 106 4 · 106 6 · 106 8 · 106
Input point set size

Figure 9. Comparison of our implementation with state of the art libraries, h = 100.

4 [7] D. R. Chand and S. S. Kapur, “An algorithm for convex

polytopes,” Journal of the ACM, vol. 17, no. 1, pp. 78–86,
1970.
3
Speedup

[8] R. L. Graham, “An efficient algorithm for determining the

2 convex hull of a finite planar set,” Inf. Process. Lett., vol. 1,
no. 4, pp. 132–133, 1972.
1
[9] A. Andrew, “Another efficient algorithm for convex hulls
Jarvis Graham Quickhull Chan
in two dimensions,” Information Processing Letters, vol. 9,
0 no. 5, pp. 216–219, 1979.
1 4 8 16 24
Number of threads [10] C. B. Barber, D. P. Dobkin, and H. Huhdanpaa, “The
quickhull algorithm for convex hulls,” ACM Transactions on
Figure 10. Comparison of parallel speedups. Mathematical Software, vol. 22, no. 4, pp. 469–483, 1996.

[11] S. G. Akl and G. T. Toussaint, “A fast convex hull algorithm,”

R EFERENCES
[1] N.-D. Hoang and N. K. Linh, “Quicker than quickhull,”
Vietnam Journal of Mathematics, vol. 43, no. 1, pp. 57–70,
2015.
[2] S. Ramaswami, “Convex hulls: Complexity and applications
(a survey),” 1993. [Online]. Available: http://repository.upenn.
edu/cgi/viewcontent.cgi?article=1272&context=cis reports.
Information Processing Letters, vol. 7, no. 5, pp. 219 – 222,
1978.
[12] J. L. Bentley, F. P. Preparata, and M. G. Faust, “Approxima-
tion algorithms for convex hulls,” Commun. ACM, vol. 25,
no. 1, pp. 64–68, 1982.
[13] C. B. Barber and H. Huhdanpaa, “Qhull 2015.2.” [Online].
Available: http://www.qhull.org/.

[3] J. G. Erickson, “Lower bounds for fundamental geometric
problems,” tech. rep., 5th Annual European Symposium on
Algorithms (ESA’97), 1996.
[4] D. G. Kirkpatrick and R. Seidel, “The ultimate planar convex
hull algorithm?,” SIAM Journal on Computing, vol. 15, no. 1,
pp. 287–299, 1986.
[5] T. M. Chan, “Optimal output-sensitive convex hull algorithms
in two and three dimensions,” Discrete & Computational
Geometry, vol. 16, no. 4, pp. 361–368, 1996.
[6] R. Jarvis, “On the identification of the convex hull of a finite
set of points in the plane,” Information Processing Letters,
vol. 2, no. 1, pp. 18–21, 1973.
[14] CGAL Editorial Board, “Cgal 4.8.” [Online]. Available: http:
//www.cgal.org/”.
[15] Boost Development Team, “Boost c++ libraries 1.55.0.” [On-
line]. Available: http://www.boost.org/users/history/version
1 55 0.html.
[16] “OpenMP API for parallel programming, version 4.0.” [On-
line]. Available: http://www.openmp.org/wp-content/uploads/
OpenMP4.0.0.pdf.
[17] “The GNU C++ library documentation, parallel mode.”
[Online]. Available: https://gcc.gnu.org/onlinedocs/libstdc++/
manual/parallel mode.html.

112

Authorized licensed use limited to: Monash University. Downloaded on October 06,2022 at 09:44:32 UTC from IEEE Xplore. Restrictions apply.