modernized intersect-polygon

DanielJDufour · DanielJDufour · commit 8b80e7d5f754 · 2021-10-03T17:30:12.000-07:00
diff --git a/src/intersect-polygon/index.js b/src/intersect-polygon/index.js
@@ -1,3 +1,6 @@
-import intersectPolygon from './intersect-polygon.module';
+/**
+ * @prettier
+ */
+import intersectPolygon from "./intersect-polygon.module";
 
 export default intersectPolygon;
diff --git a/src/intersect-polygon/intersect-polygon.module.js b/src/intersect-polygon/intersect-polygon.module.js
@@ -1,18 +1,13 @@
-import _ from 'underscore';
-import getDepth from 'get-depth';
-import get from '../get';
-import load from '../load';
-import utils from '../utils';
-
-const {
-  categorizeIntersection,
-  clusterLineSegments,
-  couple,
-  forceWithin,
-  mergeRanges,
-  getLineFromPoints,
-  getIntersectionOfTwoLines,
-} = utils;
+/**
+ * @prettier
+ */
+import _ from "underscore";
+import getDepth from "get-depth";
+import get from "../get";
+import wrap from "../wrap-func";
+import utils from "../utils";
+
+const { categorizeIntersection, clusterLineSegments, couple, forceWithin, mergeRanges, getLineFromPoints, getIntersectionOfTwoLines } = utils;
 
 const getEdgesForPolygon = polygon => {
   const edges = [];
@@ -46,7 +41,6 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
   if (numRows === 0) return;
 
   for (let y = 0; y < numRows; y++) {
-
     const lat = lat0 - cellHeight * y - cellHeight / 2;
 
     // use that point, plus another point along the same latitude to
@@ -60,22 +54,20 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
   // collapse geometry down to a list of edges
   // necessary for multi-part geometries
   const depth = getDepth(geom);
-  const polygonEdges = depth === 4  ? geom.map(getEdgesForPolygon) : [getEdgesForPolygon(geom)];
+  const polygonEdges = depth === 4 ? geom.map(getEdgesForPolygon) : [getEdgesForPolygon(geom)];
 
   polygonEdges.forEach((edges, edgesIndex) => {
     // iterate through the list of polygon vertices, convert them to
     // lines, and compute the intersections with each image row
     const intersectionsByRow = _.range(numRows).map(row => []);
     const numberOfEdges = edges.length;
     for (let i = 0; i < numberOfEdges; i++) {
-
-
       // get vertices that make up an edge and convert that to a line
       const edge = edges[i];
 
       const [startPoint, endPoint] = edge;
-      const [ x1, y1 ] = startPoint;
-      const [ x2, y2 ] = endPoint;
+      const [x1, y1] = startPoint;
+      const [x2, y2] = endPoint;
 
       const direction = Math.sign(y2 - y1);
       const horizontal = y1 === y2;
@@ -90,18 +82,18 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
 
       let startLng, startLat, endLat, endLng;
       if (x1 < x2) {
-        [ startLng, startLat ] = startPoint;
-        [ endLng, endLat ] = endPoint;
+        [startLng, startLat] = startPoint;
+        [endLng, endLat] = endPoint;
       } else {
-        [ startLng, startLat ] = endPoint;
-        [ endLng, endLat ]  = startPoint;
+        [startLng, startLat] = endPoint;
+        [endLng, endLat] = startPoint;
       }
 
-      if (startLng === undefined) throw Error('startLng is ' + startLng);
+      if (startLng === undefined) throw Error("startLng is " + startLng);
 
       // find the y values in the image coordinate space
-      const imageY1 = Math.round((lat0 - .5*cellHeight - startLat ) / cellHeight);
-      const imageY2 = Math.round((lat0 - .5*cellHeight - endLat) / cellHeight);
+      const imageY1 = Math.round((lat0 - 0.5 * cellHeight - startLat) / cellHeight);
+      const imageY2 = Math.round((lat0 - 0.5 * cellHeight - endLat) / cellHeight);
 
       // make sure to set the start and end points so that we are
       // incrementing upwards through rows
@@ -122,11 +114,10 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
       for (let j = rowStart; j < rowEnd + 1; j++) {
         const imageLine = imageLines[j];
 
-
         if (imageLine === undefined) {
-          console.error('j:', j);
-          console.error('imageLines:', imageLines);
-          throw Error('imageLines');
+          console.error("j:", j);
+          console.error("imageLines:", imageLines);
+          throw Error("imageLines");
         }
 
         // because you know x is zero in ax + by = c, so by = c and b = -1, so -1 * y = c or y = -1 * c
@@ -183,7 +174,7 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
             vertical,
             xmin: xminOnLine,
             xmax: xmaxOnLine,
-            imageLineY,
+            imageLineY
           });
         }
       }
@@ -193,15 +184,15 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
       if (segmentsInRow.length > 0) {
         const clusters = clusterLineSegments(segmentsInRow, numberOfEdges);
         const categorized = clusters.map(categorizeIntersection);
-        const [ throughs, nonthroughs ] = _.partition(categorized, item => item.through);
+        const [throughs, nonthroughs] = _.partition(categorized, item => item.through);
 
         if (throughs.length % 2 === 1) {
-          throw Error('throughs.length for ' + rowIndex + ' is odd with ' + throughs.length);
+          throw Error("throughs.length for " + rowIndex + " is odd with " + throughs.length);
         }
 
         let insides = nonthroughs.map(intersection => [intersection.xmin, intersection.xmax]);
 
-        const sortedThroughs = _.sortBy(throughs, 'xmin');
+        const sortedThroughs = _.sortBy(throughs, "xmin");
 
         const couples = couple(sortedThroughs).map(couple => {
           const [left, right] = couple;
@@ -217,12 +208,11 @@ const intersectPolygonCore = ({ georaster, geom, perPixelFunction, latlngBbox, i
         insides = mergeRanges(insides);
 
         insides.forEach(pair => {
-
           const [xmin, xmax] = pair;
 
           //convert left and right to image pixels
-          const left = Math.round((xmin - (lng0 + .5*cellWidth)) / cellWidth);
-          const right = Math.round((xmax - (lng0 + .5*cellWidth)) / cellWidth);
+          const left = Math.round((xmin - (lng0 + 0.5 * cellWidth)) / cellWidth);
+          const right = Math.round((xmax - (lng0 + 0.5 * cellWidth)) / cellWidth);
 
           const startColumnIndex = Math.max(left, 0);
           const endColumnIndex = Math.min(right, imageWidth);
@@ -245,20 +235,9 @@ const intersectPolygon = (georaster, geom, perPixelFunction) => {
   // get values in a bounding box around the geometry
   const latlngBbox = utils.getBoundingBox(geom);
 
-  if (typeof georaster === "string") {
-    return load(georaster).then(loaded => {
-      return get(georaster, latlngBbox).then(imageBands => (
-        intersectPolygonCore({ georaster: loaded, geom, perPixelFunction, latlngBbox, imageBands })
-      ));
-    });
-  } else if (!georaster.values) {
-    return get(georaster, latlngBbox).then(imageBands => (
-      intersectPolygonCore({ georaster, geom, perPixelFunction, latlngBbox, imageBands })
-    ));
-  } else {
-    const imageBands = get(georaster, latlngBbox);
-    return intersectPolygonCore({ georaster, geom, perPixelFunction, latlngBbox, imageBands });
-  }
+  const values = get(georaster, latlngBbox);
+
+  return utils.callAfterResolveArgs(imageBands => intersectPolygonCore({ georaster, geom, perPixelFunction, latlngBbox, imageBands }), values);
 };
 
-export default intersectPolygon;
+export default wrap(intersectPolygon);
diff --git a/src/intersect-polygon/intersect-polygon.test.js b/src/intersect-polygon/intersect-polygon.test.js
@@ -1,22 +1,31 @@
-import test from 'flug';
-import fetch from 'cross-fetch';
-import load from '../load';
-import utils from '../utils';
-import convertGeometry from '../convert-geometry';
-import intersectPolygon from '../intersect-polygon';
-import bboxPolygon from '@turf/bbox-polygon';
+/**
+ * @prettier
+ */
+import test from "flug";
+import { serve } from "srvd";
+import fetch from "cross-fetch";
+import get from "../get";
+import load from "../load";
+import parse from "../parse";
+import utils from "../utils";
+import convertGeometry from "../convert-geometry";
+import intersectPolygon from "../intersect-polygon";
+import bboxPolygon from "@turf/bbox-polygon";
 
-const urlToGeojson = 'http://localhost:3000/data/gadm/geojsons/Akrotiri and Dhekelia.geojson';
+if (require.main === module) serve({ debug: true, port: 3000, wait: 3 });
 
-const urlToData = 'http://localhost:3000/data/';
+const urlToGeojson = "http://localhost:3000/data/gadm/geojsons/Akrotiri and Dhekelia.geojson";
 
-const url = urlToData + 'test.tiff';
+const urlToData = "http://localhost:3000/data/";
 
-test('Testing intersection of box', async ({ eq }) => {
+const url = urlToData + "test.tiff";
+
+test("(Legacy) Testing intersection of box", async ({ eq }) => {
   const georaster = await load(url);
+  const values = await get(georaster);
 
   let expectedNumberOfIntersectingPixels = 0;
-  georaster.values.forEach(band => {
+  values.forEach(band => {
     band.forEach(row => {
       row.forEach(value => {
         if (value != georaster.noDataValue) {
@@ -30,20 +39,67 @@ test('Testing intersection of box', async ({ eq }) => {
   const pixelWidth = georaster.pixelWidth;
 
   // minX, minY, maxX, maxY
-  const geom = bboxPolygon([georaster.xmin + .5 * pixelWidth, georaster.ymin + .5 * pixelHeight, georaster.xmax - .5 * pixelWidth, georaster.ymax - .5 * pixelHeight]);
+  const geom = bboxPolygon([
+    georaster.xmin + 0.5 * pixelWidth,
+    georaster.ymin + 0.5 * pixelHeight,
+    georaster.xmax - 0.5 * pixelWidth,
+    georaster.ymax - 0.5 * pixelHeight
+  ]);
   const coordinates = utils.getGeojsonCoors(geom);
   let numberOfIntersectingPixels = 0;
   intersectPolygon(georaster, coordinates, () => numberOfIntersectingPixels++);
   eq(numberOfIntersectingPixels, expectedNumberOfIntersectingPixels);
 });
 
-
-test('Test intersection/sum calculations for Country with Multiple Rings', async ({ eq }) => {
-  const georaster = await load(urlToData + 'ghsl/tiles/GHS_POP_GPW42015_GLOBE_R2015A_54009_1k_v1_0_4326_30_40.tif');
+test("(Legacy) Test intersection/sum calculations for Country with Multiple Rings", async ({ eq }) => {
+  const georaster = await load(urlToData + "ghsl/tiles/GHS_POP_GPW42015_GLOBE_R2015A_54009_1k_v1_0_4326_30_40.tif");
   const response = await fetch(urlToGeojson);
   const country = await response.json();
   let numberOfIntersectingPixels = 0;
-  const geom = convertGeometry('polygon', country);
+  const geom = convertGeometry("polygon", country);
   intersectPolygon(georaster, geom, () => numberOfIntersectingPixels++);
   eq(numberOfIntersectingPixels, 281);
 });
+
+// MODERN
+
+test("(Modern) Testing intersection of box", async ({ eq }) => {
+  const georaster = await parse(url);
+  const values = await get(georaster);
+
+  let expectedNumberOfIntersectingPixels = 0;
+  values.forEach(band => {
+    band.forEach(row => {
+      row.forEach(value => {
+        if (value != georaster.noDataValue) {
+          expectedNumberOfIntersectingPixels++;
+        }
+      });
+    });
+  });
+
+  const pixelHeight = georaster.pixelHeight;
+  const pixelWidth = georaster.pixelWidth;
+
+  // minX, minY, maxX, maxY
+  const geom = bboxPolygon([
+    georaster.xmin + 0.5 * pixelWidth,
+    georaster.ymin + 0.5 * pixelHeight,
+    georaster.xmax - 0.5 * pixelWidth,
+    georaster.ymax - 0.5 * pixelHeight
+  ]);
+  const coordinates = utils.getGeojsonCoors(geom);
+  let numberOfIntersectingPixels = 0;
+  await intersectPolygon(georaster, coordinates, () => numberOfIntersectingPixels++);
+  eq(numberOfIntersectingPixels, expectedNumberOfIntersectingPixels);
+});
+
+test("(Modern) Test intersection/sum calculations for Country with Multiple Rings", async ({ eq }) => {
+  const georaster = await parse(urlToData + "ghsl/tiles/GHS_POP_GPW42015_GLOBE_R2015A_54009_1k_v1_0_4326_30_40.tif");
+  const response = await fetch(urlToGeojson);
+  const country = await response.json();
+  let numberOfIntersectingPixels = 0;
+  const geom = convertGeometry("polygon", country);
+  await intersectPolygon(georaster, geom, () => numberOfIntersectingPixels++);
+  eq(numberOfIntersectingPixels, 281);
+});
