node-red-contrib-tak-registration 0.2.2 → 0.3.2

package/node_modules/@turf/polygon-to-line/dist/js/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var helpers_1 = require("@turf/helpers");
+var invariant_1 = require("@turf/invariant");
+/**
+ * Converts a {@link Polygon} to {@link LineString|(Multi)LineString} or {@link MultiPolygon} to a
+ * {@link FeatureCollection} of {@link LineString|(Multi)LineString}.
+ *
+ * @name polygonToLine
+ * @param {Feature<Polygon|MultiPolygon>} poly Feature to convert
+ * @param {Object} [options={}] Optional parameters
+ * @param {Object} [options.properties={}] translates GeoJSON properties to Feature
+ * @returns {FeatureCollection|Feature<LineString|MultiLinestring>} converted (Multi)Polygon to (Multi)LineString
+ * @example
+ * var poly = turf.polygon([[[125, -30], [145, -30], [145, -20], [125, -20], [125, -30]]]);
+ *
+ * var line = turf.polygonToLine(poly);
+ *
+ * //addToMap
+ * var addToMap = [line];
+ */
+function default_1(poly, options) {
+    if (options === void 0) { options = {}; }
+    var geom = invariant_1.getGeom(poly);
+    if (!options.properties && poly.type === "Feature") {
+        options.properties = poly.properties;
+    }
+    switch (geom.type) {
+        case "Polygon":
+            return polygonToLine(geom, options);
+        case "MultiPolygon":
+            return multiPolygonToLine(geom, options);
+        default:
+            throw new Error("invalid poly");
+    }
+}
+exports.default = default_1;
+/**
+ * @private
+ */
+function polygonToLine(poly, options) {
+    if (options === void 0) { options = {}; }
+    var geom = invariant_1.getGeom(poly);
+    var coords = geom.coordinates;
+    var properties = options.properties
+        ? options.properties
+        : poly.type === "Feature"
+            ? poly.properties
+            : {};
+    return coordsToLine(coords, properties);
+}
+exports.polygonToLine = polygonToLine;
+/**
+ * @private
+ */
+function multiPolygonToLine(multiPoly, options) {
+    if (options === void 0) { options = {}; }
+    var geom = invariant_1.getGeom(multiPoly);
+    var coords = geom.coordinates;
+    var properties = options.properties
+        ? options.properties
+        : multiPoly.type === "Feature"
+            ? multiPoly.properties
+            : {};
+    var lines = [];
+    coords.forEach(function (coord) {
+        lines.push(coordsToLine(coord, properties));
+    });
+    return helpers_1.featureCollection(lines);
+}
+exports.multiPolygonToLine = multiPolygonToLine;
+/**
+ * @private
+ */
+function coordsToLine(coords, properties) {
+    if (coords.length > 1) {
+        return helpers_1.multiLineString(coords, properties);
+    }
+    return helpers_1.lineString(coords[0], properties);
+}
+exports.coordsToLine = coordsToLine;

package/node_modules/@turf/polygon-to-line/package.json

@@ -0,0 +1,95 @@
+{
+  "_from": "@turf/polygon-to-line@^6.5.0",
+  "_id": "@turf/polygon-to-line@6.5.0",
+  "_inBundle": false,
+  "_integrity": "sha512-5p4n/ij97EIttAq+ewSnKt0ruvuM+LIDzuczSzuHTpq4oS7Oq8yqg5TQ4nzMVuK41r/tALCk7nAoBuw3Su4Gcw==",
+  "_location": "/@turf/polygon-to-line",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@turf/polygon-to-line@^6.5.0",
+    "name": "@turf/polygon-to-line",
+    "escapedName": "@turf%2fpolygon-to-line",
+    "scope": "@turf",
+    "rawSpec": "^6.5.0",
+    "saveSpec": null,
+    "fetchSpec": "^6.5.0"
+  },
+  "_requiredBy": [
+    "/@turf/boolean-crosses",
+    "/@turf/boolean-disjoint",
+    "/@turf/turf"
+  ],
+  "_resolved": "https://registry.npmjs.org/@turf/polygon-to-line/-/polygon-to-line-6.5.0.tgz",
+  "_shasum": "4dc86db66168b32bb83ce448cf966208a447d952",
+  "_spec": "@turf/polygon-to-line@^6.5.0",
+  "_where": "/Users/conway/Projects/TAKreg/node_modules/@turf/turf",
+  "author": {
+    "name": "Turf Authors"
+  },
+  "bugs": {
+    "url": "https://github.com/Turfjs/turf/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "@turf/helpers": "^6.5.0",
+    "@turf/invariant": "^6.5.0"
+  },
+  "deprecated": false,
+  "description": "turf polygon-to-line module",
+  "devDependencies": {
+    "@types/tape": "*",
+    "benchmark": "*",
+    "load-json-file": "*",
+    "npm-run-all": "*",
+    "tape": "*",
+    "ts-node": "*",
+    "tslint": "*",
+    "typescript": "*",
+    "write-json-file": "*"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/es/index.js",
+      "require": "./dist/js/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "funding": "https://opencollective.com/turf",
+  "gitHead": "5375941072b90d489389db22b43bfe809d5e451e",
+  "homepage": "https://github.com/Turfjs/turf",
+  "keywords": [
+    "turf",
+    "gis",
+    "line",
+    "linestring",
+    "polygon"
+  ],
+  "license": "MIT",
+  "main": "dist/js/index.js",
+  "module": "dist/es/index.js",
+  "name": "@turf/polygon-to-line",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Turfjs/turf.git"
+  },
+  "scripts": {
+    "bench": "ts-node bench.js",
+    "build": "npm-run-all build:*",
+    "build:es": "tsc --outDir dist/es --module esnext --declaration false && echo '{\"type\":\"module\"}' > dist/es/package.json",
+    "build:js": "tsc",
+    "docs": "node ../../scripts/generate-readmes",
+    "test": "npm-run-all test:*",
+    "test:tape": "ts-node -r esm test.js"
+  },
+  "sideEffects": false,
+  "types": "dist/js/index.d.ts",
+  "version": "6.5.0"
+}

package/node_modules/@turf/polygonize/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TurfJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/@turf/polygonize/README.md

@@ -0,0 +1,69 @@
+# @turf/polygonize
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+## polygonize
+
+Polygonizes [(Multi)LineString(s)][1] into [Polygons][2].
+
+Implementation of GEOSPolygonize function (`geos::operation::polygonize::Polygonizer`).
+
+Polygonizes a set of lines that represents edges in a planar graph. Edges must be correctly
+noded, i.e., they must only meet at their endpoints.
+
+The implementation correctly handles:
+
+-   Dangles: edges which have one or both ends which are not incident on another edge endpoint.
+-   Cut Edges (bridges): edges that are connected at both ends but which do not form part of a polygon.
+
+**Parameters**
+
+-   `geoJson` **([FeatureCollection][3] \| [Geometry][4] \| [Feature][5]&lt;([LineString][6] \| [MultiLineString][7])>)** Lines in order to polygonize
+
+
+-   Throws **[Error][8]** if geoJson is invalid.
+
+Returns **[FeatureCollection][3]&lt;[Polygon][9]>** Polygons created
+
+[1]: https://tools.ietf.org/html/rfc7946#section-3.1.4
+
+[2]: https://tools.ietf.org/html/rfc7946#section-3.1.6
+
+[3]: https://tools.ietf.org/html/rfc7946#section-3.3
+
+[4]: https://tools.ietf.org/html/rfc7946#section-3.1
+
+[5]: https://tools.ietf.org/html/rfc7946#section-3.2
+
+[6]: https://tools.ietf.org/html/rfc7946#section-3.1.4
+
+[7]: https://tools.ietf.org/html/rfc7946#section-3.1.5
+
+[8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error
+
+[9]: https://tools.ietf.org/html/rfc7946#section-3.1.6
+
+<!-- This file is automatically generated. Please don't edit it directly:
+if you find an error, edit the source file (likely index.js), and re-run
+./scripts/generate-readmes in the turf project. -->
+
+---
+
+This module is part of the [Turfjs project](http://turfjs.org/), an open source
+module collection dedicated to geographic algorithms. It is maintained in the
+[Turfjs/turf](https://github.com/Turfjs/turf) repository, where you can create
+PRs and issues.
+
+### Installation
+
+Install this module individually:
+
+```sh
+$ npm install @turf/polygonize
+```
+
+Or install the Turf module that includes it as a function:
+
+```sh
+$ npm install @turf/turf
+```

package/node_modules/@turf/polygonize/dist/es/index.js

@@ -0,0 +1,46 @@
+import { featureCollection } from "@turf/helpers";
+import Graph from "./lib/Graph.js";
+import EdgeRing from "./lib/EdgeRing.js";
+/**
+ * Polygonizes {@link LineString|(Multi)LineString(s)} into {@link Polygons}.
+ *
+ * Implementation of GEOSPolygonize function (`geos::operation::polygonize::Polygonizer`).
+ *
+ * Polygonizes a set of lines that represents edges in a planar graph. Edges must be correctly
+ * noded, i.e., they must only meet at their endpoints.
+ *
+ * The implementation correctly handles:
+ *
+ * - Dangles: edges which have one or both ends which are not incident on another edge endpoint.
+ * - Cut Edges (bridges): edges that are connected at both ends but which do not form part of a polygon.
+ *
+ * @name polygonize
+ * @param {FeatureCollection|Geometry|Feature<LineString|MultiLineString>} geoJson Lines in order to polygonize
+ * @returns {FeatureCollection<Polygon>} Polygons created
+ * @throws {Error} if geoJson is invalid.
+ */
+export default function polygonize(geoJson) {
+    var graph = Graph.fromGeoJson(geoJson);
+    // 1. Remove dangle node
+    graph.deleteDangles();
+    // 2. Remove cut-edges (bridge edges)
+    graph.deleteCutEdges();
+    // 3. Get all holes and shells
+    var holes = [], shells = [];
+    graph
+        .getEdgeRings()
+        .filter(function (edgeRing) { return edgeRing.isValid(); })
+        .forEach(function (edgeRing) {
+        if (edgeRing.isHole())
+            holes.push(edgeRing);
+        else
+            shells.push(edgeRing);
+    });
+    // 4. Assign Holes to Shells
+    holes.forEach(function (hole) {
+        if (EdgeRing.findEdgeRingContaining(hole, shells))
+            shells.push(hole);
+    });
+    // 5. EdgeRings to Polygons
+    return featureCollection(shells.map(function (shell) { return shell.toPolygon(); }));
+}

package/node_modules/@turf/polygonize/dist/es/lib/Edge.js

@@ -0,0 +1,77 @@
+import { lineString } from "@turf/helpers";
+import { orientationIndex } from "./util.js";
+/**
+ * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
+ */
+var Edge = /** @class */ (function () {
+    /**
+     * @param {Node} from - start node of the Edge
+     * @param {Node} to - end node of the edge
+     */
+    function Edge(from, to) {
+        this.from = from; //< start
+        this.to = to; //< End
+        this.next = undefined; //< The edge to be computed after
+        this.label = undefined; //< Used in order to detect Cut Edges (Bridges)
+        this.symetric = undefined; //< The symetric edge of this
+        this.ring = undefined; //< EdgeRing in which the Edge is
+        this.from.addOuterEdge(this);
+        this.to.addInnerEdge(this);
+    }
+    /**
+     * Creates or get the symetric Edge.
+     *
+     * @returns {Edge} - Symetric Edge.
+     */
+    Edge.prototype.getSymetric = function () {
+        if (!this.symetric) {
+            this.symetric = new Edge(this.to, this.from);
+            this.symetric.symetric = this;
+        }
+        return this.symetric;
+    };
+    /**
+     * Removes edge from from and to nodes.
+     */
+    Edge.prototype.deleteEdge = function () {
+        this.from.removeOuterEdge(this);
+        this.to.removeInnerEdge(this);
+    };
+    /**
+     * Compares Edge equallity.
+     *
+     * An edge is equal to another, if the from and to nodes are the same.
+     *
+     * @param {Edge} edge - Another Edge
+     * @returns {boolean} - True if Edges are equal, False otherwise
+     */
+    Edge.prototype.isEqual = function (edge) {
+        return this.from.id === edge.from.id && this.to.id === edge.to.id;
+    };
+    Edge.prototype.toString = function () {
+        return "Edge { " + this.from.id + " -> " + this.to.id + " }";
+    };
+    /**
+     * Returns a LineString representation of the Edge
+     *
+     * @returns {Feature<LineString>} - LineString representation of the Edge
+     */
+    Edge.prototype.toLineString = function () {
+        return lineString([this.from.coordinates, this.to.coordinates]);
+    };
+    /**
+     * Comparator of two edges.
+     *
+     * Implementation of geos::planargraph::DirectedEdge::compareTo.
+     *
+     * @param {Edge} edge - Another edge to compare with this one
+     * @returns {number} -1 if this Edge has a greater angle with the positive x-axis than b,
+     *          0 if the Edges are colinear,
+     *          1 otherwise
+     */
+    Edge.prototype.compareTo = function (edge) {
+        return orientationIndex(edge.from.coordinates, edge.to.coordinates, this.to.coordinates);
+    };
+    return Edge;
+}());
+export default Edge;

package/node_modules/@turf/polygonize/dist/es/lib/EdgeRing.js

@@ -0,0 +1,199 @@
+import { orientationIndex, envelopeIsEqual, envelopeContains, coordinatesEqual, } from "./util.js";
+import { multiPoint, polygon, point, } from "@turf/helpers";
+import envelope from "@turf/envelope";
+import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
+/**
+ * Ring of edges which form a polygon.
+ *
+ * The ring may be either an outer shell or a hole.
+ *
+ * This class is inspired in GEOS's geos::operation::polygonize::EdgeRing
+ */
+var EdgeRing = /** @class */ (function () {
+    function EdgeRing() {
+        this.edges = [];
+        this.polygon = undefined; //< Caches Polygon representation
+        this.envelope = undefined; //< Caches Envelope representation
+    }
+    /**
+     * Add an edge to the ring, inserting it in the last position.
+     *
+     * @memberof EdgeRing
+     * @param {Edge} edge - Edge to be inserted
+     */
+    EdgeRing.prototype.push = function (edge) {
+        this.edges.push(edge);
+        this.polygon = this.envelope = undefined;
+    };
+    /**
+     * Get Edge.
+     *
+     * @memberof EdgeRing
+     * @param {number} i - Index
+     * @returns {Edge} - Edge in the i position
+     */
+    EdgeRing.prototype.get = function (i) {
+        return this.edges[i];
+    };
+    Object.defineProperty(EdgeRing.prototype, "length", {
+        /**
+         * Getter of length property.
+         *
+         * @memberof EdgeRing
+         * @returns {number} - Length of the edge ring.
+         */
+        get: function () {
+            return this.edges.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Similar to Array.prototype.forEach for the list of Edges in the EdgeRing.
+     *
+     * @memberof EdgeRing
+     * @param {Function} f - The same function to be passed to Array.prototype.forEach
+     */
+    EdgeRing.prototype.forEach = function (f) {
+        this.edges.forEach(f);
+    };
+    /**
+     * Similar to Array.prototype.map for the list of Edges in the EdgeRing.
+     *
+     * @memberof EdgeRing
+     * @param {Function} f - The same function to be passed to Array.prototype.map
+     * @returns {Array} - The mapped values in the function
+     */
+    EdgeRing.prototype.map = function (f) {
+        return this.edges.map(f);
+    };
+    /**
+     * Similar to Array.prototype.some for the list of Edges in the EdgeRing.
+     *
+     * @memberof EdgeRing
+     * @param {Function} f - The same function to be passed to Array.prototype.some
+     * @returns {boolean} - True if an Edge check the condition
+     */
+    EdgeRing.prototype.some = function (f) {
+        return this.edges.some(f);
+    };
+    /**
+     * Check if the ring is valid in geomtry terms.
+     *
+     * A ring must have either 0 or 4 or more points. The first and the last must be
+     * equal (in 2D)
+     * geos::geom::LinearRing::validateConstruction
+     *
+     * @memberof EdgeRing
+     * @returns {boolean} - Validity of the EdgeRing
+     */
+    EdgeRing.prototype.isValid = function () {
+        // TODO: stub
+        return true;
+    };
+    /**
+     * Tests whether this ring is a hole.
+     *
+     * A ring is a hole if it is oriented counter-clockwise.
+     * Similar implementation of geos::algorithm::CGAlgorithms::isCCW
+     *
+     * @memberof EdgeRing
+     * @returns {boolean} - true: if it is a hole
+     */
+    EdgeRing.prototype.isHole = function () {
+        var _this = this;
+        // XXX: Assuming Ring is valid
+        // Find highest point
+        var hiIndex = this.edges.reduce(function (high, edge, i) {
+            if (edge.from.coordinates[1] > _this.edges[high].from.coordinates[1])
+                high = i;
+            return high;
+        }, 0), iPrev = (hiIndex === 0 ? this.length : hiIndex) - 1, iNext = (hiIndex + 1) % this.length, disc = orientationIndex(this.edges[iPrev].from.coordinates, this.edges[hiIndex].from.coordinates, this.edges[iNext].from.coordinates);
+        if (disc === 0)
+            return (this.edges[iPrev].from.coordinates[0] >
+                this.edges[iNext].from.coordinates[0]);
+        return disc > 0;
+    };
+    /**
+     * Creates a MultiPoint representing the EdgeRing (discarts edges directions).
+     *
+     * @memberof EdgeRing
+     * @returns {Feature<MultiPoint>} - Multipoint representation of the EdgeRing
+     */
+    EdgeRing.prototype.toMultiPoint = function () {
+        return multiPoint(this.edges.map(function (edge) { return edge.from.coordinates; }));
+    };
+    /**
+     * Creates a Polygon representing the EdgeRing.
+     *
+     * @memberof EdgeRing
+     * @returns {Feature<Polygon>} - Polygon representation of the Edge Ring
+     */
+    EdgeRing.prototype.toPolygon = function () {
+        if (this.polygon)
+            return this.polygon;
+        var coordinates = this.edges.map(function (edge) { return edge.from.coordinates; });
+        coordinates.push(this.edges[0].from.coordinates);
+        return (this.polygon = polygon([coordinates]));
+    };
+    /**
+     * Calculates the envelope of the EdgeRing.
+     *
+     * @memberof EdgeRing
+     * @returns {Feature<Polygon>} - envelope
+     */
+    EdgeRing.prototype.getEnvelope = function () {
+        if (this.envelope)
+            return this.envelope;
+        return (this.envelope = envelope(this.toPolygon()));
+    };
+    /**
+     * `geos::operation::polygonize::EdgeRing::findEdgeRingContaining`
+     *
+     * @param {EdgeRing} testEdgeRing - EdgeRing to look in the list
+     * @param {EdgeRing[]} shellList - List of EdgeRing in which to search
+     *
+     * @returns {EdgeRing} - EdgeRing which contains the testEdgeRing
+     */
+    EdgeRing.findEdgeRingContaining = function (testEdgeRing, shellList) {
+        var testEnvelope = testEdgeRing.getEnvelope();
+        var minEnvelope, minShell;
+        shellList.forEach(function (shell) {
+            var tryEnvelope = shell.getEnvelope();
+            if (minShell)
+                minEnvelope = minShell.getEnvelope();
+            // the hole envelope cannot equal the shell envelope
+            if (envelopeIsEqual(tryEnvelope, testEnvelope))
+                return;
+            if (envelopeContains(tryEnvelope, testEnvelope)) {
+                var testEdgeRingCoordinates = testEdgeRing.map(function (edge) { return edge.from.coordinates; });
+                var testPoint = void 0;
+                var _loop_1 = function (pt) {
+                    if (!shell.some(function (edge) { return coordinatesEqual(pt, edge.from.coordinates); })) {
+                        testPoint = pt;
+                    }
+                };
+                for (var _i = 0, testEdgeRingCoordinates_1 = testEdgeRingCoordinates; _i < testEdgeRingCoordinates_1.length; _i++) {
+                    var pt = testEdgeRingCoordinates_1[_i];
+                    _loop_1(pt);
+                }
+                if (testPoint && shell.inside(point(testPoint))) {
+                    if (!minShell || envelopeContains(minEnvelope, tryEnvelope))
+                        minShell = shell;
+                }
+            }
+        });
+        return minShell;
+    };
+    /**
+     * Checks if the point is inside the edgeRing
+     *
+     * @param {Feature<Point>} pt - Point to check if it is inside the edgeRing
+     * @returns {boolean} - True if it is inside, False otherwise
+     */
+    EdgeRing.prototype.inside = function (pt) {
+        return booleanPointInPolygon(pt, this.toPolygon());
+    };
+    return EdgeRing;
+}());
+export default EdgeRing;