Computational Geometry

2D Convex Hulls

Joseph S. B. Mitchell Stony Brook University

Chapter 2: Devadoss-O’Rourke

Convexity

Set X is convex if p,qX 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

2

p q

r Extreme points in red

p

q non-convex

q

p

convex

Convex Hull

3

Convex Hull, Extreme Points

4

Convex Hull: Equivalent Def

Convex combination of points:

5

Convex Hull: Equivalent Defs

6

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:

7

halfspaceHXH

H,

Xcba

abc

,,

convexTXT

T,

Devadoss-O’Rourke Def

Convex Hull in 2D

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.

8

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)

Fundamental Algorithmic Problem: 2D Convex Hulls

9

More generally: CH(polygons) p4

p1

p3

p2

p6 p5

p8 p7

p9 Output: (9,6,4,2,7,8,5)

Convex Hull Problem in 2D

10

Computational Complexity

11

Function T(n) is O(f(n)) if there exists a constant C such that , for sufficiently large n, T(n) < C f(n)

Comparing O(n), O(n log n), O(n2)

12

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

Function T(n) is O(f(n)) if there exists a constant C such that , for sufficiently large n, T(n) < C f(n)

2D Convex Hull Algorithms

O(n4) simple, brute force (but finite!)

O(n3) still simple, brute force

O(n2) incremental algorithm

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)

13

[DO] Section 2.2

Lower Bound

Lower bound: (n log n)

14

From SORTING:

y= x2

xi

(xi ,xi2 )

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

[DO] Section 2.5

As function of n and h: (n log h) holds

Lower Bound

15

[DO] Section 2.5

computing the ordered convex hull of n points in the plane.

Lower Bound

16

[DO] Section 2.5

computing the ordered convex hull of n points in the plane.

An even stronger statement is true:

Primitive Computation

• “Left” tests: sign of a cross product (determinant), which determines the orientation of 3 points

• Time O(1) (“constant”)

17

a

b c

Left( a, b, c ) = TRUE ab ac > 0 c is left of ab

SuperStupidCH: O(n4)

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

18

O(n3)

O(n)

s p

q

r

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

19

O(n2)

O(n)

p

r

q

Caution!! Numerical errors require care to avoid crash/infinite loop!

Applet by Snoeyink

Incremental Algorithm

20

[DO] Section 2.2

Incremental Algorithm

Sort points by x-coordinate O(n log n)

Build CH(X), adding pts left to right

21

Incremental Algorithm

22

Incremental Algorithm

23

O(nh) : Gift-Wrapping

Idea: Use one edge to help find the next edge.

Output: Vertices of CH(S) Demo applet of Jarvis march

24

p

q

r

Jarvis March

Key observation: Output-sensitive!

O(n) per step h steps Total: O(nh)

Gift-Wrapping

25

[DO] Section 2.4

Gift-Wrapping

26

[DO] Section 2.4

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

28

O(n log n)

O(n)

O(n)

Demo applet vlowest CH so far

Graham Scan

29

Red points form right turn, so are discarded [DO] Section 2.4

Graham Scan

30

[DO] Section 2.4

Graham Scan

31

[O’Rourke, Chapter 3]

Sorted points:

32 [O’Rourke, Chapter 3]

Stack History

33

[O’Rourke, Chapter 3]

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”

34

Sleft Sright

Time: T(n) 2T(n/2) + O(n) T(n) = O(n log n)

Time O(n)

Time O(n)

Time 2T(n/2)

Demo applet

Divide and Conquer

35

[DO] Section 2.6

Divide and Conquer

36

[DO] Section 2.6

Divide and Conquer

37

[DO] Section 2.6

QuickHull

QuickHull(a,b,S) to compute upperhull(S)

• If S=, return ()

• Else return (QuickHull(a,c,A), c, QuickHull(c,b,B))

38

Qhull website Qhull, Brad Barber (used within MATLAB)

a

b

c

S

B A

Worst-case: O(n2 ) Avg: O(n)

Discard points in abc

c = point furthest from ab

Works well in higher dimensions too!

QuickHull

Applet (programmed by Jeff So)

Applet (by Lambert)

When is it “bad”? (see hw2) • If no points are discarded (in abc), at

each iteration, and

• The “balance” may be very lop-sided (between sets A and B; in fact, one set could be empty, at every iteration!)

39

QuickHull

40

[David Mount lecture notes, Lecture 3]

O(n log n) : Incremental Construction

Add points in the order given: v1 ,v2 ,…,vn Maintain 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

Worst-case cost of insertion: O(log n)

But, uses complex data structures

41

Point location test: O(log n)

Binary search: O(log n)

AMS 545 / CSE 555

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)

42

AMS 545 / CSE 555

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)

43

vi+1 e

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)

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

AMS 545 / CSE 555

Output-Sensitive: O(n log h)

The “ultimate” convex hull (in 2D) • “Marriage before Conquest” : O(n log h)

• Lower bound (n log h)

[Kirkpatrick & Seidel’86]

Simpler [Chan’95]

2 Ideas: • Break point set S into groups of appropriate size m

(ideally, m = h)

• Search for the “right” value of m ( =h, which we do not know in advance) by repeated squaring

44

h = output size

So, O(n log h) is BEST POSSIBLE, as function of n and h !!

AMS 545 / CSE 555

Chan’s Algorithm

Break S into n/m groups, each of size m • Find CH of each group (using, e.g., Graham scan):

O(m log m) per group, so total O((n/m) m log m) = O(n log m)

Gift-wrap the n/m hulls to get overall CH: • At each gift-wrap step, when pivoting around vertex v

find the tangency point (binary search, O(log m)) to each group CH

pick the smallest angle among the n/m tangencies:

• O( h (n/m) log m)

Hope: m=h

Try m = 4, 16, 256, 65536,…

45

= O(n log h)

= O( h (n/h) log h) = O(n log h)

v

O(n ( log (221 ) + log (222 ) + log (223 ) + … log (22 log (log (h)) ) = O(n (21 + 22 + 23 + … + 2log (log (h)) )) = O(n (2 log h)) = O(n log h)

v

AMS 545 / CSE 555

CH of Simple Chains/Polygons

Input: ordered list of points that form a simple chain/cycle

Importance of simplicity (noncrossing, Jordan curve) as a means of “sorting” (vs. sorting in x, y)

Melkman’s Algorithm: O(n) (vs. O(n log n) or O(n log h))

46

1

2

n

vi

Melkman’s Algorithm Keep hull in DEQUE: < vb ,vb+1 ,…,vt-1 ,vt =vb >

While Left(vb ,vb+1 ,vi ) and Left(vt-1 ,vt ,vi )

i i+1

Remove vb+1 , vb+2 ,…

and vt-1 , vt-2 ,…

until convexity restored

New vb =vt = vi

Claim: Simplicity assures that the only way for the chain to exit the current hull is via pockets vb vb+1 or vt-1 vt .

47

Time: O(n), since O(1) per insertion

vb vb+1

vt-1

vt vi

vt

vb

vt-1

vb+1

Simplicity helps!

Melkman’s Algorithm

48

Melkman’s Algorithm

49

Melkman’s Algorithm

50

Expected Size of CH

51

Expected Size, h, of CH

Claim: For n points uniform in a square, the expected number of maximal points is O(log n)

Corollary: E(h) = O(log n)

Thus, Gift-Wrap/Jarvis runs in expected O(n log n), if points are uniform in a box, etc.

52

(since CH vertices are subset of maximal points)

CH, Polytopes in Higher Dimensions

53

CH, Polytopes in Higher Dimensions

54

Representing the structure of a simplex or polytope: Incidence Graph Later: for planar subdivisions (e.g., boundary of 3-dim polyhedra), we have various data structures: winged-edge, doubly-connected edge list (DCEL), quad-edge, etc.

[David Mount lecture notes, Lecture 5]

Convex Hull in 3D

55

Convex Hull in 3D

56

CH in Higher Dimensions

3D: Divide and conquer: • T(n) 2T(n/2) + O(n)

• O(n log n)

• Output-sensitive: O(n log h) [Chan]

Higher dimensions: (d 4) • O(n d/2 ), which is worst-case OPT, since

point sets exist with h=(n d/2 )

• Output-sensitive: O((n+h) logd-2 h), for d=4,5

57

merge

h= O(n)

Qhull website

applet

Convex Hull in 3D

58

Convex Hull in 3D

59

More Demos

Various 2D and 3D algorithms in an applet

Applets of algorithms in O’Rourke’s book

Applets from Jack Snoeyink

60

Review: Convex Hull Algorithms

O(n4), O(n3), naïve

O(n2) incremental algorithm

O(nh) simple, “output-sensitive”

O(n log n) Graham scan, divide-and-conquer, incremental (with fancy data structures); 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) (simple)

3D: Divide and conquer: O(n log n)

• Output-sensitive: O(n log h) [Chan]

Higher dimensions: (d 4) • O(n d/2 ), which is worst-case OPT,

• Output-sensitive: O((n+h) logd-2 h), for d=4,5

61