405 lines
15 KiB
Text
405 lines
15 KiB
Text
//----------------------------------------------------------------------
|
|
// File: kd_tree.cpp
|
|
// Programmer: Sunil Arya and David Mount
|
|
// Description: Basic methods for kd-trees.
|
|
// Last modified: 01/04/05 (Version 1.0)
|
|
//----------------------------------------------------------------------
|
|
// Copyright (c) 1997-2005 University of Maryland and Sunil Arya and
|
|
// David Mount. All Rights Reserved.
|
|
//
|
|
// This software and related documentation is part of the Approximate
|
|
// Nearest Neighbor Library (ANN). This software is provided under
|
|
// the provisions of the Lesser GNU Public License (LGPL). See the
|
|
// file ../ReadMe.txt for further information.
|
|
//
|
|
// The University of Maryland (U.M.) and the authors make no
|
|
// representations about the suitability or fitness of this software for
|
|
// any purpose. It is provided "as is" without express or implied
|
|
// warranty.
|
|
//----------------------------------------------------------------------
|
|
// History:
|
|
// Revision 0.1 03/04/98
|
|
// Initial release
|
|
// Revision 1.0 04/01/05
|
|
// Increased aspect ratio bound (ANN_AR_TOOBIG) from 100 to 1000.
|
|
// Fixed leaf counts to count trivial leaves.
|
|
// Added optional pa, pi arguments to Skeleton kd_tree constructor
|
|
// for use in load constructor.
|
|
// Added annClose() to eliminate KD_TRIVIAL memory leak.
|
|
//----------------------------------------------------------------------
|
|
|
|
#include "kd_tree.h" // kd-tree declarations
|
|
#include "kd_split.h" // kd-tree splitting rules
|
|
#include "kd_util.h" // kd-tree utilities
|
|
#include <ANN/ANNperf.h> // performance evaluation
|
|
|
|
//----------------------------------------------------------------------
|
|
// Global data
|
|
//
|
|
// For some splitting rules, especially with small bucket sizes,
|
|
// it is possible to generate a large number of empty leaf nodes.
|
|
// To save storage we allocate a single trivial leaf node which
|
|
// contains no points. For messy coding reasons it is convenient
|
|
// to have it reference a trivial point index.
|
|
//
|
|
// KD_TRIVIAL is allocated when the first kd-tree is created. It
|
|
// must *never* deallocated (since it may be shared by more than
|
|
// one tree).
|
|
//----------------------------------------------------------------------
|
|
static int IDX_TRIVIAL[] = {0}; // trivial point index
|
|
ANNkd_leaf *KD_TRIVIAL = NULL; // trivial leaf node
|
|
|
|
//----------------------------------------------------------------------
|
|
// Printing the kd-tree
|
|
// These routines print a kd-tree in reverse inorder (high then
|
|
// root then low). (This is so that if you look at the output
|
|
// from the right side it appear from left to right in standard
|
|
// inorder.) When outputting leaves we output only the point
|
|
// indices rather than the point coordinates. There is an option
|
|
// to print the point coordinates separately.
|
|
//
|
|
// The tree printing routine calls the printing routines on the
|
|
// individual nodes of the tree, passing in the level or depth
|
|
// in the tree. The level in the tree is used to print indentation
|
|
// for readability.
|
|
//----------------------------------------------------------------------
|
|
|
|
void ANNkd_split::print( // print splitting node
|
|
int level, // depth of node in tree
|
|
ostream &out) // output stream
|
|
{
|
|
child[ANN_HI]->print(level+1, out); // print high child
|
|
out << " ";
|
|
for (int i = 0; i < level; i++) // print indentation
|
|
out << "..";
|
|
out << "Split cd=" << cut_dim << " cv=" << cut_val;
|
|
out << " lbnd=" << cd_bnds[ANN_LO];
|
|
out << " hbnd=" << cd_bnds[ANN_HI];
|
|
out << "\n";
|
|
child[ANN_LO]->print(level+1, out); // print low child
|
|
}
|
|
|
|
void ANNkd_leaf::print( // print leaf node
|
|
int level, // depth of node in tree
|
|
ostream &out) // output stream
|
|
{
|
|
|
|
out << " ";
|
|
for (int i = 0; i < level; i++) // print indentation
|
|
out << "..";
|
|
|
|
if (this == KD_TRIVIAL) { // canonical trivial leaf node
|
|
out << "Leaf (trivial)\n";
|
|
}
|
|
else{
|
|
out << "Leaf n=" << n_pts << " <";
|
|
for (int j = 0; j < n_pts; j++) {
|
|
out << bkt[j];
|
|
if (j < n_pts-1) out << ",";
|
|
}
|
|
out << ">\n";
|
|
}
|
|
}
|
|
|
|
void ANNkd_tree::Print( // print entire tree
|
|
ANNbool with_pts, // print points as well?
|
|
ostream &out) // output stream
|
|
{
|
|
out << "ANN Version " << ANNversion << "\n";
|
|
if (with_pts) { // print point coordinates
|
|
out << " Points:\n";
|
|
for (int i = 0; i < n_pts; i++) {
|
|
out << "\t" << i << ": ";
|
|
annPrintPt(pts[i], dim, out);
|
|
out << "\n";
|
|
}
|
|
}
|
|
if (root == NULL) // empty tree?
|
|
out << " Null tree.\n";
|
|
else {
|
|
root->print(0, out); // invoke printing at root
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// kd_tree statistics (for performance evaluation)
|
|
// This routine compute various statistics information for
|
|
// a kd-tree. It is used by the implementors for performance
|
|
// evaluation of the data structure.
|
|
//----------------------------------------------------------------------
|
|
|
|
#define MAX(a,b) ((a) > (b) ? (a) : (b))
|
|
|
|
void ANNkdStats::merge(const ANNkdStats &st) // merge stats from child
|
|
{
|
|
n_lf += st.n_lf; n_tl += st.n_tl;
|
|
n_spl += st.n_spl; n_shr += st.n_shr;
|
|
depth = MAX(depth, st.depth);
|
|
sum_ar += st.sum_ar;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Update statistics for nodes
|
|
//----------------------------------------------------------------------
|
|
|
|
const double ANN_AR_TOOBIG = 1000; // too big an aspect ratio
|
|
|
|
void ANNkd_leaf::getStats( // get subtree statistics
|
|
int dim, // dimension of space
|
|
ANNkdStats &st, // stats (modified)
|
|
ANNorthRect &bnd_box) // bounding box
|
|
{
|
|
st.reset();
|
|
st.n_lf = 1; // count this leaf
|
|
if (this == KD_TRIVIAL) st.n_tl = 1; // count trivial leaf
|
|
double ar = annAspectRatio(dim, bnd_box); // aspect ratio of leaf
|
|
// incr sum (ignore outliers)
|
|
st.sum_ar += float(ar < ANN_AR_TOOBIG ? ar : ANN_AR_TOOBIG);
|
|
}
|
|
|
|
void ANNkd_split::getStats( // get subtree statistics
|
|
int dim, // dimension of space
|
|
ANNkdStats &st, // stats (modified)
|
|
ANNorthRect &bnd_box) // bounding box
|
|
{
|
|
ANNkdStats ch_stats; // stats for children
|
|
// get stats for low child
|
|
ANNcoord hv = bnd_box.hi[cut_dim]; // save box bounds
|
|
bnd_box.hi[cut_dim] = cut_val; // upper bound for low child
|
|
ch_stats.reset(); // reset
|
|
child[ANN_LO]->getStats(dim, ch_stats, bnd_box);
|
|
st.merge(ch_stats); // merge them
|
|
bnd_box.hi[cut_dim] = hv; // restore bound
|
|
// get stats for high child
|
|
ANNcoord lv = bnd_box.lo[cut_dim]; // save box bounds
|
|
bnd_box.lo[cut_dim] = cut_val; // lower bound for high child
|
|
ch_stats.reset(); // reset
|
|
child[ANN_HI]->getStats(dim, ch_stats, bnd_box);
|
|
st.merge(ch_stats); // merge them
|
|
bnd_box.lo[cut_dim] = lv; // restore bound
|
|
|
|
st.depth++; // increment depth
|
|
st.n_spl++; // increment number of splits
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// getStats
|
|
// Collects a number of statistics related to kd_tree or
|
|
// bd_tree.
|
|
//----------------------------------------------------------------------
|
|
|
|
void ANNkd_tree::getStats( // get tree statistics
|
|
ANNkdStats &st) // stats (modified)
|
|
{
|
|
st.reset(dim, n_pts, bkt_size); // reset stats
|
|
// create bounding box
|
|
ANNorthRect bnd_box(dim, bnd_box_lo, bnd_box_hi);
|
|
if (root != NULL) { // if nonempty tree
|
|
root->getStats(dim, st, bnd_box); // get statistics
|
|
st.avg_ar = st.sum_ar / st.n_lf; // average leaf asp ratio
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// kd_tree destructor
|
|
// The destructor just frees the various elements that were
|
|
// allocated in the construction process.
|
|
//----------------------------------------------------------------------
|
|
|
|
ANNkd_tree::~ANNkd_tree() // tree destructor
|
|
{
|
|
if (root != NULL) delete root;
|
|
if (pidx != NULL) delete [] pidx;
|
|
if (bnd_box_lo != NULL) annDeallocPt(bnd_box_lo);
|
|
if (bnd_box_hi != NULL) annDeallocPt(bnd_box_hi);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// This is called with all use of ANN is finished. It eliminates the
|
|
// minor memory leak caused by the allocation of KD_TRIVIAL.
|
|
//----------------------------------------------------------------------
|
|
void annClose() // close use of ANN
|
|
{
|
|
if (KD_TRIVIAL != NULL) {
|
|
delete KD_TRIVIAL;
|
|
KD_TRIVIAL = NULL;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// kd_tree constructors
|
|
// There is a skeleton kd-tree constructor which sets up a
|
|
// trivial empty tree. The last optional argument allows
|
|
// the routine to be passed a point index array which is
|
|
// assumed to be of the proper size (n). Otherwise, one is
|
|
// allocated and initialized to the identity. Warning: In
|
|
// either case the destructor will deallocate this array.
|
|
//
|
|
// As a kludge, we need to allocate KD_TRIVIAL if one has not
|
|
// already been allocated. (This is because I'm too dumb to
|
|
// figure out how to cause a pointer to be allocated at load
|
|
// time.)
|
|
//----------------------------------------------------------------------
|
|
|
|
void ANNkd_tree::SkeletonTree( // construct skeleton tree
|
|
int n, // number of points
|
|
int dd, // dimension
|
|
int bs, // bucket size
|
|
ANNpointArray pa, // point array
|
|
ANNidxArray pi) // point indices
|
|
{
|
|
dim = dd; // initialize basic elements
|
|
n_pts = n;
|
|
bkt_size = bs;
|
|
pts = pa; // initialize points array
|
|
|
|
root = NULL; // no associated tree yet
|
|
|
|
if (pi == NULL) { // point indices provided?
|
|
pidx = new ANNidx[n]; // no, allocate space for point indices
|
|
for (int i = 0; i < n; i++) {
|
|
pidx[i] = i; // initially identity
|
|
}
|
|
}
|
|
else {
|
|
pidx = pi; // yes, use them
|
|
}
|
|
|
|
bnd_box_lo = bnd_box_hi = NULL; // bounding box is nonexistent
|
|
if (KD_TRIVIAL == NULL) // no trivial leaf node yet?
|
|
KD_TRIVIAL = new ANNkd_leaf(0, IDX_TRIVIAL); // allocate it
|
|
}
|
|
|
|
ANNkd_tree::ANNkd_tree( // basic constructor
|
|
int n, // number of points
|
|
int dd, // dimension
|
|
int bs) // bucket size
|
|
{ SkeletonTree(n, dd, bs); } // construct skeleton tree
|
|
|
|
//----------------------------------------------------------------------
|
|
// rkd_tree - recursive procedure to build a kd-tree
|
|
//
|
|
// Builds a kd-tree for points in pa as indexed through the
|
|
// array pidx[0..n-1] (typically a subarray of the array used in
|
|
// the top-level call). This routine permutes the array pidx,
|
|
// but does not alter pa[].
|
|
//
|
|
// The construction is based on a standard algorithm for constructing
|
|
// the kd-tree (see Friedman, Bentley, and Finkel, ``An algorithm for
|
|
// finding best matches in logarithmic expected time,'' ACM Transactions
|
|
// on Mathematical Software, 3(3):209-226, 1977). The procedure
|
|
// operates by a simple divide-and-conquer strategy, which determines
|
|
// an appropriate orthogonal cutting plane (see below), and splits
|
|
// the points. When the number of points falls below the bucket size,
|
|
// we simply store the points in a leaf node's bucket.
|
|
//
|
|
// One of the arguments is a pointer to a splitting routine,
|
|
// whose prototype is:
|
|
//
|
|
// void split(
|
|
// ANNpointArray pa, // complete point array
|
|
// ANNidxArray pidx, // point array (permuted on return)
|
|
// ANNorthRect &bnds, // bounds of current cell
|
|
// int n, // number of points
|
|
// int dim, // dimension of space
|
|
// int &cut_dim, // cutting dimension
|
|
// ANNcoord &cut_val, // cutting value
|
|
// int &n_lo) // no. of points on low side of cut
|
|
//
|
|
// This procedure selects a cutting dimension and cutting value,
|
|
// partitions pa about these values, and returns the number of
|
|
// points on the low side of the cut.
|
|
//----------------------------------------------------------------------
|
|
|
|
ANNkd_ptr rkd_tree( // recursive construction of kd-tree
|
|
ANNpointArray pa, // point array
|
|
ANNidxArray pidx, // point indices to store in subtree
|
|
int n, // number of points
|
|
int dim, // dimension of space
|
|
int bsp, // bucket space
|
|
ANNorthRect &bnd_box, // bounding box for current node
|
|
ANNkd_splitter splitter) // splitting routine
|
|
{
|
|
if (n <= bsp) { // n small, make a leaf node
|
|
if (n == 0) // empty leaf node
|
|
return KD_TRIVIAL; // return (canonical) empty leaf
|
|
else // construct the node and return
|
|
return new ANNkd_leaf(n, pidx);
|
|
}
|
|
else { // n large, make a splitting node
|
|
int cd; // cutting dimension
|
|
ANNcoord cv; // cutting value
|
|
int n_lo; // number on low side of cut
|
|
ANNkd_node *lo, *hi; // low and high children
|
|
|
|
// invoke splitting procedure
|
|
(*splitter)(pa, pidx, bnd_box, n, dim, cd, cv, n_lo);
|
|
|
|
ANNcoord lv = bnd_box.lo[cd]; // save bounds for cutting dimension
|
|
ANNcoord hv = bnd_box.hi[cd];
|
|
|
|
bnd_box.hi[cd] = cv; // modify bounds for left subtree
|
|
lo = rkd_tree( // build left subtree
|
|
pa, pidx, n_lo, // ...from pidx[0..n_lo-1]
|
|
dim, bsp, bnd_box, splitter);
|
|
bnd_box.hi[cd] = hv; // restore bounds
|
|
|
|
bnd_box.lo[cd] = cv; // modify bounds for right subtree
|
|
hi = rkd_tree( // build right subtree
|
|
pa, pidx + n_lo, n-n_lo,// ...from pidx[n_lo..n-1]
|
|
dim, bsp, bnd_box, splitter);
|
|
bnd_box.lo[cd] = lv; // restore bounds
|
|
|
|
// create the splitting node
|
|
ANNkd_split *ptr = new ANNkd_split(cd, cv, lv, hv, lo, hi);
|
|
|
|
return ptr; // return pointer to this node
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// kd-tree constructor
|
|
// This is the main constructor for kd-trees given a set of points.
|
|
// It first builds a skeleton tree, then computes the bounding box
|
|
// of the data points, and then invokes rkd_tree() to actually
|
|
// build the tree, passing it the appropriate splitting routine.
|
|
//----------------------------------------------------------------------
|
|
|
|
ANNkd_tree::ANNkd_tree( // construct from point array
|
|
ANNpointArray pa, // point array (with at least n pts)
|
|
int n, // number of points
|
|
int dd, // dimension
|
|
int bs, // bucket size
|
|
ANNsplitRule split) // splitting method
|
|
{
|
|
SkeletonTree(n, dd, bs); // set up the basic stuff
|
|
pts = pa; // where the points are
|
|
if (n == 0) return; // no points--no sweat
|
|
|
|
ANNorthRect bnd_box(dd); // bounding box for points
|
|
annEnclRect(pa, pidx, n, dd, bnd_box);// construct bounding rectangle
|
|
// copy to tree structure
|
|
bnd_box_lo = annCopyPt(dd, bnd_box.lo);
|
|
bnd_box_hi = annCopyPt(dd, bnd_box.hi);
|
|
|
|
switch (split) { // build by rule
|
|
case ANN_KD_STD: // standard kd-splitting rule
|
|
root = rkd_tree(pa, pidx, n, dd, bs, bnd_box, kd_split);
|
|
break;
|
|
case ANN_KD_MIDPT: // midpoint split
|
|
root = rkd_tree(pa, pidx, n, dd, bs, bnd_box, midpt_split);
|
|
break;
|
|
case ANN_KD_FAIR: // fair split
|
|
root = rkd_tree(pa, pidx, n, dd, bs, bnd_box, fair_split);
|
|
break;
|
|
case ANN_KD_SUGGEST: // best (in our opinion)
|
|
case ANN_KD_SL_MIDPT: // sliding midpoint split
|
|
root = rkd_tree(pa, pidx, n, dd, bs, bnd_box, sl_midpt_split);
|
|
break;
|
|
case ANN_KD_SL_FAIR: // sliding fair split
|
|
root = rkd_tree(pa, pidx, n, dd, bs, bnd_box, sl_fair_split);
|
|
break;
|
|
default:
|
|
annError("Illegal splitting method", ANNabort);
|
|
}
|
|
}
|