import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private void compute()
{
  // already computed
  if (minClearancePts != null) return;
  
  // initialize to "No Distance Exists" state
  minClearancePts = new Coordinate[2];
  minClearance = Double.MAX_VALUE;
  
  // handle empty geometries
  if (inputGeom.isEmpty()) {
    return;
  }
  
  STRtree geomTree = FacetSequenceTreeBuilder.build(inputGeom);
  
  Object[] nearest = geomTree.nearestNeighbour(new MinClearanceDistance());
  MinClearanceDistance mcd = new MinClearanceDistance();
  minClearance = mcd.distance(
      (FacetSequence) nearest[0],
      (FacetSequence) nearest[1]);
  minClearancePts = mcd.getCoordinates();
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
/**
     * Computes the union of the input geometries.
     *
     * @return the union of the input geometries
     * or null if no input geometries were provided
     */
    public Geometry union() {
        if (this.inputPolys.isEmpty()) {
            return null;
        }
        this.geomFactory = ((Geometry) this.inputPolys.iterator().next()).getFactory();

        /**
         * A spatial index to organize the collection
         * into groups of close geometries.
         * This makes unioning more efficient, since vertices are more likely
         * to be eliminated on each round.
         */
//    STRtree index = new STRtree();
        STRtree index = new STRtree(STRTREE_NODE_CAPACITY);
        for (Object inputPoly : inputPolys) {
            Geometry item = (Geometry) inputPoly;
            index.insert(item.getEnvelopeInternal(), item);
        }
        List itemTree = index.itemsTree();

//    printItemEnvelopes(itemTree);

        Geometry unionAll = this.unionTree(itemTree);
        return unionAll;
    }
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private void compute() {
    // already computed
    if (this.minClearancePts != null) {
        return;
    }

    // initialize to "No Distance Exists" state
    this.minClearancePts = new Coordinate[2];
    this.minClearance = Double.MAX_VALUE;

    // handle empty geometries
    if (this.inputGeom.isEmpty()) {
        return;
    }

    STRtree geomTree = FacetSequenceTreeBuilder.build(this.inputGeom);

    Object[] nearest = geomTree.nearestNeighbour(new MinClearanceDistance());
    MinClearanceDistance mcd = new MinClearanceDistance();
    this.minClearance = mcd.distance(
            (FacetSequence) nearest[0],
            (FacetSequence) nearest[1]);
    this.minClearancePts = mcd.getCoordinates();
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
public CountryBoundaries(GeometryCollection countriesBoundaries)
{
	index = new STRtree();
	geometrySizeCache = new HashMap<>(400);
	geometriesByIsoCodes = new HashMap<>(400);

	for(int i = 0; i < countriesBoundaries.getNumGeometries(); ++i)
	{
		Geometry countryBoundary = countriesBoundaries.getGeometryN(i);

		Map<String,String> props = (Map<String,String>) countryBoundary.getUserData();
		if(props == null) continue;
		if(props.containsKey(ISO3166_1_ALPHA2) || props.containsKey(ISO3166_2))
		{
			insertIntoIndex(countryBoundary);
			insertIntoIsoCodes(countryBoundary);

		}
	}
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private STRtree.STRtreeNode readSTRtreeNode(Kryo kryo, Input input){
    int level = input.readInt();
    STRtree.STRtreeNode node = new STRtree.STRtreeNode(level);
    int childrenSize = input.readInt();
    boolean isLeaf = (input.readByte() & 0x01) == 1;
    ArrayList children = new ArrayList();
    if(isLeaf){
        for(int i = 0;i < childrenSize; ++i){
            children.add(readItemBoundable(kryo, input));
        }
    }else{
        for(int i = 0;i < childrenSize; ++i){
            children.add(readSTRtreeNode(kryo, input));
        }
    }
    node.setChildBoundables(children);
    return node;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
@Override
public Iterator<T> call(Iterator<SpatialIndex> treeIndexes) throws Exception {
	SpatialIndex treeIndex = treeIndexes.next();
	final Object[] localK;
	if(treeIndex instanceof STRtree)
	{
		localK = ((STRtree)treeIndex).kNearestNeighbour(queryCenter.getEnvelopeInternal(), queryCenter, new GeometryItemDistance(), k);
	}
	else
	{
		throw new Exception("[KnnJudgementUsingIndex][Call] QuadTree index doesn't support KNN search.");
	}
	List<T> result = new ArrayList();
	for(int i=0;i<localK.length;i++)
	{
		result.add((T) localK[i]);
	}
	return result.iterator();
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
@Override
public void registerClasses(Kryo kryo) {
    GeometrySerde serializer = new GeometrySerde();
    SpatialIndexSerde indexSerializer = new SpatialIndexSerde(serializer);

    log.info("Registering custom serializers for geometry types");

    kryo.register(Point.class, serializer);
    kryo.register(LineString.class, serializer);
    kryo.register(Polygon.class, serializer);
    kryo.register(MultiPoint.class, serializer);
    kryo.register(MultiLineString.class, serializer);
    kryo.register(MultiPolygon.class, serializer);
    kryo.register(GeometryCollection.class, serializer);
    kryo.register(Circle.class, serializer);
    kryo.register(Envelope.class, serializer);
    // TODO: Replace the default serializer with default spatial index serializer
    kryo.register(Quadtree.class, indexSerializer);
    kryo.register(STRtree.class, indexSerializer);
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
@Test
    public void test() throws Exception {

        kryo.register(Quadtree.class, spatialIndexSerde);
        kryo.register(STRtree.class, spatialIndexSerde);

        // test correctness
        testCorrectness(Quadtree.class);
        testCorrectness(STRtree.class);

        // workbench of compare size
        compareSize(Quadtree.class);
        compareSize(STRtree.class);

//        // workbench of compare time
        compareTime(Quadtree.class);
        compareTime(STRtree.class);
    }
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
public void compareSize(Class aClass) throws IOException {
    final int indexSize = 10000;
    SpatialIndex tree = generateIndex(indexSize, aClass);

    // do without serde first
    byte[] noSerde = serializeIndexNoKryo(tree);

    // do with serde
    if(aClass == Quadtree.class) kryo.register(Quadtree.class, new SpatialIndexSerde());
    else kryo.register(STRtree.class, new SpatialIndexSerde());
    byte[] withSerde = serializeIndexKryo(tree);

    System.out.println("\n==== test size of " + aClass.toString() + "====");
    System.out.println("original size : " + noSerde.length);
    System.out.println("with serde kryo size : " + withSerde.length);
    System.out.println("percent : " + (double)withSerde.length / (double)noSerde.length);
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private void compute() {
    // already computed
    if (minClearancePts != null) return;

    // initialize to "No Distance Exists" state
    minClearancePts = new Coordinate[2];
    minClearance = Double.MAX_VALUE;

    // handle empty geometries
    if (inputGeom.isEmpty()) {
        return;
    }

    STRtree geomTree = FacetSequenceTreeBuilder.build(inputGeom);

    Object[] nearest = geomTree.nearestNeighbour(new MinClearanceDistance());
    MinClearanceDistance mcd = new MinClearanceDistance();
    minClearance = mcd.distance(
            (FacetSequence) nearest[0],
            (FacetSequence) nearest[1]);
    minClearancePts = mcd.getCoordinates();
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
/**
	 * Computes the union of the input geometries.
	 * 
	 * @return the union of the input geometries
	 * @return null if no input geometries were provided
	 */
	public Geometry union()
	{
		if (inputPolys.isEmpty())
			return null;
		geomFactory = ((Geometry) inputPolys.iterator().next()).getFactory();
		
		/**
		 * A spatial index to organize the collection
		 * into groups of close geometries.
		 * This makes unioning more efficient, since vertices are more likely 
		 * to be eliminated on each round.
		 */
//    STRtree index = new STRtree();
    STRtree index = new STRtree(STRTREE_NODE_CAPACITY);
    for (Iterator i = inputPolys.iterator(); i.hasNext(); ) {
      Geometry item = (Geometry) i.next();
      index.insert(item.getEnvelopeInternal(), item);
    }
    List itemTree = index.itemsTree();

//    printItemEnvelopes(itemTree);
    
    Geometry unionAll = unionTree(itemTree);
    return unionAll;
	}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
/**
	 * Computes the union of the input geometries.
	 * 
	 * @return the union of the input geometries
	 * or null if no input geometries were provided
	 */
	public Geometry union()
	{
		if (inputPolys.isEmpty())
			return null;
		geomFactory = ((Geometry) inputPolys.iterator().next()).getFactory();
		
		/**
		 * A spatial index to organize the collection
		 * into groups of close geometries.
		 * This makes unioning more efficient, since vertices are more likely 
		 * to be eliminated on each round.
		 */
//    STRtree index = new STRtree();
    STRtree index = new STRtree(STRTREE_NODE_CAPACITY);
    for (Iterator i = inputPolys.iterator(); i.hasNext(); ) {
      Geometry item = (Geometry) i.next();
      index.insert(item.getEnvelopeInternal(), item);
    }
    List itemTree = index.itemsTree();

//    printItemEnvelopes(itemTree);
    
    Geometry unionAll = unionTree(itemTree);
    return unionAll;
	}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
public void generate(File landsFile) {
    STRtree lands = lands(landsFile);

    List<Geometry> world = splittedWorld(lands);
    List<Geometry> oceans = oceans(lands, world);
    ShapefileWriter.write(new File("/workspace/oceans.shp"), oceans, MultiPolygon.class);
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static List<Geometry> splittedWorld(STRtree tree) {
    return LargePolygonSplitter.split(world(), 5, g -> {
        List<Geometry> query = tree.query(g.getEnvelopeInternal());
        return query.stream().mapToInt(Geometry::getNumPoints).sum() < 2000;
    });
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private static STRtree lands(File file) {
    STRtree tree = new STRtree();
    try (ShapefileIterator iterator = new ShapefileIterator(file, true)) {
        iterator.forEachRemaining(feature -> {
            for (Polygon polygon : PolygonsUtils.polygons(feature.getGeometry())) {
                for (Geometry p : LargePolygonSplitter.split(polygon, 30)) {
                    tree.insert(p.getEnvelopeInternal(), p);
                }
            }
        });
    }
    return tree;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static Geometry difference(STRtree tree, AtomicInteger counter, Geometry geom) {
    List<Geometry> query = tree.query(geom.getEnvelopeInternal());
    log.info("{} {} {}", counter.getAndDecrement(), query.size(), geom.getEnvelopeInternal());
    if (!query.isEmpty()) {
        List<Geometry> collect = query.stream().map(t -> t.buffer(DELTA)).collect(toList());
        return geom.difference(CascadedPolygonUnion.union(collect).buffer(-1 * DELTA));
    }
    return geom;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
public FilteredGeometrySerializer(TomtomWorld tomtom, GeometrySerializer serializer, MultiPolygon poly) {
    this.tree = new STRtree();
    for (Country country : tomtom.getCountries()) {
        Geometry geometry = country.getGeometry();
        for (Geometry geo : PolygonsUtils.polygons(geometry)) {
            List<Geometry> split = LargePolygonSplitter.split(geo, 10);
            for (Geometry g : split) {
                tree.insert(g.getEnvelopeInternal(), g);
            }
        }
    }
    this.serializer = serializer;
    this.poly = poly;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
public SplittedAreas() {
    try {
        this.tree = new STRtree();
        int i = 1;
        WKTReader reader = new WKTReader();
        for (String line : IOUtils.readLines(getClass().getResourceAsStream("/split.csv"), UTF_8)) {
            tree.insert(reader.read(line).getEnvelopeInternal(), String.valueOf(i++));
        }
    }
    catch (IOException | ParseException e) {
        throw propagate(e);
    }
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private static List createSTRTreeIndex(final List<Geometry> geomList) {
    final STRtree index = new STRtree(16);

    final PrecisionModel pm = new PrecisionModel(1000000);
    for (final Geometry item : geomList) {
        final Geometry g = GeometryPrecisionReducer.reduce(item, pm);
        index.insert(g.getEnvelopeInternal(), g);
    }

    return index.itemsTree();
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入依赖的package包/类
private void buildIndex() {
    this.index = new STRtree();

    for (Object ring1 : rings) {
        LinearRing ring = (LinearRing) ring1;
        Envelope env = ring.getEnvelopeInternal();
        this.index.insert(env, ring);
    }
}