Refine search
private void checkValid(MultiPolygon g) for (int i = 0; i < g.getNumGeometries(); i++) { Polygon p = (Polygon) g.getGeometryN(i); checkInvalidCoordinates(p); if (validErr != null) return; if (validErr != null) return; for (int i = 0; i < g.getNumGeometries(); i++) { Polygon p = (Polygon) g.getGeometryN(i); checkHolesInShell(p, graph); if (validErr != null) return; for (int i = 0; i < g.getNumGeometries(); i++) { Polygon p = (Polygon) g.getGeometryN(i); checkHolesNotNested(p, graph); if (validErr != null) return;
/** * Computes the boundary of this geometry * * @return a lineal geometry (which may be empty) * @see Geometry#getBoundary */ public Geometry getBoundary() { if (isEmpty()) { return getFactory().createMultiLineString(null); } ArrayList allRings = new ArrayList(); for (int i = 0; i < geometries.length; i++) { Polygon polygon = (Polygon) geometries[i]; Geometry rings = polygon.getBoundary(); for (int j = 0; j < rings.getNumGeometries(); j++) { allRings.add(rings.getGeometryN(j)); } } LineString[] allRingsArray = new LineString[allRings.size()]; return getFactory().createMultiLineString((LineString[]) allRings.toArray(allRingsArray)); }
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); }
/** * Tests that no element polygon is wholly in the interior of another element polygon. * <p> * Preconditions: * <ul> * <li>shells do not partially overlap * <li>shells do not touch along an edge * <li>no duplicate rings exist * </ul> * This routine relies on the fact that while polygon shells may touch at one or * more vertices, they cannot touch at ALL vertices. */ private void checkShellsNotNested(MultiPolygon mp, GeometryGraph graph) { for (int i = 0; i < mp.getNumGeometries(); i++) { Polygon p = (Polygon) mp.getGeometryN(i); LinearRing shell = (LinearRing) p.getExteriorRing(); for (int j = 0; j < mp.getNumGeometries(); j++) { if (i == j) continue; Polygon p2 = (Polygon) mp.getGeometryN(j); checkShellNotNested(shell, p2, graph); if (validErr != null) return; } } }
} else if (geom instanceof MultiPoint) { return geometryFactory.createMultiPoint(invertCoordinates(geom .getCoordinates())); } else if (geom instanceof MultiLineString) { MultiLineString multiLineString = (MultiLineString) geom; } else if (geom instanceof MultiPolygon) { MultiPolygon multiPolygon = (MultiPolygon) geom; Polygon[] inverted = new Polygon[multiPolygon.getNumGeometries()]; for (int count = 0; count < multiPolygon.getNumGeometries(); count++) { inverted[count] = (Polygon) invertGeometryCoordinates(multiPolygon .getGeometryN(count)); return geometryFactory.createMultiPolygon(inverted); + geom.getGeometryType());
multi = (MultiPolygon) geometry; } else { multi = geometryFactory.createMultiPolygon(new Polygon[] { (Polygon) geometry }); Envelope box = multi.getEnvelopeInternal(); buffer.putDouble(box.getMinX()); buffer.putDouble(box.getMinY()); for (int t = 0; t < multi.getNumGeometries(); t++) { Polygon p; p = (Polygon) multi.getGeometryN(t); nrings = nrings + 1 + p.getNumInteriorRing(); int[] pointsPerRing = new int[nrings]; for (int t = 0; t < multi.getNumGeometries(); t++) { Polygon p; p = (Polygon) multi.getGeometryN(t); pointsPerRing[u] = p.getExteriorRing().getNumPoints(); u++; int npoints = multi.getNumPoints(); Coordinate[] coords = multi.getCoordinates(); double[] zExtreame = JTSUtilities.zMinMax(multi.getCoordinates());
Point[] points; if (sourceGeometry.isEmpty()) points = new Point[0]; else if(source instanceof Point) else points=new Point[] {(Point)this.convert(source,Point.class)}; destGeometry = gFac.createMultiPoint(points); if (sourceGeometry.isEmpty()) lineStrings = new LineString[0]; else if(source instanceof LineString) else lineStrings=new LineString[] {(LineString)this.convert(source,LineString.class)}; destGeometry = gFac.createMultiLineString(lineStrings); if (sourceGeometry.isEmpty()) polygons = new Polygon[0]; else if(source instanceof Polygon) destGeometry = gFac.createLineString(new Coordinate[0]); else if(source instanceof MultiPolygon && sourceGeometry.getNumGeometries()==1) destGeometry = (Geometry) ((MultiPolygon)source).getGeometryN(0).clone(); else { if(LOGGER.isLoggable(Level.FINE))
multi = (MultiPolygon) geometry; } else { multi = geometryFactory.createMultiPolygon(new Polygon[] { (Polygon) geometry }); for (int t = 0; t < multi.getNumGeometries(); t++) { Polygon p; p = (Polygon) multi.getGeometryN(t); nrings = nrings + 1 + p.getNumInteriorRing(); int npoints = multi.getNumPoints(); int length;
/** * * * Coordinates of a MultiPolygon are an array of Polygon coordinate arrays: * * { "type": "MultiPolygon", "coordinates": [ [[[102.0, 2.0], [103.0, 2.0], * [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]]], [[[100.0, 0.0], [101.0, 0.0], * [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]], [[100.2, 0.2], [100.8, 0.2], * [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]] ] } * * @param geom * @param gen * @throws IOException */ private void write(MultiPolygon geom, JsonGenerator gen) throws IOException { gen.writeStringField("type", "MultiPolygon"); gen.writeFieldName("coordinates"); gen.writeStartArray(); for (int i = 0; i < geom.getNumGeometries(); ++i) { Polygon p = (Polygon) geom.getGeometryN(i); gen.writeStartArray(); writeCoordinates(p.getExteriorRing().getCoordinates(), gen); for (int j = 0; j < p.getNumInteriorRing(); ++j) { writeCoordinates(p.getInteriorRingN(j).getCoordinates(), gen); } gen.writeEndArray(); } gen.writeEndArray(); }
protected static Geometry transformMultiPolygon(CoordinateTransform ct, MultiPolygon multiPolygon) { Polygon[] polygon = new Polygon[multiPolygon.getNumGeometries()]; for (int i = 0; i < polygon.length; ++i) { polygon[i] = multiPolygon.getFactory() .createPolygon(transformCoordinates(ct, multiPolygon.getGeometryN(i).getCoordinates())); } return multiPolygon.getFactory().createMultiPolygon(polygon); }
/** * Create a new multiPolygon without hole. * * @param multiPolygon * @return */ public static MultiPolygon removeHolesMultiPolygon(MultiPolygon multiPolygon) { int num = multiPolygon.getNumGeometries(); Polygon[] polygons = new Polygon[num]; for (int i = 0; i < num; i++) { polygons[i] = removeHolesPolygon((Polygon) multiPolygon.getGeometryN(i)); } return multiPolygon.getFactory().createMultiPolygon(polygons); }
public static MultiPolygon tessellate(Geometry geometry) throws IllegalArgumentException { if(geometry == null) { return null; } if(geometry instanceof Polygon) { return tessellatePolygon((Polygon) geometry); } else if (geometry instanceof MultiPolygon) { ArrayList<Polygon> polygons = new ArrayList<Polygon>(geometry.getNumGeometries() * 2); for(int idPoly = 0; idPoly < geometry.getNumGeometries(); idPoly++) { MultiPolygon triangles = tessellatePolygon((Polygon)geometry.getGeometryN(idPoly)); polygons.ensureCapacity(triangles.getNumGeometries()); for(int idTri=0; idTri < triangles.getNumGeometries(); idTri++) { polygons.add((Polygon)triangles.getGeometryN(idTri)); } } return geometry.getFactory().createMultiPolygon(polygons.toArray(new Polygon[polygons.size()])); } else { throw new IllegalArgumentException("ST_Tessellate accept only Polygon and MultiPolygon types not instance" + " of "+geometry.getClass().getSimpleName()); } } }
GeometryFactory factory = g.getFactory(); transformed = factory.createMultiPoint(points); } else if (g instanceof LineString) { transformed = transformLineString((LineString) g, factory); transformed = factory.createMultiLineString(lines); } else if (g instanceof Polygon) { transformed = transformPolygon((Polygon) g, factory); } else if (g instanceof MultiPolygon) { MultiPolygon mp = (MultiPolygon) g; Polygon[] polygons = new Polygon[mp.getNumGeometries()]; polygons[i] = transformPolygon((Polygon) mp.getGeometryN(i), factory); transformed = factory.createMultiPolygon(polygons); } else if (g instanceof GeometryCollection) { GeometryCollection gc = (GeometryCollection) g; transformed.setUserData(g.getUserData()); if ((g.getUserData() == null) || g.getUserData() instanceof CoordinateReferenceSystem) {
/** * Removes duplicated coordinates within a MultiPolygon. * @param g * @return */ public static MultiPolygon removeDuplicateCoordinates(MultiPolygon g) { ArrayList<Polygon> polys = new ArrayList<Polygon>(); for (int i = 0; i < g.getNumGeometries(); i++) { Polygon poly = (Polygon) g.getGeometryN(i); polys.add(removeDuplicateCoordinates(poly)); } return FACTORY.createMultiPolygon(GeometryFactory.toPolygonArray(polys)); }
List<Polygon> polys = new ArrayList<Polygon>(); // points that are Geometry displayGeometry = gf.toGeometry(toEnvelope(displayArea)); } else { for (int t = 0; t < g.getNumGeometries(); t++) { Polygon gg = (Polygon) g.getGeometryN(t); polys.add(gg); Envelope displayGeomEnv = displayGeometry.getEnvelopeInternal(); for (Polygon p : polys) { MultiPolygon pp = clipPolygon(p, (Polygon) displayGeometry, displayGeomEnv); if ((pp != null) && (!(pp.isEmpty()))) { for (int t = 0; t < pp.getNumGeometries(); t++) clippedPolys.add((Polygon) pp.getGeometryN(t)); for (int t = 0; t < clippedPolys.size(); t++) { cpoly = (Polygon) clippedPolys.get(t); final double area = cpoly.getArea(); if (area > maxSize) { maxPoly = cpoly;
@Override public Iterator<Polygon> call(Geometry spatialObject) throws Exception { List<Polygon> result = new ArrayList<Polygon>(); if (spatialObject instanceof MultiPolygon) { MultiPolygon multiObjects = (MultiPolygon) spatialObject; for (int i = 0; i < multiObjects.getNumGeometries(); i++) { Polygon oneObject = (Polygon) multiObjects.getGeometryN(i); oneObject.setUserData(multiObjects.getUserData()); result.add(oneObject); } } else if (spatialObject instanceof Polygon) { result.add((Polygon) spatialObject); } else { throw new Exception("[ShapefileRDD][getPolygonRDD] the object type is not Polygon or MultiPolygon type. It is " + spatialObject.getGeometryType()); } return result.iterator(); } }));
/** Like makeGoodShapePolygon, but applied towards a multipolygon. * @param mp The MultiPolygon to "niceify". * @return The "nicified" MultiPolygon. */ public static MultiPolygon makeGoodShapeMultiPolygon(MultiPolygon mp) { MultiPolygon result; Polygon[] ps = new Polygon[mp.getNumGeometries()]; //check each sub-polygon for (int t = 0; t < mp.getNumGeometries(); t++) { ps[t] = makeGoodShapePolygon((Polygon) mp.getGeometryN(t)); } result = FACTORY.createMultiPolygon(ps); return result; }
/** * Returns the effective centroid of the geometry. * This is (currently) the centroid of the largest polygon. * @param g * @return */ public static Point getCenter(Geometry g) { if (g instanceof Point) { return (Point)g; } Geometry largest = g; if (largest instanceof MultiPolygon) { double largestArea = -1; MultiPolygon mp = (MultiPolygon)g; for (int i = 0; i < mp.getNumGeometries(); i++) { Geometry g2 = mp.getGeometryN(i); double area = g2.getArea(); if (area > largestArea) { largestArea = area; largest = g2; } } } return largest.getCentroid(); }
@Override public void run() { List<Geometry> region; while ((region = queue.poll()) != null) { List<Polygon> unionFactory = new ArrayList<Polygon>(region.size()); for (Geometry polygon : region) { unionFactory.add((Polygon) polygon); } Geometry union = factory.buildGeometry(unionFactory).buffer(0); if (union instanceof MultiPolygon) { MultiPolygon multiPolygon = (MultiPolygon) union; for (int geometryIndex = 0; geometryIndex < multiPolygon.getNumGeometries(); geometryIndex++) { Geometry geometry = multiPolygon.getGeometryN(geometryIndex); if (geometry instanceof Polygon) { unions.add((Polygon) geometry); } else { throw new RuntimeException("Not implemented! " + union.getClass().getName()); } } } else if (union instanceof Polygon) { unions.add((Polygon) union); } else { throw new RuntimeException("Not implemented! " + union.getClass().getName()); } } } });
private static MultiPolygon dropOverlaps(MultiPolygon outer, IsValidOp validOptions) { Geometry result = null; for(int i=0; i < outer.getNumGeometries(); i++) { Geometry geometryN = outer.getGeometryN(i); if(i == 0) { result = geometryN; } else { result = result.union(geometryN); } } if(result instanceof MultiPolygon) { return (MultiPolygon) result; } if(result instanceof Polygon) { return geometryFactory.createMultiPolygon(new Polygon[]{(Polygon)result}); } return null; }