geogrid 1.1.1 → 1.2.2

package/src/operator/polygonstogrid.js

@@ -1,34 +1,43 @@
 import { bbox } from "@turf/bbox";
 import { intersect } from "@turf/intersect";
+import { area } from "@turf/area";
 import { geoPath } from "d3-geo";
+import { stitchmerge } from "../helpers/stitchmerge.js";
+import { unstitch } from "../helpers/unstitch.js";
 import RBush from "rbush";
 
 /**
  * @function polygonstogrid
  * @description Assign polygons 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 polygon properties
+ *              Supports planar (path.area) or spherical (Turf area) surface calculation.
+ *              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 polygon properties.
  * @param {object} opts
- * @property {object} [polygons] - GeoJSON polygons or multi polygons to assign
+ * @property {object} [polygons] - GeoJSON polygons or multipolygons to assign
  * @property {object} [grid] - GeoJSON grid
- * @property {string|Array} [var] - Field(s) ton compute weighted sums (optional)
- * @property {boolean} [values=false] - Include array of raw polygons properties
+ * @property {string|Array} [var] - Field(s) to compute weighted sums (optional)
+ * @property {boolean} [values=false] - Include array of raw polygon properties
+ * @property {boolean} [spherical=false] - Compute areas on the sphere (Turf) instead of planar (D3)
  */
 export function polygonstogrid(opts = {}) {
-  const {
+  let {
     grid,
     polygons,
-    grid_id = "index",
     var: varField,
     values: includeValues = false,
+    spherical = false,
   } = opts;
 
   const t0 = performance.now();
   const path = geoPath();
 
+  // Unstitch grids if needed
+  if (spherical) {
+    grid = unstitch(grid);
+  }
+
   // --- Normalize varField to array ---
   const varFields = varField
     ? Array.isArray(varField)
@@ -36,18 +45,18 @@ export function polygonstogrid(opts = {}) {
       : [varField]
     : [];
 
-  // --- 1. Compute planar areas for polygons and grid cells ---
+  // --- 1. Compute areas for polygons and grid cells ---
   for (const poly of polygons.features) {
-    poly.properties.area_plan = path.area(poly);
+    if (spherical) poly.properties.area_spherical = area(poly);
+    else poly.properties.area_plan = path.area(poly);
   }
+
   for (const cell of grid.features) {
-    cell.properties.area_plan = path.area(cell);
+    if (spherical) cell.properties.area_spherical = area(cell);
+    else cell.properties.area_plan = path.area(cell);
 
-    // initialize statistics
     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 = [];
   }
 
@@ -67,27 +76,31 @@ export function polygonstogrid(opts = {}) {
     for (const cand of candidates) {
       const cell = cand.cell;
 
+      // vérifier que les deux features existent
+      if (!poly || !cell) continue;
+
+      // Turf v7: intersect via FeatureCollection contenant exactement deux géométries
       const inter = intersect({
         type: "FeatureCollection",
         features: [poly, cell],
       });
       if (!inter) continue;
 
-      const areaPlan = path.area(inter);
-      const pctAreaPlan = areaPlan / poly.properties.area_plan;
+      const areaVal = spherical ? area(inter) : path.area(inter);
+      const pctArea =
+        areaVal /
+        (spherical
+          ? poly.properties.area_spherical
+          : poly.properties.area_plan);
 
       // update cell statistics
       cell.properties.count += 1;
-
       for (const v of varFields) {
         const value = parseFloat(poly.properties[v]);
-        cell.properties[v] += !isNaN(value) ? value * pctAreaPlan : 0;
+        cell.properties[v] += !isNaN(value) ? value * pctArea : 0;
       }
 
-      // add properties of intersected polygons
-      if (includeValues) {
-        cell.properties.values.push({ ...poly.properties });
-      }
+      if (includeValues) cell.properties.values.push({ ...poly.properties });
     }
   }
 
@@ -104,5 +117,5 @@ export function polygonstogrid(opts = {}) {
     ).toFixed(2)} ms`
   );
 
-  return filteredGrid;
+  return spherical ? stitchmerge(filteredGrid) : filteredGrid;
 }

package/src/operator/linestogrid_save.js

@@ -1,124 +0,0 @@
-import { bbox } from "@turf/bbox";
-import { lineSplit } from "@turf/line-split";
-import { length as turfLength } from "@turf/length";
-import { booleanIntersects } from "@turf/boolean-intersects";
-import RBush from "rbush";
-import { min, max, median, mean, sum } from "d3-array";
-
-/**
- * @function linestogrid
- * @description Assigns lines to a grid and computes statistics per cell.
- *              Supports weighted lengths or simple counts.
- * @param {object} opts
- * @property {object} [grid] - GeoJSON grid
- * @property {object} [lines] - GeoJSON lines (LineString or MultiLineString)
- * @property {string} [var] - Field for weighting length (optional)
- * @property {boolean} [values=false] - Include array of raw values/IDs
- */
-export function linestogrid(opts = {}) {
-  const {
-    grid,
-    lines,
-    var: varField,
-    values: includeValues = false,
-    sum: calcSum = true,
-    median: calcMedian = false,
-    min: calcMin = false,
-    max: calcMax = false,
-    mean: calcMean = false,
-  } = opts;
-
-  const t0 = performance.now();
-  const gridFeatures = grid.features;
-  const lineFeatures = lines.features;
-  const hasVar = varField !== undefined && varField !== null;
-
-  const gridbyindex = new Map(gridFeatures.map((d, i) => [i, d]));
-
-  // ---- 1. Spatial index RBush ----
-  const tree = new RBush();
-  const items = gridFeatures.map((g, i) => {
-    const [minX, minY, maxX, maxY] = bbox(g);
-    return { minX, minY, maxX, maxY, i };
-  });
-  tree.load(items);
-
-  // ---- 2. Prepare stats storage per cell ----
-  const gridStats = new Map();
-  gridFeatures.forEach((g, i) => {
-    gridStats.set(i, { countSet: new Set(), valuesList: [], numericList: [] });
-  });
-
-  // ---- 3. Loop over lines ----
-  lineFeatures.forEach((line, i) => {
-    const totalLen = turfLength(line);
-    if (totalLen === 0) return;
-
-    const val = hasVar ? parseFloat(line.properties?.[varField]) || 0 : 1;
-    const [minX, minY, maxX, maxY] = bbox(line);
-    const candidates = tree.search({ minX, minY, maxX, maxY });
-
-    for (const cand of candidates) {
-      const g = gridbyindex.get(cand.i);
-      if (!booleanIntersects(g, line)) continue;
-
-      const split = lineSplit(line, g);
-      if (!split || split.features.length === 0) continue;
-
-      let lenInside = 0;
-      split.features.forEach((seg) => {
-        const segLen = turfLength(seg);
-        if (segLen > 0 && booleanIntersects(g, seg)) {
-          lenInside += segLen;
-        }
-      });
-
-      if (lenInside > 0) {
-        const stats = gridStats.get(cand.i);
-        stats.countSet.add(i); // unique line IDs
-
-        if (includeValues)
-          stats.valuesList.push(hasVar ? line.properties[varField] : i);
-
-        if (hasVar) stats.numericList.push(val * (lenInside / totalLen));
-      }
-    }
-  });
-
-  // ---- 4. Build final GeoJSON ----
-  const result = {
-    type: "FeatureCollection",
-    features: gridFeatures
-      .map((g, i) => {
-        const stats = gridStats.get(i);
-        const numericValues = stats.numericList;
-        const values = stats.valuesList;
-        const count = stats.countSet.size;
-
-        if (count === 0) return null;
-
-        const cellProps = { count };
-
-        if (hasVar && numericValues.length > 0) {
-          if (calcSum) cellProps.sum = sum(numericValues);
-          if (calcMean) cellProps.mean = mean(numericValues);
-          if (calcMedian) cellProps.median = median(numericValues);
-          if (calcMin) cellProps.min = min(numericValues);
-          if (calcMax) cellProps.max = max(numericValues);
-        }
-
-        if (includeValues) cellProps.values = values;
-
-        return {
-          type: g.type,
-          properties: { ...g.properties, ...cellProps },
-          geometry: g.geometry,
-        };
-      })
-      .filter((f) => f !== null),
-  };
-
-  const t1 = performance.now();
-  console.log(`Execution time: ${(t1 - t0).toFixed(2)} ms`);
-  return result;
-}

package/src/operator/polygonstogrid_save.js

@@ -1,144 +0,0 @@
-import { featureCollection } from "@turf/helpers";
-import { bbox } from "@turf/bbox";
-import { intersect } from "@turf/intersect";
-import area from "@turf/area";
-import RBush from "rbush";
-import { min, max, median, mean, sum } from "d3-array";
-
-/**
- * @function polygonstogrid
- * @description Assign polygons to a grid and compute statistics per cell.
- *              Optimized and removes cells with count = 0
- * @param {object} opts
- * @property {object} [grid] - GeoJSON grid
- * @property {object} [polygons] - GeoJSON polygons to assign
- * @property {string} [var] - Field for weighting (optional)
- * @property {boolean} [values=false] - Include array of raw values
- * @property {boolean} [sum=true] - Compute sum
- * @property {boolean} [median=false] - Compute median
- * @property {boolean} [min=false] - Compute minimum
- * @property {boolean} [max=false] - Compute maximum
- * @property {boolean} [mean=false] - Compute mean
- */
-export function polygonstogrid(opts = {}) {
-  const {
-    grid,
-    polygons,
-    var: varField,
-    values: includeValues = false,
-    sum: calcSum = true,
-    median: calcMedian = false,
-    min: calcMin = false,
-    max: calcMax = false,
-    mean: calcMean = false,
-  } = opts;
-
-  const t0 = performance.now();
-
-  const gridFeatures = grid.features;
-  const polys = polygons.features;
-  const hasVar = varField !== undefined && varField !== null;
-
-  const gridbyindex = new Map(gridFeatures.map((d, i) => [i, d]));
-
-  // ---- 1. Spatial index ----
-  const tree = new RBush();
-  const items = gridFeatures.map((g, i) => {
-    const [minX, minY, maxX, maxY] = bbox(g);
-    return { minX, minY, maxX, maxY, i };
-  });
-  tree.load(items);
-
-  // ---- 2. Stockage pour chaque carré ----
-  const gridStats = new Map();
-  gridFeatures.forEach((_, i) => {
-    gridStats.set(i, { numericList: [], valuesList: [], countSet: new Set() });
-  });
-
-  // ---- 3. Boucle sur les polygones ----
-  for (let i = 0; i < polys.length; i++) {
-    const p = polys[i];
-    if (!p.geometry || !["Polygon", "MultiPolygon"].includes(p.geometry.type))
-      continue;
-
-    const val = hasVar ? parseFloat(p.properties?.[varField]) || 0 : 1;
-
-    // 3a. Récupérer tous les carrés intersectant ce polygone
-    const [minX, minY, maxX, maxY] = bbox(p);
-    const candidates = tree.search({ minX, minY, maxX, maxY });
-
-    // 3b. Calculer toutes les intersections et leur aire
-    const pieces = [];
-    for (const cand of candidates) {
-      const g = gridbyindex.get(cand.i);
-      if (!g.geometry || !["Polygon", "MultiPolygon"].includes(g.geometry.type))
-        continue;
-
-      let f;
-      try {
-        f = intersect(featureCollection([p, g]));
-      } catch (e) {
-        continue;
-      }
-      if (!f) continue;
-
-      const areapiece = area(f);
-      if (areapiece <= 0) continue;
-
-      pieces.push({ index: cand.i, area: areapiece });
-    }
-
-    // 3c. Somme totale des aires des morceaux pour ce polygone
-    const totalPieceArea = sum(pieces.map((d) => d.area));
-    if (totalPieceArea === 0) continue;
-
-    // 3d. Calculer la valeur proportionnelle de chaque morceau
-    for (const piece of pieces) {
-      const fraction = piece.area / totalPieceArea;
-      const pieceValue = val * fraction;
-
-      const stats = gridStats.get(piece.index);
-      stats.numericList.push(pieceValue);
-      if (includeValues) stats.valuesList.push(pieceValue);
-      stats.countSet.add(i);
-    }
-  }
-
-  // ---- 4. Construire le GeoJSON final ----
-  const result = {
-    type: "FeatureCollection",
-    features: gridFeatures
-      .map((g, i) => {
-        const stats = gridStats.get(i);
-        const numericValues = stats.numericList;
-        const values = stats.valuesList;
-        const count = stats.countSet.size;
-
-        if (count === 0) return null;
-
-        const cellProps = { count };
-
-        if (hasVar && numericValues.length > 0) {
-          if (calcSum) cellProps.sum = sum(numericValues);
-          if (calcMean) cellProps.mean = mean(numericValues);
-          if (calcMedian) cellProps.median = median(numericValues);
-          if (calcMin) cellProps.min = min(numericValues);
-          if (calcMax) cellProps.max = max(numericValues);
-        }
-
-        if (includeValues) cellProps.values = values;
-
-        return {
-          type: g.type,
-          properties: { ...g.properties, ...cellProps },
-          geometry: g.geometry,
-        };
-      })
-      .filter((f) => f !== null),
-  };
-
-  const t1 = performance.now();
-  console.log(`Execution time: ${(t1 - t0).toFixed(2)} ms`);
-
-  return result;
-}