Refactor the code and improve javadoc

Author: bchapuis

baremaps-cli/src/main/java/org/apache/baremaps/cli/raster/HillShade.java

@@ -104,7 +104,8 @@ public Integer call() throws Exception {
   public static class HillShadeTileStore implements TileStore {
 
     // private String url = "https://s3.amazonaws.com/elevation-tiles-prod/geotiff/{z}/{x}/{y}.tif";
-    private String url = "https://demotiles.maplibre.org/terrain-tiles/{z}/{x}/{y}.png";
+    // private String url = "https://demotiles.maplibre.org/terrain-tiles/{z}/{x}/{y}.png";
+    private String url = "https://s3.amazonaws.com/elevation-tiles-prod/terrarium/{z}/{x}/{y}.png";
 
     private final LoadingCache<TileCoord, BufferedImage> cache = Caffeine.newBuilder()
         .maximumSize(1000)

baremaps-raster/pom.xml

@@ -11,7 +11,10 @@
     <dependency>
       <groupId>com.twelvemonkeys.imageio</groupId>
       <artifactId>imageio-tiff</artifactId>
-      <version>3.11.0</version>
+    </dependency>
+    <dependency>
+      <groupId>org.locationtech.jts</groupId>
+      <artifactId>jts-core</artifactId>
     </dependency>
   </dependencies>
 </project>

baremaps-raster/src/main/java/org/apache/baremaps/raster/ImageUtils.java

@@ -21,24 +21,17 @@
 
 public class ImageUtils {
 
-
   public static double[] grid(BufferedImage image) {
-    int gridSize = image.getWidth();
-    double[] terrain = new double[gridSize * gridSize];
-
-    int tileSize = image.getWidth();
-
-    // decode terrain values
-    for (int y = 0; y < tileSize; y++) {
-      for (int x = 0; x < tileSize; x++) {
+    double[] grid = new double[image.getWidth() * image.getHeight()];
+    for (int y = 0; y < image.getHeight(); y++) {
+      for (int x = 0; x < image.getWidth(); x++) {
         int r = (image.getRGB(x, y) >> 16) & 0xFF;
         int g = (image.getRGB(x, y) >> 8) & 0xFF;
         int b = image.getRGB(x, y) & 0xFF;
-        terrain[y * gridSize + x] = (r * 256.0 * 256.0 + g * 256.0 + b) / 10.0 - 10000.0;
+        grid[y * image.getHeight() + x] = (r * 256.0 * 256.0 + g * 256.0 + b) / 10.0 - 10000.0;
       }
     }
-
-    return terrain;
+    return grid;
   }
 
 }

baremaps-raster/src/main/java/org/apache/baremaps/raster/contour/IsoLines.java

@@ -19,97 +19,193 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.operation.linemerge.LineMerger;
 
+/**
+ * Provides methods for generating isoline contours from digital elevation models (DEMs).
+ */
 public class IsoLines {
 
-  public record Point(double x, double y) {
-  }
+  private static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory();
+
+  private static final double EPSILON = 1e-10;
 
-  public record IsoLine(List<Point> points) {
+  private IsoLines() {
+    // Prevent instantiation
   }
 
-  public static List<IsoLine> isoLines(double[] grid, int gridSize, double level) {
-    List<IsoLine> isoLines = new ArrayList<>();
-    for (int y = 0; y < gridSize - 1; y++) {
-      for (int x = 0; x < gridSize - 1; x++) {
-        int index = (grid[y * (gridSize + 1) + x] > level ? 1 : 0) |
-            (grid[y * (gridSize + 1) + (x + 1)] > level ? 2 : 0) |
-            (grid[(y + 1) * (gridSize + 1) + (x + 1)] > level ? 4 : 0) |
-            (grid[(y + 1) * (gridSize + 1) + x] > level ? 8 : 0);
-        List<Point> points = new ArrayList<>();
-        switch (index) {
-          case 1:
-          case 14:
-            points.add(interpolate(x, y, x, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x, y, x + 1, y, grid, gridSize + 1, level));
-            break;
-          case 2:
-          case 13:
-            points.add(interpolate(x + 1, y, x, y, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y, x + 1, y + 1, grid, gridSize + 1, level));
-            break;
-          case 3:
-          case 12:
-            points.add(interpolate(x, y, x, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y, x + 1, y + 1, grid, gridSize + 1, level));
-            break;
-          case 4:
-          case 11:
-            points.add(interpolate(x + 1, y + 1, x + 1, y, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y + 1, x, y + 1, grid, gridSize + 1, level));
-            break;
-          case 5:
-            points.add(interpolate(x, y, x, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x, y + 1, x + 1, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y, x + 1, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y, x, y, grid, gridSize + 1, level));
-            break;
-          case 6:
-          case 9:
-            points.add(interpolate(x, y, x + 1, y, grid, gridSize + 1, level));
-            points.add(interpolate(x, y + 1, x + 1, y + 1, grid, gridSize + 1, level));
-            break;
-          case 7:
-          case 8:
-            points.add(interpolate(x, y, x, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x, y + 1, x + 1, y + 1, grid, gridSize + 1, level));
-            break;
-          case 10:
-            points.add(interpolate(x, y, x + 1, y, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y, x + 1, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x + 1, y + 1, x, y + 1, grid, gridSize + 1, level));
-            points.add(interpolate(x, y + 1, x, y, grid, gridSize + 1, level));
-            break;
-        }
-        if (!points.isEmpty()) {
-          isoLines.add(new IsoLine(points));
-        }
+  /**
+   * Generates isolines for a given grid at a specific level.
+   *
+   * @param grid The elevation data
+   * @param width The width of the grid
+   * @param height The height of the grid
+   * @param level The elevation level for which to generate isolines
+   * @param normalize Whether to normalize the coordinates
+   * @return A list of LineString objects representing the isolines
+   */
+  public static List<LineString> generateIsoLines(
+      double[] grid, int width, int height,
+      double level, boolean normalize) {
+    validateInput(grid, width, height);
+    List<LineString> lineStrings = new ArrayList<>();
+    for (int y = 0; y < height - 1; y++) {
+      for (int x = 0; x < width - 1; x++) {
+        processCell(grid, width, height, level, normalize, lineStrings, y, x);
       }
     }
-    return isoLines;
+    return mergeLineStrings(lineStrings);
   }
 
-  public static List<IsoLine> isoLines(double[] grid, int gridSize, int start, int end,
-      int interval) {
-    List<IsoLine> isoLines = new ArrayList<>();
-    for (int level = start; level < end; level++) {
-      isoLines.addAll(isoLines(grid, gridSize, level));
+  /**
+   * Generates isolines for a given grid at multiple levels within a specified range.
+   *
+   * @param grid The elevation data
+   * @param width The width of the grid
+   * @param height The height of the grid
+   * @param start The starting elevation level
+   * @param end The ending elevation level
+   * @param interval The interval between elevation levels
+   * @param normalize Whether to normalize the coordinates
+   * @return A list of LineString objects representing the isolines
+   */
+  public static List<LineString> generateIsoLines(
+      double[] grid, int width, int height,
+      int start, int end, int interval,
+      boolean normalize) {
+    validateInput(grid, width, height);
+    List<LineString> isoLines = new ArrayList<>();
+    for (int level = start; level < end; level += interval) {
+      isoLines.addAll(generateIsoLines(grid, width, height, level, normalize));
     }
     return isoLines;
   }
 
-  private static Point interpolate(
-      int x1,
-      int y1,
-      int x2,
-      int y2,
-      double[] grid,
-      int width,
-      double level) {
+  private static List<LineString> mergeLineStrings(List<LineString> lineStrings) {
+    LineMerger lineMerger = new LineMerger();
+    lineMerger.add(lineStrings);
+    return new ArrayList<>(lineMerger.getMergedLineStrings());
+  }
+
+  private static void validateInput(double[] grid, int width, int height) {
+    if (grid == null || grid.length == 0) {
+      throw new IllegalArgumentException("Grid array cannot be null or empty");
+    }
+    if (width <= 0 || height <= 0) {
+      throw new IllegalArgumentException("Width and height must be positive");
+    }
+    if (grid.length != width * height) {
+      throw new IllegalArgumentException("Grid array length does not match width * height");
+    }
+  }
+
+  private static void processCell(
+      double[] grid, int width, int height,
+      double level, boolean normalize, List<LineString> lineStrings,
+      int y, int x) {
+    double tl = grid[y * width + x];
+    double tr = grid[y * width + (x + 1)];
+    double br = grid[(y + 1) * width + (x + 1)];
+    double bl = grid[(y + 1) * width + x];
+
+    int index =
+        (tl > level ? 1 : 0) |
+            (tr > level ? 2 : 0) |
+            (br > level ? 4 : 0) |
+            (bl > level ? 8 : 0);
+
+    switch (index) {
+      case 1:
+      case 14:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x + 1, y,
+            x, y + 1, x, y);
+        break;
+      case 2:
+      case 13:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x + 1, y, x, y,
+            x + 1, y, x + 1, y + 1);
+        break;
+      case 3:
+      case 12:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x, y + 1,
+            x + 1, y, x + 1, y + 1);
+        break;
+      case 4:
+      case 11:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x + 1, y + 1, x + 1, y,
+            x + 1, y + 1, x, y + 1);
+        break;
+      case 5:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x, y + 1,
+            x, y + 1, x + 1, y + 1);
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x + 1, y, x + 1, y + 1,
+            x + 1, y, x, y);
+        break;
+      case 6:
+      case 9:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x + 1, y,
+            x, y + 1, x + 1, y + 1);
+        break;
+      case 7:
+      case 8:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x, y + 1,
+            x, y + 1, x + 1, y + 1);
+        break;
+      case 10:
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x, y, x + 1, y,
+            x + 1, y, x + 1, y + 1);
+        createLineString(
+            grid, width, height, level, normalize, lineStrings,
+            x + 1, y + 1, x, y + 1,
+            x, y + 1, x, y);
+        break;
+    }
+  }
+
+  private static void createLineString(
+      double[] grid, int width, int height,
+      double level, boolean normalize, List<LineString> lineStrings,
+      int x1, int y1, int x2, int y2,
+      int x3, int y3, int x4, int y4) {
+    Coordinate c1 = interpolate(grid, width, height, level, normalize, x1, y1, x2, y2);
+    Coordinate c2 = interpolate(grid, width, height, level, normalize, x3, y3, x4, y4);
+    lineStrings.add(GEOMETRY_FACTORY.createLineString(new Coordinate[] {c1, c2}));
+  }
+
+  private static Coordinate interpolate(
+      double[] grid, int width, int height,
+      double level, boolean normalize,
+      int x1, int y1, int x2, int y2) {
     double v1 = grid[y1 * width + x1];
     double v2 = grid[y2 * width + x2];
-    double t = (level - v1) / (v2 - v1);
-    return new Point(x1 + t * (x2 - x1), y1 + t * (y2 - y1));
+    double t = (Math.abs(v2 - v1) < EPSILON) ? 0.5 : (level - v1) / (v2 - v1);
+    double x = x1 + t * (x2 - x1);
+    double y = y1 + t * (y2 - y1);
+    if (normalize) {
+      x = x / (width - 1) * width;
+      y = y / (height - 1) * height;
+    }
+    return new Coordinate(x, y);
   }
-
 }