Merge 7399aad into b07089b

Author: msbarry

planetiler-core/src/main/java/com/onthegomap/planetiler/FeatureCollector.java

@@ -5,6 +5,7 @@
 import com.onthegomap.planetiler.config.PlanetilerConfig;
 import com.onthegomap.planetiler.geo.GeoUtils;
 import com.onthegomap.planetiler.geo.GeometryException;
+import com.onthegomap.planetiler.geo.GeometryPipeline;
 import com.onthegomap.planetiler.geo.GeometryType;
 import com.onthegomap.planetiler.geo.SimplifyMethod;
 import com.onthegomap.planetiler.reader.SourceFeature;
@@ -506,6 +507,9 @@ public final class Feature implements WithZoomRange<Feature>, WithAttrs<Feature>
     private SimplifyMethod defaultSimplifyMethod = SimplifyMethod.DOUGLAS_PEUCKER;
     private ZoomFunction<SimplifyMethod> simplifyMethod = null;
 
+    private GeometryPipeline defaultGeometryPipeline = null;
+    private ZoomFunction<GeometryPipeline> geometryPipelineByZoom = null;
+
     private String numPointsAttr = null;
     private List<OverrideCommand> partialOverrides = null;
 
@@ -740,6 +744,40 @@ public SimplifyMethod getSimplifyMethodAtZoom(int zoom) {
       return ZoomFunction.applyOrElse(simplifyMethod, zoom, defaultSimplifyMethod);
     }
 
+    /**
+     * Sets the default pipeline to apply to geometries scaled to tile coordinates right before emitting vector tile
+     * features. This function gets run instead of simplification, so should include any simplification if you want
+     * that.
+     * <p>
+     * Geometries will be in scaled tile coordinates, so {@code 0,0} is the northwest corner and {@code 2^z, 2^z} is the
+     * southeast corner of the world scaled to web mercator coordinates.
+     */
+    public Feature transformScaledGeometry(GeometryPipeline pipeline) {
+      this.defaultGeometryPipeline = pipeline;
+      return this;
+    }
+
+    /**
+     * Dynamically change the geometry pipeline to apply to geometries scaled to tile coordinates right before emitting
+     * vector tile features at each zoom level. These functions get run instead of simplification, so should include any
+     * simplification if you want that.
+     * <p>
+     * Geometries will be in scaled tile coordinates, so {@code 0,0} is the northwest corner and {@code 2^z, 2^z} is the
+     * southeast corner of the world scaled to web mercator coordinates.
+     */
+    public Feature transformScaledGeometryByZoom(ZoomFunction<GeometryPipeline> overrides) {
+      this.geometryPipelineByZoom = overrides;
+      return this;
+    }
+
+    /**
+     * Returns the geometry transform function to apply to scaled geometries at {@code zoom}, or null to not update them
+     * at all.
+     */
+    public GeometryPipeline getScaledGeometryTransformAtZoom(int zoom) {
+      return ZoomFunction.applyOrElse(geometryPipelineByZoom, zoom, defaultGeometryPipeline);
+    }
+
     /**
      * Sets the simplification tolerance for lines and polygons in tile pixels below the maximum zoom-level of the map.
      * <p>
@@ -1091,6 +1129,10 @@ Partial withAttr(String key, Object value) {
       return rangesWithGeometries;
     }
 
+    public SourceFeature source() {
+      return source;
+    }
+
 
     /**
      * A builder that can be used to configure linear-scoped attributes for a partial segment of a line feature.

planetiler-core/src/main/java/com/onthegomap/planetiler/FeatureMerge.java

@@ -6,6 +6,7 @@
 import com.onthegomap.planetiler.collection.Hppc;
 import com.onthegomap.planetiler.geo.GeoUtils;
 import com.onthegomap.planetiler.geo.GeometryException;
+import com.onthegomap.planetiler.geo.GeometryPipeline;
 import com.onthegomap.planetiler.geo.GeometryType;
 import com.onthegomap.planetiler.geo.MutableCoordinateSequence;
 import com.onthegomap.planetiler.stats.DefaultStats;
@@ -81,7 +82,7 @@ private FeatureMerge() {}
    */
   public static List<VectorTile.Feature> mergeLineStrings(List<VectorTile.Feature> features,
     double minLength, double tolerance, double buffer, boolean resimplify) {
-    return mergeLineStrings(features, attrs -> minLength, tolerance, buffer, resimplify);
+    return mergeLineStrings(features, attrs -> minLength, tolerance, buffer, resimplify, null);
   }
 
   /**
@@ -143,20 +144,22 @@ private static List<VectorTile.Feature> mergeGeometries(
   }
 
   /**
-   * Merges linestrings with the same attributes as {@link #mergeLineStrings(List, Function, double, double, boolean)}
-   * except sets {@code resimplify=false} by default.
+   * Merges linestrings with the same attributes as
+   * {@link #mergeLineStrings(List, Function, double, double, boolean, GeometryPipeline)} except sets
+   * {@code resimplify=false} by default.
    */
   public static List<VectorTile.Feature> mergeLineStrings(List<VectorTile.Feature> features,
     Function<Map<String, Object>, Double> lengthLimitCalculator, double tolerance, double buffer) {
-    return mergeLineStrings(features, lengthLimitCalculator, tolerance, buffer, false);
+    return mergeLineStrings(features, lengthLimitCalculator, tolerance, buffer, false, null);
   }
 
   /**
    * Merges linestrings with the same attributes as {@link #mergeLineStrings(List, double, double, double, boolean)}
    * except with a dynamic length limit computed by {@code lengthLimitCalculator} for the attributes of each group.
    */
   public static List<VectorTile.Feature> mergeLineStrings(List<VectorTile.Feature> features,
-    Function<Map<String, Object>, Double> lengthLimitCalculator, double tolerance, double buffer, boolean resimplify) {
+    Function<Map<String, Object>, Double> lengthLimitCalculator, double tolerance, double buffer, boolean resimplify,
+    GeometryPipeline pipeline) {
     List<VectorTile.Feature> result = new ArrayList<>(features.size());
     var groupedByAttrs = groupByAttrs(features, result, GeometryType.LINE);
     for (List<VectorTile.Feature> groupedFeatures : groupedByAttrs) {
@@ -176,7 +179,8 @@ public static List<VectorTile.Feature> mergeLineStrings(List<VectorTile.Feature>
           .setMergeStrokes(true)
           .setMinLength(lengthLimit)
           .setLoopMinLength(lengthLimit)
-          .setStubMinLength(0.5);
+          .setStubMinLength(0.5)
+          .setSegmentTransform(pipeline);
         for (VectorTile.Feature feature : groupedFeatures) {
           try {
             merger.add(feature.geometry().decode());
@@ -287,12 +291,15 @@ public static List<VectorTile.Feature> mergeOverlappingPolygons(List<VectorTile.
    * @param buffer      the amount (in tile pixels) to expand then contract polygons by in order to combine
    *                    almost-touching polygons
    * @param stats       for counting data errors
+   * @param pipeline    a transform that should be applied to each merged polygon in tile pixel coordinates where
+   *                    {@code 0,0} is the top-left and {@code 256,256} is the bottom-right corner of the tile
    * @return a new list containing all unaltered features in their original order, then each of the merged groups
    *         ordered by the index of the first element in that group from the input list.
    * @throws GeometryException if an error occurs encoding the combined geometry
    */
   public static List<VectorTile.Feature> mergeNearbyPolygons(List<VectorTile.Feature> features, double minArea,
-    double minHoleArea, double minDist, double buffer, Stats stats) throws GeometryException {
+    double minHoleArea, double minDist, double buffer, Stats stats, GeometryPipeline pipeline)
+    throws GeometryException {
     List<VectorTile.Feature> result = new ArrayList<>(features.size());
     Collection<List<VectorTile.Feature>> groupedByAttrs = groupByAttrs(features, result, GeometryType.POLYGON);
     for (List<VectorTile.Feature> groupedFeatures : groupedByAttrs) {
@@ -326,12 +333,26 @@ public static List<VectorTile.Feature> mergeNearbyPolygons(List<VectorTile.Featu
           if (!(merged instanceof Polygonal) || merged.getEnvelopeInternal().getArea() < minArea) {
             continue;
           }
+          if (pipeline != null) {
+            merged = pipeline.apply(merged);
+            if (!(merged instanceof Polygonal)) {
+              continue;
+            }
+          }
           merged = GeoUtils.snapAndFixPolygon(merged, stats, "merge").reverse();
         } else {
           merged = polygonGroup.getFirst();
           if (!(merged instanceof Polygonal) || merged.getEnvelopeInternal().getArea() < minArea) {
             continue;
           }
+          if (pipeline != null) {
+            Geometry after = pipeline.apply(merged);
+            if (!(after instanceof Polygonal)) {
+              continue;
+            } else if (after != merged) {
+              merged = GeoUtils.snapAndFixPolygon(after, stats, "merge_after_pipeline").reverse();
+            }
+          }
         }
         extractPolygons(merged, outPolygons, minArea, minHoleArea);
       }
@@ -354,7 +375,7 @@ private static <G extends Geometry> List<G> sortByHilbertIndex(List<G> geometrie
 
   public static List<VectorTile.Feature> mergeNearbyPolygons(List<VectorTile.Feature> features, double minArea,
     double minHoleArea, double minDist, double buffer) throws GeometryException {
-    return mergeNearbyPolygons(features, minArea, minHoleArea, minDist, buffer, DefaultStats.get());
+    return mergeNearbyPolygons(features, minArea, minHoleArea, minDist, buffer, DefaultStats.get(), null);
   }