@dra2020/district-analytics 2.0.6 → 2.0.9

package/dist/district-analytics.js

@@ -120,6 +120,7 @@ const preprocess_1 = __webpack_require__(/*! ./preprocess */ "./src/preprocess.t
 const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
 const results_1 = __webpack_require__(/*! ./results */ "./src/results.ts");
 const results_2 = __webpack_require__(/*! ./results */ "./src/results.ts");
+const geofeature_1 = __webpack_require__(/*! ./geofeature */ "./src/geofeature.ts");
 const D = __importStar(__webpack_require__(/*! ./_data */ "./src/_data.ts"));
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 class AnalyticsSession {
@@ -192,19 +193,82 @@ class AnalyticsSession {
     // NOTE - This assumes that analyzePlan() has been run!
     getDiscontiguousDistrictFeatures(bLog = false) {
         // Get the (possibly empty) list of discontiguous district IDs
-        let contiguousTest = this.getTest(1 /* Contiguous */);
-        let discontiguousDistrictIDs = contiguousTest['details']['discontiguousDistricts'] || [];
+        const contiguousTest = this.getTest(1 /* Contiguous */);
+        const discontiguousDistrictIDs = contiguousTest['details']['discontiguousDistricts'] || [];
         // Convert them into a (possibly empty) list of features
         let discontiguousDistrictFeatures = { type: 'FeatureCollection', features: [] };
         if (!(U.isArrayEmpty(discontiguousDistrictIDs))) {
             for (let id of discontiguousDistrictIDs) {
                 let poly = this.districts.getDistrictShapeByID(id);
-                if (poly)
-                    discontiguousDistrictFeatures.features.push(poly);
+                if (poly) {
+                    // If a district has a shape & it is not contiguous, by definition,
+                    // it will be a Multipolygon, i.e., it will have multiple pieces, some
+                    // possibly embedded w/in other districts. Get & add all the pieces.
+                    const districtParts = geofeature_1.polyParts(poly);
+                    discontiguousDistrictFeatures.features.push(...districtParts.features);
+                    // discontiguousDistrictFeatures.features.push(poly);
+                }
             }
         }
         return discontiguousDistrictFeatures;
     }
+    // Comments clipped from dra-client geodistrict.ts.
+    // Discontiguous polygons are:
+    //  1. All polygons in a multi-polygon; and
+    //  2. All holes in a otherwise cohesive polygon.
+    // Note that all non-cohesive features are always simple polygons.
+    /*
+    let i: number, j: number;
+    let nPoly: number = 0;
+    for (i = 0;nPoly == 0 && i < this.cacheDistricts.features.length;i++)
+    {
+      let f = this.cacheDistricts.features[i];
+  
+      if (f.geometry.type === 'MultiPolygon')
+        nPoly += f.geometry.coordinates.length;
+      else if (f.geometry.type === 'Polygon' && f.geometry.coordinates.length)
+        nPoly += (f.geometry.coordinates.length - 1);
+    }
+    if (nPoly)
+    {
+      this.cacheNoncohesive = {type: 'FeatureCollection', features: []};
+      let af: any = this.cacheNoncohesive.features;
+      let oUnique: any = {};
+  
+      // First add discontiguous polygons
+      for (i = 0;i < this.cacheDistricts.features.length;i++)
+      {
+        let f = this.cacheDistricts.features[i];
+  
+        if (f.geometry.type === 'MultiPolygon')
+        {
+          // Push all non-contiguous polygons
+          for (j = 0;j < f.geometry.coordinates.length;j++)
+          {
+            let p: any = f.geometry.coordinates[j];
+            oUnique[Hash.qhash(p[0])] = true;
+            af.push({type: 'Feature', properties: {id: `${af.length + 1}`}, geometry: {type: 'Polygon', coordinates: p}});
+          }
+        }
+      }
+  
+      // Now add unique holes
+      for (i = 0;i < this.cacheDistricts.features.length;i++)
+      {
+        let f = this.cacheDistricts.features[i];
+  
+        if (f.geometry.type === 'Polygon')
+        {
+          // Push all holes from this polygon
+          for (j = 1;j < f.geometry.coordinates.length;j++)
+          {
+            let p: any = f.geometry.coordinates[j];
+            if (oUnique[Hash.qhash(p)] === undefined)
+              af.push({type: 'Feature', properties: {id: `${af.length + 1}`}, geometry: {type: 'Polygon', coordinates: [p]}});
+          }
+        }
+      }
+    } */
     // HELPERS USED INTERNALLY
     // Get an individual test, so you can drive UI with the results.
     getTest(testID) {
@@ -396,6 +460,9 @@ class Districts {
             // 3 - MORE ...
             // HACK - Because "this" gets ghosted inside the forEach loop below
             let outerThis = this;
+            // Default the pop dev % for the dummy Unassigned district to 0%.
+            // Default the pop dev % for real (1–N) but empty districts to 100%.
+            let popDevPct = (i > 0) ? (targetSize / targetSize) : 0 / targetSize;
             // Get the geoIDs assigned to the district
             // Guard against empty districts
             let geoIDs = this._session.plan.geoIDsForDistrictID(i);
@@ -442,11 +509,11 @@ class Districts {
                 });
                 // COMPUTE DERIVED VALUES
                 // Population deviation % and equal population (boolean) by district.
-                // Default the value for the dummy unassigned district to 0%.
-                let popDevPct = 0 / targetSize;
                 if (i > 0) {
-                    popDevPct = (totalPop - targetSize) / targetSize;
-                    bEqualPop = (popDevPct <= deviationThreshold);
+                    if (totalPop > 0) {
+                        popDevPct = (totalPop - targetSize) / targetSize;
+                        bEqualPop = (Math.abs(popDevPct) <= deviationThreshold);
+                    }
                 }
                 // Total two-party (not total total!) votes, Democratic and Republican vote
                 // shares, and Democratic first-past-the-post win (= 1) or loss (= 0).
@@ -535,7 +602,7 @@ class Districts {
                 }
             }
             else { // If a district is empty, zero these results (vs. null)
-                this.statistics[DistrictField.PopDevPct][i] = 0.0;
+                this.statistics[DistrictField.PopDevPct][i] = popDevPct;
                 this.statistics[DistrictField.DemVotes][i] = 0;
                 this.statistics[DistrictField.RepVotes][i] = 0;
                 this.statistics[DistrictField.TwoPartyVote][i] = 0;
@@ -1552,6 +1619,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Poly = __importStar(__webpack_require__(/*! @dra2020/poly */ "@dra2020/poly"));
+// HELPER
+function polyParts(poly) {
+    let parts = { type: 'FeatureCollection', features: [] };
+    let af = parts.features;
+    if (poly.geometry.type === 'MultiPolygon') {
+        // Push all non-contiguous polygons
+        for (let j = 0; j < poly.geometry.coordinates.length; j++) {
+            let onePoly = poly.geometry.coordinates[j];
+            af.push({ type: 'Feature', properties: { id: `${af.length + 1}` }, geometry: { type: 'Polygon', coordinates: onePoly } });
+        }
+    }
+    else {
+        parts.features.push(poly);
+    }
+    return parts;
+}
+exports.polyParts = polyParts;
 // CARTESIAN SHIMS OVER 'POLY' FUNCTIONS
 // TODO - POLY: Confirm Cartesian calculations
 function gfArea(poly) {