@Override public void setModelFeatures(List<T> map) { // build KDTree try { // System.out.println("building tree"); tree = new CoordinateKDTree<T>(); for (final T k : map) { tree.insert(k); if (k.x < minDim.x) minDim.x = k.x; if (k.y < minDim.y) minDim.y = k.y; if (k.scale < minDim.scale) minDim.scale = k.scale; if (k.x > maxDim.x) maxDim.x = k.x; if (k.y > maxDim.y) maxDim.y = k.y; if (k.scale > maxDim.scale) maxDim.scale = k.scale; } // System.out.println("done"); } catch (final Exception e) { System.out.println(e); } } }
@Override public T nearestNeighbour(Coordinate query) { float minDist = Float.MAX_VALUE; T best = null; for (T d : data) { float dist = CoordinateKDTree.distance(d, query); if (dist < minDist) { minDist = dist; best = d; } } return best; }
/** * Create a KDTree object and populate it with the given data. * * @param coords * the data to populate the index with. */ public CoordinateKDTree(Collection<T> coords) { _root = null; insertAll(coords); }
final CoordinateKDTree<PayloadCoordinate<ScaleSpaceLocation, IndependentPair<Integer, Ellipse>>> tree = new CoordinateKDTree<PayloadCoordinate<ScaleSpaceLocation, IndependentPair<Integer, Ellipse>>>(); .getX(), ellipse2.calculateCentroid().getY(), (float) getRadius( ellipse2, this.maximumDistanceMultiple)); tree.insert(PayloadCoordinate.payload(ep, new IndependentPair<Integer, Ellipse>(j, ellipse2))); j++; tree.rangeSearch(possible, new ScaleSpaceLocation(left.getX(), left.getY(), radius - scaleRadius), new ScaleSpaceLocation(
@Override public void kNearestNeighbour(Collection<T> result, Coordinate query, int k) { final Stack<KDNode<T>> stack = walkdown(query); final PriorityQueue<NNState> state = new PriorityQueue<NNState>(k); final NNState initialState = new NNState(); initialState.best = stack.peek()._point; initialState.bestDist = distance(query, initialState.best); state.add(initialState); while (!stack.isEmpty()) { final KDNode<T> current = stack.pop(); checkSubtreeK(current, query, state, k); } @SuppressWarnings("unchecked") final NNState[] stateList = state.toArray((NNState[]) Array.newInstance(NNState.class, state.size())); Arrays.sort(stateList); for (int i = stateList.length - 1; i >= 0; i--) result.add(stateList[i].best); }
/** * Find the nearest neighbour. Only one neighbour will be returned - if * multiple neighbours share the same location, or are equidistant, then * this might not be the one you expect. * * @param query * query coordinate * @return nearest neighbour */ @Override public T nearestNeighbour(Coordinate query) { final Stack<KDNode<T>> stack = walkdown(query); final NNState state = new NNState(); state.best = stack.peek()._point; state.bestDist = distance(query, state.best); if (state.bestDist == 0) return state.best; while (!stack.isEmpty()) { final KDNode<T> current = stack.pop(); checkSubtree(current, query, state); } return state.best; }
tree.rangeSearch(klist1, minDim, maxDim); tree.rangeSearch(klist, lbound, ubound);
/** * Insert all the points from the given collection into the index. * * @param coords * The points to add. */ public void insertAll(Collection<T> coords) { for (final T c : coords) insert(c); }
private void checkSubtree(KDNode<T> node, Coordinate query, NNState state) { if (node == null) return; final float dist = distance(query, node._point); if (dist < state.bestDist) { state.best = node._point; state.bestDist = dist; } if (state.bestDist == 0) return; final float d = node._point.getOrdinate(node._discriminate).floatValue() - query.getOrdinate(node._discriminate).floatValue(); if (d * d > state.bestDist) { // check subtree final double ordinate1 = query.getOrdinate(node._discriminate).doubleValue(); final double ordinate2 = node._point.getOrdinate(node._discriminate).doubleValue(); if (ordinate1 > ordinate2) checkSubtree(node._right, query, state); else checkSubtree(node._left, query, state); } else { checkSubtree(node._left, query, state); checkSubtree(node._right, query, state); } }
return; final float dist = distance(query, node._point); checkSubtreeK(node._right, query, state, k); else checkSubtreeK(node._left, query, state, k); } else { checkSubtreeK(node._left, query, state, k); checkSubtreeK(node._right, query, state, k);
@Override public void rangeSearch(Collection<T> results, Coordinate lowerExtreme, Coordinate upperExtreme) { for (T d : data) { if (CoordinateKDTree.isContained(d, lowerExtreme, upperExtreme)) results.add(d); } }
final CoordinateKDTree<PayloadCoordinate<ScaleSpaceLocation, IndependentPair<Integer, Ellipse>>> tree = new CoordinateKDTree<PayloadCoordinate<ScaleSpaceLocation, IndependentPair<Integer, Ellipse>>>(); .getX(), ellipse2.calculateCentroid().getY(), (float) getRadius( ellipse2, this.maximumDistanceMultiple)); tree.insert(PayloadCoordinate.payload(ep, new IndependentPair<Integer, Ellipse>(j, ellipse2))); j++; tree.rangeSearch(possible, new ScaleSpaceLocation(left.getX(), left.getY(), radius - scaleRadius), new ScaleSpaceLocation(
@Override public void kNearestNeighbour(Collection<T> result, Coordinate query, int k) { final Stack<KDNode<T>> stack = walkdown(query); final PriorityQueue<NNState> state = new PriorityQueue<NNState>(k); final NNState initialState = new NNState(); initialState.best = stack.peek()._point; initialState.bestDist = distance(query, initialState.best); state.add(initialState); while (!stack.isEmpty()) { final KDNode<T> current = stack.pop(); checkSubtreeK(current, query, state, k); } @SuppressWarnings("unchecked") final NNState[] stateList = state.toArray((NNState[]) Array.newInstance(NNState.class, state.size())); Arrays.sort(stateList); for (int i = stateList.length - 1; i >= 0; i--) result.add(stateList[i].best); }
/** * Find the nearest neighbour. Only one neighbour will be returned - if * multiple neighbours share the same location, or are equidistant, then * this might not be the one you expect. * * @param query * query coordinate * @return nearest neighbour */ @Override public T nearestNeighbour(Coordinate query) { final Stack<KDNode<T>> stack = walkdown(query); final NNState state = new NNState(); state.best = stack.peek()._point; state.bestDist = distance(query, state.best); if (state.bestDist == 0) return state.best; while (!stack.isEmpty()) { final KDNode<T> current = stack.pop(); checkSubtree(current, query, state); } return state.best; }
/** * Faster implementation of K-nearest-neighbours. * * @param result * Collection to hold the found coordinates. * @param query * The query coordinate. * @param k * The number of neighbours to find. */ public void fastKNN(Collection<T> result, Coordinate query, int k) { final List<T> tmp = new ArrayList<T>(); final Coord lowerExtreme = new Coord(query); final Coord upperExtreme = new Coord(query); while (tmp.size() < k) { tmp.clear(); for (int i = 0; i < lowerExtreme.getDimensions(); i++) lowerExtreme.coords[i] -= k; for (int i = 0; i < upperExtreme.getDimensions(); i++) upperExtreme.coords[i] += k; rangeSearch(tmp, lowerExtreme, upperExtreme); } final CoordinateBruteForce<T> bf = new CoordinateBruteForce<T>(tmp); bf.kNearestNeighbour(result, query, k); } }
/** * Insert all the points from the given collection into the index. * * @param coords * The points to add. */ public void insertAll(Collection<T> coords) { for (final T c : coords) insert(c); }
private void checkSubtree(KDNode<T> node, Coordinate query, NNState state) { if (node == null) return; final float dist = distance(query, node._point); if (dist < state.bestDist) { state.best = node._point; state.bestDist = dist; } if (state.bestDist == 0) return; final float d = node._point.getOrdinate(node._discriminate).floatValue() - query.getOrdinate(node._discriminate).floatValue(); if (d * d > state.bestDist) { // check subtree final double ordinate1 = query.getOrdinate(node._discriminate).doubleValue(); final double ordinate2 = node._point.getOrdinate(node._discriminate).doubleValue(); if (ordinate1 > ordinate2) checkSubtree(node._right, query, state); else checkSubtree(node._left, query, state); } else { checkSubtree(node._left, query, state); checkSubtree(node._right, query, state); } }
return; final float dist = distance(query, node._point); checkSubtreeK(node._right, query, state, k); else checkSubtreeK(node._left, query, state, k); } else { checkSubtreeK(node._left, query, state, k); checkSubtreeK(node._right, query, state, k);
@Override public void rangeSearch(Collection<T> results, Coordinate lowerExtreme, Coordinate upperExtreme) { for (T d : data) { if (CoordinateKDTree.isContained(d, lowerExtreme, upperExtreme)) results.add(d); } }
@Override public void setModelFeatures(List<T> map) { // build KDTree try { // System.out.println("building tree"); tree = new CoordinateKDTree<T>(); for (final T k : map) { tree.insert(k); if (k.x < minDim.x) minDim.x = k.x; if (k.y < minDim.y) minDim.y = k.y; if (k.scale < minDim.scale) minDim.scale = k.scale; if (k.x > maxDim.x) maxDim.x = k.x; if (k.y > maxDim.y) maxDim.y = k.y; if (k.scale > maxDim.scale) maxDim.scale = k.scale; } // System.out.println("done"); } catch (final Exception e) { System.out.println(e); } } }