1. Geometric Data Structures
Reading: Chapter 10 of the Textbook
Driving Applications
Windowing Queries
Related Application
Query Image Database
UNC Chapel Hill
M. C. Lin

2. Windowing Queries
Given a rectangular region (2D or 3D), or a window, the algorithm must determine the part of the database that lie in the window and report them. Data are normally not points, but line segments, polygons, etc.
2D Windowing: navigation using a map or an electronic GIS; circuit-board layout, etc.
3D Windowing: view frustrum culling; viewing a complex CAD/CAM model by zooming in to a small portion, etc.
UNC Chapel Hill
M. C. Lin

3. Orthogonal Window Queries
Let S be a set of n axis-parallel line segments. A query asks for the segments intersecting a 2D query window, W := [x:x’] x [y:y’]
Most cases, the segment has at least one point inside of W. We can find such segments by performing a range query with W in the set of 2n endpoints of the segments in S, by using a 2D range tree T. 2D range tree can answer a range query in O(log2n + k) time; query time can be improved to O(logn + k) by fractional cascading.
Find segments that intersect W twice either at the left and right edges or top and bottom edges. This reduces to finding horiz. (v) segments intersecting a vert. (h) line.
UNC Chapel Hill
M. C. Lin

4. Classification of Segments w.r.t. xmid
An interval [x:x’] contains l := (x=qx) iff x  qx  x’
We can classify a set of segments w.r.t to xmid :
Imid: those containing xmid
Ileft: those complete lie to the left & cannot intersect l
Iright: those complete lie to the right & cannot intersect l
Check Imid to find intersecting segments with l
Store the intervals in 2 sorted lists: increasing left endpoints and decreasing right endpoints
qx can be contained in an interval if it’s also contained in all its predecessors in the sorted list
We can simply walk along sorted lists reporting intervals & stop when we encounter I s.t. qx  I
UNC Chapel Hill
M. C. Lin

5. Interval Trees If I = 0, then the interval tree is a leaf
Otherwise, let xmid be the median of the endpoints of the intervals, let Ileft := { [xj:xj’]  I : xj’ < xmid },
Imid := { [xj:xj’]  I : xj  xmid  xj’ },
Iright := { [xj:xj’]  I : xmid < xj }.
The interval trees consists of a root node v storing xmid.
The set Imid is stored twice: once in a list Lleft(v) that is stored on the left endpoints of the intervals, once in a list Lright(v) that is stored on the right endpoints of intervals
The left subtree of v is an interval tree for Ileft
The right subtree of v is an interval tree for Iright
UNC Chapel Hill
M. C. Lin

6. ConstructIntervalTree(I)
Input: A set I of intervals on the real line.
Output: The root of an interval tree for I .
1. if I = 0
then return an empty leave
else Create a node v. Compute xmid, the median of the set of interval
endpoints, and store xmid with v.
Compute Imid and construct two sorted lists for Imid: a list Lleft(v)
sorted on left endpoint & a list Lright (v) sorted on right endpoint.
Store these two lists at v.
lc(v)  ConstructIntervalTree(Ileft)
rc(v)  ConstructIntervalTree(Iright)
7. return v
UNC Chapel Hill
M. C. Lin

7. QueryIntervalTree(v, qx)
Input: The root v of an interval tree and a query point qx
Output: All intervals that contain qx
1. if v is not a leaf
then if qx < xmid(v)
then Walk along the list Lleft(v), starting at the
interval with the leftmost endpoint, reporting
all the intervals that contain qx. Stop as soon
as an interval does not contain qx.
QueryIntervalTree(lc(v), qx)
else Walk along the list Lright(v), starting at the
interval with the rightmost endpoint, reporting
QueryIntervalTree(rc(v), qx)
UNC Chapel Hill
M. C. Lin

8. Algorithm Analysis
An interval tree for a set I of n intervals uses O(n) storage, has depth O(logn) and can be built in O(n log n) time. Using the interval tree we can report all intervals containing a query point in O(k + log n) time, where k is no. of reported intervals.
Let S be a set of n horizontal segments in the plane. The segments intersecting a vertical query segment can be reported in O(log2n + k) time with a data structure of O(n log n) storage, where k is the number of reported segments. The structure can be built in O(n log n) time.
Let S be a set of n axis-parallel segments in the plane. The segments intersecting an axis-parallel rectangular query window can be reported in O(log2n + k) time with a data structure of O(n log n) storage, where k is number of reported segments. The structure can be built in O(n log n) time.
UNC Chapel Hill
M. C. Lin

9. Motivation for Priority Search Trees
Replacing RangeTrees: A 2d rectangle query on P asks for points in P lying inside a query window (-:qx] x [qy:qy’]. Use ideas from 1d range query.
Use a heap to answer 1d query if px (-:qx] and partition using the y-coordinates.
Root of the tree stores the point with minimum x-value and the remainder is partitioned into 2 equal sets.
The 2 sets are partitioned into sets above & below
Construct the tree recursively
UNC Chapel Hill
M. C. Lin

10. Priority Search Trees
If P = 0, then the priority search tree is an empty leaf
Otherwise, let pmin be the point in P with the smallest x-coordinate and ymid be the y-median of the rest in P. Let
Pbelow := { p  P\{pmin} : py < ymid },
Pabove := { p  P\{pmin} : py > ymid }.
The priority search trees consists of a root node v where the point p(v) := pmin and the value y(v) := ymin are stored.
The left subtree of v is a priority search tree for Pbelow
The right subtree of v is a priority search tree for Pabove
UNC Chapel Hill
M. C. Lin

11. ReportInSubTree(v, qx)
Input:The root v of a subtree of a priority search tree and a value qx
Output: All points in the subtree with x-coordinate at most qx
1. if v is not a leaf and (p(v))x  qx
then Report p(v)
ReportInSubTree(lc(v), qx)
ReportInSubTree(rc(v), qx)
UNC Chapel Hill
M. C. Lin

12. QueryPrioSearchTree(T,(-:qx]x[qy:qy’])
Input: A priority search tree and a range unbounded to the left
Output: All points lying in the range
1. Search with qy and qy’ in T. Let vsplit be node where 2 search paths split
2. for each node v on the search path of qy or qy’
do if p(v)  (-:qx]x[qy:qy’] then report p(v)
4. for each node v on the search path of qy in the left subtree of vsplit
do if the search path goes left at v
then ReportInSubtree(rc(v), qx)
7. for each node v on the search path of qy’ in the right subtree of vsplit
do if the search path goes right at v
then ReportInSubtree(lc(v), qx)
UNC Chapel Hill
M. C. Lin

13. Algorithm Analysis
A priority search tree for a set P of n points in the plane uses O(n) storage & can be built in O(n log n) time. Using the priority search tree we can report all points in a query range of the form (-:qx] x [qy:qy’] in O(k + log n) time, where k is the number of reported points.
UNC Chapel Hill
M. C. Lin

14. Segment Tree Data Structures
The skeleton of the segment tree is a balanced binary tree T. The leaves of T correspond to the elementary intervals induced by the endpoints of the intervals in I in an ordered way: the leftmost leaf corresponds to the leftmost elementary interval, and so on. The elementary interval corresponding to leaf u is denoted Int(u).
The internal nodes of correspond to intervals that are the union of elementary intervals: the interval Int(v) corresponding to node v is the union of the elementary intervals Int(u) of the leaves in the subtree rooted at v. (implying Int(v) is the union of its two children)
Each node or leaf v in T stores the interval Int(v) and a set I(v) I of intervals (e.g. in a linked list). This canonical subset of node v contains the intervals [x:x’]I s.t. Int(v)[x:x’] & Int(parent(v))[x:x’]
(See the diagrams in class)
UNC Chapel Hill
M. C. Lin

15. QuerySegmentTree(v, qx)
Input:The root v of a (subtree of a) segment tree and a query point qx
Output: All intervals in the tree containing qx
1. Report all the intervals in I(v)
2. if v is not a leaf
then if qx  Int(lc(v))
then QuerySegmentTree(lc(v), qx)
else QuerySegmentTree(rc(v), qx)
UNC Chapel Hill
M. C. Lin

16. Constructing Segment Trees
Sort the endpoints on the intervals in I in O(n log n) time. This gives elementary intervals.
Construct a balanced binary tree on the elementary intervals & determine for each node v of the tree the interval Int(v) it represents.
Compute the canonical subsets by inserting one interval at a time into T. (See the next procedure)
UNC Chapel Hill
M. C. Lin

17. InsertSegmentTree(v, [x:x’])
Input: The root of a (subtree of a) segment tree and an interval
Output: The interval will be stored in the subtree
1. if Int(v)  [x:x’]
then store [x:x’] at v
else if Int(lc(v))  [x:x’]  0
then InsertSegmentTree(lc(v), qx)
if Int(rc(v))  [x:x’]  0
then InsertSegmentTree(rc(v), qx)
UNC Chapel Hill
M. C. Lin

18. Algorithm Analysis
A segment tree for a set I of n intervals uses O(n log n) storage and can be built in O(n log n). Using the segment tree we can report all intervals that contain a query point in O(log n + k) time, where k is the number of reported intervals.
Let S be a set of n segments in the plane with disjoint interiors. The segments intersecting an axis-parallel rectangular query window can be reported in O(log2n+k) time with a data structure that uses O(n log n) storage, where k is the number of reported segments. The structure can be built in O(n log n) time.
UNC Chapel Hill
M. C. Lin