/**
* Test created to check that we effectively retrieve a good representation of empty
* multipolygons. indeed, a NullPointerException used to happen...
*
* @throws Exception
*/
@Test
public void testGeometryCollectionStringRepresentation() throws Exception {
GeometryCollection mp = gf.createMultiPolygon(new Polygon[] {});
Value val = ValueFactory.createValue(mp);
String str = val.toString();
assertEquals(str, "MULTIPOLYGON EMPTY");
Polygon poly = gf.createPolygon(gf.createLinearRing(new Coordinate[] {}), new LinearRing[] {});
assertTrue(poly.isEmpty());
mp =
gf.createMultiPolygon(
new Polygon[] {
poly,
});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
Polygon polyBis =
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 0, 0),
new Coordinate(1, 1, 0),
new Coordinate(3, 4, 0),
new Coordinate(0, 0, 0),
}),
new LinearRing[] {});
mp = gf.createMultiPolygon(new Polygon[] {poly, polyBis});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
GeometryCollection coll =
gf.createGeometryCollection(
new Geometry[] {
gf.createPolygon(gf.createLinearRing(new Coordinate[] {}), new LinearRing[] {}),
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 0, 0),
new Coordinate(1, 1, 0),
new Coordinate(3, 4, 0),
new Coordinate(0, 0, 0),
}),
new LinearRing[] {})
});
mp = gf.createGeometryCollection(new Geometry[] {poly, coll, polyBis});
val = ValueFactory.createValue(mp);
str = val.toString();
assertNotNull(str);
}
private Geometry parseGeometry(JsonNode root) {
String typeName = root.get("type").asText();
if (typeName.equals("Point")) {
return gf.createPoint(parseCoordinate((ArrayNode) root.get("coordinates")));
} else if (typeName.equals("MultiPoint")) {
return gf.createMultiPoint(parseLineString(root.get("coordinates")));
} else if (typeName.equals("LineString")) {
return gf.createLineString(parseLineString(root.get("coordinates")));
} else if (typeName.equals("MultiLineString")) {
return gf.createMultiLineString(parseLineStrings(root.get("coordinates")));
} else if (typeName.equals("Polygon")) {
JsonNode arrayOfRings = root.get("coordinates");
return parsePolygonCoordinates(arrayOfRings);
} else if (typeName.equals("MultiPolygon")) {
JsonNode arrayOfPolygons = root.get("coordinates");
return gf.createMultiPolygon(parsePolygons(arrayOfPolygons));
} else if (typeName.equals("GeometryCollection")) {
return gf.createGeometryCollection(parseGeometries(root.get("geometries")));
} else {
throw new UnsupportedOperationException();
}
}
MultiPolygon createMultiPolygon(List list) {
Polygon[] polys = new Polygon[ensureSize(list, 1).size()];
for (int i = 0; i < list.size(); i++) {
polys[i] = createPolygon((List) list.get(i));
}
return gf.createMultiPolygon(polys);
}
private Geometry parseMultiPolygon(int dimension, CoordinateReferenceSystem crs)
throws XmlPullParserException, IOException, NoSuchAuthorityCodeException, FactoryException {
parser.require(START_TAG, GML.NAMESPACE, GML.MultiPolygon.getLocalPart());
Geometry geom;
List<Polygon> polygons = new ArrayList<Polygon>(2);
parser.nextTag();
while (true) {
parser.require(START_TAG, GML.NAMESPACE, GML.polygonMember.getLocalPart());
parser.nextTag();
parser.require(START_TAG, GML.NAMESPACE, GML.Polygon.getLocalPart());
Polygon p = parsePolygon(dimension, crs);
polygons.add(p);
parser.nextTag();
parser.require(END_TAG, GML.NAMESPACE, GML.polygonMember.getLocalPart());
parser.nextTag();
if (END_TAG == parser.getEventType()
&& GML.MultiPolygon.getLocalPart().equals(parser.getName())) {
// we're done
break;
}
}
parser.require(END_TAG, GML.NAMESPACE, GML.MultiPolygon.getLocalPart());
geom = geomFac.createMultiPolygon(polygons.toArray(new Polygon[polygons.size()]));
return geom;
}
/**
* Returns a completed multi type.
*
* @param geometryFactory The factory this method should use to create the multi type.
* @return Appropriate multi geometry type.
*/
public Geometry create(GeometryFactory geometryFactory) {
if (internalType.equals("Point")) {
Point[] pointArray = geometryFactory.toPointArray(geometries);
MultiPoint multiPoint = geometryFactory.createMultiPoint(pointArray);
multiPoint.setUserData(getSRS());
multiPoint.setSRID(getSRID());
LOGGER.fine("created " + multiPoint);
return multiPoint;
} else if (internalType.equals("LineString")) {
LineString[] lineStringArray = geometryFactory.toLineStringArray(geometries);
MultiLineString multiLineString = geometryFactory.createMultiLineString(lineStringArray);
multiLineString.setUserData(getSRS());
multiLineString.setSRID(getSRID());
LOGGER.fine("created " + multiLineString);
return multiLineString;
} else if (internalType.equals("Polygon")) {
Polygon[] polygonArray = geometryFactory.toPolygonArray(geometries);
MultiPolygon multiPolygon = geometryFactory.createMultiPolygon(polygonArray);
multiPolygon.setUserData(getSRS());
multiPolygon.setSRID(getSRID());
LOGGER.fine("created " + multiPolygon);
return multiPolygon;
} else {
return null;
}
}
protected MultiPolygon decodeMultiPolygon(JsonNode node, GeometryFactory fac)
throws GeoJSONException {
JsonNode coordinates = requireCoordinates(node);
Polygon[] polygons = new Polygon[coordinates.size()];
for (int i = 0; i < coordinates.size(); ++i) {
polygons[i] = decodePolygonCoordinates(coordinates.get(i), fac);
}
return fac.createMultiPolygon(polygons);
}
/** We must be able to transform specialized collections to GeometryCollectionValues */
@Test
public void testGeometryCollectionConversions() throws Exception {
Value val =
ValueFactory.createValue(
gf.createMultiPoint(
new Coordinate[] {new Coordinate(0, 0, 0), new Coordinate(1, 2, 3)}));
assertTrue(val instanceof DefaultMultiPointValue);
Value val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
val =
ValueFactory.createValue(
gf.createMultiLineString(
new LineString[] {
gf.createLineString(
new Coordinate[] {new Coordinate(0, 0, 0), new Coordinate(4, 2, 3)}),
gf.createLineString(
new Coordinate[] {new Coordinate(5, 6, 9), new Coordinate(5, 7, 1)})
}));
assertTrue(val instanceof DefaultMultiLineStringValue);
val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
val =
ValueFactory.createValue(
gf.createMultiPolygon(
new Polygon[] {
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(0, 3, 0),
new Coordinate(9, 0, 0),
new Coordinate(8, 7, 0),
new Coordinate(0, 3, 0)
}),
null),
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(10, 3, 0),
new Coordinate(9, 0, 0),
new Coordinate(8, 7, 0),
new Coordinate(10, 3, 0)
}),
null)
}));
assertTrue(val instanceof DefaultMultiPolygonValue);
val2 = val.toType(Type.GEOMETRYCOLLECTION);
assertTrue(val2 instanceof DefaultGeometryCollectionValue);
// Let's be sure it's not a GeometryCollection just thanks to the inheritance
assertFalse(val2 instanceof DefaultMultiPointValue);
}
private MultiPolygon readMultiPolygon() throws IOException, ParseException {
int numGeom = dis.readInt();
Polygon[] geoms = new Polygon[numGeom];
for (int i = 0; i < numGeom; i++) {
Geometry g = readGeometry();
if (!(g instanceof Polygon)) throw new ParseException(INVALID_GEOM_TYPE_MSG + "MultiPolygon");
geoms[i] = (Polygon) g;
}
return factory.createMultiPolygon(geoms);
}
static Geometry computeProductGeometry(Product product) {
final GeneralPath[] paths = ProductUtils.createGeoBoundaryPaths(product);
final Polygon[] polygons = new Polygon[paths.length];
final GeometryFactory factory = new GeometryFactory();
for (int i = 0; i < paths.length; i++) {
polygons[i] = convertAwtPathToJtsPolygon(paths[i], factory);
}
final DouglasPeuckerSimplifier peuckerSimplifier =
new DouglasPeuckerSimplifier(
polygons.length == 1 ? polygons[0] : factory.createMultiPolygon(polygons));
return peuckerSimplifier.getResultGeometry();
}
/**
* Convert a org.geojson.Xxxx geometry to a JTS geometry. Only support Point, Polygon,
* MultiPolygon, LineString and MultiLineString for now.
*
* @param geoJsonGeom
* @return The equivalent JTS geometry.
* @throws UnsupportedGeometryException
*/
public static Geometry convertGeoJsonToJtsGeometry(GeoJsonObject geoJsonGeom)
throws UnsupportedGeometryException {
if (geoJsonGeom instanceof org.geojson.Point) {
org.geojson.Point geoJsonPoint = (org.geojson.Point) geoJsonGeom;
return gf.createPoint(
new Coordinate(
geoJsonPoint.getCoordinates().getLongitude(),
geoJsonPoint.getCoordinates().getLatitude()));
} else if (geoJsonGeom instanceof org.geojson.Polygon) {
org.geojson.Polygon geoJsonPolygon = (org.geojson.Polygon) geoJsonGeom;
LinearRing shell = gf.createLinearRing(convertPath(geoJsonPolygon.getExteriorRing()));
LinearRing[] holes = new LinearRing[geoJsonPolygon.getInteriorRings().size()];
int i = 0;
for (List<LngLatAlt> hole : geoJsonPolygon.getInteriorRings()) {
holes[i++] = gf.createLinearRing(convertPath(hole));
}
return gf.createPolygon(shell, holes);
} else if (geoJsonGeom instanceof org.geojson.MultiPolygon) {
org.geojson.MultiPolygon geoJsonMultiPolygon = (org.geojson.MultiPolygon) geoJsonGeom;
Polygon[] jtsPolygons = new Polygon[geoJsonMultiPolygon.getCoordinates().size()];
int i = 0;
for (List<List<LngLatAlt>> geoJsonRings : geoJsonMultiPolygon.getCoordinates()) {
org.geojson.Polygon geoJsonPoly = new org.geojson.Polygon();
for (List<LngLatAlt> geoJsonRing : geoJsonRings) geoJsonPoly.add(geoJsonRing);
jtsPolygons[i++] = (Polygon) convertGeoJsonToJtsGeometry(geoJsonPoly);
}
return gf.createMultiPolygon(jtsPolygons);
} else if (geoJsonGeom instanceof org.geojson.LineString) {
org.geojson.LineString geoJsonLineString = (org.geojson.LineString) geoJsonGeom;
return gf.createLineString(convertPath(geoJsonLineString.getCoordinates()));
} else if (geoJsonGeom instanceof org.geojson.MultiLineString) {
org.geojson.MultiLineString geoJsonMultiLineString =
(org.geojson.MultiLineString) geoJsonGeom;
LineString[] jtsLineStrings = new LineString[geoJsonMultiLineString.getCoordinates().size()];
int i = 0;
for (List<LngLatAlt> geoJsonPath : geoJsonMultiLineString.getCoordinates()) {
org.geojson.LineString geoJsonLineString =
new org.geojson.LineString(geoJsonPath.toArray(new LngLatAlt[geoJsonPath.size()]));
jtsLineStrings[i++] = (LineString) convertGeoJsonToJtsGeometry(geoJsonLineString);
}
return gf.createMultiLineString(jtsLineStrings);
}
throw new UnsupportedGeometryException(geoJsonGeom.getClass().toString());
}
@Test
public void test3DGeoms() throws Exception {
Coordinate[] coords2D =
new Coordinate[] {
new Coordinate(10, 10, 10),
new Coordinate(40, 10, 10),
new Coordinate(40, 40, 10),
new Coordinate(10, 40, 10),
new Coordinate(10, 10, 10),
};
Coordinate[] coords3D =
new Coordinate[] {
new Coordinate(10, 10),
new Coordinate(40, 10),
new Coordinate(40, 40),
new Coordinate(10, 40),
new Coordinate(10, 10),
};
Value p1 = ValueFactory.createValue(gf.createPoint(new Coordinate(10, 10, 10)));
Value p2 = ValueFactory.createValue(gf.createPoint(new Coordinate(10, 10)));
checkDifferent(p1, p2);
LineString l1 = gf.createLineString(coords2D);
p1 = ValueFactory.createValue(l1);
LineString l2 = gf.createLineString(coords3D);
p2 = ValueFactory.createValue(l2);
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiPoint(coords2D));
p2 = ValueFactory.createValue(gf.createMultiPoint(coords3D));
checkDifferent(p1, p2);
Polygon pol1 = gf.createPolygon(gf.createLinearRing(coords2D), null);
p1 = ValueFactory.createValue(pol1);
Polygon pol2 = gf.createPolygon(gf.createLinearRing(coords3D), null);
p2 = ValueFactory.createValue(pol2);
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiLineString(new LineString[] {l1}));
p2 = ValueFactory.createValue(gf.createMultiLineString(new LineString[] {l2}));
checkDifferent(p1, p2);
p1 = ValueFactory.createValue(gf.createMultiPolygon(new Polygon[] {pol1}));
p2 = ValueFactory.createValue(gf.createMultiPolygon(new Polygon[] {pol2}));
checkDifferent(p1, p2);
}
public Object convert(Object obj) {
GeometryFactory fac = new GeometryFactory();
if (getBinding() == MultiPolygon.class && obj instanceof Polygon) {
return fac.createMultiPolygon(new Polygon[] {(Polygon) obj});
}
if (getBinding() == MultiPoint.class && obj instanceof Point) {
return fac.createMultiPoint(new Point[] {(Point) obj});
}
if (getBinding() == MultiLineString.class && obj instanceof LineString) {
return fac.createMultiLineString(new LineString[] {(LineString) obj});
}
if (getBinding() == GeometryCollection.class && obj instanceof Geometry) {
return fac.createGeometryCollection(
new com.vividsolutions.jts.geom.Geometry[] {(com.vividsolutions.jts.geom.Geometry) obj});
}
return obj;
}
@Test
public void multiPolygon() throws Exception {
LinearRing shell =
gf.createLinearRing(
new Coordinate[] {
new Coordinate(102.0, 2.0), new Coordinate(103.0, 2.0),
new Coordinate(103.0, 3.0), new Coordinate(102.0, 3.0),
new Coordinate(102.0, 2.0)
});
MultiPolygon multiPolygon =
gf.createMultiPolygon(new Polygon[] {gf.createPolygon(shell, null)});
assertRoundTrip(multiPolygon);
assertThat(
toJson(multiPolygon),
equalTo(
"{\"type\":\"MultiPolygon\",\"coordinates\":[[[[102.0,2.0],[103.0,2.0],[103.0,3.0],[102.0,3.0],[102.0,2.0]]]]}"));
}
public Geometry getGeometry() {
int n = collection.size();
if (MultiPolygon.class.isAssignableFrom(binding)) {
Polygon[] array = new Polygon[n];
for (int i = 0; i < n; i++) array[i] = (Polygon) collection.get(i);
return factory.createMultiPolygon(array);
}
if (MultiLineString.class.isAssignableFrom(binding)) {
LineString[] array = new LineString[n];
for (int i = 0; i < n; i++) array[i] = (LineString) collection.get(i);
return factory.createMultiLineString(array);
}
if (MultiPoint.class.isAssignableFrom(binding)) {
Point[] array = new Point[n];
for (int i = 0; i < n; i++) array[i] = (Point) collection.get(i);
return factory.createMultiPoint(array);
}
return null;
}
private Geometry getGeographicBoundingBox(CoordinateReferenceSystem crs) {
GeographicBoundingBox envelope = CRS.getGeographicBoundingBox(crs);
if (envelope == null) {
return null;
}
final double westBoundLongitude = envelope.getWestBoundLongitude();
final double eastBoundLongitude = envelope.getEastBoundLongitude();
final double southBoundLatitude = envelope.getSouthBoundLatitude();
final double northBoundLatitude = envelope.getNorthBoundLatitude();
final int numSteps = 80;
Geometry geogBoundingGeom;
if (westBoundLongitude < eastBoundLongitude) {
geogBoundingGeom =
createBoundingPolygon(
westBoundLongitude,
eastBoundLongitude,
southBoundLatitude,
northBoundLatitude,
numSteps);
} else {
// the geographic bounds cross the day line (lon -180/180), trick it into two adjacent
// polygons
Polygon eastPolygon =
createBoundingPolygon(
-180, eastBoundLongitude, southBoundLatitude, northBoundLatitude, numSteps);
Polygon westPolygon =
createBoundingPolygon(
westBoundLongitude, 180, southBoundLatitude, northBoundLatitude, numSteps);
geogBoundingGeom = gf.createMultiPolygon(new Polygon[] {eastPolygon, westPolygon});
}
return geogBoundingGeom;
}
public static Geometry getMultiPolygon3D() {
return gf.createMultiPolygon(new Polygon[] {getPolygon3D(), getPolygon3D()});
}
static MultiPolygon multiPolygon() {
return gf.createMultiPolygon(new Polygon[] {polygon(), polygon()});
}
/**
* Returns a non-null default value for the class that is passed in. This is a helper class an
* can't create a default class for any type but it does support:
*
* <ul>
* <li>String
* <li>Object - will return empty string
* <li>Number
* <li>Character
* <li>JTS Geometries
* </ul>
*
* @param type
* @return
*/
public static Object defaultValue(Class type) {
if (type == String.class || type == Object.class) {
return "";
}
if (type == Integer.class) {
return new Integer(0);
}
if (type == Double.class) {
return new Double(0);
}
if (type == Long.class) {
return new Long(0);
}
if (type == Short.class) {
return new Short((short) 0);
}
if (type == Float.class) {
return new Float(0.0f);
}
if (type == BigDecimal.class) {
return BigDecimal.valueOf(0);
}
if (type == BigInteger.class) {
return BigInteger.valueOf(0);
}
if (type == Character.class) {
return new Character(' ');
}
if (type == Boolean.class) {
return Boolean.FALSE;
}
if (type == Timestamp.class) return new Timestamp(System.currentTimeMillis());
if (type == java.sql.Date.class) return new java.sql.Date(System.currentTimeMillis());
if (type == java.sql.Time.class) return new java.sql.Time(System.currentTimeMillis());
if (type == java.util.Date.class) return new java.util.Date();
GeometryFactory fac = new GeometryFactory();
Coordinate coordinate = new Coordinate(0, 0);
Point point = fac.createPoint(coordinate);
if (type == Point.class) {
return point;
}
if (type == MultiPoint.class) {
return fac.createMultiPoint(new Point[] {point});
}
if (type == LineString.class) {
return fac.createLineString(
new Coordinate[] {coordinate, coordinate, coordinate, coordinate});
}
LinearRing linearRing =
fac.createLinearRing(new Coordinate[] {coordinate, coordinate, coordinate, coordinate});
if (type == LinearRing.class) {
return linearRing;
}
if (type == MultiLineString.class) {
return fac.createMultiLineString(new LineString[] {linearRing});
}
Polygon polygon = fac.createPolygon(linearRing, new LinearRing[0]);
if (type == Polygon.class) {
return polygon;
}
if (type == MultiPolygon.class) {
return fac.createMultiPolygon(new Polygon[] {polygon});
}
throw new IllegalArgumentException(type + " is not supported by this method");
}
@Test
public void testGeometryType() throws Exception {
// We test the point
Value val = ValueFactory.createValue(gf.createPoint(new Coordinate(2, 1)));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.POINT);
// We test the multipoint
val = ValueFactory.createValue(gf.createMultiPoint(new Coordinate[] {new Coordinate(2, 1)}));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.MULTIPOINT);
// We test the LineString
val =
ValueFactory.createValue(
gf.createLineString(new Coordinate[] {new Coordinate(2, 1), new Coordinate(2, 2)}));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.LINESTRING);
// We test the MultiLineString
val =
ValueFactory.createValue(
gf.createMultiLineString(
new LineString[] {
gf.createLineString(new Coordinate[] {new Coordinate(2, 1), new Coordinate(2, 2)})
}));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.MULTILINESTRING);
// We test the Polygon
val =
ValueFactory.createValue(
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(2, 1),
new Coordinate(2, 2),
new Coordinate(4, 3),
new Coordinate(2, 1)
}),
null));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.POLYGON);
// We test the MultiPolygon
val =
ValueFactory.createValue(
gf.createMultiPolygon(
new Polygon[] {
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(2, 1),
new Coordinate(2, 2),
new Coordinate(4, 3),
new Coordinate(2, 1)
}),
null),
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(2, 1),
new Coordinate(2, 2),
new Coordinate(6, 3),
new Coordinate(2, 1)
}),
null)
}));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue(val.getType() == Type.MULTIPOLYGON);
// We test the GeometryCollection
val =
ValueFactory.createValue(
gf.createGeometryCollection(
new Geometry[] {
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(2, 1),
new Coordinate(2, 2),
new Coordinate(4, 3),
new Coordinate(2, 1)
}),
null),
gf.createPoint(new Coordinate(2, 1))
}));
assertTrue((val.getType() & Type.GEOMETRY) != 0);
assertTrue((val.getType() & Type.GEOMETRYCOLLECTION) != 0);
}
protected MultiPolygon toMultiPolygon(ReferencedEnvelope env2) {
GeometryFactory factory = new GeometryFactory();
return factory.createMultiPolygon(new Polygon[] {toPolygon(env2)});
}
/**
* Writing test that only engages against a remote geoserver.
*
* <p>Makes reference to the standard featureTypes that geoserver ships with. NOTE: Ignoring this
* test for now because it edits topp:states and GeoServer doesn't return the correct Feature IDs
* on transactions against shapefiles
*/
@Test
@Ignore
public void testWrite()
throws NoSuchElementException, IllegalFilterException, IOException,
IllegalAttributeException {
if (url == null) return;
Map m = new HashMap();
m.put(WFSDataStoreFactory.URL.key, url);
m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(10000000));
DataStore post = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m);
String typename = TO_EDIT_TYPE;
SimpleFeatureType ft = post.getSchema(typename);
SimpleFeatureSource fs = post.getFeatureSource(typename);
class Watcher implements FeatureListener {
public int count = 0;
public void changed(FeatureEvent featureEvent) {
System.out.println("Event " + featureEvent);
count++;
}
}
Watcher watcher = new Watcher();
fs.addFeatureListener(watcher);
Id startingFeatures = createFidFilter(fs);
FilterFactory2 filterFac = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints());
try {
GeometryFactory gf = new GeometryFactory();
MultiPolygon mp =
gf.createMultiPolygon(
new Polygon[] {
gf.createPolygon(
gf.createLinearRing(
new Coordinate[] {
new Coordinate(-88.071564, 37.51099),
new Coordinate(-88.467644, 37.400757),
new Coordinate(-90.638329, 42.509361),
new Coordinate(-89.834618, 42.50346),
new Coordinate(-88.071564, 37.51099)
}),
new LinearRing[] {})
});
mp.setUserData("http://www.opengis.net/gml/srs/epsg.xml#" + EPSG_CODE);
PropertyName geometryAttributeExpression =
filterFac.property(ft.getGeometryDescriptor().getLocalName());
PropertyIsNull geomNullCheck = filterFac.isNull(geometryAttributeExpression);
Query query = new Query(typename, filterFac.not(geomNullCheck), 1, Query.ALL_NAMES, null);
SimpleFeatureIterator inStore = fs.getFeatures(query).features();
SimpleFeature f, f2;
try {
SimpleFeature feature = inStore.next();
SimpleFeature copy = SimpleFeatureBuilder.deep(feature);
SimpleFeature copy2 = SimpleFeatureBuilder.deep(feature);
f = SimpleFeatureBuilder.build(ft, copy.getAttributes(), null);
f2 = SimpleFeatureBuilder.build(ft, copy2.getAttributes(), null);
assertFalse("Max Feature failed", inStore.hasNext());
} finally {
inStore.close();
}
org.geotools.util.logging.Logging.getLogger("org.geotools.data.wfs").setLevel(Level.FINE);
SimpleFeatureCollection inserts = DataUtilities.collection(new SimpleFeature[] {f, f2});
Id fp = WFSDataStoreWriteOnlineTest.doInsert(post, ft, inserts);
// / okay now count ...
FeatureReader<SimpleFeatureType, SimpleFeature> count =
post.getFeatureReader(new Query(ft.getTypeName()), Transaction.AUTO_COMMIT);
int i = 0;
while (count.hasNext() && i < 3) {
f = count.next();
i++;
}
count.close();
WFSDataStoreWriteOnlineTest.doDelete(post, ft, fp);
WFSDataStoreWriteOnlineTest.doUpdate(post, ft, ATTRIBUTE_TO_EDIT, NEW_EDIT_VALUE);
// assertFalse("events not fired", watcher.count == 0);
} finally {
try {
((SimpleFeatureStore) fs).removeFeatures(filterFac.not(startingFeatures));
} catch (Exception e) {
System.out.println(e);
}
}
}
@RequestMapping(
value = "/projects/{id}/cleanse",
method = RequestMethod.POST,
produces = "application/xml")
@PreAuthorize("hasPermission(#project, 'write')")
public void processCleanse(
@ModelAttribute(value = "project") Project project,
@RequestParam(value = "operation", required = true) String operation,
@RequestParam(value = "fromDate", required = false) String fromDateString,
@RequestParam(value = "toDate", required = false) String toDateString,
@RequestParam(value = "animal") List<Long> animalIds,
@RequestParam(value = "maxSpeed", required = false) Double maxSpeed,
@RequestParam(value = "minArgosClass", required = false) String minArgosClassCode,
@RequestParam(value = "maxDop", required = false) Double maxDop,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, RserveInterfaceException {
Date fromDate = null;
Date toDate = null;
try {
if (StringUtils.isNotBlank(fromDateString)) {
fromDate = isoDateFormat.parse(fromDateString);
}
if (StringUtils.isNotBlank(toDateString)) {
toDate = (toDateString == null) ? null : isoDateFormat.parse(toDateString);
}
} catch (java.text.ParseException e1) {
PrintWriter out = response.getWriter();
out.append("<?xml version=\"1.0\"?>\n");
out.append("<cleanse-response xmlns=\"http://oztrack.org/xmlns#\">\n");
out.append(" <error>Invalid date parameters</error>\n");
out.append("</cleanse-response>\n");
response.setStatus(200);
return;
}
MultiPolygon multiPolygon = null;
String[] polygonsWkt = request.getParameterValues("polygon");
if ((polygonsWkt != null) && (polygonsWkt.length > 0)) {
Hints hints = new Hints();
hints.put(Hints.CRS, DefaultGeographicCRS.WGS84);
GeometryFactory geometryFactory = JTSFactoryFinder.getGeometryFactory(hints);
WKTReader reader = new WKTReader(geometryFactory);
ArrayList<Polygon> polygons = new ArrayList<Polygon>();
for (String polygonWkt : polygonsWkt) {
try {
Polygon polygon = (Polygon) reader.read(polygonWkt);
polygons.add(polygon);
} catch (ParseException e) {
throw new RuntimeException("Error reading polygon: " + polygonWkt, e);
}
}
multiPolygon = geometryFactory.createMultiPolygon(polygons.toArray(new Polygon[0]));
}
Set<PositionFix> speedFilterPositionFixes = null;
if (maxSpeed != null) {
speedFilterPositionFixes = new HashSet<PositionFix>();
SearchQuery searchQuery = new SearchQuery();
searchQuery.setProject(project);
searchQuery.setFromDate(fromDate);
searchQuery.setToDate(toDate);
searchQuery.setAnimalIds(animalIds);
List<PositionFix> positionFixList = positionFixDao.getProjectPositionFixList(searchQuery);
RserveInterface rserveInterface = new RserveInterface(rserveConnectionPool);
Map<Long, Set<Date>> animalDates =
rserveInterface.runSpeedFilter(project, positionFixList, maxSpeed);
for (PositionFix positionFix : positionFixList) {
Set<Date> dates = animalDates.get(positionFix.getAnimal().getId());
// Need to create new java.util.Date here because positionFix.detectionTime is a
// java.sql.Timestamp.
// Date and Timestamp have same hashCode but their equals methods differ, breaking contains
// call.
if ((dates != null) && dates.contains(new Date(positionFix.getDetectionTime().getTime()))) {
speedFilterPositionFixes.add(positionFix);
}
}
}
ArgosClass minArgosClass = ArgosClass.fromCode(minArgosClassCode);
if (operation.equals("delete")) {
int numDeleted =
positionFixDao.setDeleted(
project,
fromDate,
toDate,
animalIds,
multiPolygon,
speedFilterPositionFixes,
minArgosClass,
maxDop,
true);
positionFixDao.renumberPositionFixes(project);
PrintWriter out = response.getWriter();
out.append("<?xml version=\"1.0\"?>\n");
out.append("<cleanse-response xmlns=\"http://oztrack.org/xmlns#\">\n");
out.append(" <num-deleted>" + numDeleted + "</num-deleted>\n");
out.append("</cleanse-response>\n");
response.setStatus(200);
return;
} else if (operation.equals("undelete")) {
int numUndeleted =
positionFixDao.setDeleted(
project,
fromDate,
toDate,
animalIds,
multiPolygon,
speedFilterPositionFixes,
minArgosClass,
maxDop,
false);
positionFixDao.renumberPositionFixes(project);
PrintWriter out = response.getWriter();
out.append("<?xml version=\"1.0\"?>\n");
out.append("<cleanse-response xmlns=\"http://oztrack.org/xmlns#\">\n");
out.append(" <num-undeleted>" + numUndeleted + "</num-undeleted>\n");
out.append("</cleanse-response>\n");
response.setStatus(200);
return;
} else {
PrintWriter out = response.getWriter();
out.append("<?xml version=\"1.0\"?>\n");
out.append("<cleanse-response xmlns=\"http://oztrack.org/xmlns#\">\n");
out.append(" <error>" + "Unknown operation: " + operation + "</error>\n");
out.append("</cleanse-response>\n");
response.setStatus(400);
return;
}
}
public static Geometry getMultiPolygon2D() {
return gf.createMultiPolygon(new Polygon[] {(Polygon) getPolygon()});
}
@Test
public void testSetup() throws Exception {
EventListener l = new EventListener();
EditBlackboard map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
assertPixMapState(map, 1, 0, 0, 0);
map.addPoint(10, 5, map.getGeoms().get(0).getShell());
assertPixMapState(map, 1, 1, 0, 0);
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(0).getX());
assertEquals(5, map.getGeoms().get(0).getShell().getPoint(0).getY());
assertEquals(EventType.ADD_POINT, l.event.getType());
EditBlackboardEvent editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(null, editBlackboardEvent.getOldValue());
assertEquals(Point.valueOf(10, 5), editBlackboardEvent.getNewValue());
assertEquals(map.getGeoms().get(0).getShell(), editBlackboardEvent.getSource());
map.addPoint(10, 10, map.getGeoms().get(0).getShell());
assertPixMapState(map, 1, 2, 0, 0);
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(1).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(1).getY());
assertEquals(EventType.ADD_POINT, l.event.getType());
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(null, editBlackboardEvent.getOldValue());
assertEquals(Point.valueOf(10, 10), editBlackboardEvent.getNewValue());
assertEquals(map.getGeoms().get(0).getShell(), editBlackboardEvent.getSource());
GeometryFactory factory = new GeometryFactory();
Geometry geom = factory.createPoint(new Coordinate(10, 5));
map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
Map<Geometry, EditGeom> mapping = map.setGeometries(geom, null);
assertNotNull(mapping.get(geom));
assertEquals(ShapeType.POINT, mapping.get(geom).getShapeType());
assertPixMapState(map, 1, 1, 0, 0);
assertEquals(20, map.getGeoms().get(0).getShell().getPoint(0).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(0).getY());
assertEquals(EventType.SET_GEOMS, l.event.getType());
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(1, ((List) editBlackboardEvent.getOldValue()).size());
assertEquals(1, ((List) editBlackboardEvent.getNewValue()).size());
assertEquals(map, editBlackboardEvent.getSource());
geom =
factory.createMultiPoint(new Coordinate[] {new Coordinate(10, 5), new Coordinate(20, 10)});
map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
String string = "featureID"; // $NON-NLS-1$
mapping = map.setGeometries(geom, string);
EditGeom next = mapping.values().iterator().next();
assertEquals(ShapeType.POINT, next.getShapeType());
assertEquals(string, next.getFeatureIDRef().get());
assertNotNull(mapping.get(geom.getGeometryN(0)));
assertNotNull(mapping.get(geom.getGeometryN(1)));
assertPixMapState(map, 2, 1, 0, 0);
assertEquals(20, map.getGeoms().get(0).getShell().getPoint(0).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(0).getY());
assertEquals(30, map.getGeoms().get(1).getShell().getPoint(0).getX());
assertEquals(15, map.getGeoms().get(1).getShell().getPoint(0).getY());
assertEquals(new Coordinate(10, 5), map.getGeoms().get(0).getShell().getCoord(0));
assertEquals(new Coordinate(20, 10), map.getGeoms().get(1).getShell().getCoord(0));
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(2, ((List) editBlackboardEvent.getNewValue()).size());
assertEquals(map, editBlackboardEvent.getSource());
LinearRing ring = createShellRing(factory, 10);
map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
mapping = map.setGeometries(ring, null);
assertEquals(ShapeType.LINE, mapping.get(ring).getShapeType());
assertNotNull(mapping.get(ring));
assertPixMapState(map, 1, 5, 0, 0);
assertEquals(20, map.getGeoms().get(0).getShell().getPoint(0).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(0).getY());
assertEquals(30, map.getGeoms().get(0).getShell().getPoint(1).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(1).getY());
assertEquals(30, map.getGeoms().get(0).getShell().getPoint(2).getX());
assertEquals(15, map.getGeoms().get(0).getShell().getPoint(2).getY());
assertEquals(20, map.getGeoms().get(0).getShell().getPoint(3).getX());
assertEquals(15, map.getGeoms().get(0).getShell().getPoint(3).getY());
assertEquals(20, map.getGeoms().get(0).getShell().getPoint(4).getX());
assertEquals(10, map.getGeoms().get(0).getShell().getPoint(4).getY());
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(1, ((List) editBlackboardEvent.getNewValue()).size());
assertEquals(map, editBlackboardEvent.getSource());
map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
Polygon polygon = createPolygon(factory, 10);
mapping = map.setGeometries(polygon, null);
assertEquals(ShapeType.POLYGON, mapping.get(polygon).getShapeType());
assertNotNull(mapping.get(polygon));
assertPixMapState(map, 1, 5, 1, 5);
assertEquals(Point.valueOf(20, 10), map.getGeoms().get(0).getShell().getPoint(0));
assertEquals(Point.valueOf(25, 12), map.getGeoms().get(0).getHoles().get(0).getPoint(0));
assertEquals(Point.valueOf(30, 10), map.getGeoms().get(0).getShell().getPoint(1));
assertEquals(Point.valueOf(28, 12), map.getGeoms().get(0).getHoles().get(0).getPoint(1));
assertEquals(new Coordinate(15, 7), map.getGeoms().get(0).getHoles().get(0).getCoord(0));
assertEquals(new Coordinate(18, 7), map.getGeoms().get(0).getHoles().get(0).getCoord(1));
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(1, ((List) editBlackboardEvent.getNewValue()).size());
assertEquals(map, editBlackboardEvent.getSource());
geom =
factory.createMultiPolygon(
new Polygon[] {createPolygon(factory, 0), createPolygon(factory, 20)});
map = new EditBlackboard(SCREEN.x, SCREEN.y, transform, layerToWorld);
map.getListeners().add(l);
mapping = map.setGeometries(geom, null);
assertPixMapState(map, 2, 5, 1, 5);
editBlackboardEvent = l.getEditBlackboardEvent();
assertEquals(2, ((List) editBlackboardEvent.getNewValue()).size());
assertEquals(map, editBlackboardEvent.getSource());
}
private static FeatureCollection<?> buildResultList() {
try {
type = createSimpleResultType();
} catch (NoSuchAuthorityCodeException ex) {
Logger.getLogger(UnionTest.class.getName()).log(Level.SEVERE, null, ex);
} catch (FactoryException ex) {
Logger.getLogger(UnionTest.class.getName()).log(Level.SEVERE, null, ex);
}
final FeatureCollection<Feature> featureList = DataUtilities.collection("", type);
Feature myFeature;
LinearRing ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(4, 7),
new Coordinate(6, 7),
new Coordinate(6, 5),
new Coordinate(4, 5),
new Coordinate(4, 7)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature1");
sfb.set("color", "red");
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
sfb.set("att", 20);
myFeature = sfb.buildFeature("id-01-id-11");
featureList.add(myFeature);
LineString str =
geometryFactory.createLineString(
new Coordinate[] {new Coordinate(3, 5), new Coordinate(3, 6)});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature1");
sfb.set("color", "grey");
sfb.set("geom1", str);
sfb.set("att", 12);
myFeature = sfb.buildFeature("id-01-id-15");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(3, 5),
new Coordinate(3, 6),
new Coordinate(3, 7),
new Coordinate(4, 7),
new Coordinate(4, 5),
new Coordinate(3, 5)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature1");
sfb.set("color", null);
sfb.set("att", null);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-01");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(7, 5),
new Coordinate(8, 5),
new Coordinate(8, 4),
new Coordinate(7, 4),
new Coordinate(7, 5)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature3");
sfb.set("color", "blue");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-03-id-12");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(6, 4),
new Coordinate(6, 5),
new Coordinate(7, 5),
new Coordinate(7, 4),
new Coordinate(6, 4)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature3");
sfb.set("color", "red");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-03-id-11");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(6, 2),
new Coordinate(6, 4),
new Coordinate(8, 4),
new Coordinate(8, 2),
new Coordinate(6, 2)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature3");
sfb.set("color", "grey");
sfb.set("att", 10);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-03-id-13");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(7, 7),
new Coordinate(8, 7),
new Coordinate(8, 5),
new Coordinate(7, 5),
new Coordinate(7, 7)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature2");
sfb.set("color", "blue");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-02-id-12");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(6, 5),
new Coordinate(6, 7),
new Coordinate(7, 7),
new Coordinate(7, 5),
new Coordinate(6, 5)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature2");
sfb.set("color", "red");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-02-id-11");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(2, 3),
new Coordinate(2, 4),
new Coordinate(3, 4),
new Coordinate(3, 3),
new Coordinate(2, 3)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature4");
sfb.set("color", null);
sfb.set("att", null);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-04");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(7, 7),
new Coordinate(7, 8),
new Coordinate(9, 8),
new Coordinate(9, 4),
new Coordinate(8, 4),
new Coordinate(8, 5),
new Coordinate(8, 7),
new Coordinate(7, 7)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature12");
sfb.set("color", "blue");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-12");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(8, 4),
new Coordinate(9, 4),
new Coordinate(9, 2),
new Coordinate(8, 2),
new Coordinate(8, 4)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature13");
sfb.set("color", "grey");
sfb.set("att", 10);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-13");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(4, 2),
new Coordinate(4, 3),
new Coordinate(5, 3),
new Coordinate(5, 2),
new Coordinate(4, 2)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature14");
sfb.set("color", "grey");
sfb.set("att", 12);
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
myFeature = sfb.buildFeature("id-14");
featureList.add(myFeature);
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(4, 4),
new Coordinate(4, 5),
new Coordinate(6, 5),
new Coordinate(6, 4),
new Coordinate(4, 4)
});
LinearRing ring2 =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(6, 7),
new Coordinate(4, 7),
new Coordinate(4, 8),
new Coordinate(7, 8),
new Coordinate(7, 7),
new Coordinate(6, 7)
});
Polygon poly1 = geometryFactory.createPolygon(ring, null);
Polygon poly2 = geometryFactory.createPolygon(ring2, null);
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature11");
sfb.set("color", "red");
sfb.set("att", 20);
sfb.set("geom1", geometryFactory.createMultiPolygon(new Polygon[] {poly1, poly2}));
myFeature = sfb.buildFeature("id-11");
featureList.add(myFeature);
Feature myFeature5;
ring =
geometryFactory.createLinearRing(
new Coordinate[] {
new Coordinate(2.0, 5.0),
new Coordinate(2.0, 6.0),
new Coordinate(3.0, 6.0),
new Coordinate(3.0, 5.0),
new Coordinate(2.0, 5.0)
});
sfb = new SimpleFeatureBuilder(type);
sfb.set("name", "feature15");
sfb.set("color", "grey");
sfb.set("geom1", geometryFactory.createPolygon(ring, null));
sfb.set("att", 12);
myFeature5 = sfb.buildFeature("id-15");
featureList.add(myFeature5);
return featureList;
}
