Java Geometry类代码示例

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void testNegExtPolyRings() {
    try {
        // Single MultiPolygon with two triangles that have negative area from shoelace formula
        // Support for 'V1' MVTs.
        final JtsMvt mvt = loadMvt(
                "src/test/resources/mapbox/vector_tile_js/multi_poly_neg_exters.mvt",
                MvtReader.RING_CLASSIFIER_V1);
        final List<Geometry> geoms = getAllGeometries(mvt);

        assertEquals(1, geoms.size());
        assertTrue(geoms.get(0) instanceof MultiPolygon);
    } catch (IOException e) {
        fail(e.getMessage());
    }
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Override
public Object getDatabaseObject(GeometryObject geomObj, Connection connection) throws SQLException {
	Geometry geometry = null;

	switch (geomObj.getGeometryType()) {
	case POLYGON:
		geometry = convertPolygonToJTS(geomObj);
		break;
	case LINE_STRING:
	case POINT:
	case MULTI_LINE_STRING:
	case MULTI_POINT:
	case ENVELOPE:
	case MULTI_POLYGON:
	case SOLID:
	case COMPOSITE_SOLID:
		break;
	}

	if (geometry == null)
		throw new SQLException("Failed to convert geometry to internal database representation.");

	return geometry;		
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
/**
 * Validate the JtsLayer.
 *
 * @param name mvt layer name
 * @param geometries geometries in the tile
 * @throws IllegalArgumentException when {@code name} or {@code geometries} are null
 */
private static void validate(String name, Collection<Geometry> geometries) {
    if (name == null) {
        throw new IllegalArgumentException("layer name is null");
    }
    if (geometries == null) {
        throw new IllegalArgumentException("geometry collection is null");
    }
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
/**
 * Encode a {@link JtsMvt} to byte[] ready for writing to a file.
 *
 * @param mvt input to encode to bytes
 * @param mvtLayerParams tile creation parameters
 * @param userDataConverter converts {@link Geometry#userData} to MVT feature tags
 * @return bytes ready for writing to a .mvt
 */
public static byte[] encode(JtsMvt mvt, MvtLayerParams mvtLayerParams, IUserDataConverter userDataConverter) {

    // Build MVT
    final VectorTile.Tile.Builder tileBuilder = VectorTile.Tile.newBuilder();

    for(JtsLayer layer : mvt.getLayers()) {
        final Collection<Geometry> layerGeoms = layer.getGeometries();

        // Create MVT layer
        final VectorTile.Tile.Layer.Builder layerBuilder =
                MvtLayerBuild.newLayerBuilder(layer.getName(), mvtLayerParams);
        final MvtLayerProps layerProps = new MvtLayerProps();

        // MVT tile geometry to MVT features
        final List<VectorTile.Tile.Feature> features = JtsAdapter.toFeatures(
                layerGeoms, layerProps, userDataConverter);
        layerBuilder.addAllFeatures(features);
        MvtLayerBuild.writeProps(layerBuilder, layerProps);

        // Build MVT layer
        final VectorTile.Tile.Layer vtl = layerBuilder.build();
        tileBuilder.addLayers(vtl);
    }

    // Build MVT
    return tileBuilder.build().toByteArray();
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void singleLayer() throws IOException {
    Collection<Geometry> geometries = PointGen.australia();

    JtsLayer layer = new JtsLayer("animals", geometries);
    JtsMvt mvt = new JtsMvt(singletonList(layer));

    final byte[] encoded = MvtEncoder.encode(mvt);
    assertEquals(mvt, decode(encoded));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
private static Collection<Geometry> australia() {
    return getPoints(
            createPoint("Koala"),
            createPoint("Wombat"),
            createPoint("Platypus"),
            createPoint("Dingo"),
            createPoint("Croc"));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
private static Collection<Geometry> uk() {
    return getPoints(
            createPoint("Hare"),
            createPoint("Frog"),
            createPoint("Robin"),
            createPoint("Fox"),
            createPoint("Hedgehog"),
            createPoint("Bulldog"));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
private static Collection<Geometry> usa() {
    return getPoints(
            createPoint("Cougar"),
            createPoint("Raccoon"),
            createPoint("Beaver"),
            createPoint("Wolf"),
            createPoint("Bear"),
            createPoint("Coyote"));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void testLayerCollection() {
    String layerName = "Points of Interest";
    List<Geometry> geometries = new ArrayList<>();

    JtsLayer layer = new JtsLayer(layerName, geometries);

    String actualName = layer.getName();
    String expectedName = layerName;
    assertEquals(expectedName, actualName);

    Collection<Geometry> actualGeometry = layer.getGeometries();
    Collection<Geometry> expectedGeometry = geometries;
    assertEquals(expectedGeometry, actualGeometry);
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void testAddGeometry() {
    String layerName = "Points of Interest";
    List<Geometry> geometries = new ArrayList<>();

    Point point = createPoint(new int[]{51, 0});

    JtsLayer layer = new JtsLayer(layerName, geometries);
    layer.getGeometries().add(point);

    assertTrue(layer.getGeometries().contains(point));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void testAddGeometries() {
    String layerName = "Points of Interest";
    List<Geometry> geometries = new ArrayList<>();

    Point point = createPoint(new int[]{50, 0});
    Point point2 = createPoint(new int[]{51, 1});
    Collection<Geometry> points = Arrays.asList(point, point2);

    JtsLayer layer = new JtsLayer(layerName, geometries);
    layer.getGeometries().addAll(points);

    assertTrue(layer.getGeometries().containsAll(Arrays.asList(point, point2)));
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
@Test
public void simpleTest() {
    try {
        // Load multipolygon z0 tile
        final JtsMvt mvt = loadMvt("src/test/resources/vec_tile_test/0/0/0.mvt");

        List<Geometry> geoms = getAllGeometries(mvt);

        // Debug stats of multipolygon
        final JtsGeomStats stats = JtsGeomStats.getStats(geoms);
        LoggerFactory.getLogger(MvtReaderTest.class).info("Stats: {}", stats);
    } catch (IOException e) {
        fail(e.getMessage());
    }
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
private List<Geometry> getAllGeometries(JtsMvt mvt) {
    List<Geometry> allGeoms = new ArrayList<>();
    for (JtsLayer l : mvt.getLayers()) {
        allGeoms.addAll(l.getGeometries());
    }
    return allGeoms;
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
private static Collection<Geometry> getPoints(Point... points) {
    return asList(points);
}
 

import org.locationtech.jts.geom.Geometry; //导入依赖的package包/类
/**
 * Create TileGeomResult, which contains the intersection of geometry and MVT geometry.
 *
 * @param intGeoms geometry intersecting tile
 * @param mvtGeoms geometry for MVT
 * @throws NullPointerException if intGeoms or mvtGeoms are null
 */
public TileGeomResult(List<Geometry> intGeoms, List<Geometry> mvtGeoms) {
    JdkUtils.requireNonNull(intGeoms);
    JdkUtils.requireNonNull(mvtGeoms);
    this.intGeoms = intGeoms;
    this.mvtGeoms = mvtGeoms;
}