@dra2020/district-analytics 7.1.6 → 7.1.7

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Alec Ramsay
+Copyright (c) 2020 Dave's Redistricting, LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/cli.js

@@ -93801,6 +93801,7 @@ __export(__webpack_require__(/*! ./quad */ "./lib/quad.ts"));
 __export(__webpack_require__(/*! ./polylabel */ "./lib/polylabel.ts"));
 __export(__webpack_require__(/*! ./polysimplify */ "./lib/polysimplify.ts"));
 __export(__webpack_require__(/*! ./polypack */ "./lib/polypack.ts"));
+__export(__webpack_require__(/*! ./polybin */ "./lib/polybin.ts"));
 __export(__webpack_require__(/*! ./boundbox */ "./lib/boundbox.ts"));
 __export(__webpack_require__(/*! ./blend */ "./lib/blend.ts"));
 __export(__webpack_require__(/*! ./cartesian */ "./lib/cartesian.ts"));
@@ -93878,7 +93879,7 @@ function boundboxExtend(bbox, x, y) {
 }
 function boundboxExtendPacked(pp, bbox) {
     let buffer = pp.buffer;
-    let offset = pp.buffer[pp.offset + 1];
+    let offset = pp.buffer[pp.offset + 1] + pp.offset;
     let end = pp.offset + pp.length;
     for (; offset < end; offset += 2)
         boundboxExtend(bbox, buffer[offset], buffer[offset + 1]);
@@ -94517,6 +94518,151 @@ function npoints(poly) {
 exports.npoints = npoints;
 
 
+/***/ }),
+
+/***/ "./lib/polybin.ts":
+/*!************************!*\
+  !*** ./lib/polybin.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const PP = __webpack_require__(/*! ./polypack */ "./lib/polypack.ts");
+// Only under Node. TextEncoder/Decoder implemented directly in browser.
+const ServerCoding = __webpack_require__(/*! util */ "util");
+// Packed Buffer format:
+//
+//  (strings are packed as UTF8 bytes, padded to 4 byte boundary)
+//
+//  { 4 byte size (byte offset to packed coordinate buffer) }
+//  { 4 byte length: property name,
+//    4 byte length: json string }*
+//  { 4 byte length: 'features' }
+//  { 4 byte length: length of 'features' array }
+//    { 4 byte length: property name,
+//      4 byte length: json string }*
+//  { padding to 8 byte boundary }
+//  { packed buffer coordinates in polypack format (indexed by geometry.packed above) }
+//
+const MagicInt = 17;
+const MagicFloat = 17.17;
+let encoder = ServerCoding.TextEncoder ? (new ServerCoding.TextEncoder()) : (new TextEncoder());
+let decoder = ServerCoding.TextDecoder ? (new ServerCoding.TextDecoder('utf-8')) : (new TextDecoder('utf-8'));
+function pad(n, pad) {
+    let mod = n % pad;
+    return mod ? pad - mod : 0;
+}
+function sizeOfString(s) {
+    let s8 = encoder.encode(s);
+    return 4 + s8.length + pad(s8.length, 4);
+}
+function packString(buf8, buf32, offset, s) {
+    let s8 = encoder.encode(s);
+    buf32[offset >> 2] = s8.length;
+    offset += 4;
+    let i;
+    for (i = 0; i < s8.length; i++)
+        buf8[offset++] = s8[i];
+    offset += pad(offset, 4);
+    return offset;
+}
+function unpackString(buf8, buf32, offset) {
+    let size = buf32[offset >> 2];
+    let s = decoder.decode(buf8.subarray(offset + 4, offset + 4 + size));
+    return s;
+}
+function packCollection(col) {
+    // Compute size
+    let pp = PP.featurePack(col);
+    let buffer = col.features.length ? col.features[0].geometry.packed.buffer : null; // to restore, below
+    let size = 16; // int endiness, offset to coordinates, float endiness
+    col.features.forEach((f) => { delete f.geometry.packed.buffer; }); // reconstructed when unpacking
+    let j = JSON.stringify(col);
+    size += sizeOfString(j);
+    size += pad(size, 8);
+    let fullsize = size + pp.length * 8; // add space for coordinates
+    // Now pack it
+    let ab = new ArrayBuffer(fullsize);
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let buf64 = new Float64Array(ab);
+    let offset = 0;
+    buf32[0] = MagicInt;
+    offset += 4;
+    buf32[1] = size;
+    offset += 4;
+    buf64[1] = MagicFloat; // Note that buf64[0] has the two ints stored above
+    offset += 8;
+    offset = packString(buf8, buf32, offset, j);
+    offset += pad(offset, 8);
+    if (offset != size)
+        throw 'Oops, packing error.';
+    let foff = offset >> 3;
+    let buf = pp.buffer;
+    for (let i = 0; i < pp.length; i++)
+        buf64[foff++] = buf[i];
+    // Now restore
+    col.features.forEach((f) => { f.geometry.packed.buffer = buffer; });
+    PP.featureUnpack(col);
+    return ab;
+}
+exports.packCollection = packCollection;
+function reverse(buf8, s, n) {
+    let e = s + n - 1;
+    while (s < e) {
+        let t = buf8[s];
+        buf8[s] = buf8[e];
+        buf8[e] = t;
+        s++, e--;
+    }
+}
+function enforceEndianness(ab) {
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let buf64 = new Float64Array(ab);
+    let reverseInts = false;
+    if (buf32[0] != MagicInt) {
+        reverseInts = true;
+        reverse(buf8, 0, 4);
+        if (buf32[0] != MagicInt)
+            throw 'unpackCollection: badly formatted buffer';
+        reverse(buf8, 4, 4); // size of non-floats
+    }
+    let reverseFloats = false;
+    if (buf64[1] != MagicFloat) {
+        reverseFloats = true;
+        reverse(buf8, 8, 8);
+        if (buf64[1] != MagicFloat)
+            throw 'unpackCollection: badly formatted buffer';
+    }
+    if (reverseInts)
+        reverse(buf8, 16, 4); // JSON string length
+    if (reverseFloats) {
+        let s = buf32[1]; // Offset to floats
+        let e = ab.byteLength;
+        for (; s < e; s += 8)
+            reverse(buf8, s, 8);
+    }
+}
+function unpackCollection(ab) {
+    enforceEndianness(ab);
+    let col = {};
+    let buf8 = new Uint8Array(ab);
+    let buf32 = new Int32Array(ab);
+    let size = buf32[1];
+    let buf64 = new Float64Array(ab, size); // offset to start of packed coordinates
+    let offset = 16;
+    let j = unpackString(buf8, buf32, offset);
+    col = JSON.parse(j);
+    col.features.forEach((f) => { f.geometry.packed.buffer = buf64; });
+    return col;
+}
+exports.unpackCollection = unpackCollection;
+
+
 /***/ }),
 
 /***/ "./lib/polylabel.ts":
@@ -94728,7 +94874,7 @@ function polyPackEachRing(pack, cb) {
     let b = pack.buffer;
     let iRing;
     let iOffset = pack.offset;
-    let cOffset = b[iOffset + 1];
+    let cOffset = b[iOffset + 1] + pack.offset;
     // Grab number of polygons
     let nPoly = b[iOffset++];
     // Move past header length
@@ -94805,7 +94951,7 @@ function polyPack(coords, prepack) {
             af[z++] = p[j].length;
     }
     // set header size back in header
-    af[prepack.offset + 1] = z;
+    af[prepack.offset + 1] = z - prepack.offset;
     // Fill in coords
     for (i = 0; i < coords.length; i++) {
         p = coords[i];
@@ -94831,7 +94977,7 @@ function polyUnpack(prepack) {
     let coords = [];
     let h = prepack.offset;
     nPolys = af[h++];
-    let z = af[h++]; // start of coordinates
+    let z = af[h++] + prepack.offset; // start of coordinates
     for (i = 0; i < nPolys; i++) {
         p = [];
         coords[i] = p;
@@ -95099,6 +95245,7 @@ class FsmQuadTree extends FSM.Fsm {
     constructor(env, options, col) {
         super(env);
         this.options = Util.shallowAssignImmutable(Poly.DefaultTickOptions, options);
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
         this.initialize(col);
     }
     initialize(col) {
@@ -95107,6 +95254,7 @@ class FsmQuadTree extends FSM.Fsm {
         this.isempty = true;
         if (col != null) {
             let features = col.features ? col.features : col;
+            this.work.nUnion = features.length;
             this.isempty = features.length == 0;
             // Compute BoundBox for each feature
             let wrapped = features.map((f) => { return { box: BB.boundbox(f), p: featureCoords(f) }; });
@@ -95134,11 +95282,13 @@ class FsmQuadTree extends FSM.Fsm {
                     break;
                 case FSM.FSM_PENDING:
                     let tickCounter = { ticks: this.options.tickStep };
+                    let elapsed = new Util.Elapsed();
                     if (!this.isempty && this.asyncUnion === undefined) {
                         this.quad.tickUnion(tickCounter);
                         if (tickCounter.ticks != 0)
                             this.result;
                     }
+                    this.work.ms += elapsed.ms();
                     if (this.asyncUnion !== undefined)
                         this.setState(FSM.FSM_DONE);
                     else
@@ -95316,6 +95466,7 @@ exports.polyIntersects = polyIntersects;
 class FsmDifference extends FSM.Fsm {
     constructor(env, accum, polys) {
         super(env);
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
         this.initialize(accum, polys);
     }
     initialize(accum, polys) {
@@ -95323,8 +95474,10 @@ class FsmDifference extends FSM.Fsm {
         this.polys = polys;
         if (polys == null || polys.length == 0)
             this.setState(FSM.FSM_DONE);
-        else
+        else {
+            this.work.nDifference = polys.length;
             this.setState(FSM.FSM_STARTING);
+        }
     }
     cancel() {
         this.accum = null;
@@ -95344,7 +95497,9 @@ class FsmDifference extends FSM.Fsm {
                         this.setState(FSM_COMPUTING);
                     break;
                 case FSM_COMPUTING:
+                    let elapsed = new Util.Elapsed();
                     this.accum = _difference(this.accum, this.polys);
+                    this.work.ms = elapsed.ms();
                     this.polys = null;
                     this.setState(FSM.FSM_DONE);
                     break;
@@ -95421,10 +95576,20 @@ class FsmIncrementalUnion extends FSM.Fsm {
             if (this.toSub.length == 0)
                 this.toSub = null;
         }
-        this.fsmUnion = new Q.FsmQuadTree(this.env, this.options, polys);
-        this.waitOn(this.fsmUnion);
-        this.setState(FSM_UNION);
-        this.map = map;
+        // Short-circuit when no work to be done
+        if (polys.length == 1 && this.toSub == null && this.lastCompleteResult) {
+            this.work = { nUnion: 0, nDifference: 0, ms: 0 };
+            this.result = this.lastCompleteResult;
+            this.map = this.lastCompleteMap;
+            this.setState(FSM.FSM_DONE);
+        }
+        else {
+            this.work = { nUnion: polys.length - 1, nDifference: this.toSub ? this.toSub.length : 0, ms: 0 };
+            this.fsmUnion = new Q.FsmQuadTree(this.env, this.options, polys);
+            this.waitOn(this.fsmUnion);
+            this.setState(FSM_UNION);
+            this.map = map;
+        }
     }
     cancel() {
         if (this.fsmUnion) {
@@ -95449,6 +95614,8 @@ class FsmIncrementalUnion extends FSM.Fsm {
                     this.setState(FSM.FSM_DONE);
                     break;
                 case FSM_UNION:
+                    if (this.fsmUnion)
+                        this.work.ms += this.fsmUnion.work.ms;
                     this.fsmDifference = new FsmDifference(this.env, this.fsmUnion.result, this.toSub);
                     this.waitOn(this.fsmDifference);
                     this.toSub = null;
@@ -95457,6 +95624,7 @@ class FsmIncrementalUnion extends FSM.Fsm {
                     break;
                 case FSM_DIFFERENCE:
                     this.result = this.fsmDifference.result;
+                    this.work.ms += this.fsmDifference.work.ms;
                     this.lastCompleteResult = this.result;
                     this.lastCompleteMap = this.map;
                     this.fsmDifference = null;
@@ -95471,10 +95639,11 @@ class FsmUnion extends FSM.Fsm {
         super(env);
         this.options = Util.shallowAssignImmutable(Poly.DefaultTickOptions, options);
         this.unions = [];
+        this.work = { nUnion: 0, nDifference: 0, ms: 0 };
     }
     get result() {
         if (this.unions.length > 0 && this.state === FSM.FSM_DONE)
-            return this.unions.map((i) => ({ key: i.key, poly: i.result }));
+            return this.unions.map((i) => ({ key: i.key, poly: i.result, work: i.work }));
         else
             return null;
     }
@@ -95485,6 +95654,15 @@ class FsmUnion extends FSM.Fsm {
         this.unions = [];
         this.setState(FSM.FSM_DONE);
     }
+    cancelOne(key) {
+        for (let i = 0; i < this.unions.length; i++) {
+            let u = this.unions[i];
+            if (u.matches(key)) {
+                u.cancel();
+                return;
+            }
+        }
+    }
     recompute(key, map) {
         let fsm = this.unions.find((i) => i.matches(key));
         if (fsm == null) {
@@ -95493,6 +95671,8 @@ class FsmUnion extends FSM.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);
     }
@@ -95501,6 +95681,8 @@ class FsmUnion extends FSM.Fsm {
             switch (this.state) {
                 case FSM.FSM_STARTING:
                 case FSM_COMPUTING:
+                    if (this.unions)
+                        this.unions.forEach((u) => { this.work.ms += u.work.ms; });
                     this.setState(FSM.FSM_DONE);
                     break;
             }
@@ -98068,6 +98250,17 @@ module.exports = __webpack_require__(/*! @dra2020/fsm */ "./node_modules/@dra202
 
 module.exports = __webpack_require__(/*! @dra2020/util */ "./node_modules/@dra2020/util/dist/util.js");
 
+/***/ }),
+
+/***/ "util":
+/*!***********************!*\
+  !*** external "util" ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = __webpack_require__(/*! util */ "util");
+
 /***/ })
 
 /******/ });
@@ -103221,6 +103414,8 @@ class Features {
         this._session = s;
         this._data = data;
         this._keys = keys;
+        // For debugging PVI
+        // console.log("Election dataset =", this._keys[Dataset.ELECTION]);
     }
     nFeatures() { return this._data.features.length; }
     featureByIndex(i) { return this._data.features[i]; }
@@ -103231,8 +103426,15 @@ class Features {
         return value;
     }
     fieldForFeature(f, dt, fk) {
-        let dk = this._keys[dt];
-        return _getFeatures(f, dk, fk);
+        const dk = this._keys[dt];
+        let result = undefined;
+        // 07-31-2020 - Fix to post-process PVI into the expected election composite format.
+        if (dk === 'P16GPR') {
+            result = (_getFeatures(f, dk, (fk === 'D' ? 'D12' : 'R12')) + _getFeatures(f, dk, (fk === 'D' ? 'D16' : 'R16'))) / 2;
+        }
+        else
+            result = _getFeatures(f, dk, fk);
+        return result;
     }
     resetDataset(d, k) {
         this._keys[d] = k;
@@ -105051,12 +105253,16 @@ const S = __importStar(__webpack_require__(/*! ../src/settings */ "./src/setting
 const D = __importStar(__webpack_require__(/*! ../src/_data */ "./src/_data.ts"));
 // Simulate DRA unioning district shapes in the background
 function addToPoly(poly, polys) {
-    // TODO - POLY: Fix 'poly' import, so I don't have to do this workaround.
-    // return PC.union(poly, ...polys);
-    let union = PC.union;
-    if (union === undefined)
-        union = PC.default.union;
-    return union(poly, ...polys);
+    // Terry's workaround
+    let _union = undefined;
+    let anyPC = PC;
+    if (anyPC.union)
+        _union = anyPC.union;
+    if (anyPC.default.union)
+        _union = anyPC.default.union;
+    if (_union === undefined)
+        throw 'Unable to load union function from polygon-clipping';
+    return _union(poly, ...polys);
 }
 console.log("Starting command @ ", new Date());
 // COMMAND LINE
@@ -105500,6 +105706,17 @@ module.exports = require("stream");
 
 /***/ }),
 
+/***/ "util":
+/*!***********************!*\
+  !*** external "util" ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = require("util");
+
+/***/ }),
+
 /***/ "yargs":
 /*!************************!*\
   !*** external "yargs" ***!