added boolean-rectangle and precise/validate.js

Author: DanielJDufour

README.md

@@ -14,6 +14,7 @@ Bounding boxes, or rectangular extents, are represented as an array of 4 numbers
 - [booleanContains](#booleanContains)
 - [booleanContainsPoint](#booleanContainsPoint)
 - [booleanIntersects](#booleanIntersects)
+- [booleanRectangle](#booleanRectangle)
 - [calc](#calc)
 - [densePolygon](#densePolygon)
 - [intersect](#intersect)
@@ -113,6 +114,38 @@ booleanIntersects(western_hemisphere, eastern_hemisphere);
 true
 ```
 
+### booleanRectangle
+Checks if coordinates represent a rectangular bounding box
+```js
+import booleanRectangle from "bbox-fns/boolean-rectangle.js";
+
+// rectangle for the globe bbox [-180, -90, 180, 90]
+const coords = [
+  [ -180, 90 ],
+  [ -180, -90 ],
+  [ 0, -90 ],
+  [ 0, 90 ],
+  [ -180, 90 ]
+];
+booleanRectangle(coords);
+true
+
+// extra points that don't affect shape
+const denseCoords = [
+  [ -180, 90 ],
+  [ -180, 0 ],
+  [ -180, -90 ],
+  [ -90, -90 ],
+  [ 0, -90 ],
+  [ 0, 0 ],
+  [ 0, 90 ],
+  [ -90, 90 ],
+  [ -180, 90 ]
+];
+booleanRectangle(denseCoords);
+true
+```
+
 ### intersect
 ```js
 import intersect from "bbox-fns/intersect.js";

boolean-rectangle.js

@@ -0,0 +1,88 @@
+const VALID_ORDERING = [
+  // clockwise
+  "right -> down -> left -> up",
+  "down -> left -> up -> right",
+  "left -> up -> right -> down",
+  "up -> right -> down -> left",
+
+  // counter-clockwise
+  "down -> right -> up -> left",
+  "right -> up -> left -> down",
+  "up -> left -> down -> right",
+  "left -> down -> right -> up"
+];
+
+function booleanRectangle(coords, { debug = 0 } = { debug: 0 }) {
+  if (!Array.isArray(coords)) {
+    if (debug) {
+      console.log("[bbox-fns/booleanRectangle] coords is not an array");
+    }
+    return false;
+  }
+
+  // unwrap ring from polygon
+  if (coords.length === 1) coords = coords[0];
+
+  // if multi-polygon, may need to unwrap twice
+  if (coords.length === 1) coords = coords[0];
+
+  if (
+    !coords.every(
+      pt => Array.isArray(pt) && pt.every(n => typeof n === "number")
+    )
+  ) {
+    if (debug) console.log("[bbox-fns/booleanRectangle] invalid points");
+    return false;
+  }
+
+  // first and last coordinate should be the same
+  if (JSON.stringify(coords[0]) !== JSON.stringify(coords[coords.length - 1])) {
+    if (debug)
+      console.log(
+        "[bbox-fns/booleanRectangle] first and last coordinates not equal"
+      );
+    return false;
+  }
+
+  let order = [];
+  for (let i = 1; i < coords.length; i++) {
+    const [x0, y0] = coords[i - 1];
+    const [x1, y1] = coords[i];
+    const vertical = x0 === x1;
+    const horizontal = y0 === y1;
+
+    // if both true or both false
+    if (vertical === horizontal) {
+      if (debug) console.log("[bbox-fns/booleanRectangle] invalid angle");
+      return false;
+    }
+
+    let direction;
+    if (vertical) {
+      direction = y1 > y0 ? "up" : "down";
+    } else if (horizontal) {
+      direction = x1 > x0 ? "right" : "left";
+    }
+
+    if (direction !== order[order.length - 1]) {
+      if (order.length === 4) {
+        if (debug) console.log("[bbox-fns/booleanRectangle] more than 4 turns");
+        return false;
+      }
+      order.push(direction);
+    }
+  }
+
+  order = order.join(" -> ");
+  if (debug) console.log("[bbox-fns/booleanRectangle] order: " + order);
+
+  if (VALID_ORDERING.indexOf(order) === -1) {
+    if (debug) console.log("[bbox-fns/booleanRectangle] invalid order");
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = booleanRectangle;
+module.exports.default = booleanRectangle;

index.js

@@ -7,6 +7,7 @@ const bboxSize = require("./bbox-size.js");
 const booleanContains = require("./boolean-contains.js");
 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 densePolygon = require("./dense-polygon.js");
 const intersect = require("./intersect.js");
@@ -18,6 +19,7 @@ const preciseReproject = require("./precise/reproject.js");
 const reproject = require("./reproject.js");
 const scale = require("./scale.js");
 const validate = require("./validate.js");
+const preciseValidate = require("./precise/validate.js");
 
 const bboxfns = {
   bboxArea,
@@ -27,6 +29,7 @@ const bboxfns = {
   booleanContains,
   booleanContainsPoint,
   booleanIntersects,
+  booleanRectangle,
   calc,
   densePolygon,
   intersect,
@@ -37,7 +40,8 @@ const bboxfns = {
   preciseReproject,
   reproject,
   scale,
-  validate
+  validate,
+  preciseValidate
 };
 
 if (typeof define === "function" && define.amd) {

package.json

@@ -12,6 +12,7 @@
     "boolean-contains.js",
     "boolean-contains-point.js",
     "boolean-intersects.js",
+    "boolean-rectangle.js",
     "calc.js",
     "dense-polygon.js",
     "intersect.js",
@@ -23,6 +24,7 @@
     "precise/dense-polygon.js",
     "precise/divide.js",
     "precise/reproject.js",
+    "precise/validate.js",
     "validate.js"
   ],
   "scripts": {

precise/validate.js

@@ -0,0 +1,18 @@
+const compare = require("preciso/compare.js");
+
+function preciseValidate(bbox) {
+  if (!Array.isArray(bbox)) return false;
+
+  if (bbox.length !== 4) return false;
+
+  if (bbox.some(n => typeof n !== "string")) return false;
+
+  const [xmin, ymin, xmax, ymax] = bbox;
+  if (compare(xmin, xmax) === ">") return false;
+  if (compare(ymin, ymax) === ">") return false;
+
+  return true;
+}
+
+module.exports = preciseValidate;
+module.exports.default = preciseValidate;

test.js

@@ -11,6 +11,7 @@ const {
   booleanContains,
   booleanContainsPoint,
   booleanIntersects,
+  booleanRectangle,
   calc,
   densePolygon,
   intersect,
@@ -21,7 +22,8 @@ const {
   preciseReproject,
   scale,
   preciseDivide,
-  validate
+  validate,
+  preciseValidate
 } = require("./index.js");
 
 const globe = [-180, -90, 180, 90];
@@ -94,6 +96,41 @@ test("booleanIntersects", ({ eq }) => {
   eq(booleanIntersects(western_hemisphere, eastern_hemisphere), true); // overlap on prime meridian
 });
 
+test("booleanRectangle", ({ eq }) => {
+  const bbox = [-180, -90, 0, 90];
+
+  // example
+  eq(booleanRectangle(densePolygon(bbox, { density: 1 })), true);
+
+  eq(booleanRectangle(bbox), false); // invalid input
+
+  const poly = polygon(bbox);
+  const densePoly = densePolygon(bbox, { density: 10 });
+  eq(booleanRectangle(poly), true);
+  eq(booleanRectangle(poly[0]), true);
+  eq(booleanRectangle([poly]), true);
+  eq(booleanRectangle(densePoly), true);
+  eq(booleanRectangle(densePoly[0]), true);
+  eq(booleanRectangle([densePoly]), true);
+
+  const triangle = [
+    [8.9257, 25.4035],
+    [25.625, 12.6403],
+    [32.1289, 23.8054],
+    [8.9257, 25.4035]
+  ];
+  eq(booleanRectangle(triangle), false);
+
+  const quadrilateral = [
+    [-9, 22],
+    [-9, -22],
+    [58, -30],
+    [58, 22],
+    [-9, 22]
+  ];
+  eq(booleanRectangle(quadrilateral, { debug: false }), false);
+});
+
 test("calc: GeoJSON Point", ({ eq }) => {
   eq(
     calc({
@@ -554,3 +591,9 @@ test("validate", ({ eq }) => {
   eq(validate([-180, 0, 0, 180, 45, 0]), false);
   eq(validate([-45, 10, -90, 20]), false);
 });
+
+test("preciseValidate", ({ eq }) => {
+  eq(preciseValidate(["-180", "0", "180", "45"]), true);
+  eq(preciseValidate(["-180", "0", "0", "180", "45", "0"]), false);
+  eq(preciseValidate(["-45", "10", "-90", "20"]), false);
+});

validate.js

@@ -6,6 +6,8 @@
  * @return {Boolean} valid - true or false
  */
 function validate(bbox) {
+  if (!Array.isArray(bbox)) return false;
+
   if (bbox.length !== 4) return false;
 
   if (bbox.some(n => typeof n !== "number")) return false;