public void testHomogeneous() throws Exception {
    Node node =
        createNode(
            gcol,
            new ElementInstance[] {point1, point2},
            new Object[] {
              gf.createPoint(new Coordinate(0, 0)), gf.createPoint(new Coordinate(1, 1))
            },
            null,
            null);

    GMLGeometryCollectionTypeBinding s =
        (GMLGeometryCollectionTypeBinding)
            container.getComponentInstanceOfType(GMLGeometryCollectionTypeBinding.class);

    GeometryCollection gc = (GeometryCollection) s.parse(gcol, node, null);
    assertNotNull(gc);
    assertEquals(gc.getNumGeometries(), 2);
    assertTrue(gc.getGeometryN(0) instanceof Point);
    assertTrue(gc.getGeometryN(1) instanceof Point);
    assertEquals(((Point) gc.getGeometryN(0)).getX(), 0d, 0d);
    assertEquals(((Point) gc.getGeometryN(0)).getY(), 0d, 0d);
    assertEquals(((Point) gc.getGeometryN(1)).getX(), 1d, 0d);
    assertEquals(((Point) gc.getGeometryN(1)).getY(), 1d, 0d);
  }
  List<Integer> commands(Geometry geometry) {

    x = 0;
    y = 0;

    if (geometry instanceof Polygon) {
      Polygon polygon = (Polygon) geometry;
      if (polygon.getNumInteriorRing() > 0) {
        List<Integer> commands = new ArrayList<Integer>();
        commands.addAll(commands(polygon.getExteriorRing().getCoordinates(), true));
        for (int i = 0; i < polygon.getNumInteriorRing(); i++) {
          commands.addAll(commands(polygon.getInteriorRingN(i).getCoordinates(), true));
        }
        return commands;
      }
    }

    if (geometry instanceof MultiLineString || geometry instanceof MultiPoint) {
      List<Integer> commands = new ArrayList<Integer>();
      GeometryCollection gc = (GeometryCollection) geometry;
      for (int i = 0; i < gc.getNumGeometries(); i++) {
        commands.addAll(commands(gc.getGeometryN(i).getCoordinates(), false));
      }
      return commands;
    }

    return commands(geometry.getCoordinates(), shouldClosePath(geometry));
  }
Example #3
0
  private static void transformGeometry(Geometry geometry) {
    if (geometry == null) {
      return;
    }

    if (geometry instanceof GeometryCollection) {
      GeometryCollection collection = (GeometryCollection) geometry;
      for (int i = 0; i < collection.getNumGeometries(); i++) {
        transformGeometry(collection.getGeometryN(i));
      }
    } else if (geometry instanceof Polygon) {
      Polygon polygon = (Polygon) geometry;
      transformGeometry(polygon.getExteriorRing());
      for (int i = 0; i < polygon.getNumInteriorRing(); i++) {
        transformGeometry(polygon.getInteriorRingN(i));
      }
    } else if (geometry instanceof LineString) {
      LiteCoordinateSequence seq =
          (LiteCoordinateSequence) ((LineString) geometry).getCoordinateSequence();
      double[] coords = seq.getArray();
      for (int i = 0; i < coords.length; i++) {
        coords[i] = (int) (coords[i] + 0.5d);
      }
      seq.setArray(coords);
    }
  }
  /**
   * Extract the coordinate arrays for a geometry into a List.
   *
   * @param g the Geometry to extract from
   * @param coordArrayList the List to add the coordinate arrays to
   * @param orientPolygons whether or not the arrays in the List should be oriented (clockwise for
   *     the shell, counterclockwise for the holes)
   */
  public static void addCoordinateArrays(Geometry g, boolean orientPolygons, List coordArrayList) {
    if (g.getDimension() <= 0) {
      return;
    } else if (g instanceof LineString) {
      LineString l = (LineString) g;
      coordArrayList.add(l.getCoordinates());
    } else if (g instanceof Polygon) {
      Polygon poly = (Polygon) g;
      Coordinate[] shell = poly.getExteriorRing().getCoordinates();

      if (orientPolygons) {
        shell = ensureOrientation(shell, CGAlgorithms.CLOCKWISE);
      }

      coordArrayList.add(shell);

      for (int i = 0; i < poly.getNumInteriorRing(); i++) {
        Coordinate[] hole = poly.getInteriorRingN(i).getCoordinates();

        if (orientPolygons) {
          hole = ensureOrientation(hole, CGAlgorithms.COUNTERCLOCKWISE);
        }

        coordArrayList.add(hole);
      }
    } else if (g instanceof GeometryCollection) {
      GeometryCollection gc = (GeometryCollection) g;

      for (int i = 0; i < gc.getNumGeometries(); i++) {
        addCoordinateArrays(gc.getGeometryN(i), orientPolygons, coordArrayList);
      }
    } else {
      Assert.shouldNeverReachHere("Geometry of type " + g.getClass().getName() + " not handled");
    }
  }
Example #5
0
 public final void decimateTransformGeneralize(Geometry geometry, MathTransform transform)
     throws TransformException {
   if (geometry instanceof GeometryCollection) {
     GeometryCollection collection = (GeometryCollection) geometry;
     final int length = collection.getNumGeometries();
     for (int i = 0; i < length; i++) {
       decimateTransformGeneralize(collection.getGeometryN(i), transform);
     }
   } else if (geometry instanceof Point) {
     LiteCoordinateSequence seq =
         (LiteCoordinateSequence) ((Point) geometry).getCoordinateSequence();
     decimateTransformGeneralize(seq, transform);
   } else if (geometry instanceof Polygon) {
     Polygon polygon = (Polygon) geometry;
     decimateTransformGeneralize(polygon.getExteriorRing(), transform);
     final int length = polygon.getNumInteriorRing();
     for (int i = 0; i < length; i++) {
       decimateTransformGeneralize(polygon.getInteriorRingN(i), transform);
     }
   } else if (geometry instanceof LineString) {
     LiteCoordinateSequence seq =
         (LiteCoordinateSequence) ((LineString) geometry).getCoordinateSequence();
     decimateTransformGeneralize(seq, transform);
   }
 }
 private void splitAndAddFeatures(
     String layerName, Map<String, ?> attributes, GeometryCollection geometry) {
   for (int i = 0; i < geometry.getNumGeometries(); i++) {
     Geometry subGeometry = geometry.getGeometryN(i);
     addFeature(layerName, attributes, subGeometry);
   }
 }
 protected static Geometry transformGeometryCollection(
     CoordinateTransform ct, GeometryCollection geometryCollection) throws Exception {
   Geometry[] geometry = new Geometry[geometryCollection.getNumGeometries()];
   for (int i = 0; i < geometry.length; ++i) {
     geometry[i] = transformGeometry(ct, geometryCollection.getGeometryN(i));
   }
   return geometryCollection.getFactory().createGeometryCollection(geometry);
 }
Example #8
0
  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);
    }
  }
Example #9
0
  private JSONBuilder writeGeomCollection(GeometryCollection collection) {
    this.key("geometries");
    this.array();

    for (int i = 0, n = collection.getNumGeometries(); i < n; i++) {
      writeGeom(collection.getGeometryN(i));
    }

    return this.endArray();
  }
  public void testHeterogeneous() throws Exception {
    Node node =
        createNode(
            gcol,
            new ElementInstance[] {point1, point2, line1, ring1, poly1},
            new Object[] {
              gf.createPoint(new Coordinate(0, 0)),
              gf.createPoint(new Coordinate(1, 1)),
              gf.createLineString(new Coordinate[] {new Coordinate(0, 0), new Coordinate(1, 1)}),
              gf.createLinearRing(
                  new Coordinate[] {
                    new Coordinate(0, 0),
                    new Coordinate(1, 1),
                    new Coordinate(2, 2),
                    new Coordinate(0, 0)
                  }),
              gf.createPolygon(
                  gf.createLinearRing(
                      new Coordinate[] {
                        new Coordinate(0, 0),
                        new Coordinate(1, 1),
                        new Coordinate(2, 2),
                        new Coordinate(0, 0)
                      }),
                  null)
            },
            null,
            null);

    GMLGeometryCollectionTypeBinding s =
        (GMLGeometryCollectionTypeBinding)
            container.getComponentInstanceOfType(GMLGeometryCollectionTypeBinding.class);

    GeometryCollection gc = (GeometryCollection) s.parse(gcol, node, null);
    assertNotNull(gc);
    assertEquals(gc.getNumGeometries(), 5);
    assertTrue(gc.getGeometryN(0) instanceof Point);
    assertTrue(gc.getGeometryN(1) instanceof Point);
    assertTrue(gc.getGeometryN(2) instanceof LineString);
    assertTrue(gc.getGeometryN(3) instanceof LinearRing);
    assertTrue(gc.getGeometryN(4) instanceof Polygon);
  }
 protected <T> void accumulateGeometries(
     List<T> collection, Geometry g, Class<? extends T> target) {
   if (target.isInstance(g)) {
     collection.add((T) g);
   } else if (g instanceof GeometryCollection) {
     GeometryCollection coll = (GeometryCollection) g;
     for (int i = 0; i < coll.getNumGeometries(); i++) {
       accumulateGeometries(collection, coll.getGeometryN(i), target);
     }
   }
 }
Example #12
0
  Map<String, Object> createGeometryCollection(GeometryCollection gcol) {
    LinkedHashMap obj = new LinkedHashMap();

    ArrayList geoms = new ArrayList(gcol.getNumGeometries());
    for (int i = 0; i < gcol.getNumGeometries(); i++) {
      geoms.add(create(gcol.getGeometryN(i)));
    }

    obj.put("type", "GeometryCollection");
    obj.put("geometries", geoms);
    return obj;
  }
Example #13
0
 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);
 }
Example #14
0
  /** decimates JTS geometries. */
  public final Geometry decimate(Geometry geom) {
    GeometryFactory gFac = new GeometryFactory(geom.getPrecisionModel(), geom.getSRID());
    if (spanx == -1) return geom;
    if (geom instanceof MultiPoint) {
      // TODO check geometry and if its bbox is too small turn it into a 1
      // point geom
      return geom;
    }
    if (geom instanceof GeometryCollection) {
      // TODO check geometry and if its bbox is too small turn it into a
      // 1-2 point geom
      // takes a bit of work because the geometry will need to be
      // recreated.
      GeometryCollection collection = (GeometryCollection) geom;
      Geometry[] result = new Geometry[collection.getDimension()];
      final int numGeometries = collection.getNumGeometries();
      for (int i = 0; i < numGeometries; i++) {
        result[i] = decimate(collection.getGeometryN(i));
      }
      return gFac.createGeometryCollection(result);

    } else if (geom instanceof LineString) {
      LineString line = (LineString) geom;
      CoordinateSequence seq = (CoordinateSequence) line.getCoordinateSequence();
      LiteCoordinateSequence lseq = new LiteCoordinateSequence(seq.toCoordinateArray());

      if (decimateOnEnvelope(line, lseq)) {
        if (lseq.size() >= 2) return gFac.createLineString(lseq);
      }
      if (lseq.size() >= 2) return gFac.createLineString(decimate(lseq));
      return null;
    } else if (geom instanceof Polygon) {
      Polygon line = (Polygon) geom;
      Coordinate[] exterior = decimate(line.getExteriorRing()).getCoordinates();
      forceClosed(exterior);
      if (exterior.length > 3) {
        LinearRing ring = gFac.createLinearRing(exterior);

        final int numRings = line.getNumInteriorRing();
        List<LinearRing> rings = new ArrayList<LinearRing>();

        for (int i = 0; i < numRings; i++) {
          Coordinate[] interior = decimate(line.getInteriorRingN(i)).getCoordinates();
          forceClosed(interior);
          if (interior.length > 3) rings.add(gFac.createLinearRing(interior));
        }
        return gFac.createPolygon(ring, rings.toArray(new LinearRing[] {}));
      }
      return null;
    }
    return geom;
  }
 /**
  * The method explodes a geometry, if it is a multi-geometry (Geometry Collection), into their
  * parts.
  *
  * @param geom
  * @return a list of geometries
  */
 public static ArrayList<Geometry> explodeGeomsIfMultiG(Geometry geom) {
   ArrayList<Geometry> geoms = new ArrayList<Geometry>();
   if (geom instanceof GeometryCollection) {
     // System.out.println("explode multigeoms");
     GeometryCollection multig = (GeometryCollection) geom;
     for (int i = 0; i < multig.getNumGeometries(); i++) {
       Geometry g = (Geometry) multig.getGeometryN(i);
       geoms.add(g);
     }
   } else {
     geoms.add(geom);
   }
   return geoms;
 }
Example #16
0
 List toList(GeometryCollection mgeom) {
   ArrayList list = new ArrayList(mgeom.getNumGeometries());
   for (int i = 0; i < mgeom.getNumGeometries(); i++) {
     Geometry g = mgeom.getGeometryN(i);
     if (g instanceof Polygon) {
       list.add(toList((Polygon) g));
     } else if (g instanceof LineString) {
       list.add(new CoordinateSequenceEncoder(((LineString) g).getCoordinateSequence(), scale));
     } else if (g instanceof Point) {
       list.add(new CoordinateSequenceEncoder(((Point) g).getCoordinateSequence(), scale));
     }
   }
   return list;
 }
Example #17
0
  /**
   * Bulk write method for writing a collection of (hopefully) like geometries of the given
   * ShapeType.
   */
  public void write(final GeometryCollection geometries, final ShapeType type)
      throws IOException, DataStoreException {
    handler = type.getShapeHandler(true);

    writeHeaders(geometries, type);

    lp = shapeBuffer.position();
    for (int i = 0, ii = geometries.getNumGeometries(); i < ii; i++) {
      Geometry g = geometries.getGeometryN(i);

      writeGeometry(g);
    }

    close();
  }
 /**
  * @param geometry
  * @return
  * @throws Exception
  */
 @Override
 public org.geojson.GeometryCollection buildGeoJsonGeometry(GeometryCollection geometry)
     throws Exception {
   logger.trace(
       ":::::::::::::::::::Called {}#buildGeoJsonGeometry for JTS_GEOMETRY : {}\n",
       super.toString(),
       geometry);
   org.geojson.GeometryCollection geometryCollection = new org.geojson.GeometryCollection();
   for (int i = 0; i < geometry.getNumGeometries(); i++) {
     Geometry theGeom = geometry.getGeometryN(i);
     GeometryWriterImplementor implementor =
         GEOMETRY_WRITER_IMPLEMENTOR_STORE.getImplementorByKey(theGeom.getClass());
     geometryCollection.add(implementor.buildGeoJsonGeometry(theGeom));
   }
   return geometryCollection;
 }
Example #19
0
 private void writeHeaders(final GeometryCollection geometries, final ShapeType type)
     throws IOException {
   // ShapefileHeader header = new ShapefileHeader();
   // Envelope bounds = geometries.getEnvelopeInternal();
   // header.write(shapeBuffer, type, geometries.getNumGeometries(),
   // fileLength / 2,
   // bounds.getMinX(),bounds.getMinY(), bounds.getMaxX(),bounds.getMaxY()
   // );
   // header.write(indexBuffer, type, geometries.getNumGeometries(), 50 + 4
   // * geometries.getNumGeometries(),
   // bounds.getMinX(),bounds.getMinY(), bounds.getMaxX(),bounds.getMaxY()
   // );
   int fileLength = 100;
   // int largestShapeSize = 0;
   for (int i = geometries.getNumGeometries() - 1; i >= 0; i--) {
     // shape length + record (2 ints)
     int size = handler.getLength(geometries.getGeometryN(i)) + 8;
     fileLength += size;
     // if (size > largestShapeSize)
     // largestShapeSize = size;
   }
   writeHeaders(geometries.getEnvelopeInternal(), type, geometries.getNumGeometries(), fileLength);
 }
Example #20
0
  /**
   * Main method - write the featurecollection to a shapefile (2d, 3d or 4d).
   *
   * @param featureCollection collection to write
   * @param dp 'OutputFile' or 'DefaultValue' to specify where to write, and 'ShapeType' to specify
   *     dimentionality.
   */
  public void write(FeatureCollection featureCollection, DriverProperties dp)
      throws IllegalParametersException, Exception {
    String shpfileName;
    String dbffname;
    String shxfname;

    String path;
    String fname;
    String fname_withoutextention;
    int shapeType;
    int loc;

    GeometryCollection gc;

    shpfileName = dp.getProperty(FILE_PROPERTY_KEY);

    if (shpfileName == null) {
      shpfileName = dp.getProperty(DEFAULT_VALUE_PROPERTY_KEY);
    }

    if (shpfileName == null) {
      throw new IllegalParametersException("no output filename specified");
    }

    loc = shpfileName.lastIndexOf(File.separatorChar);

    if (loc == -1) {
      // loc = 0; // no path - ie. "hills.shp"
      // path = "";
      // fname = shpfileName;
      // probably using the wrong path separator character.
      throw new Exception(
          "couldn't find the path separator character '"
              + File.separatorChar
              + "' in your shape file name. This you're probably using the unix (or dos) one.");
    } else {
      path = shpfileName.substring(0, loc + 1); // ie. "/data1/hills.shp" -> "/data1/"
      fname = shpfileName.substring(loc + 1); // ie. "/data1/hills.shp" -> "hills.shp"
    }

    loc = fname.lastIndexOf(".");

    if (loc == -1) {
      throw new IllegalParametersException("Filename must end in '.shp'");
    }

    fname_withoutextention = fname.substring(0, loc); // ie. "hills.shp" -> "hills."
    dbffname = path + fname_withoutextention + ".dbf";

    writeDbf(featureCollection, dbffname);

    // this gc will be a collection of either multi-points, multi-polygons, or multi-linestrings
    // polygons will have the rings in the correct order
    gc = makeSHAPEGeometryCollection(featureCollection);

    shapeType = 2; // x,y

    if (dp.getProperty(SHAPE_TYPE_PROPERTY_KEY) != null) {
      String st = dp.getProperty(SHAPE_TYPE_PROPERTY_KEY);

      if (st.equalsIgnoreCase("xy")) {
        shapeType = 2;
      } else if (st.equalsIgnoreCase("xym")) {
        shapeType = 3;
      } else if (st.equalsIgnoreCase("xymz")) {
        shapeType = 4;
      } else if (st.equalsIgnoreCase("xyzm")) {
        shapeType = 4;
      } else if (st.equalsIgnoreCase("xyz")) {
        shapeType = 4;
      } else {
        throw new IllegalParametersException(
            "ShapefileWriter.write() - dataproperties has a 'ShapeType' that isnt 'xy', 'xym', or 'xymz'");
      }
    } else {
      if (gc.getNumGeometries() > 0) {
        shapeType = guessCoorinateDims(gc.getGeometryN(0));
      }
    }

    URL url = new URL("file", "localhost", shpfileName);
    Shapefile myshape = new Shapefile(url);
    myshape.write(gc, shapeType);

    shxfname = path + fname_withoutextention + ".shx";

    BufferedOutputStream in = new BufferedOutputStream(new FileOutputStream(shxfname));
    EndianDataOutputStream sfile = new EndianDataOutputStream(in);

    myshape.writeIndex(gc, sfile, shapeType);
  }