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

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

@@ -1,122 +0,0 @@
-import { Polygon, Feature, Point } from "geojson";
-import Edge from "./Edge";
-/**
- * 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
- */
-export default class EdgeRing {
-    private edges;
-    private polygon?;
-    private envelope?;
-    constructor();
-    /**
-     * Add an edge to the ring, inserting it in the last position.
-     *
-     * @memberof EdgeRing
-     * @param {Edge} edge - Edge to be inserted
-     */
-    push(edge: Edge): void;
-    /**
-     * Get Edge.
-     *
-     * @memberof EdgeRing
-     * @param {number} i - Index
-     * @returns {Edge} - Edge in the i position
-     */
-    get(i: number): Edge;
-    /**
-     * Getter of length property.
-     *
-     * @memberof EdgeRing
-     * @returns {number} - Length of the edge ring.
-     */
-    get length(): number;
-    /**
-     * 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
-     */
-    forEach(f: (edge: Edge, index: number, array: Edge[]) => void): void;
-    /**
-     * 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
-     */
-    map<T>(f: (edge: Edge, index: number, array: Edge[]) => T): T[];
-    /**
-     * 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
-     */
-    some(f: (edge: Edge, index: number, array: Edge[]) => boolean): boolean;
-    /**
-     * 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
-     */
-    isValid(): boolean;
-    /**
-     * 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
-     */
-    isHole(): boolean;
-    /**
-     * Creates a MultiPoint representing the EdgeRing (discarts edges directions).
-     *
-     * @memberof EdgeRing
-     * @returns {Feature<MultiPoint>} - Multipoint representation of the EdgeRing
-     */
-    toMultiPoint(): Feature<import("geojson").MultiPoint, import("geojson").GeoJsonProperties>;
-    /**
-     * Creates a Polygon representing the EdgeRing.
-     *
-     * @memberof EdgeRing
-     * @returns {Feature<Polygon>} - Polygon representation of the Edge Ring
-     */
-    toPolygon(): Feature<Polygon, {
-        [name: string]: any;
-    }>;
-    /**
-     * Calculates the envelope of the EdgeRing.
-     *
-     * @memberof EdgeRing
-     * @returns {Feature<Polygon>} - envelope
-     */
-    getEnvelope(): Feature<Polygon, {
-        [name: string]: any;
-    }>;
-    /**
-     * `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
-     */
-    static findEdgeRingContaining(testEdgeRing: EdgeRing, shellList: EdgeRing[]): EdgeRing | undefined;
-    /**
-     * 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
-     */
-    inside(pt: Feature<Point>): boolean;
-}

package/dist/js/lib/EdgeRing.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const util_1 = require("./util");
-const helpers_1 = require("@turf/helpers");
-const envelope_1 = tslib_1.__importDefault(require("@turf/envelope"));
-const boolean_point_in_polygon_1 = tslib_1.__importDefault(require("@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
- */
-class EdgeRing {
-    constructor() {
-        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
-     */
-    push(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
-     */
-    get(i) {
-        return this.edges[i];
-    }
-    /**
-     * Getter of length property.
-     *
-     * @memberof EdgeRing
-     * @returns {number} - Length of the edge ring.
-     */
-    get length() {
-        return this.edges.length;
-    }
-    /**
-     * 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
-     */
-    forEach(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
-     */
-    map(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
-     */
-    some(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
-     */
-    isValid() {
-        // 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
-     */
-    isHole() {
-        // XXX: Assuming Ring is valid
-        // Find highest point
-        const hiIndex = this.edges.reduce((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 = util_1.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
-     */
-    toMultiPoint() {
-        return helpers_1.multiPoint(this.edges.map((edge) => edge.from.coordinates));
-    }
-    /**
-     * Creates a Polygon representing the EdgeRing.
-     *
-     * @memberof EdgeRing
-     * @returns {Feature<Polygon>} - Polygon representation of the Edge Ring
-     */
-    toPolygon() {
-        if (this.polygon)
-            return this.polygon;
-        const coordinates = this.edges.map((edge) => edge.from.coordinates);
-        coordinates.push(this.edges[0].from.coordinates);
-        return (this.polygon = helpers_1.polygon([coordinates]));
-    }
-    /**
-     * Calculates the envelope of the EdgeRing.
-     *
-     * @memberof EdgeRing
-     * @returns {Feature<Polygon>} - envelope
-     */
-    getEnvelope() {
-        if (this.envelope)
-            return this.envelope;
-        return (this.envelope = envelope_1.default(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
-     */
-    static findEdgeRingContaining(testEdgeRing, shellList) {
-        const testEnvelope = testEdgeRing.getEnvelope();
-        let minEnvelope, minShell;
-        shellList.forEach((shell) => {
-            const tryEnvelope = shell.getEnvelope();
-            if (minShell)
-                minEnvelope = minShell.getEnvelope();
-            // the hole envelope cannot equal the shell envelope
-            if (util_1.envelopeIsEqual(tryEnvelope, testEnvelope))
-                return;
-            if (util_1.envelopeContains(tryEnvelope, testEnvelope)) {
-                const testEdgeRingCoordinates = testEdgeRing.map((edge) => edge.from.coordinates);
-                let testPoint;
-                for (const pt of testEdgeRingCoordinates) {
-                    if (!shell.some((edge) => util_1.coordinatesEqual(pt, edge.from.coordinates))) {
-                        testPoint = pt;
-                    }
-                }
-                if (testPoint && shell.inside(helpers_1.point(testPoint))) {
-                    if (!minShell || util_1.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
-     */
-    inside(pt) {
-        return boolean_point_in_polygon_1.default(pt, this.toPolygon());
-    }
-}
-exports.default = EdgeRing;

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

@@ -1,124 +0,0 @@
-import Node from "./Node";
-import Edge from "./Edge";
-import EdgeRing from "./EdgeRing";
-import { FeatureCollection, LineString, MultiLineString, Feature } from "geojson";
-/**
- * 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 {
-    private nodes;
-    private edges;
-    /**
-     * 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: FeatureCollection<LineString | MultiLineString> | LineString | MultiLineString | Feature<LineString | MultiLineString>): Graph;
-    /**
-     * Creates or get a Node.
-     *
-     * @param {number[]} coordinates - Coordinates of the node
-     * @returns {Node} - The created or stored node
-     */
-    getNode(coordinates: number[]): 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: Node, to: Node): void;
-    constructor();
-    /**
-     * Removes Dangle Nodes (nodes with grade 1).
-     */
-    deleteDangles(): void;
-    /**
-     * 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: Node): void;
-    /**
-     * 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(): void;
-    /**
-     * 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?: Node): void;
-    /**
-     * 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: Node, label: number): void;
-    /**
-     * 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(): Edge[];
-    /**
-     * Computes the EdgeRings formed by the edges in this graph.
-     *
-     * @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
-     */
-    getEdgeRings(): EdgeRing[];
-    /**
-     * 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: Edge): Node[];
-    /**
-     * 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: Edge): 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): void;
-    /**
-     * Remove edge from the graph and deletes the edge.
-     *
-     * @param {Edge} edge - Edge to be removed
-     */
-    removeEdge(edge: Edge): void;
-}