@dra2020/district-analytics 2.0.8 → 2.0.9

package/dist/cli.js

@@ -8055,6 +8055,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 {
@@ -8127,19 +8128,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) {
@@ -9490,6 +9554,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Poly = __importStar(__webpack_require__(/*! @dra2020/poly */ "./node_modules/@dra2020/poly/dist/poly.js"));
+// 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) {