protected PhTreeF(PhTree<T> tree) { this.pht = tree; this.pre = new PreProcessorPointF.IEEE(); }
@Override public void toMBB(double distance, long[] center, long[] outMin, long[] outMax) { double[] c = new double[center.length]; double[] min = new double[outMin.length]; double[] max = new double[outMax.length]; pre.post(center, c); for (int i = 0; i < center.length; i++) { min[i] = c[i] - distance; max[i] = c[i] + distance; } pre.pre(min, outMin); pre.pre(max, outMax); }
public <R> List<R> queryIntersectAll(double[] lower, double[] upper, int maxResults, PhFilter filter, PhMapperKey<R> mapper) { long[] lUpp = new long[lower.length << 1]; long[] lLow = new long[lower.length << 1]; pre.pre(MIN, lower, lLow); pre.pre(upper, MAX, lUpp); return ((PhTreeVProxy)pht).queryAll(lLow, lUpp, maxResults, filter, mapper); }
/** * Check whether an entry with the specified coordinates exists in the tree. * @param lower lower left corner * @param upper upper right corner * @return true if the entry was found * * @see PhTree#contains(long...) */ public boolean contains(long[] lower, long[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.contains(lVal); }
/** * Create a new {@code double} tree backed by the the specified tree. * Note that the backing tree's dimensionality must be a multiple of 2. * * @param tree the backing tree */ public PhTreeSolidF(PhTree<T> tree) { this(tree, new PreProcessorRangeF.IEEE(tree.getDim())); }
/** * Restarts the query with a new center point and range. * @param range new range * @param center new center point * @return this */ public PhRangeQueryF<T> reset(double range, double... center) { pre.pre(center, lCenter); q.reset(range, lCenter); return this; } }
/** * Removes a ranged object from the tree. * @param lower lower left corner * @param upper upper right corner * @return the value or {@code null} if no entry existed * * @see PhTree#remove(long...) */ public T remove(double[] lower, double[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.remove(lVal); }
/** * Inserts a new ranged object into the tree. * @param lower lower left corner * @param upper upper right corner * @param value value * @return the previous value or {@code null} if no entry existed * * @see PhTree#put(long[], Object) */ public T put(long[] lower, long[] upper, T value) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.put(lVal, value); }
/** * Create a new tree with the specified number of dimensions. * * @param dim number of dimensions * @return PhTreeF * @param <T> value type of the tree */ public static <T> PhTreeF<T> create(int dim) { return new PhTreeF<>(dim, new PreProcessorPointF.IEEE()); }
/** * Create a new {@code double} tree backed by the the specified tree. * Note that the backing tree's dimensionality must be a multiple of 2. * * @param tree the backing tree */ public PhTreeNVSolidF(PhTreeNV tree) { this(tree, new PreProcessorRangeF.IEEE(tree.getDIM())); }
/** * @param key key * @return true if the key exists in the tree */ public boolean contains(double ... key) { long[] lKey = new long[key.length]; pre.pre(key, lKey); return pht.contains(lKey); }
/** * @param lower min value * @param upper max value * @return the element that has 'upper' and 'lower' as key. */ public T get(double[] lower, double[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.get(lVal); }
/** * Removes a ranged object from the tree. * @param lower lower left corner * @param upper upper right corner * @return the value or {@code null} if no entry existed * * @see PhTree#remove(long...) */ public T remove(long[] lower, long[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.remove(lVal); }
/** * @param key the key * @return the value associated with the key or 'null' if the key was not found */ public T get(double ... key) { long[] lKey = new long[key.length]; pre.pre(key, lKey); return pht.get(lKey); }
/** * Removes a ranged object from the tree. * @param lower lower left corner * @param upper upper right corner * @return true if the entry was found * * @see PhTreeNV#delete(long...) */ public boolean delete(double[] lower, double[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.delete(lVal); }
/** * Remove the entry associated with a k dimensional key. * @param key the key to remove * @return the associated value or {@code null} if the key was found */ public T remove(double... key) { long[] lKey = new long[key.length]; pre.pre(key, lKey); return pht.remove(lKey); }
/** * Check whether an entry with the specified coordinates exists in the tree. * @param lower lower left corner * @param upper upper right corner * @return true if the entry was found * * @see PhTree#contains(long...) */ public boolean contains(double[] lower, double[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.contains(lVal); }
/** * Insert an entry associated with a k dimensional key. * @param key the key to store the value to store * @param value the value * @return the previously associated value or {@code null} if the key was found */ public T put(double[] key, T value) { long[] lKey = new long[key.length]; pre.pre(key, lKey); return pht.put(lKey, value); }
/** * Inserts a new ranged object into the tree. * @param lower lower left corner * @param upper upper right corner * @return true if the entry already exists * * @see PhTreeNV#insert(long...) */ public boolean insert(double[] lower, double[] upper) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.insert(lVal); }