import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
public static void iterateOverTriangles(final Polygon polygon, final Consumer<Geometry> action) {
	final double elevation = getContourCoordinates(polygon).averageZ();
	final double sizeTol = FastMath.sqrt(polygon.getArea()) / 100.0;
	final DelaunayTriangulationBuilder dtb = new DelaunayTriangulationBuilder();
	final PreparedGeometry buffered = PREPARED_GEOMETRY_FACTORY.create(polygon.buffer(sizeTol, 5, 0));
	final Envelope3D env = Envelope3D.of(buffered.getGeometry());
	try {
		dtb.setSites(polygon);
		dtb.setTolerance(sizeTol);
		applyToInnerGeometries(dtb.getTriangles(GEOMETRY_FACTORY), (gg) -> {
			final ICoordinates cc = getContourCoordinates(gg);
			if (cc.isCoveredBy(env) && buffered.covers(gg)) {
				cc.setAllZ(elevation);
				gg.geometryChanged();
				action.accept(gg);
			}
		});
	} catch (final LocateFailureException | ConstraintEnforcementException e) {
		final IScope scope = GAMA.getRuntimeScope();
		GamaRuntimeException.warning("Impossible to triangulate: " + new WKTWriter().write(polygon), scope);
		iterateOverTriangles((Polygon) DouglasPeuckerSimplifier.simplify(polygon, 0.1), action);
		return;
	}
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private static IShape difference(final IScope scope, final IShape geom, final List<IShape> geoms,
		final PreparedGeometry ref) {
	if (geom == null) { return null; }
	IShape gR = new GamaShape(geom);
	for (final IShape g : geoms) {

		if (g != null && geom.intersects(g)) {
			gR = Spatial.Operators.minus(scope, gR, g);
			if (gR == null)
				return null;
			if (gR.getGeometries().size() > 1) {
				for (final IShape sh : gR.getGeometries()) {
					if (!ref.disjoint(sh.getInnerGeometry())) {
						gR = sh;
						break;
					}
				}
			} else if (ref.disjoint(gR.getInnerGeometry())) { return null; }
		}
	}

	return gR;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
public static void main(String[] args)
        throws Exception {
    Geometry circle = createCircle();
    PreparedGeometry prepCircle = PreparedGeometryFactory.prepare(circle);

    int count = 0;
    int inCount = 0;
    for (int i = 0; i < MAX_ITER; i++) {
        count++;
        Point randPt = createRandomPoint();
        if (prepCircle.intersects(randPt)) {
            inCount++;
        }

        //System.out.println("Approximation to PI: " + (4.0 * inCount / (double) count));
    }
    double approxPi = 4.0 * inCount / (double) count;
    double approxDiffPct = 1.0 - approxPi / Math.PI;

    System.out.println("Approximation to PI: " + approxPi
            + "  ( % difference from actual = " + 100 * approxDiffPct + " )"
    );

}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
/**
 * Finds all {@link PreparedGeometry}s which intersect a given {@link Geometry}
 *
 * @param g the geometry to query by
 * @return a list of intersecting PreparedGeometrys
 */
public List intersects(Geometry g) {
    List result = new ArrayList();
    List candidates = query(g);
    for (Iterator it = candidates.iterator(); it.hasNext(); ) {
        PreparedGeometry prepGeom = (PreparedGeometry) it.next();
        if (prepGeom.intersects(g)) {
            result.add(prepGeom);
        }
    }
    return result;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
/** */
public List<VectorFeature> intersectingFeatures (Geometry geom) {
    final PreparedGeometry pGeom = PreparedGeometryFactory.prepare(geom);
    final List<VectorFeature> result = new ArrayList<VectorFeature>();
    _spatialIndex.query(geom.getEnvelopeInternal(), new ItemVisitor() {
            public void visitItem (Object item) {
                VectorFeature feature = (VectorFeature)item;
                if (pGeom.intersects(feature.getGeometry())) {
                    result.add(feature);
                }
            }
        });
    return result;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private static TimedPosition findRegionCrossingPoint(Shapefile region, Fix fix1, Fix fix2) {

        Coordinate[] coords = new Coordinate[] { new Coordinate(fix1.lon(), fix1.lat()),
                new Coordinate(fix2.lon(), fix2.lat()) };
        LineString line = new GeometryFactory().createLineString(coords);
        for (PreparedGeometry g : region.geometries()) {
            if (g.crosses(line)) {
                Geometry intersection = g.getGeometry().intersection(line);
                // expecting just one point
                Coordinate coord = intersection.getCoordinate();
                double longitude = coord.x;
                double latitude = coord.y;
                Position a = Position.create(fix1.lat(), fix1.lon());
                Position b = Position.create(fix2.lat(), fix2.lon());
                Position c = Position.create(latitude, longitude);
                double ac = a.getDistanceToKm(c);
                double bc = b.getDistanceToKm(c);
                if (ac == 0) {
                    return new TimedPosition(fix1.lat(), fix1.lon(), fix1.time());
                } else if (bc == 0) {
                    return new TimedPosition(fix2.lat(), fix2.lon(), fix2.time());
                } else {
                    // predict the timestamp based on distance from a and b
                    long diff = fix2.time() - fix1.time();
                    long t = Math.round(fix1.time() + ac * diff / (ac + bc));
                    return new TimedPosition(latitude, longitude, t);
                }
            }
        }
        throw new RuntimeException("crossing not found");
    }
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
public static boolean contains(GeometryFactory gf, Collection<PreparedGeometry> geometries,
        double lat, double lon) {
    Point point = gf.createPoint(new Coordinate(lon, lat));
    for (PreparedGeometry g : geometries) {
        if (g.contains(point))
            return true;
    }
    return false;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private Shapefile load() {
    if (state.compareAndSet(NOT_LOADED, LOADED)) {
        try {
            final List<PreparedGeometry> geometries = new ArrayList<>();
            for (String typeName : datastore.getTypeNames()) {
                SimpleFeatureSource source = datastore.getFeatureSource(typeName);
                crs = source.getBounds().getCoordinateReferenceSystem();
                final SimpleFeatureCollection features = source.getFeatures();
                SimpleFeatureIterator it = features.features();
                while (it.hasNext()) {
                    SimpleFeature feature = it.next();
                    Geometry g = (Geometry) feature.getDefaultGeometry();
                    if (bufferDistance > 0)
                        g = g.buffer(bufferDistance);
                    geometries.add(PreparedGeometryFactory.prepare(g));
                    this.features.add(feature);
                }
                it.close();
            }
            this.geometries = geometries;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    } else if (state.get() == CLOSED)
        throw new RuntimeException("Shapefile is closed and can't be accessed");
    return this;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
public Rect mbr() {
    // TODO assumes that shapefile is using WGS84?
    load();
    Rect r = null;
    for (PreparedGeometry g : geometries) {
        Coordinate[] v = g.getGeometry().getEnvelope().getCoordinates();
        System.out.println(Arrays.toString(v));
        Rect rect = new Rect(v[0].y, v[0].x, v[2].y, v[2].x);
        if (r == null)
            r = rect;
        else
            r = r.add(rect);
    }
    return r;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private static boolean contains(GeometryFactory gf, Collection<PreparedGeometry> geometries,
        double lat, double lon) {
    for (PreparedGeometry g : geometries) {
        if (g.contains(gf.createPoint(new Coordinate(lon, lat))))
            return true;
    }
    return false;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private void linkBasinWithNetwork() throws Exception {
    FeatureExtender fExt = new FeatureExtender(inNetwork.getSchema(), new String[]{NetworkChannel.NETNUMNAME},
            new Class[]{Integer.class});

    DefaultFeatureCollection newCollection = new DefaultFeatureCollection();

    SimpleFeatureIterator hillslopeFeatures = inHillslope.features();
    while( hillslopeFeatures.hasNext() ) {
        SimpleFeature hFeature = hillslopeFeatures.next();
        Object netNum = hFeature.getAttribute(NetworkChannel.NETNUMNAME);
        Geometry hGeometry = (Geometry) hFeature.getDefaultGeometry();
        PreparedGeometry preparedHGeometry = PreparedGeometryFactory.prepare(hGeometry);
        SimpleFeatureIterator netFeatures = inNetwork.features();
        while( netFeatures.hasNext() ) {
            SimpleFeature nFeature = netFeatures.next();
            Geometry geometry = (Geometry) nFeature.getDefaultGeometry();
            if (geometry.getNumGeometries() != 1) {
                throw new ModelsRuntimeException("The network geometries have to be single lines.", this);
            }
            LineString nLine = (LineString) geometry.getGeometryN(0);
            Point startPoint = nLine.getStartPoint();
            if (preparedHGeometry.contains(startPoint)) {
                SimpleFeature extendFeature = fExt.extendFeature(nFeature, new Object[]{netNum});
                newCollection.add(extendFeature);
                break;
            }
        }
    }
    inNetwork = newCollection;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
@Override
public boolean compare(
		final Geometry dataGeometry,
		final PreparedGeometry constraintGeometry ) {
	// This method is same as Geometry.equalsTopo which is
	// computationally expensive.
	// See equalsExact for quick structural equality
	return constraintGeometry.getGeometry().equals(
			dataGeometry);
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private PreparedFeature(
        final Feature feature,
        final PreparedGeometry preparedGeometry)
{
    this.feature = feature;
    this.preparedGeometry = preparedGeometry;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
@Override
public void setup(
        final Configuration configuration,
        final List<ColumnInterface> columnList) throws IOException
{
    m_spatialIndex = new STRtree();
    m_buffer = configuration.getFloat(GeoEnrichmentJob.KEY_BUFFER, 0.000001F);

    final URL url = getUrl(configuration);
    final ShapefileDataStoreFactory factory = new ShapefileDataStoreFactory();
    final Map params = new HashMap();
    params.put(ShapefileDataStoreFactory.URLP.key, url);
    final DataStore dataStore = factory.createDataStore(params);
    try
    {
        final String[] typeNames = dataStore.getTypeNames();
        final SimpleFeatureSource featureSource = dataStore.getFeatureSource(typeNames[0]);
        m_geometryName = featureSource.getSchema().getGeometryDescriptor().getLocalName();
        final SimpleFeatureCollection featureCollection = featureSource.getFeatures();
        featureCollection.accepts(new FeatureVisitor()
        {
            public void visit(final Feature feature)
            {
                final Geometry geometry = (Geometry) feature.getProperty(m_geometryName).getValue();
                final PreparedGeometry preparedGeometry = PreparedGeometryFactory.prepare(geometry);
                m_spatialIndex.insert(geometry.getEnvelopeInternal(), new PreparedFeature(feature, preparedGeometry));
            }
        }, new NullProgressListener());
    }
    finally
    {
        dataStore.dispose();
    }
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private static Geometry intersectionSim(
    PreparedGeometry pg, Geometry g2)
{
  PreparedPolygon ppoly = (PreparedPolygon) pg;
  FastSegmentSetIntersectionFinder intf = ppoly.getIntersectionFinder();
  
  Coordinate[] pts = g2.getCoordinates();
  
  List segStrings = SegmentStringUtil.extractSegmentStrings(g2);
  intf.intersects(segStrings );
  return g2;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
private static PreparedGeometry cacheFind(Geometry g)
{
  PreparedGeometry pg = cache.get(g);
  if (pg == null) {
    pg = PreparedGeometryFactory.prepare(g);
    cache.put(g, pg);
    //System.out.println("cache size = " + cache.size());
  }
  return pg;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
/**
 * Creates a prepared geometry. <p> Prepared geometries make operations like intersection must faster. </p>
 */
public static PreparedGeometry prepare(Geometry g) {
  return PreparedGeometryFactory.prepare(g);
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
@operator (
		value = "masked_by",
		category = { IOperatorCategory.SPATIAL },
		concept = { IConcept.GEOMETRY, IConcept.SPATIAL_COMPUTATION, IConcept.OBSTACLE })
@doc (
		examples = { @example (
				value = "perception_geom masked_by obstacle_list",
				equals = "the geometry representing the part of perception_geom visible from the agent position considering the list of obstacles obstacle_list.",
				isExecutable = false) })
public static IShape masked_by(final IScope scope, final IShape source, final IContainer<?, IShape> obstacles,
		Integer precision) {
	final IAgent a = scope.getAgent();
	final List<IShape> obst =
			obstacles == null ? new ArrayList<IShape>() : obstacles.listValue(scope, Types.GEOMETRY, false);
	final ILocation location = a != null ? a.getLocation() : new GamaPoint(0, 0);
	if (precision == null) {
		precision = 120;
	}
	final Geometry visiblePercept = GeometryUtils.GEOMETRY_FACTORY.createGeometry(source.getInnerGeometry());
	final boolean isPoint = source.isPoint();
	if (obstacles != null && !obstacles.isEmpty(scope)) {
		final Geometry pt = GeometryUtils.GEOMETRY_FACTORY.createPoint(GeometryUtils.toCoordinate(location));
		final Geometry locG = pt.buffer(0.01).getEnvelope();
		double percep_dist = 0;
		for (final ILocation p : source.getPoints()) {
			final double dist = location.euclidianDistanceTo(p);
			if (dist > percep_dist) {
				percep_dist = dist;
			}
		}
		final Geometry gbuff = pt.buffer(percep_dist, precision / 4);
		final List<IShape> geoms = new ArrayList<IShape>();
		for (int k = 1; k < gbuff.getNumPoints(); k++) {
			final IList coordinates = GamaListFactory.create(Types.POINT, 4);
			coordinates.add(location);
			coordinates.add(new GamaPoint(gbuff.getCoordinates()[k - 1]));
			coordinates.add(new GamaPoint(gbuff.getCoordinates()[k]));
			coordinates.add(location);
			final IShape gg =
					Spatial.Operators.inter(scope, source, Spatial.Creation.polygon(scope, coordinates));
			if (gg != null && (isPoint || !gg.isPoint())) {
				geoms.add(new GamaShape(gg));
			}
		}
		final GamaList geomsVisible = (GamaList) GamaListFactory.create();
		final PreparedGeometry ref = PreparedGeometryFactory.prepare(locG);

		for (final IShape geom : geoms) {
			if (!intersection(geom, obst)) {
				geomsVisible.addValue(scope, geom);
			} else {
				final IShape perceptReal = difference(scope, geom, obst, ref);

				if (perceptReal != null && (isPoint || !perceptReal.isPoint())) {
					geomsVisible.addValue(scope, perceptReal);
				}
			}
		}
		if (!geomsVisible.isEmpty(scope)) {
			IShape result = Cast.asGeometry(scope, geomsVisible, false);
			if (result.getInnerGeometry() instanceof GeometryCollection) {
				result = Spatial.Transformations.enlarged_by(scope, result, 0.1);
			}
			return result;
		}
		return null;
	}
	return new GamaShape(visiblePercept);
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
public List<PreparedGeometry> geometries() {
    load();
    return geometries;
}
 

import com.vividsolutions.jts.geom.prep.PreparedGeometry; //导入依赖的package包/类
@Execute
public void process() throws Exception {
    checkNull(inRaster);

    ISurfaceInterpolator interpolator;
    if (pMode.equals(IDW)) {
        interpolator = new IDWInterpolator(pBuffer);
    } else {
        interpolator = new TPSInterpolator(pBuffer);
    }

    RegionMap regionMap = CoverageUtilities.getRegionParamsFromGridCoverage(inRaster);
    int rows = regionMap.getRows();
    int cols = regionMap.getCols();

    WritableRaster outWR = CoverageUtilities.renderedImage2WritableRaster(inRaster.getRenderedImage(), false);
    WritableRandomIter outIter = CoverageUtilities.getWritableRandomIterator(outWR);

    GridGeometry2D gridGeometry = inRaster.getGridGeometry();

    PreparedGeometry preparedRoi = null;
    if (inROI != null) {
        List<Geometry> roiList = FeatureUtilities.featureCollectionToGeometriesList(inROI, false, null);
        GeometryCollection gc = new GeometryCollection(roiList.toArray(GeometryUtilities.TYPE_GEOMETRY), gf);
        preparedRoi = PreparedGeometryFactory.prepare(gc);
    }
    pm.beginTask("Filling holes...", cols - 2);
    for( int c = 1; c < cols - 1; c++ ) {
        for( int r = 1; r < rows - 1; r++ ) {
            if (pm.isCanceled()) {
                return;
            }

            double value = outIter.getSampleDouble(c, r, 0);
            if (isNovalue(value)) {
                DirectPosition worldPosition = gridGeometry.gridToWorld(new GridCoordinates2D(c, r));
                double[] coordinate = worldPosition.getCoordinate();
                Coordinate pointCoordinate = new Coordinate(coordinate[0], coordinate[1]);
                Point point = gf.createPoint(pointCoordinate);
                if (preparedRoi == null || preparedRoi.intersects(point)) {

                    // TODO this could be done considering more points and more far away points.
                    // For now, this works.
                    List<Coordinate> surroundingValids = getValidSurroundingPoints(outIter, gridGeometry, c, r);
                    if (surroundingValids.size() > 3) {
                        double newValue = interpolator.getValue(surroundingValids.toArray(new Coordinate[0]),
                                pointCoordinate);
                        outIter.setSample(c, r, 0, newValue);
                    }
                }
            }
        }
        pm.worked(1);
    }
    pm.done();

    outIter.done();

    outRaster = CoverageUtilities.buildCoverage("nulled", outWR, regionMap, inRaster.getCoordinateReferenceSystem());
}