added nan_strategy to bboxArray and reproject

Author: DanielJDufour

README.md

@@ -53,6 +53,13 @@ bboxArray([
   [ -179, 84.48577680525165 ]
 ]);
 [-180, 84.48577680525165, -179, 86.06126914660831]
+
+// throws because of the NaN value
+bboxArray([ -180, 86.06 ], [NaN, NaN], [ -179, 84.48 ]);
+
+// skip NaN values (don't throw)
+bboxArray(points, { nan_strategy: "skip" })
+[-180, 84.48, -179, 86.06]
 ```
 
 ### bboxPoint
@@ -326,6 +333,9 @@ reproject(bbox, forwardAsync, { async: true })
 
 // you can also control the point density of the intermediate polygon
 reproject(bbox, forward, { density: 99 })
+
+// skip (don't throw error) when forward returns a NaN value
+reproject(bbox, forward, { density: 99, nan_stategy: "skip" })
 ```
 
 ### sort

bbox-array.js

@@ -5,7 +5,7 @@
  * @param {Array} points - an array (aka ring) of points
  * @return {bbox} bbox in form [xmin, ymin, xmax, ymax]
  */
-function bboxArray(points) {
+function bboxArray(points, { nan_strategy = "throw" } = { nan_strategy: "throw" }) {
   const count = points.length;
   const [x, y] = points[0];
   let xmin = x;
@@ -14,10 +14,22 @@ function bboxArray(points) {
   let ymax = y;
   for (let i = 1; i < count; i++) {
     const [x, y] = points[i];
-    if (x < xmin) xmin = x;
-    else if (x > xmax) xmax = x;
-    if (y < ymin) ymin = y;
-    else if (y > ymax) ymax = y;
+    if (isNaN(x)) {
+      if (nan_strategy === "throw") {
+        throw new Error("[bbox-fns/bbox-array] encountered point with a NaN value: [" + x + ", " + y + "]");
+      }
+    } else {
+      if (x < xmin) xmin = x;
+      else if (x > xmax) xmax = x;
+    }
+    if (isNaN(y)) {
+      if (nan_strategy === "throw") {
+        throw new Error("[bbox-fns/bbox-array] encountered point with a NaN value: [" + x + ", " + y + "]");
+      }
+    } else {
+      if (y < ymin) ymin = y;
+      else if (y > ymax) ymax = y;
+    }
   }
   return [xmin, ymin, xmax, ymax];
 }

boolean-contains-point.js

@@ -1,11 +1,7 @@
 "use_strict";
 
 // check if a bounding box contains a point
-function booleanContainsPoint(
-  [xmin, ymin, xmax, ymax],
-  [x, y],
-  { exclusive = false } = { exclusive: false }
-) {
+function booleanContainsPoint([xmin, ymin, xmax, ymax], [x, y], { exclusive = false } = { exclusive: false }) {
   if (exclusive) {
     // exclude points on an exact edge of the bounding box
     return y < ymax && y > ymin && x < xmax && x > xmin;

boolean-contains.js

@@ -1,11 +1,7 @@
 "use_strict";
 
 // check if the first bbox completely contains the second
-function booleanContains(
-  [axmin, aymin, axmax, aymax],
-  [bxmin, bymin, bxmax, bymax],
-  { exclusive = false } = { exclusive: false }
-) {
+function booleanContains([axmin, aymin, axmax, aymax], [bxmin, bymin, bxmax, bymax], { exclusive = false } = { exclusive: false }) {
   if (exclusive) {
     const xContained = bxmin > axmin && bxmax < axmax;
     const yContained = bymin > aymin && bymax < aymax;

boolean-intersects.js

@@ -1,10 +1,7 @@
 "use_strict";
 
 // check if two bounding boxes overlap at all
-function booleanIntersects(
-  [axmin, aymin, axmax, aymax],
-  [bxmin, bymin, bxmax, bymax]
-) {
+function booleanIntersects([axmin, aymin, axmax, aymax], [bxmin, bymin, bxmax, bymax]) {
   const yOverlaps = bymin <= aymax && bymax >= aymin;
   const xOverlaps = bxmin <= axmax && bxmax >= axmin;
   return xOverlaps && yOverlaps;

boolean-rectangle.js

@@ -26,21 +26,14 @@ function booleanRectangle(coords, { debug = 0 } = { debug: 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 (!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"
-      );
+    if (debug) console.log("[bbox-fns/booleanRectangle] first and last coordinates not equal");
     return false;
   }
 

calc-all.js

@@ -31,20 +31,12 @@ function calcAll(geom) {
     return dedupe(flatten(geom.geometries.map(calcAll)));
   }
 
-  if (
-    Array.isArray(geom) &&
-    Array.isArray(geom[0]) &&
-    Array.isArray(geom[0][0])
-  ) {
+  if (Array.isArray(geom) && Array.isArray(geom[0]) && Array.isArray(geom[0][0])) {
     return dedupe(flatten(geom.map(calcAll)));
   }
 
   // array of [x, y] coordinate pairs
-  if (
-    Array.isArray(geom) &&
-    Array.isArray(geom[0]) &&
-    typeof geom[0][0] === "number"
-  ) {
+  if (Array.isArray(geom) && Array.isArray(geom[0]) && typeof geom[0][0] === "number") {
     const [x, y] = geom[0];
     let xmin = x;
     let ymin = y;
@@ -60,11 +52,7 @@ function calcAll(geom) {
   }
 
   // point
-  if (
-    Array.isArray(geom) &&
-    (geom.length === 2 || geom.length === 3) &&
-    typeof geom[0] === "number"
-  ) {
+  if (Array.isArray(geom) && (geom.length === 2 || geom.length === 3) && typeof geom[0] === "number") {
     const [x, y] = geom;
     return [[x, y, x, y]];
   }
@@ -75,9 +63,7 @@ function calcAll(geom) {
     return [[x, y, x, y]];
   }
 
-  if (
-    ["xmin", "xmax", "ymin", "ymax"].every(k => typeof geom[k] === "number")
-  ) {
+  if (["xmin", "xmax", "ymin", "ymax"].every(k => typeof geom[k] === "number")) {
     return [[geom.xmin, geom.ymin, geom.xmax, geom.ymax]];
   }
 }

calc.js

@@ -20,20 +20,12 @@ function calc(geom) {
     return merge(geom.geometries.map(calc));
   }
 
-  if (
-    Array.isArray(geom) &&
-    Array.isArray(geom[0]) &&
-    Array.isArray(geom[0][0])
-  ) {
+  if (Array.isArray(geom) && Array.isArray(geom[0]) && Array.isArray(geom[0][0])) {
     return merge(geom.map(calc));
   }
 
   // array of [x, y] coordinate pairs
-  if (
-    Array.isArray(geom) &&
-    Array.isArray(geom[0]) &&
-    typeof geom[0][0] === "number"
-  ) {
+  if (Array.isArray(geom) && Array.isArray(geom[0]) && typeof geom[0][0] === "number") {
     const [x, y] = geom[0];
     let xmin = x;
     let ymin = y;
@@ -49,11 +41,7 @@ function calc(geom) {
   }
 
   // point
-  if (
-    Array.isArray(geom) &&
-    (geom.length === 2 || geom.length === 3) &&
-    typeof geom[0] === "number"
-  ) {
+  if (Array.isArray(geom) && (geom.length === 2 || geom.length === 3) && typeof geom[0] === "number") {
     const [x, y] = geom;
     return [x, y, x, y];
   }
@@ -64,9 +52,7 @@ function calc(geom) {
     return [x, y, x, y];
   }
 
-  if (
-    ["xmin", "xmax", "ymin", "ymax"].every(k => typeof geom[k] === "number")
-  ) {
+  if (["xmin", "xmax", "ymin", "ymax"].every(k => typeof geom[k] === "number")) {
     return [geom.xmin, geom.ymin, geom.xmax, geom.ymax];
   }
 }

dense-polygon.js

@@ -1,9 +1,6 @@
 "use_strict";
 
-function densePolygon(
-  [xmin, ymin, xmax, ymax],
-  { density = 0 } = { density: 0 }
-) {
+function densePolygon([xmin, ymin, xmax, ymax], { density = 0 } = { density: 0 }) {
   if (typeof density === "number") density = [density, density];
 
   const [x_density, y_density] = density;

grid.js

@@ -24,8 +24,7 @@ function grid([xmin, ymin, xmax, ymax], div) {
     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;
+      const cell_xmax = c === columns.length - 1 ? xmax : cell_xmin + cell_width;
       cells.push([cell_xmin, cell_ymin, cell_xmax, cell_ymax]);
     }
   }

intersect.js

@@ -8,12 +8,7 @@ function intersect(a, b) {
 
   if (!booleanIntersects(a, b)) return null;
 
-  return [
-    Math.max(axmin, bxmin),
-    Math.max(aymin, bymin),
-    Math.min(axmax, bxmax),
-    Math.min(aymax, bymax)
-  ];
+  return [Math.max(axmin, bxmin), Math.max(aymin, bymin), Math.min(axmax, bxmax), Math.min(aymax, bymax)];
 }
 
 module.exports = intersect;

package.json

@@ -37,7 +37,7 @@
   ],
   "scripts": {
     "f": "npm run format",
-    "format": "npx prettier --arrow-parens=avoid --trailing-comma=none --write *.js */*.js",
+    "format": "npx prettier --arrow-parens=avoid --print-width=200 --trailing-comma=none --write *.js */*.js",
     "test": "node test.js"
   },
   "repository": {
@@ -56,6 +56,6 @@
   },
   "homepage": "https://github.com/DanielJDufour/bbox-fns#readme",
   "dependencies": {
-    "preciso": "^0.12.0"
+    "preciso": "^0.12.2"
   }
 }

precise/dense-polygon.js

@@ -17,8 +17,7 @@ function preciseDensePolygon(bbox, { density = 0 } = { density: 0 }) {
 
   let [xmin, ymin, xmax, ymax] = bbox;
 
-  if (typeof density === "number" || typeof density === "string")
-    density = [density, density];
+  if (typeof density === "number" || typeof density === "string") density = [density, density];
 
   density = density.map(n => n.toString());
 

precise/divide.js

@@ -8,26 +8,12 @@ const divide = require("preciso/divide.js");
  * @param {[number, number]} divisors - divisors in form [dx, dy] or [number] or just a number
  * @return {bbox} bbox
  */
-function preciseDivide(
-  [xmin, ymin, xmax, ymax],
-  div,
-  { ellipsis = false, max_decimal_digits = 100 } = {}
-) {
-  const [dx, dy] =
-    typeof div === "string" || typeof div === "number"
-      ? [div, div]
-      : div.length === 1
-      ? [div[0].toString(), div[0].toString()]
-      : div;
+function preciseDivide([xmin, ymin, xmax, ymax], div, { ellipsis = false, max_decimal_digits = 100 } = {}) {
+  const [dx, dy] = typeof div === "string" || typeof div === "number" ? [div, div] : div.length === 1 ? [div[0].toString(), div[0].toString()] : div;
   const opts = { ellipsis, max_decimal_digits };
   const dxstr = dx.toString();
   const dystr = dy.toString();
-  return [
-    divide(xmin.toString(), dxstr, opts),
-    divide(ymin.toString(), dystr, opts),
-    divide(xmax.toString(), dxstr, opts),
-    divide(ymax.toString(), dystr, opts)
-  ];
+  return [divide(xmin.toString(), dxstr, opts), divide(ymin.toString(), dystr, opts), divide(xmax.toString(), dxstr, opts), divide(ymax.toString(), dystr, opts)];
 }
 
 module.exports = preciseDivide;

reproject.js

@@ -3,14 +3,14 @@
 const bboxArray = require("./bbox-array.js");
 const densePolygon = require("./dense-polygon.js");
 
-function reproject(bbox, reproject, { async = false, density } = {}) {
+function reproject(bbox, reproject, { async = false, density, nan_strategy = "throw" } = {}) {
   const polygon = densePolygon(bbox, { density });
   const ring = polygon[0];
   const reprojected = ring.map(pt => reproject(pt));
   if (async) {
-    return Promise.all(reprojected).then(points => bboxArray(points));
+    return Promise.all(reprojected).then(points => bboxArray(points, { nan_strategy }));
   } else {
-    return bboxArray(reprojected);
+    return bboxArray(reprojected, { nan_strategy });
   }
 }
 

scale.js

@@ -7,12 +7,7 @@
  * @return {bbox} bbox
  */
 function scale([xmin, ymin, xmax, ymax], scl) {
-  const [sx, sy] =
-    typeof scl === "number"
-      ? [scl, scl]
-      : scl.length === 1
-      ? [scl[0], scl[0]]
-      : scl;
+  const [sx, sy] = typeof scl === "number" ? [scl, scl] : scl.length === 1 ? [scl[0], scl[0]] : scl;
   return [xmin * sx, ymin * sy, xmax * sx, ymax * sy];
 }
 

shift.js

@@ -1,16 +1,6 @@
 function shift([xmin, ymin, xmax, ymax], dist) {
-  const x =
-    Array.isArray(dist) && dist.length >= 1
-      ? dist[0]
-      : typeof dist.x === "number"
-      ? dist.x
-      : 0;
-  const y =
-    Array.isArray(dist) && dist.length >= 2
-      ? dist[1]
-      : typeof dist.y === "number"
-      ? dist.y
-      : 0;
+  const x = Array.isArray(dist) && dist.length >= 1 ? dist[0] : typeof dist.x === "number" ? dist.x : 0;
+  const y = Array.isArray(dist) && dist.length >= 2 ? dist[1] : typeof dist.y === "number" ? dist.y : 0;
 
   return [xmin + x, ymin + y, xmax + x, ymax + y];
 }

split.js

@@ -16,12 +16,8 @@ function split(bbox, breakpoints) {
   const xbrks = breakpoints.x || [];
   const ybrks = breakpoints.y || [];
 
-  const xedges = [xmin]
-    .concat(xbrks.filter(x => x > xmin && x < xmax))
-    .concat([xmax]);
-  const yedges = [ymin]
-    .concat(ybrks.filter(y => y > ymin && y < ymax))
-    .concat([ymax]);
+  const xedges = [xmin].concat(xbrks.filter(x => x > xmin && x < xmax)).concat([xmax]);
+  const yedges = [ymin].concat(ybrks.filter(y => y > ymin && y < ymax)).concat([ymax]);
 
   const bboxes = [];