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();
}
private Geometry getSimpleLine(final Geometry geometry, final double dTolerance) {
Geometry simple;
if (m_bPreserve) {
simple = TopologyPreservingSimplifier.simplify(geometry, dTolerance);
} else {
simple = DouglasPeuckerSimplifier.simplify(geometry, dTolerance);
}
return simple;
}
/**
* Utility method for transforming a geometry ROI into the raster space, using the provided affine
* transformation.
*
* @param roi a {@link Geometry} in model space.
* @param mt2d an {@link AffineTransform} that maps from raster to model space. This is already
* referred to the pixel corner.
* @return a {@link ROI} suitable for using with JAI.
* @throws ProcessException in case there are problems with ivnerting the provided {@link
* AffineTransform}. Very unlikely to happen.
*/
public static ROI prepareROI(Geometry roi, AffineTransform mt2d) throws ProcessException {
// transform the geometry to raster space so that we can use it as a ROI source
Geometry rasterSpaceGeometry;
try {
rasterSpaceGeometry = JTS.transform(roi, new AffineTransform2D(mt2d.createInverse()));
} catch (MismatchedDimensionException e) {
throw new ProcessException(e);
} catch (TransformException e) {
throw new ProcessException(e);
} catch (NoninvertibleTransformException e) {
throw new ProcessException(e);
}
// System.out.println(rasterSpaceGeometry);
// System.out.println(rasterSpaceGeometry.getEnvelopeInternal());
// simplify the geometry so that it's as precise as the coverage, excess coordinates
// just make it slower to determine the point in polygon relationship
Geometry simplifiedGeometry = DouglasPeuckerSimplifier.simplify(rasterSpaceGeometry, 1);
// build a shape using a fast point in polygon wrapper
return new ROIGeometry(simplifiedGeometry);
}
@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();
}
}