@dra2020/baseclient 1.0.28 → 1.0.29

package/dist/baseclient.js

@@ -4663,6 +4663,7 @@ __exportStar(__webpack_require__(/*! ./topo */ "./lib/poly/topo.ts"), exports);
 __exportStar(__webpack_require__(/*! ./selfintersect */ "./lib/poly/selfintersect.ts"), exports);
 __exportStar(__webpack_require__(/*! ./shamos */ "./lib/poly/shamos.ts"), exports);
 __exportStar(__webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts"), exports);
+__exportStar(__webpack_require__(/*! ./mapto */ "./lib/poly/mapto.ts"), exports);
 
 
 /***/ }),
@@ -5341,6 +5342,88 @@ if (typeof module !== 'undefined') {
 */
 
 
+/***/ }),
+
+/***/ "./lib/poly/mapto.ts":
+/*!***************************!*\
+  !*** ./lib/poly/mapto.ts ***!
+  \***************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.polyMapTo = void 0;
+const PL = __importStar(__webpack_require__(/*! ./polylabel */ "./lib/poly/polylabel.ts"));
+const BB = __importStar(__webpack_require__(/*! ./boundbox */ "./lib/poly/boundbox.ts"));
+const pointinpoly_1 = __webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts");
+function setLabels(c) {
+    c.features.forEach(f => {
+        if (f.properties.labelx === undefined) {
+            let { x, y } = PL.polyLabel(f);
+            f.properties.labelx = x;
+            f.properties.labely = y;
+        }
+    });
+}
+// polyMapTo:
+//
+//  Given a set of underlying blocks (or precincts), map them to the district (or any other feature)
+//  they are contained in.
+//
+//  If a block maps to multiple districts or no district, it is left out of the result.
+//
+//  Note that the algorithm is to see where the centroid of the block overlaps. So a block
+//  could potentially overlap multiple districts and this would return only the one containing
+//  the centroid.
+//
+//  The thinking is that if you want fine granularity, use real blocks as the base collection.
+//  If you provide precincts, you will get a result on precinct granularity.
+//
+//  The return value is an object that maps the block feature ids to the district feature id.
+//
+function polyMapTo(districts, blocks) {
+    let map = {};
+    // Cache labelx, labely if necessary
+    setLabels(blocks);
+    // Cache district boundboxes for quick containment exclusion
+    let bbDistricts = districts.features.map(f => BB.boundbox(f));
+    // Walk over blocks, mapping centroid to district
+    blocks.features.forEach(fBlock => {
+        let x = fBlock.properties.labelx;
+        let y = fBlock.properties.labely;
+        let fIn = [];
+        districts.features.forEach((fDistrict, i) => {
+            if (BB.boundboxContains(bbDistricts[i], x, y))
+                if (pointinpoly_1.polyContainsPoint(fDistrict, x, y))
+                    fIn.push(fDistrict);
+        });
+        if (fIn.length == 1)
+            map[fBlock.properties.id] = fIn[0].properties.id;
+    });
+    return map;
+}
+exports.polyMapTo = polyMapTo;
+
+
 /***/ }),
 
 /***/ "./lib/poly/matrix.ts":