private Polygon editPolygon(Polygon polygon, GeometryEditorOperation operation) {
Polygon newPolygon = (Polygon) operation.edit(polygon, factory);
// create one if needed
if (newPolygon == null) newPolygon = factory.createPolygon((CoordinateSequence) null);
if (newPolygon.isEmpty()) {
// RemoveSelectedPlugIn relies on this behaviour. [Jon Aquino]
return newPolygon;
}
LinearRing shell = (LinearRing) edit(newPolygon.getExteriorRing(), operation);
if (shell == null || shell.isEmpty()) {
// RemoveSelectedPlugIn relies on this behaviour. [Jon Aquino]
return factory.createPolygon(null, null);
}
ArrayList holes = new ArrayList();
for (int i = 0; i < newPolygon.getNumInteriorRing(); i++) {
LinearRing hole = (LinearRing) edit(newPolygon.getInteriorRingN(i), operation);
if (hole == null || hole.isEmpty()) {
continue;
}
holes.add(hole);
}
return factory.createPolygon(shell, (LinearRing[]) holes.toArray(new LinearRing[] {}));
}
@Test
public void testLinearRing() throws SQLException {
logger.trace("void testLinearRing()");
logger.info(lr_str);
LinearRing lr = new LinearRing(lr_str);
logger.info(lr.toString());
}
@Override
public void visit(LinearRing geom) {
writeByteOrder(output);
DimensionalFlag dimension = DimensionalFlag.valueOf(geom.is3D(), geom.isMeasured());
writeTypeCodeAndSrid(geom, dimension, output);
writeRing(geom);
}
/** reverses the order of points in lr (is CW -> CCW or CCW->CW) */
LinearRing reverseRing(LinearRing lr) {
int numPoints = lr.getNumPoints();
Coordinate[] newCoords = new Coordinate[numPoints];
for (int t = 0; t < numPoints; t++) {
newCoords[t] = lr.getCoordinateN(numPoints - t - 1);
}
return new LinearRing(newCoords, new PrecisionModel(), 0);
}
@Test
public void createComplexGeometryCollectionTest() throws Exception {
Coordinate ptc = new Coordinate(10, 20);
Point point = geometryFactory.createPoint(ptc);
point.setSRID(4326);
Coordinate[] lsc = new Coordinate[8];
lsc[0] = new Coordinate(5.0d, 5.0d);
lsc[1] = new Coordinate(6.0d, 5.0d);
lsc[2] = new Coordinate(6.0d, 6.0d);
lsc[3] = new Coordinate(7.0d, 6.0d);
lsc[4] = new Coordinate(7.0d, 7.0d);
lsc[5] = new Coordinate(8.0d, 7.0d);
lsc[6] = new Coordinate(8.0d, 8.0d);
lsc[7] = new Coordinate(9.0d, 9.0d);
LineString lineString = geometryFactory.createLineString(lsc);
lineString.setSRID(4326);
Coordinate[] lrc = new Coordinate[10];
lrc[0] = new Coordinate(7, 7);
lrc[1] = new Coordinate(6, 9);
lrc[2] = new Coordinate(6, 11);
lrc[3] = new Coordinate(7, 12);
lrc[4] = new Coordinate(9, 11);
lrc[5] = new Coordinate(11, 12);
lrc[6] = new Coordinate(13, 11);
lrc[7] = new Coordinate(13, 9);
lrc[8] = new Coordinate(11, 7);
lrc[9] = new Coordinate(7, 7);
LinearRing linearRing = geometryFactory.createLinearRing(lrc);
linearRing.setSRID(4326);
Geometry polygon =
reader.read(
"POLYGON ((35 10, 10 20, 15 40," + " 45 45, 35 10), (20 30, 35 35, 30 20, 20 30))");
polygon.setSRID(4326);
Geometry multiPoint = reader.read("MULTIPOINT ((10 40), (40 30), " + "(20 20), (30 10))");
multiPoint.setSRID(4326);
Geometry multiPolygon =
reader.read(
"MULTIPOLYGON (((40 40, 20 45,"
+ " 45 30, 40 40)), ((20 35, 45 20, 30 5, "
+ "10 10, 10 30, 20 35), (30 20, 20 25, 20 15, 30 20)))");
multiPolygon.setSRID(4326);
GeometryCollection geometryCollection =
new GeometryCollection(
new Geometry[] {point, linearRing, lineString, polygon, multiPoint, multiPolygon},
geometryFactory);
String geometryCollectionGeoJsonString = mapper.writeValueAsString(geometryCollection);
logger.info(
":::::::::::::::::::::::GEO_JSON_GEOMETRY_COLLECTION : \n{}\n",
geometryCollectionGeoJsonString);
org.geojson.GeometryCollection p =
mapper.readValue(geometryCollectionGeoJsonString, org.geojson.GeometryCollection.class);
mapper.writeValue(new File("./target/GeometryCollectionComplex.json"), p);
}
/**
* Find the innermost enclosing shell EdgeRing containing the argument EdgeRing, if any. The
* innermost enclosing ring is the <i>smallest</i> enclosing ring. The algorithm used depends on
* the fact that: <br>
* ring A contains ring B iff envelope(ring A) contains envelope(ring B) <br>
* This routine is only safe to use if the chosen point of the hole is known to be properly
* contained in a shell (which is guaranteed to be the case if the hole does not touch its shell)
*
* @return containing EdgeRing, if there is one or null if no containing EdgeRing is found
*/
public static EdgeRing findEdgeRingContaining(EdgeRing testEr, List shellList) {
LinearRing testRing = testEr.getRing();
Envelope testEnv = testRing.getEnvelopeInternal();
Coordinate testPt = testRing.getCoordinateN(0);
EdgeRing minShell = null;
Envelope minShellEnv = null;
for (Iterator it = shellList.iterator(); it.hasNext(); ) {
EdgeRing tryShell = (EdgeRing) it.next();
LinearRing tryShellRing = tryShell.getRing();
Envelope tryShellEnv = tryShellRing.getEnvelopeInternal();
// the hole envelope cannot equal the shell envelope
// (also guards against testing rings against themselves)
if (tryShellEnv.equals(testEnv)) continue;
// hole must be contained in shell
if (!tryShellEnv.contains(testEnv)) continue;
testPt =
CoordinateArrays.ptNotInList(testRing.getCoordinates(), tryShellRing.getCoordinates());
boolean isContained = false;
if (CGAlgorithms.isPointInRing(testPt, tryShellRing.getCoordinates())) isContained = true;
// check if this new containing ring is smaller than the current minimum ring
if (isContained) {
if (minShell == null || minShellEnv.contains(tryShellEnv)) {
minShell = tryShell;
minShellEnv = minShell.getRing().getEnvelopeInternal();
}
}
}
return minShell;
}
public void testIsClosed() throws Exception {
LineString l = (LineString) reader.read("LINESTRING EMPTY");
assertTrue(l.isEmpty());
assertTrue(!l.isClosed());
LinearRing r = geometryFactory.createLinearRing((CoordinateSequence) null);
assertTrue(r.isEmpty());
assertTrue(r.isClosed());
MultiLineString m = geometryFactory.createMultiLineString(new LineString[] {l, r});
assertTrue(!m.isClosed());
MultiLineString m2 = geometryFactory.createMultiLineString(new LineString[] {r});
assertTrue(!m2.isClosed());
}
/**
* Transforms a LinearRing. The transformation of a LinearRing may result in a coordinate sequence
* which does not form a structurally valid ring (i.e. a degnerate ring of 3 or fewer points). In
* this case a LineString is returned. Subclasses may wish to override this method and check for
* this situation (e.g. a subclass may choose to eliminate degenerate linear rings)
*
* @param geom the ring to simplify
* @param parent the parent geometry
* @return a LinearRing if the transformation resulted in a structurally valid ring
* @return a LineString if the transformation caused the LinearRing to collapse to 3 or fewer
* points
*/
protected Geometry transformLinearRing(LinearRing geom, Geometry parent) {
CoordinateSequence seq = transformCoordinates(geom.getCoordinateSequence(), geom);
if (seq == null) return factory.createLinearRing((CoordinateSequence) null);
int seqSize = seq.size();
// ensure a valid LinearRing
if (seqSize > 0 && seqSize < 4 && !preserveType) return factory.createLineString(seq);
return factory.createLinearRing(seq);
}
@Test
public void linearRingSerializerTest() throws Exception {
Coordinate[] lrc = new Coordinate[10];
lrc[0] = new Coordinate(7, 7);
lrc[1] = new Coordinate(6, 9);
lrc[2] = new Coordinate(6, 11);
lrc[3] = new Coordinate(7, 12);
lrc[4] = new Coordinate(9, 11);
lrc[5] = new Coordinate(11, 12);
lrc[6] = new Coordinate(13, 11);
lrc[7] = new Coordinate(13, 9);
lrc[8] = new Coordinate(11, 7);
lrc[9] = new Coordinate(7, 7);
LinearRing linearRing = geometryFactory.createLinearRing(lrc);
linearRing.setSRID(4326);
String linearRingGeoJsonString = mapper.writeValueAsString(linearRing);
logger.info(":::::::::::::::::::::::GEO_JSON_LINE_STRING : \n{}\n", linearRingGeoJsonString);
org.geojson.LineString l =
mapper.readValue(linearRingGeoJsonString, org.geojson.LineString.class);
mapper.writeValue(new File("./target/LinearRing.json"), l);
}
private void writeRing(LinearRing geom) {
output.putUInt(geom.getNumPoints());
writePoints(geom.getPoints(), geom.getCoordinateDimension(), output);
}
protected void writeRing(LinearRing<P> geom) {
output.putUInt(geom.getNumPositions());
writePoints(geom.getPositions(), geom.getCoordinateDimension(), output);
}
/**
* Tests if the {@link LinearRing} ring formed by this edge ring is topologically valid.
*
* @return true if the ring is valid
*/
public boolean isValid() {
getCoordinates();
if (ringPts.length <= 3) return false;
getRing();
return ring.isValid();
}
/**
* Tests whether this ring is a hole. Due to the way the edges in the polyongization graph are
* linked, a ring is a hole if it is oriented counter-clockwise.
*
* @return <code>true</code> if this ring is a hole
*/
public boolean isHole() {
LinearRing ring = getRing();
return CGAlgorithms.isCCW(ring.getCoordinates());
}
