public void findHull() { LOG.info("finding hull of graph..."); LOG.debug("using only stops? {}", useOnlyStops); if (bufferMeters < prototypeRoutingRequest.maxWalkDistance) LOG.warn("geographic filter buffer is smaller than max walk distance, this will probably yield incorrect results."); Graph graph= graphService.getRouter(prototypeRoutingRequest.routerId).graph; List<Geometry> geometries = new ArrayList<Geometry>(); for (Vertex v : graph.getVertices()) { if (useOnlyStops && ! (v instanceof TransitStop)) continue; Point pt = gf.createPoint(v.getCoordinate()); Geometry geom = crudeProjectedBuffer(pt, bufferMeters); geometries.add(geom); } Geometry multiGeom = gf.buildGeometry(geometries); LOG.info("unioning hull..."); hull = multiGeom.union(); LOG.trace("hull is {}", hull.toText()); // may lead to false rejections // DouglasPeuckerSimplifier simplifier = new DouglasPeuckerSimplifier(); }
for (Integer threshold : bufferLists.keys()) { Collection<Geometry> buffers = bufferLists.get(threshold); Geometry geom = geomf.buildGeometry(buffers); // make geometry collection
public Geometry getGeometry() { // end last line in case it was not done by user endLine(); return geomFact.buildGeometry(lines); } }
private static Geometry convertSegStrings(Iterator it) { GeometryFactory fact = new GeometryFactory(); List lines = new ArrayList(); while (it.hasNext()) { SegmentString ss = (SegmentString) it.next(); LineString line = fact.createLineString(ss.getCoordinates()); lines.add(line); } return fact.buildGeometry(lines); }
private Geometry extractElements(Geometry geom, boolean[] interacts, boolean isInteracting) { List extractedGeoms = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry elem = geom.getGeometryN(i); if (interacts[i] == isInteracting) extractedGeoms.add(elem); } return geomFactory.buildGeometry(extractedGeoms); }
private Geometry bufferUnion(List geoms) { GeometryFactory factory = ((Geometry) geoms.get(0)).getFactory(); Geometry gColl = factory.buildGeometry(geoms); Geometry unionAll = gColl.buffer(0.0); return unionAll; }
private Geometry getPolygonLines(Geometry g) { List lines = new ArrayList(); LinearComponentExtracter lineExtracter = new LinearComponentExtracter(lines); List polys = PolygonExtracter.getPolygons(g); for (Iterator i = polys.iterator(); i.hasNext(); ) { Polygon poly = (Polygon) i.next(); poly.apply(lineExtracter); } return g.getFactory().buildGeometry(lines); }
/** * Computes the combination of the input geometries * to produce the most appropriate {@link Geometry} or {@link GeometryCollection} * * @return a Geometry which is the combination of the inputs */ public Geometry combine() { List elems = new ArrayList(); for (Iterator i = inputGeoms.iterator(); i.hasNext(); ) { Geometry g = (Geometry) i.next(); extractElements(g, elems); } if (elems.size() == 0) { if (geomFactory != null) { // return an empty GC return geomFactory.createGeometryCollection(null); } return null; } // return the "simplest possible" geometry return geomFactory.buildGeometry(elems); }
private Geometry computeGeometry( List resultPointList, List resultLineList, List resultPolyList, int opcode) { List geomList = new ArrayList(); // element geometries of the result are always in the order P,L,A geomList.addAll(resultPointList); geomList.addAll(resultLineList); geomList.addAll(resultPolyList); //* if (geomList.isEmpty()) return createEmptyResult(opcode, arg[0].getGeometry(), arg[1].getGeometry(), geomFact); //*/ // build the most specific geometry possible return geomFact.buildGeometry(geomList); }
private Geometry extractByEnvelope(Envelope env, Geometry geom, List disjointGeoms) { List intersectingGeoms = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry elem = geom.getGeometryN(i); if (elem.getEnvelopeInternal().intersects(env)) intersectingGeoms.add(elem); else disjointGeoms.add(elem); } return geomFactory.buildGeometry(intersectingGeoms); }
protected Geometry transformMultiPoint(MultiPoint geom, Geometry parent) { List transGeomList = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry transformGeom = transformPoint((Point) geom.getGeometryN(i), geom); if (transformGeom == null) continue; if (transformGeom.isEmpty()) continue; transGeomList.add(transformGeom); } return factory.buildGeometry(transGeomList); }
protected Geometry transformMultiLineString(MultiLineString geom, Geometry parent) { List transGeomList = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry transformGeom = transformLineString((LineString) geom.getGeometryN(i), geom); if (transformGeom == null) continue; if (transformGeom.isEmpty()) continue; transGeomList.add(transformGeom); } return factory.buildGeometry(transGeomList); }
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); }
/** * Builds a geometry ({@link LineString} or {@link MultiLineString} ) * representing the sequence. * * @param sequences a List of Lists of DirectedEdges with * LineMergeEdges as their parent edges. * @return the sequenced geometry, or <code>null</code> if no sequence exists */ private Geometry buildSequencedGeometry(List sequences) { List lines = new ArrayList(); for (Iterator i1 = sequences.iterator(); i1.hasNext(); ) { List seq = (List) i1.next(); for (Iterator i2 = seq.iterator(); i2.hasNext(); ) { DirectedEdge de = (DirectedEdge) i2.next(); LineMergeEdge e = (LineMergeEdge) de.getEdge(); LineString line = e.getLine(); LineString lineToAdd = line; if (! de.getEdgeDirection() && ! line.isClosed()) lineToAdd = reverse(line); lines.add(lineToAdd); } } if (lines.size() == 0) return factory.createMultiLineString(new LineString[0]); return factory.buildGeometry(lines); }
polys.add(geometryFactory.createPolygon(shell, holeArray)); return geometryFactory.buildGeometry(polys);
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); }
/** * Maps the members of a {@link Geometry} * (which may be atomic or composite) * into another <tt>Geometry</tt> of most specific type. * <tt>null</tt> results are skipped. * In the case of hierarchical {@link GeometryCollection}s, * only the first level of members are mapped. * * @param geom the input atomic or composite geometry * @param op the mapping operation * @return a result collection or geometry of most specific type */ public static Geometry map(Geometry geom, MapOp op) { List mapped = new ArrayList(); for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry g = op.map(geom.getGeometryN(i)); if (g != null) mapped.add(g); } return geom.getFactory().buildGeometry(mapped); }
if (shell != null) components.add(shell); components.addAll(holes); return factory.buildGeometry(components);
/** * Converts text rendered in the given {@link Font} to a {@link Geometry} * * @param text the text to render * @param font the font to render with * @param flatness the flatness to use * @param geomFact the geometryFactory to use to create the result * @return a polygonal geometry representing the rendered text */ public static Geometry read(String text, Font font, double flatness, GeometryFactory geomFact) { char[] chs = text.toCharArray(); FontRenderContext fontContext = new FontRenderContext(null, false, true); GlyphVector gv = font.createGlyphVector(fontContext, chs); List polys = new ArrayList(); for (int i = 0; i < gv.getNumGlyphs(); i++) { Geometry geom = ShapeReader.read(gv.getGlyphOutline(i), flatness, geomFact); for (int j = 0; j < geom.getNumGeometries(); j++) { polys.add(geom.getGeometryN(j)); } } return geomFact.buildGeometry(polys); }
Geometry resultGeom = geomFact.buildGeometry(resultPolyList); return resultGeom;