if (partCount == 0) { if (multitype) { return GEOMETRY_FACTORY.createMultiPolygon(); return GEOMETRY_FACTORY.createMultiPolygon(polygons.toArray(new Polygon[0]));
return geometryFactory.createMultiPolygon(isolinePolygons.toArray(new Polygon[isolinePolygons.size()]));
/** * Crops the coverage to the specified bounds * * @param coverage * @param bounds */ public static GridCoverage2D crop(final GridCoverage2D coverage, final Envelope bounds) { // checks final ReferencedEnvelope cropBounds = new ReferencedEnvelope(bounds); final ReferencedEnvelope coverageBounds = new ReferencedEnvelope(coverage.getEnvelope()); if (cropBounds.contains((org.locationtech.jts.geom.Envelope) coverageBounds)) { return coverage; } Polygon polygon = JTS.toGeometry(cropBounds); Geometry roi = polygon.getFactory().createMultiPolygon(new Polygon[] {polygon}); // perform the crops final ParameterValueGroup param = PROCESSOR.getOperation("CoverageCrop").getParameters(); param.parameter("Source").setValue(coverage); param.parameter("Envelope").setValue(bounds); param.parameter("ROI").setValue(roi); return (GridCoverage2D) PROCESSOR.doOperation(param); }
/** * Creates a MultiPolygon from a set of Polygons. * * @param polys the component polygons * @return A MultiPolygon */ public MultiPolygon multiPolygon(Polygon... polys) { return geomFact.createMultiPolygon(polys); }
geomFactory.createMultiPolygon( accum.toArray(new Polygon[accum.size()]));
@Override protected Geometry getEmpty() { if (EMPTY == null) { EMPTY = new GeometryFactory().createMultiPolygon(null); } return EMPTY; }
private MultiPolygon createMulti(LinearRing single, List holes) { return geometryFactory.createMultiPolygon( new Polygon[] { geometryFactory.createPolygon( single, (LinearRing[]) holes.toArray(new LinearRing[holes.size()])) }); }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { List polys = node.getChildValues(Polygon.class); return gFactory.createMultiPolygon((Polygon[]) polys.toArray(new Polygon[polys.size()])); }
public MultiPolygon toMultiPolygon(List<?> list) { List<Polygon> polys = new ArrayList<Polygon>(); for (Object o : list) { polys.add(toPolygon((List<?>) o)); } return geometryFactory.createMultiPolygon(polys.toArray(new Polygon[polys.size()])); }
@Override public Geometry getGeometry() { if (parts.length > 0) { parts[parts.length - 1] = polygonFactory.getGeometry(); } MultiPolygon mp = gf.createMultiPolygon(parts); return mp; }
private Geometry toPolygon(GeometryFactory gf, final List<Polygon> polygons) { if (polygons.size() == 0) { return gf.createGeometryCollection(null); } else if (polygons.size() == 1) { return polygons.get(0); } else { return gf.createMultiPolygon( (Polygon[]) polygons.toArray(new Polygon[polygons.size()])); } }
@Override public MultiPolygon createMultiPolygon(Polygon[] polygons) { if (polygons != null && polygons.length == 1) { return new SinglePolygonCollection(polygons, this); } else { return super.createMultiPolygon(polygons); } }
@Override public Shape build() { return makeShape(geometryFactory.createMultiPolygon(geoms.toArray(new Polygon[geoms.size()]))); } }
/** * Build a {@link MultiPolygon} using the polygon node made in previous steps of the parsing * process. */ @Override public Geometry build(int polygonNode) throws CQLException { List<Geometry> polygonList = popGeometry(polygonNode); Polygon[] polygons = polygonList.toArray(new Polygon[polygonList.size()]); MultiPolygon multiPolygon = getGeometryFactory().createMultiPolygon(polygons); return multiPolygon; } }
@Override public Object parse(ElementInstance instance, Node node, Object value) throws Exception { Polygon polygon = (Polygon) node.getChildValue(Polygon.class); MultiPolygon surface = (MultiPolygon) node.getChildValue(MultiPolygon.class); if (polygon != null) { return gf.createMultiPolygon(new Polygon[] {polygon}); } else { return surface; } }
private Geometry decodeMultiPolygon(int shapeIndex) { Collection<Geometry> polygons = new ArrayList<Geometry>(); for (int i = shapeIndex; i < binary.getShapes().length; i++) { if (binary.getShape(i).getParentOffset() == shapeIndex) { polygons.add(decodePolygon(i)); } } return gf.createMultiPolygon(polygons.toArray(new Polygon[polygons.size()])); }
public MultiPolygon createMultiPolygon(Polygon[] polygons) { if (containsCurves(polygons)) { return new MultiSurface(polygons, this, tolerance); } return delegate.createMultiPolygon(polygons); }
private static Geometry smoothMultiPolygon( GeometryFactory factory, GeometrySmoother smoother, Geometry geom, double fit) { final int N = geom.getNumGeometries(); Polygon[] smoothed = new Polygon[N]; for (int i = 0; i < N; i++) { smoothed[i] = smoother.smooth((Polygon) geom.getGeometryN(i), fit); } return factory.createMultiPolygon(smoothed); }
private MultiPolygon readMultiPolygon() throws IOException, ParseException { int numGeom = dis.readInt(); Polygon[] geoms = new Polygon[numGeom]; for (int i = 0; i < numGeom; i++) { Geometry g = readGeometry(); if (!(g instanceof Polygon)) throw new ParseException(INVALID_GEOM_TYPE_MSG + "MultiPolygon"); geoms[i] = (Polygon) g; } return factory.createMultiPolygon(geoms); }
private GeometryCollection wrap(Geometry geometry) { if (geometry instanceof Point) { return geometry.getFactory().createMultiPoint(new Point[] {(Point) geometry}); } else if (geometry instanceof LineString) { return geometry.getFactory() .createMultiLineString(new LineString[] {(LineString) geometry}); } else if (geometry instanceof Polygon) { return geometry.getFactory().createMultiPolygon(new Polygon[] {(Polygon) geometry}); } throw new IllegalArgumentException("Unable to create multi geometry from " + geometry); } }