@dra2020/baseclient 1.0.101 → 1.0.102

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) {