/** * Gets a JTS {@link Geometry} for the given {@link Shape}. Some shapes hold a * JTS geometry whereas new ones must be created for the rest. * @param shape Not null * @return Not null */ @Deprecated public Geometry getGeometryFrom(Shape shape) { return getShapeFactory().getGeometryFrom(shape); }
for (int i = 0; i < geom.getNumGeometries(); i++) { Geometry geomN = geom.getGeometryN(i); shapes.add(makeShapeFromGeometry(geomN));//recursion return multiShape(shapes); return pointXY(pt.getX(), pt.getY()); } else if (geom instanceof LineString) { if (!useJtsLineString()) { LineString lineString = (LineString) geom; List<Point> points = new ArrayList<>(lineString.getNumPoints()); for (int i = 0; i < lineString.getNumPoints(); i++) { Coordinate coord = lineString.getCoordinateN(i); points.add(pointXY(coord.x, coord.y)); return lineString(points, 0); jtsGeom = makeShape(geom); if (getValidationRule() != ValidationRule.none) jtsGeom.validate(); } catch (RuntimeException e) { if (getValidationRule() == ValidationRule.repairConvexHull) { jtsGeom = makeShape(geom.convexHull()); } else if (getValidationRule() == ValidationRule.repairBuffer0) { jtsGeom = makeShape(geom.buffer(0)); } else {
/** * Returns the rule used to handle geometry objects that have dateline (aka anti-meridian) crossing considerations. */ @Deprecated public DatelineRule getDatelineRule() { return getShapeFactory().getDatelineRule(); }
@Override public Shape buildOrRect() { Polygon geom = buildPolygonGeom(); if (geom.isRectangle()) { return makeRectFromRectangularPoly(geom); } return makeShapeFromGeometry(geom); }
public Shape difference(Shape s1, Shape s2) { Geometry difference = shapeFactory.getGeometryFrom(s1).difference(shapeFactory.getGeometryFrom(s2)); if (difference.isEmpty()) { return shapeFactory.pointXY(Double.NaN, Double.NaN); } return shapeFactory.makeShapeFromGeometry(difference); }
public Shape union(Shape s1, Shape s2) { return shapeFactory.makeShapeFromGeometry( shapeFactory.getGeometryFrom(s1).union(shapeFactory.getGeometryFrom(s2))); }
/** * Reads WKT from the {@code str} via JTS's {@link org.locationtech.jts.io.WKTReader}. * @param str * @param reader <pre>new WKTReader(ctx.getGeometryFactory()))</pre> * @return Non-Null */ protected Shape parseIfSupported(String str, WKTReader reader) throws ParseException { try { Geometry geom = reader.read(str); //Normalizes & verifies coordinates checkCoordinates(geom); if (geom instanceof org.locationtech.jts.geom.Point) { org.locationtech.jts.geom.Point ptGeom = (org.locationtech.jts.geom.Point) geom; if (getShapeFactory().useJtsPoint()) return new JtsPoint(ptGeom, (JtsSpatialContext) ctx); else return getShapeFactory().pointXY(ptGeom.getX(), ptGeom.getY()); } else if (geom.isRectangle()) { return getShapeFactory().makeRectFromRectangularPoly(geom); } else { return getShapeFactory().makeShapeFromGeometry(geom); } } catch (InvalidShapeException e) { throw e; } catch (Exception e) { throw new InvalidShapeException("error reading WKT: "+e.toString(), e); } }
public Geoshape geoshape(org.locationtech.jts.geom.Geometry geometry) { return new Geoshape(context.getShapeFactory().makeShapeFromGeometry(geometry)); }
public T fromText(String wkt) throws ParseException { T entity = (T) SPATIAL_CONTEXT.getWktShapeParser().parse(wkt); if (entity instanceof Rectangle) { Geometry geometryFrom = SHAPE_FACTORY.getGeometryFrom(entity); entity = (T) SHAPE_FACTORY.makeShape(geometryFrom); } return entity; }
/** * INTERNAL: Creates a {@link Shape} from a JTS {@link Geometry}. Generally, this shouldn't be * called when one of the other factory methods are available, such as for points. The caller * needs to have done some verification/normalization of the coordinates by now, if any. Also, * note that direct instances of {@link GeometryCollection} isn't supported. * * Instead of calling this method, consider {@link #makeShapeFromGeometry(Geometry)} * which */ public JtsGeometry makeShape(Geometry geom) { return makeShape(geom, datelineRule != DatelineRule.none, allowMultiOverlap); }
@Override public Point fromDoc(ODocument document) { validate(document); List<Number> coordinates = document.field(COORDINATES); Point point = SHAPE_FACTORY.pointXY(coordinates.get(0).doubleValue(), coordinates.get(1).doubleValue()); return point; }
@Override public Shape lineString(List<Point> points, double bufferDistance) { if (!useJtsLineString()) return super.lineString(points, bufferDistance); //convert List<Point> to Coordinate[] Coordinate[] coords = new Coordinate[points.size()]; for (int i = 0; i < coords.length; i++) { Point p = points.get(i); if (p instanceof JtsPoint) { JtsPoint jtsPoint = (JtsPoint) p; coords[i] = jtsPoint.getGeom().getCoordinate(); } else { coords[i] = new Coordinate(p.getX(), p.getY()); } } JtsGeometry shape = makeShape(geometryFactory.createLineString(coords)); if(bufferDistance!=0) { return shape.getBuffered(bufferDistance, ctx); } return shape; }
/** * INTERNAL: Returns a Rectangle of the JTS {@link Envelope} (bounding box) of the given {@code geom}. This asserts * that {@link Geometry#isRectangle()} is true. This method reacts to the {@link DatelineRule} setting. * @param geom non-null * @return the equivalent Rectangle. */ public Rectangle makeRectFromRectangularPoly(Geometry geom) { // TODO although, might want to never convert if there's a semantic difference (e.g. // geodetically)? Should have a setting for that. assert geom.isRectangle(); Envelope env = geom.getEnvelopeInternal(); boolean crossesDateline = false; if (ctx.isGeo() && getDatelineRule() != DatelineRule.none) { if (getDatelineRule() == DatelineRule.ccwRect) { // If JTS says it is clockwise, then it's actually a dateline crossing rectangle. crossesDateline = !CGAlgorithms.isCCW(geom.getCoordinates()); } else { crossesDateline = env.getWidth() > 180; } } if (crossesDateline) return rect(env.getMaxX(), env.getMinX(), env.getMinY(), env.getMaxY()); else return rect(env.getMinX(), env.getMaxX(), env.getMinY(), env.getMaxY()); }
@Deprecated public GeometryFactory getGeometryFactory() { return getShapeFactory().getGeometryFactory(); }
/** * Returns the rule used to handle errors when creating a JTS {@link Geometry}, particularly after it has been * read from one of the {@link ShapeReader}s. */ @Deprecated public ValidationRule getValidationRule() { return getShapeFactory().getValidationRule(); }
public Shape intersection(Shape s1, Shape s2) { Geometry intersection = shapeFactory.getGeometryFrom(s1).intersection(shapeFactory.getGeometryFrom(s2)); if (intersection.isEmpty()) { return shapeFactory.pointXY(Double.NaN, Double.NaN); } return shapeFactory.makeShapeFromGeometry(intersection); }
public Shape union(Shape s1, Shape s2) { return shapeFactory.makeShapeFromGeometry( shapeFactory.getGeometryFrom(s1).union(shapeFactory.getGeometryFrom(s2))); }
@Override public Shape build() { return makeShapeFromGeometry(buildPolygonGeom()); }
@Override public Shape build() { return makeShape(geometryFactory.createMultiPolygon(geoms.toArray(new Polygon[geoms.size()]))); } }
@Override public Shape parseIfSupported(String wktString) throws ParseException { return parseIfSupported(wktString, new WKTReader(getShapeFactory().getGeometryFactory())); }