SGMatrix<int32_t> CLocallyLinearEmbedding::get_neighborhood_matrix(SGMatrix<float64_t> distance_matrix, int32_t k)
{
int32_t i;
int32_t N = distance_matrix.num_rows;
int32_t* neighborhood_matrix = SG_MALLOC(int32_t, N*k);
float64_t max_dist = SGVector<float64_t>::max(distance_matrix.matrix,N*N);
CoverTree<LLE_COVERTREE_POINT>* coverTree = new CoverTree<LLE_COVERTREE_POINT>(max_dist);
for (i=0; i<N; i++)
coverTree->insert(LLE_COVERTREE_POINT(i,distance_matrix));
for (i=0; i<N; i++)
{
std::vector<LLE_COVERTREE_POINT> neighbors =
coverTree->kNearestNeighbors(LLE_COVERTREE_POINT(i,distance_matrix),k+1);
for (std::size_t m=1; m<unsigned(k+1); m++)
neighborhood_matrix[i*k+m-1] = neighbors[m].point_index;
}
delete coverTree;
return SGMatrix<int32_t>(neighborhood_matrix,k,N);
}
SGMatrix<int32_t> CKernelLocallyLinearEmbedding::get_neighborhood_matrix(SGMatrix<float64_t> kernel_matrix, int32_t k)
{
int32_t i;
int32_t N = kernel_matrix.num_cols;
int32_t* neighborhood_matrix = SG_MALLOC(int32_t, N*k);
float64_t max_dist=0.0;
for (i=0; i<N; i++)
max_dist = CMath::max(max_dist,kernel_matrix[i*N+i]);
std::vector<KLLE_COVERTREE_POINT> vectors;
vectors.reserve(N);
for (i=0; i<N; i++)
vectors.push_back(KLLE_COVERTREE_POINT(i,kernel_matrix));
CoverTree<KLLE_COVERTREE_POINT>* coverTree = new CoverTree<KLLE_COVERTREE_POINT>(2.0*max_dist,vectors);
for (i=0; i<N; i++)
{
std::vector<KLLE_COVERTREE_POINT> neighbors =
coverTree->kNearestNeighbors(vectors[i],k+1);
ASSERT(neighbors.size()>=unsigned(k+1));
for (std::size_t m=1; m<unsigned(k+1); m++)
neighborhood_matrix[i*k+m-1] = neighbors[m].point_index;
}
delete coverTree;
return SGMatrix<int32_t>(neighborhood_matrix,k,N);
}
typename CoverTree<MetricType, StatisticType, MatType,
RootPointPolicy>::ElemType
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
MaxDistance(const CoverTree& other) const
{
return metric->Evaluate(dataset->col(point),
other.Dataset().col(other.Point())) +
furthestDescendantDistance + other.FurthestDescendantDistance();
}
typename CoverTree<MetricType, StatisticType, MatType,
RootPointPolicy>::ElemType
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
MinDistance(const CoverTree& other) const
{
// Every cover tree node will contain points up to base^(scale + 1) away.
return std::max(metric->Evaluate(dataset->col(point),
other.Dataset().col(other.Point())) -
furthestDescendantDistance - other.FurthestDescendantDistance(), 0.0);
}
math::RangeType<typename
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::ElemType>
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
RangeDistance(const CoverTree& other,
const ElemType distance) const
{
math::RangeType<ElemType> result;
result.Lo() = distance - furthestDescendantDistance -
other.FurthestDescendantDistance();
result.Hi() = distance + furthestDescendantDistance +
other.FurthestDescendantDistance();
return result;
}
math::RangeType<typename
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::ElemType>
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
RangeDistance(const CoverTree& other) const
{
const ElemType distance = metric->Evaluate(dataset->col(point),
other.Dataset().col(other.Point()));
math::RangeType<ElemType> result;
result.Lo() = distance - furthestDescendantDistance -
other.FurthestDescendantDistance();
result.Hi() = distance + furthestDescendantDistance +
other.FurthestDescendantDistance();
return result;
}
typename CoverTree<MetricType, StatisticType, MatType,
RootPointPolicy>::ElemType
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
MaxDistance(const CoverTree& other, const ElemType distance) const
{
// We already have the distance as evaluated by the metric.
return distance + furthestDescendantDistance +
other.FurthestDescendantDistance();
}
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::CoverTree(
const CoverTree& other) :
dataset((other.parent == NULL && other.localDataset) ?
new MatType(*other.dataset) : other.dataset),
point(other.point),
scale(other.scale),
base(other.base),
stat(other.stat),
numDescendants(other.numDescendants),
parent(other.parent),
parentDistance(other.parentDistance),
furthestDescendantDistance(other.furthestDescendantDistance),
localMetric(false),
localDataset(other.parent == NULL && other.localDataset),
metric(other.metric),
distanceComps(0)
{
// Copy each child by hand.
for (size_t i = 0; i < other.NumChildren(); ++i)
{
children.push_back(new CoverTree(other.Child(i)));
children[i]->Parent() = this;
}
// Propagate matrix, but only if we are the root.
if (parent == NULL && localDataset)
{
std::queue<CoverTree*> queue;
for (size_t i = 0; i < NumChildren(); ++i)
queue.push(children[i]);
while (!queue.empty())
{
CoverTree* node = queue.front();
queue.pop();
node->dataset = dataset;
for (size_t i = 0; i < node->NumChildren(); ++i)
queue.push(node->children[i]);
}
}
}
SGMatrix<int32_t> CStochasticProximityEmbedding::get_neighborhood_matrix(CDistance* distance, int32_t k, int32_t N, float64_t max_dist)
{
int32_t i;
int32_t* neighborhood_matrix = SG_MALLOC(int32_t, N*k);
CoverTree<SPE_COVERTREE_POINT>* coverTree = new CoverTree<SPE_COVERTREE_POINT>(max_dist);
for (i=0; i<N; i++)
coverTree->insert(SPE_COVERTREE_POINT(i, distance));
for (i=0; i<N; i++)
{
std::vector<SPE_COVERTREE_POINT> neighbors =
coverTree->kNearestNeighbors(SPE_COVERTREE_POINT(i, distance), k+1);
for (std::size_t m=1; m<unsigned(k+1); m++)
neighborhood_matrix[i*k+m-1] = neighbors[m].m_point_index;
}
delete coverTree;
return SGMatrix<int32_t>(neighborhood_matrix,k,N);
}
void CoverTree<MetricType, RootPointPolicy, StatisticType>::
DualTreeTraverser<RuleType>::Traverse(
CoverTree<MetricType, RootPointPolicy, StatisticType>& queryNode,
CoverTree<MetricType, RootPointPolicy, StatisticType>& referenceNode)
{
// Start by creating a map and adding the reference root node to it.
std::map<int, std::vector<DualCoverTreeMapEntry> > refMap;
DualCoverTreeMapEntry rootRefEntry;
rootRefEntry.referenceNode = &referenceNode;
// Perform the evaluation between the roots of either tree.
rootRefEntry.score = rule.Score(queryNode, referenceNode);
rootRefEntry.baseCase = rule.BaseCase(queryNode.Point(),
referenceNode.Point());
rootRefEntry.traversalInfo = rule.TraversalInfo();
refMap[referenceNode.Scale()].push_back(rootRefEntry);
Traverse(queryNode, refMap);
}
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::CoverTree(
const CoverTree& other) :
dataset((other.parent == NULL) ? new MatType(*other.dataset) : NULL),
point(other.point),
scale(other.scale),
base(other.base),
stat(other.stat),
numDescendants(other.numDescendants),
parent(other.parent),
parentDistance(other.parentDistance),
furthestDescendantDistance(other.furthestDescendantDistance),
localMetric(false),
localDataset(other.parent == NULL),
metric(other.metric),
distanceComps(0)
{
// Copy each child by hand.
for (size_t i = 0; i < other.NumChildren(); ++i)
{
children.push_back(new CoverTree(other.Child(i)));
children[i]->Parent() = this;
children[i]->dataset = this->dataset;
}
}
void CoverTree<MetricType, RootPointPolicy, StatisticType>::
DualTreeTraverser<RuleType>::PruneMap(
CoverTree& queryNode,
std::map<int, std::vector<DualCoverTreeMapEntry> >& referenceMap,
std::map<int, std::vector<DualCoverTreeMapEntry> >& childMap)
{
if (referenceMap.empty())
return; // Nothing to do.
// Copy the zero set first.
if ((*referenceMap.begin()).first == INT_MIN)
{
// Get a reference to the vector representing the entries at this scale.
std::vector<DualCoverTreeMapEntry>& scaleVector =
(*referenceMap.begin()).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
const int thisScale = (*referenceMap.begin()).first;
childMap[thisScale].reserve(scaleVector.size());
std::vector<DualCoverTreeMapEntry>& newScaleVector = childMap[thisScale];
// Loop over each entry in the vector.
for (size_t j = 0; j < scaleVector.size(); ++j)
{
const DualCoverTreeMapEntry& frame = scaleVector[j];
// First evaluate if we can prune without performing the base case.
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// Perform the actual scoring, after restoring the traversal info.
rule.TraversalInfo() = frame.traversalInfo;
double score = rule.Score(queryNode, *refNode);
if (score == DBL_MAX)
{
// Pruned. Move on.
++numPrunes;
continue;
}
// If it isn't pruned, we must evaluate the base case.
const double baseCase = rule.BaseCase(queryNode.Point(),
refNode->Point());
// Add to child map.
newScaleVector.push_back(frame);
newScaleVector.back().score = score;
newScaleVector.back().baseCase = baseCase;
newScaleVector.back().traversalInfo = rule.TraversalInfo();
}
// If we didn't add anything, then strike this vector from the map.
if (newScaleVector.size() == 0)
childMap.erase((*referenceMap.begin()).first);
}
typename std::map<int, std::vector<DualCoverTreeMapEntry> >::reverse_iterator
it = referenceMap.rbegin();
while ((it != referenceMap.rend()))
{
const int thisScale = (*it).first;
if (thisScale == INT_MIN) // We already did it.
break;
// Get a reference to the vector representing the entries at this scale.
std::vector<DualCoverTreeMapEntry>& scaleVector = (*it).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
childMap[thisScale].reserve(scaleVector.size());
std::vector<DualCoverTreeMapEntry>& newScaleVector = childMap[thisScale];
// Loop over each entry in the vector.
for (size_t j = 0; j < scaleVector.size(); ++j)
{
const DualCoverTreeMapEntry& frame = scaleVector[j];
// First evaluate if we can prune without performing the base case.
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// Perform the actual scoring, after restoring the traversal info.
rule.TraversalInfo() = frame.traversalInfo;
double score = rule.Score(queryNode, *refNode);
if (score == DBL_MAX)
{
// Pruned. Move on.
++numPrunes;
continue;
}
// If it isn't pruned, we must evaluate the base case.
const double baseCase = rule.BaseCase(queryNode.Point(),
refNode->Point());
// Add to child map.
newScaleVector.push_back(frame);
newScaleVector.back().score = score;
newScaleVector.back().baseCase = baseCase;
newScaleVector.back().traversalInfo = rule.TraversalInfo();
}
// If we didn't add anything, then strike this vector from the map.
if (newScaleVector.size() == 0)
childMap.erase((*it).first);
++it; // Advance to next scale.
}
}
void CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
SingleTreeTraverser<RuleType>::Traverse(
const size_t queryIndex,
CoverTree& referenceNode)
{
// This is a non-recursive implementation (which should be faster than a
// recursive implementation).
typedef CoverTreeMapEntry<MetricType, StatisticType, MatType, RootPointPolicy>
MapEntryType;
// We will use this map as a priority queue. Each key represents the scale,
// and then the vector is all the nodes in that scale which need to be
// investigated. Because no point in a scale can add a point in its own
// scale, we know that the vector for each scale is final when we get to it.
// In addition, map is organized in such a way that rbegin() will return the
// largest scale.
std::map<int, std::vector<MapEntryType> > mapQueue;
// Create the score for the children.
double rootChildScore = rule.Score(queryIndex, referenceNode);
if (rootChildScore == DBL_MAX)
{
numPrunes += referenceNode.NumChildren();
}
else
{
// Manually add the children of the first node.
// Often, a ruleset will return without doing any computation on cover trees
// using TreeTraits::FirstPointIsCentroid; this is an optimization that
// (theoretically) the compiler should get right.
double rootBaseCase = rule.BaseCase(queryIndex, referenceNode.Point());
// Don't add the self-leaf.
size_t i = 0;
if (referenceNode.Child(0).NumChildren() == 0)
{
++numPrunes;
i = 1;
}
for (/* i was set above. */; i < referenceNode.NumChildren(); ++i)
{
MapEntryType newFrame;
newFrame.node = &referenceNode.Child(i);
newFrame.score = rootChildScore;
newFrame.baseCase = rootBaseCase;
newFrame.parent = referenceNode.Point();
// Put it into the map.
mapQueue[newFrame.node->Scale()].push_back(newFrame);
}
}
// Now begin the iteration through the map, but only if it has anything in it.
if (mapQueue.empty())
return;
typename std::map<int, std::vector<MapEntryType> >::reverse_iterator rit =
mapQueue.rbegin();
// We will treat the leaves differently (below).
while ((*rit).first != INT_MIN)
{
// Get a reference to the current scale.
std::vector<MapEntryType>& scaleVector = (*rit).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
// Now loop over each element.
for (size_t i = 0; i < scaleVector.size(); ++i)
{
// Get a reference to the current element.
const MapEntryType& frame = scaleVector.at(i);
CoverTree* node = frame.node;
const double score = frame.score;
const size_t parent = frame.parent;
const size_t point = node->Point();
double baseCase = frame.baseCase;
// First we recalculate the score of this node to find if we can prune it.
if (rule.Rescore(queryIndex, *node, score) == DBL_MAX)
{
++numPrunes;
continue;
}
// Create the score for the children.
const double childScore = rule.Score(queryIndex, *node);
// Now if this childScore is DBL_MAX we can prune all children. In this
// recursion setup pruning is all or nothing for children.
if (childScore == DBL_MAX)
{
numPrunes += node->NumChildren();
continue;
}
// If we are a self-child, the base case has already been evaluated.
// Often, a ruleset will return without doing any computation on cover
// trees using TreeTraits::FirstPointIsCentroid; this is an optimization
// that (theoretically) the compiler should get right.
if (point != parent)
baseCase = rule.BaseCase(queryIndex, point);
// Don't add the self-leaf.
size_t j = 0;
if (node->Child(0).NumChildren() == 0)
{
++numPrunes;
j = 1;
}
for (/* j is already set. */; j < node->NumChildren(); ++j)
{
MapEntryType newFrame;
newFrame.node = &node->Child(j);
newFrame.score = childScore;
newFrame.baseCase = baseCase;
newFrame.parent = point;
mapQueue[newFrame.node->Scale()].push_back(newFrame);
}
}
// Now clear the memory for this scale; it isn't needed anymore.
mapQueue.erase((*rit).first);
}
// Now deal with the leaves.
for (size_t i = 0; i < mapQueue[INT_MIN].size(); ++i)
{
const MapEntryType& frame = mapQueue[INT_MIN].at(i);
CoverTree* node = frame.node;
const double score = frame.score;
const size_t point = node->Point();
// First, recalculate the score of this node to find if we can prune it.
double rescore = rule.Rescore(queryIndex, *node, score);
if (rescore == DBL_MAX)
{
++numPrunes;
continue;
}
// For this to be a valid dual-tree algorithm, we *must* evaluate the
// combination, even if pruning it will make no difference. It's the
// definition.
const double actualScore = rule.Score(queryIndex, *node);
if (actualScore == DBL_MAX)
{
++numPrunes;
continue;
}
else
{
// Evaluate the base case, since the combination was not pruned.
// Often, a ruleset will return without doing any computation on cover
// trees using TreeTraits::FirstPointIsCentroid; this is an optimization
// that (theoretically) the compiler should get right.
rule.BaseCase(queryIndex, point);
}
}
}
CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::CoverTree(
MatType&& data,
MetricType& metric,
const ElemType base) :
dataset(new MatType(std::move(data))),
point(RootPointPolicy::ChooseRoot(dataset)),
scale(INT_MAX),
base(base),
numDescendants(0),
parent(NULL),
parentDistance(0),
furthestDescendantDistance(0),
localMetric(false),
localDataset(true),
metric(&metric),
distanceComps(0)
{
// If there is only one point or zero points in the dataset... uh, we're done.
// Technically, if the dataset has zero points, our node is not correct...
if (dataset->n_cols <= 1)
return;
// Kick off the building. Create the indices array and the distances array.
arma::Col<size_t> indices = arma::linspace<arma::Col<size_t> >(1,
dataset->n_cols - 1, dataset->n_cols - 1);
// This is now [1 2 3 4 ... n]. We must be sure that our point does not
// occur.
if (point != 0)
indices[point - 1] = 0; // Put 0 back into the set; remove what was there.
arma::vec distances(dataset->n_cols - 1);
// Build the initial distances.
ComputeDistances(point, indices, distances, dataset->n_cols - 1);
// Create the children.
size_t farSetSize = 0;
size_t usedSetSize = 0;
CreateChildren(indices, distances, dataset->n_cols - 1, farSetSize,
usedSetSize);
// If we ended up creating only one child, remove the implicit node.
while (children.size() == 1)
{
// Prepare to delete the implicit child node.
CoverTree* old = children[0];
// Now take its children and set their parent correctly.
children.erase(children.begin());
for (size_t i = 0; i < old->NumChildren(); ++i)
{
children.push_back(&(old->Child(i)));
// Set its parent correctly, and rebuild the statistic.
old->Child(i).Parent() = this;
old->Child(i).Stat() = StatisticType(old->Child(i));
}
// Remove all the children so they don't get erased.
old->Children().clear();
// Reduce our own scale.
scale = old->Scale();
// Now delete it.
delete old;
}
// Use the furthest descendant distance to determine the scale of the root
// node.
scale = (int) ceil(log(furthestDescendantDistance) / log(base));
// Initialize statistic.
stat = StatisticType(*this);
Log::Info << distanceComps << " distance computations during tree "
<< "construction." << std::endl;
}
inline void CoverTree<MetricType, StatisticType, MatType, RootPointPolicy>::
RemoveNewImplicitNodes()
{
// If we created an implicit node, take its self-child instead (this could
// happen multiple times).
while (children[children.size() - 1]->NumChildren() == 1)
{
CoverTree* old = children[children.size() - 1];
children.erase(children.begin() + children.size() - 1);
// Now take its child.
children.push_back(&(old->Child(0)));
// Set its parent and parameters correctly, and rebuild the statistic.
old->Child(0).Parent() = this;
old->Child(0).ParentDistance() = old->ParentDistance();
old->Child(0).DistanceComps() = old->DistanceComps();
old->Child(0).Stat() = StatisticType(old->Child(0));
// Remove its child (so it doesn't delete it).
old->Children().erase(old->Children().begin() + old->Children().size() - 1);
// Now delete it.
delete old;
}
}
void CoverTree<MetricType, RootPointPolicy, StatisticType>::
DualTreeTraverser<RuleType>::ReferenceRecursion(
CoverTree& queryNode,
std::map<int, std::vector<DualCoverTreeMapEntry> >& referenceMap)
{
// First, reduce the maximum scale in the reference map down to the scale of
// the query node.
while (!referenceMap.empty())
{
// Hacky bullshit to imitate jl cover tree.
if (queryNode.Parent() == NULL && (*referenceMap.rbegin()).first <
queryNode.Scale())
break;
if (queryNode.Parent() != NULL && (*referenceMap.rbegin()).first <=
queryNode.Scale())
break;
// If the query node's scale is INT_MIN and the reference map's maximum
// scale is INT_MIN, don't try to recurse...
if ((queryNode.Scale() == INT_MIN) &&
((*referenceMap.rbegin()).first == INT_MIN))
break;
// Get a reference to the current largest scale.
std::vector<DualCoverTreeMapEntry>& scaleVector = (*referenceMap.rbegin()).second;
// Before traversing all the points in this scale, sort by score.
std::sort(scaleVector.begin(), scaleVector.end());
// Now loop over each element.
for (size_t i = 0; i < scaleVector.size(); ++i)
{
// Get a reference to the current element.
const DualCoverTreeMapEntry& frame = scaleVector.at(i);
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// Create the score for the children.
double score = rule.Rescore(queryNode, *refNode, frame.score);
// Now if this childScore is DBL_MAX we can prune all children. In this
// recursion setup pruning is all or nothing for children.
if (score == DBL_MAX)
{
++numPrunes;
continue;
}
// If it is not pruned, we must evaluate the base case.
// Add the children.
for (size_t j = 0; j < refNode->NumChildren(); ++j)
{
rule.TraversalInfo() = frame.traversalInfo;
double childScore = rule.Score(queryNode, refNode->Child(j));
if (childScore == DBL_MAX)
{
++numPrunes;
continue;
}
// It wasn't pruned; evaluate the base case.
const double baseCase = rule.BaseCase(queryNode.Point(),
refNode->Child(j).Point());
DualCoverTreeMapEntry newFrame;
newFrame.referenceNode = &refNode->Child(j);
newFrame.score = childScore; // Use the score of the parent.
newFrame.baseCase = baseCase;
newFrame.traversalInfo = rule.TraversalInfo();
referenceMap[newFrame.referenceNode->Scale()].push_back(newFrame);
}
}
// Now clear the memory for this scale; it isn't needed anymore.
referenceMap.erase((*referenceMap.rbegin()).first);
}
}
void CoverTree<MetricType, RootPointPolicy, StatisticType>::
DualTreeTraverser<RuleType>::Traverse(
CoverTree<MetricType, RootPointPolicy, StatisticType>& queryNode,
std::map<int, std::vector<DualCoverTreeMapEntry> >& referenceMap)
{
if (referenceMap.size() == 0)
return; // Nothing to do!
// First recurse down the reference nodes as necessary.
ReferenceRecursion(queryNode, referenceMap);
// Did the map get emptied?
if (referenceMap.size() == 0)
return; // Nothing to do!
// Now, reduce the scale of the query node by recursing. But we can't recurse
// if the query node is a leaf node.
if ((queryNode.Scale() != INT_MIN) &&
(queryNode.Scale() >= (*referenceMap.rbegin()).first))
{
// Recurse into the non-self-children first. The recursion order cannot
// affect the runtime of the algorithm, because each query child recursion's
// results are separate and independent. I don't think this is true in
// every case, and we may have to modify this section to consider scores in
// the future.
for (size_t i = 1; i < queryNode.NumChildren(); ++i)
{
// We need a copy of the map for this child.
std::map<int, std::vector<DualCoverTreeMapEntry> > childMap;
PruneMap(queryNode.Child(i), referenceMap, childMap);
Traverse(queryNode.Child(i), childMap);
}
std::map<int, std::vector<DualCoverTreeMapEntry> > selfChildMap;
PruneMap(queryNode.Child(0), referenceMap, selfChildMap);
Traverse(queryNode.Child(0), selfChildMap);
}
if (queryNode.Scale() != INT_MIN)
return; // No need to evaluate base cases at this level. It's all done.
// If we have made it this far, all we have is a bunch of base case
// evaluations to do.
Log::Assert((*referenceMap.begin()).first == INT_MIN);
Log::Assert(queryNode.Scale() == INT_MIN);
std::vector<DualCoverTreeMapEntry>& pointVector =
(*referenceMap.begin()).second;
for (size_t i = 0; i < pointVector.size(); ++i)
{
// Get a reference to the frame.
const DualCoverTreeMapEntry& frame = pointVector[i];
CoverTree<MetricType, RootPointPolicy, StatisticType>* refNode =
frame.referenceNode;
// If the point is the same as both parents, then we have already done this
// base case.
if ((refNode->Point() == refNode->Parent()->Point()) &&
(queryNode.Point() == queryNode.Parent()->Point()))
{
++numPrunes;
continue;
}
// Score the node, to see if we can prune it, after restoring the traversal
// info.
rule.TraversalInfo() = frame.traversalInfo;
double score = rule.Score(queryNode, *refNode);
if (score == DBL_MAX)
{
++numPrunes;
continue;
}
// If not, compute the base case.
rule.BaseCase(queryNode.Point(), pointVector[i].referenceNode->Point());
}
}
