@dra2020/baseclient 1.0.101 → 1.0.103

package/dist/baseclient.js

@@ -5938,6 +5938,7 @@ __exportStar(__webpack_require__(/*! ./selfintersect */ "./lib/poly/selfintersec
 __exportStar(__webpack_require__(/*! ./shamos */ "./lib/poly/shamos.ts"), exports);
 __exportStar(__webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts"), exports);
 __exportStar(__webpack_require__(/*! ./mapto */ "./lib/poly/mapto.ts"), exports);
+__exportStar(__webpack_require__(/*! ./featurecleanholes */ "./lib/poly/featurecleanholes.ts"), exports);
 
 
 /***/ }),
@@ -6241,6 +6242,91 @@ function polyDiameterFlat(poly) {
 exports.polyDiameterFlat = polyDiameterFlat;
 
 
+/***/ }),
+
+/***/ "./lib/poly/featurecleanholes.ts":
+/*!***************************************!*\
+  !*** ./lib/poly/featurecleanholes.ts ***!
+  \***************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.featureCleanHoles = void 0;
+const union_1 = __webpack_require__(/*! ./union */ "./lib/poly/union.ts");
+const poly_1 = __webpack_require__(/*! ./poly */ "./lib/poly/poly.ts");
+function flattenMultiPoly(polys) {
+    let c = [];
+    polys.forEach((poly) => {
+        poly.forEach((ring) => {
+            c.push([ring]);
+        });
+    });
+    return c;
+}
+// Handed a multipolygon that may not have been properly structured as outer rings and inner holes, fix it up.
+// This is relatively expensive since we compute intersection areas to test for holes.
+//
+function featureCleanHoles(f) {
+    if (!f
+        || f.type !== 'Feature'
+        || !f.geometry
+        || f.geometry.type !== 'MultiPolygon'
+        || !Array.isArray(f.geometry.coordinates))
+        return f;
+    // Normalize to flattened polygon
+    f.geometry.coordinates = flattenMultiPoly(f.geometry.coordinates);
+    let polys = f.geometry.coordinates;
+    let areas = polys.map(poly_1.polyArea);
+    // Compute 'top triangle' of overlap grid, then reflect
+    let overlaps = polys.map((p1, i) => {
+        return polys.map((p2, j) => { return j <= i ? false : (0, union_1.polyIntersects)(p1, p2); });
+    });
+    // Now reflect
+    let n = polys.length;
+    for (let i = 0; i < n - 1; i++)
+        for (let j = i + 1; j < n; j++)
+            overlaps[j][i] = overlaps[i][j];
+    // The outer polygon is one that
+    //  1. Overlaps with this one
+    //  2. Has a larger area than this one
+    //  3. Has the smallest area of any that overlap
+    //  4. There are an odd number of polygons that satisfy 1 and 2.  (This allows nesting of polygons inside holes.)
+    //
+    function findOuter(i) {
+        let jOuter = -1;
+        let aOuter = 0;
+        let nOverlap = 0;
+        for (let j = 0; j < n; j++)
+            if (overlaps[i][j] && areas[j] > areas[i]) {
+                nOverlap++;
+                if (jOuter < 0 || areas[j] < aOuter) {
+                    jOuter = j;
+                    aOuter = areas[j];
+                }
+            }
+        return (nOverlap % 2) == 1 ? jOuter : -1;
+    }
+    // Walk through and match up holes with their containers
+    for (let i = 0; i < n; i++) {
+        let j = findOuter(i);
+        if (j >= 0) {
+            polys[j].push(polys[i][0]);
+            polys[i] = [];
+        }
+    }
+    // Delete outer shell of hole rings that were moved
+    f.geometry.coordinates = polys.filter((p) => p.length > 0);
+    // Degenerate multi-polygon
+    if (f.geometry.coordinates.length == 1) {
+        f.geometry.type = 'Polygon';
+        f.geometry.coordinates = f.geometry.coordinates[0];
+    }
+    return f;
+}
+exports.featureCleanHoles = featureCleanHoles;
+
+
 /***/ }),
 
 /***/ "./lib/poly/graham-scan.ts":
@@ -7233,6 +7319,7 @@ exports.polyBadCoordinates = exports.polyRewindRings = exports.featureRewind = e
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
 const graham_scan_1 = __webpack_require__(/*! ./graham-scan */ "./lib/poly/graham-scan.ts");
+const featurecleanholes_1 = __webpack_require__(/*! ./featurecleanholes */ "./lib/poly/featurecleanholes.ts");
 exports.DefaultTickOptions = { maxLeafCount: 256, maxDepth: 20, tickStep: 1 };
 // Internal utilities
 exports.EARTH_RADIUS = 6371000; // Radius of earth in meters
@@ -7749,7 +7836,7 @@ function closePoly(poly) {
     poly.forEach(closeRing);
     return poly;
 }
-function closeFeature(f) {
+function featureClose(f) {
     let d = Util.depthof(f.geometry.coordinates);
     if (d === 4)
         closePoly(f.geometry.coordinates);
@@ -7793,6 +7880,15 @@ function polyRingWindings(poly) {
     return windings;
 }
 exports.polyRingWindings = polyRingWindings;
+function flattenMultiPoly(polys) {
+    let c = [];
+    polys.forEach((poly) => {
+        poly.forEach((ring) => {
+            c.push([ring]);
+        });
+    });
+    return c;
+}
 // This mutates the passed in feature to ensure it is correctly wound
 // For convenience, passed back the value provided.
 //
@@ -7810,53 +7906,16 @@ function featureRewind(f, options) {
         return canonicalPoint(f, options);
     // Make sure polygon is closed (first === last)
     if (options.validateClose)
-        closeFeature(f);
+        featureClose(f);
     // Check if multi-polygon is really polygon with holes
-    // Only applies to multi-polygons with no holes
-    let d = Util.depthof(f.geometry.coordinates);
-    let windings = polyRingWindings(f);
-    if (options.validateHoles && d === 5 && windings.length > 1) {
-        // First winding needs to be correct so we have a poly to add holes to
-        if (!misWound(windings[0])) {
-            // Flatten everything out and then rebuild hole structure based on windings
-            let nHoles = 0;
-            windings.forEach(w => { nHoles += w.iRing ? 1 : 0; });
-            if (nHoles) {
-                let c = [];
-                f.geometry.coordinates.forEach((poly) => {
-                    poly.forEach((ring) => {
-                        c.push([ring]);
-                    });
-                });
-                f.geometry.coordinates = c;
-                windings = polyRingWindings(f);
-            }
-            let polys = f.geometry.coordinates;
-            let iPoly = 0;
-            for (let iWinding = 0; iWinding < windings.length; iWinding++) {
-                let good = !misWound(windings[iWinding]);
-                if (good)
-                    iPoly = iWinding;
-                else {
-                    // If hole, add to previous poly
-                    polys[iPoly].push(polys[iWinding][0]);
-                    polys[iWinding] = null;
-                }
-            }
-            f.geometry.coordinates = polys.filter((p) => p != null);
-        }
-        // Degenerate multi-polygon
-        if (f.geometry.coordinates.length == 1) {
-            f.geometry.type = 'Polygon';
-            f.geometry.coordinates = f.geometry.coordinates[0];
-            d = 4;
-        }
-    }
+    if (options.validateHoles)
+        (0, featurecleanholes_1.featureCleanHoles)(f);
     // OK, now go through each ring
     let polys = f.geometry.coordinates;
+    let d = Util.depthof(f.geometry.coordinates);
     if (d == 4)
         polys = [polys];
-    windings = polyRingWindings(f);
+    let windings = polyRingWindings(f);
     windings.forEach((w) => {
         let good = !misWound(w);
         if (!good) {
@@ -10035,18 +10094,16 @@ exports.topoMergeFeatures = topoMergeFeatures;
 let UniqueState = FSM.FSM_CUSTOM1;
 let FSM_COMPUTING = UniqueState++;
 class FsmIncrementalUnion extends FSM.Fsm {
-    constructor(env, options, key, map) {
+    constructor(env, options, multi, key, map) {
         super(env);
         this.options = options;
+        this.multi = multi;
         this.key = key;
         this.result = null;
         this.map = null;
         if (map)
             this.recompute(map);
     }
-    matches(key) {
-        return Util.shallowEqual(this.key, key);
-    }
     recompute(map) {
         if (this.map != null && map != null && Util.shallowEqual(map, this.map)) {
             this.work = { nUnion: 0, nDifference: 0, ms: 0 };
@@ -10060,7 +10117,7 @@ class FsmIncrementalUnion extends FSM.Fsm {
             let values = Object.values(map);
             this.work = { nUnion: values.length, nDifference: 0, ms: 0 };
             let elapsed = new Util.Elapsed();
-            this.result = topoMergeFeatures(this.key.multi.allTopo(), values);
+            this.result = topoMergeFeatures(this.multi.allTopo(), values);
             this.work.ms = elapsed.ms();
             this.map = map;
         }
@@ -10086,41 +10143,36 @@ class FsmTopoUnion extends FSM.Fsm {
     constructor(env, options) {
         super(env);
         this.options = Util.shallowAssignImmutable(P.DefaultTickOptions, options);
-        this.unions = [];
+        this.unions = {};
         this.work = { nUnion: 0, nDifference: 0, ms: 0 };
     }
     get result() {
-        if (this.unions.length > 0 && this.state === FSM.FSM_DONE)
-            return this.unions.map((i) => ({ key: i.key, poly: i.result, work: i.work }));
+        if (Util.countKeys(this.unions) > 0 && this.state === FSM.FSM_DONE)
+            return Object.values(this.unions).map((i) => ({ key: i.key, poly: i.result, work: i.work }));
         else
             return null;
     }
     cancel() {
-        this.unions.forEach((i) => {
+        Object.values(this.unions).forEach((i) => {
             i.cancel();
         });
-        this.unions = [];
+        this.unions = {};
         this.setState(FSM.FSM_DONE);
     }
     cancelOne(key) {
-        for (let i = 0; i < this.unions.length; i++) {
-            let u = this.unions[i];
-            if (u.matches(key)) {
-                u.cancel();
-                return;
-            }
-        }
+        let u = this.unions[key];
+        if (u)
+            u.cancel();
     }
-    recompute(key, map) {
-        let fsm = this.unions.find((i) => i.matches(key));
-        if (fsm == null) {
-            fsm = new FsmIncrementalUnion(this.env, this.options, key, map);
-            this.unions.push(fsm);
+    recompute(multi, key, map) {
+        let fsm = this.unions[key];
+        if (fsm == null || fsm.multi !== multi) {
+            fsm = new FsmIncrementalUnion(this.env, this.options, multi, key, map);
+            this.unions[key] = fsm;
         }
         else
             fsm.recompute(map);
         this.work = { nUnion: 0, nDifference: 0, ms: 0 };
-        this.unions.forEach((u) => { this.work.nUnion += u.work.nUnion; this.work.nDifference += u.work.nDifference; });
         this.waitOn(fsm);
         this.setState(FSM_COMPUTING);
     }
@@ -10129,8 +10181,13 @@ class FsmTopoUnion extends FSM.Fsm {
             switch (this.state) {
                 case FSM.FSM_STARTING:
                 case FSM_COMPUTING:
+                    this.work = { nUnion: 0, nDifference: 0, ms: 0 };
                     if (this.unions)
-                        this.unions.forEach((u) => { this.work.ms += u.work.ms; });
+                        Object.values(this.unions).forEach((i) => {
+                            this.work.ms += i.work.ms;
+                            this.work.nUnion += i.work.nUnion;
+                            this.work.nDifference += i.work.nDifference;
+                        });
                     this.setState(FSM.FSM_DONE);
                     break;
             }