JtsShapeFactory.java
/*******************************************************************************
* Copyright (c) 2015 Voyager Search and MITRE
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Apache License, Version 2.0 which
* accompanies this distribution and is available at
* http://www.apache.org/licenses/LICENSE-2.0.txt
******************************************************************************/
package org.locationtech.spatial4j.shape.jts;
import org.locationtech.spatial4j.context.SpatialContext;
import org.locationtech.spatial4j.context.jts.DatelineRule;
import org.locationtech.spatial4j.context.jts.JtsSpatialContext;
import org.locationtech.spatial4j.context.jts.JtsSpatialContextFactory;
import org.locationtech.spatial4j.context.jts.ValidationRule;
import org.locationtech.spatial4j.exception.InvalidShapeException;
import org.locationtech.spatial4j.io.ShapeReader;
import org.locationtech.spatial4j.shape.Circle;
import org.locationtech.spatial4j.shape.Point;
import org.locationtech.spatial4j.shape.Rectangle;
import org.locationtech.spatial4j.shape.Shape;
import org.locationtech.spatial4j.shape.impl.ShapeFactoryImpl;
import org.locationtech.jts.algorithm.CGAlgorithms;
import org.locationtech.jts.geom.*;
import org.locationtech.jts.util.GeometricShapeFactory;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* Enhances {@link ShapeFactoryImpl} with support for Polygons
* using <a href="https://sourceforge.net/projects/jts-topo-suite/">JTS</a>.
* To the extent possible, our {@link JtsGeometry} adds some amount of geodetic support over
* vanilla JTS which only has a Euclidean (flat plane) model.
*/
public class JtsShapeFactory extends ShapeFactoryImpl {
protected static final LinearRing[] EMPTY_HOLES = new LinearRing[0];
protected final GeometryFactory geometryFactory;
protected final boolean allowMultiOverlap;
protected final boolean useJtsPoint;
protected final boolean useJtsLineString;
protected final boolean useJtsMulti;
protected final DatelineRule datelineRule;
protected final ValidationRule validationRule;
protected final boolean autoIndex;
/**
* Called by {@link org.locationtech.spatial4j.context.jts.JtsSpatialContextFactory#newSpatialContext()}.
*/
public JtsShapeFactory(JtsSpatialContext ctx, JtsSpatialContextFactory factory) {
super(ctx, factory);
this.geometryFactory = factory.getGeometryFactory();
this.allowMultiOverlap = factory.allowMultiOverlap;
this.useJtsPoint = factory.useJtsPoint;
this.useJtsLineString = factory.useJtsLineString;
this.useJtsMulti = factory.useJtsMulti;
this.datelineRule = factory.datelineRule;
this.validationRule = factory.validationRule;
this.autoIndex = factory.autoIndex;
}
/**
* If geom might be a multi geometry of some kind, then might multiple
* component geometries overlap? Strict OGC says this is invalid but we
* can accept it by computing the union. Note: Our ShapeCollection mostly
* doesn't care but it has a method related to this
* {@link org.locationtech.spatial4j.shape.ShapeCollection#relateContainsShortCircuits()}.
*/
public boolean isAllowMultiOverlap() {
return allowMultiOverlap;
}
/**
* Returns the rule used to handle geometry objects that have dateline (aka anti-meridian) crossing considerations.
*/
public DatelineRule getDatelineRule() {
return datelineRule;
}
/**
* 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.
*/
public ValidationRule getValidationRule() {
return validationRule;
}
/**
* If JtsGeometry shapes should be automatically "prepared" (i.e. optimized) when read via from a {@link ShapeReader}.
*
* @see org.locationtech.spatial4j.shape.jts.JtsGeometry#index()
*/
public boolean isAutoIndex() {
return autoIndex;
}
@Override
public double normX(double x) {
x = super.normX(x);
return geometryFactory.getPrecisionModel().makePrecise(x);
}
@Override
public double normY(double y) {
y = super.normY(y);
return geometryFactory.getPrecisionModel().makePrecise(y);
}
@Override
public double normZ(double z) {
z = super.normZ(z);
return geometryFactory.getPrecisionModel().makePrecise(z);
}
@Override
public double normDist(double d) {
return geometryFactory.getPrecisionModel().makePrecise(d);
}
/**
* 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
*/
public Geometry getGeometryFrom(Shape shape) {
if (shape instanceof JtsGeometry) {
return ((JtsGeometry)shape).getGeom();
}
if (shape instanceof JtsPoint) {
return ((JtsPoint) shape).getGeom();
}
if (shape instanceof Point) {
Point point = (Point) shape;
return geometryFactory.createPoint(new Coordinate(point.getX(),point.getY()));
}
if (shape instanceof Rectangle) {
Rectangle r = (Rectangle)shape;
if (r.getCrossesDateLine()) {
Collection<Geometry> pair = new ArrayList<>(2);
pair.add(geometryFactory.toGeometry(new Envelope(
r.getMinX(), ctx.getWorldBounds().getMaxX(), r.getMinY(), r.getMaxY())));
pair.add(geometryFactory.toGeometry(new Envelope(
ctx.getWorldBounds().getMinX(), r.getMaxX(), r.getMinY(), r.getMaxY())));
return geometryFactory.buildGeometry(pair);//a MultiPolygon or MultiLineString
} else {
return geometryFactory.toGeometry(new Envelope(r.getMinX(), r.getMaxX(), r.getMinY(), r.getMaxY()));
}
}
if (shape instanceof Circle) {
// FYI Some interesting code for this is here:
// http://docs.codehaus.org/display/GEOTDOC/01+How+to+Create+a+Geometry#01HowtoCreateaGeometry-CreatingaCircle
//TODO This should ideally have a geodetic version
Circle circle = (Circle)shape;
GeometricShapeFactory gsf = new GeometricShapeFactory(geometryFactory);
gsf.setWidth(circle.getBoundingBox().getWidth());
gsf.setHeight(circle.getBoundingBox().getHeight());
gsf.setNumPoints(4*25);//multiple of 4 is best
gsf.setCentre(new Coordinate(circle.getCenter().getX(), circle.getCenter().getY()));
Geometry geom = gsf.createCircle();
if (circle.getBoundingBox().getCrossesDateLine())
// wrap the geometry in a JtsGeometry to handle date line wrapping
geom = new JtsGeometry(geom, (JtsSpatialContext) getSpatialContext(),false, false).getGeom();
return geom;
}
//TODO add BufferedLineString
throw new InvalidShapeException("can't make Geometry from: " + shape);
}
/** Should {@link #pointXY(double, double)} return {@link JtsPoint}? */
public boolean useJtsPoint() {
return useJtsPoint;
}
@Override
public Point pointXY(double x, double y) {
return pointXYZ(x, y, Coordinate.NULL_ORDINATE);
}
@Override
public Point pointXYZ(double x, double y, double z) {
if (!useJtsPoint())
return super.pointXY(x, y);// ignore z
//A Jts Point is fairly heavyweight! TODO could/should we optimize this? SingleCoordinateSequence
verifyX(x);
verifyY(y);
verifyZ(z);
// verifyZ(z)?
Coordinate coord = Double.isNaN(x) ? null : new Coordinate(x, y, z);
return new JtsPoint(geometryFactory.createPoint(coord), (JtsSpatialContext) ctx);
}
/** Should {@link #lineString(java.util.List,double)} return {@link JtsGeometry}? */
public boolean useJtsLineString() {
//BufferedLineString doesn't yet do dateline cross, and can't yet be relate()'ed with a
// JTS geometry
return useJtsLineString;
}
@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;
}
@Override
public LineStringBuilder lineString() {
if (!useJtsLineString())
return super.lineString();
return new JtsLineStringBuilder();
}
private class JtsLineStringBuilder extends CoordinatesAccumulator<JtsLineStringBuilder>
implements LineStringBuilder {
protected double bufDistance;
public JtsLineStringBuilder() {
}
@Override
public LineStringBuilder buffer(double distance) {
this.bufDistance = distance;
return this;
}
@Override
public Shape build() {
Geometry geom = buildLineStringGeom();
if (bufDistance != 0.0) {
geom = geom.buffer(bufDistance);
}
return makeShape(geom);
}
LineString buildLineStringGeom() {
return geometryFactory.createLineString(getCoordsArray());
}
}
@Override
public PolygonBuilder polygon() {
return new JtsPolygonBuilder();
}
private class JtsPolygonBuilder extends CoordinatesAccumulator<JtsPolygonBuilder>
implements PolygonBuilder {
List<LinearRing> holes;// lazy instantiated
@Override
public JtsHoleBuilder hole() {
return new JtsHoleBuilder();
}
private class JtsHoleBuilder extends CoordinatesAccumulator<JtsHoleBuilder>
implements PolygonBuilder.HoleBuilder {
@Override
public JtsPolygonBuilder endHole() {
LinearRing linearRing = geometryFactory.createLinearRing(getCoordsArray());
if (JtsPolygonBuilder.this.holes == null) {
JtsPolygonBuilder.this.holes = new ArrayList<>(4);//short
}
JtsPolygonBuilder.this.holes.add(linearRing);
return JtsPolygonBuilder.this;
}
}
@Override
public Shape build() {
return makeShapeFromGeometry(buildPolygonGeom());
}
@Override
public Shape buildOrRect() {
Polygon geom = buildPolygonGeom();
if (geom.isRectangle()) {
return makeRectFromRectangularPoly(geom);
}
return makeShapeFromGeometry(geom);
}
Polygon buildPolygonGeom() {
LinearRing outerRing = geometryFactory.createLinearRing(getCoordsArray());
LinearRing[] holeRings = holes == null ? EMPTY_HOLES : holes.toArray(new LinearRing[this.holes.size()]);
return geometryFactory.createPolygon(outerRing, holeRings);
}
} // class JtsPolygonBuilder
private abstract class CoordinatesAccumulator<T extends CoordinatesAccumulator> {
protected List<Coordinate> coordinates = new ArrayList<>();
public T pointXY(double x, double y) {
return pointXYZ(x, y, Coordinate.NULL_ORDINATE);
}
public T pointXYZ(double x, double y, double z) {
verifyX(x);
verifyY(y);
coordinates.add(new Coordinate(x, y, z));
return getThis();
}
// TODO would be be useful to add other ways of providing points? e.g. point(Coordinate)?
// TODO consider wrapping the List<Coordinate> in a custom CoordinateSequence and then (conditionally) use
// geometryFactory's coordinateSequenceFactory to create a new CS if configured to do so.
// Also consider instead natively storing the double[] and then auto-expanding on pointXY* as needed.
protected Coordinate[] getCoordsArray() {
return coordinates.toArray(new Coordinate[coordinates.size()]);
}
@SuppressWarnings("unchecked")
protected T getThis() { return (T) this; }
}
/** Whether {@link #multiPoint()}, {@link #multiLineString()}, and {@link #multiPolygon()} should all use JTS's
* subclasses of {@link GeometryCollection} instead of Spatial4j's basic impl. The general {@link #multiShape(Class)}
* will never use {@link GeometryCollection} because that class doesn't support relations. */
public boolean useJtsMulti() {
return useJtsMulti;
}
@Override
public MultiPointBuilder multiPoint() {
if (!useJtsMulti) {
return super.multiPoint();
}
return new JtsMultiPointBuilder();
}
private class JtsMultiPointBuilder extends CoordinatesAccumulator<JtsMultiPointBuilder> implements MultiPointBuilder {
@Override
public Shape build() {
return makeShape(geometryFactory.createMultiPoint(getCoordsArray()));
}
}
@Override
public MultiLineStringBuilder multiLineString() {
if (!useJtsMulti) {
return super.multiLineString();
}
return new JtsMultiLineStringBuilder();
}
private class JtsMultiLineStringBuilder implements MultiLineStringBuilder {
List<LineString> geoms = new ArrayList<>();
@Override
public LineStringBuilder lineString() {
return new JtsLineStringBuilder();
}
@Override
public MultiLineStringBuilder add(LineStringBuilder lineStringBuilder) {
geoms.add(((JtsLineStringBuilder)lineStringBuilder).buildLineStringGeom());
return this;
}
@Override
public Shape build() {
return makeShape(geometryFactory.createMultiLineString(geoms.toArray(new LineString[geoms.size()])));
}
}
@Override
public MultiPolygonBuilder multiPolygon() {
if (!useJtsMulti) {
return super.multiPolygon();
}
return new JtsMultiPolygonBuilder();
}
private class JtsMultiPolygonBuilder implements MultiPolygonBuilder {
List<Polygon> geoms = new ArrayList<>();
@Override
public PolygonBuilder polygon() {
return new JtsPolygonBuilder();
}
@Override
public MultiPolygonBuilder add(PolygonBuilder polygonBuilder) {
geoms.add(((JtsPolygonBuilder)polygonBuilder).buildPolygonGeom());
return this;
}
@Override
public Shape build() {
return makeShape(geometryFactory.createMultiPolygon(geoms.toArray(new Polygon[geoms.size()])));
}
}
@Override
public <T extends Shape> MultiShapeBuilder<T> multiShape(Class<T> shapeClass) {
if (!useJtsMulti()) {
return super.multiShape(shapeClass);
}
return new JtsMultiShapeBuilder<>();
}
// TODO: once we have typed shapes for Polygons & LineStrings, this logic could move to the superclass
// (not JTS specific) and the multi* builders could take a Shape
private class JtsMultiShapeBuilder<T extends Shape> extends GeneralShapeMultiShapeBuilder<T> {
@Override
public Shape build() {
Class<?> last = null;
List<Geometry> geoms = new ArrayList<>(shapes.size());
for(Shape s : shapes) {
if (last != null && last != s.getClass()) {
return super.build();
}
if (s instanceof JtsGeometry) {
geoms.add(((JtsGeometry)s).getGeom());
} else if (s instanceof JtsPoint) {
geoms.add(((JtsPoint)s).getGeom());
} else {
return super.build();
}
last = s.getClass();
}
return makeShapeFromGeometry(geometryFactory.buildGeometry(geoms));
}
}
/**
* INTERNAL Usually creates a JtsGeometry, potentially validating, repairing, and indexing ("preparing"). This method
* is intended for use by {@link ShapeReader} instances.
*
* If given a direct instance of {@link GeometryCollection} then it's contents will be
* recursively converted and then the resulting list will be passed to
* {@link SpatialContext#makeCollection(List)} and returned.
*
* If given a {@link org.locationtech.jts.geom.Point} then {@link SpatialContext#makePoint(double, double)}
* is called, which will return a {@link JtsPoint} if {@link JtsSpatialContext#useJtsPoint()}; otherwise
* a standard Spatial4j Point is returned.
*
* If given a {@link LineString} and if {@link JtsSpatialContext#useJtsLineString()} is true then
* then the geometry's parts are exposed to call {@link SpatialContext#makeLineString(List)}.
*/
// TODO should this be called always (consistent but sometimes not needed?)
// v.s. only from a ShapeReader (pre-ShapeFactory behavior)
public Shape makeShapeFromGeometry(Geometry geom) {
if (geom instanceof GeometryCollection) {
// Direct instances of GeometryCollection can't be wrapped in JtsGeometry but can be expanded into
// a ShapeCollection.
if (!useJtsMulti || geom.getClass() == GeometryCollection.class) {
List<Shape> shapes = new ArrayList<>(geom.getNumGeometries());
for (int i = 0; i < geom.getNumGeometries(); i++) {
Geometry geomN = geom.getGeometryN(i);
shapes.add(makeShapeFromGeometry(geomN));//recursion
}
return multiShape(shapes);
}
} else if (geom instanceof org.locationtech.jts.geom.Point) {
org.locationtech.jts.geom.Point pt = (org.locationtech.jts.geom.Point) geom;
if (pt.isEmpty()) {
return pointXY(Double.NaN, Double.NaN);
} else {
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);
}
}
JtsGeometry jtsGeom;
try {
jtsGeom = makeShape(geom);
if (getValidationRule() != ValidationRule.none)
jtsGeom.validate();
} catch (RuntimeException e) {
// repair:
if (getValidationRule() == ValidationRule.repairConvexHull) {
jtsGeom = makeShape(geom.convexHull());
} else if (getValidationRule() == ValidationRule.repairBuffer0) {
jtsGeom = makeShape(geom.buffer(0));
} else {
// TODO there are other smarter things we could do like repairing inner holes and
// subtracting
// from outer repaired shell; but we needn't try too hard.
throw e;
}
}
return jtsGeom;
}
/**
* INTERNAL
* @see #makeShape(org.locationtech.jts.geom.Geometry)
*
* @param geom Non-null
* @param dateline180Check if both this is true and {@link SpatialContext#isGeo()}, then JtsGeometry will check
* for adjacent coordinates greater than 180 degrees longitude apart, and
* it will do tricks to make that line segment (and the shape as a whole)
* cross the dateline even though JTS doesn't have geodetic support.
* @param allowMultiOverlap See {@link #isAllowMultiOverlap()}.
*/
public JtsGeometry makeShape(Geometry geom, boolean dateline180Check, boolean allowMultiOverlap) {
JtsGeometry jtsGeom = new JtsGeometry(geom, (JtsSpatialContext) ctx, dateline180Check, allowMultiOverlap);
if (isAutoIndex()) {
jtsGeom.index();
}
return jtsGeom;
}
/**
* 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);
}
public GeometryFactory getGeometryFactory() {
return geometryFactory;
}
/**
* 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());
}
}