added calcAll, grid, and union

Author: DanielJDufour

README.md

@@ -16,9 +16,12 @@ Bounding boxes, or rectangular extents, are represented as an array of 4 numbers
 - [booleanIntersects](#booleanIntersects)
 - [booleanRectangle](#booleanRectangle)
 - [calc](#calc)
+- [calcAll](#calcAll)
 - [densePolygon](#densePolygon)
+- [grid](#grid)
 - [intersect](#intersect)
 - [merge](#merge)
+- [union](#union)
 - [polygon](#polygon)
 - [scale](#scale)
 - [reproject](#reproject)
@@ -206,6 +209,19 @@ calc({
 [10, 10, 40, 40]
 ```
 
+### calcAll
+Calculate an array of bounding boxes for all the input geometries.
+For example, a multipolygon will return multiple bounding boxes.
+```js
+import calcAll from "bbox-fns/calc-all.js";
+
+calcAll({
+  type: "MultiPolygon",
+  coordinates: [ ... ]
+});
+[bbox1, bbox2, ...]
+```
+
 ### densePolygon
 A more advanced version of polygon.  Create a polygon
 while adding points to each side of the rectangle.
@@ -220,6 +236,23 @@ densePolygon(bbox, { density: 100 });
 densePolygon(bbox, { density: [100, 400] });
 ```
 
+### grid
+Chop bounding box up into multiple smaller bounding boxes.
+```js
+import grid from "bbox-fns/grid.js";
+
+const globe = [-180, -90, 180, 90];
+const number_of_columns = 2; // how many grid cells left to right
+const number_of_rows = 2; // how many grid cells top to bottom
+const quadrants = grid(globe, [number_of_columns, number_of_rows]);
+[
+  [-180, -90, 0, 0], // south-western
+  [0, -90, 180, 0], // south-eastern
+  [-180, 0, 0, 90], // north-western
+  [0, 0, 180, 90]  // north-eastern
+]
+```
+
 ### scale
 Multiply x and y values by the given scale values
 ```js
@@ -252,6 +285,22 @@ reproject(bbox, forwardAsync, { async: true })
 reproject(bbox, forward, { density: 99 })
 ```
 
+### union
+Combine all bounding boxes that intersect.
+This is different from merge, which will combine bounding boxes even if they don't intersect.
+```js
+import union from "bbox-fns/union.js";
+
+const wyoming = [-110.99, 40.97, -104.08, 45.03];
+const usa = [-125.10, 24.75, -66, 49.54];
+const iceland = [-24.40,  63.29, -13.16, 66.73];
+
+union([wyoming, usa, iceland]);
+
+// only includes usa and iceland, because wyoming merged into usa
+[[-125.10, 24.75, -66, 49.54], [-24.40,  63.29, -13.16, 66.73]]
+```
+
 ### validate
 ```js
 import validate from "bbox-fns/validate.js";

calc-all.js

@@ -0,0 +1,75 @@
+"use_strict";
+
+const dedupe = require("./dedupe.js");
+
+function calcAll(geom) {
+  if (geom.geometry) geom = geom.geometry;
+  if (geom.coordinates) geom = geom.coordinates;
+
+  if (geom.paths) geom = geom.paths; // ArcGIS Polyline
+  if (geom.points) geom = geom.points; // ArcGIS Multipoint
+  if (geom.rings) geom = geom.rings; // ArcGIS Polygon
+
+  // GeoJSON FeatureCollection
+  if (Array.isArray(geom.features)) {
+    return dedupe(geom.features.map(calcAll));
+  }
+
+  // GeoJSON GeometryCollection
+  if (Array.isArray(geom.geometries)) {
+    return dedupe(geom.geometries.map(calcAll));
+  }
+
+  if (
+    Array.isArray(geom) &&
+    Array.isArray(geom[0]) &&
+    Array.isArray(geom[0][0])
+  ) {
+    return dedupe(geom.map(calcAll));
+  }
+
+  // array of [x, y] coordinate pairs
+  if (
+    Array.isArray(geom) &&
+    Array.isArray(geom[0]) &&
+    typeof geom[0][0] === "number"
+  ) {
+    const [x, y] = geom[0];
+    let xmin = x;
+    let ymin = y;
+    let xmax = x;
+    let ymax = y;
+    geom.forEach(([px, py]) => {
+      if (px < xmin) xmin = px;
+      if (px > xmax) xmax = px;
+      if (py < ymin) ymin = py;
+      if (py > ymax) ymax = py;
+    });
+    return [xmin, ymin, xmax, ymax];
+  }
+
+  // point
+  if (
+    Array.isArray(geom) &&
+    (geom.length === 2 || geom.length === 3) &&
+    typeof geom[0] === "number"
+  ) {
+    const [x, y] = geom;
+    return [x, y, x, y];
+  }
+
+  // ArcGIS Point
+  if (typeof geom.x === "number" && typeof geom.y === "number") {
+    const { x, y } = geom;
+    return [x, y, x, y];
+  }
+
+  if (
+    ["xmin", "xmax", "ymin", "ymax"].every(k => typeof geom[k] === "number")
+  ) {
+    return [geom.xmin, geom.ymin, geom.xmax, geom.ymax];
+  }
+}
+
+module.exports = calcAll;
+module.exports.default = calcAll;

dedupe.js

@@ -0,0 +1,14 @@
+function dedupe(arr) {
+  const strs = [];
+  for (let i = 0; i < arr.length; i++) {
+    const it = arr[i];
+    const s = JSON.stringify(it);
+    if (strs.indexOf(s) === -1) {
+      strs.push(s);
+    }
+  }
+  return strs.map(s => JSON.parse(s));
+}
+
+module.exports = dedupe;
+module.exports.default = dedupe;

grid.js

@@ -0,0 +1,37 @@
+"use strict";
+
+/**
+ * @name grid
+ * @param {Array} bbox - bounding box in form [xmin, ymin, xmax, ymax]
+ * @return {Array<bbox>} array of bounding boxes
+ */
+function grid([xmin, ymin, xmax, ymax], div) {
+  if (typeof div === "number") div = [div, div];
+  else if (typeof div === "undefined") div = [2, 2];
+
+  const [columns, rows] = div;
+
+  const height = ymax - ymin;
+  const width = xmax - xmin;
+
+  const cells = [];
+
+  const cell_width = width / columns;
+  const cell_height = height / rows;
+
+  for (let r = 0; r < rows; r++) {
+    const cell_ymin = ymin + r * cell_height;
+    const cell_ymax = r === rows.length - 1 ? ymax : cell_ymin + cell_height;
+    for (let c = 0; c < columns; c++) {
+      const cell_xmin = xmin + c * cell_width;
+      const cell_xmax =
+        c === columns.length - 1 ? xmax : cell_xmin + cell_width;
+      cells.push([cell_xmin, cell_ymin, cell_xmax, cell_ymax]);
+    }
+  }
+
+  return cells;
+}
+
+module.exports = grid;
+module.exports.default = grid;

index.js

@@ -9,7 +9,9 @@ const booleanContainsPoint = require("./boolean-contains-point.js");
 const booleanIntersects = require("./boolean-intersects.js");
 const booleanRectangle = require("./boolean-rectangle.js");
 const calc = require("./calc.js");
+const calcAll = require("./calc-all.js");
 const densePolygon = require("./dense-polygon.js");
+const grid = require("./grid.js");
 const intersect = require("./intersect.js");
 const merge = require("./merge.js");
 const polygon = require("./polygon.js");
@@ -20,6 +22,7 @@ const reproject = require("./reproject.js");
 const scale = require("./scale.js");
 const validate = require("./validate.js");
 const preciseValidate = require("./precise/validate.js");
+const union = require("./union.js");
 
 const bboxfns = {
   bboxArea,
@@ -31,7 +34,9 @@ const bboxfns = {
   booleanIntersects,
   booleanRectangle,
   calc,
+  calcAll,
   densePolygon,
+  grid,
   intersect,
   merge,
   polygon,
@@ -41,7 +46,8 @@ const bboxfns = {
   reproject,
   scale,
   validate,
-  preciseValidate
+  preciseValidate,
+  union
 };
 
 if (typeof define === "function" && define.amd) {

package.json

@@ -14,7 +14,10 @@
     "boolean-intersects.js",
     "boolean-rectangle.js",
     "calc.js",
+    "calc-all.js",
+    "dedupe.js",
     "dense-polygon.js",
+    "grid.js",
     "intersect.js",
     "merge.js",
     "polygon.js",
@@ -25,6 +28,7 @@
     "precise/divide.js",
     "precise/reproject.js",
     "precise/validate.js",
+    "union.js",
     "validate.js"
   ],
   "scripts": {

test.js

@@ -3,6 +3,27 @@
 const test = require("flug");
 const subtract = require("preciso/subtract.js");
 
+const polygons_split_across_antimeridian = [
+  [
+    [
+      [-180, -18],
+      [-178, -18],
+      [-178, -20],
+      [-180, -20],
+      [-180, -18]
+    ]
+  ],
+  [
+    [
+      [180, -20],
+      [178, -20],
+      [178, -18],
+      [180, -18],
+      [180, -20]
+    ]
+  ]
+];
+
 const {
   bboxArea,
   bboxArray,
@@ -13,7 +34,9 @@ const {
   booleanIntersects,
   booleanRectangle,
   calc,
+  calcAll,
   densePolygon,
+  grid,
   intersect,
   merge,
   polygon,
@@ -23,7 +46,8 @@ const {
   scale,
   preciseDivide,
   validate,
-  preciseValidate
+  preciseValidate,
+  union
 } = require("./index.js");
 
 const globe = [-180, -90, 180, 90];
@@ -461,6 +485,22 @@ test("calc: ArcGIS Envelope in 2D", ({ eq }) => {
   );
 });
 
+test("polygons split across antimeridian", ({ eq }) => {
+  eq(calc(polygons_split_across_antimeridian), [-180, -20, 180, -18]);
+  eq(calcAll(polygons_split_across_antimeridian), [
+    [[-180, -20, -178, -18]],
+    [[178, -20, 180, -18]]
+  ]);
+  eq(
+    calcAll(
+      polygons_split_across_antimeridian.concat(
+        polygons_split_across_antimeridian
+      )
+    ),
+    [[[-180, -20, -178, -18]], [[178, -20, 180, -18]]]
+  );
+});
+
 test("densePolygon", ({ eq }) => {
   eq(densePolygon(globe, { density: 1 }), [
     [
@@ -530,6 +570,16 @@ test("intersect", ({ eq }) => {
   eq(intersect([-180, 1, -1, 90], [1, 1, 180, 90]), null);
 });
 
+test("grid", ({ eq }) => {
+  eq(grid(globe, [2, 1]), [western_hemisphere, eastern_hemisphere]);
+  eq(grid(globe, [2, 2]), [
+    [-180, -90, 0, 0],
+    [0, -90, 180, 0],
+    [-180, 0, 0, 90],
+    [0, 0, 180, 90]
+  ]);
+});
+
 test("merge", ({ eq }) => {
   const bboxes = [western_hemisphere, eastern_hemisphere];
   eq(merge(bboxes), [-180, -90, 180, 90]);
@@ -597,3 +647,15 @@ test("preciseValidate", ({ eq }) => {
   eq(preciseValidate(["-180", "0", "0", "180", "45", "0"]), false);
   eq(preciseValidate(["-45", "10", "-90", "20"]), false);
 });
+
+test("union", ({ eq }) => {
+  const wyoming = [-110.99, 40.97, -104.08, 45.03];
+  const usa = [-125.1, 24.75, -66, 49.54];
+  const iceland = [-24.4, 63.29, -13.16, 66.73];
+
+  eq(union([]), []);
+  eq(union([iceland]), [iceland]);
+  eq(union([wyoming, usa]), [usa]);
+  eq(union([wyoming, usa, iceland]), [iceland, usa]);
+  eq(union([wyoming, iceland]), [iceland, wyoming]);
+});