/** * Writes any geometry object. This class figures out which geometry representation to write and * calls subclasses to actually write the object. * * @param geometry The geometry to be encoded * @return The JSONBuilder with the new geometry * @throws JSONException If anything goes wrong */ public JSONBuilder writeGeom(Geometry geometry) throws JSONException { this.object(); this.key("type"); this.value(getGeometryName(geometry)); final int geometryType = getGeometryType(geometry); if (geometryType != MULTIGEOMETRY) { this.key("coordinates"); switch (geometryType) { case POINT: Point point = (Point) geometry; Coordinate c = point.getCoordinate(); writeCoordinate(c.x, c.y, c.z); break; case LINESTRING: writeCoordinates(((LineString) geometry).getCoordinateSequence()); break; case MULTIPOINT: writeCoordinates(geometry.getCoordinates()); break; case POLYGON: writePolygon((Polygon) geometry); break; case MULTILINESTRING: this.array(); for (int i = 0, n = geometry.getNumGeometries(); i < n; i++) { writeCoordinates(((LineString) geometry.getGeometryN(i)).getCoordinateSequence()); } this.endArray(); break; case MULTIPOLYGON: this.array(); for (int i = 0, n = geometry.getNumGeometries(); i < n; i++) { writePolygon((Polygon) geometry.getGeometryN(i)); } this.endArray(); break; } } else { writeGeomCollection((GeometryCollection) geometry); } return this.endObject(); }
private static boolean collectionToMultiPoint( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (geom instanceof GeometryCollection && MultiPoint.class == targetType) { Point[] points = new Point[geom.getNumGeometries()]; for (int i = 0; i < geom.getNumGeometries(); i++) { points[i] = geom.getGeometryN(i).getCentroid(); } result.add(geomBuilder.factory.createMultiPoint(points)); return true; } return false; }
/** * converts the collection of holes (LineString) to a List of String * * @param holeGeometries * @return List of holes as LineString */ private List<LineString> convertHolesGeometriesToHoleList(final Geometry holeGeometries) { assert holeGeometries != null; List<LineString> holeList = new ArrayList<LineString>(holeGeometries.getNumGeometries()); for (int i = 0; i < holeGeometries.getNumGeometries(); i++) { LineString hole = (LineString) holeGeometries.getGeometryN(i); holeList.add(hole); } return holeList; }
/** * split intersection segments have interior location at both left and right * * @param utilSplitLine * @param polygon * @param holesList */ private void addSplitLineIntoGraph( final Geometry utilSplitLine, final Polygon polygon, List<LineString> holesList) { // split intersection segments have interior location at both left // and right Geometry intersectingLineStrings = utilSplitLine.intersection(polygon); if (intersectingLineStrings.getNumGeometries() > 1) { // If points exist, then remove them. intersectingLineStrings = filterLineString(intersectingLineStrings); } // use the same input used to create hole edges Geometry holeCollection = intersectingLineStrings .getFactory() .createMultiLineString(holesList.toArray(new LineString[holesList.size()])); Geometry holeGeometries = holeCollection.difference(utilSplitLine); insertEdge( intersectingLineStrings, holeGeometries, Location.BOUNDARY, Location.INTERIOR, Location.INTERIOR); }
private static boolean collectionToMultiLine( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (!(geom instanceof Polygon) && !(geom instanceof MultiPolygon) && (geom instanceof GeometryCollection) && MultiLineString.class == targetType) { LineString[] geoms = new LineString[geom.getNumGeometries()]; for (int i = 0; i < geom.getNumGeometries(); i++) { geoms[i] = geomBuilder.safeCreateGeometry(LineString.class, geom.getGeometryN(i).getCoordinates()); } result.add(geomBuilder.factory.createMultiLineString(geoms)); return true; } return false; }
/** * Each edge will be built with 2 coordinates. * * @param intersectingLineStrings The geometry which edges will be based on. * @param onLoc position for ON. * @param leftLoc position for LEFT. * @param rightLoc position for RIGHT. */ private void insertEdge( final Geometry intersectingLineStrings, final Geometry holeGeometries, final int onLoc, final int leftLoc, final int rightLoc) { for (int i = 0; i < intersectingLineStrings.getNumGeometries(); i++) { Geometry intersectingSegment = intersectingLineStrings.getGeometryN(i); if ((intersectingSegment.getNumPoints() == 2) && !holeGeometries.isEmpty()) { // special case, when the line has 2 coordinates and // its orientation can't be calculated because it hasn't. intersectingSegment = adjustSegmentToHoleDirection(intersectingSegment, holeGeometries); } Coordinate[] coords = intersectingSegment.getCoordinates(); for (int j = 0; j < coords.length - 1; j++) { final SplitEdge edge = SplitEdge.newInstance(coords[j], coords[j + 1], onLoc, leftLoc, rightLoc); // add the list that only contains one edge because it will // create 2 directedEdge. this.graph.addEdge(edge); } } }
/** Write an Array of "full" Geometries */ private int estimateGeometryArray(Geometry container) { int result = 0; for (int i = 0; i < container.getNumGeometries(); i++) { result += estimateBytes(container.getGeometryN(i)); } return result; }
/** * Returns the nth geometry of a geometry collection, or the geometry if the input is not a * collection. * * @param node xml element containing gml object(s) * @param number integer number as the index of nth geometry * @return geometry as a gml element * @throws QueryException query exception */ @Deterministic public ANode geometryN(final ANode node, final Int number) throws QueryException { final Geometry geo = checkGeo(node); final long n = number.itr(); if (n < 1 || n > geo.getNumGeometries()) throw GeoErrors.outOfRangeIdx(number); return gmlWriter(geo.getGeometryN((int) n - 1)); }
/** * Tests whether a geometry consists of a single polygon with no holes. * * @return true if the geometry is a single polygon with no holes */ private boolean isSingleShell(Geometry geom) { // handles single-element MultiPolygons, as well as Polygons if (geom.getNumGeometries() != 1) return false; Polygon poly = (Polygon) geom.getGeometryN(0); int numHoles = poly.getNumInteriorRing(); if (numHoles == 0) return true; return false; }
private void addGeometry(Geometry geom) { if (geom.getGeometryType().equals("GeometryCollection")) { for (int i = 0; i < geom.getNumGeometries(); i++) { addGeometry(geom.getGeometryN(i)); } } else { toUnite.add(geom); } }
/** * Creates an iterator starting at a specified component and vertex in a linear {@link Geometry} * * @param linearGeom the linear geometry to iterate over * @param componentIndex the component to start at * @param vertexIndex the vertex to start at * @throws IllegalArgumentException if linearGeom is not lineal */ public LinearIterator(Geometry linearGeom, int componentIndex, int vertexIndex) { if (!(linearGeom instanceof Lineal)) throw new IllegalArgumentException("Lineal geometry is required"); this.linearGeom = linearGeom; numLines = linearGeom.getNumGeometries(); this.componentIndex = componentIndex; this.vertexIndex = vertexIndex; loadCurrentLine(); }
private String geometrySignature(Geometry geom) { if (geom == null) return ""; String sig = geom.getGeometryType(); if (geom instanceof GeometryCollection) { sig += "[" + geom.getNumGeometries() + "]"; } else { sig += "(" + geom.getNumPoints() + ")"; } return sig; }
private static boolean collectionToPoint( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (geom instanceof GeometryCollection && Point.class == targetType) { for (int i = 0; i < geom.getNumGeometries(); i++) { result.add(geom.getGeometryN(i).getCentroid()); } return true; } return false; }
public static boolean test(Point p) { if ((p.getX() >= 53.25666000000001 && p.getY() >= 12.106109999999944 && p.getX() <= 53.340828000000094 && p.getY() <= 12.134442999999976) || (p.getX() >= 53.011383000000016 && p.getY() >= 12.13305500000007 && p.getX() <= 53.11332700000008 && p.getY() <= 12.181389000000138) || (p.getX() >= 52.08305399999995 && p.getY() >= 12.144721999999945 && p.getX() <= 52.397217000000126 && p.getY() <= 12.2469440000001) || (p.getX() >= 43.39138799999994 && p.getY() >= 12.630278000000088 && p.getX() <= 43.450554000000125 && p.getY() <= 12.67388699999998) || (p.getX() >= 53.325829 && p.getY() >= 12.30805400000014 && p.getX() <= 54.47694400000007 && p.getY() <= 12.717777000000067) || (p.getX() >= 42.67527800000005 && p.getY() >= 13.660000000000082 && p.getX() <= 42.79721800000005 && p.getY() <= 13.782775999999956) || (p.getX() >= 42.68916300000012 && p.getY() >= 13.909443000000124 && p.getX() <= 42.79999500000014 && p.getY() <= 14.066944000000092) || (p.getX() >= 42.55583200000012 && p.getY() >= 15.270831999999984 && p.getX() <= 42.65972099999999 && p.getY() <= 15.458331999999984) || (p.getX() >= 42.67999300000008 && p.getY() >= 12.592776999999955 && p.getX() <= 53.114441000000056 && p.getY() <= 18.99934400000012)) { byte[] data; try { data = ByteStreams.toByteArray( Antarctica.class.getClassLoader().getResourceAsStream("com/country/Yemen.data")); } catch (IOException e) { throw new RuntimeException(e); } Geometry geo = Util.convert(data); for (int i = 0; i < geo.getNumGeometries(); i++) { if (geo.getGeometryN(i).contains(p)) { return true; } } } return false; }
private static boolean multiPolygonToPolygon( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (geom instanceof MultiPolygon && Polygon.class == targetType) { for (int j = 0; j < geom.getNumGeometries(); j++) { result.add(geom.getGeometryN(j)); } return true; } return false; }
public boolean acceptGeometry(Geometry geom) { if (geom.getGeometryType().equals("GeometryCollection")) { for (int i = 0; i < geom.getNumGeometries(); i++) { if (acceptGeometry(geom.getGeometryN(i))) { return true; } } return false; } else { return willDrawSimpleGeometry(geom); } }
private static boolean multiPolygonToLine( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (geom instanceof MultiPolygon && LineString.class == targetType) { for (int i = 0; i < geom.getNumGeometries(); i++) { if (!polygonToLine(geom.getGeometryN(i), targetType, result)) throw new RuntimeException( "Huh? multi polygons should only have polygons in them"); //$NON-NLS-1$ } return true; } return false; }
private MapDisplayer calculateMapBoundingBox() throws TransformException { /* Identify extreme values for the X and Y dimensions * among the Geometries in our featureCollection. * Note that this is *after* Geometry preparation (cropping and projecting). */ double dataMinX = Double.POSITIVE_INFINITY; double dataMinY = Double.POSITIVE_INFINITY; double dataMaxX = Double.NEGATIVE_INFINITY; double dataMaxY = Double.NEGATIVE_INFINITY; FeatureIterator<SimpleFeature> it = featureCollection.features(); while (it.hasNext()) { SimpleFeature feature = it.next(); Geometry rawGeometry = (Geometry) feature.getDefaultGeometry(); Geometry geometry = geometryProjector.projectGeometry(rawGeometry); for (int gg = 0; gg < geometry.getNumGeometries(); gg++) { Geometry subgeometry = geometry.getGeometryN(gg); Coordinate[] coordinates = subgeometry.getCoordinates(); for (Coordinate coordinate : coordinates) { if (coordinate.x < dataMinX) { dataMinX = coordinate.x; } if (coordinate.y < dataMinY) { dataMinY = coordinate.y; } if (coordinate.x > dataMaxX) { dataMaxX = coordinate.x; } if (coordinate.y > dataMaxY) { dataMaxY = coordinate.y; } } } } // YOU MUST CLOSE THE ITERATOR! it.close(); // Exaggerate the data range a bit to provide a buffer around it in the map. double xRange = dataMaxX - dataMinX; double xBufferSize = MAP_BOUNDING_BOX_BUFFER_RATIO * xRange; double bufferedDataMinX = dataMinX - xBufferSize; double bufferedDataMaxX = dataMaxX + xBufferSize; double yRange = dataMaxY - dataMinY; double yBufferSize = MAP_BOUNDING_BOX_BUFFER_RATIO * yRange; double bufferedDataMinY = dataMinY - yBufferSize; double bufferedDataMaxY = dataMaxY + yBufferSize; return new MapDisplayer(bufferedDataMinX, bufferedDataMinY, bufferedDataMaxX, bufferedDataMaxY); }
static Geometry densify(Geometry geom, CoordinateReferenceSystem crs, double maxAreaError) throws FactoryException, TransformException { // basic checks if (maxAreaError <= 0) { throw new IllegalArgumentException("maxAreaError must be greater than 0"); } if (!(geom instanceof Polygon) && !(geom instanceof MultiPolygon)) { throw new IllegalArgumentException("Geom must be poligonal"); } if (crs == null) { throw new IllegalArgumentException("CRS cannot be set to null"); } double previousArea = 0.0; CoordinateReferenceSystem targetCRS = CRS.parseWKT(ECKERT_IV_WKT); MathTransform firstTransform = CRS.findMathTransform(crs, targetCRS); GeometryFactory geomFactory = new GeometryFactory(); int ngeom = geom.getNumGeometries(); Geometry densifiedGeometry = geom; double areaError = 1.0d; int maxIterate = 0; do { double max = 0; maxIterate++; // check the maximum side length of the densifiedGeometry for (int j = 0; j < ngeom; j++) { Geometry geometry = densifiedGeometry.getGeometryN(j); Coordinate[] coordinates = geometry.getCoordinates(); int n = coordinates.length; for (int i = 0; i < (n - 1); i++) { Coordinate[] coords = new Coordinate[2]; coords[0] = coordinates[i]; coords[1] = coordinates[i + 1]; LineString lineString = geomFactory.createLineString(coords); if (lineString.getLength() > max) max = lineString.getLength(); } } // calculate the denified geometry densifiedGeometry = Densifier.densify(densifiedGeometry, max / 2); // reproject densifiedGeometry to Eckert IV Geometry targetGeometry = JTS.transform(densifiedGeometry, firstTransform); double nextArea = targetGeometry.getArea(); // evaluate the current error areaError = Math.abs(previousArea - nextArea) / nextArea; // logger3.info("AREA ERROR"+areaError); previousArea = nextArea; // check whether the current error is greater than the maximum allowed } while (areaError > maxAreaError && maxIterate < 10); return densifiedGeometry; }
private static boolean collectionToMultiPolygon( Geometry geom, Class<? extends Geometry> targetType, Collection<Geometry> result) { if (!(geom instanceof Polygon) && geom instanceof GeometryCollection && MultiPolygon.class == targetType) { for (int i = 0; i < geom.getNumGeometries(); i++) { result.add( geomBuilder.safeCreateGeometry(targetType, geom.getGeometryN(i).getCoordinates())); } return true; } return false; }
/** * @param toSplit the line to split * @param line the line to use for the split * @return a sorted list of geometries as a result of splitting toSplit with line */ protected List<LineString> splitLine(Geometry toSplit, Geometry line) { List<LineString> output = new ArrayList(); Geometry lines = toSplit.union(line); for (int i = 0; i < lines.getNumGeometries(); i++) { LineString l = (LineString) lines.getGeometryN(i); // TODO to be tested if (toSplit.contains(l.getInteriorPoint())) { output.add(l); } } geometrySorter(output); return output; }
/** * @param poly the polygon to split * @param line the line to use for the split * @return a sorted list of geometries as a result of splitting poly with line */ protected List<Polygon> splitPolygon(Geometry poly, Geometry line) { List<Polygon> output = new ArrayList(); Geometry nodedLinework = poly.getBoundary().union(line); Geometry polys = polygonize(nodedLinework); // only keep polygons which are inside the input for (int i = 0; i < polys.getNumGeometries(); i++) { Polygon candpoly = (Polygon) polys.getGeometryN(i); if (poly.contains(candpoly.getInteriorPoint())) { output.add(candpoly); } } geometrySorter(output); return output; }
public void addOSMEdgeToSpatialIndex(OSMEdge osmEdge) { // System.out.println("added edge with ID " + osmEdge.getId()); // counter__edge.put(osmEdge.getId(), osmEdge.getGeometry()); // store edges in the hash map Geometry env = osmEdge.getGeometry().getBoundary(); // (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny). if (env.getNumGeometries() > 0) { Point p1 = (Point) env.getGeometryN(0); Point p2 = (Point) env.getGeometryN(1); si.add( new Rectangle((float) p1.getX(), (float) p1.getY(), (float) p2.getX(), (float) p2.getY()), osmEdge.getId()); } }
private void setCurrentFeature(final Feature feature) { this.feature = feature; this.geometry = null; this.subGeometries.clear(); if (feature != null) { this.geometry = helper.toObjectiveCRS(feature); if (geometry != null) { geometry.clone(); multipolygon = (geometry instanceof MultiPolygon); for (int i = 0; i < geometry.getNumGeometries(); i++) { subGeometries.add(geometry.getGeometryN(i)); } } } decoration.setGeometries(Collections.singleton(this.geometry)); }
/** * Finds the hole that intersects in two points with the the segment. * * @param splitLineSegment * @param holeGeometries * @return the hole that intersect with the segment, null in other case */ private LineString intersectionHole( final Geometry splitLineSegment, final Geometry holeGeometries) { List<LineString> holeList = convertHolesGeometriesToHoleList(holeGeometries); LineString intersectedHole = null; for (LineString hole : holeList) { // Seeks if the segment intersect with the line Geometry intersectionWithHole = splitLineSegment.intersection(hole); if (intersectionWithHole.getNumGeometries() == 2) { intersectedHole = hole; } } return intersectedHole; }
/** * Adds the geometries present in the intersection result if they are {@link LineString} into the * geometry list * * @param intersectResult * @param geometryList * @return the geometry list updated with the geometries intersection */ private List<Geometry> addLinesInCommon(Geometry intersectResult, List<Geometry> geometryList) { if (intersectResult instanceof GeometryCollection) { // get the lineString or multiLineString instances for (int i = 0; i < intersectResult.getNumGeometries(); i++) { Geometry part = intersectResult.getGeometryN(i); if (part instanceof LineString || part instanceof MultiLineString) { geometryList.add(part); } } } else if (intersectResult instanceof LineString || intersectResult instanceof MultiLineString) { geometryList.add(intersectResult); } return geometryList; }
/** * Computes the angle from the first point to the last point of a LineString or MultiLineString. * TODO: put this method into org.opentripplanner.common.geometry.DirectionUtils * * @param geometry a LineString or a MultiLineString * @return */ public synchronized double getFirstToLastSegmentAngle(Geometry geometry) { LineString line; if (geometry instanceof MultiLineString) { line = (LineString) geometry.getGeometryN(geometry.getNumGeometries() - 1); } else { assert geometry instanceof LineString; line = (LineString) geometry; } int numPoints = line.getNumPoints(); Coordinate coord0 = line.getCoordinateN(0); Coordinate coord1 = line.getCoordinateN(numPoints - 1); int i = numPoints - 3; while (distanceLibrary.fastDistance(coord0, coord1) < 10 && i >= 0) { coord1 = line.getCoordinateN(i--); } geodeticCalculator.setStartingGeographicPoint(coord0.x, coord0.y); geodeticCalculator.setDestinationGeographicPoint(coord1.x, coord1.y); return geodeticCalculator.getAzimuth() * Math.PI / 180; }
/** * Only return the lines contained on the given geometry, the non lines geometry are rejected. * * @param geometry Intersection geometry between split line and source geometry. * @return The valid geometries needed for the graph, those are lines and multiLines. */ private Geometry filterLineString(Geometry geometry) { List<Geometry> filteredLines = new ArrayList<Geometry>(); for (int i = 0; i < geometry.getNumGeometries(); i++) { Geometry possibleLine = geometry.getGeometryN(i); // if there are point geometries, discard it. if (possibleLine instanceof LineString || possibleLine instanceof MultiLineString) { // also remove very very short liens. if (possibleLine.getLength() > UsefulSplitLineBuilder.DEPRECIATE_VALUE) { filteredLines.add(possibleLine); } } } GeometryFactory gf = geometry.getFactory(); return gf.buildGeometry(filteredLines); }
@Override public void filter(Geometry gmtr) { if (MultiPolygon.class.isAssignableFrom(binding)) { if (gmtr.getArea() != 0.0d && gmtr.getGeometryType().equals("Polygon")) { collection.add(gmtr); } } if (MultiLineString.class.isAssignableFrom(binding)) { if (gmtr.getLength() != 0.0d && gmtr.getGeometryType().equals("LineString")) { collection.add(gmtr); } } if (MultiPoint.class.isAssignableFrom(binding)) { if (gmtr.getNumGeometries() > 0 && gmtr.getGeometryType().equals("Point")) { collection.add(gmtr); } } if (Point.class.isAssignableFrom(binding)) { if (gmtr.getGeometryType().equals("Point")) { collection.add(gmtr); } } }
public static boolean test(Point p) { if ((p.getX() >= 105.628998 && p.getY() >= -10.51097 && p.getX() <= 105.7519 && p.getY() <= -10.38408)) { byte[] data; try { data = ByteStreams.toByteArray( Antarctica.class .getClassLoader() .getResourceAsStream("com/country/ChristmasIsland.data")); } catch (IOException e) { throw new RuntimeException(e); } Geometry geo = Util.convert(data); for (int i = 0; i < geo.getNumGeometries(); i++) { if (geo.getGeometryN(i).contains(p)) { return true; } } } return false; }