geogrid 1.0.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geogrid",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Regular and irregular geoJSON grids ",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/operator/linestogrid.js

@@ -1,129 +1,108 @@
 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 { length } from "@turf/length";
 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.
+ * @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 {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
- * @property {boolean} [sum=true] - Compute sum of weighted lengths
- * @property {boolean} [median=false] - Compute median
- * @property {boolean} [min=false] - Compute minimum
- * @property {boolean} [max=false] - Compute maximum
- * @property {boolean} [mean=false] - Compute mean
+ * @property {string|Array} [var] - Field(s) to compute weighted sums (optional)
+ * @property {boolean} [values=false] - Include array of raw lines properties
  */
 export function linestogrid(opts = {}) {
   const {
     grid,
     lines,
+    grid_id = "index",
     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]));
+  // --- 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" });
+  }
+
+  for (const cell of grid.features) {
+    cell.properties.count = 0;
+    for (const v of varFields) {
+      cell.properties[v] = 0;
+    }
+    if (includeValues) cell.properties.values = [];
+  }
 
-  // ---- 1. Spatial index RBush ----
+  // --- 2. Build spatial index (RBush) on the grid ---
   const tree = new RBush();
-  const items = gridFeatures.map((g, i) => {
-    const [minX, minY, maxX, maxY] = bbox(g);
-    return { minX, minY, maxX, maxY, i };
+  const items = grid.features.map((cell) => {
+    const [minX, minY, maxX, maxY] = bbox(cell);
+    return { minX, minY, maxX, maxY, cell };
   });
   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;
+  // --- 3. Loop over lines ---
+  for (const line of lines.features) {
     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 cell = cand.cell;
 
-      const split = lineSplit(line, g);
-      if (!split || split.features.length === 0) continue;
+      // split line by cell polygon
+      const splitLines = lineSplit(line, cell);
+      if (!splitLines.features.length) continue;
 
-      let lenInside = 0;
-      split.features.forEach((seg) => {
-        const segLen = turfLength(seg);
-        if (segLen > 0 && booleanIntersects(g, seg)) {
-          lenInside += segLen;
-        }
-      });
+      // compute total length of segments inside the cell
+      let totalSegLength = 0;
+      for (const seg of splitLines.features) {
+        totalSegLength += length(seg, { units: "meters" });
+      }
+      if (totalSegLength === 0) continue;
 
-      if (lenInside > 0) {
-        const stats = gridStats.get(cand.i);
-        stats.countSet.add(i); // unique line IDs
+      // --- update cell statistics ---
+      cell.properties.count += 1; // one line per cell
 
-        if (includeValues)
-          stats.valuesList.push(hasVar ? line.properties[varField] : i);
+      for (const v of varFields) {
+        const value = parseFloat(line.properties[v]);
+        cell.properties[v] += !isNaN(value)
+          ? value * (totalSegLength / line.properties.length_total)
+          : 0;
+      }
 
-        if (hasVar) stats.numericList.push(val * (lenInside / totalLen));
+      if (includeValues) {
+        cell.properties.values.push({ ...line.properties });
       }
     }
-  });
+  }
 
-  // ---- 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),
+  // --- 4. Filter out cells with count == 0 ---
+  const filteredGrid = {
+    ...grid,
+    features: grid.features.filter((cell) => cell.properties.count > 0),
   };
 
   const t1 = performance.now();
-  console.log(`Execution time: ${(t1 - t0).toFixed(2)} ms`);
-  return result;
+  console.log(
+    `Line intersection completed for ${filteredGrid.features.length} cells — ${(
+      t1 - t0
+    ).toFixed(2)} ms`
+  );
+
+  return filteredGrid;
 }

package/src/operator/linestogrid_save.js

@@ -0,0 +1,124 @@
+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/pointstogrid.js

@@ -1,43 +1,35 @@
 import RBush from "rbush";
 import { bbox } from "@turf/bbox";
 import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-import { min, max, median, mean, sum } from "d3-array";
 
 /**
  * @function pointstogrid
- * @description Assigns points to grid cells and computes statistics per cell.
+ * @description Assigns points to grid cells and computes sums per cell.
+ *              Supports multiple variables and stores point properties if values=true
  * @param {object} opts
  * @property {object} [points] - GeoJSON points
  * @property {object} [grid] - GeoJSON grid (polygons)
- * @property {string} [var] - Field for weighting points (optional)
- * @property {boolean} [values=false] - Include array of raw values/IDs
- * @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
+ * @property {string|Array} [var] - Field(s) for summing values
+ * @property {boolean} [values=false] - Include array of raw point properties
  */
 export function pointstogrid(opts = {}) {
-  const {
-    points,
-    grid,
-    var: varField,
-    values: includeValues = false,
-    sum: calcSum = true,
-    median: calcMedian = false,
-    min: calcMin = false,
-    max: calcMax = false,
-    mean: calcMean = false,
-  } = opts;
+  const { points, grid, var: varField, values: includeValues = false } = opts;
 
   const t0 = performance.now();
+
   const gridFeatures = grid.features;
   const pointFeatures = points.features;
-  const hasVar = varField !== undefined && varField !== null;
+
+  // --- Normalize varField to array ---
+  const varFields = varField
+    ? Array.isArray(varField)
+      ? varField
+      : [varField]
+    : [];
 
   const gridbyindex = new Map(gridFeatures.map((d, i) => [i, d]));
 
-  // ---- 1. Spatial index for polygons ----
+  // --- 1. Spatial index for polygons ---
   const tree = new RBush();
   const items = gridFeatures.map((g, i) => {
     const [minX, minY, maxX, maxY] = bbox(g);
@@ -45,13 +37,14 @@ export function pointstogrid(opts = {}) {
   });
   tree.load(items);
 
-  // ---- 2. Prepare stats storage per cell ----
+  // --- 2. Prepare stats storage per cell ---
   const gridStats = new Map();
   gridFeatures.forEach((g, i) => {
-    gridStats.set(i, { countSet: new Set(), valuesList: [], numericList: [] });
+    gridStats.set(i, { countSet: new Set(), valuesList: [], numericLists: {} });
+    varFields.forEach((v) => (gridStats.get(i).numericLists[v] = []));
   });
 
-  // ---- 3. Loop over points ----
+  // --- 3. Loop over points ---
   pointFeatures.forEach((pt, i) => {
     const x = pt.geometry.coordinates[0];
     const y = pt.geometry.coordinates[1];
@@ -65,38 +58,40 @@ export function pointstogrid(opts = {}) {
       const stats = gridStats.get(cand.i);
       stats.countSet.add(i);
 
-      const val = hasVar ? pt.properties[varField] : 1;
+      // --- handle numeric variables ---
+      varFields.forEach((v) => {
+        const val = parseFloat(pt.properties[v]);
+        if (!isNaN(val)) stats.numericLists[v].push(val);
+      });
+
+      // --- handle values option ---
+      if (includeValues) stats.valuesList.push({ ...pt.properties });
 
-      if (includeValues)
-        stats.valuesList.push(hasVar ? pt.properties[varField] : i);
-      if (hasVar) stats.numericList.push(parseFloat(val) || 0);
       break; // point counted once per cell
     }
   });
 
-  // ---- 4. Build final GeoJSON ----
+  // --- 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);
-        }
+        // sum each variable
+        varFields.forEach((v) => {
+          const numericValues = stats.numericLists[v];
+          cellProps[v] =
+            numericValues.length > 0
+              ? numericValues.reduce((a, b) => a + b, 0)
+              : 0;
+        });
 
-        if (includeValues) cellProps.values = values;
+        if (includeValues) cellProps.values = stats.valuesList;
 
         return {
           type: g.type,
@@ -109,5 +104,6 @@ export function pointstogrid(opts = {}) {
 
   const t1 = performance.now();
   console.log(`Execution time: ${(t1 - t0).toFixed(2)} ms`);
+
   return result;
 }

package/src/operator/polygonstogrid.js

@@ -1,126 +1,108 @@
-import { featureCollection } from "@turf/helpers";
 import { bbox } from "@turf/bbox";
 import { intersect } from "@turf/intersect";
-import area from "@turf/area";
+import { geoPath } from "d3-geo";
 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.
+ * @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
  * @param {object} opts
+ * @property {object} [polygons] - GeoJSON polygons or multi polygons to assign
  * @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
+ * @property {string|Array} [var] - Field(s) ton compute weighted sums (optional)
+ * @property {boolean} [values=false] - Include array of raw polygons properties
  */
 export function polygonstogrid(opts = {}) {
   const {
     grid,
     polygons,
+    grid_id = "index",
     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 path = geoPath();
+
+  // --- Normalize varField to array ---
+  const varFields = varField
+    ? Array.isArray(varField)
+      ? varField
+      : [varField]
+    : [];
+
+  // --- 1. Compute planar areas for polygons and grid cells ---
+  for (const poly of polygons.features) {
+    poly.properties.area_plan = path.area(poly);
+  }
+  for (const cell of grid.features) {
+    cell.properties.area_plan = path.area(cell);
+
+    // initialize statistics
+    cell.properties.count = 0;
+    for (const v of varFields) {
+      cell.properties[v] = 0;
+    }
+    if (includeValues) cell.properties.values = [];
+  }
 
-  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 RBush ----
+  // --- 2. Build spatial index (RBush) on the grid ---
   const tree = new RBush();
-  const items = gridFeatures.map((g, i) => {
-    const [minX, minY, maxX, maxY] = bbox(g);
-    return { minX, minY, maxX, maxY, i };
+  const items = grid.features.map((cell) => {
+    const [minX, minY, maxX, maxY] = bbox(cell);
+    return { minX, minY, maxX, maxY, cell };
   });
   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 polygons ----
-  polys.forEach((p, i) => {
-    const polygonArea = area(p);
-    const val = hasVar ? parseFloat(p.properties?.[varField]) || 0 : 1;
-
-    const [minX, minY, maxX, maxY] = bbox(p);
+  // --- 3. Loop over polygons ---
+  for (const poly of polygons.features) {
+    const [minX, minY, maxX, maxY] = bbox(poly);
     const candidates = tree.search({ minX, minY, maxX, maxY });
 
     for (const cand of candidates) {
-      const g = gridbyindex.get(cand.i);
-      const f = intersect(featureCollection([p, g]));
-      if (!f) continue;
+      const cell = cand.cell;
 
-      const areapiece = area(f);
-      const fraction = areapiece / polygonArea;
+      const inter = intersect({
+        type: "FeatureCollection",
+        features: [poly, cell],
+      });
+      if (!inter) continue;
 
-      const stats = gridStats.get(cand.i);
-      stats.countSet.add(i);
+      const areaPlan = path.area(inter);
+      const pctAreaPlan = areaPlan / poly.properties.area_plan;
 
-      if (includeValues) {
-        stats.valuesList.push(hasVar ? p.properties[varField] : 1);
+      // 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;
       }
 
-      if (hasVar) {
-        stats.numericList.push(val * fraction);
+      // add properties of intersected polygons
+      if (includeValues) {
+        cell.properties.values.push({ ...poly.properties });
       }
     }
-  });
+  }
 
-  // ---- 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),
+  // --- 4. Filter out cells with count == 0 ---
+  const filteredGrid = {
+    ...grid,
+    features: grid.features.filter((cell) => cell.properties.count > 0),
   };
 
   const t1 = performance.now();
-  console.log(`Optimized execution time: ${(t1 - t0).toFixed(2)} ms`);
+  console.log(
+    `Intersection completed for ${filteredGrid.features.length} cells — ${(
+      t1 - t0
+    ).toFixed(2)} ms`
+  );
 
-  return result;
+  return filteredGrid;
 }