public static void createGeom(List<Node> nodes) { StringBuilder wkt = new StringBuilder(); for (Node node : nodes) wkt.append(node.lng + " " + node.lat + ", "); wkt.delete(wkt.length() - 2, wkt.length()); wkt.insert(0, "POLYGON(("); wkt.append("))"); WKTReader wktreader = new WKTReader(); Geometry geom = null; try { geom = wktreader.read(wkt.toString()); } catch (Exception ex) { ex.printStackTrace(); } Polygon pol = (Polygon) geom; if (!pol.isValid()) { Geometry repaired = pol.buffer(0.0D); log.info("Invalid polygon detected. Is fixed? " + repaired.isValid()); wkt = new StringBuilder(repaired.toText()); } try { System.out.println(pol.contains(wktreader.read("POINT(82 25)"))); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
/** * @param dataStore * @param damageArea * @param target * @return * @throws IOException * @throws SQLException */ public static Map<Integer, Double> calculateDamageValues( JDBCDataStore dataStore, Geometry damageArea, int target) throws IOException, SQLException { String wkt = damageArea.toText(); DefaultTransaction transaction = new DefaultTransaction(); Connection conn = null; Map<Integer, Double> damageValues = new HashMap<Integer, Double>(); try { conn = dataStore.getConnection(transaction); if (FormulaUtils.isSimpleTarget(target)) { if (FormulaUtils.checkTarget(target, FormulaUtils.humanTargetsList)) { addDamageValuesByField(damageValues, conn, target + "", wkt); } else { addDamageValuesByArea(damageValues, conn, target + "", wkt); } } else if (FormulaUtils.isAllHumanTargets(target)) { addDamageValuesByField(damageValues, conn, FormulaUtils.humanTargetsList, wkt); } else if (FormulaUtils.isAllNotHumanTargets(target)) { addDamageValuesByArea(damageValues, conn, FormulaUtils.notHumanTargetsList, wkt); } else { addDamageValuesByField(damageValues, conn, FormulaUtils.humanTargetsList, wkt); addDamageValuesByArea(damageValues, conn, FormulaUtils.notHumanTargetsList, wkt); } return damageValues; } catch (SQLException e) { throw new ProcessException(e); } finally { transaction.close(); if (conn != null) { conn.close(); } } }
/** * Analyze the feature list, and for those features that can suffer split operation, they'll be * split. * * @return The builder instance. * @throws SplitFeatureBuilderFailException if the operation fail * @throws CannotSplitException if the split line cannot divide the feature's geometry */ public SplitFeatureBuilder buildSplit() throws SplitFeatureBuilderFailException, CannotSplitException { try { this.splitResultList = new LinkedList<SimpleFeature>(); boolean existSplit = false; for (SimpleFeature feature : this.featureList) { Geometry geomToSplit = (Geometry) feature.getDefaultGeometry(); assert geomToSplit.isValid() : "No Valid Geometry: " + geomToSplit.toText(); // $NON-NLS-1$ CoordinateReferenceSystem featureCrs = feature.getFeatureType().getCoordinateReferenceSystem(); geomToSplit = GeoToolsUtils.reproject(geomToSplit, featureCrs, this.desiredCRS); if (canSplit(geomToSplit)) { existSplit = true; this.featuresThatSufferedSplit.add(feature); List<Geometry> splitGeometriesResult = split(geomToSplit); this.splitResultList.addAll(createSplitFeatures(splitGeometriesResult, feature)); } } if (!existSplit) { throw new CannotSplitException("The split line cannot split any features"); // $NON-NLS-1$ } } catch (OperationNotFoundException e) { throw makeFailException(e); } catch (TransformException e) { throw makeFailException(e); } return this; }
private void validate(final Geometry geom, final List<ValidationResult> validationErrors) { if (geom.isEmpty()) { return; } if (geom instanceof GeometryCollection) { final GeometryCollection gc = (GeometryCollection) geom; for (int numGeom = 0; numGeom < gc.getNumGeometries(); numGeom++) { validate(gc.getGeometryN(numGeom), validationErrors); } } final ValidationResult result = new ValidationResult(); result.setWkt(geom.toText()); final List<String> messages = new ArrayList<String>(); if (!geom.isValid()) { messages.add("Error en topología básica"); } if (!geom.isSimple()) { messages.add("No es una geometría simple"); } if (repeatedPointTester.hasRepeatedPoint(geom)) { messages.add("Se encuentran vértices repetidos"); } if (geom instanceof Polygon) { final Polygon polygon = (Polygon) geom; if (CGAlgorithms.isCCW(polygon.getExteriorRing().getCoordinates())) { messages.add("Error en orientación del polígono"); } else { for (int numRing = 0; numRing < polygon.getNumInteriorRing(); numRing++) { if (!CGAlgorithms.isCCW(polygon.getInteriorRingN(numRing).getCoordinates())) { messages.add("Error en orientación del polígono en anillos interiores"); break; } } } if (!validateMinPolygonArea(geom)) { messages.add("Error en validación mínima de area de un polígono"); } } if (!validateMinSegmentLength(geom)) { messages.add("Error en validación mínima de longitud de segmento"); } if (!messages.isEmpty()) { result.setMessages(messages); validationErrors.add(result); } }
@Test public void testProyeccion() { GeometryFactory factory = new GeometryFactory(); final String sourceSRID = "EPSG:4326"; final String targetSRID = "EPSG:3395"; Geometry geom = factory.createPoint(new Coordinate(42.349167d, 3.684722d)); geom = MessageProcessor.transform(geom, sourceSRID, targetSRID); assertEquals(geom.toText(), "POINT (410181.3767547725 5184634.982024495)"); }
@Override public void serialize(Geometry value, JsonGenerator jgen, SerializerProvider provider) throws IOException { if (value == null) { provider.defaultSerializeNull(jgen); return; } // Todo support at least GeoJSON and WKT provider.defaultSerializeValue(value.toText(), jgen); }
public Geometry createHullFromGeometry( Geometry clusterGeometry, Collection<Coordinate> additionalPoints, boolean fast) { if (additionalPoints.isEmpty()) return clusterGeometry; final Set<Coordinate> batchCoords = new HashSet<Coordinate>(); for (final Coordinate coordinate : clusterGeometry.getCoordinates()) { batchCoords.add(coordinate); } for (final Coordinate coordinate : additionalPoints) { batchCoords.add(coordinate); } final Coordinate[] actualCoords = batchCoords.toArray(new Coordinate[batchCoords.size()]); if (batchCoords.size() == 2) { return clusterGeometry.getFactory().createLineString(actualCoords); } final ConvexHull convexHull = new ConvexHull(actualCoords, clusterGeometry.getFactory()); final Geometry convexHullGeo = convexHull.getConvexHull(); try { // does this shape benefit from concave hulling? // it cannot be a line string if (batchCoords.size() > 5 && convexHullGeo.getArea() > 0.0) { final Geometry concaveHull = fast ? concaveHull(convexHullGeo, batchCoords) : this.concaveHullParkOhMethod(convexHullGeo, batchCoords); if (!concaveHull.isSimple()) { LOGGER.warn("Produced non simple hull", concaveHull.toText()); return convexHullGeo; } return concaveHull; } else { return convexHullGeo; } } catch (final Exception ex) { /* * Geometry[] points = new Geometry[actualCoords.length + 1]; for * (int i = 0; i < actualCoords.length; i++) points[i] = * hull.getFactory().createPoint( actualCoords[i]); * points[points.length - 1] = hull; try { ShapefileTool.writeShape( * "test_perf_xh", new File( "./targettest_perf_xh"), points); } * catch (IOException e) { e.printStackTrace(); } */ LOGGER.error("Failed to compute hull", ex); return convexHullGeo; } }
@Override public void encodeGeometryValue(Geometry value, int srid, StringBuffer sql) throws IOException { if (value == null || value.isEmpty()) { sql.append("NULL"); } else { if (value instanceof LinearRing) { // postgis does not handle linear rings, convert to just a line string value = value.getFactory().createLineString(((LinearRing) value).getCoordinateSequence()); } sql.append("ST_GeomFromText('" + value.toText() + "', " + srid + ")"); } }
/** * Build the graph using the given polygon and the split line. * * @return this builder */ public SplitGraphBuilder build() { // after normalize() we know the shell is oriented CW and the holes CCW this.polygon.normalize(); this.usefulSplitLineBuilder.build(this.polygon); Geometry utilSplitLine = this.usefulSplitLineBuilder.getResultSplitLine(); AdaptedPolygon adaptedPolygon = this.usefulSplitLineBuilder.getAdaptedPolygon(); LOGGER.fine("Adapted Polygon: " + adaptedPolygon.asPolygon().toText()); // $NON-NLS-1$ LOGGER.fine("Util split line: " + utilSplitLine.toText()); // $NON-NLS-1$ buildGraph(utilSplitLine, adaptedPolygon.asPolygon()); return this; }
// ~ Methods ------------------------------------------------------------ @Override protected Set<CidsBean> doInBackground() throws Exception { final FlurstueckSchluesselCustomBean currentKey = LagisBroker.getInstance().getCurrentFlurstueckSchluessel(); if (currentKey != null) { Geometry flurstueckGeom = LagisBroker.getInstance().getInstance().getCurrentWFSGeometry(); if (flurstueckGeom != null) { log.info( "Crossover: Geometrie zum bestimmen der Kassenzeichen (vor Transformation): " + flurstueckGeom + ",SRS" + flurstueckGeom.getSRID()); flurstueckGeom = CrsTransformer.transformToGivenCrs(flurstueckGeom, "EPSG:31466"); // Hardcoded FTW log.info( "Crossover: Geometrie zum bestimmen der Kassenzeichen: " + flurstueckGeom + ",SRS" + flurstueckGeom.getSRID()); // final KassenzeichenFacadeRemote verdisServer = // LagisBroker.getInstance().getVerdisServer(); final String query = "SELECT 11, k.id\n" + "FROM kassenzeichen k, geom\n" + "WHERE k.geometrie = geom.id\n" + "AND not isEmpty(geom.geo_field)\n" + "AND intersects(geom.geo_field,st_buffer(st_buffer(geometryfromtext('" + flurstueckGeom.toText() + "',31466), " + LagisBroker.getInstance().getKassenzeichenBuffer() + "), 0))"; if (log.isDebugEnabled()) { log.debug(query); } if (isCancelled()) { return null; } final MetaObject[] result = CidsBroker.getInstance().getMetaObject(query, "VERDIS_GRUNDIS"); final HashSet<CidsBean> kassenzeichen = new HashSet<CidsBean>((result == null) ? 0 : result.length); if (result != null) { for (int i = 0; i < result.length; i++) { kassenzeichen.add(result[i].getBean()); } } // kassenzeichen = // verdisServer.getIntersectingKassenzeichen(flurstueckGeom, // LagisBroker.getInstance().getKassenzeichenBuffer()); if ((kassenzeichen != null) && (kassenzeichen.size() > 0)) { if (log.isDebugEnabled()) { log.debug("Crossover: Anzahl Kassenzeichen: " + kassenzeichen.size()); } } else { log.info("Crossover:Keine geschnittenen Kassenzeichen gefunden."); // ToDo Meldung an // benutzer } return kassenzeichen; } else { // ToDo user message ! lblMessage.setText( "<html>Keine Flurstücksgeometrie vorhanden,<br/>bestimmen der Kasssenzeichen nicht möglich.</html>"); log.warn("Crossover: Keine Geometrie vorhanden zum bestimmen der Kassenzeichen"); } } else { // ToDo user message ! lblMessage.setText( "<html>Bitte wählen Sie ein Flurstück aus,<br/>damit Kassenzeichen bestimmt werden können.</html > "); log.warn("Crossover: Kein Flurstück ausgewählt kann Lagis Kassenzeichen nicht bestimmen"); } return null; }
/** * Add a feature with layer name (typically feature type name), some attributes and a Geometry. * The Geometry must be in "pixel" space 0,0 lower left and 256,256 upper right. * * <p>For optimization, geometries will be clipped, geometries will simplified and features with * geometries outside of the tile will be skipped. * * @param layerName * @param attributes * @param geometry */ public void addFeature(String layerName, Map<String, ?> attributes, Geometry geometry) { // split up MultiPolygon and GeometryCollection (without subclasses) if (geometry instanceof MultiPolygon || geometry.getClass().equals(GeometryCollection.class)) { splitAndAddFeatures(layerName, attributes, (GeometryCollection) geometry); return; } // skip small Polygon/LineString. if (geometry instanceof Polygon && geometry.getArea() < 1.0d) { return; } if (geometry instanceof LineString && geometry.getLength() < 1.0d) { return; } // clip geometry. polygons right outside. other geometries at tile // border. try { if (geometry instanceof Polygon) { Geometry original = geometry; geometry = polygonClipGeometry.intersection(original); // some times a intersection is returned as an empty geometry. // going via wkt fixes the problem. if (geometry.isEmpty() && original.intersects(polygonClipGeometry)) { Geometry originalViaWkt = new WKTReader().read(original.toText()); geometry = polygonClipGeometry.intersection(originalViaWkt); } } else { geometry = clipGeometry.intersection(geometry); } } catch (TopologyException e) { // could not intersect. original geometry will be used instead. } catch (ParseException e1) { // could not encode/decode WKT. original geometry will be used instead. } // if clipping result in MultiPolygon, then split once more if (geometry instanceof MultiPolygon) { splitAndAddFeatures(layerName, attributes, (GeometryCollection) geometry); return; } // no need to add empty geometry if (geometry.isEmpty()) { return; } Layer layer = layers.get(layerName); if (layer == null) { layer = new Layer(); layers.put(layerName, layer); } Feature feature = new Feature(); feature.geometry = geometry; for (Map.Entry<String, ?> e : attributes.entrySet()) { // skip attribute without value if (e.getValue() == null) { continue; } feature.tags.add(layer.key(e.getKey())); feature.tags.add(layer.value(e.getValue())); } layer.features.add(feature); }
public void runTest() throws ParseException { failed = false; isRun = true; initGeometry(); if (expectedIM != null) { IntersectionMatrix im = null; if (geom[0] != null && geom[1] != null) { im = relate(geom[0], geom[1]); } if (im != null) { String msg = " expected " + expectedIM + ", found " + im.toString(); assertTrue(im.matches(expectedIM), msg); } } if (expectedBoundary != null) { Geometry result = geom[0].getBoundary(); assertEqualsExact( expectedBoundary, result, " expected boundary " + expectedBoundary.toText() + " , found " + result.toText()); } if (expectedConvexHull != null) { Geometry result = geom[0].convexHull(); assertEqualsExact( expectedConvexHull, result, " expected convex hull " + expectedConvexHull.toText() + " , found " + result.toText()); } if (expectedIntersection != null) { Geometry result = geom[0].intersection(geom[1]); assertEqualsExact( expectedIntersection, result, " expected intersection " + expectedIntersection.toText() + " , found " + result.toText()); } if (expectedUnion != null) { Geometry result = geom[0].union(geom[1]); assertEqualsExact( expectedUnion, result, " expected union " + expectedUnion.toText() + " , found " + result.toText()); } if (expectedDifference != null) { Geometry result = geom[0].difference(geom[1]); assertEqualsExact( expectedDifference, result, " expected difference " + expectedDifference.toText() + " , found " + result.toText()); } if (expectedSymDifference != null) { Geometry result = geom[0].symDifference(geom[1]); assertEqualsExact( expectedSymDifference, result, " expected sym difference " + expectedSymDifference.toText() + " , found " + result.toText()); } }
/** * Construct a geometry from the WKT representation of a geometry * * @param geom the constructor for the geometry. */ public String db2Geom(Geometry geom) { String geomType = geom.getGeometryType(); String g1 = geom.toText(); String g2 = "db2gse.ST_" + geomType + "('" + g1 + "'," + getSRID() + ")"; return g2; }