CONVEX HULLS

PETR FELKEL
FEL CTU PRAGUE
felkel@[Link]
[Link]

Based on [Berg] and [Mount]

Version from 16.11.2017

Talk overview
 Motivation and Definitions
 Graham’s scan – incremental algorithm
 Divide & Conquer
 Quick hull
 Jarvis’s March – selection by gift wrapping
 Chan’s algorithm – optimal algorithm

[Link]

Felkel: Computational geometry

(2)
Convex hull (CH) – why to deal with it?

 Shape approximation of a point set or complex shapes

(other common approximations include: minimal area enclosing
rectangle, circle, and ellipse,…) – e.g., for collision detection
 Initial stage of many algorithms to filter out irrelevant
points, e.g.:
– diameter of a point set
– minimum enclosing convex shapes (such as rectangle, circle,
and ellipse) depend only on points on CH

Felkel: Computational geometry

(3)
Convexity
Line test !!!

 A set S is convex convex not convex

– if for any points p,q  S the lines segment pq  S, or

– if any convex combination of p and q is in S
 Convex combination of points p, q is any point that
can be expressed as q
p =1
(1 – ) p + q, where 0    1 =0

 Convex hull CH(S) of set S – is (similar definitions)

– the smallest set that contains S (convex)
– or: intersection of all convex sets that contain S
– Or in 2D for points: the smallest convex polygon
containing all given points

Felkel: Computational geometry

(5)
Definitions from topology in metric spaces
 Metric space – each two of points have defined a distance r
 r-neighborhood of a point p and radius r > 0 p

= set of points whose distance to p is strictly less than r

(open ball of diameter r centered about p)
 Given set S, point p is
– Interior point of S – if ∃ , > 0, (r-neighborhood about p)  S
– Exterior point – if it lies in interior of the complement of S
– Border point – is neither interior neither exterior

Interior point r
p
Exterior point p
S
Border point

Felkel: Computational geometry

(6)
 Definitions from topology in metric spaces
 Set S is Open (otevřená)
Are border points p ∈ ?

– p  S  (r-neighborhood about p of radius r)  S

– it contains only interior points, none of its border points
 Closed (uzavřená)
– If it is equal to its closure S (uzávěr = smallest closed set containing S in topol. space)
(r-neighborhood about p of radius r)  S  )
 Clopen (otevřená i uzavřená) – Ex. Empty set , finite set of disjoint components
– if it is both closed and open
Goes to infinity?

space Q = rational numbers

(S= all positive rational numbers whose square is bigger than 2) S = (2, ) in Q, 2  Q, S = S

Bounded (ohraničená)
Goes to
infinity
 Unbounded

– if it can be enclosed in a ball of finite radius

 Compact (kompaktní)
– if it is both closed and bounded
Felkel: Computational geometry
(7)
Clopen (otevřená i uzavřená)
– Ex. Empty set , finite set of disjoint components
if it is both closed and open space Q = rational numbers
(S= all positive rational numbers whose square is bigger than 2) S = (2, ) in Q, 2  Q, S = S

= .
S

Felkel: Computational geometry

(8)
Definitions from topology in metric spaces
 Convex set S may be bounded or unbounded
Bounded
Bounded
Closed

Open

[Mount]

 Convex hull CH(S) of a finite set S of points in the

plane
= Bounded, closed, (= compact) convex polygon

point
segment
polygon

Felkel: Computational geometry

(9)
Convex hull representation
 CCW enumeration of vertices
 Contains only the extreme points
(“endpoints” of collinear points)

 Simplification for the whole semester:

Assume the input points are in general position,
– no two points have the same x-coordinates and
– no three points are collinear

-> We avoid problem with non-extreme points on x

(solution may be simple – e.g. lexicographic ordering)
Felkel: Computational geometry
(10)
Online x offline algorithms
 Incremental algorithm
– Proceeds one element at a time (step-by-step)
 Online algorithm (must be incremental)
– is started on a partial (or empty) input and
– continues its processing as additional input data
becomes available (comes online, thus the name).
– Ex.: insertion sort
 Offline algorithm (may be incremental)
– requires the entire input data from the beginning
– than it can start
– Ex.: selection sort (any algorithm using sort)

Felkel: Computational geometry

(11)
Graham’s scan
 Incremental O(n log n) algorithm
 Objects (points) are added one at a time
 Order of insertion is important
1. Random insertion
–> we need to test: is-point-inside-the-hull(p)
2. Ordered insertion
Find the point with the smallest y coordinate first
a) Sort points according to increasing angles around the point
(angle of and axis)
b) Andrew’s modification: sort points according to x and add
them left to right (construct upper & lower hull)
Sorting x-coordinates is simpler to implement than sorting of angles

Felkel: Computational geometry

(13)
Graham’s scan – b) modification by Andrew
 O(n log n) for unsorted points, O(n) for sorted pts.
 Upper hull, then lower hull. Merge.
 Minimum and maximum on x belong to CH
upper hull

pn

p1

lower hull

Felkel: Computational geometry

(14)
Graham’s scan – incremental algorithm
push pop
GrahamsScan(points p)
Input: points p tos
sos
Output: CCW points on the convex hull
1. sort points according to increasing x-coord -> {p1, p2, …, pn} Stack H
2. push( p1, H), push( p2, H ) upper hull
3. for i = 3 to n do
4. while( size(H)  2 and orient( sos, tos, pi )  0 ) // skip left turns
5. pop H // (back-tracking)
6. push( pi, H ) // store right turn
7. store H to the output (in reverse order) // upper hull
8. Symmetrically the lower hull

pop H pop H
pop

sos tos pi sos tos pi sos tos pi

Felkel: Computational geometry
(15)
Position of point in relation to segment
>0 r is left from pq, CCW orient
orient( p, q, r ) =0 if ( p, q, r ) are collinear
<0 r is right from pq, CW orient
Point r is: left from pq on segment pq right from pq
r q
q r q p
p p r

Convex polygon with edges pq and qr or

Triangle pqr: is CCW oriented degenerated is CW oriented
r to line q
q r q
p
p p r

Felkel: Computational geometry

(16)
Is Graham’s scan correct?
Stack H at any stage contains upper hull of the points
{ 1, … , , }, processed so far
– For induction basis = { , } … true
– = last added point to CH, = its predecessor on CH
– Each point that lies between and lies below and should
not be part of UH after addition of => is removed before push .
[orient( , , ) > 0, is right from ⇒ is removed from UH]
– Stop, if 2 points in the stack or after construction of the upper hull

CHi-1 CHi

Points on stack H
= CH ({ , , … , })

pk
[Mount]

Felkel: Computational geometry

(19)
Complexity of Graham’s scan
 Sorting according x – O(n log n)
 Each point pushed once – O(n)
 Some (di  n) points deleted while processing pi
– O(n)
 The same for lower hull – O(n)

 Total O(n log n) for unsorted points

O(n) for sorted points

Felkel: Computational geometry

(20)
Divide & Conquer
 (n log(n)) algorithm
 Extension of mergesort
 Principle
– Sort points according to x-coordinate,
– recursively partition the points and solve CH.

Felkel: Computational geometry

(21)
Convex hull by D&C
Upper tangent
ConvexHullD&C( points P )
Input: points p
Output: CCW points on the convex hull
1. Sort points P according to x
2. return hull( P )

3. hull( points P )
4. if |P|  3 then
Lower tangent
5. compute CH by brute force,
6. return
7. Partition P into two sets L and R (with lower & higher coords x)
8. Recursively compute HL = hull(L), HR = hull(R)
9. H = Merge hulls(HL, HR) by computing
10. Upper_tangent( HL, HR) // find nearest points, HL CCW, HR CW
11. Lower_tangent( HL, HR) // (HL CW, HR CCW)
12. discard points between these two tangents
13. return H

Felkel: Computational geometry

(22)
Search for upper tangent (lower is symmetrical)
Upper tangent
Upper_tangent( HL, HR) HR
Input: two non-overlapping CH’s HL
Output: upper tangent ab
b
1. a = rightmost HL
a
2. b = leftmost HR

Lower tangent
3. while( ab is not the upper tangent for HL, HR ) do
4. while( ab is not the upper tangent for HL) a = [Link] // move CCW
5. while( ab is not the upper tangent for HR) b = [Link] // move CW
6. Return ab

Where: (ab is not the upper tangent for HL) => orient(a, b, [Link])  0
which means [Link] is left from line ab
m = |HL|+ |HR|  |L| + |R| => Upper Tangent: O(m) = O(n)
Felkel: Computational geometry
(23)
Convex hull by D&C complexity
 Initial sort O(n log(n))
 Function hull()
– Upper and lower tangent O(n)
– Merge hulls O(1) O(n)
– Discard points between tangents O(n)
 Overall complexity
– Recursion
1 … if n  3
T(n) =
2T(n/2) + O(n) … otherwise
– Overall complexity of CH by D&C: => O(n log(n))

Felkel: Computational geometry

(24)
Quick hull
 A variant of Quick Sort
 O(n log n) expected time, max O(n2)
 Principle
– in praxis, most of the points lie in the interior of CH
– E.g., for uniformly distributed points in unit square, we
expect only O(log n) points on CH
 Find extreme points (parts of CH)
quadrilateral, discard inner points
– Add 4 edges to temp hull T
– Process points outside 4 edges

[Mount]

Felkel: Computational geometry

(25)
Process each of four groups of points outside

 For points outside ab (left from ab for clockwise CH)

– Find point c on the hull – max. perpend. distance to ab
– Discard points inside triangle abc (right from the edges)
– Split points into two subsets
- outside ac (left from ac) and outside cb (left from cb)
– Process points outside ac and cb recursively
– Replace edge ab in T by edges ac and cb

discard inner points

[Mount]

Felkel: Computational geometry

(26)
Quick hull complexity n2

n points remain outside the hull

n1


 T(n) = running time for such n points outside

– O(n) - selection of splitting point c
– O(n) - point classification to inside & (n1+n2) outside
– n1+n2  n
– The running time is given by recurrence

1 if n = 1 OK

T(n) = > WRONG

T(n1) + T(n2) where n1+n2  n
– If evenly distributed that max , ,0 1
then solves as QuickSort to O(cn log n) where c=f()
else O(n2) for unbalanced splits

Felkel: Computational geometry

(27)
Jarvis’s March – selection by gift wrapping
 Variant of O(n2) selection sort
 Output sensitive algorithm
 O(nh) … h = number of points on convex hull

Felkel: Computational geometry

(28)
Jarvis’s March
JarvisCH(points P)
Input: points p
Output: CCW points on the convex hull hh
p0
1. Take point pmin with minimum y-coordinate, h1= pmin h2
// pmin will be the first point in the hull – append it to the hull as h1
2. Take a horizontal line, i.e., create temporary point p0 = (–, h1.y)
3. j=1
4. repeat
5. Rotate the line around hj until it bounces to the nearest point q = pq
// compute the smallest angle by the “smallest orient(hj-1 , hj, q)”
6. j++
append the bounced nearest point q to the hull as next hj
7. until (q  pmin) Output sensitive algorithm

Complexity: O( n ) + O( n ) * h => O( h*n )

good for low number of points on convex hull
Felkel: Computational geometry
(29)
Output sensitive algorithm
 Worst case complexity analysis analyzes the worst
case data
– Presumes, that all (const fraction of) points lie on the CH
– The points are ordered along CH
=> We need sorting => (n log n) of CH algorithm
 Such assumption is rare
– usually only much less of points are on CH
 Output sensitive algorithms
– Depend on: input size n and the size of the output h
– Are more efficient for small output sizes
– Reasonable time for CH is O(n log h), h = Number of points on the CH
Felkel: Computational geometry
(30)
Chan’s algorithm
 Cleverly combines Graham’s scan and Jarvis’s
march algorithms
 Goal is O(n log h) running time
– We cannot afford sorting of all points - (n log n)
=> Idea: work on parts, limit the part sizes to polynomial hc
the complexity does not change => log hc = log h
– h is unknown – we get the estimation later
– Use estimation m, better not too high => h  m  h2
 1. Partition points P into r-groups of size m, r = n/m
– Each group take O(m log m) time - sort + Graham
– r-groups take O(r m log m) = O(n log m) - Jarvis

Felkel: Computational geometry

(31)
Merging of m parts in Chan’s algorithm
 2. Merge r-group CHs as “fat points”
– Tangents to convex m-gon can be found in O(log m)
by binary search

r = n/m disjoint subsets

of size at most m

Jarvis
[Mount]
Chan
[Mount]

Felkel: Computational geometry

(32)
Chan’s algorithm complexity
 h points on the final convex hull
=> at most h steps in the Jarvis march algorithm
– each step computes r-tangents, O(log m) each
– merging together O(hr log m)
r-groups of size m, r = n/m
 Complete algorithm O(n log h)
– Graham’s scan on partitions O(r .m log m)=O(n log m)
– Jarvis Merging: O(hr log m) = O(h n/m log m), …4a)
h  m  h2 = O(n log m)
– Altogether O(n log m)
– How to guess m? Wait!
1) use m as an estimation of h 2) if it fails, increase m
Felkel: Computational geometry
(33)
Chan’s algorithm for known m
PartialHull( P, m)
Input: points P
Output: group of size m
[Mount]

1. Partition P into r = n/m disjoint subsets {p1, p2, …, pr} of size at most m
2. for i=1 to r do
a) Convex hull by GrahamsScan(Pi), store vertices in ordered array
3. let p1 = the bottom most point of P and p0 = (–, p1.y)
4. for k = 1 to m do // compute merged hull points O(log m)
a) for i = 1 to r do // angle to all r subsets => points qi
Compute the point qi  P that maximizes the angle  pk-1, pk, qi
Jarvis

b) let pk+1 be the point q  {q1, q2, …, qr} that maximizes  pk-1, pk, q
(pk+1 is the new point in CH)
c) if pk+1 = p1 then return {p1, p2, …, pk}
5. return “Fail, m was too small”

Felkel: Computational geometry

(34)
Chan’s algorithm – estimation of m
ChansHull
Input: points P
Output: convex hull p1…pk

1. for t = 1, 2, … , lg lg ℎ do {
a) let m = min(22^t, n)
b) L = PartialHull( P, m)
c) if L  “Fail, m was too small” then return L
}
Sequence of choices of m are { 4, 16, 256,…, 22^t ,…, n } … squares

Example: for h = 23 points on convex hull of n = 57 points, the algorithm

will try this sequence of choices of m { 4, 16, 57 }
1. 4 and 16 will fail
2. 256 will be replaced by n=57

Felkel: Computational geometry

(35)
Complexity of Chan’s Convex Hull?
 The worst case: Compute all iterations
 tth iteration takes O( n log 22^t) = O(n 2t)
 Algorithm stops when 22^t  h => t = lg lg h
 All t = lg lg h iterations take:
k
Using the fact that  2 i

i 0
 2 k 1
1
t iterations

lg lg h lg lg h

 n2  n  2  n2
t 1
t

t 1
t 1 lg lg h
 2n lg h  O(n log h)

2x more work in the worst case

Felkel: Computational geometry
(36)
Conclusion in 2D
 Graham’s scan: O(n log n), O(n) for sorted pts
 Divide & Conquer: O(n log n)
 Quick hull: O(n log n), max O(n2) ~ distrib.
 Jarvis’s march: O(hn), max O(n2) ~ pts on CH
 Chan’s alg.: O(n log h) ~ pts on CH
asymptotically optimal
but
constants are too high to be useful

Felkel: Computational geometry

(37)
References
 [Berg] Mark de Berg, Otfried Cheong, Marc van Kreveld, Mark
Overmars: Computational Geometry: Algorithms and Applications,
Springer-Verlag, 3rd rev. ed. 2008. 386 pages, 370 fig. ISBN: 978-3-540-
77973-5, Chapter 5, [Link]
 [Mount] David Mount, - CMSC 754: Computational Geometry, Lecture
Notes for Spring 2007, University of Maryland, Lectures 3 and 4.
[Link]
 [Chan] Timothy M. Chan. Optimal output-sensitive convex hull
algorithms in two and three dimensions., Discrete and Computational
Geometry, 16, 1996, 361-368.
[Link]

Felkel: Computational geometry

(38)