Geometric Algorithms 7.3 Range Searching

Geometric search: Overview

Types of data. Points, lines, planes, polygons, circles, ... Geometric Algorithms This lecture. Sets of N objects.

Geometric problems extend to higher dimensions.

! Good algorithms also extend to higher dimensions.

! Curse of dimensionality.

Basic problems.

! Range searching.

! Nearest neighbor.

! Finding intersections of geometric objects.

Reference: Chapters 26-27, Algorithms in C, 2nd Edition, Robert Sedgewick.

1D Range Search

7.3 Range Searching Extension to symbol-table ADT with comparable keys. ! Insert key-value pair.

! Search for key k.

! How many records have keys between k1 and k2?

! Iterate over all records with keys between k1 and k2.

Application: database queries.

insert B B insert D B D insert A A B D insert I A B D I Geometric intuition. insert H A B D H I ! Keys are point on a line. insert F A B D F H I

! How many points in a given interval? insert P A B D F H I P count G to K 2 search G to K H I

Range search. How many records have keys between k1 and k2? Extension to symbol-table ADT with 2D keys.

! Insert a 2D key.

Ordered array. Slow insert, binary search for k1 and k2 to find range. ! Search for a 2D key.

Hash table. No reasonable algorithm (key order lost in hash). ! Range search: find all keys that lie in a 2D range?

! Range count: how many keys lie in a 2D range? BST. In each node x, maintain number of nodes in tree rooted at x.

Search for smallest element ! k1 and largest element " k2. Applications: networking, circuit design, databases.

Geometric interpretation. insert count range ! Keys are point in the plane. ordered array N log N R + log N ! Find all points in a given h-v rectangle?

hash table 1 N N

BST log N log N R + log N

nodes examined N = # records within interval R = # records that match not touched

5 6

2D Orhtogonal Range Search: Grid Implementation 2D Orthogonal Range Search: Grid Implementation Costs

Grid implementation. [Sedgewick 3.18] Space-time tradeoff. 2 ! Divide space into M-by-M grid of squares. ! Space: M + N. 2 ! Create linked list for each square. ! Time: 1 + N / M per grid cell examined on average.

! Use 2D array to directly access relevant square.

! Insert: insert (x, y) into corresponding grid square. Choose grid square size to tune performance.

! Range search: examine only those grid squares that could have ! Too small: wastes space.

points in the rectangle. ! Too large: too many points per grid square.

! Rule of thumb: ! N by ! N grid.

Time costs. [if points are evenly distributed] RT RT ! Initialize: O(N).

! Insert: O(1).

! Range: O(1) per point in range.

LB LB

7 8 Clustering Space Partitioning Trees

Grid implementation. Fast, simple solution for well-distributed points. Space partitioning tree. Use a tree to represent the recursive Problem. Clustering is a well-known phenomenon in geometric data. hierarchical subdivision of d-dimensional space.

BSP tree. Recursively divide space into two regions. Quadtree. Recursively divide plane into four quadrants. Octree. Recursively divide 3D space into eight octants. kD tree. Recursively divide k-dimensional space into two half-spaces.

Applications.

Ex: USA map data. ! Ray tracing.

! Flight simulators. ! 80,000 points, 20,000 grid squares. ! N-body simulation. ! Half the grid squares are empty. Grid kD tree ! Collision detection. ! Half the points have ! 10 others in same grid square. ! Astronomical databases. ! Ten percent have ! 100 others in same grid square. ! Adaptive mesh generation.

! Accelerate rendering in Doom. Need data structure that gracefully adapts to data. ! Hidden surface removal and shadow casting. Quadtree BSP tree

9 10

Quad Trees Curse of Dimensionality

Quad tree. Recursively partition plane into 4 quadrants. Range search / nearest neighbor in k dimensions? Main application. Multi-dimensional databases.

Implementation: 4-way tree. public class QuadTree { Quad quad; 3D space. Octrees: recursively divide 3D space into 8 octants. Value value; QuadTree NW, NE, SW, SE; 100D space. Centrees: recursively divide into 2100 centrants??? }

c a d a h

d e f g e

f b c g h

Good clustering performance is a primary reason to choose quad trees over grid methods. Raytracing with octrees http://graphics.cs.ucdavis.edu/~gregorsk/graphics/275.html

11 12 2D Trees kD Trees

2D tree. Recursively partition plane into 2 halfplanes. kD tree. Recursively partition k-dimensional space into 2 halfspaces.

Implementation: BST, but alternate using x and y coordinates as key. Implementation: BST, but cycle through dimensions ala 2D trees.

! Search gives rectangle containing point.

! Insert further subdivides the plane. p

level ! i (mod k) p points points whose ith whose ith coordinate coordinate is less than p’s is greater than p’s points points left of p right of p even levels Efficient, simple data structure for processing k-dimensional data. q ! Adapts well to clustered data.

! Adapts well to high dimensional data.

points points ! Discovered by an undergrad in an algorithms class! below q above q odd levels

13 14

Summary

Basis of many geometric algorithms: search in a planar subdivision. 7.4 Geometric Intersection

Voronoi intersecting grid 2D tree diagram lines

basis #N h-v lines N points N points #N lines

2D array N-node representation N-node BST ~N-node BST of N lists multilist

cells ~N squares N rectangles N polygons ~N triangles

search cost 1 log N log N log N

cells too use (k-1)D extend to kD? too many cells easy complicated hyperplane

Problem. Find all intersecting pairs among set of N geometric objects. Sweep vertical line from left to right.

Applications. CAD, games, movies, virtual reality. ! Event times: x-coordinates of h-v line segments.

! Left endpoint of h-segment: insert y coordinate into ST.

! Right endpoint of h-segment: remove y coordinate from ST.

Simple version: 2D, all objects are horizontal or vertical line segments. ! v-segment: range search for interval of y endpoints.

Brute force. Test all $(N2) pairs of line segments for intersection. Sweep line. Efficient solution extends to 3D and general objects.

insert y range search delete y 17 18

Orthogonal Segment Intersection: Sweep Line Algorithm Immutable H-V Segment ADT

Sweep line: reduces 2D orthogonal segment intersection problem to 1D range searching! public final class SegmentHV implements Comparable { Running time of sweep line algorithm. public final int x1, y1; public final int x2, y2; ! Put x-coordinates on a PQ (or sort). O(N log N) N = # line segments ! Insert y-coordinate into ST. O(N log N) R = # intersections public SegmentHV(int x1, int y1, int x2, int y2) public boolean isHorizontal() { … } ! Delete y-coordinate from ST. O(N log N) public boolean isVertical() { … } ! Range search. O(R + N log N) public int compareTo(SegmentHV b) { … } public String toString() { … }

} compare by y-coordinate; break ties by x-coordinate Efficiency relies on judicious use of data structures.

(x1, y2)

(x1, y1) (x2, y1) (x1, y1)

horizontal segment vertical segment

19 20 Sweep Line Event Sweep Line Algorithm: Initialize Events

// initialize events public class Event implements Comparable { MinPQ pq = new MinPQ(); int time; for (int i = 0; i < N; i++) { SegmentHV segment; if (segments[i].isVertical()) { Event e = new Event(segments[i].x1, segments[i]); public Event(int time, SegmentHV segment) { pq.insert(e); this.time = time; } this.segment = segment; else if (segments[i].isHorizontal()) { } Event e1 = new Event(segments[i].x1, segments[i]); Event e2 = new Event(segments[i].x2, segments[i]); public int compareTo(Event b) { pq.insert(e1); return a.time - b.time; pq.insert(e2); } } } }

21 22

Sweep Line Algorithm: Simulate the Sweep Line General Line Segment Intersection

// simulate the sweep line Use horizontal sweep line moving from left to right. int INF = Integer.MAX_VALUE; ! Maintain order of segments that intersect sweep line by y-coordinate. RangeSearch st = new RangeSearch(); ! Intersections can only occur between adjacent segments. while (!pq.isEmpty()) { Event e = pq.delMin(); ! Add/delete line segment % one new pair of adjacent segments.

int sweep = e.time; ! Intersection % two new pairs of adjacent segments. SegmentHV segment = e.segment;

if (segment.isVertical()) { SegmentHV seg1, seg2; seg1 = new SegmentHV(-INF, segment.y1, -INF, segment.y1); seg2 = new SegmentHV(+INF, segment.y2, +INF, segment.y2); A Iterable list = st.range(seg1, seg2); B for (SegmentHV seg : list) System.out.println(segment + " intersects " + seg); } C else if (sweep == segment.x1) st.add(segment); insert segment else if (sweep == segment.x2) st.remove(segment); D delete segment } A AB ABC ACB ACBD ACD CAD CA A intersection

order of segments

23 24 Line Segment Intersection: Implementation

Efficient implementation of sweep line algorithm. VLSI Rules Checking ! Maintain PQ of important x-coordinates: endpoints and intersections.

! Maintain ST of segments intersecting sweep line, sorted by y.

! O(R log N + N log N).

Implementation issues.

! Degeneracy.

! Floating point precision.

! Use PQ since intersection events aren't known ahead of time.

Algorithms and Moore's Law Algorithms and Moore's Law

Rectangle intersection. Find all intersections among h-v rectangles. "Moore’s Law." Processing power doubles every 18 months.

Application. VLSI rules checking in microprocessor design. ! 197x: need to check N rectangles.

! 197(x+1.5): need to check 2N rectangles on a 2x-faster computer.

Early 1970s: microprocessor design became a geometric problem. Quadratic algorithm. Compare each rectangle against all others.

! Very Large Scale Integration (VLSI). ! 197x: takes M days.

! Computer-Aided Design (CAD). ! 197(x+1.5): takes (4M)/2 = 2M days. (!)

! Design-rule checking. Need O(N log N) CAD algorithms to sustain Moore’s Law.

27 28 VLSI Database Problem Interval Search Trees

Move a vertical "sweep line" from left to right. (7, 10) (20, 22)

! Sweep line: sort rectangles by x-coordinate and process in this order, (5, 11) (17, 19) stopping on left and right endpoints.

! Maintain set of intervals intersecting sweep line. (4, 8) (15, 18)

! Key operation: given a new interval, does it intersect one in the set?

Support following operations.

! Insert an interval (lo, hi).

! Delete the interval (lo, hi).

! Search for an interval that intersects (lo, hi).

Non-degeneracy assumption. No intervals have the same x-coordinate.

29 30

Interval Search Trees Finding an Intersecting Interval

(7, 10) (20, 22) Search for an interval that intersects (lo, hi).

(5, 11) (17, 19) Node x = root; while (x != null) { (4, 8) (15, 18) if (x.interval.intersects(lo, hi)) return x.interval; else if (x.left == null) x = x.right; else if (x.left.max < lo) x = x.right; else x = x.left; } return null;

Interval tree implementation with BST. (17, 19) 22

! Each BST node stores one interval.

! BST nodes sorted on lo endpoint. Case 1. If search goes right, no overlap in left.

! Additional info: store and maintain (5, 11) 18 (20, 22) 22 ! (x.left == null) % trivial.

max endpoint in subtree rooted at node. ! (x.left.max < lo) % for any interval (a, b) in left subtree of x, we have b " max < lo.

(4, 8) 8 (15, 18) 18 max defn of max reason for going right

max in subtree (a, b) (lo, hi)

(7, 10) 10 left subtree of x

32 33 Finding an Intersecting Interval Interval Search Tree: Analysis

Search for an interval that intersects (lo, hi). Implementation. Use a balanced BST to guarantee performance.

Node x = root; can maintain auxiliary information while (x != null) { using log N extra work per op if (x.interval.intersects(lo, hi)) return x.interval; else if (x.left == null) x = x.right; else if (x.left.max < lo) x = x.right; else x = x.left; } Operation Worst case return null; insert interval log N delete interval log N Case 2. If search goes left, then either (i) there is an intersection in find an interval that intersects (lo, hi) log N left subtree or (ii) no intersections in either subtree. find all intervals that intersect (lo, hi) R log N Pf. Suppose no intersection in left. Then for any interval (a, b) in right subtree, a ! c > hi % no intersection in right. N = # intervals R = # intersections max intervals sorted no intersection by left endpoint in left subtree (lo, hi) (c, max) (a, b)

left subtree of x right subtree of x

34 35

VLSI Database Sweep Line Algorithm: Review VLSI Database Problem: Sweep Line Algorithm

Move a vertical "sweep line" from left to right. Sweep line: reduces 2D orthogonal rectangle intersection problem to 1D

! Sweep line: sort rectangles by x-coordinates and process in this order. interval searching!

! Store set of rectangles that intersect the sweep line in an interval search tree (using y-interval of rectangle). Running time of sweep line algorithm.

! Left side: interval search for y-interval of rectangle, insert y-interval. ! Sort by x-coordinate. O(N log N) N = # line segments ! Right side: delete y-interval. ! Insert y-interval into ST. O(N log N) R = # intersections

! Delete y-interval from ST. O(N log N)

! Interval search. O(R log N)

Efficiency relies on judicious extension of BST.

36 37