geogrid 1.2.0 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geogrid",
-  "version": "1.2.0",
+  "version": "1.2.4",
   "description": "Regular and irregular geoJSON grids ",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -52,9 +52,8 @@
     "d3-geo": "^3.1.1",
     "d3-geo-projection": "^4.0.0",
     "d3-geo-voronoi": "^2.1.0",
-    "docs": "^0.3.2-canary.0",
-    "documentation": "^14.0.3",
-    "geojson2h3": "^1.2.0",
+    "geojson2h3": "1.2.0",
+    "geotoolbox": "^3.2.0",
     "h3-js": "^4.1.0",
     "martinez-polygon-clipping": "^0.7.4",
     "rbush": "^4.0.1",
@@ -63,11 +62,13 @@
     "s2js": "^1.43.6"
   },
   "devDependencies": {
+    "@babel/preset-env": "^7.29.2",
     "@jood/jsdoc-theme": "^0.1.14",
+    "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.3",
+    "@rollup/plugin-terser": "^1.0.0",
     "clean-jsdoc-theme": "^4.2.17",
     "docdash": "^2.0.1",
     "jsdoc": "^4.0.2",

package/src/grid/square_sph.js

@@ -1,94 +1,91 @@
-import { createSteppedArray } from "../helpers/createSteppedArray.js";
 import booleanIntersects from "@turf/boolean-intersects";
 
 /**
  * @function square_sph
- * @summary Compute a square grid in WGS84 degrees.
- * @description Builds a square grid in latitude/longitude degrees,
- * avoids coordinates exactly at ±180 or ±90 to prevent rewind issues.
+ * @summary Build a global square grid in lon/lat.
+ * @description
+ * Generates a grid of square polygons covering the whole globe in WGS84 coordinates.
+ * - Longitudes: start at -180, add `step` until reaching +180 (last cell may be smaller)
+ * - Latitudes: start at +90, subtract `step` until reaching -90 (last cell may be smaller)
+ * - Cells never overlap; borders align exactly
+ * - EPS is used to avoid coordinates exactly at ±180 and ±90 to prevent rewind/topology issues
+ *
  * @param {object} options
- * @param {number[]} [options.start=[-180, -90]] - Starting coordinates [lon, lat].
- * @param {number} [options.width=360] - Width of the grid in degrees (longitude span).
- * @param {number} [options.height=180] - Height of the grid in degrees (latitude span).
- * @param {number} [options.step=1] - Step size in degrees.
- * @param {GeoJSON.Feature|GeoJSON.FeatureCollection|GeoJSON.Geometry} [options.domain] -
- *   Optional GeoJSON object. Only cells that intersect this domain are kept.
- * @returns {GeoJSON.FeatureCollection} A GeoJSON FeatureCollection of polygons.
+ * @param {number} [options.step=1] - Grid cell size in degrees
+ * @param {GeoJSON} [options.domain=null] - Optional GeoJSON mask; only intersecting cells are kept
+ * @returns {GeoJSON.FeatureCollection} A FeatureCollection of square polygons
  */
-export function square_sph({
-  start = [-180, -90],
-  width = 360,
-  height = 180,
-  step = 1,
-  domain = null,
-} = {}) {
+export function square_sph({ step = 1, domain = null } = {}) {
   const LON_MIN = -180;
   const LON_MAX = 180;
   const LAT_MIN = -90;
   const LAT_MAX = 90;
-  const EPS = 1e-2; // petit décalage pour éviter ±180 et ±90 exacts
+  const EPS = 1e-2; // small offset to avoid exact ±180/±90 coordinates
 
-  const lonStart = Math.max(LON_MIN, start[0]);
-  const latStart = Math.max(LAT_MIN, start[1]);
-  const lonEnd = Math.min(LON_MAX, start[0] + width);
-  const latEnd = Math.min(LAT_MAX, start[1] + height);
-
-  let x = createSteppedArray(lonStart + step / 2, lonEnd - step / 2, step);
-  let y = createSteppedArray(
-    latStart + step / 2,
-    latEnd - step / 2,
-    step,
-    true
-  );
+  if (step <= 0) throw new Error("step must be > 0");
 
   const features = [];
-  let i = 0;
+  let index = 0;
+
+  // --- Longitudes: from -180 (west) to +180 (east), incrementing by step ---
+  let lonWest = LON_MIN;
+  while (lonWest < LON_MAX - 1e-12) {
+    let lonEast = lonWest + step;
+    if (lonEast > LON_MAX) lonEast = LON_MAX;
 
-  for (const lon of x) {
-    for (const lat of y) {
-      // coins initiaux
-      let lonWest = lon - step / 2;
-      let lonEast = lon + step / 2;
-      let latSouth = lat - step / 2;
-      let latNorth = lat + step / 2;
+    // Apply EPS to avoid exact ±180
+    const lonW = Math.max(lonWest, LON_MIN + EPS);
+    const lonE = Math.min(lonEast, LON_MAX - EPS);
 
-      // remplacer ±180 et ±90 par des valeurs légèrement inférieures/supérieures
-      if (lonWest <= LON_MIN) lonWest = LON_MIN + EPS;
-      if (lonEast >= LON_MAX) lonEast = LON_MAX - EPS;
-      if (latSouth <= LAT_MIN) latSouth = LAT_MIN + EPS;
-      if (latNorth >= LAT_MAX) latNorth = LAT_MAX - EPS;
+    // --- Latitudes: from +90 (north) to -90 (south), decrementing by step ---
+    let latNorth = LAT_MAX;
+    while (latNorth > LAT_MIN + 1e-12) {
+      let latSouth = latNorth - step;
+      if (latSouth < LAT_MIN) latSouth = LAT_MIN;
 
-      features.push({
-        type: "Feature",
-        geometry: {
-          type: "Polygon",
-          coordinates: [
-            [
-              [lonWest, latNorth],
-              [lonEast, latNorth],
-              [lonEast, latSouth],
-              [lonWest, latSouth],
-              [lonWest, latNorth],
+      // Apply EPS to avoid exact ±90
+      const latN = Math.min(latNorth, LAT_MAX - EPS);
+      const latS = Math.max(latSouth, LAT_MIN + EPS);
+
+      // Skip degenerate cells (can happen with EPS near poles)
+      if (lonE - lonW > 1e-12 && latN - latS > 1e-12) {
+        features.push({
+          type: "Feature",
+          geometry: {
+            type: "Polygon",
+            coordinates: [
+              [
+                [lonW, latN],
+                [lonE, latN],
+                [lonE, latS],
+                [lonW, latS],
+                [lonW, latN],
+              ],
             ],
-          ],
-        },
-        properties: { index: i++ },
-      });
+          },
+          properties: { index: index++ },
+        });
+      }
+
+      // Move to the next row (southward)
+      latNorth = latSouth;
     }
-  }
 
-  // Domain
-  let filtered = features;
-  if (domain) {
-    filtered = features.filter((f) => {
-      try {
-        return booleanIntersects(f, domain);
-      } catch {
-        return false;
-      }
-    });
+    // Move to the next column (eastward)
+    lonWest = lonEast;
   }
 
+  // --- Optional filtering by domain ---
+  const filtered = domain
+    ? features.filter((f) => {
+        try {
+          return booleanIntersects(f, domain);
+        } catch {
+          return false;
+        }
+      })
+    : features;
+
   return {
     type: "FeatureCollection",
     grid: "square_sph",

package/src/operator/linestogrid.js

@@ -1,24 +1,17 @@
 import { bbox } from "@turf/bbox";
 import { lineSplit } from "@turf/line-split";
 import { length } from "@turf/length";
+import { booleanWithin } from "@turf/boolean-within";
 import { stitchmerge } from "../helpers/stitchmerge.js";
 import { unstitch } from "../helpers/unstitch.js";
 import RBush from "rbush";
 
 /**
  * @function linestogrid
- * @description Assign lines to a grid and compute weighted sums per cell.
- *              Uses a spatial index to speed up calculations.
- *              Optimized and removes cells with count = 0.
- *              Supports multiple variables in varField (string or array of strings)
- *              Treats undefined or NaN as zero when summing
- *              If `values` is true, stores an array of intersected line properties
- * @param {object} opts
- * @property {object} [lines] - GeoJSON lines to assign
- * @property {object} [grid] - GeoJSON grid
- * @property {string|Array} [var] - Field(s) to compute weighted sums (optional)
- * @property {boolean} [values=false] - Include array of raw lines properties
+ * @description Assign lines (LineString or MultiLineString) to a grid and compute weighted sums per cell.
+ *              MultiLineStrings are treated as a single feature for count and proportional distribution.
  */
+
 export function linestogrid(opts = {}) {
   let {
     grid,
@@ -26,36 +19,49 @@ export function linestogrid(opts = {}) {
     var: varField,
     values: includeValues = false,
     spherical = false,
+    debug = false,
   } = opts;
 
   const t0 = performance.now();
 
-  // Unstitch grids if needed
-  if (spherical) {
-    grid = unstitch(grid);
-  }
+  if (spherical) grid = unstitch(grid);
 
-  // --- Normalize varField to array ---
   const varFields = varField
     ? Array.isArray(varField)
       ? varField
       : [varField]
     : [];
 
-  // --- 1. Compute total lengths for lines and initialize grid cells ---
-  for (const line of lines.features) {
-    line.properties.length_total = length(line, { units: "meters" });
+  // --- Add stable ID to grid cells ---
+  grid.features.forEach((cell, i) => (cell._id = i));
+
+  // --- Compute total length per line feature ---
+  for (const f of lines.features) {
+    if (f.geometry.type === "LineString") {
+      f.properties.length_total = length(f, { units: "meters" });
+    } else if (f.geometry.type === "MultiLineString") {
+      let total = 0;
+      for (const coords of f.geometry.coordinates) {
+        const part = {
+          type: "Feature",
+          geometry: { type: "LineString", coordinates: coords },
+        };
+        total += length(part, { units: "meters" });
+      }
+      f.properties.length_total = total;
+    } else {
+      f.properties.length_total = 0;
+    }
   }
 
+  // --- Initialize grid cells ---
   for (const cell of grid.features) {
     cell.properties.count = 0;
-    for (const v of varFields) {
-      cell.properties[v] = 0;
-    }
+    for (const v of varFields) cell.properties[v] = 0;
     if (includeValues) cell.properties.values = [];
   }
 
-  // --- 2. Build spatial index (RBush) on the grid ---
+  // --- Build spatial index ---
   const tree = new RBush();
   const items = grid.features.map((cell) => {
     const [minX, minY, maxX, maxY] = bbox(cell);
@@ -63,53 +69,100 @@ export function linestogrid(opts = {}) {
   });
   tree.load(items);
 
-  // --- 3. Loop over lines ---
-  for (const line of lines.features) {
-    const [minX, minY, maxX, maxY] = bbox(line);
+  // --- Track counted features for debug ---
+  const countedLines = new Set();
+
+  // --- Process each line feature ---
+  for (const f of lines.features) {
+    const totalLength = f.properties.length_total || 0;
+    if (totalLength === 0) continue;
+
+    const [minX, minY, maxX, maxY] = bbox(f);
     const candidates = tree.search({ minX, minY, maxX, maxY });
+    const touched = new Set();
+    let totalSegLen = 0;
 
     for (const cand of candidates) {
       const cell = cand.cell;
+      let segLen = 0;
+
+      if (f.geometry.type === "LineString") {
+        segLen = safeSegLength(f, cell);
+      } else if (f.geometry.type === "MultiLineString") {
+        for (const coords of f.geometry.coordinates) {
+          const part = {
+            type: "Feature",
+            geometry: { type: "LineString", coordinates: coords },
+          };
+          segLen += safeSegLength(part, cell);
+        }
+      }
 
-      // split line by cell polygon
-      const splitLines = lineSplit(line, cell);
-      if (!splitLines.features.length) continue;
+      if (segLen === 0) continue;
+      totalSegLen += segLen;
 
-      // compute total length of segments inside the cell
-      let totalSegLength = 0;
-      for (const seg of splitLines.features) {
-        totalSegLength += length(seg, { units: "meters" });
+      if (!touched.has(cell._id)) {
+        cell.properties.count += 1;
+        touched.add(cell._id);
       }
-      if (totalSegLength === 0) continue;
-
-      // --- update cell statistics ---
-      cell.properties.count += 1; // one line per cell
 
       for (const v of varFields) {
-        const value = parseFloat(line.properties[v]);
+        const value = parseFloat(f.properties[v]);
         cell.properties[v] += !isNaN(value)
-          ? value * (totalSegLength / line.properties.length_total)
+          ? value * (segLen / totalLength)
           : 0;
       }
 
-      if (includeValues) {
-        cell.properties.values.push({ ...line.properties });
-      }
+      if (includeValues) cell.properties.values.push({ ...f.properties });
     }
+
+    if (totalSegLen > 0) countedLines.add(f.properties.id || f.id || f);
   }
 
-  // --- 4. Filter out cells with count == 0 ---
+  // --- Filter empty cells ---
   const filteredGrid = {
     ...grid,
-    features: grid.features.filter((cell) => cell.properties.count > 0),
+    features: grid.features.filter((c) => c.properties.count > 0),
   };
 
   const t1 = performance.now();
   console.log(
-    `Line intersection completed for ${filteredGrid.features.length} cells — ${(
+    `Line aggregation completed for ${filteredGrid.features.length} cells — ${(
       t1 - t0
     ).toFixed(2)} ms`
   );
 
+  // --- Debug report ---
+  if (debug) {
+    const totalLines = lines.features.length;
+    const missing = totalLines - countedLines.size;
+    console.log(
+      `Counted ${countedLines.size}/${totalLines} line features (${missing} missing)`
+    );
+  }
+
   return spherical ? stitchmerge(filteredGrid) : filteredGrid;
 }
+
+/**
+ * @function safeSegLength
+ * @description Returns total segment length of intersection between a line and polygon cell,
+ *              including case where line is entirely contained in the cell.
+ */
+function safeSegLength(line, cell) {
+  try {
+    if (booleanWithin(line, cell)) {
+      return length(line, { units: "meters" });
+    }
+
+    const split = lineSplit(line, cell);
+    let sum = 0;
+    for (const s of split.features) {
+      const l = length(s, { units: "meters" });
+      if (l > 0.001) sum += l; // ignore sub-mm artifacts
+    }
+    return sum;
+  } catch (e) {
+    return 0;
+  }
+}