@turf/polygonize 7.0.0-alpha.1 → 7.0.0-alpha.111

package/dist/es/lib/Graph.js

@@ -1,289 +0,0 @@
-import Node from "./Node.js";
-import Edge from "./Edge.js";
-import EdgeRing from "./EdgeRing.js";
-import { flattenEach, coordReduce } from "@turf/meta";
-import { featureOf } from "@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)
- */
-export default 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();
-        flattenEach(geoJson, (feature) => {
-            featureOf(feature, "LineString", "Graph::fromGeoJson");
-            // When a LineString if formed by many segments, split them
-            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.buildId(coordinates);
-        let node = this.nodes[id];
-        if (!node)
-            node = this.nodes[id] = new Node(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(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();
-        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();
-    }
-}

package/dist/es/lib/Node.js

@@ -1,90 +0,0 @@
-import { orientationIndex } from "./util.js";
-/**
- * Node
- */
-export default 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 = 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);
-    }
-}

package/dist/es/lib/util.js

@@ -1,64 +0,0 @@
-import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-import { point } from "@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
- */
-export 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);
-}
-/**
- * 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 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));
-}
-/**
- * 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 function envelopeContains(self, env) {
-    return env.geometry.coordinates[0].every((c) => booleanPointInPolygon(point(c), self));
-}
-/**
- * Checks if two coordinates are equal.
- *
- * @param {number[]} coord1 - First coordinate
- * @param {number[]} coord2 - Second coordinate
- * @returns {boolean} - True if coordinates are equal
- */
-export function coordinatesEqual(coord1, coord2) {
-    return coord1[0] === coord2[0] && coord1[1] === coord2[1];
-}

package/dist/es/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/js/index.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const helpers_1 = require("@turf/helpers");
-const Graph_1 = tslib_1.__importDefault(require("./lib/Graph"));
-const EdgeRing_1 = tslib_1.__importDefault(require("./lib/EdgeRing"));
-/**
- * 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.
- */
-function polygonize(geoJson) {
-    const graph = Graph_1.default.fromGeoJson(geoJson);
-    // 1. Remove dangle node
-    graph.deleteDangles();
-    // 2. Remove cut-edges (bridge edges)
-    graph.deleteCutEdges();
-    // 3. Get all holes and shells
-    const holes = [], shells = [];
-    graph
-        .getEdgeRings()
-        .filter((edgeRing) => edgeRing.isValid())
-        .forEach((edgeRing) => {
-        if (edgeRing.isHole())
-            holes.push(edgeRing);
-        else
-            shells.push(edgeRing);
-    });
-    // 4. Assign Holes to Shells
-    holes.forEach((hole) => {
-        if (EdgeRing_1.default.findEdgeRingContaining(hole, shells))
-            shells.push(hole);
-    });
-    // 5. EdgeRings to Polygons
-    return helpers_1.featureCollection(shells.map((shell) => shell.toPolygon()));
-}
-exports.default = polygonize;

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

@@ -1,55 +0,0 @@
-import Node from "./Node";
-import EdgeRing from "./EdgeRing";
-/**
- * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
- */
-export default class Edge {
-    label?: number;
-    symetric?: Edge;
-    from: Node;
-    to: Node;
-    next?: Edge;
-    ring?: EdgeRing;
-    /**
-     * Creates or get the symetric Edge.
-     *
-     * @returns {Edge} - Symetric Edge.
-     */
-    getSymetric(): Edge;
-    /**
-     * @param {Node} from - start node of the Edge
-     * @param {Node} to - end node of the edge
-     */
-    constructor(from: Node, to: Node);
-    /**
-     * Removes edge from from and to nodes.
-     */
-    deleteEdge(): void;
-    /**
-     * 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
-     */
-    isEqual(edge: Edge): boolean;
-    toString(): string;
-    /**
-     * Returns a LineString representation of the Edge
-     *
-     * @returns {Feature<LineString>} - LineString representation of the Edge
-     */
-    toLineString(): import("geojson").Feature<import("geojson").LineString, import("geojson").GeoJsonProperties>;
-    /**
-     * 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
-     */
-    compareTo(edge: Edge): number;
-}

package/dist/js/lib/Edge.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("@turf/helpers");
-const util_1 = require("./util");
-/**
- * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
- */
-class Edge {
-    /**
-     * @param {Node} from - start node of the Edge
-     * @param {Node} to - end node of the edge
-     */
-    constructor(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.
-     */
-    getSymetric() {
-        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.
-     */
-    deleteEdge() {
-        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
-     */
-    isEqual(edge) {
-        return this.from.id === edge.from.id && this.to.id === edge.to.id;
-    }
-    toString() {
-        return `Edge { ${this.from.id} -> ${this.to.id} }`;
-    }
-    /**
-     * Returns a LineString representation of the Edge
-     *
-     * @returns {Feature<LineString>} - LineString representation of the Edge
-     */
-    toLineString() {
-        return helpers_1.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
-     */
-    compareTo(edge) {
-        return util_1.orientationIndex(edge.from.coordinates, edge.to.coordinates, this.to.coordinates);
-    }
-}
-exports.default = Edge;