geogrid 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geogrid",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Regular and irregular geoJSON grids ",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -36,10 +36,15 @@
   },
   "homepage": "https://github.com/neocarto/geogrid#readme",
   "dependencies": {
+    "@turf/area": "^7.2.0",
     "@turf/bbox": "^7.2.0",
+    "@turf/boolean-intersects": "^7.2.0",
     "@turf/boolean-point-in-polygon": "^7.1.0",
+    "@turf/boolean-within": "^7.2.0",
     "@turf/helpers": "^7.1.0",
     "@turf/intersect": "^7.1.0",
+    "@turf/length": "^7.2.0",
+    "@turf/line-split": "^7.2.0",
     "d3-array": "^3.2.4",
     "d3-delaunay": "^6.0.4",
     "d3-geo": "^3.1.1",
@@ -47,7 +52,6 @@
     "docs": "^0.3.2-canary.0",
     "documentation": "^14.0.3",
     "geojson2h3": "^1.2.0",
-    "geotoolbox": "^3.0.3",
     "h3-js": "^4.1.0",
     "rbush": "^4.0.1",
     "rollup": "^4.10.0"

package/src/{operator → helpers}/project.js

@@ -2,12 +2,12 @@ import { geoProject } from "d3-geo-projection";
 const d3 = Object.assign({}, { geoProject });
 
 /**
- * @function tool/project
- * @description The function `tool.project` use geoproject from d3-geo-projection to project a geoJSON. It returns a GeoJSON FeatureCollection with coordinates in the page map.
+ * @function project
+ * @description The function `project` use geoproject from d3-geo-projection to project a geoJSON. It returns a GeoJSON FeatureCollection with coordinates in the page map.
  * @property {object} data - a GeoJSON FeatureCollection
  * @property {function} options.projection - projection definition. See [d3-geo](https://github.com/d3/d3-geo) & [d3-geo-projection](https://github.com/d3/d3-geo-projection)
  * @example
- * let newGeoJSON = geoviz.tool.project(world, { projection: d3.geoOrthographic()})
+ * let newGeoJSON = project(world, { projection: d3.geoOrthographic()})
  */
 export function project(data, { projection = null } = {}) {
   return projection == null ? data : d3.geoProject(data, projection);

package/src/index.js

@@ -1,9 +1,11 @@
-export { square } from "./grid/square.js";
-export { triangle } from "./grid/triangle.js";
-export { dot } from "./grid/dot.js";
-export { random } from "./grid/random.js";
-export { diamond } from "./grid/diamond.js";
+// export { square } from "./grid/square.js";
+// export { triangle } from "./grid/triangle.js";
+// export { dot } from "./grid/dot.js";
+//export { random } from "./grid/random.js";
+// export { diamond } from "./grid/diamond.js";
 export { hexbin } from "./grid/hexbin.js";
-export { h3 } from "./grid/h3.js";
+// export { h3 } from "./grid/h3.js";
 export { pointstogrid } from "./operator/pointstogrid.js";
-export { polygonstogrid } from "./operator/polygonstogrid.js";
+// export { polygonstogrid } from "./operator/polygonstogrid.js";
+// export { linestogrid } from "./operator/linestogrid.js";
+// export { project } from "./helpers/project.js";

package/src/operator/linestogrid.js

@@ -0,0 +1,129 @@
+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
+ * @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
+ */
+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,72 +1,113 @@
 import RBush from "rbush";
 import { bbox } from "@turf/bbox";
 import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-import { geoPath } from "d3-geo";
-import { groups } from "d3-array";
-const d3 = Object.assign({}, { geoPath, groups });
+import { min, max, median, mean, sum } from "d3-array";
 
 /**
- * @function op.pointstogrid
- * @description The `op.pointstogrid()` function allows to count dots in polygons (e.g. grid cells)
- * @property {object} [points] - dots geoJSON
- * @property {object} [grid] - grid
- * @property {string} [var = undefined] - field (absolute quantitative data only)
+ * @function pointstogrid
+ * @description Assigns points to grid cells and computes statistics per cell.
+ * @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
  */
-export function pointstogrid(
-  opts = {
-    points: undefined,
-    grid: undefined,
-    var: undefined,
-  }
-) {
+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 t0 = performance.now();
+  const gridFeatures = grid.features;
+  const pointFeatures = points.features;
+  const hasVar = varField !== undefined && varField !== null;
 
-  const polys = opts.grid.features;
-  const points = opts.points.features;
-  const count = new Array(polys.length).fill(0);
+  const gridbyindex = new Map(gridFeatures.map((d, i) => [i, d]));
 
-  // ---- 1. Construire l’index spatial des polygones ----
+  // ---- 1. Spatial index for polygons ----
   const tree = new RBush();
-  const items = polys.map((p, i) => {
-    const [minX, minY, maxX, maxY] = bbox(p);
+  const items = gridFeatures.map((g, i) => {
+    const [minX, minY, maxX, maxY] = bbox(g);
     return { minX, minY, maxX, maxY, i };
   });
   tree.load(items);
 
-  // ---- 2. Boucle sur les points ----
-  points.forEach((pt) => {
-    const [x, y] = pt.geometry.coordinates;
+  // ---- 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 points ----
+  pointFeatures.forEach((pt, i) => {
+    const x = pt.geometry.coordinates[0];
+    const y = pt.geometry.coordinates[1];
 
-    // Trouver les polygones candidats dont la bbox contient le point
-    const candidates = tree.search({
-      minX: x,
-      minY: y,
-      maxX: x,
-      maxY: y,
-    });
+    const candidates = tree.search({ minX: x, minY: y, maxX: x, maxY: y });
 
-    // Tester seulement ces candidats
     for (const cand of candidates) {
-      const poly = polys[cand.i];
-      if (booleanPointInPolygon(pt, poly)) {
-        const value =
-          opts.var === undefined ? 1 : parseFloat(pt.properties[opts.var]) || 0;
-        count[cand.i] += value;
-        break; // Si un point ne doit appartenir qu'à une cellule
-      }
+      const poly = gridbyindex.get(cand.i);
+      if (!booleanPointInPolygon(pt, poly)) continue;
+
+      const stats = gridStats.get(cand.i);
+      stats.countSet.add(i);
+
+      const val = hasVar ? pt.properties[varField] : 1;
+
+      if (includeValues)
+        stats.valuesList.push(hasVar ? pt.properties[varField] : i);
+      if (hasVar) stats.numericList.push(parseFloat(val) || 0);
+      break; // point counted once per cell
     }
   });
 
-  // ---- 3. Reconstituer la grille ----
-  const output = polys
-    .map((d, i) => ({
-      type: d.type,
-      geometry: d.geometry,
-      properties: { ...d.properties, count: count[i] },
-    }))
-    .filter((d) => d.properties.count !== 0);
+  // ---- 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(`Temps d'exécution: ${(t1 - t0).toFixed(2)} ms`);
-  return { type: "FeatureCollection", features: output };
+  console.log(`Execution time: ${(t1 - t0).toFixed(2)} ms`);
+  return result;
 }

package/src/operator/polygonstogrid.js

@@ -1,90 +1,126 @@
 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 { geoPath } from "d3-geo";
-import { groups } from "d3-array";
-
-const d3 = Object.assign({}, { geoPath, groups });
+import { min, max, median, mean, sum } from "d3-array";
 
 /**
- * @function op.pointstogrid
- * @description Count points (optionally weighted) within polygons (e.g. grid cells)
- * @property {object} [points] - points geoJSON
- * @property {object} [grid] - grid geoJSON
- * @property {string} [var = undefined] - field for point weight
+ * @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 = { grid: undefined, polygons: undefined, var: undefined }
-) {
+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 grid = opts.grid.features;
-  const polys = opts.polygons.features;
-  const gridbyindex = new Map(grid.map((d, i) => [i, d]));
+  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. Créer l’index spatial RBush ----
+  // ---- 1. Spatial index RBush ----
   const tree = new RBush();
-  const items = grid.map((g, i) => {
+  const items = gridFeatures.map((g, i) => {
     const [minX, minY, maxX, maxY] = bbox(g);
     return { minX, minY, maxX, maxY, i };
   });
   tree.load(items);
 
-  const arr = [];
-  const path = d3.geoPath();
+  // ---- 2. Prepare stats storage per cell ----
+  const gridStats = new Map();
+  gridFeatures.forEach((g, i) => {
+    gridStats.set(i, { countSet: new Set(), valuesList: [], numericList: [] });
+  });
 
-  // ---- 2. Boucle sur les polygones ----
+  // ---- 3. Loop over polygons ----
   polys.forEach((p, i) => {
-    const area = path.area(p);
-    const [minX, minY, maxX, maxY] = bbox(p);
+    const polygonArea = area(p);
+    const val = hasVar ? parseFloat(p.properties?.[varField]) || 0 : 1;
 
-    // 3. Chercher uniquement les cellules qui peuvent intersecter
+    const [minX, minY, maxX, maxY] = bbox(p);
     const candidates = tree.search({ minX, minY, maxX, maxY });
 
-    // 4. Tester seulement les candidats
     for (const cand of candidates) {
       const g = gridbyindex.get(cand.i);
       const f = intersect(featureCollection([p, g]));
-      if (f) {
-        const areapiece = path.area(f);
-        arr.push([i, cand.i, areapiece / area]);
+      if (!f) continue;
+
+      const areapiece = area(f);
+      const fraction = areapiece / polygonArea;
+
+      const stats = gridStats.get(cand.i);
+      stats.countSet.add(i);
+
+      if (includeValues) {
+        stats.valuesList.push(hasVar ? p.properties[varField] : 1);
+      }
+
+      if (hasVar) {
+        stats.numericList.push(val * fraction);
       }
     }
   });
 
-  // ---- 5. Calcul des valeurs ----
-  const accessor = new Map(
-    polys.map((d, i) => [
-      i,
-      opts.var ? parseFloat(d.properties[opts.var]) || 0 : 1,
-    ])
-  );
-
-  const datagrid = d3.groups(arr, (d) => d[1]);
-
-  function getsum(cell) {
-    let sum = 0;
-    cell[1].forEach((d) => {
-      sum += accessor.get(d[0]) * d[2];
-    });
-    return sum === 0 ? undefined : sum;
-  }
-
-  // ---- 6. Assemblage du résultat ----
+  // ---- 4. Build final GeoJSON ----
   const result = {
     type: "FeatureCollection",
-    features: datagrid.map(([key, vals]) => {
-      const tmp = gridbyindex.get(key);
-      return {
-        type: tmp.type,
-        properties: { ...tmp.properties, sum: getsum([key, vals]) },
-        geometry: tmp.geometry,
-      };
-    }),
+    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(`Temps d'exécution: ${(t1 - t0).toFixed(2)} ms`);
+  console.log(`Optimized execution time: ${(t1 - t0).toFixed(2)} ms`);
+
   return result;
 }

package/src/operator/save.js

@@ -0,0 +1,100 @@
+import { featureCollection } from "@turf/helpers";
+import { bbox } from "@turf/bbox";
+import { intersect } from "@turf/intersect";
+import RBush from "rbush";
+import { geoPath } from "d3-geo";
+import { groups } from "d3-array";
+
+const d3 = Object.assign({}, { geoPath, groups });
+
+/**
+ * @function polygonstogrid
+ * @description Répartit des polygones (optionnellement pondérés) sur une grille polygonale.
+ * @property {object} [polygons] - GeoJSON de polygones
+ * @property {object} [grid] - GeoJSON de grille
+ * @property {string} [var] - Champ de pondération (facultatif)
+ */
+export function polygonstogrid(
+  opts = { grid: undefined, polygons: undefined, var: undefined }
+) {
+  const t0 = performance.now();
+
+  const grid = opts.grid.features;
+  const polys = opts.polygons.features;
+  const gridbyindex = new Map(grid.map((d, i) => [i, d]));
+
+  // ---- 1. Créer l’index spatial RBush ----
+  const tree = new RBush();
+  const items = grid.map((g, i) => {
+    const [minX, minY, maxX, maxY] = bbox(g);
+    return { minX, minY, maxX, maxY, i };
+  });
+  tree.load(items);
+
+  const arr = [];
+  const path = d3.geoPath();
+
+  // ---- 2. Boucle sur les polygones ----
+  polys.forEach((p, i) => {
+    const area = path.area(p);
+    const [minX, minY, maxX, maxY] = bbox(p);
+
+    // 3. Chercher uniquement les cellules qui peuvent intersecter
+    const candidates = tree.search({ minX, minY, maxX, maxY });
+
+    // 4. Tester seulement les candidats
+    for (const cand of candidates) {
+      const g = gridbyindex.get(cand.i);
+      const f = intersect(featureCollection([p, g]));
+      if (f) {
+        const areapiece = path.area(f);
+        arr.push([i, cand.i, areapiece / area]);
+      }
+    }
+  });
+
+  // ---- 5. Calcul des valeurs ----
+  const hasVar = opts.var !== undefined && opts.var !== null;
+
+  const accessor = new Map(
+    polys.map((d, i) => [
+      i,
+      hasVar ? parseFloat(d.properties[opts.var]) || 0 : 1,
+    ])
+  );
+
+  const datagrid = d3.groups(arr, (d) => d[1]);
+
+  function getsum(cell) {
+    const vals = cell[1];
+    if (hasVar) {
+      // Cas pondéré
+      let sum = 0;
+      vals.forEach((d) => {
+        sum += accessor.get(d[0]) * d[2];
+      });
+      return sum === 0 ? undefined : sum;
+    } else {
+      // Cas non pondéré : juste compter le nombre de polygones intersectés
+      const uniquePolygons = new Set(vals.map((d) => d[0]));
+      return uniquePolygons.size;
+    }
+  }
+
+  // ---- 6. Assemblage du résultat ----
+  const result = {
+    type: "FeatureCollection",
+    features: datagrid.map(([key, vals]) => {
+      const tmp = gridbyindex.get(key);
+      return {
+        type: tmp.type,
+        properties: { ...tmp.properties, sum: getsum([key, vals]) },
+        geometry: tmp.geometry,
+      };
+    }),
+  };
+
+  const t1 = performance.now();
+  console.log(`Temps d'exécution: ${(t1 - t0).toFixed(2)} ms`);
+  return result;
+}