1. Computational Geometry Overview from Cormen, et al. Chapter 33
UMass Lowell Computer Science Advanced Algorithms Computational Geometry Prof. Karen Daniels Spring, 2005
Computational Geometry
Overview from Cormen, et al.
Chapter 33

2. Overview Computational Geometry Introduction Line Segment Intersection
Convex Hull Algorithms
Nearest Neighbors/Closest Points

3. Line Segment Intersections (2D)
Intersection of 2 Line Segments
Intersection of > 2Line Segments

4. Cross-Product-Based Geometric Primitives
Some fundamental geometric questions:
source: textbook Cormen et al. p0 p2 p1 p1 p3 p2
(2) p2 p1 p3 p4
(3)
(1)

5. Cross-Product-Based Geometric Primitives: (1)
33.1
Advantage: less sensitive to accumulated round-off error
source: textbook Cormen et al.

6. Cross-Product-Based Geometric Primitives: (2)
33.2
source: textbook Cormen et al.

7. Intersection of 2 Line Segments
Step 1: Bounding Box Test
p3 and p4 on opposite sides of p1p2 p2 p1 p3 p4
(3)
Step 2: Does each segment straddle the line containing the other?
33.3
source: textbook Cormen et al.

8. Segment-Segment Intersection
Finding the actual intersection point
Approach: parametric vs. slope/intercept
parametric generalizes to more complex intersections
e.g. segment/triangle
Parameterize each segment a b c d
Lab
Lcd
A=b-a
p(s)=a+sA
q(t)=c+tC
C=d-c
Intersection: values of s, t such that p(s) =q(t) : a+sA=c+tC
2 equations in unknowns s, t : 1 for x, 1 for y
source: O’Rourke, Computational Geometry in C

9. Segment/Segment Intersection
Demo
Segment/Segment Intersection

10. Intersection of >2 Line Segments
Sweep-Line Algorithmic Paradigm:
33.4
source: textbook Cormen et al.

11. Intersection of >2 Line Segments
Sweep-Line Algorithmic Paradigm:
source: textbook Cormen et al.

12. Intersection of >2 Line Segments
Time to detect if any 2 segments intersect:O(n lg n)
Balanced BST stores segments in order of intersection with sweep line. Associated operations take O(lgn) time.
Note that it exits as soon as one intersection is detected.
33.5
source: textbook Cormen et al.
source: textbook Cormen et al.

13. Intersection of Segments
Goal: “Output-size sensitive” line segment intersection algorithm that actually computes all intersection points
Bentley-Ottmann plane sweep: O((n+k)log(n+k))= O((n+k)logn) time
k = number of intersection points in output
Intuition: sweep horizontal line downwards
just before intersection, 2 segments are adjacent in sweep-line intersection structure
check for intersection only adjacent segments
insert intersection event into sweep-line structure
event types:
top endpoint of a segment
bottom endpoint of a segment
intersection between 2 segments
swap order
Improved to O(nlogn+k) [Chazelle/Edelsbrunner]
source: O’Rourke, Computational Geometry in C

14. Convex Hull Algorithms
Definitions
Gift Wrapping
Graham Scan
QuickHull
Incremental
Divide-and-Conquer
Lower Bound in W(nlgn)

15. Convexity & Convex Hulls
source: O’Rourke, Computational Geometry in C
A convex combination of points x1, ..., xk is a sum of the form a1x akxk where
Convex hull of a set of points is the set of all convex combinations of points in the set.
nonconvex polygon
convex hull of a point set
source: textbook Cormen et al.

16. Naive Algorithms for Extreme Points
Algorithm: INTERIOR POINTS
for each i do
for each j = i do
for each k = j = i do
for each L = k = j = i do
if pL in triangle(pi, pj, pk)
then pL is nonextreme
O(n4)
Algorithm: EXTREME EDGES
for each i do
for each j = i do
for each k = j = i do
if pk is not left or on (pi, pj)
then (pi , pj) is not extreme
O(n3)
source: O’Rourke, Computational Geometry in C

17. Algorithms: 2D Gift Wrappingq
Use one extreme edge as an anchor for finding the next
Algorithm: GIFT WRAPPING
i index of the lowest point
i i0
repeat
for each j = i
Compute counterclockwise angle q from previous hull edge
k index of point with smallest q
Output (pi , pk) as a hull edge
i k
until i = i0
O(n2)
source: O’Rourke, Computational Geometry in C

18. Gift Wrapping
source: textbook Cormen et al.
33.9
Output Sensitivity: O(n2) run-time is actually O(nh) where h is the number of vertices of the convex hull.

19. Algorithms: 3D Gift Wrapping
O(n2) time
[output sensitive: O(nF) for F faces on hull]
CxHull Animations:

20. Algorithms: 2D QuickHull
Concentrate on points close to hull boundary
Named for similarity to Quicksort a b A c
O(n2)
Algorithm: QUICK HULL
function QuickHull(a,b,S)
if S = 0 return()
else
c index of point with max distance from ab
A points strictly right of (a,c)
B points strictly right of (c,b)
return QuickHull(a,c,A) + (c) + QuickHull(c,b,B)
finds one of upper or lower hull
source: O’Rourke, Computational Geometry in C

21. Algorithms: 3D QuickHull
CxHull Animations:

22. Algorithms: >= 2D
Convex Hull boundary is intersection of hyperplanes, so worst-case combinatorial size (not necessarily running time) complexity is in:
Qhull:

23. Graham’s Algorithm
source: O’Rourke, Computational Geometry in C q
Points sorted angularly provide “star-shaped” starting point
Prevent “dents” as you go via convexity testing p0
O(nlgn)
Algorithm: GRAHAM SCAN, Version B
Find rightmost lowest point; label it p0.
Sort all other points angularly about p0.
In case of tie, delete point(s) closer to p0.
Stack S (p1, p0) = (pt, pt-1); t indexes top i
while i < n do
if pi is strictly left of pt-1pt
then Push(pi, S) and set i i +1
else Pop(S)
“multipop”

24. Graham Scan
source: textbook Cormen et al.

25. Graham Scan
33.7
source: textbook Cormen et al.

26. Graham Scan
33.7
source: textbook Cormen et al.

27. Graham Scan
source: textbook Cormen et al.

28. Graham Scan
source: textbook Cormen et al.

29. Algorithms: 2D Incremental
source: O’Rourke, Computational Geometry in C
Add points, one at a time
update hull for each new point
Key step becomes adding a single point to an existing hull.
Find 2 tangents
Results of 2 consecutive LEFT tests differ
Idea can be extended to 3D.
Algorithm: INCREMENTAL ALGORITHM
Let H ConvexHull{p0 , p1 , p2 }
for k to n - 1 do
Hk ConvexHull{ Hk-1 U pk }
O(n2)
can be improved to O(nlgn)

30. Algorithms: 3D Incremental
O(n2) time
CxHull Animations:

31. Algorithms: 2D Divide-and-Conquer
source: O’Rourke, Computational Geometry in C
Divide-and-Conquer in a geometric setting
O(n) merge step is the challenge
Find upper and lower tangents
Lower tangent: find rightmost pt of A & leftmost pt of B; then “walk it downwards”
Idea can be extended to 3D. B A
Algorithm: DIVIDE-and-CONQUER
Sort points by x coordinate
Divide points into 2 sets A and B:
A contains left n/2 points
B contains right n/2 points
Compute ConvexHull(A) and ConvexHull(B) recursively
Merge ConvexHull(A) and ConvexHull(B)
O(nlgn)

32. Algorithms: 3D Divide and Conquer
O(n log n) time !
CxHull Animations:

33. Lower Bound of O(nlgn)
source: O’Rourke, Computational Geometry in C
Worst-case time to find convex hull of n points in algebraic decision tree model is in W(nlgn)
Proof uses sorting reduction:
Given unsorted list of n numbers: (x1,x2 ,…, xn)
Form unsorted set of points: (xi, xi2) for each xi
Convex hull of points produces sorted list!
Parabola: every point is on convex hull
Reduction is O(n) (which is in o(nlgn))
Finding convex hull of n points is therefore at least as hard as sorting n points, so worst-case time is in W(nlgn)
Parabola for sorting 2,1,3

34. Nearest Neighbor/ Closest Pair of Points

35. Closest Pair
Goal: Given n (2D) points in a set Q, find the closest pair under the Euclidean metric in O(n lgn) time.
Divide-and-Conquer Strategy:
X = points sorted by increasing x
Y = points sorted by increasing y
Divide: partition with vertical line L into PL, PR
Conquer: recursively find closest pair in PL, PR
dL, dR are closest-pair distances
d = min( dL, dR )
Combine: closest-pair is either d or pair straddles partition line L
Check for pair straddling partition line L
both points must be within d of L
create array Y’ = Y with only points in 2d strip
for each point p in Y’
find (<= 7) points in Y’ within d of p
source: textbook Cormen et al.

36. Closest Pair
Correctness
33.11
source: textbook Cormen et al.

37. Closest Pair Running Time:
Key Point: Presort points, then at each step form sorted subset of sorted array in linear time
Like opposite of MERGE step in MERGESORT…
source: textbook Cormen et al. R L