@dra2020/baseclient 1.0.48 → 1.0.51

package/dist/geo/geo.d.ts

@@ -10,7 +10,14 @@ export declare type GeoCentroidMap = {
         y: number;
     };
 };
-export declare function geoEnsureID(col: GeoFeatureCollection): void;
+export interface NormalizeOptions {
+    joinPolygons?: boolean;
+    checkRewind?: boolean;
+    ensureID?: boolean;
+}
+export declare function geoEnsureID(col: GeoFeatureCollection, options?: NormalizeOptions): void;
+export declare function geoNormalizeFeature(f: any, options?: NormalizeOptions): GeoFeature;
+export declare function geoNormalizeCollection(col: GeoFeatureCollection, options?: NormalizeOptions): GeoFeatureCollection;
 export declare function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap;
 export declare function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection;
 export declare function geoMapToCollectionNonNull(map: GeoFeatureMap): GeoFeatureCollection;

package/dist/poly/topo.d.ts

@@ -8,6 +8,7 @@ export declare function topoToFeature(topo: Topo, geoid: string): any;
 export declare function topoToCollection(topo: Topo): any;
 export interface SimplifyOptions {
     minArea?: number;
+    log?: boolean;
 }
 export declare function topoSimplifyCollection(col: any, options?: SimplifyOptions): any;
 export declare function topoMerge(topo: Topo, geoids: string[]): any;

package/lib/geo/geo.ts

@@ -8,16 +8,40 @@ export type GeoFeatureArray = GeoFeature[];
 export type GeoFeatureCollection = geojson.FeatureCollection;
 export type GeoCentroidMap = { [geoid: string]: { x: number, y: number } };
 
-export function geoEnsureID(col: GeoFeatureCollection): void
+export interface NormalizeOptions
 {
+  joinPolygons?: boolean,
+  checkRewind?: boolean,
+  ensureID?: boolean,
+}
+const NormalizeAll: NormalizeOptions = { 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.
+//
+
+export function geoEnsureID(col: GeoFeatureCollection, options?: NormalizeOptions): void
+{
+  options = Util.shallowAssignImmutable({}, options);
+
   let prop: string;
-  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; });
+    if (f.properties.id !== undefined) 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
@@ -28,6 +52,94 @@ export function geoEnsureID(col: GeoFeatureCollection): void
   }
 }
 
+export function geoNormalizeFeature(f: any, options?: NormalizeOptions): GeoFeature
+{
+  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;
+}
+
+function onlyPolygons(col: GeoFeatureCollection): boolean
+{
+  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: any, f2: any): any
+{
+  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;
+}
+
+export function geoNormalizeCollection(col: GeoFeatureCollection, options?: NormalizeOptions): GeoFeatureCollection
+{
+  options = Util.shallowAssignImmutable(NormalizeAll, options);
+
+  // Normalize individual features
+  if (col && Array.isArray(col.features)) col.features.forEach((f: GeoFeature) => 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: GeoFeatureMap = {};
+    col.features.forEach(f => { let id = f.properties.id; map[id] = mergePolygon(map[id], f) });
+    col.features = Object.values(map);
+  }
+  return col;
+}
+
 export function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap
 {
   if (col == null) return null;

package/lib/poly/polylabel.ts

@@ -21,16 +21,66 @@ export function polyDistance(poly: any, x: number, y: number): number
   let pp = P.polyNormalize(poly);
   if (pp == null) return 0;
 
-  let forEachPointPair = (iter: any) => {
-      PP.polyPackEachRing(pp, (b: Float64Array, iPoly, iRing: number, iOffset: number, nPoints: number) => {
-          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: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      // 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: any) => {
+          PP.polyPackEachRing(pp, (b: Float64Array, iInteriorPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+              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: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      // 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: any) => {
+          PP.polyPackEachRing(pp, (b: Float64Array, iInteriorPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+              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;
 }
 
 //
@@ -69,7 +119,7 @@ export function polyLabel(poly: any, precision?: number, debug?: boolean): PolyL
           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]);
         });
     };
 
@@ -164,38 +214,15 @@ class Cell
 // signed distance from point to polygon outline (negative if point is outside)
 function pointToPolygonDist(x: number, y: number, forEachPointPair: any): number
 {
-  let iPolyLast = -1;
-  let iRingLast = -1;
   let inside = false;
-  let thisInside = false;
-  let useInside = false;
-  let isHole = false;
-  let minDistSq: number = Infinity;
+  let minDistSq = Infinity;
 
-  forEachPointPair((iPoly: number, iRing: number, ax: number, ay: number, bx: number, by: number) => {
-      if (iPoly != iPolyLast || iRing != iRingLast)
-      {
-        if (useInside)
-          inside = isHole ? ! thisInside : thisInside;
-        iPolyLast = iPoly;
-        iRingLast = iRing;
-        thisInside = false;
-        useInside = false;
-        isHole = false;
-      }
+  forEachPointPair((ax: number, ay: number, bx: number, by: number) => {
       if ((ay > y !== by > y) && (x < (bx - ax) * (y - ay) / (by - ay) + ax))
-        thisInside = !thisInside;
+        inside = !inside;
 
-      let thisDistSq = getSegDistSq(x, y, ax, ay, bx, by);
-      if (thisDistSq < minDistSq)
-      {
-        minDistSq = thisDistSq;
-        useInside = true;
-        isHole = iRing != 0;
-      }
+      minDistSq = Math.min(minDistSq, getSegDistSq(x, y, ax, ay, bx, by));
     });
-  if (useInside)
-    inside = isHole ? ! thisInside : thisInside;
 
   return (inside ? 1 : -1) * Math.sqrt(minDistSq);
 }
@@ -209,7 +236,7 @@ function getCentroidCell(forEachPointPair: any): Cell
   let fx: number;
   let fy: number;
 
-  forEachPointPair((iPoly: number, iRing: number, ax: number, ay: number, bx: number, by: number) => {
+  forEachPointPair((ax: number, ay: number, bx: number, by: number) => {
       if (fx === undefined) fx = ax, fy = ay;
       let f: number = ax * by - bx * ay;
       x += (ax + bx) * f;

package/lib/poly/topo.ts

@@ -215,13 +215,14 @@ function intpt(f: any): { x: number, y: number }
 export interface SimplifyOptions
 {
   minArea?: number,
+  log?: boolean,
 }
 
 const DefaultSimplifyOptions: SimplifyOptions = { minArea: 500 };
 
-function log(s: string): void
+function log(emitlog: boolean, s: string): void
 {
-  console.log(s);
+  if (emitlog) console.log(s);
 }
 
 //
@@ -248,10 +249,10 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
   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
@@ -328,19 +329,19 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
                 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;
 
@@ -356,7 +357,7 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
     nTries++;
   }
 
-  log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
+  log(options.log, `topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
 
   return col;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.48",
+  "version": "1.0.51",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",