Merge master

Signed-off-by: Mike Barry <msb5014@gmail.com>

doc/JTS_Version_History.md

@@ -36,6 +36,7 @@ Distributions for older JTS versions can be obtained at the
 * Improve `OffsetCurve` to return more linework for some input situations (#956)
 * Reduce buffer curve short fillet segments (#960)
 * Added ability to specify boundary for `LargestEmptyCircle` (#973)
+* Improve `DouglaPeuckerSimplifier` and `TopologyPreservingSimplifier` to handle ring endpoints (#1013)
 
 ### Bug Fixes
 * Fix `PreparedGeometry` handling of EMPTY elements (#904)

modules/core/src/main/java/org/locationtech/jts/simplify/DouglasPeuckerLineSimplifier.java

@@ -13,6 +13,7 @@
 package org.locationtech.jts.simplify;
 
 import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateArrays;
 import org.locationtech.jts.geom.CoordinateList;
 import org.locationtech.jts.geom.LineSegment;
 
@@ -24,16 +25,18 @@
  */
 class DouglasPeuckerLineSimplifier
 {
- public static Coordinate[] simplify(Coordinate[] pts, double distanceTolerance)
+ public static Coordinate[] simplify(Coordinate[] pts, double distanceTolerance, boolean isPreserveEndpoint)
  {
  DouglasPeuckerLineSimplifier simp = new DouglasPeuckerLineSimplifier(pts);
  simp.setDistanceTolerance(distanceTolerance);
+ simp.setPreserveEndpoint(isPreserveEndpoint);
  return simp.simplify();
  }
 
  private Coordinate[] pts;
  private boolean[] usePt;
  private double distanceTolerance;
+ private boolean isPreserveEndpoint = false;
 
  public DouglasPeuckerLineSimplifier(Coordinate[] pts)
  {
@@ -50,19 +53,44 @@ public void setDistanceTolerance(double distanceTolerance) {
  this.distanceTolerance = distanceTolerance;
  }
 
+ private void setPreserveEndpoint(boolean isPreserveEndpoint) {
+ this.isPreserveEndpoint = isPreserveEndpoint;
+ }
+
  public Coordinate[] simplify()
  {
  usePt = new boolean[pts.length];
  for (int i = 0; i < pts.length; i++) {
  usePt[i] = true;
  }
  simplifySection(0, pts.length - 1);
+
  CoordinateList coordList = new CoordinateList();
  for (int i = 0; i < pts.length; i++) {
  if (usePt[i])
  coordList.add(new Coordinate(pts[i]));
  }
- return coordList.toCoordinateArray();
+
+ if (! isPreserveEndpoint && CoordinateArrays.isRing(pts)) {
+ simplifyRingEndpoint(coordList);
+ }
+
+ return coordList.toCoordinateArray();
+ }
+
+ private void simplifyRingEndpoint(CoordinateList pts) {
+ //-- avoid collapsing triangles
+ if (pts.size() < 4)
+ return;
+ //-- base segment for endpoint
+ seg.p0 = pts.get(1);
+ seg.p1 = pts.get(pts.size() - 2); 
+ double distance = seg.distance(pts.get(0));
+ if (distance <= distanceTolerance) {
+ pts.remove(0);
+ pts.remove(pts.size() - 1);
+ pts.closeRing();
+ }
  }
 
  private LineSegment seg = new LineSegment();

modules/core/src/main/java/org/locationtech/jts/simplify/DouglasPeuckerSimplifier.java

@@ -136,13 +136,14 @@ public DPTransformer(boolean isEnsureValidTopology, double distanceTolerance)
  @Override
  protected CoordinateSequence transformCoordinates(CoordinateSequence coords, Geometry parent)
  {
+ boolean isPreserveEndpoint = ! (parent instanceof LinearRing);
  Coordinate[] inputPts = coords.toCoordinateArray();
  Coordinate[] newPts = null;
  if (inputPts.length == 0) {
  newPts = new Coordinate[0];
  }
  else {
- newPts = DouglasPeuckerLineSimplifier.simplify(inputPts, distanceTolerance);
+ newPts = DouglasPeuckerLineSimplifier.simplify(inputPts, distanceTolerance, isPreserveEndpoint);
  }
  return factory.getCoordinateSequenceFactory().create(newPts);
  }

modules/core/src/main/java/org/locationtech/jts/simplify/TaggedLineString.java

@@ -34,17 +34,23 @@ class TaggedLineString
  private TaggedLineSegment[] segs;
  private List resultSegs = new ArrayList();
  private int minimumSize;
+ private boolean isPreserveEndpoint = true;
 
  public TaggedLineString(LineString parentLine) {
- this(parentLine, 2);
+ this(parentLine, 2, true);
  }
 
- public TaggedLineString(LineString parentLine, int minimumSize) {
+ public TaggedLineString(LineString parentLine, int minimumSize, boolean isPreserveEndpoint) {
  this.parentLine = parentLine;
  this.minimumSize = minimumSize;
+ this.isPreserveEndpoint = isPreserveEndpoint;
  init();
  }
 
+ public boolean isPreserveEndpoint() {
+ return isPreserveEndpoint;
+ }
+
  public int getMinimumSize() { return minimumSize; }
  public LineString getParent() { return parentLine; }
  public Coordinate[] getParentCoordinates() { return parentLine.getCoordinates(); }
@@ -58,6 +64,20 @@ public int getResultSize()
 
  public TaggedLineSegment getSegment(int i) { return segs[i]; }
 
+ /**
+ * Gets a segment of the result list.
+ * Negative indexes can be used to retrieve from the end of the list.
+ * @param i the segment index to retrieve
+ * @return the result segment
+ */
+ public LineSegment getResultSegment(int i) { 
+ int index = i;
+ if (i < 0) {
+ index = resultSegs.size() + i;
+ }
+ return (LineSegment) resultSegs.get(index);
+ }
+
  private void init()
  {
  Coordinate[] pts = parentLine.getCoordinates();
@@ -98,5 +118,12 @@ private static Coordinate[] extractCoordinates(List segs)
  return pts;
  }
 
+ void removeRingEndpoint()
+ {
+ LineSegment firstSeg = (LineSegment) resultSegs.get(0);
+ LineSegment lastSeg = (LineSegment) resultSegs.get(resultSegs.size() - 1);
 
+ firstSeg.p0 = lastSeg.p0;
+ resultSegs.remove(resultSegs.size() - 1);
+ }
 }

modules/core/src/main/java/org/locationtech/jts/simplify/TaggedLineStringSimplifier.java

@@ -18,6 +18,7 @@
 import org.locationtech.jts.algorithm.LineIntersector;
 import org.locationtech.jts.algorithm.RobustLineIntersector;
 import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateArrays;
 import org.locationtech.jts.geom.LineSegment;
 
 /**
@@ -66,13 +67,16 @@ void simplify(TaggedLineString line)
  this.line = line;
  linePts = line.getParentCoordinates();
  simplifySection(0, linePts.length - 1, 0);
+
+ if (! line.isPreserveEndpoint() && CoordinateArrays.isRing(linePts)) {
+ simplifyRingEndpoint();
+ }
  }
 
  private void simplifySection(int i, int j, int depth)
  {
  depth += 1;
- int[] sectionIndex = new int[2];
- if((i+1) == j) {
+ if ((i+1) == j) {
  LineSegment newSeg = line.getSegment(i);
  line.addToResult(newSeg);
  // leave this segment in the input index, for efficiency
@@ -101,9 +105,7 @@ private void simplifySection(int i, int j, int depth)
  LineSegment candidateSeg = new LineSegment();
  candidateSeg.p0 = linePts[i];
  candidateSeg.p1 = linePts[j];
- sectionIndex[0] = i;
- sectionIndex[1] = j;
- if (hasBadIntersection(line, sectionIndex, candidateSeg)) {
+ if (hasBadIntersection(line, i, j, candidateSeg)) {
  isValidToSimplify = false;
  }
 
@@ -116,6 +118,21 @@ private void simplifySection(int i, int j, int depth)
  simplifySection(furthestPtIndex, j, depth);
  }
 
+ private void simplifyRingEndpoint()
+ {
+ if (line.getResultSize() > line.getMinimumSize()) {
+ LineSegment firstSeg = line.getResultSegment(0);
+ LineSegment lastSeg = line.getResultSegment(-1);
+
+ LineSegment simpSeg = new LineSegment(lastSeg.p0, firstSeg.p1);
+ //-- the excluded segments are the ones containing the endpoint
+ if (simpSeg.distance(firstSeg.p0) <= distanceTolerance
+ && ! hasBadIntersection(line, line.getSegments().length - 2, 0, simpSeg)) {
+ line.removeRingEndpoint();
+ }
+ }
+ }
+
  private int findFurthestPoint(Coordinate[] pts, int i, int j, double[] maxDistance)
  {
  LineSegment seg = new LineSegment();
@@ -158,12 +175,25 @@ private LineSegment flatten(int start, int end)
  return newSeg;
  }
 
- private boolean hasBadIntersection(TaggedLineString parentLine,
- int[] sectionIndex,
+ /**
+ * Tests if a flattening segment intersects a line 
+ * (excluding a given section of segments).
+ * The excluded section is being replaced by the flattening segment, 
+ * so there is no need to test it 
+ * (and it may well intersect the segment).
+ * 
+ * @param line
+ * @param excludeStart
+ * @param excludeEnd
+ * @param candidateSeg
+ * @return
+ */
+ private boolean hasBadIntersection(TaggedLineString line,
+ int excludeStart, int excludeEnd,
  LineSegment candidateSeg)
  {
  if (hasBadOutputIntersection(candidateSeg)) return true;
- if (hasBadInputIntersection(parentLine, sectionIndex, candidateSeg)) return true;
+ if (hasBadInputIntersection(line, excludeStart, excludeEnd, candidateSeg)) return true;
  return false;
  }
 
@@ -179,16 +209,19 @@ private boolean hasBadOutputIntersection(LineSegment candidateSeg)
  return false;
  }
 
- private boolean hasBadInputIntersection(TaggedLineString parentLine,
- int[] sectionIndex,
+ private boolean hasBadInputIntersection(TaggedLineString line,
+  int excludeStart, int excludeEnd,
  LineSegment candidateSeg)
  {
  List querySegs = inputIndex.query(candidateSeg);
  for (Iterator i = querySegs.iterator(); i.hasNext(); ) {
  TaggedLineSegment querySeg = (TaggedLineSegment) i.next();
  if (hasInvalidIntersection(querySeg, candidateSeg)) {
- //-- don't fail if the segment is part of parent line
- if (isInLineSection(parentLine, sectionIndex, querySeg))
+ /**
+ * Ignore the intersection if the intersecting segment is part of the section being collapsed
+ * to the candidate segment
+ */
+ if (isInLineSection(line, excludeStart, excludeEnd, querySeg))
  continue;
  return true;
  }
@@ -197,23 +230,36 @@ private boolean hasBadInputIntersection(TaggedLineString parentLine,
  }
 
  /**
- * Tests whether a segment is in a section of a TaggedLineString
- * @param line
- * @param sectionIndex
- * @param seg
- * @return
+ * Tests whether a segment is in a section of a TaggedLineString.
+ * Sections may wrap around the endpoint of the line, 
+ * to support ring endpoint simplification.
+ * This is indicated by excludedStart > excludedEnd
+ * 
+ * @param line the TaggedLineString containing the section segments
+ * @param excludeStart the index of the first segment in the excluded section 
+ * @param excludeEnd the index of the last segment in the excluded section
+ * @param seg the segment to test
+ * @return true if the test segment intersects some segment in the line not in the excluded section
  */
  private static boolean isInLineSection(
  TaggedLineString line,
- int[] sectionIndex,
+ int excludeStart, int excludeEnd,
  TaggedLineSegment seg)
  {
- // not in this line
+ //-- test segment is not in this line
  if (seg.getParent() != line.getParent())
  return false;
  int segIndex = seg.getIndex();
- if (segIndex >= sectionIndex[0] && segIndex < sectionIndex[1])
+ if (excludeStart <= excludeEnd) {
+ //-- section is contiguous
+ if (segIndex >= excludeStart && segIndex < excludeEnd)
+ return true;
+ }
+ else {
+ //-- section wraps around the end of a ring
+ if (segIndex >= excludeStart || segIndex <= excludeEnd)
  return true;
+ }
  return false;
  }
 

modules/core/src/main/java/org/locationtech/jts/simplify/TopologyPreservingSimplifier.java

@@ -45,6 +45,9 @@
  * any intersecting line segments, this property
  * will be preserved in the output.
  * <p>
+ * For polygonal geometries and LinearRings the endpoint will participate
+ * in simplification. For LineStrings the endpoints will not be unchanged.
+ * <p>
  * For all geometry types, the result will contain 
  * enough vertices to ensure validity. For polygons
  * and closed linear geometries, the result will have at
@@ -177,7 +180,8 @@ public void filter(Geometry geom)
  if (line.isEmpty()) return;
 
  int minSize = ((LineString) line).isClosed() ? 4 : 2;
- TaggedLineString taggedLine = new TaggedLineString((LineString) line, minSize);
+ boolean isPreserveEndpoint = (line instanceof LinearRing) ? false : true;
+ TaggedLineString taggedLine = new TaggedLineString((LineString) line, minSize, isPreserveEndpoint);
  tps.linestringMap.put(line, taggedLine);
  }
  }