O'Rourke Chapter 7: Search & Intersection in PDF - Computer Science

UMass Lowell Computer Science 91.504
Advanced Algorithms
Computational Geometry
Prof. Karen Daniels
Fall, 2012
O’Rourke Chapter 7
Search & Intersection

Chapter 7
Search & Intersection
Segment-Segment Intersection
Segment-Triangle Intersection
Point in Polygon
Point in Polyhedron
Intersection of Convex Polygons
Intersection of Segments
Intersection of Nonconvex Polygons
Extreme Point of Convex Polygon
Extremal Polytope Queries
Planar Point Location

Segment-Segment Intersection
• Finding the actual intersection point
• Approach: parametric vs. slope/intercept
• parametric generalizes to more complex
intersectionsi
• Parameterize each segment
L cd
c
a
b
L ab
d
L cd
c
C=d-c
b
a
A=b-a
p(s)=a+sA
source: O’Rourke
L ab
q(t)=c+tC
d
Intersection: values of s, t such that p(s) =q(t)
: a+sA=c+tC

Segment-Triangle Intersection
• Determine if qr intersects plane π containing
triangle T.
source: O’Rourke
useful in ray tracing
• Let N=(A,B,C) be normal to π
r
π :(x,y,z) •(A,B,C)=D (i.e.π π = Ax + By + Cz = D)
π
c N
• Find normal N using cross-products involving a, b, c
p
T
• parameterize qr: p(t) = q + t(r-q)
a b
D − ( q • N)
• solve for t :
t
=
q
( r − q)
• N
• using t, find point of intersection p if it exists
• Classify relationship between p and T
• p is in T iff its projection p’ is in a projection* T’ of T
to xy, xz or yz-plane
+--
• Barycentric coordinates
“left edge” p’ +-+
• Check results of 3 of tests for with
++respect
to T’: +++ means p’ inside T’.
+++
-+- -++
--
* avoid degeneracy by projecting out largest coordinate
--+
T’

Point in Polygon
An application: GUI mouse click
• Winding number (see Guibas/Stolfi)
• standing at q, turn to follow border of P
• sum rotation to create signed angular turn + ccw
- cw
• divide by 2π
• elegant but not practical: O(n) with large constant
• Ray crossings
• extend horizontal ray from q
• count number of intersections with P
• even q is outside P
• odd q is inside P
• beware degenerate intersections!
Compare with using LeftOn test when polygon is convex
P
P
O(n)
q
q
source: O’Rourke

• Winding number
generalizes to 3D
Point in Polyhedron
• uses solid angle
(fraction of sphere surface
used by cone at point)
• Ray crossing
generalizes to 3D
• q inside P if odd
number of
crossings
• q outside P if even
number of
crossings
Running Time
(see next slide)
P
q
r
Assume each face is a triangle.
Algorithm: : POINT in POLYHEDRON (P, R, q)
Compute bounding radius R
loop forever
r 0 = random ray of length R
r=q+r
r 0
crossings = 0
for each triangle T of polyhedron P do
SegTriInt(T, q, r)
if degenerate intersection
then go back to loop
else increment crossings appropriately
if crossings odd
then q is inside P
else q is outside P
Exit
source: O’Rourke

Point in Polyhedron
source: O’Rourke
P
q
r
Expected time O(ρn)
ρ = expected number of tries to get
nondegenerate intersection
• Experiment: One combinatorially dense sample
polyhedron has ρ ~ 1.01.
• Claim: ρ = 1 + ε can be achieved for any ε > 0!
• For analysis, replace sphere with bounding cube.
• In worst case, L integer points on cube face
“disqualified” by each edge of polyhedron.
• Probability of hitting a degeneracy =
• Let E = #edges
• (E x L) out of L 2 disqualified = E/L
• E is a constant, so choosing L large enough
yields any desired ε = E/L.
Assume each face is a triangle.
Imagine integer discretization of L.
Edge e “kills” a line of points on face of
surrounding cube.

Intersection of Convex Polygons
• For nonconvex n-vertex P and m-vertex
Q, the worst-case size complexity of
P ∩ Q
is in Ω(nm)
• For convex P, Q, size is only in
O ( n + m) )
and can be computed in O ( n + m) time
source: O’Rourke
B
A
(example)
Q
P
Algorithm: : INTERSECTION of CONVEX POLYGONS
Choose A and B arbitrarily
/* A is directed edge on P */
repeat
/* B is directed edge on Q */
if A intersects B then /* A, B “chase” each other */
/* A, B meet at each */
Check for termination
/* boundary crossing */
Update inside flag
Advance either A or B
depending on geometric conditions (see next slide)
until both A and B cycle their polygons
Handle cases: P ⊂ Q P ⊃ Q P ∩ Q = 0/
O(n+m)

Intersection of Convex Polygons
source: O’Rourke
If B “aims towards” line containing A but does not cross it then
If B aims towards line containing A, but does not cross it, then
advance B to “close in” on possible intersection with A.

Intersection of Segments
• Goal: “Output-size sensitive”
polygon intersection algorithm
• Core Problem: “Output-size
sensitive” line segment intersection
algorithm
• Bentley-Ottmann plane sweep:
O((n+k)logn) time
• k = number of intersection points in
output
• Intuition: sweep line (discrete event
ent
simulation)
• First, review algorithm that returns
TRUE iff there exists an intersection

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 decide if any 2
segments intersect:
segments intersect:O(n lg n)
Balanced BST stores segments in order
of intersection with sweep line.
Associated operations take O(lgn) time.
(See next slide.)
Note that it exits as soon as one intersection is detected.
33.5
source: source: 91.503 91.503 textbook Cormen et al.

Intersection of >2 Line Segments
Balanced BST stores segments in order of intersection with sweep line.
Associated operations take O(lgn) time.
Each segment has a leaf node.
At each internal node, store
segment from rightmost leaf in its
left subtree.
What does this allow us to do
source: deBerg et al.

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 vertical line rightwards
• 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:
(example on previous slide)
• left endpoint of a segment
• right endpoint of a segment
• intersection between 2 segments
• swap order
Improved to O(nlogn+k) [Chazelle/Edelsbrunner]
l source: O’Rourke, Computational Geometry in C

Intersection of Nonconvex Polygons
• Variation on Bentley-
Ottmann sweep
• Maintain status for
each piece of sweep
line:
• 0: exterior to P, Q
• P: inside P, outside Q
• Q: inside Q, outside P
• PQ: inside P , inside Q
• Useful for CAD/CAM
P
source: O’Rourke
Q
For n-vertex
P, , m-vertex
Q, , O((n+m
n+m)log( )log(n+m)+k) time to compute:
P ∩ Q
P ∪ Q
P \ Q

Extreme Point of Convex Polygon
Algorithm: HIGHEST POINT of CONVEX POLYGON
Initialize a and b
/* highest h point is in [a,b] */
repeat forever
c index midway from a to b
if P[c] is locally highest then return c
if A points up and C points down
then [a,b] [a,c]
/* highest point is in [a,c] */
else if A points down and C points up
then [a,b] [c,b]
/* highest point is in [c,b] */
else if A points up and C points up
if P[a] is above P[c]
then [a,b] [a,c]
else [a,b] [c,b]
/* highest point is in [c,b] */
else if A points down and C points down
if P[a] is below P[c]
then [a,b] [a,c]
/* highest point is in [a,c] */
else [a,b] [c,b]
/* highest point is in [c,b] */
source: O’Rourke
I iti li d b A Geometric
Binary Search
C
c
b
A
Unimodality
allows
B
Binary Search
O(lg n)
a

Stabbing a Convex Polygon
source: O’Rourke
Extreme-Finding algorithm can stab a convex polygon
extreme in + u direction
a
+u
y
L
x
b
extreme in - u direction
If a and b straddle L,
binary search on [a,b] yields x
binary search on [b,a] yields y
O(lg n)

Extremal Polytope Queries:
Main Idea
source: O’Rourke
• Form sequence of O(log n) simpler nested
polytopes in O(n) time (see next slide)
• To answer a (w.l.o.g.. vertical) query in
O(logn
logn) time: (see slide after next)
• Find extreme with respect to inner polytope,
then work outwards
• Need only check small number of candidate
vertices in next polytope
• Key idea:
• independent sets in planar graphs are
“large”; vertices of “low” degree
• to construct next (inner) polytope, remove
independent set of vertices
• deleting constant fraction of vertices at each
step produces O(logn
logn) polytopes lt (derivation
derivation)
O(log n)
An independent set of a polytope graph of n vertices
produced by INDEPENDENT SET has size at least n/18 (to be shown later).

Extremal Polytope Queries:
Main Idea (continued)
source: O’Rourke

Extremal Polytope Queries:
Main Idea (continued)
source: O’Rourke
For maximal z query:
Moving from P i+1 to P i
is like raising a plane
orthogonal to z axis
from a i+1 1(
(highest
point on P i+1 ) to
a i …a 0

Extremal Polytope Queries
Details
source: O’Rourke
Maximum Independent Set is NP-complete,
but greedy heuristic performs well.
Choose vertex of lowest degree, not
adjacent to vertices already chosen.
Algorithm 7.4: : INDEPENDENT SET
Input: : graph G
Output: : independent set I
I 0
Mark all nodes of G of degree >= 9
while some nodes remain unmarked
do
Choose an unmarked node v
Mark v and all neighbors of v
I I U {v}
spurious
edge
Goal: tetrahedron
triangulate
polytope: lt use convex hll hull
(d) octahedron
(a) Icosahedron
Schlegel
diagram: 5
triangles meet at
each vertex.
There exist at least n/2 vertices of degree
at most 8 (derivation
derivation).
An independent set of a polytope graph of n vertices
produced by INDEPENDENT SET has size at least n/18 (derivation).

Extremal Polytope Queries
Details (continued)
source: O’Rourke
(creation)
i
← i +1
1
(creation)

Extremal Polytope Queries
Details (continued)
• To use nested polytope hierarchy to
answer an extreme point query:
• Find extreme with respect to inner
polytope P k (brute-force search)
• Move from polytope P i+1 to P i
• Let a i and a i+1 be uniquely highest h vertices of
P i and P i+1 . Then (Lemma 7.10.2) either:
• a i = a i+1 or
• a i+1 is the highest among the vertices adjacent to a i
(See proof sketch in next slide.)
source: O’Rourke
(Assume w.l.o.g. . vertical query direction)
π
(Plane effect )

Extremal Polytope Queries
Dtil Details (continued)
source: O’Rourke
• Lemma 7.10.2: (repeated) Let a i and a i+1 be uniquely highest vertices
of P i and P i+1 . Then either:
• a i = a i+1 or
• a i+1 is the highest among the vertices adjacent to a i
• Proof Sketch: (by cases)
• a i is vertex of both P i and P i+1
• a i = a i+1
• else a i deleted in construction of P i+1
• Let b i+1 = highest vertex of P i+1 among
those adjacent to a i in P i
• Claim: b i+1 is highest vertex of P i+1
• Proof uses polygonal-faced “cone”
• See book for further details
But we still need bound on #
vertices adjacent to a i+1 …

Extremal Polytope Queries
Dtil Details (continued)
source: O’Rourke
• Lemma7103:Leta 7.10.3: Let a i and a i+1 be uniquely highest vertices of P i and
P i+1 . Then either (to provide constant-time search):
• a i = a i+1 or
• a i is the highest among the parents of the extreme edges L i+1 and
R i+1
• Proof Sketch: π
• Project P i+1 onto plane orthogonal to π
(e.g. xz plane)
• Let L i+1 , R i+1 = 2 edges of P i+1 projecting to 2
edges of P’ i+1 incident to a’ i+1
• Parents of edge are vertices of P i from
L’
π’ i+1 = R’ i+1
which it “derives” (during P i+1 creation)
tetrahedron
• New extreme edges are “close” to the old.
projected
onto xz plane
• See p. 281-283 for remaining details. P’ i+1
tetrahedron

Extremal Polytope Queries
Summary
Algorithm: EXTREME POINT of a POLYTOPE
Input: polytope P and direction vector u
Output: vertex a of P extreme in u direction
Construct nested polytope p hierarchy P = P 0 0, , P 1 1, ,...,, P k
a k
vertex of P k extreme in u direction
Compute L k and R k
for i = k - 1, k - 2, ...,1, 0 do
a i extreme vertex among a i+1 and parents of L i+1 and R i+1
if a i = a i+1 then
i i 1
for all edges incident to a i do
source: O’Rourke
π
u
P k
P 0
save extreme edges L i and R i
else (a i = a i+1 ) compute L i from L i+1 etc...
After O(n) time and space preprocessing, a polytope
extreme-point query can be answered in O(log n) time

Planar Point Location
source: O’Rourke
• Goal: Given a planar subdivision of n
vertices, preprocess it so that point location
query can be quickly answered.
• A polygonal planar subdivision can be
preprocessed in O(n) time and space for
O(log n) query.
• 2D version/variant of independent set/nested
approach ( may need to triangulate polygonal faces)
• Monotone subdivision approach*
• Randomized dtrapezoidal decomposition*
i * See next slides.

Planar Point Location (continued)
• Monotone subdivision approach:
-Partition subdivision (e.g.
Voronoi diagram) into
“horizontal” strips.
-Double binary search:
-Vertical search on
strips to locate query
point between 2
separators
-Horizontal search to
locate it within 1 strip
-O(log
2 n) query time
source: O’Rourke

Planar Point Location (continued)
• And now for something completely different…
source: O’Rourke
• As foreshadowed in Ch. 2 (polygon partitioning/triangulation)
• Seidel’s randomized trapezoidal decomposition for non-crossing
segments:
* *
O(nlogn)
construction
Assume no 2 points are at same height.
time: extend
horizontal line
through each
endpoint.
O(logn)
query time.
* can build
binary tree

Planar Point Location (continued)
source: O’Rourke
• Lemma allows us to incrementally build binary search tree.
• 3 types of nodes:
1. internal X nodes, which branch left or right of a segment s i
2. internal Y nodes, which branch above or below a segment endpoint
3. Leaf trapezoid nodes.
Identify each trapezoid cut by s 1 .
B
C

Planar Point Location (continued)
source: O’Rourke

Planar Point Location (continued)
source: O’Rourke

Planar Point Location (continued)
source: O’Rourke
query point q
search path for
query point q