@dra2020/baseclient 1.0.101 → 1.0.103

package/dist/poly/all.d.ts

@@ -15,3 +15,4 @@ export * from './selfintersect';
 export * from './shamos';
 export * from './pointinpoly';
 export * from './mapto';
+export * from './featurecleanholes';

package/dist/poly/featurecleanholes.d.ts

@@ -0,0 +1 @@
+export declare function featureCleanHoles(f: any): any;

package/dist/poly/topo.d.ts

@@ -1,4 +1,5 @@
 import * as FSM from '../fsm/all';
+import * as G from '../geo/all';
 import * as P from './poly';
 import * as Q from './quad';
 export declare type Topo = any;
@@ -15,30 +16,32 @@ export declare function topoMerge(topo: Topo, geoids: string[]): any;
 export declare function topoMergeFeatures(topo: Topo, features: any[]): any;
 declare class FsmIncrementalUnion extends FSM.Fsm {
     options: P.TickOptions;
-    key: any;
+    key: number;
+    multi: G.GeoMultiCollection;
     map: any;
     result: any;
     work: Q.WorkDone;
-    constructor(env: FSM.FsmEnvironment, options: P.TickOptions, key: any, map?: any);
-    matches(key: any): boolean;
+    constructor(env: FSM.FsmEnvironment, options: P.TickOptions, multi: G.GeoMultiCollection, key: number, map?: any);
     recompute(map: any): void;
     cancel(): void;
     tick(): void;
 }
 export interface TopoUnionResult {
-    key: any;
+    key: number;
     poly: any;
     work: Q.WorkDone;
 }
 export declare class FsmTopoUnion extends FSM.Fsm {
     options: P.TickOptions;
-    unions: FsmIncrementalUnion[];
+    unions: {
+        [index: number]: FsmIncrementalUnion;
+    };
     work: Q.WorkDone;
     constructor(env: FSM.FsmEnvironment, options?: P.TickOptions);
     get result(): TopoUnionResult[];
     cancel(): void;
-    cancelOne(key: any): void;
-    recompute(key: any, map: any): void;
+    cancelOne(key: number): void;
+    recompute(multi: G.GeoMultiCollection, key: number, map: any): void;
     tick(): void;
 }
 export declare function topoPacked(topo: any): boolean;

package/lib/poly/all.ts

@@ -15,3 +15,4 @@ export * from './selfintersect';
 export * from './shamos';
 export * from './pointinpoly';
 export * from './mapto';
+export * from './featurecleanholes';

package/lib/poly/featurecleanholes.ts

@@ -0,0 +1,89 @@
+import { polyIntersects } from './union';
+import { polyArea } from './poly';
+
+function flattenMultiPoly(polys: any): any
+{
+  let c: any[] = [];
+  polys.forEach((poly: any) => {
+      poly.forEach((ring: any) => {
+          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.
+//
+export function featureCleanHoles(f: any): any
+{
+  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: number[] = polys.map(polyArea);
+  // Compute 'top triangle' of overlap grid, then reflect
+  let overlaps: boolean[][] = polys.map((p1: any, i: number) => {
+      return polys.map((p2: any, j: number) => { return j <= i ? false : 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: number): number
+  {
+    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: any[]) => 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;
+}

package/lib/poly/poly.ts

@@ -2,6 +2,8 @@ import * as Util from '../util/all';
 
 import * as PP from './polypack';
 import { makeConvexHullGrahamScan } from './graham-scan';
+import { polyIntersects } from './union';
+import { featureCleanHoles } from './featurecleanholes';
 
 // For incremental poly interface
 export interface TickOptions
@@ -667,7 +669,7 @@ function closePoly(poly: any): any
   return poly;
 }
 
-function closeFeature(f: any): void
+function featureClose(f: any): void
 {
   let d = Util.depthof(f.geometry.coordinates);
   if (d === 4) closePoly(f.geometry.coordinates);
@@ -738,6 +740,16 @@ export function polyRingWindings(poly: any): Winding[]
   return windings;
 }
 
+function flattenMultiPoly(polys: any): any
+{
+  let c: any[] = [];
+  polys.forEach((poly: any) => {
+      poly.forEach((ring: any) => {
+          c.push([ring]);
+        });
+    });
+  return c;
+}
 
 // This mutates the passed in feature to ensure it is correctly wound
 // For convenience, passed back the value provided.
@@ -756,61 +768,18 @@ export function featureRewind(f: any, options?: RewindOptions): any
   if (f.geometry.type !== 'Polygon' && f.geometry.type !== 'MultiPolygon') return canonicalPoint(f, options);
 
   // Make sure polygon is closed (first === last)
-  if (options.validateClose) closeFeature(f);
+  if (options.validateClose)
+    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: any[] = [];
-        f.geometry.coordinates.forEach((poly: any) => {
-            poly.forEach((ring: any) => {
-                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: any) => 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)
+    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: Winding) => {
       let good = !misWound(w);
       if (!good)

package/lib/poly/topo.ts

@@ -8,6 +8,7 @@ import * as TopoSimplify from '@dra2020/topojson-simplify';
 
 import * as Util from '../util/all';
 import * as FSM from '../fsm/all';
+import * as G from '../geo/all';
 
 import * as P from './poly';
 import * as Q from './quad';
@@ -362,26 +363,23 @@ let FSM_COMPUTING = UniqueState++;
 class FsmIncrementalUnion extends FSM.Fsm
 {
   options: P.TickOptions;
-  key: any;
+  key: number;
+  multi: G.GeoMultiCollection;
   map: any; // { [geoid: string]: Feature }
   result: any;
   work: Q.WorkDone;
 
-  constructor(env: FSM.FsmEnvironment, options: P.TickOptions, key: any, map?: any)
+  constructor(env: FSM.FsmEnvironment, options: P.TickOptions, multi: G.GeoMultiCollection, key: number, map?: any)
   {
     super(env);
     this.options = options;
+    this.multi = multi;
     this.key = key;
     this.result = null;
     this.map = null;
     if (map) this.recompute(map);
   }
 
-  matches(key: any): boolean
-  {
-    return Util.shallowEqual(this.key, key);
-  }
-
   recompute(map: any): void
   {
     if (this.map != null && map != null && Util.shallowEqual(map, this.map))
@@ -399,7 +397,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;
     }
@@ -430,7 +428,7 @@ class FsmIncrementalUnion extends FSM.Fsm
 
 export interface TopoUnionResult
 {
-  key: any;
+  key: number;
   poly: any;
   work: Q.WorkDone;
 }
@@ -438,59 +436,51 @@ export interface TopoUnionResult
 export class FsmTopoUnion extends FSM.Fsm
 {
   options: P.TickOptions;
-  unions: FsmIncrementalUnion[];
+  unions: { [index: number]: FsmIncrementalUnion };
   work: Q.WorkDone;
 
   constructor(env: FSM.FsmEnvironment, options?: P.TickOptions)
   {
     super(env);
     this.options = Util.shallowAssignImmutable(P.DefaultTickOptions, options);
-    this.unions = [];
+    this.unions = {};
     this.work = { nUnion: 0, nDifference: 0, ms: 0 };
   }
 
   get result(): TopoUnionResult[]
   {
-    if (this.unions.length > 0 && this.state === FSM.FSM_DONE)
-      return this.unions.map((i: FsmIncrementalUnion) => ({ 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: FsmIncrementalUnion) => ({ key: i.key, poly: i.result, work: i.work }) );
     else
       return null;
   }
 
   cancel(): void
   {
-    this.unions.forEach((i: FsmIncrementalUnion) => {
+    Object.values(this.unions).forEach((i: FsmIncrementalUnion) => {
         i.cancel();
       });
-    this.unions = [];
+    this.unions = {};
     this.setState(FSM.FSM_DONE);
   }
 
-  cancelOne(key: any): void
+  cancelOne(key: number): void
   {
-    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: any, map: any): void
+  recompute(multi: G.GeoMultiCollection, key: number, map: any): void
   {
-    let fsm: FsmIncrementalUnion = this.unions.find((i: FsmIncrementalUnion) => i.matches(key));
-    if (fsm == null)
+    let fsm = this.unions[key];
+    if (fsm == null || fsm.multi !== multi)
     {
-      fsm = new FsmIncrementalUnion(this.env, this.options, key, map);
-      this.unions.push(fsm);
+      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);
   }
@@ -503,7 +493,12 @@ export class FsmTopoUnion extends FSM.Fsm
       {
         case FSM.FSM_STARTING:
         case FSM_COMPUTING:
-          if (this.unions) this.unions.forEach((u) => { this.work.ms += u.work.ms });
+          this.work = { nUnion: 0, nDifference: 0, ms: 0 };
+          if (this.unions) Object.values(this.unions).forEach((i: FsmIncrementalUnion) => {
+              this.work.ms += i.work.ms;
+              this.work.nUnion += i.work.nUnion;
+              this.work.nDifference += i.work.nDifference;
+            });
           this.setState(FSM.FSM_DONE);
           break;
       }

package/package.json

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