@dra2020/baseclient 1.0.48 → 1.0.51

package/dist/baseclient.js

@@ -1345,18 +1345,31 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.geoIntersect = exports.geoIntersectOptions = exports.GeoMultiCollection = exports.geoMapEqual = exports.geoEqual = exports.geoTopoToCollectionNonNull = exports.geoTopoToCollection = exports.geoCollectionToTopoNonNull = exports.geoCollectionToTopo = exports.geoMapToCollectionNonNull = exports.geoMapToCollection = exports.geoCollectionToMap = exports.geoEnsureID = void 0;
+exports.geoIntersect = exports.geoIntersectOptions = exports.GeoMultiCollection = exports.geoMapEqual = exports.geoEqual = exports.geoTopoToCollectionNonNull = exports.geoTopoToCollection = exports.geoCollectionToTopoNonNull = exports.geoCollectionToTopo = exports.geoMapToCollectionNonNull = exports.geoMapToCollection = exports.geoCollectionToMap = exports.geoNormalizeCollection = exports.geoNormalizeFeature = exports.geoEnsureID = void 0;
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 const Poly = __importStar(__webpack_require__(/*! ../poly/all */ "./lib/poly/all.ts"));
-function geoEnsureID(col) {
+const NormalizeAll = { joinPolygons: true, checkRewind: true, ensureID: true };
+// set the canonical 'id' property from the best property value.
+// if joinPolygons is true, we do not enforce uniqueness.
+//
+function geoEnsureID(col, options) {
+    options = Util.shallowAssignImmutable({}, options);
     let prop;
-    const props = ['id', 'GEOID', 'GEOID10', 'GEOID20', 'GEOID30'];
+    const props = ['id', 'GEOID', 'GEOID10', 'GEOID20', 'GEOID30', 'DISTRICT', 'DISTRICTNO', 'DISTRICTNAME'];
     if (col && col.features && col.features.length > 0) {
         let f = col.features[0];
         if (f.properties.id !== undefined)
-            return;
-        props.forEach(p => { if (prop === undefined && f.properties[p] !== undefined)
-            prop = p; });
+            return; // short-cut - assume if 'id' is set, we're all good.
+        props.forEach(p => {
+            if (prop === undefined)
+                if (f.properties[p] !== undefined)
+                    prop = p;
+                else {
+                    p = p.toLowerCase();
+                    if (f.properties[p] !== undefined)
+                        prop = p;
+                }
+        });
         if (prop)
             col.features.forEach(f => { f.properties.id = f.properties[prop]; });
         else {
@@ -1366,6 +1379,77 @@ function geoEnsureID(col) {
     }
 }
 exports.geoEnsureID = geoEnsureID;
+function geoNormalizeFeature(f, options) {
+    options = Util.shallowAssignImmutable({}, options);
+    if (f && f.geometry && f.geometry.type === 'MultiPolygon' && f.geometry.coordinates) {
+        let multiPoly = f.geometry.coordinates;
+        // Convert degenerate MultiPolygon to Polygon
+        if (multiPoly.length == 1) {
+            f.geometry.type = 'Polygon';
+            f.geometry.coordinates = multiPoly[0];
+        }
+    }
+    else if (f && f.geometry && f.geometry.type === 'Point' && f.geometry.coordinates) {
+        while (Array.isArray(f.geometry.coordinates[0]))
+            f.geometry.coordinates = f.geometry.coordinates[0];
+    }
+    else if (options.checkRewind)
+        // Various tools do not guarantee valid GeoJSON winding rules. Verify it since internal processing
+        // assumes it is correct.
+        Poly.featureRewind(f);
+    return f;
+}
+exports.geoNormalizeFeature = geoNormalizeFeature;
+function onlyPolygons(col) {
+    if (col && Array.isArray(col.features))
+        for (let i = 0; i < col.features.length; i++) {
+            let f = col.features[i];
+            if (f.geometry && f.geometry.type === 'MultiPolygon')
+                return false;
+        }
+    return true;
+}
+function mergePolygon(f1, f2) {
+    if (!f1)
+        return f2;
+    if (!f2)
+        return f1;
+    if (f1.geometry.type !== 'Polygon' && f1.geometry.type !== 'MultiPolygon')
+        return f1;
+    if (f2.geometry.type !== 'Polygon' && f2.geometry.type !== 'MultiPolygon')
+        return f2;
+    if (f1.geometry.type === 'Polygon') {
+        f1.geometry.type = 'MultiPolygon';
+        if (f2.geometry.type === 'Polygon')
+            f1.geometry.coordinates = [f1.geometry.coordinates, f2.geometry.coordinates];
+        else
+            f1.geometry.coordinates = [f1.geometry.coordinates, ...f2.geometry.coordinates];
+    }
+    else {
+        if (f2.geometry.type === 'Polygon')
+            f1.geometry.coordinates.push(f2.geometry.coordinates);
+        else
+            f1.geometry.coordinates = [...f1.geometry.coordinates, ...f2.geometry.coordinates];
+    }
+    return f1;
+}
+function geoNormalizeCollection(col, options) {
+    options = Util.shallowAssignImmutable(NormalizeAll, options);
+    // Normalize individual features
+    if (col && Array.isArray(col.features))
+        col.features.forEach((f) => geoNormalizeFeature(f, options));
+    // Ensure ID
+    if (options.ensureID)
+        geoEnsureID(col, options);
+    // Merge polygons into multi-polygons based on id?
+    if (options.ensureID && options.joinPolygons && onlyPolygons(col)) {
+        let map = {};
+        col.features.forEach(f => { let id = f.properties.id; map[id] = mergePolygon(map[id], f); });
+        col.features = Object.values(map);
+    }
+    return col;
+}
+exports.geoNormalizeCollection = geoNormalizeCollection;
 function geoCollectionToMap(col) {
     if (col == null)
         return null;
@@ -6874,16 +6958,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 +7058,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 +7132,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 +7148,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;
@@ -8520,8 +8635,9 @@ function intpt(f) {
     return { x: x, y: y };
 }
 const DefaultSimplifyOptions = { minArea: 500 };
-function log(s) {
-    console.log(s);
+function log(emitlog, s) {
+    if (emitlog)
+        console.log(s);
 }
 //
 // topoSimplifyCollection:
@@ -8545,10 +8661,10 @@ function topoSimplifyCollection(col, options) {
     let elapsedTotal = new Util.Elapsed();
     let elapsed = new Util.Elapsed();
     let topo = topoFromCollection(col);
-    log(`topoSimplifyCollection: fromCollection: ${Math.round(elapsed.ms())}ms`);
+    log(options.log, `topoSimplifyCollection: fromCollection: ${Math.round(elapsed.ms())}ms`);
     elapsed.start();
     topo = TopoSimplify.presimplify(topo, TopoSimplify['sphericalTriangleArea']);
-    log(`topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
+    log(options.log, `topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
     elapsed.start();
     // Keep iterating on removing simplification from degenerate shapes
     let nTries = 1;
@@ -8613,17 +8729,17 @@ function topoSimplifyCollection(col, options) {
                             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}`);
+                            log(options.log, `topoSimplifyCollection: ${f.properties.id}: increasing feature fidelity because intpt dist is ${d}`);
                         }
                     }
                 }
             }
         });
-        log(`topoSimplifyCollection: pass ${nTries}: ${nBad} (${nTiny} tiny) of ${col.features.length} features are degenerate`);
+        log(options.log, `topoSimplifyCollection: pass ${nTries}: ${nBad} (${nTiny} tiny) of ${col.features.length} features are degenerate`);
         // If not making progress, keep more points
         if (nBad >= nBadLast) {
             keepweight /= 10;
-            log(`topoSimplifyCollection: pass ${nTries}: reducing weight limit to ${keepweight}`);
+            log(options.log, `topoSimplifyCollection: pass ${nTries}: reducing weight limit to ${keepweight}`);
         }
         nBadLast = nBad;
         if (nBad && nTries > MAX_TRIES)
@@ -8635,7 +8751,7 @@ function topoSimplifyCollection(col, options) {
         }
         nTries++;
     }
-    log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
+    log(options.log, `topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
     return col;
 }
 exports.topoSimplifyCollection = topoSimplifyCollection;