refactor: Update the polybool library

This moves from the patched polybool library to the modern, maintained
version.

Closes #1404

Author: manthey

package-lock.json

@@ -12,6 +12,7 @@
     "url": "https://github.com/OpenGeoscience/geojs"
   },
   "dependencies": {
+    "@velipso/polybool": "^2.0.11",
     "canvas": "^3.0.0",
     "color-name": "^2.0.0",
     "docdash": "^2.0.1",
@@ -23,7 +24,6 @@
     "jquery": "^3.6.0",
     "kdbush": "^4.0.0",
     "mousetrap": "^1.6.5",
-    "polybooljs": "git+https://github.com/manubb/polybooljs#eps-logic",
     "proj4": "^2.7.5"
   },
   "optionalDependencies": {

package.json

@@ -122,11 +122,11 @@ var polygonFeature = function (arg) {
       if (!poly) {
         return undefined;
       }
-      var outer, inner, range, coord, j, x, y, mapouter, mapinner, maprange;
+      var outer, inner, range, coord,  x, y, mapouter, mapinner, maprange;
 
       coord = poly.outer || (Array.isArray(poly) ? poly : []);
       outer = new Array(coord.length);
-      for (j = 0; j < coord.length; j += 1) {
+      for (let j = 0; j < coord.length; j += 1) {
         outer[j] = posFunc.call(m_this, coord[j], j, d, i);
         x = outer[j].x;
         y = outer[j].y;
@@ -142,14 +142,14 @@ var polygonFeature = function (arg) {
       inner = (poly.inner || []).map(function (hole) {
         coord = hole || [];
         var trans = new Array(coord.length);
-        for (j = 0; j < coord.length; j += 1) {
+        for (let j = 0; j < coord.length; j += 1) {
           trans[j] = posFunc.call(m_this, coord[j], j, d, i);
         }
         return trans;
       });
       mapouter = transform.transformCoordinates(fcs, mapgcs, outer);
       mapinner = inner.map(part => transform.transformCoordinates(fcs, mapgcs, part));
-      for (j = 0; j < mapouter.length; j += 1) {
+      for (let j = 0; j < mapouter.length; j += 1) {
         x = mapouter[j].x;
         y = mapouter[j].y;
         if (!j) {

src/polygonFeature.js

@@ -1,4 +1,5 @@
-var PolyBool = require('polybooljs');
+const { PolyBool, GeometryEpsilon } = require('@velipso/polybool');
+const polybool = new PolyBool();
 var geo_map = require('../map');
 var util = require('../util/common');
 
@@ -106,7 +107,7 @@ function seglistToPolygonList(seglist) {
   const borders = []; // polygons in format needed for util.pointInPolygon
   const regions = []; // polygons in end result format
   const parents = []; // list of parents of each polygon
-  seglist.forEach((s) => PolyBool.polygon(s).regions.forEach((r) => {
+  seglist.forEach((s) => polybool.polygon(s).regions.forEach((r) => {
     const border = r.map((pt) => ({x: pt[0], y: pt[1]}));
     if (border.length < 3) {
       return;
@@ -162,36 +163,27 @@ function seglistToPolygonList(seglist) {
  */
 function polygonOperationSeglist(op, epsilon, seglist) {
   op = 'select' + op.charAt(0).toUpperCase() + op.slice(1);
-  PolyBool.epsilon(epsilon);
+  const polyboolEps1 = new PolyBool(new GeometryEpsilon(epsilon));
 
   while (seglist.length > 1) {
     const newlist = [];
     const half = Math.ceil(seglist.length / 2);
     for (let i = 0; i < half; i += 1) {
       let segments = seglist[i];
       if (i + half < seglist.length) {
-        let nextseg = seglist[i + half];
+        const nextseg = seglist[i + half];
         try {
-          segments = PolyBool.combine(segments, nextseg);
+          segments = polyboolEps1.combine(segments, nextseg);
         } catch (err) {
-          segments = PolyBool.segments(PolyBool.polygon(segments));
-          nextseg = PolyBool.segments(PolyBool.polygon(nextseg));
           for (let j = 20; j >= 6; j -= 1) {
-            PolyBool.epsilon(Math.pow(0.1, j));
+            const polyboolEps2 = new PolyBool(new GeometryEpsilon(Math.pow(0.1, j)));
             try {
-              segments = PolyBool.combine(segments, nextseg);
+              segments = polyboolEps2.combine(segments, nextseg);
               break;
             } catch (err) {}
           }
-          PolyBool.epsilon(epsilon);
         }
-        if (segments.combined) {
-          segments.combined = segments.combined.filter(s => Math.abs(s.start[0] - s.end[0]) > epsilon || Math.abs(s.start[1] - s.end[1]) > epsilon);
-          segments = PolyBool[op](segments);
-        } else {
-          console.warn('Failed in polygon functions.');  // eslint-disable-line no-console
-        }
-        segments.segments = segments.segments.filter(s => Math.abs(s.start[0] - s.end[0]) > epsilon || Math.abs(s.start[1] - s.end[1]) > epsilon);
+        segments = polyboolEps1[op](segments);
       }
       newlist.push(segments);
     }
@@ -463,8 +455,8 @@ function generalOperationProcess(op, poly1, poly2, opts) {
   if (ingcs2 && gcs && ingcs2 !== gcs) {
     poly2 = poly2.map((p) => p.map((h) => transform.transformCoordinates(ingcs2, gcs, h)));
   }
-  let seglist1 = poly1.map(p => PolyBool.segments({regions: p}));
-  let seglist2 = poly2.map(p => PolyBool.segments({regions: p}));
+  let seglist1 = poly1.map(p => polybool.segments({regions: p}));
+  let seglist2 = poly2.map(p => polybool.segments({regions: p}));
   seglist1 = polygonOperationSeglist(opts.innerOperation || 'union', mode1.epsilon, seglist1);
   seglist2 = polygonOperationSeglist(opts.innerOperation || 'union', mode2.epsilon, seglist2);
   let seglist = seglist1;

src/util/polyops.js

@@ -106,16 +106,16 @@ describe('geo.util.polyops', function () {
     a: [[0, 0], [10, 0], [10, 10], [0, 10]],
     b: [[4, 4], [6, 4], [6, 6], [4, 6]],
     union: {out: [[0, 10], [0, 0], [10, 0], [10, 10]], ca: [[0]], cb: [undefined]},
-    difference: {out: [[[0, 10], [0, 0], [10, 0], [10, 10]], [[6, 6], [6, 4], [4, 4], [4, 6]]], ca: [[0]], cb: [[0]]},
+    difference: {out: [[[0, 10], [0, 0], [10, 0], [10, 10]], [[4, 4], [6, 4], [6, 6], [4, 6]]], ca: [[0]], cb: [[0]]},
     intersect: {out: [[4, 6], [4, 4], [6, 4], [6, 6]], ca: [undefined], cb: [[0]]},
-    xor: {out: [[[0, 10], [0, 0], [10, 0], [10, 10]], [[6, 6], [6, 4], [4, 4], [4, 6]]], ca: [[0]], cb: [[0]]}
+    xor: {out: [[[0, 10], [0, 0], [10, 0], [10, 10]], [[4, 4], [6, 4], [6, 6], [4, 6]]], ca: [[0]], cb: [[0]]}
   }, {
     a: [[0, 0], [10, 0], [10, 10], [0, 10]],
     b: [[-2, -2], [12, -2], [12, 12], [-2, 12]],
     union: {out: [[-2, 12], [-2, -2], [12, -2], [12, 12]], ca: [undefined], cb: [[0]]},
     difference: {out: undefined, ca: [undefined], cb: [undefined]},
     intersect: {out: [[0, 10], [0, 0], [10, 0], [10, 10]], ca: [[0]], cb: [undefined]},
-    xor: {out: [[[-2, 12], [-2, -2], [12, -2], [12, 12]], [[10, 10], [10, 0], [0, 0], [0, 10]]], ca: [[0]], cb: [[0]]}
+    xor: {out: [[[-2, 12], [-2, -2], [12, -2], [12, 12]], [[0, 0], [10, 0], [10, 10], [0, 10]]], ca: [[0]], cb: [[0]]}
   }];
 
   describe('general operations', function () {
@@ -129,6 +129,7 @@ describe('geo.util.polyops', function () {
             expect(opts.correspond.poly1).toEqual(test[op].ca);
             expect(opts.correspond.poly2).toEqual(test[op].cb);
 
+            opts.correspond = {};
             opts.poly1 = test.a;
             opts.poly2 = test.b;
             out = geo.util.polyops[op](opts);