Computational Geometry: Spatial Data Structures, Voronoi Diagram and Delaunay Triangulation§

author:	David Coeurjolly

Point Set Spatial Data Structures§

Range Queries§

Problem setting

Define a structure on point set to efficiently answer to range queries: given a range, output the set of points belonging to it

Dimension 1

Set of points in a line $S=\{x_i\}$
Interval queries $[l,r]$ , returns $\{x_j\}\subset S$ with $x_j\in[l,r]$
Data structure: balanced binary search tree

$\Rightarrow$ $O(n)$ storage and $O(n\log n)$ construction time, then $O(k + \log(n))$ per query ( $k$ is number of reported points)

Regular but recursive spatial decomposition: QuadTree/OctTree§

Idea

Regular $2^d$ -ary tree
Recursive construction and data placed to leaves
Usually, one datum per leaf
$\Rightarrow$ depth depending in the min distance between two points
$\Rightarrow$ could be unbalanced
$\Rightarrow$ fast bottom-up/top-down construction algorithms

Implementation: Pointerless Trees§

Idea

Pointer based implementation is quite expensive (4 or 8 pointer per tree node)
$\Rightarrow$ Binary encoding (Morton codes) and implicit hierarchical structure

Implementation: Pointerless Trees (again)§

Ctd.

At construction, when we increase the depths, we just add 2 bits (2D) or 3 bits (3D) suffixes
One datum = one binary code
Localizing a point = bit code interleaving on binary representation of point coordinates
Final encoding: hash map on binary morton codes

$x = x_1x_2\ldots x_m\\ y = y_1y_2\ldots x_m\\ morton_l(x,y) = \bar{0}1 y_1x_1y_2x_2\ldots y_lx_l$

QuadTree/Octree conclusion§

Nice pointerless encoding
Many operations on quadtree/octree (sibling nodes, ….)
Data can be stored in intermediate nodes

… but

Bad point distributions lead to unbalanced structures
Worst case quadratic time construction (naive top-down)

Kd-Tree structure§

Description

Hierarchical structure
Recursive construction and we use axis parallel constraints to subdivide the space

Pseudo-code in 2D:

BuildKdTree(S, depth)
  if |S|=1
     return a leaf containing this point

  if depth is even
     Let l be the vertical line with median x-coordinate
     Split S w.r.t. l -> S1 and S2

  if depth is odd
     Let l be the horizontal line with median y-coordinate
     Split S w.r.t. l -> S1 and S2

  SubTree1 = BuildKdTree(S1,depth + 1)
  SubTree2 = BuildKdTree(S2,depth + 1)

  return Tree(l , SubTree1, SubTree2)

Computational cost§

Median computation of a vector of scalars $O(n)$
Recursive cost $T(n) = O(n) + 2T(n/2)$

$\Rightarrow$ KdTree construction in $O(n \log n)$ , $O(n)$ storage

Example <Cf board>

FYI: Median of a scalar vector§

Random algorithm

QuickSelect(A, k)
  Pick a pivot element p randomly from A
  Split A into LESS and GREATER sets
  L =  number of elements in the LESS array
  if (L == k-1)
     return p;

  if (L > k-1)
     return QuickSelect(LESS, k)

  if (L < k-1)
     return QuickSelect(GREATER, k - L - 1)

$\Rightarrow$ randomized O(n) expected time to get the k-rank element

FYI: Median of a scalar vector§

Deterministic algorithm

QuickSelect(A, k)
  Group the array into n/5 groups of size 5
  Find the median of each group  //Let M be the set of medians

  p = QuickSelect(M,k)  // median of the medians

  Split A into LESS and GREATER sets
  L =  number of elements in the LESS array
  if (L == k-1)
     return p;

  if (L > k-1)
     return QuickSelect(LESS, k)

  if (L < k-1)
     return QuickSelect(GREATER, k - L - 1)

$\Rightarrow$ Deterministic O(n) time to get the k-rank element (details skipped but I encourage you to have a look!)

KdTree: Advantages/Drawbacks§

Balanced structure (no dependency on the point distribution)
Binary tree: during the descent, we just have to compare one coordinate to select the subtree
Rectangular range query in $O(\sqrt{n} + k)$

Range query in kd-Tree§

Algo

RangeQueryKdTree(node, Range)

  //Stop
  if node is a leaf
     return the p point in node if p in Range

  //left child
  if region(leftChild(node)) is fully contained in Range
     return all points in the subtree leftChild(node) //(A)
  else
     if region(leftChild(node)) intersects Range
       return RangeQueryKdTree( leftChild(node) , Range)

  //right child
  if region(rightChild(node)) is fully contained in Range
     return all points in the subtree rightChild(node) //(B)
  else
     if region(rightChild(node)) intersects Range
       return RangeQueryKdTree( rightChild(node) , Range)

Hints

Cases (A) and (B) are in $O(k)$
We need to bound the number of visited nodes which are not in the output (= number of nodes with line intersection Range)

Proof Ctd.§

We focus on the number of regions intersected by any vertical line $l$ (left/right interval in Range)
Let $Q(n)$ be the number of such regions in a kdTree with n vertex whose root is a vertical line

Obs1 If $l$ is vertical and the constraint of the root is vertical, $l$ only crosses one of the root children regions

Obs2 If $l$ is vertical and the constraint of the root is horizontal, $l$ crosses both root children regions

$\Rightarrow$ two step recurrence (sub-trees of depth 2 have n/4 points)

$Q(n) = 2 + 2Q(n/4)$

$\Rightarrow$ $Q(n) = O(\sqrt{n})\quad \Box$

Thm.

Range tree structure in dimension d with $O(n\log^{d-1}n)$ storage constructed in $O(n\log^{d-1}n)$ can answer to hyperrectangular range queries in $O(\log^dn + k)$ .