@dra2020/baseclient 1.0.46 → 1.0.49

package/dist/baseclient.js

@@ -6874,16 +6874,68 @@ function polyDistance(poly, x, y) {
     let pp = P.polyNormalize(poly);
     if (pp == null)
         return 0;
-    let forEachPointPair = (iter) => {
-        PP.polyPackEachRing(pp, (b, iPoly, iRing, iOffset, nPoints) => {
-            let iFirst = iOffset;
-            let iLast = iOffset + nPoints * 2;
-            let iSecond = iLast - 2;
-            for (; iFirst < iLast; iSecond = iFirst, iFirst += 2)
-                iter(iPoly, iRing, b[iFirst], b[iFirst + 1], b[iSecond], b[iSecond + 1]);
-        });
-    };
-    return pointToPolygonDist(x, y, forEachPointPair);
+    // First find if it is contained in one of the outer polygons, or outside all outer polygons
+    let iContaining = -1;
+    let maxOutside = -Infinity;
+    let minInside = Infinity;
+    let noholes = true;
+    PP.polyPackEachRing(pp, (b, iPoly, iRing, iOffset, nPoints) => {
+        // If we have determined we are inside this polygon, keep track of whether it has holes
+        if (iContaining == iPoly && iRing > 0)
+            noholes = false;
+        // Don't process rings
+        if (iRing > 0)
+            return;
+        // OK, get distance
+        let forEachPointPair = (iter) => {
+            PP.polyPackEachRing(pp, (b, iInteriorPoly, iRing, iOffset, nPoints) => {
+                if (iRing || iInteriorPoly != iPoly)
+                    return;
+                let iFirst = iOffset;
+                let iLast = iOffset + nPoints * 2;
+                let iSecond = iLast - 2;
+                for (; iFirst < iLast; iSecond = iFirst, iFirst += 2)
+                    iter(b[iFirst], b[iFirst + 1], b[iSecond], b[iSecond + 1]);
+            });
+        };
+        let dist = pointToPolygonDist(x, y, forEachPointPair);
+        // If inside, is it closest inside (deal with multipolygons that self-contain - think filled donut)
+        if (dist > 0 && dist < minInside) {
+            iContaining = iPoly;
+            minInside = dist;
+            noholes = true;
+        }
+        else if (dist < 0)
+            maxOutside = Math.max(maxOutside, dist);
+    });
+    if (iContaining < 0)
+        return maxOutside;
+    if (noholes)
+        return minInside;
+    // OK, now need to worry about holes in the polygon it is contained in
+    PP.polyPackEachRing(pp, (b, iPoly, iRing, iOffset, nPoints) => {
+        // Only want to look at the holes for the containing polygon
+        if (iPoly != iContaining || iRing == 0)
+            return;
+        // Compute distance to those holes
+        let forEachPointPair = (iter) => {
+            PP.polyPackEachRing(pp, (b, iInteriorPoly, iRing, iOffset, nPoints) => {
+                if (iInteriorPoly != iContaining || iRing == 0)
+                    return;
+                let iFirst = iOffset;
+                let iLast = iOffset + nPoints * 2;
+                let iSecond = iLast - 2;
+                for (; iFirst < iLast; iSecond = iFirst, iFirst += 2)
+                    iter(b[iFirst], b[iFirst + 1], b[iSecond], b[iSecond + 1]);
+            });
+        };
+        // Negate distance since dealing with holes
+        let dist = -pointToPolygonDist(x, y, forEachPointPair);
+        // We take the min to either get a negative value (inside hole) or a smaller positive value
+        // (outside hole but close to hole boundary).
+        minInside = Math.min(minInside, dist);
+    });
+    return minInside;
 }
 exports.polyDistance = polyDistance;
 //
@@ -6922,7 +6974,7 @@ function polyLabel(poly, precision, debug) {
             let iLast = iOffset + nPoints * 2;
             let iSecond = iLast - 2;
             for (; iFirst < iLast; iSecond = iFirst, iFirst += 2)
-                iter(iPoly, iRing, b[iFirst], b[iFirst + 1], b[iSecond], b[iSecond + 1]);
+                iter(b[iFirst], b[iFirst + 1], b[iSecond], b[iSecond + 1]);
         });
     };
     // find the bounding box of the outer ring
@@ -6996,34 +7048,13 @@ class Cell {
 }
 // signed distance from point to polygon outline (negative if point is outside)
 function pointToPolygonDist(x, y, forEachPointPair) {
-    let iPolyLast = -1;
-    let iRingLast = -1;
     let inside = false;
-    let thisInside = false;
-    let useInside = false;
-    let isHole = false;
     let minDistSq = Infinity;
-    forEachPointPair((iPoly, iRing, ax, ay, bx, by) => {
-        if (iPoly != iPolyLast || iRing != iRingLast) {
-            if (useInside)
-                inside = isHole ? !thisInside : thisInside;
-            iPolyLast = iPoly;
-            iRingLast = iRing;
-            thisInside = false;
-            useInside = false;
-            isHole = false;
-        }
+    forEachPointPair((ax, ay, bx, by) => {
         if ((ay > y !== by > y) && (x < (bx - ax) * (y - ay) / (by - ay) + ax))
-            thisInside = !thisInside;
-        let thisDistSq = getSegDistSq(x, y, ax, ay, bx, by);
-        if (thisDistSq < minDistSq) {
-            minDistSq = thisDistSq;
-            useInside = true;
-            isHole = iRing != 0;
-        }
+            inside = !inside;
+        minDistSq = Math.min(minDistSq, getSegDistSq(x, y, ax, ay, bx, by));
     });
-    if (useInside)
-        inside = isHole ? !thisInside : thisInside;
     return (inside ? 1 : -1) * Math.sqrt(minDistSq);
 }
 // get polygon centroid
@@ -7033,7 +7064,7 @@ function getCentroidCell(forEachPointPair) {
     let y = 0;
     let fx;
     let fy;
-    forEachPointPair((iPoly, iRing, ax, ay, bx, by) => {
+    forEachPointPair((ax, ay, bx, by) => {
         if (fx === undefined)
             fx = ax, fy = ay;
         let f = ax * by - bx * ay;
@@ -8350,7 +8381,6 @@ const P = __importStar(__webpack_require__(/*! ./poly */ "./lib/poly/poly.ts"));
 const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
 const PL = __importStar(__webpack_require__(/*! ./polylabel */ "./lib/poly/polylabel.ts"));
 const shamos_1 = __webpack_require__(/*! ./shamos */ "./lib/poly/shamos.ts");
-const pointinpoly_1 = __webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts");
 function getGEOID(f) {
     if (f.features && f.features.length)
         f = f.features[0];
@@ -8601,16 +8631,20 @@ function topoSimplifyCollection(col, options) {
                 }
                 if (!bDecided) {
                     let pp = PP.polyPackTopoArcs(testtopo, arcs);
+                    P.polyRewindRings(pp);
                     if (shamos_1.selfIntersectFast(pp)) {
                         keepArcs(topo, oOld.arcs, keepweight);
                         nBad++;
                     }
                     else {
                         let { x, y } = intpt(f);
-                        if (x && y && !pointinpoly_1.polyContainsPoint(pp, x, y)) {
-                            keepArcs(topo, oOld.arcs, keepweight);
-                            nBad++;
-                            log(`topoSimplifyCollection: ${f.properties.id}: increasing feature fidelity because of intpt problem`);
+                        let d = PL.polyDistance(pp, x, y);
+                        if (d < 0.00001) // d is negative if outside the polygon, so that qualifies here
+                         {
+                            keepTiny.set(f, f);
+                            keepArcs(topo, oOld.arcs, 0); // keeps all points to avoid reprocessing these tiny shapes
+                            nBad++, nTiny++;
+                            log(`topoSimplifyCollection: ${f.properties.id}: increasing feature fidelity because intpt dist is ${d}`);
                         }
                     }
                 }