@dra2020/baseclient 1.0.15 → 1.0.16

package/lib/geo/geo.ts

@@ -0,0 +1,452 @@
+import * as geojson from 'geojson';
+import * as Util from '../util/all'
+import * as Poly from '../poly/all'
+
+export type GeoProperties = geojson.GeoJsonProperties;
+export type GeoFeature = geojson.Feature;
+export type GeoFeatureArray = GeoFeature[];
+export type GeoFeatureCollection = geojson.FeatureCollection;
+
+export function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap
+{
+  if (col == null) return null;
+  let map: GeoFeatureMap = {};
+  col.features.forEach((f: GeoFeature) => { map[String(f.properties.id)] = f; });
+  return map;
+}
+
+export function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection
+{
+  if (map == null || Util.countKeys(map) == 0) return null;
+  let col: GeoFeatureCollection = { type: 'FeatureCollection', features: [] };
+  Object.keys(map).forEach((geoid: string) => { col.features.push(map[geoid]) });
+  return col;
+}
+
+export function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Topo
+{
+  let topo = Poly.topoFromCollection(col);
+  Poly.topoPack(topo);
+  return topo;
+}
+
+export function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection
+{
+  let col = Poly.topoToCollection(topo);
+  Poly.featurePack(col);
+  return col;
+}
+
+export interface GeoFeatureMap
+{
+  [id: string]: GeoFeature;  // Maps id to GeoFeature
+}
+
+export type FeatureFunc = (f: GeoFeature) => void;
+
+interface GeoEntry
+{
+  tag: string;
+  col?: GeoFeatureCollection;
+  map?: GeoFeatureMap;
+  topo?: Poly.Topo;
+}
+type GeoEntryMap = { [tag: string]: GeoEntry };
+
+export function geoEqual(m1: GeoMultiCollection, m2: GeoMultiCollection): boolean
+{
+  let n1 = m1 ? m1.length : 0;
+  let n2 = m2 ? m2.length : 0;
+  
+  if (n1 != n2) return false;
+  if (n1 == 0) return true;
+
+  let n = 0;
+  let eq = true;
+  m1.forEach(f => { if (eq && !m2.find(f.properties.id)) eq = false });
+  return eq;
+}
+
+export function geoMapEqual(m1: GeoFeatureMap, m2: GeoFeatureMap): boolean
+{
+  if (m1 == null) return Util.isEmpty(m2);
+  if (m2 == null) return Util.isEmpty(m1);
+  let p: string;
+  for (p in m1) if (m1.hasOwnProperty(p))
+    if (m1[p] !== m2[p])
+      return false;
+  for (p in m2) if (m2.hasOwnProperty(p))
+    if (m1[p] === undefined)
+      return false;
+  return true;
+}
+
+export class GeoMultiCollection
+{
+  entries: GeoEntryMap;
+  all: GeoEntry;
+  hidden: any;
+  stamp: number;
+
+  constructor(tag?: string, topo?: Poly.Topo, col?: GeoFeatureCollection, map?: GeoFeatureMap)
+  {
+    this.stamp = Math.trunc(Math.random() * Number.MAX_SAFE_INTEGER / 2);
+    this.empty();
+    if (tag)
+      this.add(tag, topo, col, map);
+  }
+
+  empty()
+  {
+    this.entries = {};
+    this.hidden = {};
+    this._onChange();
+  }
+
+  get nEntries(): number { return Util.countKeys(this.entries) }
+
+  nthEntry(n: number): GeoEntry
+  {
+    return Util.nthProperty(this.entries, n) as GeoEntry;
+  }
+
+  add(tag: string, topo: Poly.Topo, col: GeoFeatureCollection, map: GeoFeatureMap): void
+  {
+    let entry = this.entries[tag];
+    if (entry === undefined) entry = { tag: tag }, this.entries[tag] = entry;
+    if ((topo && entry.topo !== topo) || (col && entry.col !== col) || (map && entry.map !== map))
+    {
+      entry.topo = topo;
+      entry.col = col;
+      entry.map = map;
+      this._onChange();
+    }
+    else if (topo == null && col == null && map == null)
+      this.remove(tag);
+  }
+
+  addMulti(multi: GeoMultiCollection): void
+  {
+    multi.forEachEntry(e => {
+        this.add(e.tag, e.topo, e.col, e.map);
+      });
+    for (let p in multi.hidden) if (multi.hidden.hasOwnProperty(p))
+    {
+      this.hidden[p] = true;
+      this._onChange();
+    }
+  }
+
+  remove(tag: string): void
+  {
+    let entry = this.entries[tag];
+    if (entry)
+    {
+      if (entry.topo || entry.col || entry.map)
+        this._onChange();
+      delete this.entries[tag];
+    }
+  }
+
+  _onChange(): void
+  {
+    this.all = { tag: 'all' };
+    this.stamp++;
+  }
+
+  _col(e: GeoEntry): GeoFeatureCollection
+  {
+    if (e == null) return null;
+    if (! e.col)
+    {
+      if (e.map)
+        e.col = geoMapToCollection(e.map);
+      else if (e.topo)
+        e.col = geoTopoToCollection(e.topo);
+    }
+    return e.col;
+  }
+
+  _map(e: GeoEntry): GeoFeatureMap
+  {
+    if (e == null) return null;
+    if (! e.map)
+    {
+      if (e.col)
+        e.map = geoCollectionToMap(e.col);
+      else if (e.topo)
+      {
+        e.col = geoTopoToCollection(e.topo);
+        e.map = geoCollectionToMap(e.col);
+      }
+    }
+    return e.map;
+  }
+
+  _topo(e: GeoEntry): Poly.Topo
+  {
+    if (e == null) return null;
+    if (! e.topo)
+    {
+      if (e.col)
+        e.topo = geoCollectionToTopo(e.col);
+      else if (e.map)
+      {
+        e.col = geoMapToCollection(e.map);
+        e.topo = geoCollectionToTopo(e.col);
+      }
+    }
+    return e.topo;
+  }
+
+  colOf(tag: string): GeoFeatureCollection { return this._col(this.entries[tag]); }
+  mapOf(tag: string): GeoFeatureMap { return this._map(this.entries[tag]); }
+  topoOf(tag: string): Poly.Topo { return this._topo(this.entries[tag]); }
+
+  forEachEntry(cb: (e: GeoEntry) => void): void
+  {
+    Object.values(this.entries).forEach(cb);
+  }
+
+  allCol(): GeoFeatureCollection
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.col)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.col = this._col(this.nthEntry(0));
+      else
+        // Going from map to collection guarantees that any duplicates are removed
+        this.all.col = geoMapToCollection(this.allMap());
+    }
+    return this.all.col;
+  }
+
+  allMap(): GeoFeatureMap
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.map)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.map = this._map(this.nthEntry(0));
+      else
+      {
+        let map: GeoFeatureMap = {};
+        this.all.map = map;
+        this.forEach(f => { map[String(f.properties.id)] = f });
+      }
+    }
+    return this.all.map;
+  }
+
+  allTopo(): Poly.Topo
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.topo)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.topo = this._topo(this.nthEntry(0));
+      else
+        this.all.topo = geoCollectionToTopo(this.allCol());
+    }
+    return this.all.topo;
+  }
+
+  hide(id: any): void
+  {
+    if (id)
+    {
+      if (typeof id === 'string')
+        this.hidden[id] = true;
+      else if (Array.isArray(id))
+        id.forEach((i: string) => { this.hidden[i] = true })
+      else if (typeof id === 'object')
+        for (let p in id) if (id.hasOwnProperty(p)) this.hidden[p] = true;
+      this._onChange();
+    }
+  }
+
+  show(id: any): void
+  {
+    if (id)
+    {
+      if (typeof id === 'string')
+        delete this.hidden[id];
+      else if (Array.isArray(id))
+        id.forEach((i: string) => { delete this.hidden[i] })
+      else if (typeof id === 'object')
+        for (let p in id) if (id.hasOwnProperty(p)) delete this.hidden[p];
+      this._onChange();
+    }
+  }
+
+  showAll(): void
+  {
+    if (! Util.isEmpty(this.hidden))
+    {
+      this.hidden = {};
+      this._onChange();
+    }
+  }
+
+  get length(): number
+  {
+    let n = 0;
+    this.forEachEntry(e => {
+        if (e.col)
+          n += e.col.features.length;
+        else if (e.map)
+          n += Util.countKeys(e.map);
+        else if (e.topo)
+          n += Util.countKeys(e.topo.objects);
+      });
+    return n;
+  }
+
+  // Use forEach in preference to iteration using this function
+  nthFeature(n: number): GeoFeature
+  {
+    let found: GeoFeature;
+
+    if (n >= 0)
+      this.forEachEntry(e => {
+          if (found) return;
+          let col = this._col(e);
+          if (col)
+            if (n > col.features.length)
+              n -= col.features.length;
+            else
+              found = col.features[n];
+        });
+    return found;
+  }
+
+  nthFilteredFeature(n: number, cb: (f: GeoFeature) => boolean)
+  {
+    let found: GeoFeature;
+
+    this.forEachEntry(e => {
+        if (found) return;
+        let col = this._col(e);
+        if (col)
+          for (let i = 0; !found && i < col.features.length; i++)
+          {
+            let f = col.features[i];
+            if (this.hidden[f.properties.id] === undefined && cb(f))
+            {
+              if (n === 0)
+              {
+                found = f;
+                break;
+              }
+              n--;
+            }
+          }
+      });
+    return found;
+  }
+
+  forEach(cb: FeatureFunc): void
+  {
+    this.forEachEntry(e => {
+        let col = this._col(e);
+        if (e.col)
+          e.col.features.forEach(f => { if (this.hidden[f.properties.id] === undefined) cb(f) })
+      });
+  }
+
+  map(cb: (f: GeoFeature) => GeoFeature): GeoFeature[]
+  {
+    let features: GeoFeature[] = [];
+    this.forEach((f: GeoFeature) => { features.push(cb(f)) });
+    return features;
+  }
+
+  isHidden(id: string): boolean
+  {
+    return this.hidden[id] !== undefined;
+  }
+
+  find(id: string): GeoFeature
+  {
+    if (this.hidden[id] !== undefined)
+      return undefined;
+
+    let entries = Object.values(this.entries);
+    for (let i = 0; i < entries.length; i++)
+    {
+      let map = this._map(entries[i]);
+      if (map[id])
+        return map[id];
+    }
+
+    return undefined;
+  }
+
+  filter(test: (f: GeoFeature) => boolean): GeoMultiCollection
+  {
+    let m = new GeoMultiCollection();
+    this.forEachEntry(e => {
+        let col = this._col(e);
+        let features = col ? col.features.filter(test) : null;
+        if (features && features.length)
+          m.add(e.tag, null, { type: 'FeatureCollection', features: features }, null);
+      });
+    return m;
+  }
+}
+
+export enum geoIntersectOptions { Intersects, Bounds, BoundsCenter };
+
+function geoBoxIntersect(x1: Poly.BoundBox, x2: Poly.BoundBox, opt: geoIntersectOptions): boolean
+{
+  if (x1.left === undefined || x2.left === undefined) return false;
+
+  let l1 = x1.left;
+  let l2 = x2.left;
+  let r1 = x1.right;
+  let r2 = x2.right;
+  let b1 = x1.top;  // flip
+  let b2 = x2.top;  // flip
+  let t1 = x1.bottom;  // flip
+  let t2 = x2.bottom;  // flip
+  let cx2 = l2 + (r2 - l2) / 2;
+  let cy2 = t2 + (b2 - t2) / 2;
+
+  // Note I flipped top and bottom above when extracting,
+  // in order to make below logic work for normal y axis alignment (0 at top).
+  switch (opt)
+  {
+    case geoIntersectOptions.Intersects:
+      return !(l2 > r1 || r2 < l1 || t2 > b1 || b2 < t1);
+    case geoIntersectOptions.Bounds:
+      return l1 <= l2 && t1 <= t2 && r1 >= r2 && b1 >= b2;
+    case geoIntersectOptions.BoundsCenter:
+      return l1 <= cx2 && t1 <= cy2 && r1 >= cx2 && b1 >= cy2;
+  }
+}
+
+export function geoIntersect(multi: GeoMultiCollection, bbox: Poly.BoundBox, opt: geoIntersectOptions): GeoMultiCollection
+{
+  let m: GeoFeatureMap = {};
+  let bboxPoly = Poly.boundboxPoly(bbox);
+
+  multi.forEach((f: GeoFeature) => {
+      let box = Poly.boundbox(f);
+      if (geoBoxIntersect(bbox, box, opt))
+      {
+        if (opt !== geoIntersectOptions.Intersects || Poly.polyIntersects(bboxPoly, f))
+          m[f.properties.id] = f;
+      }
+    });
+
+  let result = new GeoMultiCollection();
+  result.add('result', null, null, m);
+  return result;
+}

package/lib/geo/vfeature.ts

@@ -0,0 +1,34 @@
+import * as geojson from 'geojson';
+import * as Util from '../util/all'
+import * as Poly from '../poly/all'
+import * as G from './geo';
+
+// Given the topology for a precinct, the bintrie mapping and the list of blocks, construct the
+// feature data for the virtual feature.
+//
+
+export function computeVFeature(topoPrecinct: Poly.Topo, bintrie: Util.BinTrie, blocks: string[]): G.GeoFeature
+{
+  let contiguity = new Util.IndexedArray();
+  let block_contiguity = new Util.IndexedArray();
+  let f = Poly.topoMerge(topoPrecinct, blocks);
+  f.properties.datasets = {};
+  blocks.forEach(blockid => {
+      let b = topoPrecinct.objects[blockid];
+      if (b.properties.datasets)
+        Util.deepAccum(f.properties.datasets, b.properties.datasets);
+      if (b.properties.contiguity)
+      {
+        b.properties.contiguity.forEach((id: string) => {
+            contiguity.set(id === 'OUT_OF_STATE' ? id : bintrie.get(id));
+          });
+        b.properties.contiguity.forEach((id: string) => {
+            block_contiguity.set(id);
+          });
+      }
+    });
+  f.properties.contiguity = contiguity.asArray();
+  f.properties.block_contiguity = block_contiguity.asArray();
+  f.properties.blocks = blocks;
+  return f;
+}

package/lib/ot-js/otsession.ts

@@ -23,7 +23,8 @@ export const FilterRecent: number = 3;
 export const FilterTrash: number = 4;
 export const FilterPublic: number = 5;
 export const FilterOfficial: number = 6;
-export const FilterCount: number = 7;
+export const FilterCOI: number = 7;
+export const FilterCount: number = 8;
 export type Filter = number;
 
 // Permissions
@@ -111,6 +112,8 @@ export interface SessionProps
 	loadFailed: boolean;
   accessMap: AccessMap;
   revisions: RevisionList;
+  expunged?: boolean;
+  expungeDate?: string;
   xprops?: { [prop: string]: string };
 }
 

package/lib/poly/hash.ts

@@ -1,4 +1,4 @@
-import * as objectHash from 'object-hash';
+import objectHash from 'object-hash';
 
 export function qhash(o: any, keys?: any): any
 {

package/lib/poly/polypack.ts

@@ -221,7 +221,8 @@ export function polyPack(coords: any, prepack?: PolyPack): PolyPack
 
   // Transparently handle polygon or multi-polygon
   let depth = Util.depthof(coords);
-  if (depth == 3) coords = [ [ coords ] ];
+  if (depth == 2) coords = [ [ [ coords ] ] ];
+  else if (depth == 3) coords = [ [ coords ] ];
   else if (depth == 4) coords = [ coords ];
 
   let nFloats = polyPackSize(coords);
@@ -374,9 +375,18 @@ export function featureUnpack(f: any): any
   if (f && f.geometry && f.geometry.packed !== undefined)
   {
     f.geometry.coordinates = polyUnpack(f.geometry.packed);
+    let depth = Util.depthof(f.geometry.coordinates);
     // Check for oops, optimized away the multipolygon in polyUnpack
-    if (f.geometry.type === 'MultiPolygon' && Util.depthof(f.geometry.coordinates) === 4)
+    if (f.geometry.type === 'MultiPolygon' && depth === 4)
       f.geometry.coordinates = [ f.geometry.coordinates ];
+    else if (f.geometry.type === 'Point' && depth != 2)
+    {
+      while (depth > 2)
+      {
+        f.geometry.coordinates = f.geometry.coordinates[0];
+        depth = Util.depthof(f.geometry.coordinates);
+      }
+    }
     delete f.geometry.packed;
   }
   else if (f.type && f.type === 'FeatureCollection' && f.features)

package/lib/poly/topo.ts

@@ -59,19 +59,6 @@ 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)
     {
@@ -80,6 +67,15 @@ function correctGeometry(f: any): any
     }
   }
 
+  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
+    // TopoJSON does not guarantee proper winding order which messes up later processing. Fix it.
+    P.featureRewind(f);
+
   return f;
 }
 
@@ -194,6 +190,11 @@ 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
@@ -218,10 +219,10 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
   let elapsedTotal = new Util.Elapsed();
   let elapsed = new Util.Elapsed();
   let topo = topoFromCollection(col);
-  console.log(`topoSimplifyCollection: fromCollection: ${Math.round(elapsed.ms())}ms`);
+  log(`topoSimplifyCollection: fromCollection: ${Math.round(elapsed.ms())}ms`);
   elapsed.start();
   topo = TopoSimplify.presimplify(topo, TopoSimplify['sphericalTriangleArea']);
-  console.log(`topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
+  log(`topoSimplifyCollection: presimplify: ${Math.round(elapsed.ms())}ms`);
   elapsed.start();
 
   // Keep iterating on removing simplification from degenerate shapes
@@ -240,6 +241,11 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
     col.features.forEach((f: any) => {
         let oOld: any = topo.objects[f.properties.id];
         let oNew: any = testtopo.objects[f.properties.id];
+
+        // Ignore points
+        if (f.geometry && f.geometry.type === 'Point')
+          keepTiny.set(f, f);
+
         if (! keepTiny.has(f))
         {
           // Walk through each polygon of a multipolygon separately since I may have a large non-degenerate
@@ -286,13 +292,13 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
           }
         }
       });
-    console.log(`topoSimplifyCollection: pass ${nTries}: ${nBad} (${nTiny} tiny) of ${col.features.length} features are degenerate`);
+    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;
-      console.log(`topoSimplifyCollection: pass ${nTries}: reducing weight limit to ${keepweight}`);
+      log(`topoSimplifyCollection: pass ${nTries}: reducing weight limit to ${keepweight}`);
     }
     nBadLast = nBad;
 
@@ -308,7 +314,7 @@ export function topoSimplifyCollection(col: any, options?: SimplifyOptions): any
     nTries++;
   }
 
-  console.log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
+  log(`topoSimplifyCollection: total elapsed time: ${bigTimeString(elapsedTotal.ms())}`);
 
   return col;
 }
@@ -318,28 +324,7 @@ 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]));
-  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;
+  return correctGeometry({ type: 'Feature', properties: {}, geometry: TopoClient.merge(topo, objects) });
 }
 
 export function topoMergeFeatures(topo: Topo, features: any[]): any
@@ -392,7 +377,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.topo, values);
+      this.result = topoMergeFeatures(this.key.multi.allTopo(), values);
       this.work.ms = elapsed.ms();
       this.map = map;
     }

package/lib/poly/union.ts

@@ -59,6 +59,23 @@ 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;