@cpp.js/package-geos 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/prebuilt/Android-x86_64/include/geos/coverage/CoverageRingEdges.h

@@ -0,0 +1,170 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (c) 2023 Martin Davis.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/coverage/CoverageEdge.h> // to materialize CoverageEdge
+
+#include <set>
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+class LinearRing;
+class MultiPolygon;
+class Polygon;
+}
+namespace coverage {
+class CoverageEdge;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+using geos::geom::LineSegment;
+using geos::geom::MultiPolygon;
+using geos::geom::Polygon;
+
+namespace geos {     // geos
+namespace coverage { // geos.coverage
+
+/**
+ * Models a polygonal coverage as a set of unique {@link CoverageEdge}s,
+ * linked to the parent rings in the coverage polygons.
+ * Each edge has either one or two parent rings, depending on whether
+ * it is an inner or outer edge of the coverage.
+ * The source coverage is represented as a array of polygonal geometries
+ * (either {@link geos::geom::Polygon}s or {@link geos::geom::MultiPolygon}s).
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL CoverageRingEdges {
+
+private:
+
+    // Members
+    const std::vector<const Geometry*>& m_coverage;
+    std::map<const LinearRing*, std::vector<CoverageEdge*>> m_ringEdgesMap;
+    std::vector<CoverageEdge*> m_edges;
+    std::vector<std::unique_ptr<CoverageEdge>> m_edgeStore;
+
+    /* Turn off copy constructors for MSVC */
+    CoverageRingEdges(const CoverageRingEdges&) = delete;
+    CoverageRingEdges& operator=(const CoverageRingEdges&) = delete;
+
+public:
+
+    CoverageRingEdges(const std::vector<const Geometry*>& coverage)
+        : m_coverage(coverage)
+    {
+        build();
+    };
+
+
+    std::vector<CoverageEdge*>& getEdges()
+    {
+        return m_edges;
+    };
+
+    /**
+    * Selects the edges with a given ring count (which can be 1 or 2).
+    *
+    * @param ringCount the edge ring count to select (1 or 2)
+    * @return the selected edges
+    */
+    std::vector<CoverageEdge*> selectEdges(
+        std::size_t ringCount) const;
+
+    /**
+    * Recreates the polygon coverage from the current edge values.
+    *
+    * @return an array of polygonal geometries representing the coverage
+    */
+    std::vector<std::unique_ptr<Geometry>> buildCoverage() const;
+
+
+private:
+
+    void build();
+
+    void addRingEdges(
+        const LinearRing* ring,
+        Coordinate::UnorderedSet& nodes,
+        LineSegment::UnorderedSet& boundarySegs,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    void addBoundaryInnerNodes(
+        const LinearRing* ring,
+        LineSegment::UnorderedSet& boundarySegs,
+        Coordinate::UnorderedSet& nodes);
+
+    std::vector<CoverageEdge*> extractRingEdges(
+        const LinearRing* ring,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap,
+        Coordinate::UnorderedSet& nodes);
+
+    CoverageEdge* createEdge(
+        const CoordinateSequence& ring,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    CoverageEdge* createEdge(
+        const CoordinateSequence& ring,
+        std::size_t start, std::size_t end,
+        std::map<LineSegment, CoverageEdge*>& uniqueEdgeMap);
+
+    std::size_t findNextNodeIndex(
+        const CoordinateSequence& ring,
+        std::size_t start,
+        Coordinate::UnorderedSet& nodes) const;
+
+    static std::size_t next(
+        std::size_t index,
+        const CoordinateSequence& ring);
+
+    Coordinate::UnorderedSet findMultiRingNodes(
+        const std::vector<const Geometry*>& coverage);
+
+    Coordinate::UnorderedSet findBoundaryNodes(
+        LineSegment::UnorderedSet& lineSegments);
+
+    std::unique_ptr<Geometry> buildPolygonal(
+        const Geometry* geom) const;
+
+    std::unique_ptr<Geometry> buildMultiPolygon(
+        const MultiPolygon* geom) const;
+
+    std::unique_ptr<Polygon> buildPolygon(
+        const Polygon* polygon) const;
+
+    std::unique_ptr<LinearRing> buildRing(
+        const LinearRing* ring) const;
+
+    bool isEdgeDirForward(
+        const std::vector<CoverageEdge*>& ringEdges,
+        std::size_t index,
+        const Coordinate& prevPt) const;
+
+
+};
+
+} // namespace geos.coverage
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/coverage/CoverageSimplifier.h

@@ -0,0 +1,166 @@
+
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * Copyright (c) 2023 Martin Davis.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <geos/export.h>
+
+
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class MultiLineString;
+}
+namespace coverage {
+class CoverageEdge;
+}
+}
+
+
+using geos::coverage::CoverageEdge;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::MultiLineString;
+
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+/**
+ * Simplifies the boundaries of the polygons in a polygonal coverage
+ * while preserving the original coverage topology.
+ * An area-based simplification algorithm
+ * (similar to Visvalingam-Whyatt simplification)
+ * is used to provide high-quality results.
+ * Also supports simplifying just the inner edges in a coverage,
+ * which allows simplifying "patches" without affecting their boundary.
+ *
+ * The amount of simplification is determined by a tolerance value,
+ * which is a non-negative quantity. It equates roughly to the maximum
+ * distance by which a simplified line can change from the original.
+ * (In fact, it is the square root of the area tolerance used
+ * in the Visvalingam-Whyatt algorithm.)
+ *
+ * The simplified result coverage has the following characteristics:
+ *
+ *   * It has the same number and types of polygonal geometries as the input
+ *   * Node points (inner vertices shared by three or more polygons,
+ *     or boundary vertices shared by two or more) are not changed
+ *   * If the input is a valid coverage, then so is the result
+ *
+ * This class also supports inner simplification, which simplifies
+ * only edges of the coverage which are adjacent to two polygons.
+ * This allows partial simplification of a coverage, since a simplified
+ * subset of a coverage still matches the remainder of the coverage.
+ *
+ * The input coverage should be valid according to {@link CoverageValidator}.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL CoverageSimplifier {
+
+
+public:
+
+    /**
+    * Create a new coverage simplifier instance.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    */
+    CoverageSimplifier(const std::vector<const Geometry*>& coverage);
+
+    /**
+    * Simplifies the boundaries of a set of polygonal geometries forming a coverage,
+    * preserving the coverage topology.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    static std::vector<std::unique_ptr<Geometry>> simplify(
+        std::vector<const Geometry*>& coverage,
+        double tolerance);
+
+    static std::vector<std::unique_ptr<Geometry>> simplify(
+        const std::vector<std::unique_ptr<Geometry>>& coverage,
+        double tolerance);
+
+    /**
+    * Simplifies the inner boundaries of a set of polygonal geometries forming a coverage,
+    * preserving the coverage topology.
+    * Edges which form the exterior boundary of the coverage are left unchanged.
+    *
+    * @param coverage a set of polygonal geometries forming a coverage
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    static std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        std::vector<const Geometry*>& coverage,
+        double tolerance);
+
+    static std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        const std::vector<std::unique_ptr<Geometry>>& coverage,
+        double tolerance);
+
+    /**
+    * Computes the simplified coverage, preserving the coverage topology.
+    *
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    std::vector<std::unique_ptr<Geometry>> simplify(
+        double tolerance);
+
+    /**
+    * Computes the inner-boundary simplified coverage,
+    * preserving the coverage topology,
+    * and leaving outer boundary edges unchanged.
+    *
+    * @param tolerance the simplification tolerance
+    * @return the simplified polygons
+    */
+    std::vector<std::unique_ptr<Geometry>> simplifyInner(
+        double tolerance);
+
+
+private:
+
+    // Members
+    const std::vector<const Geometry*>& m_input;
+    const GeometryFactory* m_geomFactory;
+
+    // Methods
+    void simplifyEdges(
+        std::vector<CoverageEdge*> edges,
+        const MultiLineString* constraints,
+        double tolerance);
+
+    void setCoordinates(
+        std::vector<CoverageEdge*>& edges,
+        const MultiLineString* lines);
+
+    std::vector<bool> getFreeRings(
+        const std::vector<CoverageEdge*>& edges) const;
+
+
+}; // CoverageSimplifier
+
+
+} // geos::coverage
+} // geos

package/dist/prebuilt/Android-x86_64/include/geos/coverage/CoverageUnion.h

@@ -0,0 +1,77 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+using geos::geom::Geometry;
+
+namespace geos {      // geos
+namespace coverage { // geos::coverage
+
+/**
+ * Unions a polygonal coverage in an efficient way.
+ *
+ * Valid polygonal coverage topology allows merging polygons in a very efficient way.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL CoverageUnion {
+
+private:
+
+
+public:
+
+    /**
+    * Unions a polygonal coverage.
+    *
+    * @param coverage a vector of polygons in the coverage
+    * @return the union of the coverage polygons
+    */
+    static std::unique_ptr<Geometry> Union(std::vector<const Geometry*>& coverage);
+
+    /**
+    * Unions a polygonal coverage.
+    *
+    * @param coverage a collection of the polygons in the coverage
+    * @return the union of the coverage polygons
+    */
+    static std::unique_ptr<Geometry> Union(const Geometry* coverage);
+
+};
+
+} // namespace geos::coverage
+} // namespace geos
+
+
+
+
+
+
+
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/coverage/CoverageValidator.h

@@ -0,0 +1,159 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/strtree/TemplateSTRtree.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+using geos::geom::Geometry;
+using geos::index::strtree::TemplateSTRtree;
+
+namespace geos {      // geos
+namespace coverage { // geos::coverage
+
+
+/**
+ * Validates a polygonal coverage, and returns the locations of
+ * invalid polygon boundary segments if found.
+ *
+ * A polygonal coverage is a set of polygons which may be edge-adjacent but do
+ * not overlap.
+ * Coverage algorithms (such as {@link CoverageUnion} or simplification)
+ * generally require the input coverage to be valid to produce correct results.
+ * A polygonal coverage is valid if:
+ *
+ *   * The interiors of all polygons do not intersect (are disjoint).
+ *     This is the case if no polygon has a boundary which intersects
+ *     the interior of another polygon, and no two polygons are identical.
+ *   * If the boundaries of polygons intersect, the vertices
+ *     and line segments of the intersection match exactly.
+ *
+ * A valid coverage may contain holes (regions of no coverage).
+ * Sometimes it is desired to detect whether coverages contain
+ * narrow gaps between polygons
+ * (which can be a result of digitizing error or misaligned data).
+ * This class can detect narrow gaps,
+ * by specifying a maximum gap width using {@link #setGapWidth(double)}.
+ * Note that this also identifies narrow gaps separating disjoint coverage regions,
+ * and narrow gores.
+ * In some situations it may also produce false positives
+ * (linework identified as part of a gap which is actually wider).
+ * See CoverageGapFinder for an alternate way to detect gaps which may be more accurate.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL CoverageValidator {
+
+private:
+
+    std::vector<const Geometry*>& m_coverage;
+    double m_gapWidth = 0.0;
+
+    std::unique_ptr<Geometry> validate(
+        const Geometry* targetGeom,
+        TemplateSTRtree<const Geometry*>& index);
+
+
+public:
+
+    /*
+    * Creates a new coverage validator
+    *
+    * @param coverage a array of polygons representing a polygonal coverage
+    */
+    CoverageValidator(std::vector<const Geometry*>& coverage)
+        : m_coverage(coverage)
+        {};
+
+    /**
+    * Sets the maximum gap width, if narrow gaps are to be detected.
+    *
+    * @param gapWidth the maximum width of gaps to detect
+    */
+    void setGapWidth(double gapWidth) {
+        m_gapWidth = gapWidth;
+    };
+
+    /**
+    * Validates the polygonal coverage.
+    * The result is an array of the same size as the input coverage.
+    * Each array entry is either null, or if the polygon does not form a valid coverage,
+    * a linear geometry containing the boundary segments
+    * which intersect polygon interiors, which are mismatched,
+    * or form gaps (if checked).
+    *
+    * @return an array of nulls or linear geometries
+    */
+    std::vector<std::unique_ptr<Geometry>> validate();
+
+    /**
+    * Tests whether a polygonal coverage is valid.
+    *
+    * @param coverage an array of polygons forming a coverage
+    * @return true if the coverage is valid
+    */
+    static bool isValid(
+        std::vector<const Geometry*>& coverage);
+
+    /**
+    * Tests if some element of an array of geometries is a coverage invalidity
+    * indicator.
+    *
+    * @param validateResult an array produced by a polygonal coverage validation
+    * @return true if the result has at least one invalid indicator
+    */
+    static bool hasInvalidResult(
+        const std::vector<std::unique_ptr<Geometry>>& validateResult);
+
+    /**
+    * Validates that a set of polygons forms a valid polygonal coverage.
+    * The result is a list of the same length as the input,
+    * containing for each input geometry either
+    * a linear geometry indicating the locations of invalidities,
+    * or a null if the geometry is coverage-valid.
+    *
+    * @param coverage an array of polygons forming a coverage
+    * @return an array of linear geometries indicating coverage errors, or nulls
+    */
+    static std::vector<std::unique_ptr<Geometry>> validate(
+        std::vector<const Geometry*>& coverage);
+
+    /**
+    * Validates that a set of polygons forms a valid polygonal coverage
+    * and contains no gaps narrower than a specified width.
+    * The result is a list of the same length as the input,
+    * containing for each input geometry either
+    * a linear geometry indicating the locations of invalidities,
+    * or a null if the geometry is coverage-valid.
+    *
+    * @param coverage an array of polygons forming a coverage
+    * @param gapWidth the maximum width of invalid gaps
+    * @return an array of linear geometries indicating coverage errors, or nulls
+    */
+    static std::vector<std::unique_ptr<Geometry>> validate(
+        std::vector<const Geometry*>& coverage,
+        double gapWidth);
+};
+
+} // namespace geos::coverage
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/coverage/InvalidSegmentDetector.h

@@ -0,0 +1,133 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2022 Paul Ramsey <pramsey@cleverelephant.ca>
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************/
+
+#pragma once
+
+
+#include <geos/noding/SegmentIntersector.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace noding {
+class SegmentString;
+}
+namespace coverage {
+class CoverageRing;
+}
+}
+
+
+using geos::noding::SegmentIntersector;
+using geos::noding::SegmentString;
+using geos::geom::Coordinate;
+
+
+namespace geos {      // geos.
+namespace coverage { // geos.coverage
+
+/**
+ * Detects invalid coverage topology where ring segments interact.
+ * The inputs to processIntersections(SegmentString, int, SegmentString, int)}
+ * must be CoverageRing s.
+ * If an invalid situation is detected the input target segment is
+ * marked invalid using CoverageRing#markInvalid(int).
+ *
+ * This class assumes it is used with SegmentSetMutualIntersector,
+ * so that segments in the same ring are not evaluated.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL InvalidSegmentDetector : public SegmentIntersector {
+
+private:
+
+    // Members
+    double distanceTol;
+
+    // Methods
+    bool isInvalid(const Coordinate& tgt0, const Coordinate& tgt1,
+        const Coordinate& adj0, const Coordinate& adj1,
+        CoverageRing* adj, std::size_t indexAdj);
+
+    bool isEqual(
+        const Coordinate& t0, const Coordinate& t1,
+        const Coordinate& adj0, const Coordinate& adj1);
+
+    /**
+    * Checks if the segments are collinear, or if the target segment
+    * intersects the interior of the adjacent ring.
+    * Segments which are collinear must be non-equal and hence invalid,
+    * since matching segments have already been marked as valid and
+    * are not passed to this code.
+    *
+    * @param tgt0
+    * @param tgt1
+    * @param adj0
+    * @param adj1
+    * @return
+    */
+    bool isCollinearOrInterior(
+        const Coordinate& tgt0, const Coordinate& tgt1,
+        const Coordinate& adj0, const Coordinate& adj1,
+        CoverageRing* adj, std::size_t indexAdj);
+
+    bool isInteriorSegment(
+        const Coordinate& intVertex,
+        const Coordinate& tgt0, const Coordinate& tgt1,
+        CoverageRing* adj, std::size_t indexAdj);
+
+    static bool isNearlyParallel(
+        const Coordinate& p00, const Coordinate& p01,
+        const Coordinate& p10, const Coordinate& p11,
+        double distanceTol);
+
+
+public:
+
+    /**
+    * Creates an invalid segment detector.
+    */
+    InvalidSegmentDetector() {};
+
+    InvalidSegmentDetector(double p_distanceTol)
+        : distanceTol(p_distanceTol) {};
+
+
+    bool isDone() const override {
+        // process all intersections
+        return false;
+    };
+
+    /**
+    * Process interacting segments.
+    * The input order is important.
+    * The adjacent segment is first, the target is second.
+    * The inputs must be CoverageRing.
+    */
+    void processIntersections(
+        SegmentString* ssAdj,    std::size_t iAdj,
+        SegmentString* ssTarget, std::size_t iTarget) override;
+
+
+
+};
+
+} // namespace geos.coverage
+} // namespace geos
+
+