UMass Lowell Computer Science
Prof. Karen Daniels
Computational Geometry
Overview from Cormen, et al.
Chapter 33
Overview

Line Segment Intersection

Convex Hull Algorithms

Nearest Neighbors/Closest Points
Line Segment Intersections
(2D)
Intersection of 2 Line Segments
Intersection of > 2Line Segments
Cross-Product-Based
Geometric Primitives
Some fundamental geometric questions:
source: 91.503 textbook Cormen et al.
p3
p2
p3
(1)
p4
p2
p1
p0
p2
p1
p1
(2)
(3)
Cross-Product-Based
Geometric Primitives: (1)
p2
33.1
p1
p0
 x1
p1  p2  det 
 y1
x2 
  x1 y2  x2 y1
y2 
Advantage: less sensitive to accumulated round-off error
(1)
source: 91.503 textbook Cormen et al.
Cross-Product-Based
Geometric Primitives: (2)
p2
p1
33.2
p0
(2)
source: 91.503 textbook Cormen et al.
Intersection of 2 Line Segments
Step 1:
Bounding Box
Test
p3
p3 and p4 on opposite sides of p1p2
p2
p4
p1
(3)
Step 2: Does each
segment straddle
the line containing
the other?
33.3
source: 91.503 textbook Cormen et al.
Segment-Segment Intersection


Finding the actual intersection point
Approach: parametric vs. slope/intercept
 parametric generalizes to more complex intersections


Lcd
e.g. segment/triangle
Parameterize each segment
Lcd
c
C=d-c
Lab
c
b
a
Lab
b
q(t)=c+tC
A=b-a
d
d
a
p(s)=a+sA
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
Demo
Segment/Segment Intersection
http://cs.smith.edu/~orourke/books/CompGeom/CompGeom.html
Intersection of >2 Line Segments
Sweep-Line Algorithmic Paradigm:
33.4
source: 91.503 textbook Cormen et al.
Intersection of >2 Line Segments
Sweep-Line Algorithmic Paradigm:
source: 91.503 textbook Cormen et al.
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:
91.503
textbook
Cormenet
et al.
al.
source:
91.503
textbook
Cormen
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
Convex Hull Algorithms
Definitions
Gift Wrapping
Graham Scan
QuickHull
Incremental
Divide-and-Conquer
Lower Bound in W(nlgn)
Convexity & Convex Hulls
source: O’Rourke, Computational Geometry in C

A convex combination of points
x1, ..., xk is a sum of the form
a1x1+...+ akxk where
a i  0 i and a1    a k  1

Convex hull of a set of points is the
set of all convex combinations of
points in the set.
source: 91.503 textbook Cormen et al.
nonconvex polygon
convex hull of a point set
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
Algorithms: 2D Gift Wrapping

Use one extreme edge as an
anchor for finding the next
q
Algorithm: GIFT WRAPPING
i0
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
Gift Wrapping
source: 91.503 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.
Algorithms: 3D Gift Wrapping
O(n2) time
[output sensitive: O(nF) for F faces on hull]
CxHull Animations: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
Algorithms: 2D QuickHull


Concentrate on points close to
hull boundary
Named for similarity to
Quicksort
a
b
A
c
finds one of upper or lower hull
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)
O(n2)
source: O’Rourke, Computational Geometry in C
Algorithms: 3D QuickHull
CxHull Animations: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
Algorithms: >= 2D
Convex Hull
boundary is
intersection of
hyperplanes, so
worst-case
combinatorial size
(not necessarily running
time)
in:
Qhull: http://www.qhull.org/
complexity is
(n
d / 2 
)
Graham’s Algorithm
source: O’Rourke, Computational Geometry in C


Points sorted angularly provide
“star-shaped” starting point
Prevent “dents” as you go via
convexity testing
q
p0
Algorithm: GRAHAM SCAN
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
2
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”
O(nlgn)
Graham Scan
source: 91.503 textbook Cormen et al.
Graham Scan
33.7
source: 91.503 textbook Cormen et al.
Graham Scan
33.7
source: 91.503 textbook Cormen et al.
Graham Scan
source: 91.503 textbook Cormen et al.
Graham Scan
source: 91.503 textbook Cormen et al.
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 H2
ConvexHull{p0 , p1 , p2 }
for k
3 to n - 1 do
Hk
ConvexHull{ Hk-1 U pk }
O(n2)
can be improved to O(nlgn)
Algorithms: 3D Incremental
O(n2) time
CxHull Animations: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
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”
B
A
Idea can be extended to 3D.
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)
Algorithms:
3D Divide and Conquer
O(n log n) time !
CxHull Animations: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
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
Nearest Neighbor/
Closest Pair of Points
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: 91.503 textbook Cormen et al.
Closest Pair
Correctness
33.11
source: 91.503 textbook Cormen et al.
Closest Pair
Running Time: T (n)  2T (n / 2)  O(n)


O(1)
if n  3
  O(n lg n)
if n  3
Key Point: Presort points, then at each step form
sorted subset of sorted array in linear time
Like opposite of MERGE step in MERGESORT…
L
R
source: 91.503 textbook Cormen et al.