15-211Fundamental Data Structures and Algorithms

Klaus Sutner

April 22, 2004

Computational Geometry

Announcements

HW7 the clock is ticking ...

Quiz 3: Today, after class

Final Exam on Tuesday May 4, 5:30 pmreview session April 29

The Basics

Computational Geometry

Lots of applications.

- computer graphics

- CAD/CAM

- motion planning

Could be done in dimension D, but we will stick to D=2.

D=3 is already much harder.

Airplane wing triangulation

The Basics

What are the basic objects in plane geometry, how do we represent them as data structures?

- point two floats

- line two points

- ray two points, constraints

- line segment two points, constraints

and triangles, rectangles, polygons, ...

Never mind curves such as circles and ellipses.

Disclaimer

There are two annoying issues one has to confront in CompGeo algorithms.

- Degenerate Cases

Points are collinear, lines parallel, …

Dealing with degeneracy is a huge pain, not to mention boring.

- Floating point numbers are not reals. Floating point arithmetic introduces errors and hence leads to accuracy problems.

High Precision Arithmetic

If 32 or 64 bits are not enough, use 128, or 512, or 1024, or …

Problems:

We have to be able to analyze how many bits are required.

Slows down computation significantly.

See GNU gmp.

Interval Arithmetic

Replace “real number” x by an interval

xL x xU

Problems:

Arithmetic becomes quite a bit more complicated.

Slows down computation significantly.

Symbolic Computation

Use (arbitrary precision) rationals and whatever algebraic operations that are necessary symbolically: compute with the formal expressions, not their numerical values.

Sqrt[2]

Problems:

Manipulating these expressions is complicated.

Slows down computation significantly.

Warm-Up

Let's figure out how to check if a point P lies on a line L.

P = (p1,p2)

L = (A,B) two-points representation

Need

P = A + (B - A)

where is a real parameter.

A

B

P

P

Linear Equations

The vector equation

P = A + (B – A) = (1- ) A + B

is just short-hand for two linear equations:

p1 = a1 + (b1 – a1) p2 = a2 + (b2 – a2)

Will have a common solution if P lies on L.

Subroutines

Solving systems of equations such as

p1 = a1 + (b1 – a1) p2 = a2 + (b2 – a2)

is best left to specialized software: send all linear equation subproblems to an equation solver - that will presumably handle all the tricky cases properly and will produce reasonable accuracy.

Rays and Line Segments

What if L =[A,B) is the ray from A through B?

No problem. Now we need

P = A + (B - A)

where is a non-negative real.

Likewise, if L = [A,B] is the line segment from A to B we need

0 1.

Both and (1 – ) must be non-negative.

Intersections

How do we check if two lines intersect?

A + (B - A) = C + (D – C)

Two linear equations, two unknowns ,

Add constraints for intersection of rays, line segments.

A

D

CB

General Placement

Here is a slightly harder problem:

Which side of L is the point P on?

A

B

right

lefton

P

P

P

Left/Right Turns

March from A to B, then perform a left/right turn.

A

B

right

lefton

Calculus: Cross Product

The cross product of two (3-D) vectors is another vector perpendicular to the given ones

Z = X Y

Length and direction of Z express the signed area of the parallelogram spanned by the vectors.

antisymmetric:

X Y = - Y X

Cross Product

Simple expression for cross product:

(x1,x2,x3) (y1,y2,y3) = (-x3y2 + x2 y3, x3 y1 - x1y3, -x2y1 + x1y2 )

Compute

w = (b1-a1,b2-a2,0) (p1-a1,p2-a2) = (0,0,-a2 b1+a1 b2+a2 p1-b2 p1-a1 p2+b1 p2 )

P is to the right of ray A to B iff w[3] > 0.

Determinants

Alternatively one can compute the determinant of the matrix

a1 a2 1b1 b2 1p1 p2 1

This may be a better solution since presumably the determinant subroutine presumably deals better with numerical problems.

Some Applications

Membership

How do we check if a point X belongs to some region R in the plane (triangle, rectangle, polygon, ... ).

XR

X

R X

X

Membership

Clearly the difficulty of a membership query depends a lot on the complexity of the region. For some regions it is not even clear that there is an inside and an outside.

Simple Polgyons

A polygon is simple if its lines do not intersect except at the vertices of the polygon (and then only two).By the Jordan curve theorem any simple polygon partions the plane into inside and outside.

Point Membership

The proof of the JCT provides a membership test. Let P be a simple polygon and X a point. Draw a line through X and count the intersections of that line with the edges of P.

Odd One can show that X lies inside of P iff the number of intersections (on either side) is odd.

Note that there are bothersome degenerate cases:X lies on an edge, an edge lies on the line through X.Maybe wiggle the line a little.

Algorithm

Theorem: One can test in linear time whether a point lies inside a simple polygon.

Linear here refers to the number of edges of the polygon.

And, of course, we assume that these edges are given as a list of points, say, in counterclockwise order.

Convexity

Here is one type of simple region.

A region R in the plane is convex if for all A, B in R: the line segment [A,B] is a subset of R.

In particular convex polygons: boundary straight line segments.

Membership in Convex Polygon

Traverse the boundary of the convex polygon in counterclockwise order, check that the point in question is always to the left of the corresponding line.

This is clearly linear in the number of boundary points.

Intersections of LSs

Suppose we are given a collection of LSs and want to compute all the intersections between them.

Note that the number of intersections may be quadratic in the number n of LSs.

The brute force algorithms is (n2): consider all pairs of LSs and check each pair for intersection.

Bad if there are only a few intersections.

Sweep-Line

Suppose there are s intersections. We would like an algorithm with running time O( (n+s) ??? ) where ??? is hopefully small.

The key idea is to use a sweep-line: moves from left to right. At each point, maintain the intersection of the sweep line and the given LSs.

Variant

It helps to think about the following easier problem first: check if there is at least one intersection between the given LSs.

Brute force is still quadratic.

Note how the SL needs to consider only immediate neighbors.

Again

The sweep line needs to consider only immediate neighbors.

s

r

t

SL Operations

The SL has to keep track of all the LSs that currently intersect it. So we need operations

insert(s)delete(s)

where s is a given LS.

The “time” when the segments are inserted/deleted are given by the endpoints of the input LSs.

(Static events, preprocess by sorting.)

Dealing With Intersections

When a new LS is entered, we have to check if it interacts with any of the neighboring LSs. So we need additional operations

above(s)below(s)

which return the immediate neighborsabove/below on the SL.

And we need to stop the sweep at anyintersections found that way.

Dynamic events, no known ahead of time.

Data Structures

What is the right data structure for all of this?

Sweep line: dictionary Perhaps threaded to get O(1) above/below operations.

Event structure: priority queue.

Theorem: Can compute all s intersections of n line segments in O((n + s) log n) steps.

Testing Simplicity

How do we check if a polygon is simple?

Use the line segment intersection algorithm on the edges.

Polgyon Intersection

How do we check if two simple polygon intersect?

Note: two cases!

Polgyon Intersection

The first case can be handled with LS intersection testing.

For the second, pick any vertex in P and check wether it lies in (the interior of) Q.

Total running time: O(n log n).

Convex Hulls

A Hull Operation

Suppose P is a set of points in the plane. The convex hull of P is the least set of points Q such that:

- P is a subset of Q,- Q is convex.

Written CH(P).

This pattern should look very familiar by now

(reachability in graphs, equivalence relations, ...)

Convex Combinations

Abstractly it is easy to describe CH(P): is the set of all points

X = i Pi

where 0 i and i = 1.

X is a convex combination of the Pi .

So the convex combinations of A and B are the line segment [A,B].

And the convex combinations of three points (in general position) form a triangle. And so on.

So?

Geometrically this is nice, but computationally this characterization of the convex hull is not too useful.

We want an algorithm that takes as input a simple polygon P and returns as output the simple polygon CH(P).

PCH(P)

Extremal Points

Point X in region R is extremal iff X is not a convex combination of other points in R.

For a polygon, the extremal points make up the CH.

An Observation

So let's deal with a set of points P rather than regions.

Lemma: Point X in P is not extremal iff X lies in the interior of a triangle spanned by three other points in P.

An Algorithm

Hence we can find the convex hull of a simple polygon: for all n points we eliminate non-extremal points by trying all possible triangles using the membership test for convex polygons.

In the end we sort the remaining extremal points in counterclockwise order.

Unfortunately, this is O(n4).

Could it be faster? When do we get n4?

Next Time

Clearly, O(n4) is way too slow to be of any practical use.

Next time we will see a number of simple algorithms that push this down to O(n log n). This turns out to be optimal: sorting can be reduced to convex hull.

Note, though, that in dimension 3 and higher things get much more messy.