@dra2020/baseclient 1.0.11 → 1.0.14

package/lib/poly/topo.ts

@@ -59,6 +59,19 @@ function correctGeometry(f: any): any
   {
     let multiPoly = f.geometry.coordinates;
 
+    /* Comment this out right now - might have been do to not rewinding merge output
+    // topojson will under certain circumstances return a MultiPolygon with the first Polygon containing holes
+    // that are precisely filled by a subsequent polygon. We make a secondary union pass to try to correct for this.
+    // If we have a really degenerate multipolygon (test above some number of polygons) omit this expensive pass
+    // since cleanup is unlikely.
+    if (multiPoly.length > 1 && multiPoly.length < 50)
+    {
+      let result = Q.unionPolys(multiPoly);
+      if (Util.depthof(result) == 4) result = [ result ];
+      multiPoly = result;
+    }
+    */
+
     // Convert degenerate MultiPolygon to Polygon
     if (multiPoly.length == 1)
     {
@@ -67,9 +80,6 @@ function correctGeometry(f: any): any
     }
   }
 
-  // TopoJSON does not guarantee proper winding order which messes up later processing. Fix it.
-  P.featureRewind(f);
-
   return f;
 }
 
@@ -184,11 +194,6 @@ export interface SimplifyOptions
 
 const DefaultSimplifyOptions: SimplifyOptions = { minArea: 500 };
 
-function log(s: string): void
-{
-  //console.log(s);
-}
-
 //
 // topoSimplifyCollection:
 //    This implements our simplification strategy for block/precinct level shapes. The basic idea is to
@@ -213,10 +218,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`);
+  console.log(`topoSimplifyCollection: fromCollection: ${Math.round(elapsed.ms())}ms`);
   elapsed.start();
   topo = TopoSimplify.presimplify(topo, TopoSimplify['sphericalTriangleArea']);
-  log(`topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
+  console.log(`topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
   elapsed.start();
 
   // Keep iterating on removing simplification from degenerate shapes
@@ -281,13 +286,13 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
           }
         }
       });
-    log(`topoSimplifyCollection: pass ${nTries}: ${nBad} (${nTiny} tiny) of ${col.features.length} features are degenerate`);
+    console.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}`);
+      console.log(`topoSimplifyCollection: pass ${nTries}: reducing weight limit to ${keepweight}`);
     }
     nBadLast = nBad;
 
@@ -303,7 +308,7 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
     nTries++;
   }
 
-  log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
+  console.log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
 
   return col;
 }
@@ -313,7 +318,28 @@ export function topoMerge(topo: Topo, geoids: string[]): any
   if (geoids == null || geoids.length == 0) return null;
   let objects: any[] = [];
   geoids.forEach((geoid) => objects.push(topo.objects[geoid]));
-  return correctGeometry({ type: 'Feature', properties: {}, geometry: TopoClient.merge(topo, objects) });
+  let f: any = correctGeometry({ type: 'Feature', properties: {}, geometry: TopoClient.merge(topo, objects) });
+  P.featureRewind(f);
+
+  /* Comment out for now - may be due to merge output needing to be rewound
+  // If I get a bad output from topoMerge, just do more expensive poly union. This can happen if input polygons
+  // are a little funky (in particular, if they double back along the same edge.
+  if (selfIntersectFast(f))
+  {
+    //console.log('topoMerge: patching selfIntersect');
+    let polys: any[] = [];
+    geoids.forEach((geoid) => polys.push(topoToFeature(topo, geoid).geometry.coordinates));
+    let result = Q.unionPolys(polys);
+    let depth = Util.depthof(result);
+    if (depth === 5 && result.length === 1)
+    {
+      depth = 4;
+      result = result[0];
+    }
+    f = { type: 'feature', properties: {}, geometry: { type: depth == 4 ? 'Polygon' : 'MultiPolygon', coordinates: result } };
+  }
+  */
+  return f;
 }
 
 export function topoMergeFeatures(topo: Topo, features: any[]): any
@@ -366,7 +392,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.key.topo, values);
       this.work.ms = elapsed.ms();
       this.map = map;
     }

package/lib/poly/union.ts

@@ -59,23 +59,6 @@ export function polyIntersects(p1: any, p2: any): boolean
   return bIntersects;
 }
 
-export function polyDifference(main: any, parts: any[]): any
-{
-  main = PP.polyUnpack(coords(main));
-
-  // need to explode multipolygon so that "exploded" is a valid multipolygon input to underlying difference routine
-  let exploded: any[] = [];
-  parts.forEach((p: any) => {
-      p = PP.polyUnpack(coords(p));
-      if (Util.depthof(p) == 5)
-        p.forEach((poly: any) => { exploded.push(poly) });
-      else
-        exploded.push(p);
-    });
-
-  return PR.polyRound(_difference(main, exploded));
-}
-
 class FsmDifference extends FSM.Fsm
 {
   accum: any;

package/lib/storage/all.ts

@@ -0,0 +1,4 @@
+export * from './env';
+export * from './storage';
+export * from './datablob';
+export * from './splitsblob';

package/lib/storage/datablob.ts

@@ -0,0 +1,36 @@
+// Shared libraries
+import * as Util from '../util/all';
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+
+// App libraries
+import { Environment } from './env';
+import * as Storage from './storage';
+
+export class DataBlob extends Storage.StorageBlob
+{
+  constructor(env: Environment, params: Storage.BlobParams)
+  {
+    if (params.bucket == null) params.bucket = env.context.xflag('production') ? 'data' : 'data-dev';
+    super(env, params);
+  }
+
+  get env(): Environment { return this._env as Environment; }
+
+  get json(): any { return this.params.loadTo }
+
+  static createForJSON(env: Environment, id: string): DataBlob
+  {
+    let blob = new DataBlob(env, { id: id, loadToType: 'object' });
+    blob.startLoad(env.storageManager);
+    return blob;
+  }
+
+  static createForStream(env: Environment, id: string, bucket?: string): DataBlob
+  {
+    let blob = new DataBlob(env, { id: id, bucket: bucket, loadToType: 'stream' });
+    blob.startLoad(env.storageManager);
+    return blob;
+  }
+}

package/lib/storage/env.ts

@@ -0,0 +1,14 @@
+// Shared libraries
+import * as Context from '../context/all';
+import * as FSM from '../fsm/all';
+import * as LogAbstract from '../logabstract/all';
+
+import * as Storage from './storage';
+
+export interface Environment
+{
+  context: Context.IContext;
+  log: LogAbstract.ILog;
+  fsmManager: FSM.FsmManager;
+  storageManager: Storage.StorageManager;
+}

package/lib/storage/splitsblob.ts

@@ -0,0 +1,63 @@
+// Node
+import * as zlib from 'zlib';
+
+// Shared libraries
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+
+// App libraries
+import { Environment } from './env';
+import * as Storage from './storage';
+
+export class SplitsBlob extends Storage.StorageBlob
+{
+  ls: { [key: string]: Storage.BlobProperties };
+
+  constructor(env: Environment, params: Storage.BlobParams)
+  {
+    if (params.bucket === undefined) params.bucket = env.context.xflag('production') ? 'splits' : 'splits-dev';
+    super(env, params);
+  }
+
+  get env(): Environment { return this._env as Environment; }
+
+  get collection(): any { return this.params.loadTo }
+
+  static createForLs(env: Environment): SplitsBlob
+  {
+    let blob = new SplitsBlob(env, { id: '' });
+    blob.startList(env.storageManager);
+    new FSM.FsmOnDone(env, blob.fsmList, (f: FSM.Fsm) => {
+        if (! f.iserror)
+        {
+          blob.ls = {};
+          blob.keys.forEach((k: string, i: number) => { blob.ls[k] = blob.props[i] });
+        }
+      });
+    return blob;
+  }
+
+  static createForUpload(env: Environment, id: string, collection: any): SplitsBlob
+  {
+    let params: Storage.BlobParams = {
+      id: id,
+      saveFromType: 'object',
+      saveFrom: collection,
+      ContentEncoding: 'gzip',
+      ContentType: 'application/json',
+      CacheControl: 'no-cache'
+      };
+    let blob = new SplitsBlob(env, params);
+    blob.setDirty();
+    blob.checkSave(env.storageManager);
+    return blob;
+  }
+
+  static createForDownload(env: Environment, id: string): SplitsBlob
+  {
+    let blob = new SplitsBlob(env, { id: id, loadToType: 'object' });
+    blob.startLoad(env.storageManager);
+    return blob;
+  }
+}