1

Computational Geometry Chapter 12

2

Motivation Range Trees

• e.g. Database

Database Record

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

• age• salary• start date• city address

employee

3

Motivation

• e.g. Database

Database Record

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

• age• salary• start date• city address

employee

4

Motivation Ctnd.

• 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)

5

Motivation (cont)

Orthogonal Range Query (Rectangular)Want all points in the orthogonal rangeFaster than linear scan if good data structures are used.Want time O( f(n)+k ) ; where k= # of points reported

0 50K100K150K200K

15

25

35

45

…

…

age

salary

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

6

• 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)

Total O(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)

1-D Range Searching

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

7

Evaluation of sorted array (cont)

• 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)

8

1-D Range Searching Ctnd.Data structure 2: Balanced Binary Search Tree• Leaves store points in P (in order left to right)• Internal nodes are splitting values. v.x used 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’)

9

1-D Range Searching Ctnd.

• 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

893710

802362

3 19 30 7059 100

3 10 592319 30 37 62 70 80 100 105

49 89

10

1-D Range Searching Ctnd.

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

49

893710

802362

3 19 30 7059 100

3 10 592319 30 37 62 70 80 100 105

49 89

u

Search path

u’

1-D Range Tree

11

• 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)

Algorithm: 1D Range Query(x, x’,v)

12

Time complexity of 1D-Range Query

– 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

13

- 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))

Range trees 2D Queries

Tx

v

P(v)

Ty(v)

P(v)

p1

p2

p3

p4

p5p6

p7

p1 p2 p3 p4 p5 p6 p7

v

T4

p7 p5 p6

Ty(v)

14

Range treesBuild 2D-Range Tree(P)input: a set of P points in the planeoutput: root of a 2D range tree

1. Construct 2nd level tree Ty for P (store entire points at leaves) 2. if (|P|=1)

3. then create leaf v. Ty(v):= Ty

4. else split P into Pleft and Pright parts of equal size by x coordinate around xmid

5. vleft :=Build2D-RangeTree(Pleft)

6. vright:=Build2D-RangeTree(Pright)

7. create new v such that xv:=xmid

Leftchild(v):=vleft

Righteftchild(v):=vleft

Ty(v):=Ty

8. return vend /* Build2D-RangeTree */

15

Range trees - revisedBuild 2D-Range Tree(P)input: a set of P points in the plane, sorted by xoutput: root of a 2D range tree, set of points sorted by y 1. if (|P|=1)

2. then create leaf v. Ty(v):= Ty

3. else split P into Pleft and Pright parts of equal size by x coordinate around xmid

4. (Vleft, Yleft):=Build2D-RangeTree(Pleft)

5. (Vright, Yright):=Build2D-RangeTree(Pright)

6. create new 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 */

16

Range treesA 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.

17

Construction Time for 2D Range Tree • 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)

18

Queries in 2D Range Trees

• 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

19

2dRangeSearch(x1,x2,y1,y2,root,type) -page 555if 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

20

Proof• 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

v

v kk

v

)kO(logn v

n) θ(log n),O(log O(logn) 2

v

vk

vn

21

Proof (Cont.)

total = k) +n logO( 2

22

Priority Search Trees

– 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

23

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

Dotted curves represent the median x coordinate of the subtree

24

– 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

25

Priority Range Trees– 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.

26

Quad and kD Trees – 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.

27

– 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).

28

KD-Trees (Higher dimensional generalization of 1D-Range Tree.)

idea:first split on x-coord (even levels)next split on y-coord (odd levels)repeat

levels : store pts

internal nodes : splitting lines (as opposed to values)

29

Algorithm : BuildKDtree (p, depth)• Input: set of pts P + currrent depth

output : root of KD-tree storing P1. If (|p| = 1)2. then return leaf storing p3. else if (depth is even) // books method does not change direction4. split p into 2 equal sets by vertical line l(p1+p2)5. else6. split P into equal sized p1+p2 by horizontal line l7. Endif8. Vleft := Buildkdtree (p1, depth +1)9. Vright := Buildkdtree (p2, depth +1)10. (new) v s.t lc(v) := Vleft

rc(v) :=Vright11. Return v

Lc(v)=v’s left child

Rc(v)=v’s right child

30

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P

1l 1l

31

Build KD-Tree

1l

2l

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

1l

32

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

1l

2l 3l

33

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

1l

2l 3l

4lP 3

34

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

5l 1l

2l 3l

4lP 3

5l

P 5P 4

35

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

5l

6l

1l

2l 3l

4lP 3

5l

P 5P 4

6l

p8

36

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

5l

6l

7l 1l

2l 3l

4lP 3

5l

P 5P 4

6l

p8

7l

p10p9

37

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

5l

6l

7l

8l

1l

2l 3l

4lP 3

5l

P 5P 4

6l

p8

7l

p10p9

8l

P 1 P 2

38

Build KD-Tree

1P

2P

3P

4P

5P

6P

7P

8P

9P

10P2l

3l

1l

4l

5l

6l

7l

8l

9l

1l

2l 3l

4lP 3

5l

P 5P 4

6l

p8

7l

p10p9

8l

P 1 P 2

9l

P 6 P 7

39

Complexity

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

)nlogn(O)2

n(T2)n(O)n(T

)nlogn(O)2

n(T2)n(O)n(T

40

Complexity

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

41

Algorithm: Search KD-Tree (v, R)

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

1. If (v = leaf)2. then report v’s point if in R3. else if (region (lc(v)) fully contained in R)4. then ReportSubtree (Rc(v))5. else if (region (lc(v)) intersects R)6. then SearchKdTree(lc(v), R)7. if (region(rc(v)) fully contained in R)8. then ReportSubtree(rc(v))9. else if (region(rc(v)) intersects R)10. then SearchKdtree(rc(v), R)11. 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)

left)v(l)v(region)v(lc(region

left)v(l

42

Query time

Lemma 5.4 A query with an axis parallel rectangle in a Kd-tree storing n points can be performed in O(¯+k) time where k is 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

43

Query time

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.

44

Query time

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

45

Query time

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.

46

Nearest Neighbor

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

47

Orthogonal Segment IntersectionPlane Sweep

– 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.

48

There are three kinds of objects and event processing steps:

– 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)

49

For each object, we either:

– 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.

50

Closest Pairs• 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?

51

Divide and Conquer Approach• Since we need to combine the information of the two sets, we have to be concerned with distances between points of different sets

52

Approach• 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).

53

• 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

54

Complexity• 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.

•  

55

• 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).

56

Sweeping to Find Closest Pairs

– 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.

57

The events are:– 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).

58

Convex Hull

obstacle

startend

59

Convex Polygon• A convex polygon is a nonintersecting polygon whose

internal angles are all convex (i.e., less than )• In a convex polygon, a segment joining two vertices of the

polygon lies entirely inside the polygon

convex nonconvex

60

Convex Hull• 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

61

Special Cases• 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

62

Applications• Motion planning

– Find an optimal route that avoids obstacles for a robot

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

obstacle

startend

63

Computing the Convex Hull• 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

64

Orientation• 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 (a, b, c), whose absolute value is twice the area of the triangle with vertices a, b and c

a

b

c

a

c

b

c

ba

CW -

CCW +

COLL 0

1

1

1

),,(

cc

bb

aa

yx

yx

yx

cba

65

Orientation QUIZ• The orientation of three points is

characterized by the sign of the determinant (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.

a

b

c

a

c

b

c

ba

clockwise

counter clockwi

ze

colinear1

1

1

),,(

cc

bb

aa

yx

yx

yx

cba

66

1

1

1

),,(

cc

bb

aa

yx

yx

yx

cba

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

67

Sorting by Angle• 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

a

bc

CCW

a

cb

CW

a

bc

COLL

68

Removing Nonconvex Vertices• 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

– q nonconvex orientation(p, q, r) CW or COLL

pq

r

qr

p

69

Graham Scan• 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 polygonLet q and p be the last and second last

vertex of H

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

Add r to the end of H

p

q

r

H

pqr

H

p

qr

H

70

Analysis

• 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

71

Incremental Convex Hull

q

w uez t

72

Point Location• 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

P

TH

TL

73

Point Location (cont.)

• To perform locate(q), we search for x(q) in TL and TH to find– Edge eL or vertex vL on the lower

chain of P whose horizontal span includes x(q)

– Edge eH or 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

P

TH

TL

q

eH

vL

74

Incremental Convex Hull

• 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

• TL for the lower hull

• TH for the upper hull

75

Insertion of a Point• In operation insert(q),

we consider four cases that depend on the location of point qA IN or ON: no change

B OUT and above: add q to the upper hull

C OUT and below: add q to the lower hull

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

A

C

D

76

Insertion of a Point (cont.)• 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

q

w uez t

q

w

uz t

77

Analysis

• 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)