Example #1
0
 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();
    }
  }