SUN_source_code_v1/code/vlfeat-0.9.5/vl/kdtree.c

/** @file   kdtree.c
 ** @brief  KD-tree - Definition
 ** @author Andrea Vedaldi
 **/

/* AUTORIGHTS
 Copyright (C) 2007-09 Andrea Vedaldi and Brian Fulkerson

 This file is part of VLFeat, available in the terms of the GNU
 General Public License version 2.
 */

#include "kdtree.h"
#include "generic.h"
#include "random.h"
#include "mathop.h"

#include <stdlib.h>

/** @file kdtree.h
 **
 ** ::VlKDTree implements a KD-tree object data structure useful to
 ** index moderately dimensional vector spaces. It can be used to
 ** quickly match two groups of feature descriptors.
 **
 ** - @ref kdtree-overview
 ** - @ref kdtree-tech
 **
 ** @section kdtree-overview Overview
 **
 ** To create a ::VlKDForest object use ::vl_kdforest_new specifying
 ** the dimensionality of the data and the number of trees in the
 ** forest.  With one tree only, the algorithm is analogous to [1]
 ** (best-bin KDTree). Multiple trees correspond to the randomized
 ** KDTree forest as in [2,3].
 **
 ** To let the KD-tree index some data use ::vl_kdforest_build. Note
 ** that for efficiency KD-tree does not copy the data but retains a
 ** pointer to it. Therefore the data must exist (and not change)
 ** until the KD-tree is deleted. To delete the KD-tree object, use
 ** ::vl_kdforest_delete.
 **
 ** To find the N nearest neighbors to a query point use
 ** ::vl_kdforest_query. To set a maximum number of comparisons per
 ** query and calculate approximate nearest neighbors use
 ** ::vl_kdforest_set_max_num_comparisons.
 **
 ** @section kdtree-tech Technical details
 ** @sa @ref kdtree-references
 **
 ** KDTree implements the best-bin-first kd-tree of [1]. Given a set
 ** of points @f$ x_1,\dots,x_n \in \mathbb{R}^d @f$, the algorithm
 ** recursively partitions the @e d dimensional Euclidean space @f$
 ** \mathbb{R}^d @f$ into (hyper-) rectangles.
 **
 ** Partitions are organized into a binary tree with the root
 ** corresponding to the whole space @f$ \mathbb{R}^d @f$. The
 ** algorithm refines each partition by dividing it into two halves by
 ** thresholding along a given dimension. Both the splitting dimension
 ** and the threshold are determined as a statistic of the data points
 ** contained in the partition. The splitting dimension is the one
 ** which has largest sample variance and the splitting threshold is
 ** either the sample mean or the median. Leaves are atomic partitions
 ** and they contain a list of zero or more data points (typically
 ** one).
 **
 ** Querying amounts to finding the N data points closer to a given
 ** query point @f$ x_q \in \mathbb{R}^d @f$. This is done by
 ** branch-and-bound. A search state is an active partition (initially
 ** the root) and it is weighed by the lower bound on the distance of
 ** any point in the partition and the query point. Such a lower bound
 ** is trivial to compute because partitions are hyper-rectangles.
 **
 ** @section kdtree-references References
 **
 ** [1] J. S. Beis and D. G. Lowe. Shape indexing using approximate
 ** nearest-neighbour search in high-dimensional spaces. In
 ** Proc. CVPR, 1997.
 **
 ** [2] C. Silpa-Anan and R. Hartley. Optimised KD-trees for fast
 ** image descriptor matching. In Proc. CVPR, 2008.
 **
 ** [3] M. Muja and D. G. Lowe. Fast approximate nearest neighbors
 ** with automatic algorithmic configuration. In Proc. VISAPP, 2009.
 **/

#define NAME vl_kdforest_search_heap
#define T VlKDForestSearchState
#define CMP(x,y) (x->distanceLowerBound - y->distanceLowerBound)
#include "heap-t.h"
#undef CMP
#undef T
#undef NAME

#define NAME vl_kdtree_split_heap
#define T VlKDTreeSplitDimension
#define CMP(x,y) (x->variance - y->variance)
#include "heap-t.h"
#undef CMP
#undef T
#undef NAME

#define NAME vl_kdforest_neighbor_heap
#define T VlKDForestNeighbor
#define CMP(x,y) (y->distance - x->distance)
#include "heap-t.h"
#undef CMP
#undef T
#undef NAME

/** ------------------------------------------------------------------
 ** @internal
 ** @brief Allocate a new node from the tree pool
 **
 **/

int unsigned
vl_kdtree_node_new (VlKDTree * tree, int unsigned parentIndex)
{
  VlKDTreeNode * node = NULL ;
  int unsigned nodeIndex = tree->numUsedNodes ;
  tree -> numUsedNodes += 1 ;

  assert (tree->numUsedNodes <= tree->numAllocatedNodes) ;

  node = tree->nodes + nodeIndex ;
  node -> parent = parentIndex ;
  node -> lowerChild = 0 ;
  node -> upperChild = 0 ;
  node -> splitDimension = 0 ;
  node -> splitThreshold = 0 ;
  return nodeIndex ;
}

/** ------------------------------------------------------------------
 ** @internal
 ** @brief Compare KDTree index entries for sorting
 **/

static int
vl_kdtree_compare_index_entries (void const * a,
                                 void const * b)
{
  float delta =
   ((VlKDTreeDataIndexEntry const*)a) -> value -
   ((VlKDTreeDataIndexEntry const*)b) -> value ;
  if (delta < 0) return -1 ;
  if (delta > 0) return +1 ;
  return 0 ;
}

/** ------------------------------------------------------------------
 ** @internal
 ** @brief Build KDTree recursively
 ** @param tree KDTree object.
 ** @param nodeIndex node to process.
 ** @param dataBegin begin of data for this node.
 ** @param dataEnd end of data for this node.
 ** @param depth depth of this node.
 **/

static void
vl_kdtree_build_recursively
(VlKDForest * forest,
 VlKDTree * tree, unsigned int nodeIndex,
 unsigned int dataBegin, unsigned int dataEnd,
 unsigned int depth)
{
  int d, i, medianIndex, splitIndex ;
  VlKDTreeNode * node = tree->nodes + nodeIndex ;
  VlKDTreeSplitDimension * splitDimension ;

  /* base case: there is only one data point */
  if (dataEnd - dataBegin <= 1) {
    if (tree->depth < depth) tree->depth = depth ;
    node->lowerChild = - dataBegin - 1;
    node->upperChild = - dataEnd - 1 ;
    return ;
  }

  /* compute the dimension with largest variance */
  forest->splitHeapNumNodes = 0 ;
  for (d = 0 ; d < forest->numDimensions ; ++ d) {
    float mean = 0 ; /* unnormalized */
    float secondMoment = 0 ;
    float variance = 0 ;
    for (i = dataBegin ; i < dataEnd ; ++ i) {
      int di = tree -> dataIndex [i] .index ;
      float const datum = forest->data [di * forest->numDimensions + d] ;
      mean += datum ;
      secondMoment += datum * datum ;
    }
    mean /= (dataEnd - dataBegin) ;
    secondMoment /= (dataEnd - dataBegin) ;
    variance = secondMoment - mean * mean ;

    /* keep splitHeapSize most varying dimensions */
    if (forest->splitHeapNumNodes < forest->splitHeapSize) {
      VlKDTreeSplitDimension * splitDimension
        = forest->splitHeapArray + forest->splitHeapNumNodes ;
      splitDimension->dimension = d ;
      splitDimension->mean = mean ;
      splitDimension->variance = variance ;
      vl_kdtree_split_heap_push (forest->splitHeapArray, &forest->splitHeapNumNodes) ;
    } else {
      VlKDTreeSplitDimension * splitDimension = forest->splitHeapArray + 0 ;
      if (splitDimension->variance < variance) {
        splitDimension->dimension = d ;
        splitDimension->mean = mean ;
        splitDimension->variance = variance ;
        vl_kdtree_split_heap_update (forest->splitHeapArray, forest->splitHeapNumNodes, 0) ;
      }
    }
  }

  /* toss a dice to decide the splitting dimension */
  splitDimension = forest->splitHeapArray
  + (vl_rand_uint32() % VL_MIN(forest->splitHeapSize, forest->splitHeapNumNodes)) ;

  /* additional base case: variance is equal to 0 (overlapping points) */
  if (splitDimension->variance == 0) {
    node->lowerChild = - dataBegin - 1 ;
    node->upperChild = - dataEnd - 1 ;
    return ;
  }
  node->splitDimension = splitDimension->dimension ;

  /* sort data along largest variance dimension */
  for (i = dataBegin ; i < dataEnd ; ++ i) {
    int di = tree->dataIndex [i] .index ;
    float datum = forest->data [di * forest->numDimensions + splitDimension->dimension] ;
    tree->dataIndex [i] .value = datum ;
  }
  qsort (tree->dataIndex + dataBegin,
         dataEnd - dataBegin,
         sizeof (VlKDTreeDataIndexEntry),
         vl_kdtree_compare_index_entries) ;

  /* determine split threshold */
  switch (forest->thresholdingMethod) {
    case VL_KDTREE_MEAN :
      node->splitThreshold = splitDimension->mean ;
      for (splitIndex = dataBegin ;
           splitIndex < dataEnd && tree->dataIndex[splitIndex].value <= node->splitThreshold ;
           ++ splitIndex) ;
      splitIndex -= 1 ;
      /* If the mean does not provide a proper partition, fall back to
       * median. This usually happens if all points have the same
       * value and the zero variance test fails for numerical accuracy
       * reasons. In this case, also due to numerical accuracy, the
       * mean value can be smaller, equal, or larger than all
       * points. */
      if (dataBegin <= splitIndex && splitIndex + 1 < dataEnd) break ;

    case VL_KDTREE_MEDIAN :
      medianIndex = (dataBegin + dataEnd - 1) / 2 ;
      splitIndex = medianIndex ;
      node -> splitThreshold = tree->dataIndex[medianIndex].value ;
      break ;

    default:
      assert(0) ;
  }

  /* divide subparts */
  node->lowerChild = vl_kdtree_node_new (tree, nodeIndex) ;
  vl_kdtree_build_recursively (forest, tree, node->lowerChild, dataBegin, splitIndex + 1, depth + 1) ;

  node->upperChild = vl_kdtree_node_new (tree, nodeIndex) ;
  vl_kdtree_build_recursively (forest, tree, node->upperChild, splitIndex + 1, dataEnd, depth + 1) ;
}

/** ------------------------------------------------------------------
 ** @brief Create new KDForest object
 ** @param numDimensions data dimensionality.
 ** @param numTrees number of trees in the forest.
 ** @return new KDForest.
 **/

VL_EXPORT
VlKDForest *
vl_kdforest_new (int unsigned numDimensions, int unsigned numTrees)
{
  VlKDForest * self = vl_malloc (sizeof(VlKDForest)) ;

  self -> numData = 0 ;
  self -> data = 0 ;
  self -> numDimensions = numDimensions ;
  self -> numTrees = numTrees ;
  self -> trees = 0 ;
  self -> thresholdingMethod = VL_KDTREE_MEDIAN ;
  self -> splitHeapSize = (numTrees == 1) ? 1 : VL_KDTREE_SPLIT_HEALP_SIZE ;
  self -> splitHeapNumNodes = 0 ;

  self -> searchHeapArray = 0 ;
  self -> searchHeapNumNodes = 0 ;


  self -> searchMaxNumComparisons = 0 ;
  self -> searchIdBook = 0 ;
  self -> searchId = 0 ;

  return self ;
}

/** ------------------------------------------------------------------
 ** @brief Delete KDForest object
 ** @param tree KDForest object to delete
 ** @sa ::vl_kdforest_new
 **/

VL_EXPORT void
vl_kdforest_delete (VlKDForest * self)
{
  int ti ;
  if (self->searchIdBook) vl_free (self->searchIdBook) ;
  if (self->trees) {
    for (ti = 0 ; ti < self->numTrees ; ++ ti) {
      if (self->trees[ti]) {
        if (self->trees[ti]->nodes) vl_free (self->trees[ti]->nodes) ;
        if (self->trees[ti]->dataIndex) vl_free (self->trees[ti]->dataIndex) ;
      }
    }
    vl_free (self->trees) ;
  }
  vl_free (self) ;
}

/** ------------------------------------------------------------------
 ** @brief Build KDTree from data
 ** @param tree KDTree object
 ** @param numData number of data points.
 ** @param data pointer to the data.
 **
 ** The function builds the KDTree by processing the data @a data. For
 ** efficiency, KDTree does not copy the data, but retains a pointer to it.
 ** Therefore the data must survive (and not change) until the KDTree
 ** is deleted.
 **/

VL_EXPORT void
vl_kdforest_build (VlKDForest * self, int numData, float const * data)
{
  int di, ti ;

  /* need to check: if alredy built, clean first */
  self->data = data ;
  self->numData = numData ;
  self->trees = vl_malloc (sizeof(VlKDTree*) * self->numTrees) ;

  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
    self->trees[ti] = vl_malloc (sizeof(VlKDTree)) ;
    self->trees[ti]->dataIndex = vl_malloc (sizeof(VlKDTreeDataIndexEntry) * self->numData) ;
    for (di = 0 ; di < self->numData ; ++ di) {
      self->trees[ti]->dataIndex[di].index = di ;
    }
    self->trees[ti]->numUsedNodes = 0 ;
    /* num. nodes of a complete binary tree with numData leaves */
    self->trees[ti]->numAllocatedNodes = 2 * self->numData - 1 ;
    self->trees[ti]->nodes = vl_malloc (sizeof(VlKDTreeNode) * self->trees[ti]->numAllocatedNodes) ;
    self->trees[ti]->depth = 0 ;
    vl_kdtree_build_recursively (self, self->trees[ti],
                                 vl_kdtree_node_new(self->trees[ti], 0), 0,
                                 self->numData, 0) ;
  }
}

/** ------------------------------------------------------------------
 ** @internal @brief
 **/

VL_INLINE
float calc_dist2 (float const * a, float const * b, int unsigned N)
{
  float acc = 0 ;
  float d0, d1, d2, d3 ;
  float const * age = a + N - 3 ;
  float const * ae = a + N ;

  while (a < age) {
    d0 = *a++ - *b++ ;
    d1 = *a++ - *b++ ;
    d2 = *a++ - *b++ ;
    d3 = *a++ - *b++ ;
    acc += d0 * d0 ;
    acc += d1 * d1 ;
    acc += d2 * d2 ;
    acc += d3 * d3 ;
  }
  while (a < ae) {
    d0 = *a++ - *b++ ;
    acc += d0 * d0 ;
  }
  return acc ;
}

/** ------------------------------------------------------------------
 ** @internal @brief
 **/

VL_EXPORT int
vl_kdforest_query_recursively (VlKDForest  * self,
                               VlKDTree * tree,
                               int unsigned nodeIndex,
                               VlKDForestNeighbor * neighbors,
                               int unsigned numNeighbors,
                               int unsigned * numAddedNeighbors,
                               float dist,
                               float const * query)
{
  VlKDTreeNode const * node = tree->nodes + nodeIndex ;
  int unsigned i = node->splitDimension ;
  int nextChild, saveChild ;
  float delta, saveDist ;
  float x = query [i] ;
  float x1 = node->lowerBound ;
  float x2 = node->splitThreshold ;
  float x3 = node->upperBound ;
  VlKDForestSearchState * searchState ;

  self->searchNumRecursions ++ ;

  /* base case: this is a leaf node */
  if (node->lowerChild < 0) {
    int begin = - node->lowerChild - 1 ;
    int end   = - node->upperChild - 1 ;
    int iter ;

    for (iter = begin ;
         iter < end &&
         (self->searchMaxNumComparisons == 0 ||
          self->searchNumComparisons < self->searchMaxNumComparisons) ;
         ++ iter) {

      int unsigned di = tree->dataIndex [iter].index ;
      float const * datum = self->data + di * self->numDimensions ;

      /* multiple KDTrees share the database points and we must avoid
       * adding the same point twice */
      if (self->searchIdBook [di] == self->searchId) continue ;
      self->searchIdBook [di] = self->searchId ;

      /* compare the query to this point */
      dist = calc_dist2 (query, datum, self->numDimensions) ;
      self->searchNumComparisons += 1 ;

      /* see if it should be added to the result set */
      if (*numAddedNeighbors < numNeighbors) {
        VlKDForestNeighbor * newNeighbor = neighbors + *numAddedNeighbors ;
        newNeighbor->index = di ;
        newNeighbor->distance = dist ;
        vl_kdforest_neighbor_heap_push (neighbors, numAddedNeighbors) ;
      } else {
        VlKDForestNeighbor * largestNeighbor = neighbors + 0 ;
        if (largestNeighbor->distance > dist) {
          largestNeighbor->index = di ;
          largestNeighbor->distance = dist ;
          vl_kdforest_neighbor_heap_update (neighbors, *numAddedNeighbors, 0) ;
        }
      }
    } /* next data point */

    return nodeIndex ;
  }

#if 0
  assert (x1 <= x2 && x2 <= x3) ;
  assert (node->lowerChild >= 0) ;
  assert (node->upperChild >= 0) ;
#endif

  /*
   *   x1  x2 x3
   * x (---|---]
   *   (--x|---]
   *   (---|x--]
   *   (---|---] x
   */

  delta = x - x2 ;
  saveDist = dist + delta*delta ;

  if (x <= x2) {
    nextChild = node->lowerChild ;
    saveChild = node->upperChild ;
    if (x <= x1) {
      delta = x - x1 ;
      saveDist -= delta*delta ;
    }
  } else {
    nextChild = node->upperChild ;
    saveChild = node->lowerChild ;
    if (x > x3) {
      delta = x - x3 ;
      saveDist -= delta*delta ;
    }
  }

  if (*numAddedNeighbors < numNeighbors || neighbors[0].distance > saveDist) {
    searchState = self->searchHeapArray + self->searchHeapNumNodes ;
    searchState->tree = tree ;
    searchState->nodeIndex = saveChild ;
    searchState->distanceLowerBound = saveDist ;
    vl_kdforest_search_heap_push (self->searchHeapArray,
                                  &self->searchHeapNumNodes) ;
  }

  return vl_kdforest_query_recursively (self,
                                        tree,
                                        nextChild,
                                        neighbors,
                                        numNeighbors,
                                        numAddedNeighbors,
                                        dist,
                                        query) ;
}

/** ------------------------------------------------------------------
 ** @internal @brief Compute tree bounds recursively
 ** @param self KDTree object instance.
 ** @param nodeIndex node index to start from.
 ** @param searchBounds 2 x numDimension array of bounds.
 **/

static void
vl_kdtree_calc_bounds_recursively (VlKDTree * tree,
                                   int unsigned nodeIndex, float * searchBounds)
{
  VlKDTreeNode * node = tree->nodes + nodeIndex ;
  int unsigned i = node->splitDimension ;
  float t = node->splitThreshold ;

  node->lowerBound = searchBounds [2 * i + 0] ;
  node->upperBound = searchBounds [2 * i + 1] ;

  if (node->lowerChild > 0) {
    searchBounds [2 * i + 1] = t ;
    vl_kdtree_calc_bounds_recursively (tree, node->lowerChild, searchBounds) ;
    searchBounds [2 * i + 1] = node->upperBound ;
  }
  if (node->upperChild > 0) {
    searchBounds [2 * i + 0] = t ;
    vl_kdtree_calc_bounds_recursively (tree, node->upperChild, searchBounds) ;
    searchBounds [2 * i + 0] = node->lowerBound ;
  }
}

/** ------------------------------------------------------------------
 ** @brief Query operation
 ** @param self KDTree object instance.
 ** @param neighbors list of nearest neighbors found (output).
 ** @param numNeighbors number of nearest neighbors to find.
 ** @param query query point.
 ** @return number of tree leaves visited.
 **
 ** A neighbor is represented by an instance of the structure
 ** ::VlKDForestNeighbor. Each entry contains the index of the
 ** neighbor (this is an index into the KDTree data) and its distance
 ** to the query point. Neighbors are sorted by increasing distance.
 **/

VL_EXPORT int
vl_kdforest_query (VlKDForest * self,
                   VlKDForestNeighbor * neighbors,
                   int unsigned numNeighbors,
                   float const * query)
{
  int i, ti ;
  vl_bool exactSearch = (self->searchMaxNumComparisons == 0) ;
  VlKDForestSearchState * searchState  ;
  int unsigned numAddedNeighbors = 0 ;

  assert (neighbors) ;
  assert (numNeighbors > 0) ;
  assert (query) ;

  /* this number is used to differentiate a query from the next */
  self -> searchId += 1 ;
  self -> searchNumRecursions = 0 ;

  if (! self -> searchHeapArray) {
    /* count number of tree nodes */
    /* add support structures */
    int maxNumNodes = 0 ;
    for (ti = 0 ; ti < self->numTrees ; ++ti) {
      maxNumNodes += self->trees[ti]->numUsedNodes ;
    }
    self -> searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * maxNumNodes) ;
    self -> searchIdBook = vl_calloc (sizeof(unsigned int), self->numData) ;

    for (ti = 0 ; ti < self->numTrees ; ++ti) {
      float * searchBounds = vl_malloc(sizeof(float) * 2 * self->numDimensions) ;
      float * iter = searchBounds  ;
      float * end = iter + 2 * self->numDimensions ;
      while (iter < end) {
        *iter++ = - VL_INFINITY_F ;
        *iter++ = + VL_INFINITY_F ;
      }
      vl_kdtree_calc_bounds_recursively (self->trees[ti], 0, searchBounds) ;
      vl_free (searchBounds) ;
    }
  }

  self->searchNumComparisons = 0 ;
  self->searchNumSimplifications = 0 ;

  /* put the root node into the search heap */
  self->searchHeapNumNodes = 0 ;
  for (ti = 0 ; ti < self->numTrees ; ++ ti) {
    searchState = self->searchHeapArray + self->searchHeapNumNodes ;
    searchState -> tree = self->trees[ti] ;
    searchState -> nodeIndex = 0 ;
    searchState -> distanceLowerBound = 0 ;
    vl_kdforest_search_heap_push (self->searchHeapArray, &self->searchHeapNumNodes) ;
  }

  /* branch and bound */
  while (exactSearch || self->searchNumComparisons < self->searchMaxNumComparisons)
  {
    /* pop the next optimal search node */
    VlKDForestSearchState * searchState = vl_kdforest_search_heap_pop
      (self->searchHeapArray, &self->searchHeapNumNodes) ;

    /* break if search space completed */
    if (searchState == NULL) {
      break ;
    }

    /* break if no better solution may exist */
    if (numAddedNeighbors == numNeighbors &&
        neighbors[0].distance < searchState->distanceLowerBound) {
      self->searchNumSimplifications ++ ;
      break ;
    }

    vl_kdforest_query_recursively (self,
                                   searchState->tree,
                                   searchState->nodeIndex,
                                   neighbors,
                                   numNeighbors,
                                   &numAddedNeighbors,
                                   searchState->distanceLowerBound,
                                   query) ;
  }

  /* sort neighbors by increasing distance */
  for (i = numAddedNeighbors ;  i < numNeighbors ; ++ i) {
    neighbors[i].index = -1 ;
    neighbors[i].distance = VL_NAN_F ;
  }
  while (numAddedNeighbors) {
    vl_kdforest_neighbor_heap_pop (neighbors, &numAddedNeighbors) ;
  }

  return self->searchNumComparisons ;
}