public static T[][] LinearRadialSearch <T>(T[][] data, T[] point, Func <T[], T[], float> metric, float radius) { var pointsInRadius = new BoundedPriorityList <T[], double>(data.Length, true); for (int i = 0; i < data.Length; i++) { var currentDist = metric(point, data[i]); if (radius >= currentDist) { pointsInRadius.Add(data[i], currentDist); } } return(pointsInRadius.ToArray()); }
public static Tuple <TPoint[], TNode>[] LinearRadialSearch <TPoint, TNode>(TPoint[][] points, TNode[] nodes, TPoint[] target, Func <TPoint[], TPoint[], float> metric, float radius) { var pointsInRadius = new BoundedPriorityList <int, double>(points.Length, true); for (int i = 0; i < points.Length; i++) { var currentDist = metric(target, points[i]); if (radius >= currentDist) { pointsInRadius.Add(i, currentDist); } } return(pointsInRadius.Select(idx => new Tuple <TPoint[], TNode>(points[idx], nodes[idx])).ToArray()); }
/// <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="BoundedPriorityList{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, BoundedPriorityList <int, float> nearestNeighbors, float 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 ? LeftChildIndex(nodeIndex) : RightChildIndex(nodeIndex); var furtherNode = compare <= 0 ? RightChildIndex(nodeIndex) : 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); } }