Add checks for invalid and zero input

Author: dr-jts

modules/core/src/main/java/org/locationtech/jts/algorithm/distance/DirectedHausdorffDistance.java

@@ -255,7 +255,14 @@ private static Coordinate[] pair(Coordinate p0, Coordinate p1) {
    */
   private static final double FULLY_WITHIN_TOLERANCE_FACTOR = 10 * AUTO_TOLERANCE_FACTOR;
 
-  
+  /**
+   * Computes an automatic distance tolerance for a query geometry.
+   * A tolerance of zero may be returned (e.g. for a zero-length line);
+   * this is supported by the distance algorithm.
+   * 
+   * @param geom the query geometry
+   * @return the distance tolerance
+   */
   private static double computeTolerance(Geometry geom) {
     return geom.getEnvelopeInternal().getDiameter() / AUTO_TOLERANCE_FACTOR;
   }
@@ -363,6 +370,14 @@ public Coordinate[] farthestPoints(Geometry geom, double tolerance) {
   }
 
   private Coordinate[] computeDistancePoints(Geometry geom, double tolerance, double maxDistanceLimit) {
+    /**
+     * Negative tolerances are not allowed.
+     * Zero tolerance is allowed, to support zero-size input.
+     */
+    if (tolerance < 0.0 ) {
+      throw new IllegalArgumentException("Tolerance must be non-negative");
+    }
+    
     if (geom.isEmpty() || target.isEmpty())
       return null;
 
@@ -412,7 +427,8 @@ private Coordinate[] computeForPoints(Geometry geom, double maxDistanceLimit) {
         maxDist = dist;
         maxDistPtsAB = pair(pA, pB);
       }
-      if (isBeyondLimit(maxDist, maxDistanceLimit)) {
+      if (isValidLimit(maxDistanceLimit) 
+          && isBeyondLimit(maxDist, maxDistanceLimit)) {
         break;
       }
     }
@@ -460,10 +476,12 @@ private Coordinate[] computeForEdges(Geometry geom, double tolerance, double max
        * - if segment distance bound is less than distance limit, no other segment can be farther
        * - if a point of segment is farther than limit, isFulyWithin must be false
        */
-      if (isWithinLimit(segMaxBound.getMaxDistanceBound(), maxDistanceLimit)
+      if (isValidLimit(maxDistanceLimit)) {
+        if (isWithinLimit(segMaxBound.getMaxDistanceBound(), maxDistanceLimit)
           || isBeyondLimit(segMaxBound.getMaxDistance(), maxDistanceLimit)
           ) {
-        break;
+            break;
+        }
       }
 
       /**
@@ -483,9 +501,10 @@ private Coordinate[] computeForEdges(Geometry geom, double tolerance, double max
       /**
        * If segment is longer than tolerance
        * it might provide a better max distance point,
-       * so bisect and keep searching
+       * so bisect and keep searching.
        */
-      if ((segMaxBound.getLength() > tolerance)) {
+      if (tolerance > 0 
+          && segMaxBound.getLength() > tolerance) {
         DHDSegment[] bisects = segMaxBound.bisect(targetDistance);
         addNonInterior(bisects[0], segQueue);
         addNonInterior(bisects[1], segQueue);
@@ -514,6 +533,10 @@ private boolean isSameOrCollinear(DHDSegment seg) {
     return f0.isSameSegment(f1);
   }
 
+  private static boolean isValidLimit(double limit) {
+    return limit >= 0.0;
+  }
+  
   private static boolean isBeyondLimit(double maxDist, double maxDistanceLimit) {
     return maxDistanceLimit >= 0 && maxDist > maxDistanceLimit;
   }
@@ -561,6 +584,9 @@ private boolean isInterior(DHDSegment segment) {
    *   or null if it is known to not occur at an interior point 
    */
   private Coordinate[] computeForAreaInterior(Geometry geom, double tolerance) {
+    if (tolerance <= 0.0)
+      return null;
+    
     //TODO: extract polygonal geoms from A
     Geometry polygonal = geom;
 

modules/core/src/test/java/org/locationtech/jts/algorithm/distance/DirectedHausdorffDistanceTest.java

@@ -26,6 +26,8 @@ public static void main(String args[]) {
 
   public DirectedHausdorffDistanceTest(String name) { super(name); }
 
+  //-- empty inputs
+  
   public void testEmptyPoint()
   {
     checkDistanceEmpty("POINT EMPTY", "POINT (1 1)");
@@ -42,6 +44,76 @@ public void testEmptyPolygon()
   }
 
   //--------------------------------------
+  //-- extreme and invalid inputs
+  
+  public void testZeroTolerancePoint()
+  {
+    checkDistance("POINT (5 5)", "LINESTRING (5 1, 9 5)",
+        0,
+        "LINESTRING (5 5, 7 3)");
+  }
+  
+  public void testZeroToleranceLine()
+  {
+    checkDistance("LINESTRING (1 5, 5 5)", "LINESTRING (5 1, 9 5)",
+        0,
+        "LINESTRING (1 5, 5 1)");
+  }
+  
+  public void testZeroToleranceZeroLengthLineQuery()
+  {
+    checkDistance("LINESTRING (5 5, 5 5)", "LINESTRING (5 1, 9 5)",
+        0,
+        "LINESTRING (5 5, 7 3)");
+  }
+  
+  public void testZeroLengthLineQuery()
+  {
+    checkDistance("LINESTRING (5 5, 5 5)", "LINESTRING (5 1, 9 5)",
+        "LINESTRING (5 5, 7 3)");
+  }
+  
+  public void testZeroLengthPolygonQuery()
+  {
+    checkDistance("POLYGON ((5 5, 5 5, 5 5, 5 5))", "LINESTRING (5 1, 9 5)",
+        "LINESTRING (5 5, 7 3)");
+  }
+  
+  public void testZeroLengthLineTarget()
+  {
+    checkDistance("POINT (5 5)", "LINESTRING (5 1, 5 1)",
+        "LINESTRING (5 5, 5 1)");
+  }
+  
+  public void testNegativeTolerancePoint()
+  {
+    try {
+      checkDistance("POINT (5 5)", "LINESTRING (5 1, 9 5)",
+          -1,
+          "LINESTRING (5 5, 7 3)");
+      fail();
+    }
+    catch (IllegalArgumentException expected) {
+      
+    }
+  }
+  
+  public void testNegativeToleranceLine()
+  {
+    try {
+      checkDistance("LINESTRING (1 5, 5 5)", "LINESTRING (5 1, 9 5)",
+        -1,
+        "LINESTRING (1 5, 5 1)");
+      fail();
+    }
+    catch (IllegalArgumentException expected) {
+    
+    }
+  }
+  
+  //--------------------------------------
+  
+  
   public void testPointPoint()
   {
     checkHausdorff("POINT (0 0)", "POINT (1 1)", 
@@ -302,6 +374,16 @@ private void checkDistance(String wkt1, String wkt2, String wktExpected) {
     checkEqualExact(expected, result, TOLERANCE);
   }
 
+  private void checkDistance(String wkt1, String wkt2, double tolerance, String wktExpected) {
+    Geometry g1 = read(wkt1);
+    Geometry g2 = read(wkt2);
+    
+    Coordinate[] pts = DirectedHausdorffDistance.distancePoints(g1, g2, tolerance);
+    Geometry result = g1.getFactory().createLineString(pts);
+    Geometry expected = read(wktExpected);
+    checkEqualExact(expected, result, TOLERANCE);
+  }
+  
   private void checkDistanceStartPtLen(String wkt1, String wkt2, 
       String wktExpected, double resultTolerance) {
     Geometry g1 = read(wkt1);