0% found this document useful (0 votes)
60 views34 pages

Convex Hulls

This document provides an overview of algorithms for computing convex hulls. It begins with definitions and motivation for computing convex hulls, including using them for shape approximation and as an initial step in other algorithms. It then outlines several algorithms for computing convex hulls, including Graham's scan, which is an incremental O(n log n) algorithm. The document explains Graham's scan in detail, including how it constructs the upper and lower hulls using a stack. It also defines key terms used in convex hull algorithms like orientation.

Uploaded by

Tsuki Zombina
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
60 views34 pages

Convex Hulls

This document provides an overview of algorithms for computing convex hulls. It begins with definitions and motivation for computing convex hulls, including using them for shape approximation and as an initial step in other algorithms. It then outlines several algorithms for computing convex hulls, including Graham's scan, which is an incremental O(n log n) algorithm. The document explains Graham's scan in detail, including how it constructs the upper and lower hulls using a stack. It also defines key terms used in convex hull algorithms like orientation.

Uploaded by

Tsuki Zombina
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 34

CONVEX HULLS

PETR FELKEL
FEL CTU PRAGUE
[email protected]
https://cw.felk.cvut.cz/doku.php/courses/a4m39vg/start

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

www.cguu.com

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 = a.succ // move CCW
5. while( ab is not the upper tangent for HR) b = b.pred // move CW
6. Return ab

Where: (ab is not the upper tangent for HL) => orient(a, b, a.succ)  0
which means a.succ 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, http://www.cs.uu.nl/geobook/
 [Mount] David Mount, - CMSC 754: Computational Geometry, Lecture
Notes for Spring 2007, University of Maryland, Lectures 3 and 4.
http://www.cs.umd.edu/class/spring2007/cmsc754/lectures.shtml
 [Chan] Timothy M. Chan. Optimal output-sensitive convex hull
algorithms in two and three dimensions., Discrete and Computational
Geometry, 16, 1996, 361-368.
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.44.389

Felkel: Computational geometry


(38)

You might also like