internal static void rsearch(HyperPoint lowk, HyperPoint uppk, KDNode t, int lev, int K, List <KDNode> v) { if (t == null) { return; } if (lowk.coord[lev] <= t.k.coord[lev]) { rsearch(lowk, uppk, t.left, (lev + 1) % K, K, v); } int j; for (j = 0; j < K && lowk.coord[j] <= t.k.coord[j] && uppk.coord[j] >= t.k.coord[j]; j++) { ; } if (j == K) { v.Add(t); } if (uppk.coord[lev] > t.k.coord[lev]) { rsearch(lowk, uppk, t.right, (lev + 1) % K, K, v); } }
internal static KDNode ins(HyperPoint key, Object val, KDNode t, int lev, int K) { if (t == null) { t = new KDNode(key, val); } else if (key.equals(t.k)) { if (t.deleted) { t.deleted = false; t.v = val; } else { if (t.duplicates == null) { t.duplicates = new List <object>(); } t.duplicates.Add(val); } } else if (key.coord[lev] > t.k.coord[lev]) { t.right = ins(key, val, t.right, (lev + 1) % K, K); } else { t.left = ins(key, val, t.left, (lev + 1) % K, K); } return(t); }
/// <summary> /// Look for 'n' neighbours to a given point. Each neighbour must be unique.. /// </summary> /// <param name="inputVector">vector to find neighbours of</param> /// <param name="neighbourCount">number of neighbours to find</param> /// <param name="distances">array of distances</param> public void UniqueSearch(double[] inputVector, int neighbourCount, ref List <KDTreePoint> distances) // { distances.Clear(); if (neighbourCount < 0 || neighbourCount > m_count) { throw new ArgumentOutOfRangeException("Number of neighbors cannot" + " be negative or greater than number of nodes"); } if (inputVector.Length != dimensions) { throw new ArgumentOutOfRangeException(); } Object [] nbrs = new Object [neighbourCount]; NearestNeighborList nnl = new NearestNeighborList(neighbourCount); // initial call is with infinite hyper-rectangle and max distance HyperRect hr = HyperRect.infiniteHyperRect(inputVector.Length); double max_dist_sqd = Double.MaxValue; HyperPoint keyp = new HyperPoint(inputVector); KDNode.nnbr(root, keyp, hr, max_dist_sqd, 0, dimensions, nnl); while (distances.Count < neighbourCount) { KDNode kd = (KDNode)nnl.removeHighest(); double dist = HyperPoint.eucdist(keyp, kd.k); distances.Add(new KDTreePoint(kd.v, dist * dist)); } distances.Sort(); }
private KDNode(HyperPoint key, Object val) { k = key; v = val; left = null; right = null; deleted = false; }
internal static double sqrdist(HyperPoint x, HyperPoint y) { double dist = 0; for (int i = 0; i < x.coord.Length; ++i) { double diff = (x.coord[i] - y.coord[i]); dist += (diff * diff); } return(dist); }
internal bool equals(HyperPoint p) { for (int i = 0; i < coord.Length; ++i) { if (coord[i] != p.coord[i]) { return(false); } } return(true); }
// used in initial conditions of KDTree.nearest() internal static HyperRect infiniteHyperRect(int d) { HyperPoint vmin = new HyperPoint(d); HyperPoint vmax = new HyperPoint(d); for (int i = 0; i < d; ++i) { vmin.coord[i] = Double.NegativeInfinity; vmax.coord[i] = Double.PositiveInfinity; } return(new HyperRect(vmin, vmax)); }
// currently unused internal HyperRect intersection(HyperRect r) { HyperPoint newmin = new HyperPoint(min.coord.Length); HyperPoint newmax = new HyperPoint(min.coord.Length); for (int i = 0; i < min.coord.Length; ++i) { newmin.coord[i] = Math.Max(min.coord[i], r.min.coord[i]); newmax.coord[i] = Math.Min(max.coord[i], r.max.coord[i]); if (newmin.coord[i] >= newmax.coord[i]) { return(null); } } return(new HyperRect(newmin, newmax)); }
internal static KDNode srch(HyperPoint key, KDNode t, int K) { for (int lev = 0; t != null; lev = (lev + 1) % K) { if (!t.deleted && key.equals(t.k)) { return(t); } else if (key.coord[lev] > t.k.coord[lev]) { t = t.right; } else { t = t.left; } } return(null); }
/// <summary> /// find the neighbours within a distance of a point /// </summary> /// <remarks>Note that the distance array contains the squares of the distances found.</remarks> /// <param name="inputVector">Vector to find neighbours of</param> /// <param name="maxDistance">distance to search over</param> /// <param name="neighbourCount">number of neighbours found within distance</param> /// <param name="distances">array of squared distances of neighbours from the input vector</param> /// <param name="maxNeighbourCount">maximum permissable size of arrays</param> public void SearchByDistance(double[] inputVector, double maxDistance, out int neighbourCount, ref List <KDTreePoint> distances, int maxNeighbourCount) { double[] lower = new double[inputVector.Length]; double[] upper = new double[inputVector.Length]; for (int n = 0; n < inputVector.Length; n++) { lower[n] = inputVector[n] - maxDistance; upper[n] = inputVector[n] + maxDistance; } KDNode[] list = this.range(lower, upper); foreach (KDNode node in list) { double dist = HyperPoint.eucdist(new HyperPoint(inputVector), node.k); if (dist <= maxDistance) { distances.Add(new KDTreePoint(node.v, dist * dist)); } } distances.Sort(); neighbourCount = distances.Count; }
// from Moore's eqn. 6.6 internal HyperPoint closest(HyperPoint t) { HyperPoint p = new HyperPoint(t.coord.Length); for (int i = 0; i < t.coord.Length; ++i) { if (t.coord[i] <= min.coord[i]) { p.coord[i] = min.coord[i]; } else if (t.coord[i] >= max.coord[i]) { p.coord[i] = max.coord[i]; } else { p.coord[i] = t.coord[i]; } } return(p); }
internal static double eucdist(HyperPoint x, HyperPoint y) { return(Math.Sqrt(sqrdist(x, y))); }
internal static void nnbr(KDNode kd, HyperPoint target, HyperRect hr, double max_dist_sqd, int lev, int K, NearestNeighborList nnl) { // 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 HyperPoint pivot = kd.k; double pivot_to_target = HyperPoint.sqrdist(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. HyperRect left_hr = hr; // optimize by not cloning HyperRect right_hr = (HyperRect)hr.clone(); left_hr.max.coord[s] = pivot.coord[s]; right_hr.min.coord[s] = pivot.coord[s]; // 5. target-in-left := target_s <= pivot_s bool target_in_left = target.coord[s] < pivot.coord[s]; KDNode nearer_kd; HyperRect nearer_hr; KDNode further_kd; HyperRect further_hr; // 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 if (target_in_left) { nearer_kd = kd.left; nearer_hr = left_hr; further_kd = kd.right; further_hr = right_hr; } // // 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 else { nearer_kd = kd.right; nearer_hr = right_hr; further_kd = kd.left; further_hr = left_hr; } // 8. Recursively call Nearest Neighbor with paramters // (nearer-kd, target, nearer-hr, max-dist-sqd), storing the // results in nearest and dist-sqd nnbr(nearer_kd, target, nearer_hr, max_dist_sqd, lev + 1, K, nnl); KDNode nearest = (KDNode)nnl.getHighest(); double dist_sqd; if (!nnl.isCapacityReached()) { dist_sqd = Double.MaxValue; } else { dist_sqd = nnl.getMaxPriority(); } // 9. max-dist-sqd := minimum of max-dist-sqd and dist-sqd max_dist_sqd = Math.Min(max_dist_sqd, dist_sqd); // 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 HyperPoint closest = further_hr.closest(target); if (HyperPoint.eucdist(closest, target) < Math.Sqrt(max_dist_sqd)) { // 10.1 if (pivot-target)^2 < dist-sqd then if (pivot_to_target < dist_sqd) { // 10.1.1 nearest := (pivot, range-elt field of kd) nearest = kd; // 10.1.2 dist-sqd = (pivot-target)^2 dist_sqd = pivot_to_target; // add to nnl if (!kd.deleted) { nnl.insert(kd, dist_sqd); } // 10.1.3 max-dist-sqd = dist-sqd // max_dist_sqd = dist_sqd; if (nnl.isCapacityReached()) { max_dist_sqd = nnl.getMaxPriority(); } else { max_dist_sqd = Double.MaxValue; } } // 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 nnbr(further_kd, target, further_hr, max_dist_sqd, lev + 1, K, nnl); KDNode temp_nearest = (KDNode)nnl.getHighest(); double temp_dist_sqd = nnl.getMaxPriority(); // 10.3 If tmp-dist-sqd < dist-sqd then if (temp_dist_sqd < dist_sqd) { // 10.3.1 nearest := temp_nearest and dist_sqd := temp_dist_sqd nearest = temp_nearest; dist_sqd = temp_dist_sqd; } } // SDL: otherwise, current point is nearest else if (pivot_to_target < max_dist_sqd) { nearest = kd; dist_sqd = pivot_to_target; } }
internal HyperRect(HyperPoint vmin, HyperPoint vmax) { min = (HyperPoint)vmin.clone(); max = (HyperPoint)vmax.clone(); }
internal HyperRect(int ndims) { min = new HyperPoint(ndims); max = new HyperPoint(ndims); }