geogrid 0.0.1 → 0.0.3

package/src/operator/pointstogrid.js

@@ -1,4 +1,9 @@
+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 });
 
 /**
  * @function op.pointstogrid
@@ -14,28 +19,46 @@ export function pointstogrid(
     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;
-        }
-      }
+  const t0 = performance.now();
+
+  const polys = opts.grid.features;
+  const points = opts.points.features;
+  const count = new Array(polys.length).fill(0);
+
+  // ---- 1. Construire l’index spatial des polygones ----
+  const tree = new RBush();
+  const items = polys.map((p, i) => {
+    const [minX, minY, maxX, maxY] = bbox(p);
+    return { minX, minY, maxX, maxY, i };
+  });
+  tree.load(items);
+
+  // ---- 2. Boucle sur les points ----
+  points.forEach((pt) => {
+    const [x, y] = pt.geometry.coordinates;
+
+    // Trouver les polygones candidats dont la bbox contient le point
+    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
+      }
+    }
   });
 
-  // Rebuild grid
-  let output = polys
+  // ---- 3. Reconstituer la grille ----
+  const output = polys
     .map((d, i) => ({
       type: d.type,
       geometry: d.geometry,
@@ -43,7 +66,7 @@ export function pointstogrid(
     }))
     .filter((d) => d.properties.count !== 0);
 
-  //const endTime = performance.now();
-  //const elapsedTime = endTime - startTime;
+  const t1 = performance.now();
+  console.log(`Temps d'exécution: ${(t1 - t0).toFixed(2)} ms`);
   return { type: "FeatureCollection", features: output };
 }

package/src/operator/polygonstogrid.js

@@ -1,68 +1,90 @@
 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 op.polygonstogrid
- * @description The `op.polygonstogrid()` function allows to affect polygons values tu grid cells.
- * @property {object} [polygons] - polygons geoJSON
+ * @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 (absolute quantitative data only)
+ * @property {string} [var = undefined] - field for point weight
  */
-
 export function polygonstogrid(
-  opts = {
-    grid: undefined,
-    polygons: undefined,
-    var: undefined,
-  }
+  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]));
+  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);
 
-  let arr = [];
+  const arr = [];
+  const path = d3.geoPath();
+
+  // ---- 2. Boucle sur les polygones ----
   polys.forEach((p, i) => {
-    const area = d3.geoPath().area(p);
-    grid.forEach((g, j) => {
+    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 !== null) {
-        let areapiece = d3.geoPath().area(f);
-        arr.push([i, j, areapiece / area]);
+      if (f) {
+        const areapiece = path.area(f);
+        arr.push([i, cand.i, areapiece / area]);
       }
-    });
+    }
   });
 
-  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]));
-  }
+  // ---- 5. Calcul des valeurs ----
+  const accessor = new Map(
+    polys.map((d, i) => [
+      i,
+      opts.var ? parseFloat(d.properties[opts.var]) || 0 : 1,
+    ])
+  );
 
-  let datagrid = d3.groups(arr, (d) => d[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;
+    return sum === 0 ? undefined : sum;
   }
 
-  return {
+  // ---- 6. Assemblage du résultat ----
+  const result = {
     type: "FeatureCollection",
-    features: datagrid.map((d) => {
-      let tmp = gridbyindex.get(d[0]);
+    features: datagrid.map(([key, vals]) => {
+      const tmp = gridbyindex.get(key);
       return {
         type: tmp.type,
-        properties: { ...tmp.properties, sum: getsum(d) },
+        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/operator/project.js

@@ -0,0 +1,14 @@
+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.
+ * @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()})
+ */
+export function project(data, { projection = null } = {}) {
+  return projection == null ? data : d3.geoProject(data, projection);
+}

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();
-}

package/src/helpers/rewind2.ts

@@ -1,159 +0,0 @@
-/**
- * The code in this file rewinds GeoJSON polygons and multipolygons to fit d3's expectations.
- * This is adapted by Matthieu Viry from a notebook of Philippe Rivière: https://observablehq.com/@fil/rewind
- * which is licensed under the ISC license.
- */
-
-import d3 from './d3-custom';
-import { GeoJSONFeature, GeoJSONFeatureCollection } from '../global';
-
-const {
-  geoTransform,
-  geoStream,
-  geoContains,
-  geoArea,
-} = d3;
-
-function projectPolygons(o, stream) {
-  let coordinates = [];
-  let polygon; let
-    line;
-  geoStream(
-    o,
-    stream({
-      polygonStart() {
-        coordinates.push((polygon = []));
-      },
-      polygonEnd() {},
-      lineStart() {
-        polygon.push((line = []));
-      },
-      lineEnd() {
-        line.push(line[0].slice());
-      },
-      point(x, y) {
-        line.push([x, y]);
-      },
-    }),
-  );
-  if (o.type === 'Polygon') {
-    // eslint-disable-next-line prefer-destructuring
-    coordinates = coordinates[0];
-  }
-  return { ...o, coordinates, rewind: true };
-}
-
-function projectGeometry(o, stream) {
-  // eslint-disable-next-line no-nested-ternary
-  return !o
-    ? null
-    : o.type === 'GeometryCollection' // eslint-disable-line no-nested-ternary
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      ? projectGeometryCollection(o, stream)
-      : o.type === 'Polygon' || o.type === 'MultiPolygon'
-        ? projectPolygons(o, stream)
-        : o;
-}
-
-function projectFeature(o, stream) {
-  return { ...o, geometry: projectGeometry(o.geometry, stream) };
-}
-
-function projectFeatureCollection(o, stream) {
-  return { ...o, features: o.features.map((f) => projectFeature(f, stream)) };
-}
-
-function projectGeometryCollection(obj, stream) {
-  return {
-    ...obj,
-    geometries: obj.geometries.map((o) => projectGeometry(o, stream)),
-  };
-}
-
-const geoProjectSimple = function (object, projection) {
-  const { stream } = projection;
-  let project;
-  if (!stream) throw new Error('invalid projection');
-  switch (object && object.type) {
-    case 'Feature':
-      project = projectFeature;
-      break;
-    case 'FeatureCollection':
-      project = projectFeatureCollection;
-      break;
-    default:
-      project = projectGeometry;
-      break;
-  }
-  return project(object, stream);
-};
-
-function geoRewindStream(simple = true) {
-  let ring;
-  let polygon;
-  return geoTransform({
-    polygonStart() {
-      this.stream.polygonStart();
-      polygon = [];
-    },
-    lineStart() {
-      if (polygon) polygon.push((ring = []));
-      else this.stream.lineStart();
-    },
-    lineEnd() {
-      if (!polygon) this.stream.lineEnd();
-    },
-    point(x, y) {
-      if (polygon) ring.push([x, y]);
-      else this.stream.point(x, y);
-    },
-    polygonEnd() {
-      // eslint-disable-next-line no-restricted-syntax
-      for (const [i, rring] of polygon.entries()) {
-        rring.push(rring[0].slice());
-        if (
-          i // eslint-disable-line no-nested-ternary
-            // a hole must contain the first point of the polygon
-            ? !geoContains(
-              { type: 'Polygon', coordinates: [rring] },
-              polygon[0][0],
-            )
-            : polygon[1]
-              // the outer ring must contain the first point of its first hole (if any)
-              ? !geoContains(
-                { type: 'Polygon', coordinates: [rring] },
-                polygon[1][0],
-              // eslint-disable-next-line @typescript-eslint/no-loop-func
-              ) && !rring.some((p) => p[0] === polygon[1][0][0] && p[1] === polygon[1][0][1])
-              // a single ring polygon must be smaller than a hemisphere (optional)
-              : simple && geoArea({ type: 'Polygon', coordinates: [rring] }) > 2 * Math.PI
-        ) {
-          rring.reverse();
-        }
-
-        this.stream.lineStart();
-        rring.pop();
-        // eslint-disable-next-line no-restricted-syntax
-        for (const [x, y] of rring) this.stream.point(x, y);
-        this.stream.lineEnd();
-      }
-      this.stream.polygonEnd();
-      polygon = null;
-    },
-  });
-}
-
-const rewindFeature = (
-  feature: GeoJSONFeature,
-  simple: boolean,
-) => geoProjectSimple(feature, geoRewindStream(simple));
-
-const rewindLayer = (
-  layer: GeoJSONFeatureCollection,
-  simple: boolean = true,
-): GeoJSONFeatureCollection => {
-  const features = layer.features.map((feature) => rewindFeature(feature, simple));
-  return { ...layer, features };
-};
-
-export default rewindLayer;