1. Computational Geometry 2D Convex Hulls
Joseph S. B. Mitchell
Stony Brook University

2. Comparing O(n), O(n log n), O(n2)
n n log n n²
210 10³ • 210   106
220  • 220  2 • 1012
Interactive
Processing n log n algorithms n² algorithms
n = yes ?
n = ? no

3. Convexity Set X is convex if p,qX  pq X
non-convex
convex
Set X is convex if p,qX  pq X
Point p X is an extreme point if there exists a line (hyperplane) through p such that all other points of X lie strictly to one side
Fact: If X=S is a finite set of points in 2D, then CH(X) is a convex polygon whose vertices (extreme points) are points of S.
Extreme points in red r p q

4. Fundamental Problem: 2D Convex Hulls
More generally:
CH(polygons)
Input: n points S = (p1, p2, …, pn)
Output: A boundary representation, e.g., ordered list of vertices (extreme points), of the convex hull, CH(S), of S (convex polygon) p2 p7 p4 p8 p3 p1 p6 p5 p9
Output: (9,6,4,2,7,8,5)

5. Equivalent Definitions of Convex Hull, CH(X)
{all convex combinations of d+1 points of X } [Caratheodory’s Thm] (in any dimension d)
Set-theoretic “smallest” convex set containing X.
In 2D: min-area (or min-perimeter) enclosing convex body containing X
In 2D:

6. 2D Convex Hull Algorithms
O(n4) simple, brute force (but finite!)
O(n3) still simple, brute force
O(nh) simple, “output-sensitive”
h = output size (# vertices)
O(n log n) worst-case optimal (as fcn of n)
O(n log h) “ultimate” time bound (as fcn of n,h)
Randomized, expected O(n log n)
Lower bound: (n log n)
Simple, elegant
y= x2
(xi ,xi2 )
From SORTING:
Note: Even if the output of CH is not required to be an ordered list of vertices (e.g., just the # of vertices), (n log n) holds xi

7. Primitive Computation
“Left” tests: sign of a cross product (determinant), which determines the orientation of 3 points
Time O(1) (“constant”) c b
Left( a, b, c ) = TRUE  ab  ac > 0
c is left of ab a

8. SuperStupidCH: O(n4) Fact: If s ∆pqr, then s is not a vertex of CH(S)
 q  p
 r  p,q
 s  p,q,r: If s  ∆pqr then mark s as NON-vertex
Output: Vertices of CH(S)
Can sort (O(n log n) ) to get ordered q s p
O(n3) r
O(n)

9. StupidCH: O(n3)
Fact: If all points of S lie strictly to one side of the line pq or lie in between p and q, then pq is an edge of CH(S).
 p
 q  p
 r  p,q: If r  red then mark pq as NON-edge (ccw)
Output: Edges of CH(S)
Can sort (O(n log n) ) to get ordered p r q
O(n2)
O(n)
Applet by Snoeyink
Caution!! Numerical errors require care to avoid crash/infinite loop!

10. O(nh) : Gift-Wrapping Idea: Use one edge to help find the next edge.
Jarvis March
Idea: Use one edge to help find the next edge.
Output: Vertices of CH(S)
Demo applet of Jarvis march r
O(n) per step
h steps
Total: O(nh) q p
Key observation:
Output-sensitive!

11. Example: QHull Extensive links and material! webpage
Komei Fukuda website
Delaunay triangulation and 3D convex hulls applet

12. O(n log n) : Graham Scan Idea: Sorting helps!
Start with vlowest (min-y), a known vertex
Sort S by angle about vlowest
Graham scan:
Maintain a stack representing (left-turning) CH so far
If pi is left of last edge of stack, then PUSH
Else, POP stack until it is left, charging work to popped points
O(n)
O(n log n)
O(n)
CH so far
vlowest
Demo applet

13. O(n log n) : Divide and Conquer
Split S into Sleft and Sright , sizes n/2
Recursively compute CH(Sleft ), CH(Sright)
Merge the two hulls by finding upper/lower bridges in O(n), by “wobbly stick”
Time O(n)
Time 2T(n/2)
Time O(n)
Sleft
Sright
Time:
T(n)  2T(n/2) + O(n) 
T(n) = O(n log n)
Demo applet

14. QuickHull
Applet (programmed by Jeff So)
Applet (by Lambert)

15. QuickHull QuickHull(a,b,S) to compute upperhull(S) B A S
If S=, return ()
Else return (QuickHull(a,c,A), c, QuickHull(c,b,B))
c = point furthest from ab c
Discard points in abc B A
Worst-case: O(n2 )
Avg: O(n) b a
Works well in higher dimensions too! S
Qhull website
Qhull, Brad Barber (used within MATLAB)

16. O(n log n) : Randomized Incremental
Add points in random order
Keep current Qi = CH(v1 ,v2 ,…,vi )
Add vi+1 :
If vi+1  Qi , do nothing
Else insert vi+1 by
finding tangencies,
updating the hull
Expected cost of insertion: O(log n)

17. Each uninserted vj  Qi (j>i+1) points to the bucket (cone) containing it; each cone points to the list of uninserted vj  Qi within it (with its conflict edge)
Add vi+1  Qi :
Start from “conflict” edge e, and walk cw/ccw to establish new tangencies from vi+1 , charging walk to deleted vertices
Rebucket points in affected cones
(update lists for each bucket)
Total work: O(n) + rebucketing work
E(rebucket cost for vj at step i) =
O(1)  P(rebucket)  O(1)  (2/i ) = O(1/i )
E(total rebucket cost for vj ) =  O(1/i ) = O(log n)
Total expected work = O(n log n) e
vi+1
Backwards Analysis:
vj was just rebucketed iff the last point inserted was one of the 2 endpoints of the (current) conflict edge, e, for vj vj

18. More Demos
Various 2D and 3D algorithms in an applet

19. More CG Applets Applets of algorithms in O’Rourke’s book
Applets from Jack Snoeyink