org.locationtech.jts.geom.PrecisionModel Java Examples

public Geometry getGeometry() {
    if (isSetGeometry()) {
        TreeMap<Time, Coordinate> map = new TreeMap<>();
        int srid = -1;
        for (ProfileLevel level : getValue()) {
            if (level.isSetPhenomenonTime() && level.isSetLocation()) {
                if (srid < 0) {
                    srid = level.getLocation().getSRID();
                }
                map.put(level.getPhenomenonTime(), level.getLocation().getCoordinate());
            }
        }
        if (!map.isEmpty()) {
            if (new HashSet<>(map.values()).size() == 1) {
                return getValue().iterator().next().getLocation();
            } else {
                return new GeometryFactory(new PrecisionModel(), srid)
                        .createLineString(map.values().toArray(new Coordinate[1]));
            }
        }
    }
    return null;
}
 

@Test
public final void should_have_SpatialFilteringProfileParameter() throws OwsExceptionReport, DecodingException {
    OmObservation omObservation = new OmObservation();
    NamedValue<Geometry> namedValue = new NamedValue<>();
    namedValue.setName(new ReferenceType(OmConstants.PARAM_NAME_SAMPLING_GEOMETRY));
    GeometryFactory fac = new GeometryFactory(new PrecisionModel(PrecisionModel.FLOATING), 4326);
    namedValue.setValue(new GeometryValue(fac.createPoint(new Coordinate(34.5, 76.4))));
    // test no parameter is set
    assertFalse(omObservation.isSetParameter());
    assertFalse(omObservation.isSetSpatialFilteringProfileParameter());
    omObservation.addParameter(namedValue);
    // test with set SpatialFilteringProfile parameter
    assertTrue(omObservation.isSetParameter());
    assertTrue(omObservation.isSetSpatialFilteringProfileParameter());
    assertThat(omObservation.getSpatialFilteringProfileParameter(), is(equalTo(namedValue)));
}
 

/**
 * Tries to split an invalid polygon in its {@link GeometryCollection}.
 * <p/>
 * <p>Based on JTSBuilder code.
 *
 * @param invalidPolygon the invalid polygon.
 * @return the geometries.
 */
@SuppressWarnings("rawtypes")
public static Geometry invalidPolygonSplit(Geometry invalidPolygon) {
    PrecisionModel pm = new PrecisionModel(10000000);
    GeometryFactory geomFact = invalidPolygon.getFactory();
    List lines = LinearComponentExtracter.getLines(invalidPolygon);
    List nodedLinework = new GeometryNoder(pm).node(lines);
    // union the noded linework to remove duplicates
    Geometry nodedDedupedLinework = geomFact.buildGeometry(nodedLinework).union();
    // polygonize the result
    Polygonizer polygonizer = new Polygonizer();
    polygonizer.add(nodedDedupedLinework);
    Collection polys = polygonizer.getPolygons();
    // convert to collection for return
    Polygon[] polyArray = GeometryFactory.toPolygonArray(polys);
    return geomFact.createGeometryCollection(polyArray);
}
 

@BeforeEach
public void setup() {
    this.parser = new ODataFesParser();
    this.geometryFactory = new GeometryFactory(new PrecisionModel(PrecisionModel.FLOATING_SINGLE), 4326);
    this.polygon = this.geometryFactory
            .createPolygon(new Coordinate[] {
                    new Coordinate(-15.46, 77.98), new Coordinate(-93.51, 38.27),
                    new Coordinate(47.10, -1.05), new Coordinate(58.71, 70.61), new Coordinate(-15.46, 77.98)
            });
    this.wktGeometry = new WKTWriter().write(polygon).replaceFirst(" ", "").replaceAll(", ", ",");
}
 

/**
 * Convert to org.locationtech.jts.geom geometry.
 *
 * @param wktString the wkt string
 * @param crsCode the crs code
 * @return the geometry
 */
public static Geometry convertToGeometry(String wktString, String crsCode) {
    int srid = 0;

    if (crsCode != null) {
        CoordinateReferenceSystem crs = CoordManager.getInstance().getCRS(crsCode);
        String sridString = CRS.toSRS(crs, true);
        srid = Integer.parseInt(sridString);
    }
    org.locationtech.jts.geom.GeometryFactory geometryFactory =
            new org.locationtech.jts.geom.GeometryFactory(new PrecisionModel(), srid);

    WKTReader parser = new WKTReader(geometryFactory);

    if (wktString.startsWith(WKT_PREFIX)) {
        wktString = wktString.substring(WKT_PREFIX.length());
    }

    Geometry shape = null;
    try {
        shape = parser.read(wktString);
    } catch (org.locationtech.jts.io.ParseException e) {
        ConsoleManager.getInstance().exception(WKTConversion.class, e);
    }

    return shape;
}
 

/**
 * Project geometry.
 *
 * @param originalGeom
 *            the original geom
 * @param srcCRSCode
 *            the src crs code
 * @param trgCRSCode
 *            the trg crs code
 * @return the geometry
 * @throws NoSuchAuthorityCodeException
 *             the no such authority code exception
 * @throws FactoryException
 *             the factory exception
 * @throws MismatchedDimensionException
 *             the mismatched dimension exception
 * @throws TransformException
 *             the transform exception
 */
public static Geometry projectGeometry(Geometry originalGeom, String srcCRSCode,
    String trgCRSCode) throws NoSuchAuthorityCodeException, FactoryException, MismatchedDimensionException,
    TransformException
{

    Geometry projectedGeometry = null;
    final MathTransform transform = CRS.findMathTransform(CRS.decode(srcCRSCode, true), CRS.decode(trgCRSCode, true), true);

    // converting geometries into a linear system
    try
    {
        projectedGeometry = JTS.transform(originalGeom, transform);
    }
    catch (Exception e)
    {
        GeometryFactory geometryFactory = new GeometryFactory(new PrecisionModel(
                    PrecisionModel.FLOATING), 4326);
        WKTReader reader = new WKTReader(geometryFactory);

        try
        {
            Polygon worldCutPolygon = (Polygon) reader.read("POLYGON((-180 -89.9, -180 89.9, 180 89.9, 180 -89.9, -180 -89.9))");

            projectedGeometry = JTS.transform(originalGeom.intersection(worldCutPolygon),
                    transform);
        }
        catch (Exception ex)
        {
            throw new RuntimeException(ex);
        }
    }

    return projectedGeometry;
}
 

public GeometryCalculations(final CoordinateReferenceSystem crs) {
  factory = new GeometryFactory(new PrecisionModel(), 4326);
  this.crs = crs;
  xMin = crs.getCoordinateSystem().getAxis(0).getMinimumValue();
  xMax = crs.getCoordinateSystem().getAxis(0).getMaximumValue();
  yMin = crs.getCoordinateSystem().getAxis(1).getMinimumValue();
  yMax = crs.getCoordinateSystem().getAxis(1).getMaximumValue();
}
 

public static GeometryFactory getGeometryFactoryForSRID(int srid) {
    return new GeometryFactory(new PrecisionModel(PrecisionModel.FLOATING), srid);
}
 

public static SwitchCoordinateGeometryFactory getSwitchCoordinateGeometryFactoryForSRID(int srid) {
    return new SwitchCoordinateGeometryFactory(new PrecisionModel(PrecisionModel.FLOATING), srid);
}
 

SwitchCoordinateGeometryFactory(PrecisionModel precisionModel, int srid) {
    super(precisionModel, srid);
}
 

@Override
public PrecisionModel getPrecisionModel() {
    return geom.getPrecisionModel();
}
 

private static GeometryFactory createGeometryFactory() {
    final PrecisionModel precisionModel = new PrecisionModel();
    final PackedCoordinateSequenceFactory coordinateSequenceFactory = 
            new PackedCoordinateSequenceFactory(PackedCoordinateSequenceFactory.DOUBLE, NUMBER_OF_DIMENSIONS);
    return new GeometryFactory(precisionModel, SRID, coordinateSequenceFactory);
}
 

public static PrecisionModel basicPrecisionModel() {
    return (pm());
}
 

public static PrecisionModel basicPrecisionModel() {
    return (pm());
}