Align setting of brunnel (and layer) tags for brunnel features depending on their length and zoom level

src/main/java/org/openmaptiles/layers/Park.java

@@ -100,9 +100,9 @@ public void process(Tables.OsmParkPolygon element, FeatureCollector features) {
         protectionTitle = protectionTitle.replace(' ', '_').toLowerCase(Locale.ROOT);
       }
       clazz = coalesce(
-          nullIfEmpty(protectionTitle),
-          nullIfEmpty(element.boundary()),
-          nullIfEmpty(element.leisure())
+        nullIfEmpty(protectionTitle),
+        nullIfEmpty(element.boundary()),
+        nullIfEmpty(element.leisure())
       );
     }
 

src/main/java/org/openmaptiles/layers/Poi.java

@@ -61,7 +61,6 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Consumer;
-import org.locationtech.jts.geom.Geometry;
 import org.locationtech.jts.geom.Point;
 import org.openmaptiles.OpenMapTilesProfile;
 import org.openmaptiles.generated.OpenMapTilesSchema;
@@ -156,7 +155,7 @@ private int minzoom(String subclass, String mappingKey) {
 
   public static int uniAreaToMinZoom(double areaWorld) {
     double oneSideWorld = Math.sqrt(areaWorld);
-    // full(-er) formula (along with comments) is in PoiTest.testUniAreaToMinZoom(), here is simplified reverse of that
+    // adjusted formula from `Utils.getMinZoomForLength()`, given that 1/10 does not match `1 / (2^<something>)`
     double zoom = -(Math.log(oneSideWorld * SQRT10) / LOG2);
 
     // Say Z13.01 means bellow threshold, Z13.00 is exactly threshold, Z12.99 is over threshold,

src/main/java/org/openmaptiles/layers/Transportation.java

@@ -74,6 +74,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 import org.openmaptiles.OpenMapTilesProfile;
 import org.openmaptiles.generated.OpenMapTilesSchema;
 import org.openmaptiles.generated.Tables;
+import org.openmaptiles.util.Utils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -155,6 +156,8 @@ public class Transportation implements
     .put(6, 100)
     .put(5, 500)
     .put(4, 1_000);
+  // "shipway_linestring_gen_z5: ... tolerance: ZRES6", etc. when recalculated from meters to pixels is always:
+  private static final double FERRY_TOLERANCE = 0.5;
   // ORDER BY network_type, network, LENGTH(ref), ref)
   private static final Comparator<RouteRelation> RELATION_ORDERING = Comparator
     .<RouteRelation>comparingInt(
@@ -163,11 +166,11 @@ public class Transportation implements
     .thenComparingInt(r -> r.ref().length())
     .thenComparing(RouteRelation::ref);
   private static final Set<Integer> ONEWAY_VALUES = Set.of(-1, 1);
+  private final Map<String, Integer> MINZOOMS;
   private static final String LIMIT_MERGE_TAG = "__limit_merge";
   private final AtomicBoolean loggedNoGb = new AtomicBoolean(false);
   private final AtomicBoolean loggedNoIreland = new AtomicBoolean(false);
   private final boolean z13Paths;
-  private final Map<String, Integer> MINZOOMS;
   private final Stats stats;
   private final PlanetilerConfig config;
   private PreparedGeometry greatBritain = null;
@@ -449,6 +452,9 @@ public void process(Tables.OsmHighwayLinestring element, FeatureCollector featur
       }
       int minzoom = getMinzoom(element, highwayClass);
 
+      String brunnelValue = brunnel(element.isBridge(), element.isTunnel(), element.isFord());
+      int brunnelMinzoom = brunnelValue != null ? getBrunnelMinzoom(element) : minzoom;
+
       if (minzoom > config.maxzoom()) {
         return;
       }
@@ -462,13 +468,11 @@ public void process(Tables.OsmHighwayLinestring element, FeatureCollector featur
         .setAttr(Fields.CLASS, highwayClass)
         .setAttr(Fields.SUBCLASS, highwaySubclass(highwayClass, element.publicTransport(), highway))
         .setAttr(Fields.NETWORK, networkType != null ? networkType.name : null)
-        // TODO: including brunnel at low zooms leads to some large 300-400+kb z4-7 tiles, instead
-        //       we should only set brunnel if the line is above a certain length
-        .setAttr(Fields.BRUNNEL, brunnel(element.isBridge(), element.isTunnel(), element.isFord()))
+        .setAttrWithMinzoom(Fields.BRUNNEL, brunnelValue, brunnelMinzoom)
         // z8+
         .setAttrWithMinzoom(Fields.EXPRESSWAY, element.expressway() && !"motorway".equals(highway) ? 1 : null, 8)
         // z9+
-        .setAttrWithMinzoom(Fields.LAYER, nullIfLong(element.layer(), 0), 9)
+        .setAttrWithMinzoom(Fields.LAYER, nullIfLong(element.layer(), 0), brunnelValue == null ? 9 : brunnelMinzoom)
         .setAttrWithMinzoom(Fields.BICYCLE, nullIfEmpty(element.bicycle()), 9)
         .setAttrWithMinzoom(Fields.FOOT, nullIfEmpty(element.foot()), 9)
         .setAttrWithMinzoom(Fields.HORSE, nullIfEmpty(element.horse()), 9)
@@ -534,6 +538,17 @@ int getMinzoom(Tables.OsmHighwayLinestring element, String highwayClass) {
     return minzoom;
   }
 
+  int getBrunnelMinzoom(Tables.OsmHighwayLinestring element) {
+    try {
+      return Utils.getClippedMinZoomForLength(element.source().length(), 6, 9, 12);
+    } catch (GeometryException e) {
+      e.log(stats, "omt_brunnel_minzoom",
+        "Unable to calculate brunnel minzoom for " + element.source().id());
+      // brunnel is optional (depends on feature size) for Z9-Z11, it is always present for Z12+, hence 12 as fallback
+      return 12;
+    }
+  }
+
   private boolean isPierPolygon(Tables.OsmHighwayLinestring element) {
     if ("pier".equals(element.manMade())) {
       try {
@@ -609,7 +624,18 @@ public void process(Tables.OsmShipwayLinestring element, FeatureCollector featur
       .setAttr(Fields.LAYER, nullIfLong(element.layer(), 0))
       .setSortKey(element.zOrder())
       .setMinPixelSize(0) // merge during post-processing, then limit by size
-      .setMinZoom(11);
+      .setMinZoom(getFerryMinzoom(element));
+  }
+
+  int getFerryMinzoom(Tables.OsmShipwayLinestring element) {
+    try {
+      return Utils.getClippedMinZoomForLength(element.source().length(), 3, 4, 11);
+    } catch (GeometryException e) {
+      e.log(stats, "omt_ferry_minzoom",
+        "Unable to calculate ferry minzoom for " + element.source().id());
+      // ferries are supposed to be included in Z4-Z10 depending on their length (=this min. zoom calculation), for Z11+ always, hence 11 as fallback
+      return 11;
+    }
   }
 
   @Override
@@ -632,9 +658,7 @@ public void process(Tables.OsmHighwayPolygon element, FeatureCollector features)
     }
   }
 
-  @Override
-  public List<VectorTile.Feature> postProcess(int zoom, List<VectorTile.Feature> items) {
-    double tolerance = config.tolerance(zoom);
+  private List<VectorTile.Feature> postProcessItems(int zoom, List<VectorTile.Feature> items, double tolerance) {
     double minLength = coalesce(MIN_LENGTH.apply(zoom), 0).doubleValue();
 
     // don't merge road segments with oneway tag
@@ -655,6 +679,36 @@ public List<VectorTile.Feature> postProcess(int zoom, List<VectorTile.Feature> i
     return merged;
   }
 
+  private List<VectorTile.Feature> postProcessAllOrNonFerry(int zoom, List<VectorTile.Feature> items) {
+    // TODO: use same tolerance as for ferries (see tolerances in OMT `transportation/mapping.yaml`), hence no need to split ferries from the rest in postProcess()
+    return postProcessItems(zoom, items, config.tolerance(zoom));
+  }
+
+  private List<VectorTile.Feature> postProcessFerry(int zoom, List<VectorTile.Feature> items) {
+    return postProcessItems(zoom, items, FERRY_TOLERANCE);
+  }
+
+  @Override
+  public List<VectorTile.Feature> postProcess(int zoom, List<VectorTile.Feature> items) {
+    if (zoom < 4 || zoom > 10) {
+      return postProcessAllOrNonFerry(zoom, items);
+    } else {
+      // ferries at Z4-Z10 need different treatment
+      List<VectorTile.Feature> ferryItems = new ArrayList<>();
+      List<VectorTile.Feature> otherItems = new ArrayList<>();
+      for (var item : items) {
+        if (FieldValues.CLASS_FERRY.equals(item.attrs().get(Fields.CLASS))) {
+          ferryItems.add(item);
+        } else {
+          otherItems.add(item);
+        }
+      }
+      var result = postProcessFerry(zoom, ferryItems);
+      result.addAll(postProcessAllOrNonFerry(zoom, otherItems));
+      return result;
+    }
+  }
+
   enum RouteNetwork {
 
     US_INTERSTATE("us-interstate"),

src/main/java/org/openmaptiles/layers/TransportationName.java

@@ -284,7 +284,9 @@ public void process(Tables.OsmHighwayLinestring element, FeatureCollector featur
     }
 
     if (brunnel) {
-      feature.setAttr(Fields.BRUNNEL, brunnel(element.isBridge(), element.isTunnel(), element.isFord()));
+      String brunnelValue = brunnel(element.isBridge(), element.isTunnel(), element.isFord());
+      int brunnelMinzoom = brunnelValue != null ? transportation.getBrunnelMinzoom(element) : minzoom;
+      feature.setAttrWithMinzoom(Fields.BRUNNEL, brunnelValue, brunnelMinzoom);
     }
 
     /*

src/main/java/org/openmaptiles/layers/WaterName.java

@@ -56,6 +56,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 import org.openmaptiles.generated.OpenMapTilesSchema;
 import org.openmaptiles.generated.Tables;
 import org.openmaptiles.util.OmtLanguageUtils;
+import org.openmaptiles.util.Utils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,7 +83,6 @@ public class WaterName implements
    */
 
   private static final Logger LOGGER = LoggerFactory.getLogger(WaterName.class);
-  private static final double LOG2 = Math.log(2);
   private static final Set<String> SEA_OR_OCEAN_PLACE = Set.of("sea", "ocean");
   private final Translations translations;
   // need to synchronize updates from multiple threads
@@ -227,14 +227,7 @@ public void process(Tables.OsmWaterPolygon element, FeatureCollector features) {
 
   public static int areaToMinZoom(double areaWorld) {
     double oneSideWorld = Math.sqrt(areaWorld);
-    // full(-er) formula (along with comments) is in WaterNameTest.testAreaToMinZoom(), here is simplified reverse of that
-    double zoom = -(Math.log(oneSideWorld) / LOG2) - 1;
-
-    // Say Z13.01 means bellow threshold, Z13.00 is exactly threshold, Z12.99 is over threshold,
-    // hence Z13.01 and Z13.00 will be rounded to Z14 and Z12.99 to Z13 (e.g. `floor() + 1`).
-    // And to accommodate for some precision errors (observed for Z9-Z11) we do also `- 0.1e-11`.
-    int result = (int) Math.floor(zoom - 0.1e-11) + 1;
-
-    return Math.min(14, Math.max(3, result));
+    // OMT does "feature area is 1/4 of tile area", which is same as "feature side is 1/2 of tile side"
+    return Utils.getClippedMinZoomForLength(oneSideWorld, 1, 3, 14);
   }
 }

src/main/java/org/openmaptiles/util/Utils.java

@@ -8,6 +8,8 @@
  */
 public class Utils {
 
+  private static final double LOG2 = Math.log(2);
+
   public static <T> T coalesce(T a, T b) {
     return a != null ? a : b;
   }
@@ -75,4 +77,43 @@ public static String brunnel(boolean isBridge, boolean isTunnel, boolean isFord)
     return isBridge ? "bridge" : isTunnel ? "tunnel" : isFord ? "ford" : null;
   }
 
+  /**
+   * Calculate minzoom for a feature with given length based on threshold: if a feature's length is least
+   * {@code 1 / (2^threshold)} of a tile at certain zoom level, it will be shown at that and higher zoom levels, e.g.
+   * that particular zoom level is minzoom.
+   * <p>
+   * {@code threshold} is calculated in such way to avoid calculating log(2) os it during the runtime. Use 1 for 1/2, 2
+   * for 1/4, 3 for 1/8, etc.
+   * 
+   * @param length    length of the feature
+   * @param threshold threshold
+   * @return minzoom for a feature with given length and given threshold
+   */
+  public static int getMinZoomForLength(double length, double threshold) {
+    // Say threshold is 1/8 (threshold variable = 8) of tile size, hence ...
+    // ... from pixels to world coord, for say Z14, the minimum length is:
+    //  PORTION_OF_TILE_SIDE = (256d / 8) / Math.pow(2d, 14d + 8d);
+    // ... and then minimum length for some lower zoom:
+    //  PORTION_OF_TILE_SIDE * Math.pow(2, 14 - zoom);
+    // all this then reversed and simplified to:
+    double zoom = -(Math.log(length) / LOG2) - threshold;
+
+    // Say Z13.01 means bellow threshold, Z13.00 is exactly threshold, Z12.99 is over threshold,
+    // hence Z13.01 and Z13.00 will be rounded to Z14 and Z12.99 to Z13 (e.g. `floor() + 1`).
+    // And to accommodate for some precision errors (observed for Z9-Z11) we do also `- 0.1e-10`.
+    return (int) Math.floor(zoom - 0.1e-10) + 1;
+  }
+
+  /**
+   * Same as {@link #getMinZoomForLength(double, double)} but with result within the given minimum and maximim.
+   * 
+   * @param length    length of the feature
+   * @param threshold threshold
+   * @param min       clip the result to this value if lower
+   * @param max       clip the result to this value if higher
+   * @return minzoom for a feature with given length and given threshold clipped to not exceed given minimum and maximum
+   */
+  public static int getClippedMinZoomForLength(double length, double threshold, int min, int max) {
+    return Math.min(max, Math.max(min, getMinZoomForLength(length, threshold)));
+  }
 }

src/test/java/org/openmaptiles/layers/AbstractLayerTest.java

@@ -137,6 +137,16 @@ SourceFeature lineFeature(Map<String, Object> props) {
     );
   }
 
+  SourceFeature lineFeatureWithLength(double length, Map<String, Object> props) {
+    return SimpleFeature.create(
+      GeoUtils.worldToLatLonCoords(newLineString(0, 0, 0, length)),
+      new HashMap<>(props),
+      OpenMapTilesProfile.OSM_SOURCE,
+      null,
+      0
+    );
+  }
+
   SourceFeature closedWayFeature(Map<String, Object> props) {
     return SimpleFeature.createFakeOsmFeature(
       newLineString(0, 0, 1, 0, 1, 1, 0, 1, 0, 0),

src/test/java/org/openmaptiles/layers/ParkTest.java

@@ -48,24 +48,24 @@ void testNationalPark() {
   @Test
   void testAbotiginalLand() {
     assertFeatures(13, List.of(Map.of(
-        "_layer", "park",
-        "_type", "polygon",
-        "class", "aboriginal_lands",
-        "name", "Hualapai Tribe",
-        "_minpixelsize", 2d,
-        "_minzoom", 4,
-        "_maxzoom", 14
+      "_layer", "park",
+      "_type", "polygon",
+      "class", "aboriginal_lands",
+      "name", "Hualapai Tribe",
+      "_minpixelsize", 2d,
+      "_minzoom", 4,
+      "_maxzoom", 14
     ), Map.of(
-        "_layer", "park",
-        "_type", "point",
-        "class", "aboriginal_lands",
-        "name", "Hualapai Tribe",
-        "_minzoom", 5,
-        "_maxzoom", 14
+      "_layer", "park",
+      "_type", "point",
+      "class", "aboriginal_lands",
+      "name", "Hualapai Tribe",
+      "_minzoom", 5,
+      "_maxzoom", 14
     )), process(polygonFeature(Map.of(
-        "boundary", "aboriginal_lands",
-        "name", "Hualapai Tribe",
-        "protection_title", "National Park"
+      "boundary", "aboriginal_lands",
+      "name", "Hualapai Tribe",
+      "protection_title", "National Park"
     ))));
   }