protected Geometry transformPolygon(Polygon geom, Geometry parent) {
boolean isAllValidLinearRings = true;
Geometry shell = transformLinearRing((LinearRing) geom.getExteriorRing(), geom);
if (shell == null || !(shell instanceof LinearRing) || shell.isEmpty())
isAllValidLinearRings = false;
// return factory.createPolygon(null, null);
ArrayList holes = new ArrayList();
for (int i = 0; i < geom.getNumInteriorRing(); i++) {
Geometry hole = transformLinearRing((LinearRing) geom.getInteriorRingN(i), geom);
if (hole == null || hole.isEmpty()) {
continue;
}
if (!(hole instanceof LinearRing)) isAllValidLinearRings = false;
holes.add(hole);
}
if (isAllValidLinearRings)
return factory.createPolygon(
(LinearRing) shell, (LinearRing[]) holes.toArray(new LinearRing[] {}));
else {
List components = new ArrayList();
if (shell != null) components.add(shell);
components.addAll(holes);
return factory.buildGeometry(components);
}
}
@Override
public void marshal(Object value, HierarchicalStreamWriter writer, MarshallingContext context) {
if (value != null) {
Wfs20FeatureCollection wfc = (Wfs20FeatureCollection) value;
String schemaLoc = generateSchemaLocationFromMetacards(wfc.getMembers(), prefixToUriMapping);
for (Entry<String, String> entry : prefixToUriMapping.entrySet()) {
writer.addAttribute(XMLConstants.XMLNS_ATTRIBUTE + ":" + entry.getKey(), entry.getValue());
}
writer.addAttribute(Wfs20Constants.ATTRIBUTE_SCHEMA_LOCATION, schemaLoc);
Geometry allGeometry = getBounds(wfc.getMembers());
if (!allGeometry.isEmpty()) {
XmlNode.writeEnvelope(
Wfs20Constants.GML_PREFIX + ":" + "boundedBy",
context,
writer,
allGeometry.getEnvelopeInternal());
}
for (Metacard mc : wfc.getMembers()) {
writer.startNode(Wfs20Constants.GML_PREFIX + ":" + FEATURE_MEMBER);
context.convertAnother(mc);
writer.endNode();
}
} else {
LOGGER.warn("Incoming value was null");
}
}
/**
* Each edge will be built with 2 coordinates.
*
* @param intersectingLineStrings The geometry which edges will be based on.
* @param onLoc position for ON.
* @param leftLoc position for LEFT.
* @param rightLoc position for RIGHT.
*/
private void insertEdge(
final Geometry intersectingLineStrings,
final Geometry holeGeometries,
final int onLoc,
final int leftLoc,
final int rightLoc) {
for (int i = 0; i < intersectingLineStrings.getNumGeometries(); i++) {
Geometry intersectingSegment = intersectingLineStrings.getGeometryN(i);
if ((intersectingSegment.getNumPoints() == 2) && !holeGeometries.isEmpty()) {
// special case, when the line has 2 coordinates and
// its orientation can't be calculated because it hasn't.
intersectingSegment = adjustSegmentToHoleDirection(intersectingSegment, holeGeometries);
}
Coordinate[] coords = intersectingSegment.getCoordinates();
for (int j = 0; j < coords.length - 1; j++) {
final SplitEdge edge =
SplitEdge.newInstance(coords[j], coords[j + 1], onLoc, leftLoc, rightLoc);
// add the list that only contains one edge because it will
// create 2 directedEdge.
this.graph.addEdge(edge);
}
}
}
@Override
protected Envelope getEnvelope(final TestGeometry entry) {
// incorporate the bounding box of the entry's envelope
final Geometry geometry = entry.geom;
if ((geometry != null) && !geometry.isEmpty()) {
return geometry.getEnvelopeInternal();
}
return null;
}
private void validate(final Geometry geom, final List<ValidationResult> validationErrors) {
if (geom.isEmpty()) {
return;
}
if (geom instanceof GeometryCollection) {
final GeometryCollection gc = (GeometryCollection) geom;
for (int numGeom = 0; numGeom < gc.getNumGeometries(); numGeom++) {
validate(gc.getGeometryN(numGeom), validationErrors);
}
}
final ValidationResult result = new ValidationResult();
result.setWkt(geom.toText());
final List<String> messages = new ArrayList<String>();
if (!geom.isValid()) {
messages.add("Error en topología básica");
}
if (!geom.isSimple()) {
messages.add("No es una geometría simple");
}
if (repeatedPointTester.hasRepeatedPoint(geom)) {
messages.add("Se encuentran vértices repetidos");
}
if (geom instanceof Polygon) {
final Polygon polygon = (Polygon) geom;
if (CGAlgorithms.isCCW(polygon.getExteriorRing().getCoordinates())) {
messages.add("Error en orientación del polígono");
} else {
for (int numRing = 0; numRing < polygon.getNumInteriorRing(); numRing++) {
if (!CGAlgorithms.isCCW(polygon.getInteriorRingN(numRing).getCoordinates())) {
messages.add("Error en orientación del polígono en anillos interiores");
break;
}
}
}
if (!validateMinPolygonArea(geom)) {
messages.add("Error en validación mínima de area de un polígono");
}
}
if (!validateMinSegmentLength(geom)) {
messages.add("Error en validación mínima de longitud de segmento");
}
if (!messages.isEmpty()) {
result.setMessages(messages);
validationErrors.add(result);
}
}
protected Geometry transformMultiPolygon(MultiPolygon geom, Geometry parent) {
List transGeomList = new ArrayList();
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry transformGeom = transformPolygon((Polygon) geom.getGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.isEmpty()) continue;
transGeomList.add(transformGeom);
}
return factory.buildGeometry(transGeomList);
}
/**
* Check if geometry is in SpatialFilter envelopes
*
* @param geometry Geometry to check
* @param envelopes SpatialFilter envelopes
* @return True if geometry is contained in envelopes
*/
public boolean featureIsInFilter(final Geometry geometry, final List<Geometry> envelopes) {
if (geometry != null && !geometry.isEmpty()) {
for (final Geometry envelope : envelopes) {
if (envelope.contains(geometry)) {
return true;
}
}
}
return false;
}
private Geometry switchCoordinateAxisIfNeeded(Geometry geometry, int targetSRID)
throws OwsExceptionReport {
if (geometry != null && !geometry.isEmpty()) {
if ((isNorthingFirstEpsgCode(geometry.getSRID()) && isNorthingFirstEpsgCode(targetSRID))
|| (isEastingFirstEpsgCode(geometry.getSRID()) && isEastingFirstEpsgCode(targetSRID))) {
return geometry;
}
return JTSHelper.switchCoordinateAxisOrder(geometry);
}
return geometry;
}
public void encodeGeometryValue(Geometry value, int srid, StringBuffer sql) throws IOException {
if (value == null || value.isEmpty()) {
sql.append("ST_GeomFromText ('");
sql.append(new WKTWriter().write(value));
sql.append("',");
sql.append(srid);
sql.append(")");
} else {
sql.append("NULL");
}
}
protected Geometry transformGeometryCollection(GeometryCollection geom, Geometry parent) {
List transGeomList = new ArrayList();
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry transformGeom = transform(geom.getGeometryN(i));
if (transformGeom == null) continue;
if (pruneEmptyGeometry && transformGeom.isEmpty()) continue;
transGeomList.add(transformGeom);
}
if (preserveGeometryCollectionType)
return factory.createGeometryCollection(GeometryFactory.toGeometryArray(transGeomList));
return factory.buildGeometry(transGeomList);
}
/**
* Transform geometry to this EPSG code
*
* @param geometry Geometry to transform
* @param targetSRID Target EPSG code
* @return Transformed geometry
* @throws OwsExceptionReport
*/
public Geometry transform(final Geometry geometry, final int targetSRID)
throws OwsExceptionReport {
if (geometry != null && !geometry.isEmpty()) {
if (geometry.getSRID() == targetSRID) {
return geometry;
}
CoordinateReferenceSystem sourceCRS = getCRS(geometry.getSRID());
CoordinateReferenceSystem targetCRS = getCRS(targetSRID);
return transform(geometry, targetSRID, sourceCRS, targetCRS);
}
return geometry;
}
@Override
public void encodeGeometryValue(Geometry value, int srid, StringBuffer sql) throws IOException {
if (value == null || value.isEmpty()) {
sql.append("NULL");
} else {
if (value instanceof LinearRing) {
// postgis does not handle linear rings, convert to just a line string
value = value.getFactory().createLineString(((LinearRing) value).getCoordinateSequence());
}
sql.append("ST_GeomFromText('" + value.toText() + "', " + srid + ")");
}
}
/**
* Transforms the geometry to the storage EPSG code
*
* @param geometry Geometry to transform
* @return Transformed geometry
* @throws OwsExceptionReport
*/
public Geometry transformToStorageEpsg(final Geometry geometry) throws OwsExceptionReport {
if (geometry != null && !geometry.isEmpty()) {
CoordinateReferenceSystem sourceCRS = getCRS(geometry.getSRID());
int targetSRID;
if (sourceCRS.getCoordinateSystem().getDimension() == 3) {
targetSRID = getStorage3DEPSG();
} else {
targetSRID = getStorageEPSG();
}
return transform(geometry, targetSRID, sourceCRS, getCRS(targetSRID));
}
return geometry;
}
public static Rectangle computePixelRegion(
Product product, Geometry geoRegion, int numBorderPixels) {
final Geometry productGeometry = computeProductGeometry(product);
final Geometry regionIntersection = geoRegion.intersection(productGeometry);
if (regionIntersection.isEmpty()) {
return new Rectangle();
}
final PixelRegionFinder pixelRegionFinder = new PixelRegionFinder(product.getGeoCoding());
regionIntersection.apply(pixelRegionFinder);
final Rectangle pixelRegion = pixelRegionFinder.getPixelRegion();
pixelRegion.grow(numBorderPixels, numBorderPixels);
return pixelRegion.intersection(
new Rectangle(product.getSceneRasterWidth(), product.getSceneRasterHeight()));
}
public static final int getCoordDim(Geometry geom) {
if (geom.isEmpty()) {
return 0;
}
if (geom instanceof Point) {
return getCoordSequenceDim(((Point) geom).getCoordinateSequence());
} else if (geom instanceof LineString) {
return getCoordSequenceDim(((LineString) geom).getCoordinateSequence());
} else if (geom instanceof Polygon) {
return getCoordSequenceDim(((Polygon) geom).getExteriorRing().getCoordinateSequence());
} else {
return getCoordDim(geom.getGeometryN(0));
}
}
public static Envelope3D of(final Geometry g) {
if (g == null || g.isEmpty()) {
return new Envelope3D();
}
final Envelope3D env = new Envelope3D();
g.apply(
new CoordinateFilter() {
@Override
public void filter(final Coordinate coord) {
env.expandToInclude(coord);
}
});
return env;
}
/**
* Switch the coordinate axis of geometry from or for datasource
*
* @param geom Geometry to switch coordinate axis
* @return Geometry with switched coordinate axis if needed
* @throws OwsExceptionReport If coordinate axis switching fails
*/
public Geometry switchCoordinateAxisFromToDatasourceIfNeeded(final Geometry geom)
throws OwsExceptionReport {
if (geom != null && !geom.isEmpty()) {
if (isDatasourceNorthingFirst()) {
if (!isNorthingFirstEpsgCode(geom.getSRID())) {
return JTSHelper.switchCoordinateAxisOrder(geom);
}
return geom;
} else {
if (isNorthingFirstEpsgCode(geom.getSRID())) {
return JTSHelper.switchCoordinateAxisOrder(geom);
}
return geom;
}
}
return geom;
}
public void write(Geometry geometry, EndianDataOutputStream file) throws IOException {
if (geometry.isEmpty()) {
file.writeIntLE(0);
return;
}
file.writeIntLE(getShapeType());
Coordinate c = geometry.getCoordinates()[0];
file.writeDoubleLE(c.x);
file.writeDoubleLE(c.y);
if (myShapeType == 11) {
if (Double.isNaN(c.z)) // nan means not defined
file.writeDoubleLE(0.0);
else file.writeDoubleLE(c.z);
}
if ((myShapeType == 11) || (myShapeType == 21)) {
file.writeDoubleLE(-10E40); // M
}
}
Expression clipToWorld(BinarySpatialOperator filter, Expression e) {
if (e instanceof Literal) {
Geometry eval = e.evaluate(filter, Geometry.class);
// Oracle cannot deal with filters using geometries that span beyond the whole world
// in case the
if (dialect != null
&& isCurrentGeometryGeodetic()
&& !WORLD.contains(eval.getEnvelopeInternal())) {
Geometry result = eval.intersection(JTS.toGeometry(WORLD));
if (result != null && !result.isEmpty()) {
if (result instanceof GeometryCollection) {
result = distillSameTypeGeometries((GeometryCollection) result, eval);
}
e = new FilterFactoryImpl().createLiteralExpression(result);
}
}
}
return e;
}
public static int getWKBType(Geometry geom) {
// We always write emtpy geometries as emtpy collections - for OpenGIS
// conformance
if (geom.isEmpty()) {
return org.postgis.Geometry.GEOMETRYCOLLECTION;
} else if (geom instanceof Point) {
return org.postgis.Geometry.POINT;
} else if (geom instanceof com.vividsolutions.jts.geom.LineString) {
return org.postgis.Geometry.LINESTRING;
} else if (geom instanceof com.vividsolutions.jts.geom.Polygon) {
return org.postgis.Geometry.POLYGON;
} else if (geom instanceof MultiPoint) {
return org.postgis.Geometry.MULTIPOINT;
} else if (geom instanceof MultiLineString) {
return org.postgis.Geometry.MULTILINESTRING;
} else if (geom instanceof com.vividsolutions.jts.geom.MultiPolygon) {
return org.postgis.Geometry.MULTIPOLYGON;
}
if (geom instanceof com.vividsolutions.jts.geom.GeometryCollection) {
return org.postgis.Geometry.GEOMETRYCOLLECTION;
} else {
throw new IllegalArgumentException("Unknown Geometry Type: " + geom.getClass().getName());
}
}
@Override
public void run() {
/*
* This tool places the nodes (vertices) from a shapefile of polygons or
* lines into a shapefile of Point ShapeType.
*/
amIActive = true;
String inputFile;
String outputFile;
int progress;
int i, n;
int numFeatures;
int oneHundredthTotal;
ShapeType shapeType, outputShapeType;
GeometryFactory factory = new GeometryFactory();
double distTolerance = 10;
boolean loseNoFeatures = false;
if (args.length <= 0) {
showFeedback("Plugin parameters have not been set.");
return;
}
inputFile = args[0];
outputFile = args[1];
distTolerance = Double.parseDouble(args[2]);
loseNoFeatures = Boolean.parseBoolean(args[3]);
// check to see that the inputHeader and outputHeader are not null.
if ((inputFile == null) || (outputFile == null)) {
showFeedback("One or more of the input parameters have not been set properly.");
return;
}
try {
// set up the input shapefile.
ShapeFile input = new ShapeFile(inputFile);
shapeType = input.getShapeType();
// make sure that the shapetype is either a flavour of polyline or polygon.
if (shapeType.getBaseType() != ShapeType.POLYGON
&& shapeType.getBaseType() != ShapeType.POLYLINE) {
showFeedback("This tool only works with shapefiles of a polygon or line base shape type.");
return;
}
// set up the output files of the shapefile and the dbf
if (shapeType.getBaseType() == ShapeType.POLYGON) {
outputShapeType = ShapeType.POLYGON;
} else if (shapeType.getBaseType() == ShapeType.POLYLINE) {
outputShapeType = ShapeType.POLYLINE;
} else {
showFeedback("This tool only works with shapefiles of a polygon or line base shape type.");
return;
}
int numOutputFields = input.getAttributeTable().getFieldCount() + 1;
int numInputFields = input.getAttributeTable().getFieldCount();
DBFField[] inputFields = input.getAttributeTable().getAllFields();
DBFField fields[] = new DBFField[numOutputFields];
fields[0] = new DBFField();
fields[0].setName("PARENT_ID");
fields[0].setDataType(DBFField.DBFDataType.NUMERIC);
fields[0].setFieldLength(10);
fields[0].setDecimalCount(0);
System.arraycopy(inputFields, 0, fields, 1, numInputFields);
ShapeFile output = new ShapeFile(outputFile, outputShapeType, fields);
numFeatures = input.getNumberOfRecords();
oneHundredthTotal = numFeatures / 100;
n = 0;
progress = 0;
com.vividsolutions.jts.geom.Geometry[] recJTS = null;
int recordNum;
for (ShapeFileRecord record : input.records) {
recordNum = record.getRecordNumber();
Object[] attData = input.getAttributeTable().getRecord(recordNum - 1);
// featureNum++;
recJTS = record.getGeometry().getJTSGeometries();
ArrayList<com.vividsolutions.jts.geom.Geometry> geomList = new ArrayList<>();
for (int a = 0; a < recJTS.length; a++) {
geomList.add(recJTS[a]);
}
DouglasPeuckerSimplifier dps =
new DouglasPeuckerSimplifier(factory.buildGeometry(geomList));
dps.setDistanceTolerance(distTolerance);
com.vividsolutions.jts.geom.Geometry outputGeom = dps.getResultGeometry();
if (outputGeom.isEmpty() && loseNoFeatures) {
outputGeom = factory.buildGeometry(geomList);
}
if (!outputGeom.isEmpty()) {
for (int a = 0; a < outputGeom.getNumGeometries(); a++) {
// parentRecNum = 0;
com.vividsolutions.jts.geom.Geometry g = outputGeom.getGeometryN(a);
if (g instanceof com.vividsolutions.jts.geom.Polygon && !g.isEmpty()) {
com.vividsolutions.jts.geom.Polygon p = (com.vividsolutions.jts.geom.Polygon) g;
ArrayList<ShapefilePoint> pnts = new ArrayList<>();
int[] parts = new int[p.getNumInteriorRing() + 1];
Coordinate[] buffCoords = p.getExteriorRing().getCoordinates();
if (!Topology.isLineClosed(buffCoords)) {
System.out.println("Exterior ring not closed.");
}
if (Topology.isClockwisePolygon(buffCoords)) {
for (i = 0; i < buffCoords.length; i++) {
pnts.add(new ShapefilePoint(buffCoords[i].x, buffCoords[i].y));
}
} else {
for (i = buffCoords.length - 1; i >= 0; i--) {
pnts.add(new ShapefilePoint(buffCoords[i].x, buffCoords[i].y));
}
}
for (int b = 0; b < p.getNumInteriorRing(); b++) {
parts[b + 1] = pnts.size();
buffCoords = p.getInteriorRingN(b).getCoordinates();
if (!Topology.isLineClosed(buffCoords)) {
System.out.println("Interior ring not closed.");
}
if (Topology.isClockwisePolygon(buffCoords)) {
for (i = buffCoords.length - 1; i >= 0; i--) {
pnts.add(new ShapefilePoint(buffCoords[i].x, buffCoords[i].y));
}
} else {
for (i = 0; i < buffCoords.length; i++) {
pnts.add(new ShapefilePoint(buffCoords[i].x, buffCoords[i].y));
}
}
}
PointsList pl = new PointsList(pnts);
whitebox.geospatialfiles.shapefile.Polygon wbPoly =
new whitebox.geospatialfiles.shapefile.Polygon(parts, pl.getPointsArray());
Object[] rowData = new Object[numOutputFields];
rowData[0] = new Double(recordNum - 1);
System.arraycopy(attData, 0, rowData, 1, numInputFields);
output.addRecord(wbPoly, rowData);
} else if (g instanceof com.vividsolutions.jts.geom.LineString && !g.isEmpty()) {
LineString ls = (LineString) g;
ArrayList<ShapefilePoint> pnts = new ArrayList<>();
int[] parts = {0};
Coordinate[] coords = ls.getCoordinates();
for (i = 0; i < coords.length; i++) {
pnts.add(new ShapefilePoint(coords[i].x, coords[i].y));
}
PointsList pl = new PointsList(pnts);
whitebox.geospatialfiles.shapefile.PolyLine wbGeometry =
new whitebox.geospatialfiles.shapefile.PolyLine(parts, pl.getPointsArray());
Object[] rowData = new Object[numOutputFields];
rowData[0] = new Double(recordNum - 1);
System.arraycopy(attData, 0, rowData, 1, numInputFields);
output.addRecord(wbGeometry, rowData);
}
}
}
n++;
if (n >= oneHundredthTotal) {
n = 0;
if (cancelOp) {
cancelOperation();
return;
}
progress++;
updateProgress(progress);
}
}
output.write();
// returning a header file string displays the image.
updateProgress("Displaying vector: ", 0);
returnData(outputFile);
} catch (OutOfMemoryError oe) {
myHost.showFeedback("An out-of-memory error has occurred during operation.");
} catch (Exception e) {
myHost.showFeedback("An error has occurred during operation. See log file for details.");
myHost.logException("Error in " + getDescriptiveName(), e);
} finally {
updateProgress("Progress: ", 0);
// tells the main application that this process is completed.
amIActive = false;
myHost.pluginComplete();
}
}
/**
* Add a feature with layer name (typically feature type name), some attributes and a Geometry.
* The Geometry must be in "pixel" space 0,0 lower left and 256,256 upper right.
*
* <p>For optimization, geometries will be clipped, geometries will simplified and features with
* geometries outside of the tile will be skipped.
*
* @param layerName
* @param attributes
* @param geometry
*/
public void addFeature(String layerName, Map<String, ?> attributes, Geometry geometry) {
// split up MultiPolygon and GeometryCollection (without subclasses)
if (geometry instanceof MultiPolygon || geometry.getClass().equals(GeometryCollection.class)) {
splitAndAddFeatures(layerName, attributes, (GeometryCollection) geometry);
return;
}
// skip small Polygon/LineString.
if (geometry instanceof Polygon && geometry.getArea() < 1.0d) {
return;
}
if (geometry instanceof LineString && geometry.getLength() < 1.0d) {
return;
}
// clip geometry. polygons right outside. other geometries at tile
// border.
try {
if (geometry instanceof Polygon) {
Geometry original = geometry;
geometry = polygonClipGeometry.intersection(original);
// some times a intersection is returned as an empty geometry.
// going via wkt fixes the problem.
if (geometry.isEmpty() && original.intersects(polygonClipGeometry)) {
Geometry originalViaWkt = new WKTReader().read(original.toText());
geometry = polygonClipGeometry.intersection(originalViaWkt);
}
} else {
geometry = clipGeometry.intersection(geometry);
}
} catch (TopologyException e) {
// could not intersect. original geometry will be used instead.
} catch (ParseException e1) {
// could not encode/decode WKT. original geometry will be used instead.
}
// if clipping result in MultiPolygon, then split once more
if (geometry instanceof MultiPolygon) {
splitAndAddFeatures(layerName, attributes, (GeometryCollection) geometry);
return;
}
// no need to add empty geometry
if (geometry.isEmpty()) {
return;
}
Layer layer = layers.get(layerName);
if (layer == null) {
layer = new Layer();
layers.put(layerName, layer);
}
Feature feature = new Feature();
feature.geometry = geometry;
for (Map.Entry<String, ?> e : attributes.entrySet()) {
// skip attribute without value
if (e.getValue() == null) {
continue;
}
feature.tags.add(layer.key(e.getKey()));
feature.tags.add(layer.value(e.getValue()));
}
layer.features.add(feature);
}
/**
* Calcuates the record length of this object.
*
* @return the length of the record that this point will take up in a shapefile (in WORDS)
*/
public int getLength(Geometry geometry) {
if (geometry.isEmpty()) return 2;
else if (myShapeType == 1) return 10;
else if (myShapeType == 21) return 14;
else return 18;
}
/** Parse a geometry starting at offset. */
protected void writeGeometry(Geometry geom, ValueSetter dest) {
final int dimension;
if (geom == null) {
throw new NullPointerException();
} else if (geom.isEmpty()) {
// don't set any flag bits
dimension = 0;
} else {
dimension = getCoordDim(geom);
if (dimension < 2 || dimension > 4) {
throw new IllegalArgumentException("Unsupported geometry dimensionality: " + dimension);
}
}
// write endian flag
dest.setByte(dest.endian);
// write typeword
final int plaintype = getWKBType(geom);
int typeword = plaintype;
if (dimension == 3 || dimension == 4) {
typeword |= 0x80000000;
}
if (dimension == 4) {
typeword |= 0x40000000;
}
final boolean haveSrid = checkSrid(geom);
if (haveSrid) {
typeword |= 0x20000000;
}
dest.setInt(typeword);
if (haveSrid) {
dest.setInt(geom.getSRID());
}
switch (plaintype) {
case org.postgis.Geometry.POINT:
writePoint((Point) geom, dest);
break;
case org.postgis.Geometry.LINESTRING:
writeLineString((LineString) geom, dest);
break;
case org.postgis.Geometry.POLYGON:
writePolygon((Polygon) geom, dest);
break;
case org.postgis.Geometry.MULTIPOINT:
writeMultiPoint((MultiPoint) geom, dest);
break;
case org.postgis.Geometry.MULTILINESTRING:
writeMultiLineString((MultiLineString) geom, dest);
break;
case org.postgis.Geometry.MULTIPOLYGON:
writeMultiPolygon((MultiPolygon) geom, dest);
break;
case org.postgis.Geometry.GEOMETRYCOLLECTION:
writeCollection((GeometryCollection) geom, dest);
break;
default:
throw new IllegalArgumentException("Unknown Geometry Type: " + plaintype);
}
}
