Java Relation.getRangeQuery方法代码示例

import de.lmu.ifi.dbs.elki.database.relation.Relation; //导入方法依赖的package包/类
/**
 * Run the leader clustering algorithm.
 * 
 * @param relation Data set
 * @return Clustering result
 */
public Clustering<PrototypeModel<O>> run(Relation<O> relation) {
  RangeQuery<O> rq = relation.getRangeQuery(getDistanceFunction(), threshold);

  ModifiableDBIDs seen = DBIDUtil.newHashSet(relation.size());
  Clustering<PrototypeModel<O>> clustering = new Clustering<>("Prototype clustering", "prototype-clustering");

  int queries = 0;
  FiniteProgress prog = LOG.isVerbose() ? new FiniteProgress("Leader clustering", relation.size(), LOG) : null;
  for(DBIDIter it = relation.iterDBIDs(); it.valid() && seen.size() < relation.size(); it.advance()) {
    if(seen.contains(it)) {
      continue;
    }
    DoubleDBIDList res = rq.getRangeForDBID(it, threshold);
    ++queries;
    ModifiableDBIDs ids = DBIDUtil.newArray(res.size());
    for(DBIDIter cand = res.iter(); cand.valid(); cand.advance()) {
      if(seen.add(cand)) {
        LOG.incrementProcessed(prog);
        ids.add(cand);
      }
    }
    assert (ids.size() > 0 && ids.contains(it));
    PrototypeModel<O> mod = new SimplePrototypeModel<>(relation.get(it));
    clustering.addToplevelCluster(new Cluster<>(ids, mod));
  }
  LOG.statistics(new LongStatistic(this.getClass().getName() + ".queries", queries));
  LOG.ensureCompleted(prog);
  return clustering;
}
 

import de.lmu.ifi.dbs.elki.database.relation.Relation; //导入方法依赖的package包/类
@Override
public <O> RangeQuery<O> getRangeQuery(DistanceQuery<O> distanceQuery, Object... hints) {
  @SuppressWarnings("unchecked")
  final Relation<O> relation = (Relation<O>) distanceQuery.getRelation();
  return relation.getRangeQuery(distanceQuery, hints);
}
 

import de.lmu.ifi.dbs.elki.database.relation.Relation; //导入方法依赖的package包/类
/**
 * Initializes the dimension selecting distancefunctions to determine the
 * preference vectors.
 *
 * @param relation the database storing the objects
 * @param dimensionality the dimensionality of the objects
 * @return the dimension selecting distancefunctions to determine the
 *         preference vectors
 */
private RangeQuery<V>[] initRangeQueries(Relation<V> relation, int dimensionality) {
  @SuppressWarnings("unchecked")
  RangeQuery<V>[] rangeQueries = (RangeQuery<V>[]) new RangeQuery[dimensionality];
  for(int d = 0; d < dimensionality; d++) {
    rangeQueries[d] = relation.getRangeQuery(new PrimitiveDistanceQuery<>(relation, new OnedimensionalDistanceFunction(d)));
  }
  return rangeQueries;
}
 

import de.lmu.ifi.dbs.elki.database.relation.Relation; //导入方法依赖的package包/类
/**
 * Get a range query object for the given distance function for radius-based
 * neighbor search. (Range queries in ELKI refers to radius-based ranges, not
 * rectangular query windows.)
 *
 * An index is used when possible, but it may fall back to a linear scan.
 *
 * Hints include:
 * <ul>
 * <li>Range: maximum range requested</li>
 * <li>{@link de.lmu.ifi.dbs.elki.database.query.DatabaseQuery#HINT_BULK} bulk
 * query needed</li>
 * </ul>
 *
 * @param <O> Object type
 * @param database Database
 * @param distanceFunction Distance function
 * @param hints Optimizer hints
 * @return KNN Query object
 */
public static <O> RangeQuery<O> getRangeQuery(Database database, DistanceFunction<? super O> distanceFunction, Object... hints) {
  final Relation<O> relation = database.getRelation(distanceFunction.getInputTypeRestriction(), hints);
  final DistanceQuery<O> distanceQuery = relation.getDistanceQuery(distanceFunction, hints);
  return relation.getRangeQuery(distanceQuery, hints);
}