1. 2-dimensional indexing structure
R-Trees
2-dimensional indexing structure

2. R-trees 2-dimensional version of the B-tree:
B-tree of maximum degree 8; degree between 3 and 8
Internal nodes with k children have k-1 split values

3. R-trees Can store: Stored objects may overlap
a set of polygons (regions of a subdivision)
a set of polygonal lines (or boundaries)
a set of points
a mix of the above
Stored objects may overlap

4. R-trees Originally by Guttman, 1984
Dozens of variations and optimizations since
Suitable for windowing, point location and intersection queries
Heuristic structure, no order bounds ( O(..) )
Tree with higher degree: suitable for background storage (short search paths); one node per disk block

5. Definition R-tree
Every internal node contains entries (rectangle, pointer to child node)
All leaves contain entries (rectangle, pointer to object) in database or file
Rectangles are minimal bounding rectangles (MBR)
The root has  2 and  M entries
All other nodes have at least m and at most M entries
All leaves have the same depth
m > 1 and M > 2m (e.g. m = 200; M = 1000)

6. Object descriptions

7. Grouping of objects
Windowing query: the fewer rectangles intersected, the fewer subtrees to descend into

8. Grouping of objects
Objects close together in same leaves  small rectangles  queries descend in only few subtrees
Group the child nodes under a parent node such that small rectangles arise

9. Heuristics for fast queries
Small area of rectangles
Small perimeter of rectangles
Little overlap among rectangles
Well-filled nodes (tree less deep  fewer disk accesses on each search path)

10. Example R-tree

15. Object descriptions

16. point containment query

17. point containment query

18. Searching in an R-tree Q is query object (point, window, object)
For each rectangle R in the current node, if Q and R intersect,
search recursively in the subtree under the pointer at R (at an internal node)
get the object corresponding to R and test for intersection with R (at a leaf)

19. Inserting in an R-tree
Determine minimal bounding rectangle (MBR) of new object
When not yet at a leaf (choose subtree):
determine rectangle whose area increment after insertion of R is smallest
increase this rectangle if necessary and insert R
At a leaf:
if there is space, insert, otherwise Split Node

20. Split Node
Divide the M+1 rectangles into two groups, each with at least m and at most M rectangles
Make a node for each group, with the rectangles and corresponding subtrees as entries
Hang the two new nodes under the parent node in the place of the overfull node; determine the new MBRs (if the root was overfull, make a new root with two child nodes)
If the parent has M+1 children, repeat Split Node with this parent

21. Split Node, example
New MBRs

22. Strategies for Split Node, I
Determine R1 and R2 with largest MBR: the seeds for sets S1 and S2
While |S1| , |S2| < M - m and not all rectangles distributed:
Take not yet distributed rectangle Rj , add to the set whose MBR increases least
Linear R-tree of Guttman, 1984

23. Example Split Node I

24. Strategies for Split Node, II
Determine R1 and R2 with largest area(MBR) -area(R1) - area(R2): the seeds for sets S1 and S2
While |S1| , |S2| < M - m and not all distributed:
Determine of every not yet distributed rectangle Rj : d1 = area increment of MBR(S1  Rj) (* w.r.t. MBR(S1) *) d2 = area increment of MBR(S2  Rj) (* w.r.t. MBR(S2) *)
Choose Ri with maximal | d1 - d2 | ; add it to the set with smallest area increment
Quadratic R-tree of Guttman, 1984

25. Example Split Node, II

26. Strategies for Split Node, III
Determine R1 and R2 with largest area(MBR) - area(R1) - area(R2): the seeds for sets S1 and S2 (* same as quadratic R-tree *)
Determine axis with largest normalized separation of R1 and R2 ( x-separation / x-range of MBR(R1  R2), or y-separation / y-range of MBR(R1  R2) )
Sort rectangles according to that axis (lower left corner) and split evenly in subsets of size (M+1) / 2
Greene’s split, 1989

27. Example Split Node, III
Y-axis has largest normalized
separation

28. Deletion from an R-tree
Find the leaf (node) and delete object; determine new (possibly smaller) MBR
If the node is too empty (< m entries):
delete the node recursively at its parent
insert all entries of the deleted node into the R-tree
Note: Insertions of entries/subtrees always occurs at the level where it came from

33. Insert as rectangle on middle level

34. Insert in a leaf
object

35. R*-trees
Experimentally determined measures for choices at insertion (Choose Subtree, Split Node)
Experimentally determined algorithms for:
Choose Subtree
Split Node

36. R*-trees; Choose Subtree
At nodes directly above leaves: Choose entry (rectangle) with smallest overlap-increase
At higher nodes: Choose entry (rectangle) with smallest area-increase (same as before)
R ,…, R are the entry rectangles 1 p

37. R*-trees; Split Node Determine split axis:
For both the x- and the y-axis:
sort the rectangles by smallest and largest coordinate
determine the M - 2m + 2 allowed distributions into two groups
determine for each: the perimeter of the two MBRs
add the M - 2m + 2 perimeter lengths
Choose the axis with smallest sum of perimeters m m
M - 2m + 1

38. R*-trees; Split Node Determine split index (given the split axis):
Choose the distribution, among the M - 2m + 2, with the smallest area of intersection of the MBRs

39. Nearest neighbor queries
An R-tree can be used for nearest neighbor queries
The idea is to perform a DFS, maintain the closest object so far and use the distance for pruning
pruned
closest object so far
queried

40. 1 4 2 5 3

41. Forced reinsert
Build R-tree by repeated insertion: first inserted rectangles are possibly badly placed
Experiment:
make R-tree by inserting rectangles
again, but afterwards, delete the first inserted and insert them again!
Search time improvement of 20-50% !

42. Summary R-trees
Versatile 2-dimensional search tree (referred to as: indexing structure, or spatial index)
Some variant used in most GIS
Well-suited for windowing, point location, intersection, and nearest neighbor queries
Heuristic structure, no order bounds ( O(..) )
Dynamic; insertions and deletions supported
Tree with higher degree: well-suited for background storage (short search paths)