@turf/polygonize 7.0.0-alpha.2 → 7.0.0

package/dist/js/lib/Graph.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const Node_1 = tslib_1.__importDefault(require("./Node"));
-const Edge_1 = tslib_1.__importDefault(require("./Edge"));
-const EdgeRing_1 = tslib_1.__importDefault(require("./EdgeRing"));
-const meta_1 = require("@turf/meta");
-const invariant_1 = require("@turf/invariant");
-/**
- * Validates the geoJson.
- *
- * @param {GeoJSON} geoJson - input geoJson.
- * @throws {Error} if geoJson is invalid.
- */
-function validateGeoJson(geoJson) {
-    if (!geoJson)
-        throw new Error("No geojson passed");
-    if (geoJson.type !== "FeatureCollection" &&
-        geoJson.type !== "GeometryCollection" &&
-        geoJson.type !== "MultiLineString" &&
-        geoJson.type !== "LineString" &&
-        geoJson.type !== "Feature")
-        throw new Error(`Invalid input type '${geoJson.type}'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature`);
-}
-/**
- * Represents a planar graph of edges and nodes that can be used to compute a polygonization.
- *
- * Although, this class is inspired by GEOS's `geos::operation::polygonize::PolygonizeGraph`,
- * it isn't a rewrite. As regards algorithm, this class implements the same logic, but it
- * isn't a javascript transcription of the C++ source.
- *
- * This graph is directed (both directions are created)
- */
-class Graph {
-    constructor() {
-        this.edges = []; //< {Edge[]} dirEdges
-        // The key is the `id` of the Node (ie: coordinates.join(','))
-        this.nodes = {};
-    }
-    /**
-     * Creates a graph from a GeoJSON.
-     *
-     * @param {FeatureCollection<LineString>} geoJson - it must comply with the restrictions detailed in the index
-     * @returns {Graph} - The newly created graph
-     * @throws {Error} if geoJson is invalid.
-     */
-    static fromGeoJson(geoJson) {
-        validateGeoJson(geoJson);
-        const graph = new Graph();
-        meta_1.flattenEach(geoJson, (feature) => {
-            invariant_1.featureOf(feature, "LineString", "Graph::fromGeoJson");
-            // When a LineString if formed by many segments, split them
-            meta_1.coordReduce(feature, (prev, cur) => {
-                if (prev) {
-                    const start = graph.getNode(prev), end = graph.getNode(cur);
-                    graph.addEdge(start, end);
-                }
-                return cur;
-            });
-        });
-        return graph;
-    }
-    /**
-     * Creates or get a Node.
-     *
-     * @param {number[]} coordinates - Coordinates of the node
-     * @returns {Node} - The created or stored node
-     */
-    getNode(coordinates) {
-        const id = Node_1.default.buildId(coordinates);
-        let node = this.nodes[id];
-        if (!node)
-            node = this.nodes[id] = new Node_1.default(coordinates);
-        return node;
-    }
-    /**
-     * Adds an Edge and its symetricall.
-     *
-     * Edges are added symetrically, i.e.: we also add its symetric
-     *
-     * @param {Node} from - Node which starts the Edge
-     * @param {Node} to - Node which ends the Edge
-     */
-    addEdge(from, to) {
-        const edge = new Edge_1.default(from, to), symetricEdge = edge.getSymetric();
-        this.edges.push(edge);
-        this.edges.push(symetricEdge);
-    }
-    /**
-     * Removes Dangle Nodes (nodes with grade 1).
-     */
-    deleteDangles() {
-        Object.keys(this.nodes)
-            .map((id) => this.nodes[id])
-            .forEach((node) => this._removeIfDangle(node));
-    }
-    /**
-     * Check if node is dangle, if so, remove it.
-     *
-     * It calls itself recursively, removing a dangling node might cause another dangling node
-     *
-     * @param {Node} node - Node to check if it's a dangle
-     */
-    _removeIfDangle(node) {
-        // As edges are directed and symetrical, we count only innerEdges
-        if (node.innerEdges.length <= 1) {
-            const outerNodes = node.getOuterEdges().map((e) => e.to);
-            this.removeNode(node);
-            outerNodes.forEach((n) => this._removeIfDangle(n));
-        }
-    }
-    /**
-     * Delete cut-edges (bridge edges).
-     *
-     * The graph will be traversed, all the edges will be labeled according the ring
-     * in which they are. (The label is a number incremented by 1). Edges with the same
-     * label are cut-edges.
-     */
-    deleteCutEdges() {
-        this._computeNextCWEdges();
-        this._findLabeledEdgeRings();
-        // Cut-edges (bridges) are edges where both edges have the same label
-        this.edges.forEach((edge) => {
-            if (edge.label === edge.symetric.label) {
-                this.removeEdge(edge.symetric);
-                this.removeEdge(edge);
-            }
-        });
-    }
-    /**
-     * Set the `next` property of each Edge.
-     *
-     * The graph will be transversed in a CW form, so, we set the next of the symetrical edge as the previous one.
-     * OuterEdges are sorted CCW.
-     *
-     * @param {Node} [node] - If no node is passed, the function calls itself for every node in the Graph
-     */
-    _computeNextCWEdges(node) {
-        if (typeof node === "undefined") {
-            Object.keys(this.nodes).forEach((id) => this._computeNextCWEdges(this.nodes[id]));
-        }
-        else {
-            node.getOuterEdges().forEach((edge, i) => {
-                node.getOuterEdge((i === 0 ? node.getOuterEdges().length : i) - 1).symetric.next = edge;
-            });
-        }
-    }
-    /**
-     * Computes the next edge pointers going CCW around the given node, for the given edgering label.
-     *
-     * This algorithm has the effect of converting maximal edgerings into minimal edgerings
-     *
-     * XXX: method literally transcribed from `geos::operation::polygonize::PolygonizeGraph::computeNextCCWEdges`,
-     * could be written in a more javascript way.
-     *
-     * @param {Node} node - Node
-     * @param {number} label - Ring's label
-     */
-    _computeNextCCWEdges(node, label) {
-        const edges = node.getOuterEdges();
-        let firstOutDE, prevInDE;
-        for (let i = edges.length - 1; i >= 0; --i) {
-            let de = edges[i], sym = de.symetric, outDE, inDE;
-            if (de.label === label)
-                outDE = de;
-            if (sym.label === label)
-                inDE = sym;
-            if (!outDE || !inDE)
-                // This edge is not in edgering
-                continue;
-            if (inDE)
-                prevInDE = inDE;
-            if (outDE) {
-                if (prevInDE) {
-                    prevInDE.next = outDE;
-                    prevInDE = undefined;
-                }
-                if (!firstOutDE)
-                    firstOutDE = outDE;
-            }
-        }
-        if (prevInDE)
-            prevInDE.next = firstOutDE;
-    }
-    /**
-     * Finds rings and labels edges according to which rings are.
-     *
-     * The label is a number which is increased for each ring.
-     *
-     * @returns {Edge[]} edges that start rings
-     */
-    _findLabeledEdgeRings() {
-        const edgeRingStarts = [];
-        let label = 0;
-        this.edges.forEach((edge) => {
-            if (edge.label >= 0)
-                return;
-            edgeRingStarts.push(edge);
-            let e = edge;
-            do {
-                e.label = label;
-                e = e.next;
-            } while (!edge.isEqual(e));
-            label++;
-        });
-        return edgeRingStarts;
-    }
-    /**
-     * Computes the EdgeRings formed by the edges in this graph.
-     *
-     * @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
-     */
-    getEdgeRings() {
-        this._computeNextCWEdges();
-        // Clear labels
-        this.edges.forEach((edge) => {
-            edge.label = undefined;
-        });
-        this._findLabeledEdgeRings().forEach((edge) => {
-            // convertMaximalToMinimalEdgeRings
-            this._findIntersectionNodes(edge).forEach((node) => {
-                this._computeNextCCWEdges(node, edge.label);
-            });
-        });
-        const edgeRingList = [];
-        // find all edgerings
-        this.edges.forEach((edge) => {
-            if (edge.ring)
-                return;
-            edgeRingList.push(this._findEdgeRing(edge));
-        });
-        return edgeRingList;
-    }
-    /**
-     * Find all nodes in a Maxima EdgeRing which are self-intersection nodes.
-     *
-     * @param {Node} startEdge - Start Edge of the Ring
-     * @returns {Node[]} - intersection nodes
-     */
-    _findIntersectionNodes(startEdge) {
-        const intersectionNodes = [];
-        let edge = startEdge;
-        do {
-            // getDegree
-            let degree = 0;
-            edge.from.getOuterEdges().forEach((e) => {
-                if (e.label === startEdge.label)
-                    ++degree;
-            });
-            if (degree > 1)
-                intersectionNodes.push(edge.from);
-            edge = edge.next;
-        } while (!startEdge.isEqual(edge));
-        return intersectionNodes;
-    }
-    /**
-     * Get the edge-ring which starts from the provided Edge.
-     *
-     * @param {Edge} startEdge - starting edge of the edge ring
-     * @returns {EdgeRing} - EdgeRing which start Edge is the provided one.
-     */
-    _findEdgeRing(startEdge) {
-        let edge = startEdge;
-        const edgeRing = new EdgeRing_1.default();
-        do {
-            edgeRing.push(edge);
-            edge.ring = edgeRing;
-            edge = edge.next;
-        } while (!startEdge.isEqual(edge));
-        return edgeRing;
-    }
-    /**
-     * Removes a node from the Graph.
-     *
-     * It also removes edges asociated to that node
-     * @param {Node} node - Node to be removed
-     */
-    removeNode(node) {
-        node.getOuterEdges().forEach((edge) => this.removeEdge(edge));
-        node.innerEdges.forEach((edge) => this.removeEdge(edge));
-        delete this.nodes[node.id];
-    }
-    /**
-     * Remove edge from the graph and deletes the edge.
-     *
-     * @param {Edge} edge - Edge to be removed
-     */
-    removeEdge(edge) {
-        this.edges = this.edges.filter((e) => !e.isEqual(edge));
-        edge.deleteEdge();
-    }
-}
-exports.default = Graph;

package/dist/js/lib/Node.d.ts

@@ -1,40 +0,0 @@
-import Edge from "./Edge";
-/**
- * Node
- */
-export default class Node {
-    static buildId(coordinates: number[]): string;
-    id: string;
-    coordinates: number[];
-    innerEdges: Edge[];
-    private outerEdges;
-    private outerEdgesSorted;
-    constructor(coordinates: number[]);
-    removeInnerEdge(edge: Edge): void;
-    removeOuterEdge(edge: Edge): void;
-    /**
-     * Outer edges are stored CCW order.
-     *
-     * @memberof Node
-     * @param {Edge} edge - Edge to add as an outerEdge.
-     */
-    addOuterEdge(edge: Edge): void;
-    /**
-     * Sorts outer edges in CCW way.
-     *
-     * @memberof Node
-     * @private
-     */
-    sortOuterEdges(): void;
-    /**
-     * Retrieves outer edges.
-     *
-     * They are sorted if they aren't in the CCW order.
-     *
-     * @memberof Node
-     * @returns {Edge[]} - List of outer edges sorted in a CCW order.
-     */
-    getOuterEdges(): Edge[];
-    getOuterEdge(i: number): Edge;
-    addInnerEdge(edge: Edge): void;
-}

package/dist/js/lib/Node.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("./util");
-/**
- * Node
- */
-class Node {
-    constructor(coordinates) {
-        this.id = Node.buildId(coordinates);
-        this.coordinates = coordinates; //< {Number[]}
-        this.innerEdges = []; //< {Edge[]}
-        // We wil store to (out) edges in an CCW order as geos::planargraph::DirectedEdgeStar does
-        this.outerEdges = []; //< {Edge[]}
-        this.outerEdgesSorted = false; //< {Boolean} flag that stores if the outer Edges had been sorted
-    }
-    static buildId(coordinates) {
-        return coordinates.join(",");
-    }
-    removeInnerEdge(edge) {
-        this.innerEdges = this.innerEdges.filter((e) => e.from.id !== edge.from.id);
-    }
-    removeOuterEdge(edge) {
-        this.outerEdges = this.outerEdges.filter((e) => e.to.id !== edge.to.id);
-    }
-    /**
-     * Outer edges are stored CCW order.
-     *
-     * @memberof Node
-     * @param {Edge} edge - Edge to add as an outerEdge.
-     */
-    addOuterEdge(edge) {
-        this.outerEdges.push(edge);
-        this.outerEdgesSorted = false;
-    }
-    /**
-     * Sorts outer edges in CCW way.
-     *
-     * @memberof Node
-     * @private
-     */
-    sortOuterEdges() {
-        if (!this.outerEdgesSorted) {
-            //this.outerEdges.sort((a, b) => a.compareTo(b));
-            // Using this comparator in order to be deterministic
-            this.outerEdges.sort((a, b) => {
-                const aNode = a.to, bNode = b.to;
-                if (aNode.coordinates[0] - this.coordinates[0] >= 0 &&
-                    bNode.coordinates[0] - this.coordinates[0] < 0)
-                    return 1;
-                if (aNode.coordinates[0] - this.coordinates[0] < 0 &&
-                    bNode.coordinates[0] - this.coordinates[0] >= 0)
-                    return -1;
-                if (aNode.coordinates[0] - this.coordinates[0] === 0 &&
-                    bNode.coordinates[0] - this.coordinates[0] === 0) {
-                    if (aNode.coordinates[1] - this.coordinates[1] >= 0 ||
-                        bNode.coordinates[1] - this.coordinates[1] >= 0)
-                        return aNode.coordinates[1] - bNode.coordinates[1];
-                    return bNode.coordinates[1] - aNode.coordinates[1];
-                }
-                const det = util_1.orientationIndex(this.coordinates, aNode.coordinates, bNode.coordinates);
-                if (det < 0)
-                    return 1;
-                if (det > 0)
-                    return -1;
-                const d1 = Math.pow(aNode.coordinates[0] - this.coordinates[0], 2) +
-                    Math.pow(aNode.coordinates[1] - this.coordinates[1], 2), d2 = Math.pow(bNode.coordinates[0] - this.coordinates[0], 2) +
-                    Math.pow(bNode.coordinates[1] - this.coordinates[1], 2);
-                return d1 - d2;
-            });
-            this.outerEdgesSorted = true;
-        }
-    }
-    /**
-     * Retrieves outer edges.
-     *
-     * They are sorted if they aren't in the CCW order.
-     *
-     * @memberof Node
-     * @returns {Edge[]} - List of outer edges sorted in a CCW order.
-     */
-    getOuterEdges() {
-        this.sortOuterEdges();
-        return this.outerEdges;
-    }
-    getOuterEdge(i) {
-        this.sortOuterEdges();
-        return this.outerEdges[i];
-    }
-    addInnerEdge(edge) {
-        this.innerEdges.push(edge);
-    }
-}
-exports.default = Node;

package/dist/js/lib/util.d.ts

@@ -1,46 +0,0 @@
-import { Feature, Polygon } from "geojson";
-/**
- * Returns the direction of the point q relative to the vector p1 -> p2.
- *
- * Implementation of geos::algorithm::CGAlgorithm::orientationIndex()
- * (same as geos::algorithm::CGAlgorithm::computeOrientation())
- *
- * @param {number[]} p1 - the origin point of the vector
- * @param {number[]} p2 - the final point of the vector
- * @param {number[]} q - the point to compute the direction to
- *
- * @returns {number} - 1 if q is ccw (left) from p1->p2,
- *    -1 if q is cw (right) from p1->p2,
- *     0 if q is colinear with p1->p2
- */
-export declare function orientationIndex(p1: number[], p2: number[], q: number[]): number;
-/**
- * Checks if two envelopes are equal.
- *
- * The function assumes that the arguments are envelopes, i.e.: Rectangular polygon
- *
- * @param {Feature<Polygon>} env1 - Envelope
- * @param {Feature<Polygon>} env2 - Envelope
- * @returns {boolean} - True if the envelopes are equal
- */
-export declare function envelopeIsEqual(env1: Feature<Polygon>, env2: Feature<Polygon>): boolean;
-/**
- * Check if a envelope is contained in other one.
- *
- * The function assumes that the arguments are envelopes, i.e.: Convex polygon
- * XXX: Envelopes are rectangular, checking if a point is inside a rectangule is something easy,
- * this could be further improved.
- *
- * @param {Feature<Polygon>} self - Envelope
- * @param {Feature<Polygon>} env - Envelope
- * @returns {boolean} - True if env is contained in self
- */
-export declare function envelopeContains(self: Feature<Polygon>, env: Feature<Polygon>): boolean;
-/**
- * Checks if two coordinates are equal.
- *
- * @param {number[]} coord1 - First coordinate
- * @param {number[]} coord2 - Second coordinate
- * @returns {boolean} - True if coordinates are equal
- */
-export declare function coordinatesEqual(coord1: number[], coord2: number[]): boolean;

package/dist/js/lib/util.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const boolean_point_in_polygon_1 = tslib_1.__importDefault(require("@turf/boolean-point-in-polygon"));
-const helpers_1 = require("@turf/helpers");
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign#Polyfill
-function mathSign(x) {
-    return ((x > 0) - (x < 0) || +x);
-}
-/**
- * Returns the direction of the point q relative to the vector p1 -> p2.
- *
- * Implementation of geos::algorithm::CGAlgorithm::orientationIndex()
- * (same as geos::algorithm::CGAlgorithm::computeOrientation())
- *
- * @param {number[]} p1 - the origin point of the vector
- * @param {number[]} p2 - the final point of the vector
- * @param {number[]} q - the point to compute the direction to
- *
- * @returns {number} - 1 if q is ccw (left) from p1->p2,
- *    -1 if q is cw (right) from p1->p2,
- *     0 if q is colinear with p1->p2
- */
-function orientationIndex(p1, p2, q) {
-    const dx1 = p2[0] - p1[0], dy1 = p2[1] - p1[1], dx2 = q[0] - p2[0], dy2 = q[1] - p2[1];
-    return mathSign(dx1 * dy2 - dx2 * dy1);
-}
-exports.orientationIndex = orientationIndex;
-/**
- * Checks if two envelopes are equal.
- *
- * The function assumes that the arguments are envelopes, i.e.: Rectangular polygon
- *
- * @param {Feature<Polygon>} env1 - Envelope
- * @param {Feature<Polygon>} env2 - Envelope
- * @returns {boolean} - True if the envelopes are equal
- */
-function envelopeIsEqual(env1, env2) {
-    const envX1 = env1.geometry.coordinates[0].map((c) => c[0]), envY1 = env1.geometry.coordinates[0].map((c) => c[1]), envX2 = env2.geometry.coordinates[0].map((c) => c[0]), envY2 = env2.geometry.coordinates[0].map((c) => c[1]);
-    return (Math.max.apply(null, envX1) === Math.max.apply(null, envX2) &&
-        Math.max.apply(null, envY1) === Math.max.apply(null, envY2) &&
-        Math.min.apply(null, envX1) === Math.min.apply(null, envX2) &&
-        Math.min.apply(null, envY1) === Math.min.apply(null, envY2));
-}
-exports.envelopeIsEqual = envelopeIsEqual;
-/**
- * Check if a envelope is contained in other one.
- *
- * The function assumes that the arguments are envelopes, i.e.: Convex polygon
- * XXX: Envelopes are rectangular, checking if a point is inside a rectangule is something easy,
- * this could be further improved.
- *
- * @param {Feature<Polygon>} self - Envelope
- * @param {Feature<Polygon>} env - Envelope
- * @returns {boolean} - True if env is contained in self
- */
-function envelopeContains(self, env) {
-    return env.geometry.coordinates[0].every((c) => boolean_point_in_polygon_1.default(helpers_1.point(c), self));
-}
-exports.envelopeContains = envelopeContains;
-/**
- * Checks if two coordinates are equal.
- *
- * @param {number[]} coord1 - First coordinate
- * @param {number[]} coord2 - Second coordinate
- * @returns {boolean} - True if coordinates are equal
- */
-function coordinatesEqual(coord1, coord2) {
-    return coord1[0] === coord2[0] && coord1[1] === coord2[1];
-}
-exports.coordinatesEqual = coordinatesEqual;