Computational Geometry 2D Convex Hulls

Computational Geometry2D 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 Processingn log n algorithms n² algorithms n = 1000 yes ? n = 1000000 ? no

p q p convex non-convex q Convexity Extreme points in red r p q Set X is convexif 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.

Fundamental Problem: 2D Convex Hulls More generally: CH(polygons) p2 p7 p4 p8 p3 p1 p6 p5 p9 Output: (9,6,4,2,7,8,5) 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)

Equivalent Definitions of Convex Hull, CH(X) {all convex combinations of d+1 points of X } [Caratheodory’sThm] (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 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 • 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) xi

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

SuperStupidCH: O(n4) q s p O(n3) r O(n) • Fact: If s∆pqr, then s is not a vertex of CH(S) •  p •  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

StupidCH: O(n3) q p O(n2) r O(n) Applet by Snoeyink • 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  redthen mark pq as NON-edge (ccw) • Output: Edges of CH(S) • Can sort (O(n log n) ) to get ordered Caution!! Numerical errors require care to avoid crash/infinite loop!

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

O(n log n) : Graham Scan O(n) O(n log n) O(n) CH so far • 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 vlowest Demo applet

O(n log n) : Divide and Conquer 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) Split S into Sleftand 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” Demo applet

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

QuickHull 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 • QuickHull(a,b,S) to compute upperhull(S) • If S=, return () • Else return (QuickHull(a,c,A), c, QuickHull(c,b,B)) 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)

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 vjat 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) vj 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 Each uninsertedvj Qi(j>i+1) points to the bucket (cone) containing it; each cone points to the list of uninsertedvj Qiwithin it(with its conflict edge)

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

Computational Geometry 2D Convex Hulls