@dra2020/district-analytics 5.1.0 → 5.2.2

package/dist/district-analytics.js

@@ -122,7 +122,7 @@ const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
 const score_1 = __webpack_require__(/*! ./score */ "./src/score.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 Poly = __importStar(__webpack_require__(/*! @dra2020/poly */ "@dra2020/poly"));
 const D = __importStar(__webpack_require__(/*! ./_data */ "./src/_data.ts"));
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 class AnalyticsSession {
@@ -198,7 +198,7 @@ class AnalyticsSession {
                     // 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);
+                    const districtParts = Poly.polyParts(poly);
                     discontiguousDistrictFeatures.features.push(...districtParts.features);
                     // discontiguousDistrictFeatures.features.push(poly);
                 }
@@ -1114,7 +1114,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // NOTE - This file will NOT be empty, when legacy code is deleted.
 const Poly = __importStar(__webpack_require__(/*! @dra2020/poly */ "@dra2020/poly"));
-const geofeature_1 = __webpack_require__(/*! ./geofeature */ "./src/geofeature.ts");
 // HELPER TO EXTRACT PROPERTIES OF DISTRICT SHAPES
 // TODO - Create an array, as opposed to a dict
 function extractDistrictProperties(s, bLog = false) {
@@ -1122,13 +1121,12 @@ function extractDistrictProperties(s, bLog = false) {
     for (let i = 1; i <= s.state.nDistricts; i++) {
         let poly = s.districts.getDistrictShapeByID(i);
         // Guard against no shape for empty districts AND null shapes
-        let polyOptions = { noLatitudeCorrection: true };
-        let bNull = (!Poly.polyNormalize(poly, polyOptions));
+        let bNull = !Poly.polyNormalize(poly);
         if (poly && (!bNull)) {
             // TODO - OPTIMIZE: Bundle these calls?
-            let area = geofeature_1.gfArea(poly);
-            let perimeter = geofeature_1.gfPerimeter(poly);
-            let diameter = geofeature_1.gfDiameter(poly);
+            let area = Poly.polyAreaFlat(poly);
+            let perimeter = Poly.polyPerimeterFlat(poly);
+            let diameter = Poly.polyDiameterFlat(poly);
             let props = [0, 0, 0]; // TODO - TERRY?!?
             props[0 /* Area */] = area;
             props[1 /* Diameter */] = diameter;
@@ -1219,143 +1217,6 @@ function doHasEqualPopulations(s, bLog = false) {
 exports.doHasEqualPopulations = doHasEqualPopulations;
 
 
-/***/ }),
-
-/***/ "./src/geofeature.ts":
-/*!***************************!*\
-  !*** ./src/geofeature.ts ***!
-  \***************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-//
-// GEO-FEATURES UTILITIES
-//
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-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) {
-    let area = _polygonArea(poly);
-    return area;
-}
-exports.gfArea = gfArea;
-// Algorithm for the area of a simple/single planar polygon:
-// https://algorithmtutor.com/Computational-Geometry/Area-of-a-polygon-given-a-set-of-points/
-// https://mathopenref.com/coordpolygonarea2.html
-//
-// function polygonArea(X, Y, numPoints) 
-// { 
-//   area = 0;         // Accumulates area in the loop
-//   j = numPoints-1;  // The last vertex is the 'previous' one to the first
-//   for (i=0; i<numPoints; i++)
-//     { area = area +  (X[j]+X[i]) * (Y[j]-Y[i]); 
-//       j = i;  //j is previous vertex to i
-//     }
-//   return area/2;
-// }
-// Reimplemented to use polygons vs. X & Y vectors
-function _polygonSimpleArea(p) {
-    let area = 0; // Accumulates area in the loop
-    let n = p.length;
-    let j = n - 1; // The last vertex is the 'previous' one to the first
-    for (let i = 0; i < n; i++) {
-        area = area + (p[j][0] + p[i][0]) * (p[j][1] - p[i][1]);
-        // area = area + (X[j] + X[i]) * (Y[j] - Y[i]);
-        j = i; // j is previous vertex to i
-    }
-    return Math.abs(area / 2);
-}
-// Generalizes the above for MultiPolygons -- cloned from polyArea() in 'poly'
-function _polygonArea(poly) {
-    let polyOptions = { noLatitudeCorrection: true }; // NO-OP?
-    poly = Poly.polyNormalize(poly, polyOptions); // TODO - POLY: Discuss w/ Terry
-    let a = 0;
-    // A MultiPolygon is a set of polygons
-    for (let i = 0; poly && i < poly.length; i++) {
-        // A single polygon is an exterior ring with interior holes. Holes are subtracted.
-        let p = poly[i];
-        for (let j = 0; j < p.length; j++) {
-            let sp = p[j];
-            a += _polygonSimpleArea(sp) * (j == 0 ? 1 : -1);
-        }
-    }
-    return a;
-}
-// TODO - POLY: Confirm Cartesian calculations w/ Terry
-// The perimeter calculation already just computes cartesian distance if you
-// pass in the noLatitudeCorrection flag. You would need to divide by 
-// Poly.EARTH_RADIUS to go from the returned units of meters to Lat/Lon “units”.
-function gfPerimeter(poly) {
-    let perimeter = _polygonPerimeter(poly);
-    return perimeter;
-}
-exports.gfPerimeter = gfPerimeter;
-// TODO - POLY: Confirm Cartesian calculations w/ Terry
-// Cloned from polyPerimeter() in 'poly' and revised to use Cartesian distance
-// NOTE - No conversion of degrees to radians!
-function _polygonPerimeter(poly) {
-    let polyOptions = { noLatitudeCorrection: true }; // Cartesian distance
-    poly = Poly.polyNormalize(poly, polyOptions);
-    let perimeter = 0;
-    for (let i = 0; poly && i < poly.length; i++) {
-        // Ignore holes so only look at first polyline
-        let p = poly[i][0];
-        for (let j = 0; j < p.length - 1; j++)
-            perimeter += _distance(p[j][0], p[j][1], p[j + 1][0], p[j + 1][1]);
-        if (p.length > 2 && (p[0][0] != p[p.length - 1][0] || p[0][1] != p[p.length - 1][1]))
-            perimeter += _distance(p[0][0], p[0][1], p[p.length - 1][0], p[p.length - 1][1]);
-    }
-    return perimeter;
-}
-function _distance(x1, y1, x2, y2) {
-    let dLat = y2 - y1;
-    let dLon = x2 - x1;
-    let d;
-    d = Math.sqrt((dLat * dLat) + (dLon * dLon));
-    return d;
-}
-// TODO - POLY: Confirm Cartesian calculations w/ Terry
-// As I mentioned, the polyCircle code was already just treating the coordinate
-// system as Cartesian. I then did polyFromCircle to convert it to a polygon that
-// then could be passed to polyArea in order to take into account the projection.
-// If instead, you compute area directly from the circle as PI R squared, then
-// you should have your cartesian circular area.
-function gfDiameter(poly) {
-    let polyOptions = { noLatitudeCorrection: true }; // NO-OP
-    let circle = Poly.polyToCircle(poly, polyOptions);
-    let diameter = circle.r * 2;
-    return diameter;
-}
-exports.gfDiameter = gfDiameter;
-
-
 /***/ }),
 
 /***/ "./src/index.ts":