/// <summary>
/// A top-down recursive method to find the nearest neighbors of a given point.
/// </summary>
/// <param name="nodeIndex">The index of the node for the current recursion branch.</param>
/// <param name="target">The point whose neighbors we are trying to find.</param>
/// <param name="rect">The <see cref="HyperRect{T}"/> containing the possible nearest neighbors.</param>
/// <param name="dimension">The current splitting dimension for this recursion branch.</param>
/// <param name="nearestNeighbors">The <see cref="KDTreePriorityList{TElement,TPriority}"/> containing the nearest neighbors already discovered.</param>
/// <param name="maxSearchRadiusSquared">The squared radius of the current largest distance to search from the <paramref name="target"/></param>
private void SearchForNearestNeighbors(
int nodeIndex,
TDimension[] target,
HyperRect <TDimension> rect,
int dimension,
KDTreePriorityList <int, double> nearestNeighbors,
double maxSearchRadiusSquared)
{
if (this.InternalPointArray.Length <= nodeIndex || nodeIndex < 0 ||
this.InternalPointArray[nodeIndex] == null)
{
return;
}
// Work out the current dimension
var dim = dimension % this.Dimensions;
// Split our hyper-rectangle into 2 sub rectangles along the current
// node's point on the current dimension
var leftRect = rect.Clone();
leftRect.MaxPoint[dim] = this.InternalPointArray[nodeIndex][dim];
var rightRect = rect.Clone();
rightRect.MinPoint[dim] = this.InternalPointArray[nodeIndex][dim];
// Determine which side the target resides in
var compare = target[dim].CompareTo(this.InternalPointArray[nodeIndex][dim]);
var nearerRect = compare <= 0 ? leftRect : rightRect;
var furtherRect = compare <= 0 ? rightRect : leftRect;
var nearerNode = compare <= 0 ? KDTreeNavigation.LeftChildIndex(nodeIndex) : KDTreeNavigation.RightChildIndex(nodeIndex);
var furtherNode = compare <= 0 ? KDTreeNavigation.RightChildIndex(nodeIndex) : KDTreeNavigation.LeftChildIndex(nodeIndex);
// Move down into the nearer branch
this.SearchForNearestNeighbors(
nearerNode,
target,
nearerRect,
dimension + 1,
nearestNeighbors,
maxSearchRadiusSquared);
// Walk down into the further branch but only if our capacity hasn't been reached
// OR if there's a region in the further rectangle that's closer to the target than our
// current furtherest nearest neighbor
var closestPointInFurtherRect = furtherRect.GetClosestPoint(target);
var distanceSquaredToTarget = this.Metric(closestPointInFurtherRect, target);
if (distanceSquaredToTarget.CompareTo(maxSearchRadiusSquared) <= 0)
{
if (nearestNeighbors.IsFull)
{
if (distanceSquaredToTarget.CompareTo(nearestNeighbors.MaxPriority) < 0)
{
this.SearchForNearestNeighbors(
furtherNode,
target,
furtherRect,
dimension + 1,
nearestNeighbors,
maxSearchRadiusSquared);
}
}
else
{
this.SearchForNearestNeighbors(
furtherNode,
target,
furtherRect,
dimension + 1,
nearestNeighbors,
maxSearchRadiusSquared);
}
}
// Try to add the current node to our nearest neighbors list
distanceSquaredToTarget = this.Metric(this.InternalPointArray[nodeIndex], target);
if (distanceSquaredToTarget.CompareTo(maxSearchRadiusSquared) <= 0)
{
nearestNeighbors.Add(nodeIndex, distanceSquaredToTarget);
}
}
/// <summary>
/// Grows a KD tree recursively via median splitting. We find the median by doing a full sort.
/// </summary>
/// <param name="index">The array index for the current node.</param>
/// <param name="dim">The current splitting dimension.</param>
/// <param name="points">The set of points remaining to be added to the kd-tree</param>
/// <param name="nodes">The set of nodes RE</param>
private void GenerateTree(
int index,
int dim,
ICollection <TDimension[]> points,
IEnumerable <TNode> nodes)
{
// See wikipedia for a good explanation kd-tree construction.
// https://en.wikipedia.org/wiki/K-d_tree
// zip both lists so we can sort nodes according to points
IList <KDTreeTuple <TDimension[], TNode> > zippedList = new List <KDTreeTuple <TDimension[], TNode> >();
var nodeEnum = nodes.GetEnumerator();
foreach (TDimension[] point in points)
{
if (!nodeEnum.MoveNext())
{
throw new InvalidOperationException("Node / Dim mismatch");
}
zippedList.Add(new KDTreeTuple <TDimension[], TNode>(point, nodeEnum.Current));
}
// sort the points along the current dimension
var sortedPoints = zippedList.OrderBy(z => z.Dimensions[dim]).ToArray();
// get the point which has the median value of the current dimension.
var medianPoint = sortedPoints[points.Count / 2];
var medianPointIdx = sortedPoints.Length / 2;
// The point with the median value all the current dimension now becomes the value of the current tree node
// The previous node becomes the parents of the current node.
this.InternalPointArray[index] = medianPoint.Dimensions;
this.InternalNodeArray[index] = medianPoint.Node;
// We now split the sorted points into 2 groups
// 1st group: points before the median
var leftPoints = new TDimension[medianPointIdx][];
var leftNodes = new TNode[medianPointIdx];
Array.Copy(sortedPoints.Select(z => z.Dimensions).ToArray(), leftPoints, leftPoints.Length);
Array.Copy(sortedPoints.Select(z => z.Node).ToArray(), leftNodes, leftNodes.Length);
// 2nd group: Points after the median
var rightPoints = new TDimension[sortedPoints.Length - (medianPointIdx + 1)][];
var rightNodes = new TNode[sortedPoints.Length - (medianPointIdx + 1)];
Array.Copy(
sortedPoints.Select(z => z.Dimensions).ToArray(),
medianPointIdx + 1,
rightPoints,
0,
rightPoints.Length);
Array.Copy(sortedPoints.Select(z => z.Node).ToArray(), medianPointIdx + 1, rightNodes, 0, rightNodes.Length);
// We new recurse, passing the left and right arrays for arguments.
// The current node's left and right values become the "roots" for
// each recursion call. We also forward cycle to the next dimension.
var nextDim = (dim + 1) % this.Dimensions; // select next dimension
// We only need to recurse if the point array contains more than one point
// If the array has no points then the node stay a null value
if (leftPoints.Length <= 1)
{
if (leftPoints.Length == 1)
{
this.InternalPointArray[KDTreeNavigation.LeftChildIndex(index)] = leftPoints[0];
this.InternalNodeArray[KDTreeNavigation.LeftChildIndex(index)] = leftNodes[0];
}
}
else
{
this.GenerateTree(KDTreeNavigation.LeftChildIndex(index), nextDim, leftPoints, leftNodes);
}
// Do the same for the right points
if (rightPoints.Length <= 1)
{
if (rightPoints.Length == 1)
{
this.InternalPointArray[KDTreeNavigation.RightChildIndex(index)] = rightPoints[0];
this.InternalNodeArray[KDTreeNavigation.RightChildIndex(index)] = rightNodes[0];
}
}
else
{
this.GenerateTree(KDTreeNavigation.RightChildIndex(index), nextDim, rightPoints, rightNodes);
}
}