org.apache.lucene.spatial.prefix.RecursivePrefixTreeStrategy Java Examples

protected RecursivePrefixTreeStrategy makeRPTStrategy(String spatialField, Config config,
                                                      Map<String, String> configMap, SpatialContext ctx) {
  //A factory for the prefix tree grid
  SpatialPrefixTree grid = SpatialPrefixTreeFactory.makeSPT(configMap, null, ctx);

  RecursivePrefixTreeStrategy strategy = new RecursivePrefixTreeStrategy(grid, spatialField);
  strategy.setPointsOnly(config.get("spatial.docPointsOnly", false));
  final boolean pruneLeafyBranches = config.get("spatial.pruneLeafyBranches", true);
  if (grid instanceof PackedQuadPrefixTree) {
    ((PackedQuadPrefixTree) grid).setPruneLeafyBranches(pruneLeafyBranches);
    strategy.setPruneLeafyBranches(false);//always leave it to packed grid, even though it isn't the same
  } else {
    strategy.setPruneLeafyBranches(pruneLeafyBranches);
  }

  int prefixGridScanLevel = config.get("query.spatial.prefixGridScanLevel", -4);
  if (prefixGridScanLevel < 0)
    prefixGridScanLevel = grid.getMaxLevels() + prefixGridScanLevel;
  strategy.setPrefixGridScanLevel(prefixGridScanLevel);

  double distErrPct = config.get("spatial.distErrPct", .025);//doc & query; a default
  strategy.setDistErrPct(distErrPct);
  return strategy;
}
 

@Test
public void testEqualsHashCode() {

  switch (random().nextInt(4)) {//0-3
    case 0: predicate = SpatialOperation.Contains; break;
    case 1: predicate = SpatialOperation.IsWithin; break;

    default: predicate = SpatialOperation.Intersects; break;
  }
  final SpatialPrefixTree gridQuad = new QuadPrefixTree(ctx,10);
  final SpatialPrefixTree gridGeohash = new GeohashPrefixTree(ctx,10);

  Collection<SpatialStrategy> strategies = new ArrayList<>();
  RecursivePrefixTreeStrategy recursive_geohash = new RecursivePrefixTreeStrategy(gridGeohash, "recursive_geohash");
  strategies.add(recursive_geohash);
  strategies.add(new TermQueryPrefixTreeStrategy(gridQuad, "termquery_quad"));
  strategies.add(PointVectorStrategy.newInstance(ctx, "pointvector"));
  strategies.add(BBoxStrategy.newInstance(ctx, "bbox"));
  final SerializedDVStrategy serialized = new SerializedDVStrategy(ctx, "serialized");
  strategies.add(serialized);
  strategies.add(new CompositeSpatialStrategy("composite", recursive_geohash, serialized));
  for (SpatialStrategy strategy : strategies) {
    testEqualsHashcode(strategy);
  }
}
 

protected Function<String, ? extends SpatialStrategy> createSpatialStrategyMapper(Map<String, String> parameters) {
	ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
	SpatialContext geoContext = SpatialContextFactory.makeSpatialContext(parameters, classLoader);
	final SpatialPrefixTree spt = SpatialPrefixTreeFactory.makeSPT(parameters, classLoader, geoContext);
	return new Function<String, SpatialStrategy>() {

		@Override
		public SpatialStrategy apply(String field) {
			return new RecursivePrefixTreeStrategy(spt, GEO_FIELD_PREFIX + field);
		}

	};
}
 

protected void init() {
  //Typical geospatial context
  //  These can also be constructed from SpatialContextFactory
  this.ctx = SpatialContext.GEO;

  int maxLevels = 11;//results in sub-meter precision for geohash
  //TODO demo lookup by detail distance
  //  This can also be constructed from SpatialPrefixTreeFactory
  SpatialPrefixTree grid = new GeohashPrefixTree(ctx, maxLevels);

  this.strategy = new RecursivePrefixTreeStrategy(grid, "myGeoField");

  this.directory = new ByteBuffersDirectory();
}
 

@Override
protected RecursivePrefixTreeStrategy newPrefixTreeStrategy(String fieldName) {
  RecursivePrefixTreeStrategy strategy = new RecursivePrefixTreeStrategy(grid, fieldName);
  if (prefixGridScanLevel != null)
    strategy.setPrefixGridScanLevel(prefixGridScanLevel);
  if (grid instanceof PackedQuadPrefixTree) {
    // This grid has a (usually) better prune leafy branch implementation
    ((PackedQuadPrefixTree) grid).setPruneLeafyBranches(true);
    strategy.setPruneLeafyBranches(false);
  }
  return strategy;
}
 

public OLuceneSpatialIndexManager(OShapeFactory factory) {
  super();
  this.ctx = SpatialContext.GEO;
  this.factory = factory;
  SpatialPrefixTree grid = new GeohashPrefixTree(ctx, 11);
  this.strategy = new RecursivePrefixTreeStrategy(grid, "location");
}
 

public CompositeSpatialStrategy(String fieldName,
                                RecursivePrefixTreeStrategy indexStrategy, SerializedDVStrategy geometryStrategy) {
  super(indexStrategy.getSpatialContext(), fieldName);//field name; unused
  this.indexStrategy = indexStrategy;
  this.geometryStrategy = geometryStrategy;
}
 

public RecursivePrefixTreeStrategy getIndexStrategy() {
  return indexStrategy;
}
 

protected RecursivePrefixTreeStrategy newRPT() {
  final RecursivePrefixTreeStrategy rpt = new RecursivePrefixTreeStrategy(this.grid,
      getClass().getSimpleName() + "_rpt");
  rpt.setDistErrPct(0.10);//not too many cells
  return rpt;
}
 

protected RecursivePrefixTreeStrategy newRPT() {
  final RecursivePrefixTreeStrategy rpt = new RecursivePrefixTreeStrategy(this.grid,
      getClass().getSimpleName() + "_rpt");
  rpt.setDistErrPct(0.10);//not too many cells
  return rpt;
}
 

@Override
protected CompositeSpatialStrategy newSpatialStrategy(String fieldName) {
  // We use the same field name for both sub-strategies knowing there will be no conflict for these two

  RecursivePrefixTreeStrategy rptStrategy = rptFieldType.newSpatialStrategy(fieldName);

  SerializedDVStrategy geomStrategy = new CachingSerializedDVStrategy(ctx, fieldName);

  return new CompositeSpatialStrategy(fieldName, rptStrategy, geomStrategy);
}