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); }
/** * Restarts the query with a new query rectangle. * @param lower minimum values of query rectangle * @param upper maximum values of query rectangle * @return this */ public PhQuerySF<T> reset(double[] lower, double[] upper) { if (intersect) { pre.pre(qMIN, lower, lLow); pre.pre(upper, qMAX, lUpp); } else { //include pre.pre(lower, lower, lLow); pre.pre(upper, upper, lUpp); } q.reset(lLow, lUpp); return this; } }
/** * @param lo1 old min value * @param up1 old max value * @param lo2 new min value * @param up2 new max value * @return true, if the value could be replaced. * @see PhTree#update(long[], long[]) */ public T update(double[] lo1, double[] up1, double[] lo2, double[] up2) { long[] pOld = new long[lo1.length << 1]; long[] pNew = new long[lo1.length << 1]; pre.pre(lo1, up1, pOld); pre.pre(lo2, up2, pNew); return pht.update(pOld, pNew); }
/** * @param lo1 old lower left * @param up1 old upper right * @param lo2 new lower left * @param up2 new upper right * @return true, if the value could be replaced. * @see PhTree#update(long[], long[]) */ public boolean update(double[] lo1, double[] up1, double[] lo2, double[] up2) { long[] pOld = new long[lo1.length << 1]; long[] pNew = new long[lo1.length << 1]; pre.pre(lo1, up1, pOld); pre.pre(lo2, up2, pNew); return pht.update(pOld, pNew); }
/** * Same as {@link #queryIntersectAll(double[], double[], int, PhFilter, PhMapper)}, * except that it returns a list instead of an iterator. * This may be faster for small result sets. * @param lower min value * @param upper max value * @param maxResults max result count * @param filter filter instance * @param mapper mapper instance for mapping double[] to long[] * @return List of query results * @param <R> result type */ public <R> List<R> queryIntersectAll(double[] lower, double[] upper, int maxResults, PhFilter filter, PhMapper<T,R> mapper) { long[] lUpp = new long[lower.length << 1]; long[] lLow = new long[lower.length << 1]; pre.pre(qMIN, lower, lLow); pre.pre(upper, qMAX, lUpp); return pht.queryAll(lLow, lUpp, maxResults, filter, mapper); }
/** * Query for all bodies that are included in or partially intersect with the query rectangle. * @param lower 'lower left' corner of query rectangle * @param upper 'upper right' corner of query rectangle * @return Iterator over all matching elements. */ public PhQuerySF<T> queryIntersect(double[] lower, double[] upper) { long[] lUpp = new long[lower.length << 1]; long[] lLow = new long[lower.length << 1]; pre.pre(qMIN, lower, lLow); pre.pre(upper, qMAX, lUpp); return new PhQuerySF<>(pht.query(lLow, lUpp), dims, pre, true); }
/** * 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); }
/** * 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); }
/** * @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); }
/** * Calculates a MBB (minimal bounding box) for use with a query. * This is not strictly a box, but generates a query that returns all rectangles whose * centerpoint may be closer than the given distance. */ @Override public void toMBB(double distance, long[] center, long[] outMin, long[] outMax) { int dimsHalf = center.length>>1; double[] cLo = new double[dimsHalf]; double[] cUp = new double[dimsHalf]; double[] min = new double[dimsHalf]; double[] max = new double[dimsHalf]; //The simplest way to get all rectangles whose centerpoint may be within the distance, //is to perform an 'intersect' type query around center+/-distance. pre.post(center, cLo, cUp); for (int i = 0; i < dimsHalf; i++) { double c = (cUp[i] + cLo[i])/2; min[i] = c - distance; max[i] = c + distance; } //outMin contains the minimum allowed values for the lower and the upper corner //outMax contains the maximum allowed values for the lower and the upper corner pre.pre(qMIN, min, outMin); pre.pre(max, qMAX, outMax); }
/** * Calculates a MBB (minimal bounding box) for use with a query. * This is not strictly a box, but generates a query that returns all rectangles whose * edges may be closer than the given distance. */ @Override public void toMBB(double distance, long[] center, long[] outMin, long[] outMax) { int dimsHalf = center.length>>1; double[] cLo = new double[dimsHalf]; double[] cUp = new double[dimsHalf]; double[] min = new double[dimsHalf]; double[] max = new double[dimsHalf]; //The simplest way to get all rectangles whose centerpoint may be within the distance, //is to perform an 'intersect' type query around center+/-distance. pre.post(center, cLo, cUp); for (int i = 0; i < dimsHalf; i++) { min[i] = cLo[i] - distance; max[i] = cUp[i] + distance; } //outMin contains the minimum allowed values for the lower and the upper corner //outMax contains the maximum allowed values for the lower and the upper corner pre.pre(qMIN, min, outMin); pre.pre(max, qMAX, outMax); }
/** * Resets the current kNN query with new parameters. * @param nMin minimum results to be returned * @param newDist Distance function. Supplying 'null' uses the default distance function * for the current preprocessor. * @param center the center point * @return this query instance */ public PhKnnQuerySF<T> reset(int nMin, PhDistance newDist, double[] center) { pre.pre(center, center, lCenterBuffer); q.reset(nMin, newDist, lCenterBuffer); return this; }
/** * 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 PhTreeNV#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); }
/** * Query for all bodies that are fully included in the query rectangle. * @param lower 'lower left' corner of query rectangle * @param upper 'upper right' corner of query rectangle * @return Iterator over all matching elements. */ public PHREntryIterator queryInclude(double[] lower, double[] upper) { long[] lUpp = new long[lower.length << 1]; long[] lLow = new long[lower.length << 1]; pre.pre(lower, lower, lLow); pre.pre(upper, upper, lUpp); return new PHREntryIterator((PhIteratorNV) pht.query(lLow, lUpp), DIM); }
/** * 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); }
/** * Query for all bodies that are fully included in the query rectangle. * @param lower 'lower left' corner of query rectangle * @param upper 'upper right' corner of query rectangle * @return Iterator over all matching elements. */ public PhQuerySF<T> queryInclude(double[] lower, double[] upper) { long[] lUpp = new long[lower.length << 1]; long[] lLow = new long[lower.length << 1]; pre.pre(lower, lower, lLow); pre.pre(upper, upper, lUpp); return new PhQuerySF<>(pht.query(lLow, lUpp), dims, pre, false); }
/** * 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); }
/** * Query for all bodies that are included in or partially intersect with the query rectangle. * @param lower 'lower left' corner of query rectangle * @param upper 'upper right' corner of query rectangle * @return Iterator over all matching elements. */ public PHREntryIterator queryIntersect(double[] lower, double[] upper) { 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 new PHREntryIterator((PhIteratorNV) pht.query(lLow, lUpp), DIM); }
/** * Inserts a new ranged object into the tree. * @param lower lower left corner * @param upper upper right corner * @param value the value * @return the previous value or {@code null} if no entry existed * * @see PhTree#put(long[], Object) */ public T put(double[] lower, double[] upper, T value) { long[] lVal = new long[lower.length*2]; pre.pre(lower, upper, lVal); return pht.put(lVal, value); }
/** * Locate nearest neighbours for a given point in space. * @param nMin number of entries to be returned. More entries may or may not be returned if * several points have the same distance. * @param distanceFunction A distance function for rectangle data. This parameter is optional, * passing a {@code null} will use the default distance function. * @param center the center point * @return The query iterator. */ public PhKnnQuerySF<T> nearestNeighbour(int nMin, PhDistanceSF distanceFunction, double ... center) { long[] lCenter = new long[2*dims]; pre.pre(center, center, lCenter); PhDistanceSF df = distanceFunction == null ? dist : distanceFunction; return new PhKnnQuerySF<>(pht.nearestNeighbour(nMin, df, null, lCenter), dims, pre); }