Add DirectedHausdorffDistance class

modules/app/src/main/java/org/locationtech/jtstest/function/DistanceFunctions.java

@@ -13,6 +13,7 @@
 
 import org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance;
 import org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance;
+import org.locationtech.jts.algorithm.distance.DirectedHausdorffDistance;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.LineString;
@@ -45,53 +46,61 @@ public static Geometry frechetDistanceLine(Geometry a, Geometry b)
     return a.getFactory().createLineString(dist.getCoordinates());
   }
 
-  public static double hausdorffDistance(Geometry a, Geometry b)  
+  @Metadata(description="Oriented discrete Hausdorff distance from A to B")
+	public static double orientedDiscreteHausdorffDistance(Geometry a, Geometry b)	
+	{		
+    return DiscreteHausdorffDistance.orientedDistance(a, b);
+	}
+
+  @Metadata(description="Oriented discrete Hausdorff distance line from A to B, densified")
+  public static Geometry orientedDiscreteHausdorffLineDensify(Geometry a, Geometry b, 
+      @Metadata(title="Densify fraction")
+      double frac)  
   {   
-    return DiscreteHausdorffDistance.distance(a, b);
+    return DiscreteHausdorffDistance.orientedDistanceLine(a, b, frac);
+  }
+
+  @Metadata(description="Clipped directed Hausdorff distance from A to B")
+  public static Geometry clippedDirectedHausdorffLine(Geometry a, Geometry b)  
+  {   
+    Geometry clippedLine = LinearReferencingFunctions.project(a, b);
+    Coordinate[] pts = DirectedHausdorffDistance.distancePoints(clippedLine, b);
+    return a.getFactory().createLineString(pts);
   }
 
-  @Metadata(description="Hausdorff distance between A and B")
-  public static Geometry hausdorffDistanceLine(Geometry a, Geometry b)  
+  @Metadata(description="Directed Hausdorff distance from A to B, up to tolerance")
+  public static double directedHausdorffDistance(Geometry a, Geometry b, 
+      @Metadata(title="Distance tolerance")
+      double distTol)  
   {   
-    return DiscreteHausdorffDistance.distanceLine(a, b);
+    return DirectedHausdorffDistance.distance(a, b, distTol);
   }
-
-  @Metadata(description="Hausdorff distance between A and B, densified")
-	public static Geometry hausdorffDistanceLineDensify(Geometry a, Geometry b, 
-      @Metadata(title="Densify fraction")
-	    double frac)	
-	{		
-    return DiscreteHausdorffDistance.distanceLine(a, b, frac);
-	}
-
-  @Metadata(description="Oriented Hausdorff distance from A to B")
-  public static Geometry orientedHausdorffDistanceLine(Geometry a, Geometry b)  
+
+  @Metadata(description="Directed Hausdorff distance line from A to B, up to tolerance")
+  public static Geometry directedHausdorffLineTol(Geometry a, Geometry b, 
+      @Metadata(title="Distance tolerance")
+      double distTol)  
   {   
-    return DiscreteHausdorffDistance.orientedDistanceLine(a, b);
+    Coordinate[] pts = DirectedHausdorffDistance.distancePoints(a, b, distTol);
+    return a.getFactory().createLineString(pts);
   }
-
-  @Metadata(description="Oriented Hausdorff distance from A to B")
-  public static Geometry clippedOrientedHausdorffDistanceLine(Geometry a, Geometry b)  
+  
+  @Metadata(description="Directed Hausdorff distance line from A to B")
+  public static Geometry directedHausdorffLine(Geometry a, Geometry b)  
   {   
-    //TODO: would this be more efficient done as part of DiscreteHausdorffDistance?
-    Geometry clippedLine = LinearReferencingFunctions.project(a, b);
-    return DiscreteHausdorffDistance.orientedDistanceLine(clippedLine, b);
+    Coordinate[] pts = DirectedHausdorffDistance.distancePoints(a, b);
+    return a.getFactory().createLineString(pts);
   }
-
-  @Metadata(description="Oriented Hausdorff distance from A to B")
-	public static double orientedHausdorffDistance(Geometry a, Geometry b)	
-	{		
-    return DiscreteHausdorffDistance.orientedDistance(a, b);
-	}
-
-  @Metadata(description="Oriented Hausdorff distance from A to B, densified")
-  public static Geometry orientedHausdorffDistanceLineDensify(Geometry a, Geometry b, 
-      @Metadata(title="Densify fraction")
-      double frac)  
+
+  @Metadata(description="Hausdorff distance between A and B, up to tolerance")
+  public static Geometry hausdorffLine(Geometry a, Geometry b)  
   {   
-    return DiscreteHausdorffDistance.orientedDistanceLine(a, b, frac);
+    Coordinate[] pts = DirectedHausdorffDistance.hausdorffDistancePoints(a, b);
+    return a.getFactory().createLineString(pts);
   }
-
+
+  //--------------------------------------------
+
   public static double distanceIndexed(Geometry a, Geometry b) {
     return IndexedFacetDistance.distance(a, b);
   }
@@ -117,4 +126,5 @@ public static Geometry nearestPointsIndexedEachB(Geometry a, Geometry b) {
 
     return a.getFactory().createMultiLineString(lines);
   }
+
 }

modules/app/src/main/java/org/locationtech/jtstest/function/SelectionFunctions.java

@@ -16,6 +16,7 @@
 import java.util.List;
 
 import org.locationtech.jts.algorithm.construct.MaximumInscribedCircle;
+import org.locationtech.jts.algorithm.distance.DirectedHausdorffDistance;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.prep.PreparedGeometry;
 import org.locationtech.jts.geom.prep.PreparedGeometryFactory;
@@ -238,6 +239,25 @@ public boolean isTrue(Geometry g) {
     });
   }
 
+  public static Geometry fullyWithinDistance(Geometry a, final Geometry mask, double maximumDistance)
+  {
+    return select(a, new GeometryPredicate() {
+      public boolean isTrue(Geometry g) {
+        return DirectedHausdorffDistance.isFullyWithinDistance(g, mask, maximumDistance);
+      }
+    });
+  }
+
+  public static Geometry fullyWithinDistancePrep(Geometry a, final Geometry mask, double maximumDistance)
+  {
+    DirectedHausdorffDistance dhd = new DirectedHausdorffDistance(mask);
+    return select(a, new GeometryPredicate() {
+      public boolean isTrue(Geometry g) {
+        return dhd.isFullyWithinDistance(g, maximumDistance);
+      }
+    });
+  }
+
   public static Geometry maxInCircleRadiusWithin(Geometry a, 
       @Metadata(title="Max Radius Length")
       double maximumRadius)

modules/core/src/main/java/org/locationtech/jts/algorithm/construct/IndexedDistanceToPoint.java

@@ -11,6 +11,7 @@
  */
 package org.locationtech.jts.algorithm.construct;
 
+import org.locationtech.jts.algorithm.locate.IndexedPointInPolygonsLocator;
 import org.locationtech.jts.geom.Coordinate;
 import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.Location;