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

Comparing O(n), O(n log n), O(n2) n n log n n² 210 10³ 10 • 210  104 220  106 220  106 20 • 220  2 • 107 240 1012 Interactive Processing n log n algorithms n² algorithms n = 1000 yes ? n = 1000000 ? no

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

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)

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:

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

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

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)

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!

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!

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

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

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

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

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)

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)

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

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

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