1. CS16: Introduction to Data Structures & Algorithms
Thursday March 12, 2015
Convex Hull
CS16: Introduction to Data Structures & Algorithms

2. Outline Overview Convex Hull Overview Graham Scan Algorithm
Thursday March 12, 2015
Outline
Overview
Convex Hull Overview
Graham Scan Algorithm
Incremental Algorithm

3. Thursday March 12, 2015
Convex Hull
The convex hull of a set of points is the smallest convex polygon containing the points
A convex polygon is a nonintersecting polygon whose internal angles are all convex (i.e., less than 180 degrees)
In a convex polygon, a segment joining any two lies entirely inside the polygon
segment not contained!
convex
nonconvex

4. Convex Hull (2) Think of a rubber band snapping around the points
Thursday March 12, 2015
Convex Hull (2)
Think of a rubber band snapping around the points
Remember to think of special cases
Colinearity: A point that lies on a segment of the convex is not included in the convex hull

5. Applications Motion planning
Thursday March 12, 2015
Applications
Motion planning
Find an optimal route that avoids obstacles for a robot
Bounding Box
Obtain a closer bounding box in computer graphics
Pattern Matching
Compare two objects using their convex hulls
obstacle
start
end

6. Thursday March 12, 2015
Finding a Convex Hull
One algorithm for determining a convex polygon is one which, when following the points in counterclockwise order, always produces left-turns

7. Calculating Orientation
Thursday March 12, 2015
Calculating Orientation a b c
The orientation of three points (a, b, c) in the plane is clockwise, counterclockwise, or collinear
Clockwise (CW): right turn
Counterclockwise (CCW): left turn
Collinear (COLL): no turn
The orientation of three points is characterized by the sign of the determinant Δ(a, b, c) CW c b
CCW a c b a
COLL
function isLeftTurn(a, b, c):
return (b.x - a.x)*(c.y - a.y)–
(b.y - a.y)*(c.x - a.x) > 0

8. Calculating Orientation (2)
Thursday March 12, 2015
Calculating Orientation (2)
Using the isLeftTurn() method:
(0.5-0) * ( ) - (1-0) * (1-0) = (CW)
(1-0) * (1-0) - (0.5-0) * (0.5-0) = 0.75 (CCW)
(1-0) * (2-0) - (1-0) * (2-0) = 0 (COLL)
a (0,0)
b (0.5,1)
c (1, 0.5) CW
c (0.5,1)
b (1, 0.5)
CCW
a (0,0)
c(2,2)
b(1,1)
a(0,0)
COLL

9. Calculating Orientation (3)
Thursday March 12, 2015
Calculating Orientation (3)
Let a, b, c be three consecutive vertices of a polygon, in counterclockwise order
b’ is not included in the hull if a’, b,’ c’ is non-convex, i.e. orientation(a’, b’, c’) = CW or COLL
b is included in the hull if a, b, c is convex, i.e. orientation(a, b, c) = CCW, and all other non-hull points have been removed c’ c b’ a’ b a

10. Thursday March 12, 2015
Graham Scan Algorithm
Find the anchor point (the point with the smallest y value)
Sort points in CCW order around the anchor
You can sort points by comparing the angle between the anchor and the point you’re looking at (the smaller the angle, the closer the point) 4 7 5 6 3 8 2
Anchor 1

11. Thursday March 12, 2015
Graham Scan Algorithm
The polygon is traversed in sorted order and a sequence H of vertices in the hull is maintained
For each point a, add a to H
While the last turn is a right turn, remove the second to last point from H
In the image below, p, q, r forms a right turn, and thus q is removed from H. Similarly, o, p, r forms a right turn, and thus p is removed from H. p q r H o p r H n o r H

12. Graham Scan: Pseudocode
Thursday March 12, 2015
Graham Scan: Pseudocode
function graham_scan(pts):
// Input: Set of points pts
// Output: Hull of points
find anchor point
sort other points in CCW order around anchor
hull = []
for p in pts:
add p to hull
while last turn is a “right turn”
remove 2nd to last point
add anchor to hull
return hull
Work on a diagram on the board B D
C A P
Hull:
A few more pieces
“sort in counter-clockwise order”
X coordinate of normalized vector from P to any Q works for the sort
it is the cos of angle with x axis (Side adjacent over hypotenuse (1))
V = (A – P) / | A-P |
Sort according to V.x
Right or left turn:
Given points A B C
take cross product of BA and BC
answer is perpendicular to plane
and follows right/left hand rule for in vs. out of plane
so size of the z coordinate
Sign of (Ax-Bx)(Cy-By) – (Ay-By)(Cx-Bx) gives turn direction
if positive, left turn
if negative, right turn
(or maybe vice versa; depends on handedness of coordinate system)
Complexity
O(n)
O(n log n)
Loop: O(n)
while: O(1) times amortized, since max n points can be removed
Note: this is very high-level pseudocode. There are many special cases to consider!

13. Overall run time: O(nlogn)
Thursday March 12, 2015
Graham Scan: Run Time
function graham_scan(pts):
// Input: Set of points pts
// Output: Hull of points
find anchor point // O(n)
sort other points in CCW order around anchor // O(nlogn)
create hull (empty list representing ordered points)
for p in pts: // O(n)
add p to hull
while last turn is a “right turn” // O(1) amortized
remove 2nd to last point
add anchor to hull
return hull
Overall run time: O(nlogn)

14. Incremental Algorithm
Thursday March 12, 2015
Incremental Algorithm
What if we already have a convex hull, and we just want to add one point q?
This is what you’ll be doing on the Java project after heap!
Get the angle from the anchor to q and find points p and r, the hull points on either side of q
If p, q, r forms a left turn, add q to the hull
Check if adding q creates a concave shape
If you have right turns on either side of q, remove vertices until the shape becomes convex
This is done in the same way as the static Graham Scan

15. Incremental Algorithm
Thursday March 12, 2015
Incremental Algorithm
Original Hull:
Want to add point q:
Find p and r: q H q H H p r
p, q, r forms a left turn, so add q:
o, p, q forms a right turn, so remove p
n, o, q forms a right turn, so remove o p r q H r q H o n r q H n n o s s s

16. Incremental Algorithm
Thursday March 12, 2015
Incremental Algorithm
Since m, n, q is a left turn, we’re done with that side.
Now we look at the other side:
Since q, r, s is a left turn, we’re done! r q H q H r q H n m s s
Remember that you can have right turns on either or both sides, so make sure to check in both directions and remove concave points!

17. Thursday March 12, 2015
Incremental Analysis
Let n be the current size of the convex hull, stored in a binary search tree for efficiency
How are they sorted? Around the anchor
To check if a point q should be in the hull, we insert it into the tree and get its neighbors (p and r on the prior slides) in O(log n) time
We then traverse the ring, possibly deleting d points from the convex hull in O((1 + d) log n) time
Therefore, incremental insertion is O(d log n) where d is the number of points removed by the insertion