Java STRtree.insert方法代码示例

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包/类
/**
	 * 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包/类
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包/类
public static STRtree build(Geometry g) {
    STRtree tree = new STRtree(STR_TREE_NODE_CAPACITY);
    List sections = computeFacetSequences(g);
    for (Object section1 : sections) {
        FacetSequence section = (FacetSequence) section1;
        tree.insert(section.getEnvelope(), section);
    }
    tree.build();
    return tree;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
public STRtreeJts(IFeatureCollection<Feat> collection) {
  this.collection = collection;
  stree = new STRtree();
  for (int i = 0; i < collection.size(); ++i) {
    IEnvelope egeox = collection.get(i).getGeom().getEnvelope();
    Envelope envelopeJts = new Envelope(egeox.maxX(), egeox.minX(),
        egeox.maxY(), egeox.minY());
    stree.insert(envelopeJts, i);
  }
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
@Override
public void validate () {
    // Project all stop coordinates and put them in a spatial index
    HashMap<Stop, Coordinate> projectedCoordinateForStop = new HashMap<>();
    STRtree stopSpatialIndex = new STRtree();
    for (Stop stop : feed.stops) {
        // Only validate point where vehicles stop, excluding logical "parent stations"
        if (stop.location_type != 0) continue;
        Coordinate projectedStopCoordinate = Util.projectLatLonToMeters(stop.stop_lat, stop.stop_lon);
        stopSpatialIndex.insert(new Envelope(projectedStopCoordinate), stop);
        projectedCoordinateForStop.put(stop, projectedStopCoordinate);
    }
    stopSpatialIndex.build();

    // Track which stops have already been reported in an error message so we don't report them more than once.
    Set<Stop> reportedStops = new HashSet<>();
    projectedCoordinateForStop.forEach((stop, coord) -> {
        if (reportedStops.contains(stop)) return;
        Envelope queryEnvelope = new Envelope(coord);
        queryEnvelope.expandBy(BUFFER_METERS);
        List<Stop> nearby = (List<Stop>)stopSpatialIndex.query(queryEnvelope).stream()
                .filter(s -> !reportedStops.contains(s)).collect(Collectors.toList());
        // The nearby stops list will include at least one stop, the one for which we're performing the query.
        // We want to include that one in the referenced entities along with the duplicates.
        if (nearby.size() > 1) {
            // TODO including bad_value and info entries - settle on one or the other
            String badStopIds = nearby.stream().map(Stop::getId).filter(s -> !s.equals(stop.stop_id))
                    .map(sid -> "stopId=" + sid).collect(Collectors.joining("; "));
            NewGTFSError error = NewGTFSError.forEntity(stop, DUPLICATE_STOP).setBadValue(badStopIds);
            int i = 1;
            for (Stop nearbyStop : nearby) {
                error.addInfo("stop_id " + i, nearbyStop.stop_id);
                i += 1;
            }
            registerError(error);
            reportedStops.addAll(nearby);
        }
    });
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
/**
 * Instantiates a new rtree partitioning.
 *
 * @param samples the sample list
 * @param partitions the partitions
 * @throws Exception the exception
 */
public RtreePartitioning(List<Envelope> samples, int partitions) throws Exception
{
	STRtree strtree=new STRtree(samples.size()/partitions);
	for (Envelope sample : samples) {
		strtree.insert(sample, sample);
   	}

   	List<Envelope> envelopes=strtree.queryBoundary();
	for (Envelope envelope : envelopes) {
   		grids.add(envelope);
   	}
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
/**
     * Computes the union of the input geometries.
     * <p/>
     * This method discards the input geometries as they are processed.
     * In many input cases this reduces the memory retained
     * as the operation proceeds.
     * Optimal memory usage is achieved
     * by disposing of the original input collection
     * before calling this method.
     *
     * @return the union of the input geometries
     * or null if no input geometries were provided
     * @throws IllegalStateException if this method is called more than once
     */
    public Geometry union() {
        if (inputPolys == null)
            throw new IllegalStateException("union() method cannot be called twice");
        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);
        }
        // To avoiding holding memory remove references to the input geometries,
        inputPolys = null;

        List itemTree = index.itemsTree();
//    printItemEnvelopes(itemTree);
        Geometry unionAll = unionTree(itemTree);
        return unionAll;
    }
 

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

    for (int i = 0; i < rings.size(); i++) {
        LinearRing ring = (LinearRing) rings.get(i);
        Envelope env = ring.getEnvelopeInternal();
        index.insert(env, ring);
    }
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
public static STRtree build(Geometry g) {
    STRtree tree = new STRtree(STR_TREE_NODE_CAPACITY);
    List sections = computeFacetSequences(g);
    for (Iterator i = sections.iterator(); i.hasNext(); ) {
        FacetSequence section = (FacetSequence) i.next();
        tree.insert(section.getEnvelope(), section);
    }
    tree.build();
    return tree;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
public void testDisallowedInserts() {
  STRtree t = new STRtree(5);
  t.insert(new Envelope(0, 0, 0, 0), new Object());
  t.insert(new Envelope(0, 0, 0, 0), new Object());
  t.query(new Envelope());
  try {
    t.insert(new Envelope(0, 0, 0, 0), new Object());
    assertTrue(false);
  }
  catch (AssertionFailedException e) {
    assertTrue(true);
  }
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
/** */
private void reindex () {
    _envelope = new Envelope();
    _spatialIndex = new STRtree();
    for (int i = 0; i < _features.size(); i += 1) {
        VectorFeature feature = _features.get(i);
        Envelope featureEnvelope = feature.getEnvelope();
        _envelope.expandToInclude(featureEnvelope);
        _spatialIndex.insert(featureEnvelope, feature);
    }
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
/**
 * Extracts features from a {@link FeatureCollection} into an {@link STRtree}.
 * 
 * @param collection the feature collection.
 * @return the tree containing the features.
 */
public static STRtree featureCollectionToSTRtree( SimpleFeatureCollection collection ) {
    STRtree tree = new STRtree();
    SimpleFeatureIterator featureIterator = collection.features();
    while( featureIterator.hasNext() ) {
        SimpleFeature feature = featureIterator.next();
        Geometry geometry = (Geometry) feature.getDefaultGeometry();
        tree.insert(geometry.getEnvelopeInternal(), feature);
    }
    featureIterator.close();
    return tree;
}
 

import com.vividsolutions.jts.index.strtree.STRtree; //导入方法依赖的package包/类
public void finalCleanup( final double pFinalCleanupDist ) {
    if (isFirstStatsCalculation) {
        throw new IllegalArgumentException("The first round needs to be filtered on all data.");
    }
    pm.beginTask("Creating points indexes...", leftOverCoordinateList.size());
    final STRtree leftOverCoordinatesTree = new STRtree(leftOverCoordinateList.size());
    for( Coordinate c : leftOverCoordinateList ) {
        leftOverCoordinatesTree.insert(new Envelope(c), c);
    }
    pm.done();

    final AtomicInteger removedCount = new AtomicInteger();
    Geometry[] triangles = getTriangles();
    final List<Coordinate> newLeftOverCoordinateList = new ArrayList<Coordinate>();
    pm.beginTask("Final cleanup through triangle to point distance filter...", triangles.length);
    ThreadedRunnable tRun = new ThreadedRunnable(threadsNum, null);
    for( int i = 0; i < triangles.length; i++ ) {
        final Geometry triangle = triangles[i];
        tRun.executeRunnable(new Runnable(){
            public void run() {
                runFinalFilter(leftOverCoordinatesTree, newLeftOverCoordinateList, triangle, pFinalCleanupDist, removedCount);
            }
        });
    }
    tRun.waitAndClose();
    pm.done();

    pm.message("Final points removed from non ground: " + removedCount.get());
    pm.message("Final points left as non ground: " + newLeftOverCoordinateList.size());
    leftOverCoordinateList.clear();
    leftOverCoordinateList.addAll(newLeftOverCoordinateList);
}