- 64 Views
- Uploaded on
- Presentation posted in: General

Computational Geometry Chapter 12

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Computational Geometry Chapter 12

employee

- age
- salary
- start date
- city address

- e.g. DatabaseDatabase Record
- Suppose you want to know all employees with Salary ∈ [40K, 50K]
Scan records & pick out those in range *slow*

employee

- age
- salary
- start date
- city address

- e.g. DatabaseDatabase Record
- Suppose you want to know all employees with Salary ∈ [40K, 50K] AND Age ∈ [25, 40]
Scan records & check each one *slow*

- Alternative to Scan: Each employee is a point in space
- age range[15, 75]
- salary range[0K, 500K]
- start date[1/1/1900, today]
- city/address[College Station, Bryan, Austin, …]

4D

- may just keep as data w/records
- could encode
- could use categories (of a row)

Orthogonal Range Query (Rectangular)

- Want all points in the orthogonal range
- Faster than linear scan if good data structures are used.
- Want time O( f(n)+k ) ; where k= # of points reported

Query #2 (age 25-40, salary 40K-50K)

age

…

45

35

25

15

…

0

50K

100K

150K

200K

salary

3 9 27 28 29 98 141 187 200 201 202 999

- Data:Points P={p1, p2, … pn} in 1-D space (set of real numbers)
- Query: Which points are in 1-D query rectangle (in interval [x, x’])
Data structure 1:Sorted Array

- A=
- Query:Search for x & x’ in A by binary searchO(logn)
Output all points between them. O(k)

TotalO(logn+k)

- Update: Hard to insert points. Add point p’, locate it n A by binary search. Shift elements in A to make room.O(n) on avarage
- Storage Cost:O(n)
- Construction Cost:O(nlogn)

- Update: hard to insert. Find point of insertion in log n (via binary search), but have to shift.
- Storage costs: O(n)
- Construction costs: - just sorting (n log n)

Data structure 2:Balanced Binary Search Tree

- Leaves store points in P (in order left to right)
- Internal nodes are splitting values. v.xused to guide search.
- Left sub tree of V contains all values ≤ v.x
- Right sub tree of V contains all values > v.x

- Query:[x, x’]
- Locate x & x’ in T (search ends at leaves u & u’)
- Points we want are located in leaves
- In between u & u’
- Possibly in u (if x=u.x)
- Possibly in u’ (if x’=u’.x)

Leaves of sub trees rooted at nodes V s.t. parent (v) is on search path root to u (or root to u’)

49

23

80

62

10

37

89

3

19

30

49

59

70

100

89

3

10

19

23

30

37

59

62

70

80

100

105

- Look for node Vsplit where search paths for x & x’ split
- Report all values in right sub tree on search path for x’
- Report all values in left sub tree on search path for x

- Query: [18:77]

49

23

80

62

10

37

89

3

19

30

49

59

70

100

89

3

10

19

23

30

37

59

62

70

80

100

105

- Update Cost O(logn)
- Storage Cost O(n)
- Construction Cost O(nlogn)

1-D Range Tree

Search path

u

u’

- Input: range tree rooted at v and x ≤ x’
- Output: all points in range [x, x’]
- if v is null return {}
- if (x < v.x < x’)
- L = 1DRangeQuery(x,x’,v.left)
- R = 1DRangeQuery(x,x’,v.right)
- return (L+v + R)
- if v.x < x return 1DRangeQuery(x,x’,v.right)
- return 1DRangeQuery(x,x’,v.left)

- Balanced Binary Search Tree
- O(n) storage
- O(n log n) construction time

- Query Time
- Time Spent – traversing root to μ + μ’ paths – O(log n) time
- Time spent in ReportSubtree
- Worst case theta Θ(n)Since may need to report all points if they fall in query range
- Finer analysis gives total time in ReportSubtree is proportional to number of nodes reported O(s) if report s node
Total Time – O(s + log n) when s is number of nodes reported

Tx

Ty(v)

T4

p6

p5

p4

p3

p1

p2

p7

Ty(v)

v

v

p7

p5

p6

p1

p2

p3

p4

p5

p6

p7

P(v)

P(v)

- For each internal node vTx let P(v) be set of points stored in leaves of subtree rooted at v.

Set P(v) is stored with v as another balanced binary search tree Ty(v) (second level tree) on y-coordinate. (have pointer from v to Ty(v))

Build 2D-Range Tree(P)

input: a set of P points in the plane

output: root of a 2D range tree

- Construct 2nd level tree Ty for P (store entire points at leaves)
- if (|P|=1)
- then create leaf v. Ty(v):= Ty
- else split P into Pleft and Pright parts of equal size by x coordinate around xmid
- vleft :=Build2D-RangeTree(Pleft)
- vright:=Build2D-RangeTree(Pright)
- createnew v such that xv:=xmid
Leftchild(v):=vleft

Righteftchild(v):=vleft

Ty(v):=Ty

8. return v

end /* Build2D-RangeTree */

Build 2D-Range Tree(P)

input: a set of P points in the plane, sorted by x

output: root of a 2D range tree, set of points sorted by y

- if (|P|=1)
- then create leaf v. Ty(v):= Ty
- else split P into Pleft and Pright parts of equal size by x coordinate around xmid
- (Vleft, Yleft):=Build2D-RangeTree(Pleft)
- (Vright, Yright):=Build2D-RangeTree(Pright)
- createnew v such that xv:=xmid
Leftchild(v):=vleftt

Righteftchild(v):=vrightt

Yall =merge(Yleft,Yright));

Ty(v):=buildTree(Yall)

7. return (v, Yall)

end /* Build2D-RangeTree */

- A 2D-range tree with n points uses O(nlogn) storage.
- Proof.
- Consider a point pP.
- p is stored in Ty(v) for every node vTx such that p is a leaf of the subtree of Tx rooted at v.
- There are O(logn) such subtrees those rooted on root of (Tx) to p path. (Tx has height O(logn))
- Each point stored O(logn) times.
- N points requires O(nlogn) storage in total.

- Naive implementation of step 1 takes O(n log n) time (unsorted points)
- But, if points already sorted by y-coordinate can build 1D binary search tree in (n) time (bottom up)
pre-sort points by x- and y- coordinates (two lists)

build trees bottom up and merge sorted lists

- construction of tree Ty takes (n’) time
(n’ = number points in Ty)

total construction time = O(n log n)

- first determine O(log n) sub-trees to search (those w/ x-coord in range, don’t visit kids of internal node)
- search each sub-tree Ty for points in y-coord range. both above steps use 1D search algorithm.
so alg identical to 1D Range Query (on x-coords) except replace calls to Report Subtree by 1D Range Query (on y-coords)

Lemma: A query w/ axis-parallel rectangle in range tree for n points takes O( log2 n+ k) time, where k = # reported points

if root == null return;

M=L=R= 0;

if x1 < root.x < x2{

if y1 < root.y <y2 M = root

if type = left

L = 2dRangeSearch(x1,x2,y1,y2,root.left,left)

R = 1dRangeSearch(y1,y2, root.right)

else if type = right

L = 1dRangeSearch(y1,y2,root.left)

R = 2dRangeSearch(x1,x2,y1,y2, root.right,right)

else L=2dRangeSearch(x1,x2,y1,y2,root.left, left)

R=2dRangeSearch(x1,x2,y1,y2,root.right, right)

}

else if root.x < x1 then R = 2dRangeSearch(x1,c2,y1,y2,root.right, type)

else L = 2dRangeSearch(s1,s2,y1,y2,root.left, type)

return L+M+R

- spend O(log n) time searching 1st level tree Tx
- for each 1D range query in a second level tree spend O(log n +
) time searching 2nd level tree Ty(v)

- total time is (since log = O(log n)
where summation is over all visited nodes v.

(total # nodes reported)

- nodes v visited when searching Ty

total =

- These act as balanced binary search trees for the x coordinate and as max heaps for the y coordinates.
- In such a tree, the root node stores the item with the largest y value, the median x coordinate of its tree (note that this isn’t the x coordinate of the item), and the left and right subtrees represent those items with x coordinate less than or greater than that median.
- See Figure 12.5 (page 556) in which nodes are placed to represent their (x,y) values

Priority Search tree: placement of nodes represents (x,y) coordinates

Dotted curves represent the median x coordinate of the subtree

- Such a tree is built in O(n log n) time, as we would expect for a balanced tree.
- Searching involves a standard range search on x, except that we terminate early when the y value at a node is less than the minimum y we are interested in.
- Searches are O(log n + s).
- Alternative trees for downward, leftward, or rightward infinite regions are very similar

- What if have four sided range queries?
- can convert a binary search tree keyed on x coordinates to a priority range tree by associating a priority search tree (3 sided) with each node.
- Right children have associated priority search trees which are unbounded to the left. Left children have associated priority search trees which are unbounded to the right. In each case, the parent node serves as the missing bound, so the three sided search is sufficient.
- requires O(n log n) space and time for construction.
- This structure can answer two-dimensional queries in O(s + log n) time by noticing that a search target in a left child won’t go beyond the values in the right child, so it doesn’t matter that we seem to be searching an infinite range; and vice versa.

- Quadtrees are used to store points in a plane in a way that regional searching becomes easy. Generally, non-rectangular regions are difficult to deal with, so we use the bounding box as a first approximation to the region.
- use a 4-ary tree to represent quadrants, sub-quadrants, etc. The quadrants are ordered as in geometry
- Since the depth of a quadtree is governed by the closeness of points, it can be very deep. Usually as a practical safeguard we give a maximum depth, D. The book doesn’t explain how to store multiple points that occur in the same maximally refined sub-sub-…quadrant.

- The major use of a quadtree is range searching, where the range is now a region of the plane, R. The algorithm recursively examines each sub-quadrant which intersects R, stopping when it arrives at external nodes. When R totally contains a sub-quadrant, we don’t employ any more logic on the sub-quadrant’s tree, but simply enumerate it.
- When the quadtree is of bounded depth <= D, then both construction and range searching are O(Dn).

idea:first split on x-coord (even levels)next split on y-coord (odd levels)repeatlevels : store ptsinternal nodes : splitting lines (as opposed to values)

- Input: set of pts P + currrent depthoutput : root of KD-tree storing P
- If (|p| = 1)
- then return leaf storing p
- else if (depth is even) // books method does not change direction
- split p into 2 equal sets by vertical line l(p1+p2)
- else
- split P into equal sized p1+p2 by horizontal line l
- Endif
- Vleft := Buildkdtree (p1, depth +1)
- Vright := Buildkdtree (p2, depth +1)
- (new) v s.t lc(v) := Vleft rc(v) :=Vright
- Return v

Lc(v)=v’s left child

Rc(v)=v’s right child

Construction time

- Expensive operation: determining splitting line(median finding)
- Can use linear time median finding algorithm (Quickselect)
- Then total time is
- but can obtain this time without fancy median finding Presort points by x-coord and by y-coord (O(nlogn))
Each time find median in O(1) and partition lists and update x and y ordering by scan in O(n) time

StorageNumber of leaves = n (one per point)

Still binary tree O(n) storage total

Querys

- each node corresponds to a region in plane
- Need only search nodes whose region intersects query region
- Report all points in subtrees whose regions contained in query range
- When reach leaf, check if point in query region

- Input: root of a subtree of a KD-tree and a range R
Output: All points at leaves below v that lie in the range

- If (v = leaf)
- then report v’s point if in R
- else if (region (lc(v)) fully contained in R)
- then ReportSubtree (Rc(v))
- else if (region (lc(v)) intersects R)
- then SearchKdTree(lc(v), R)
- if (region(rc(v)) fully contained in R)
- then ReportSubtree(rc(v))
- else if (region(rc(v)) intersects R)
- then SearchKdtree(rc(v), R)
- Endif

- Note: need to know region(v)
- - can precompute and store
- Computer during recursive calls, e.g.,
- L(v) is v’s splitting line and is left halfpland of l(v)

Lemma 5.4A query with an axis parallel rectangle in a Kd-tree storing n points can be performed in O(¯+k) time where kis the number of reported points.

Proof.

- Total time for reporting points in Report Subtree is O(k). So need to bound number of nodes visited by query algorithm that are not in traversed subtree.
- For each such node v, region(v) intersects but is not contained in R.

n

- To bound number of such nodes we bound number of regions intersected by vertical line.
(gives bound on number of regions intersected by left and right edges)

(bound on number of intersected by top and bottom edges of R is similar)

- Let l be vertical line and
- Let l(root(t)) be root’s splitting line.

- l intersects region to right or left of l(root(t)) but not both. Q(n) is equal to the number of in n point Kd-tree whose root contains vertical splitting line. This is important since if include horizontal nodes then don’t get reduction.
- Go down 2 levels before counting
- l intersects 2 of 4 regions at this level
- Each contains n/4 points
Q(1)=O(n)

Q(n)=2+2·Q(n/4)=O(¯).

×

n

Note: Analysis is probably pessimistic…

Bounded on the number of regions intersecting an edge of the query rectangle by the number of regions intersecting line through its edge.

If range is small, so will be the edge and it won’t intersect this many.

- We can use KD trees to find the nearest neighbor (see page 564)

- We can imagine a set of horizontal line segments and vertical line segments scattered in the plane. We may want to find out which segments intersect each other. In a brute-force method we could search all pairs in O(n2) time. But it would be nice to have an algorithm which is proportional in time to the actual number of intersections, since most often these segments won’t intersect anything.
- While we imagine the vertical line sweeping in a continuous fashion, in fact we only need to jump from encountering one object to encountering the next. We can think of these encounters as events which interrupt the continuous sweep for some event processing.

- Left endpoint of horizontal segment, add the segment to the range-search dictionary
- Left endpoint of horizontal segment, remove segment from the range-search dictionary
- Vertical segment, search down the dictionary for intersecting horizontal segments.
- We first have to sort the objects from left to right, O(n log n)

- Add something to a range tree – O(log n)
- Remove something from a range tree O(log n)
- Search a range tree – O(log n + s’)
- So overall, this is an O(n log n + s) operation.

- make sure that no two objects are too close to each other. We may have a lot of points scattered over a plane, and want to find the two points which are closest to one another. For instance, a point might be the locus of a moving part in a machine which shouldn’t touch any other, or parts of a circuit which might “leak” voltage if they are too close.
- Problem: Given a set of n points in the plane, find a pair of closest points.Brute force: Compute the distance between every pair. O(n2)How can we improve? Can we determine which pairs are interesting?

- Since we need to combine the information of the two sets, we have to be concerned with distances between points of different sets

- Sort the points by x-coordinate.
- Divide in half by a vertical line which bisects the set.
- Find the distances in the two sets
- We now need to consider the distances between points of different sets. We only need to consider those in a strip 2d in width along the bisection line.
- For any given point, there are a small number of points on the other side which can be less than d apart. This is because in each strip points are at least d apart (as it was the minimum).

- In fact, there are only at most six points on one side of the strip that could be less than d apart.
- Sort the points in the strip by the y coordinate.
- We check each point with a constant number of its neighbors.The text says there are at most 6 neighbors

- Sorting the x coordinates (done only once) O(n log n)
- Solve two subproblems of size n/2
- Select just those items within the strip O(n). It would be faster than this is we relied on the sorted order (by x), but they are lookingto the next improvement when the points don't come back in the same order.

- Sort those items in the strip: O(n log n) (as we can't be sure we have eliminated any of them)
- Scan those points and compare with constant number of neighbors:O(n)
- T(n) = 2T(n/2) + O(n log n) = O(n log2n)
- Improvement: Instead of having to sort the points in the strip, output the points (from the recursive steps) in sorted order by y coordinate.
- Since the merging is O(n) instead of O(n log n), the final complexity is O(n log n).

- order the points by x coordinate from left to right, and as the sweep line crosses a point, check back to the left to see if any points are closer than the current minimum distance. We use our list ordered by x to locate these points.
- This requires us to keep track of the current minimum distance, the current closest pair of points, and y range tree of all of the points within that minimum horizontal distance of the line.

- Add a point to the tree as we encounter it
- Remove a point from the tree as the line shifts to the next event and the distance is greater than d
- Encounter a point and check the potential close points which, to a first approximation, are those which are in the range tree, within a vertical distance of d from the event point.
- There will only be at most 6 such points that we actually select. (Recall, for this algorithm the time depends on the number of things selected.) We have to examine each one to see whether it is actually at a distance closer than d.
- Since s’ here is the constant 6, the sweep is O(n log n).

obstacle

start

end

Convex Hull

- A convex polygon is a nonintersecting polygon whose internal angles are all convex (i.e., less than p)
- In a convex polygon, a segment joining two vertices of the polygon lies entirely inside the polygon

convex

nonconvex

- The convex hull of a set of points is the smallest convex polygon containing the points
- Think of a rubber band snapping around the points

- The convex hull is a segment
- Two points
- All the points are collinear

- The convex hull is a point
- there is one point
- All the points are coincident

- Motion planning
- Find an optimal route that avoids obstacles for a robot

- Geometric algorithms
- Convex hull is like a two-dimensional sorting

obstacle

start

end

- The following method computes the convex hull of a set of points
Phase 1: Find the lowest point (anchor point)

Phase 2: Form a nonintersecting polygon by sorting the points counterclockwise around the anchor point

Phase 3: While the polygon has a nonconvex vertex, remove it

b

c

a

c

b

a

- The orientation of three points in the plane is clockwise, counterclockwise, or collinear
- orientation(a, b, c)
- clockwise (CW, right turn) NEGATIVE
- counterclockwise (CCW, left turn) POSITIVE
- collinear (COLL, no turn) ZERO

- The orientation of three points is characterized by the sign of the determinant D(a, b, c), whose absolute value is twice the area of the triangle with vertices a, b and c

CW -

c

CCW +

b

a

COLL 0

b

c

a

c

b

a

clockwise

- The orientation of three points is characterized by the sign of the determinant D(a, b, c), whose absolute value is twice the area of the triangle with vertices a, b and c
- QUIZ: By experimentation, explain what the various signs of the determinant mean.

counter clockwize

c

b

a

colinear

xbyc –ybxc – (xayc-yaxc) + xayb-yaxb

- Computing angles from coordinates is complex and leads to numerical inaccuracy
- We can sort a set of points by angle with respect to the anchor point a using a comparator based on the orientation function
- b<c orientation(a, b, c) = CCW
- b=c orientation(a, b, c) = COLL
- b>c orientation(a, b, c) = CW

CCW

CW

COLL

c

b

c

b

b

c

a

a

a

- Testing whether a vertex is convex can be done using the orientation function
- Let p, q and r be three consecutive vertices of a polygon, in counterclockwise order
- q convex orientation(p, q, r) = CCW
- qnonconvex orientation(p, q, r) = CW or COLL

r

r

q

q

p

p

The Graham scan is a systematic procedure for removing nonconvex vertices from a polygon

The polygon is traversed counterclockwise and a sequence H of vertices is maintained

for each vertex r of the polygon

Let q and p be the last and second last vertex of H

whileorientation(p, q, r) = CW or COLLremove q from Hq pp vertex preceding p in H

Add r to the end of H

r

r

p

r

q

p

q

p

q

H

H

H

- Computing the convex hull of a set of points takes O(n log n) time
- Finding the anchor point takes O(n) time
- Sorting the points counterclockwise around the anchor point takes O(n log n) time
- Use the orientation comparator and any sorting algorithm that runs in O(n log n) time (e.g., heap-sort or merge-sort)

- The Graham scan takes O(n) time
- Each point is inserted once in sequence H
- Each vertex is removed at most once from sequence H

q

e

w

u

z

t

Incremental Convex Hull

Given a convex polygon P, a point location query locate(q) determines whether a query point q is inside (IN), outside (OUT), or on the boundary (ON) of P

An efficient data structure for point location stores the top and bottom chains of P in two binary search trees, TL and TH of logarithmic height

An internal node stores a pair (x (v), v) where v is a vertex and x (v)is its x-coordinate

An external node represents an edge or an empty half-plane

TH

P

TL

TH

- To perform locate(q), we search for x(q) in TLand TH to find
- Edge eLor vertex vL on the lower chain of P whose horizontal span includes x(q)
- Edge eHor vertex vH on the upper chain of P whose horizontal span includes x(q)

- We consider four cases
- If no such edges/vertices exist, we return OUT
- Else if q is on eL(vL) or on eH(vH), we return ON
- Else if q is above eL(vL) and below eH(vH), we return IN
- Else, we return OUT

eH

P

q

vL

TL

The incremental convex hull problem consists of performing a series of the following operations on a set S of points

locate(q): determines if query point q is inside, outside or on the convex hull of S

insert(q): inserts a new point q into S

hull(): returns the convex hull of S

Incremental convex hull data structure

We store the points of the convex hull and discard the other points

We store the hull points in two red-black trees

TLfor the lower hull

THfor the upper hull

In operation insert(q), we consider four cases that depend on the location of point q

AIN or ON: no change

BOUT and above: add q to the upper hull

COUT and below: add q to the lower hull

DOUT and left or right: add q to the lower and upper hull

A

C

D

q

w

u

z

t

q

- Algorithm to add a vertex q to the upper hull chain in Case B (boundary conditions omitted for simplicity)
- We find the edge e (vertex v) whose horizontal span includes q
- w left endpoint (neighbor) of e (v)
- z left neighbor of w
- While orientation(q, w, z) = CW or COLL
- We remove vertex w
- w z
- z left neighbor of w

- u right endpoint (neighbor) of e (v)
- t right neighbor of u
- While orientation(t, u, q) = CW or COLL
- We remove vertex u
- u t
- t right neighbor of u

- We add vertex q

e

w

u

z

t

- Let n be the current size of the convex hull
- Operation locate takes O(log n) time
- Operation insert takes O((1 +k)log n) time, where k is the number of vertices removed
- Operation hull takes O(n) time
- The amortized running time of operation insert is O(log n)