/** * Helper method for {@link #intersection(Geometry, Geometry) intersection(Geometry, Geometry)} */ private static GeometryCollection intersection(GeometryCollection gc1, GeometryCollection gc2) { List<Geometry> ret = new ArrayList<Geometry>(); final int size = gc1.getNumGeometries(); for (int i = 0; i < size; i++) { Geometry g1 = gc1.getGeometryN(i); List<Geometry> partial = intersection(gc2, g1); ret.addAll(partial); } return gc1.getFactory().createGeometryCollection(GeometryFactory.toGeometryArray(ret)); }
/** * Return the intersection of two Geometries. <br> * This method relies completely on {@link Geometry#intersection(Geometry)} but also tries to * unroll <TT>GeometryCollection</TT>s. * * @param g1 * @param g2 * @return true if the two geometries intersect. */ public static Geometry intersection(Geometry g1, Geometry g2) { if (g1 instanceof GeometryCollection) { if (g2 instanceof GeometryCollection) { return intersection((GeometryCollection) g1, (GeometryCollection) g2); } else { List<Geometry> ret = intersection((GeometryCollection) g1, g2); return g1.getFactory() .createGeometryCollection(GeometryFactory.toGeometryArray(ret)); } } else { if (g2 instanceof GeometryCollection) { List<Geometry> ret = intersection((GeometryCollection) g2, g1); return g1.getFactory() .createGeometryCollection(GeometryFactory.toGeometryArray(ret)); } else { return g1.intersection(g2); } } }
@DescribeProcess(title = "Split Polygon", description = "Splits a polygon by a linestring") @DescribeResult(description = "The collection of split polygons") public static Geometry splitPolygon( @DescribeParameter(name = "polygon", description = "Polygon to split") Geometry polygon, @DescribeParameter(name = "line", description = "Linestring to split by") LineString line) { Geometry nodedLinework = polygon.getBoundary().union(line); Geometry polys = polygonize(nodedLinework); // Only keep polygons which are inside the input List<Polygon> output = new ArrayList<Polygon>(); for (int i = 0; i < polys.getNumGeometries(); i++) { Polygon candpoly = (Polygon) polys.getGeometryN(i); // use interior point to test for inclusion in parent if (polygon.contains(candpoly.getInteriorPoint())) { output.add(candpoly); } } return polygon.getFactory() .createGeometryCollection(GeometryFactory.toGeometryArray(output)); }
public static Geometry readWKBHexString(String wkb, GeometryFactory geomFact) throws ParseException, IOException { WKBReader reader = new WKBReader(geomFact); WKBHexFileReader fileReader = new WKBHexFileReader(new StringReader(wkb), reader); List geomList = fileReader.read(); if (geomList.size() == 1) return (Geometry) geomList.get(0); return geomFact.createGeometryCollection(GeometryFactory.toGeometryArray(geomList)); }
public static Geometry componentBuffers(Geometry g, double distance) { List bufs = new ArrayList(); for (Iterator it = new GeometryCollectionIterator(g); it.hasNext(); ) { Geometry comp = (Geometry) it.next(); if (comp instanceof GeometryCollection) continue; bufs.add(comp.buffer(distance)); } return FunctionsUtil.getFactoryOrDefault(g) .createGeometryCollection(GeometryFactory.toGeometryArray(bufs)); }
/** * Extracts all Geometry object substrings and reads them * @param s * @throws ParseException */ private Geometry readFeatureCollection(String s) throws ParseException { Pattern p = Pattern.compile("\\{[^\\{\\}]+?\\}"); Matcher m = p.matcher(s); List geoms = new ArrayList(); while (true) { boolean isFound = m.find(); if (! isFound) break; String substr = m.group(); if (isGeometry(substr)) { geoms.add(readGeometry(substr)); } //System.out.println(sgeom); } return geomFact.createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); }
private static Geometry readShapefile(String filename, GeometryFactory geomFact) throws Exception { Shapefile shpfile = new Shapefile(new FileInputStream(filename)); shpfile.readStream(geomFact); List geomList = new ArrayList(); do { Geometry geom = shpfile.next(); if (geom == null) break; geomList.add(geom); } while (true); return geomFact.createGeometryCollection(GeometryFactory.toGeometryArray(geomList)); }
public static Geometry buildGeometry(List geoms, Geometry parentGeom) { if (geoms.size() <= 0) return null; if (geoms.size() == 1) return (Geometry) geoms.get(0); // if parent was a GC, ensure returning a GC if (parentGeom != null && parentGeom.getGeometryType().equals("GeometryCollection")) return parentGeom.getFactory().createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); // otherwise return MultiGeom return getFactoryOrDefault(parentGeom).buildGeometry(geoms); }
/** * Gets the cells in the Voronoi diagram for this triangulation. * The cells are returned as a {@link GeometryCollection} of {@link Polygon}s * <p> * The userData of each polygon is set to be the {@link Coordinate} * of the cell site. This allows easily associating external * data associated with the sites to the cells. * * @param geomFact a geometry factory * @return a GeometryCollection of Polygons */ public Geometry getVoronoiDiagram(GeometryFactory geomFact) { List vorCells = getVoronoiCellPolygons(geomFact); return geomFact.createGeometryCollection(GeometryFactory.toGeometryArray(vorCells)); }
private GeometryCollection clean(GeometryCollection g) { List geoms = new ArrayList(); for (int i = 0; i < g.getNumGeometries(); i++) { Geometry geom = g.getGeometryN(i); geoms.add(clean(geom)); } return fact.createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); }
/** * Reads one or more WKT geometries from a string. * * @param wkt * @param geomFact * @return the geometry read * @throws ParseException * @throws IOException */ public static Geometry readWKTString(String wkt, GeometryFactory geomFact) throws ParseException, IOException { WKTReader reader = new WKTReader(geomFact); WKTFileReader fileReader = new WKTFileReader(new StringReader(wkt), reader); List geomList = fileReader.read(); if (geomList.size() == 1) return (Geometry) geomList.get(0); return geomFact.createGeometryCollection(GeometryFactory.toGeometryArray(geomList)); }
public static Geometry toGeometryCollection(Geometry g, Geometry g2) { List atomicGeoms = new ArrayList(); if (g != null) addComponents(g, atomicGeoms); if (g2 != null) addComponents(g2, atomicGeoms); return g.getFactory().createGeometryCollection( GeometryFactory.toGeometryArray(atomicGeoms)); }
/** * Removes duplicated coordinates within a GeometryCollection * * @param g * @return */ public static GeometryCollection removeCoordinates(GeometryCollection g) { ArrayList<Geometry> geoms = new ArrayList<Geometry>(); for (int i = 0; i < g.getNumGeometries(); i++) { Geometry geom = g.getGeometryN(i); geoms.add(removeCoordinates(geom)); } return FACTORY.createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); } }
GeometryCollection toGeometryCollection(Collection geoms) { return geomFactory.createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); }
/** * Removes duplicated coordinates within a GeometryCollection * * @param geometryCollection * @param tolerance to delete the coordinates * @return * @throws java.sql.SQLException */ public static GeometryCollection removeDuplicateCoordinates(GeometryCollection geometryCollection, double tolerance) throws SQLException { ArrayList<Geometry> geoms = new ArrayList<>(); for (int i = 0; i < geometryCollection.getNumGeometries(); i++) { Geometry geom = geometryCollection.getGeometryN(i); geoms.add(removeDuplicateCoordinates(geom, tolerance)); } return FACTORY.createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); } }
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); }
public GeometryCollection map(GeometryCollection gc) { List mapped = new ArrayList(); for (int i = 0; i < gc.getNumGeometries(); i++) { Geometry g = mapOp.map(gc.getGeometryN(i)); if (!g.isEmpty()) mapped.add(g); } return gc.getFactory().createGeometryCollection( GeometryFactory.toGeometryArray(mapped)); } }
private Geometry extractComponents(Geometry parentGeom, Geometry aoi) { ComponentLocater locater = new ComponentLocater(parentGeom); List locs = locater.getComponents(aoi); List geoms = extractLocationGeometry(locs); if (geoms.size() <= 0) return null; if (geoms.size() == 1) return (Geometry) geoms.get(0); // if parent was a GC, ensure returning a GC if (parentGeom.getGeometryType().equals("GeometryCollection")) return parentGeom.getFactory().createGeometryCollection(GeometryFactory.toGeometryArray(geoms)); // otherwise return MultiGeom return parentGeom.getFactory().buildGeometry(geoms); }
/** * Gets a geometry representing the polygons formed by the polygonization. * If a valid polygonal geometry was extracted the result is a {@link Polygonal} geometry. * * @return a geometry containing the polygons */ public Geometry getGeometry() { if (geomFactory == null) geomFactory = new GeometryFactory(); polygonize(); if (extractOnlyPolygonal) { return geomFactory.buildGeometry(polyList); } // result may not be valid Polygonal, so return as a GeometryCollection return geomFactory.createGeometryCollection(GeometryFactory.toGeometryArray(polyList)); }
private static Geometry clipGeometryCollection(Geometry geom, Envelope clipEnv) { Geometry clipPoly = geom.getFactory().toGeometry(clipEnv); List clipped = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry g = geom.getGeometryN(i); Geometry result = null; // don't clip unless necessary if (clipEnv.contains(g.getEnvelopeInternal())) result = g; else if (clipEnv.intersects(g.getEnvelopeInternal())) { result = clipPoly.intersection(g); // keep vertex key info result.setUserData(g.getUserData()); } if (result != null && ! result.isEmpty()) { clipped.add(result); } } return geom.getFactory().createGeometryCollection(GeometryFactory.toGeometryArray(clipped)); } }