geogrid 0.0.1 → 0.0.4

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,49 +1,113 @@
+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 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,
-  }
-) {
-  let polys = opts.grid.features;
-  let points = opts.dots.features;
-  let count = new Array(polys.length).fill(0);
-  let nb = points.length;
-  let test = new Array(nb).fill(true);
-  polys.forEach((p, i) => {
-    points.forEach((d, j) => {
-      if (test[j]) {
-        if (booleanPointInPolygon(d, p)) {
-          if (opts.var == undefined) {
-            count[i] = count[i] + 1;
-          } else {
-            count[i] = count[i] + parseFloat(d.properties[opts.var]);
-          }
-          test[j] = false;
-        }
-      }
-    });
+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 gridbyindex = new Map(gridFeatures.map((d, i) => [i, d]));
+
+  // ---- 1. Spatial index for polygons ----
+  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 points ----
+  pointFeatures.forEach((pt, i) => {
+    const x = pt.geometry.coordinates[0];
+    const y = pt.geometry.coordinates[1];
+
+    const candidates = tree.search({ minX: x, minY: y, maxX: x, maxY: y });
+
+    for (const cand of candidates) {
+      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
+    }
   });
 
-  // Rebuild grid
-  let output = polys
-    .map((d, i) => ({
-      type: d.type,
-      geometry: d.geometry,
-      properties: { ...d.properties, count: count[i] },
-    }))
-    .filter((d) => d.properties.count !== 0);
-
-  //const endTime = performance.now();
-  //const elapsedTime = endTime - startTime;
-  return { type: "FeatureCollection", features: output };
+  // ---- 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.js

@@ -1,68 +1,126 @@
 import { featureCollection } from "@turf/helpers";
+import { bbox } from "@turf/bbox";
 import { intersect } from "@turf/intersect";
-import { geoPath } from "d3-geo";
-import { groups } from "d3-array";
-const d3 = Object.assign({}, { geoPath, groups });
+import area from "@turf/area";
+import RBush from "rbush";
+import { min, max, median, mean, sum } from "d3-array";
 
 /**
- * @function op.polygonstogrid
- * @description The `op.polygonstogrid()` function allows to affect polygons values tu grid cells.
- * @property {object} [polygons] - polygons geoJSON
- * @property {object} [grid] - grid geoJSON
- * @property {string} [var = undefined] - field (absolute quantitative data only)
+ * @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;
 
-export function polygonstogrid(
-  opts = {
-    grid: undefined,
-    polygons: undefined,
-    var: undefined,
-  }
-) {
-  let grid = opts.grid.features;
-  let polys = opts.polygons.features;
-  let gridbyindex = new Map(grid.map((d, i) => [i, d]));
-
-  let arr = [];
+  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 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 polygons ----
   polys.forEach((p, i) => {
-    const area = d3.geoPath().area(p);
-    grid.forEach((g, j) => {
+    const polygonArea = area(p);
+    const val = hasVar ? parseFloat(p.properties?.[varField]) || 0 : 1;
+
+    const [minX, minY, maxX, maxY] = bbox(p);
+    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 !== null) {
-        let areapiece = d3.geoPath().area(f);
-        arr.push([i, j, 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);
       }
-    });
+    }
   });
 
-  let accessor;
-  if (opts.var) {
-    accessor = new Map(
-      polys.map((d, i) => [i, parseFloat(d.properties[opts.var]) || 0])
-    );
-  } else {
-    accessor = new Map(polys.map((d, i) => [i, 1]));
-  }
-
-  let 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;
-  }
-
-  return {
+  // ---- 4. Build final GeoJSON ----
+  const result = {
     type: "FeatureCollection",
-    features: datagrid.map((d) => {
-      let tmp = gridbyindex.get(d[0]);
-      return {
-        type: tmp.type,
-        properties: { ...tmp.properties, sum: getsum(d) },
-        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(`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;
+}

package/src/helpers/rewind.js

@@ -1,45 +0,0 @@
-/**
- * @function tool/rewind
- * @description The `tool.rewind` function allows to generate compliant Polygon and MultiPolygon geometries. Adapted from MapBox geojson-rewind code (https://github.com/mapbox/grojson-rewind) under ISC license
- * @see {@link https://observablehq.com/@neocartocnrs/handle-geometries}
- * @property {object} data - a GeoJSON FeatureCollection
- * @property {boolean} [options.outer = false] - rewind Rings Outer
- * @property {boolean} [options.mutate  = false] - mutate the Input geoJSON
- */
-
-export function rewind(data, options = {}) {
-  data = JSON.parse(JSON.stringify(data));
-  let outer = options.outer === false ? false : true;
-  let mutate = options.mutate === false ? false : true;
-  let geo = mutate === true ? data : JSON.parse(JSON.stringify(x));
-  for (let i = 0; i < geo.features.length; i++) {
-    if (geo.features[i].geometry.type === "Polygon") {
-      rewindRings(geo.features[i].geometry.coordinates, outer);
-    } else if (geo.features[i].geometry.type === "MultiPolygon") {
-      for (let j = 0; j < geo.features[i].geometry.coordinates.length; j++) {
-        rewindRings(geo.features[i].geometry.coordinates[j], outer);
-      }
-    }
-  }
-  return geo;
-}
-
-function rewindRings(rings, outer) {
-  if (rings.length === 0) return;
-  rewindRing(rings[0], outer);
-  for (let i = 1; i < rings.length; i++) {
-    rewindRing(rings[i], !outer);
-  }
-}
-
-function rewindRing(ring, dir) {
-  let tArea = 0;
-  let err = 0;
-  for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
-    const k = (ring[i][0] - ring[j][0]) * (ring[j][1] + ring[i][1]);
-    const m = tArea + k;
-    err += Math.abs(tArea) >= Math.abs(k) ? tArea - m + k : k - m + tArea;
-    tArea = m;
-  }
-  if (tArea + err >= 0 !== !!dir) ring.reverse();
-}