/// <summary> /// Find KD-tree nodes whose keys are <I>n</I> farthest neighbors from /// key. Neighbors are returned in descending order of distance to key. /// </summary> /// <param name="key">key for KD-tree node</param> /// <param name="numNeighbors">The Integer showing how many neighbors to find</param> /// <returns>An array of objects at the node nearest to the key</returns> /// <exception cref="KeySizeException">Mismatch if key length doesn't match the dimension for the tree</exception> /// <exception cref="NeighborsOutOfRangeException">if <I>n</I> is negative or exceeds tree size </exception> public object[] Farthest(double[] key, int numNeighbors) { if (numNeighbors < 0 || numNeighbors > _count) { throw new NeighborsOutOfRangeException(); } if (key.Length != _k) { throw new KeySizeException(); } object[] neighbors = new object[numNeighbors]; FarthestNeighborList fnl = new FarthestNeighborList(numNeighbors); // initial call is with infinite hyper-rectangle and max distance HRect hr = HRect.InfiniteHRect(key.Length); //double max_dist_sqd = 1.79769e+30; //Double.MaxValue; HPoint keyp = new HPoint(key); KdNode.FarthestNeighbor(_root, keyp, hr, 0, 0, _k, fnl); //KDNode.nnbr(_root, keyp, hr, max_dist_sqd, 0, _k, nnl); for (int i = 0; i < numNeighbors; ++i) { KdNode kd = (KdNode)fnl.RemoveFarthest(); neighbors[numNeighbors - i - 1] = kd.V; } return(neighbors); }
/// <summary> /// This method was written by Ted Dunsford by restructuring the nearest neighbor /// algorithm presented by Andrew and Bjoern /// </summary> /// <param name="kd">Since this is recursive, this represents the current node</param> /// <param name="target">The target is the HPoint that we are trying to calculate the farthest distance from</param> /// <param name="hr">In this case, the hr is the hyper rectangle bounding the region that must contain the furthest point.</param> /// <param name="maxDistSqd">The maximum distance that we have calculated thus far, and will therefore be testing against.</param> /// <param name="lev">The integer based level of that we have recursed to in the tree</param> /// <param name="k">The dimensionality of the kd tree</param> /// <param name="fnl">A list to contain the output, prioritized by distance</param> public static void FarthestNeighbor(KdNode kd, HPoint target, HRect hr, double maxDistSqd, int lev, int k, FarthestNeighborList fnl) { // 1. if kd is empty then set dist-sqd to infinity and exit. if (kd == null) { return; } // 2. s := split field of kd int s = lev % k; // 3. pivot := dom-elt field of kd HPoint pivot = kd.K; double pivotToTarget = HPoint.SquareDistance(pivot, target); // 4. Cut hr into to sub-hyperrectangles left-hr and right-hr. // The cut plane is through pivot and perpendicular to the s // dimension. HRect leftHr = hr; // optimize by not cloning HRect rightHr = hr.Copy(); leftHr.Max[s] = pivot[s]; rightHr.Min[s] = pivot[s]; // 5. target-in-left := target_s <= pivot_s bool targetInLeft = target[s] < pivot[s]; KdNode nearerKd; HRect nearerHr; KdNode furtherKd; HRect furtherHr; if (targetInLeft) { // 6. if target-in-left then // 6.1. nearer-kd := left field of kd and nearer-hr := left-hr // 6.2. further-kd := right field of kd and further-hr := right-hr nearerKd = kd.Left; nearerHr = leftHr; furtherKd = kd.Right; furtherHr = rightHr; } else { // // 7. if not target-in-left then // 7.1. nearer-kd := right field of kd and nearer-hr := right-hr // 7.2. further-kd := left field of kd and further-hr := left-hr nearerKd = kd.Right; nearerHr = rightHr; furtherKd = kd.Left; furtherHr = leftHr; } // 8. Recursively call Nearest Neighbor with paramters // (nearer-kd, target, nearer-hr, max-dist-sqd), storing the // results in nearest and dist-sqd //FarthestNeighbor(nearer_kd, target, nearer_hr, max_dist_sqd, lev + 1, K, nnl); // This line changed by Ted Dunsford to attempt to find the farther point FarthestNeighbor(furtherKd, target, furtherHr, maxDistSqd, lev + 1, k, fnl); //KDNode nearest = (KDNode)nnl.Highest; double distSqd; if (!fnl.IsCapacityReached) { //dist_sqd = 1.79769e+30; // Double.MaxValue; distSqd = 0; } else { distSqd = fnl.MinimumPriority; } // 9. max-dist-sqd := minimum of max-dist-sqd and dist-sqd //max_dist_sqd = Math.Min(max_dist_sqd, dist_sqd); maxDistSqd = Math.Max(maxDistSqd, distSqd); // 10. A nearer point could only lie in further-kd if there were some // part of further-hr within distance sqrt(max-dist-sqd) of // target. If this is the case then // HPoint closest = further_hr.Closest(target); HPoint furthest = nearerHr.Farthest(target); //if (HPoint.EuclideanDistance(closest, target) < Math.Sqrt(max_dist_sqd)) if (HPoint.EuclideanDistance(furthest, target) > Math.Sqrt(maxDistSqd)) { // 10.1 if (pivot-target)^2 < dist-sqd then if (pivotToTarget > distSqd) { // 10.1.1 nearest := (pivot, range-elt field of kd) //nearest = kd; // 10.1.2 dist-sqd = (pivot-target)^2 distSqd = pivotToTarget; // add to nnl if (!kd.IsDeleted) { fnl.Insert(kd, distSqd); } // 10.1.3 max-dist-sqd = dist-sqd // max_dist_sqd = dist_sqd; if (fnl.IsCapacityReached) { maxDistSqd = fnl.MinimumPriority; } else { // max_dist_sqd = 1.79769e+30; //Double.MaxValue; maxDistSqd = 0; } } // 10.2 Recursively call Nearest Neighbor with parameters // (further-kd, target, further-hr, max-dist_sqd), // storing results in temp-nearest and temp-dist-sqd FarthestNeighbor(nearerKd, target, nearerHr, maxDistSqd, lev + 1, k, fnl); double tempDistSqd = fnl.MinimumPriority; // 10.3 If tmp-dist-sqd < dist-sqd then if (tempDistSqd > distSqd) { // 10.3.1 nearest := temp_nearest and dist_sqd := temp_dist_sqd distSqd = tempDistSqd; } } else if (pivotToTarget < maxDistSqd) { // SDL: otherwise, current point is nearest distSqd = pivotToTarget; } }
/// <summary> /// Find KD-tree nodes whose keys are <I>n</I> farthest neighbors from /// key. Neighbors are returned in descending order of distance to key. /// </summary> /// <param name="key">key for KD-tree node</param> /// <param name="numNeighbors">The Integer showing how many neighbors to find</param> /// <returns>An array of objects at the node nearest to the key</returns> /// <exception cref="KeySizeException">Mismatch if key length doesn't match the dimension for the tree</exception> /// <exception cref="NeighborsOutOfRangeException">if <I>n</I> is negative or exceeds tree size </exception> public object[] Farthest(double[] key, int numNeighbors) { if (numNeighbors < 0 || numNeighbors > _count) throw new NeighborsOutOfRangeException(); if (key.Length != _k) throw new KeySizeException(); object[] neighbors = new object[numNeighbors]; FarthestNeighborList fnl = new FarthestNeighborList(numNeighbors); // initial call is with infinite hyper-rectangle and max distance HRect hr = HRect.InfiniteHRect(key.Length); //double max_dist_sqd = 1.79769e+30; //Double.MaxValue; HPoint keyp = new HPoint(key); KdNode.FarthestNeighbor(_root, keyp, hr, 0, 0, _k, fnl); //KDNode.nnbr(_root, keyp, hr, max_dist_sqd, 0, _k, nnl); for (int i = 0; i < numNeighbors; ++i) { KdNode kd = (KdNode)fnl.RemoveFarthest(); neighbors[numNeighbors - i - 1] = kd.V; } return neighbors; }