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

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

@@ -0,0 +1,225 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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 <queue>
+
+#include <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/index/VertexSequencePackedRtree.h>
+#include <geos/simplify/LinkedLine.h>
+#include <geos/coverage/Corner.h>
+#include <geos/export.h>
+
+
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Envelope;
+class Geometry;
+class GeometryFactory;
+class LineString;
+class MultiLineString;
+}
+}
+
+
+using geos::coverage::Corner;
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Envelope;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::LineString;
+using geos::geom::MultiLineString;
+using geos::index::VertexSequencePackedRtree;
+using geos::index::strtree::TemplateSTRtree;
+using geos::simplify::LinkedLine;
+
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+
+/**
+ * Computes a Topology-Preserving Visvalingam-Whyatt simplification
+ * of a set of input lines.
+ * The simplified lines will contain no more intersections than are present
+ * in the original input.
+ * Line and ring endpoints are preserved, except for rings
+ * which are flagged as "free".
+ *
+ * The amount of simplification is determined by a tolerance value,
+ * which is a non-zero quantity.
+ * It is the square root of the area tolerance used
+ * in the Visvalingam-Whyatt algorithm.
+ * This equates roughly to the maximum
+ * distance by which a simplified line can change from the original.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL TPVWSimplifier
+{
+
+public:
+
+    // Prototype
+    class EdgeIndex;
+
+    /* private static */
+    class Edge {
+
+    public:
+
+        // Members
+        double areaTolerance;
+        bool isFreeRing;
+        const Envelope* envelope;
+        std::size_t nbPts;
+        LinkedLine linkedLine;
+        VertexSequencePackedRtree vertexIndex;
+        std::size_t minEdgeSize;
+
+        /**
+         * Creates a new edge.
+         * The endpoints of the edge are preserved during simplification,
+         * unless it is a ring and the isFreeRing flag is set.
+         *
+         * @param p_inputLine the line or ring
+         * @param p_isFreeRing whether a ring endpoint can be removed
+         * @param p_areaTolerance the simplification tolerance
+         */
+        Edge(const LineString* p_inputLine, bool p_isFreeRing, double p_areaTolerance);
+
+        const Coordinate& getCoordinate(std::size_t index) const;
+
+        const Envelope* getEnvelopeInternal() const;
+
+        std::size_t size() const;
+
+        std::unique_ptr<CoordinateSequence> simplify(EdgeIndex& edgeIndex);
+
+        void createQueue(Corner::PriorityQueue& pq);
+
+        void addCorner(std::size_t i, Corner::PriorityQueue& cornerQueue);
+
+        bool isRemovable(Corner& corner, EdgeIndex& edgeIndex) const;
+
+        /**
+         * Tests if any vertices in a line intersect the corner triangle.
+         * Uses the vertex spatial index for efficiency.
+         *
+         * @param corner the corner vertices
+         * @param cornerEnv the envelope of the corner
+         * @param edge the hull to test
+         * @return true if there is an intersecting vertex
+         */
+        bool hasIntersectingVertex(const Corner& corner,
+            const Envelope& cornerEnv,
+            const Edge& edge) const;
+
+        std::vector<std::size_t> query(const Envelope& cornerEnv) const;
+
+        /**
+         * Removes a corner by removing the apex vertex from the ring.
+         * Two new corners are created with apexes
+         * at the other vertices of the corner
+         * (if they are non-convex and thus removable).
+         *
+         * @param corner the corner to remove
+         * @param cornerQueue the corner queue
+         */
+        void removeCorner(
+            Corner& corner,
+            Corner::PriorityQueue& cornerQueue);
+
+    }; // Edge
+
+    class EdgeIndex
+    {
+        public:
+
+            TemplateSTRtree<const Edge*> index;
+
+            void add(std::vector<Edge>& edges);
+
+            std::vector<const Edge*> query(const Envelope& queryEnv);
+
+    }; // EdgeIndex
+
+
+    /**
+    * Simplifies a set of lines, preserving the topology of the lines.
+    *
+    * @param lines the lines to simplify
+    * @param distanceTolerance the simplification tolerance
+    * @return the simplified lines
+    */
+    static std::unique_ptr<MultiLineString> simplify(
+        const MultiLineString* lines,
+        double distanceTolerance);
+
+    /**
+    * Simplifies a set of lines, preserving the topology of the lines between
+    * themselves and a set of linear constraints.
+    * The endpoints of lines are preserved.
+    * The endpoint of rings are preserved as well, unless
+    * the ring is indicated as "free" via a bit flag with the same index.
+    *
+    * @param lines the lines to simplify
+    * @param freeRings flags indicating which ring edges do not have node endpoints
+    * @param constraintLines the linear constraints
+    * @param distanceTolerance the simplification tolerance
+    * @return the simplified lines
+    */
+    static std::unique_ptr<MultiLineString> simplify(
+        const MultiLineString* lines,
+        std::vector<bool>& freeRings,
+        const MultiLineString* constraintLines,
+        double distanceTolerance);
+
+    // Constructor
+    TPVWSimplifier(const MultiLineString* lines,
+        double distanceTolerance);
+
+
+private:
+
+    // Members
+    const MultiLineString* inputLines;
+    std::vector<bool> isFreeRing;
+    double areaTolerance;
+    const GeometryFactory* geomFactory;
+    const MultiLineString* constraintLines;
+
+
+    // Methods
+    void setFreeRingIndices(std::vector<bool>& freeRing);
+
+    void setConstraints(const MultiLineString* constraints);
+
+    std::unique_ptr<MultiLineString> simplify();
+
+    std::vector<Edge> createEdges(
+        const MultiLineString* lines,
+        std::vector<bool>& freeRing);
+
+
+}; // TPVWSimplifier
+
+
+} // geos::coverage
+} // geos

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

@@ -0,0 +1,71 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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 <map>
+
+#include <geos/geom/CoordinateSequenceFilter.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/export.h>
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::CoordinateSequenceFilter;
+using geos::geom::Geometry;
+
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+class VertexRingCounter : public CoordinateSequenceFilter
+{
+
+public:
+
+    VertexRingCounter(std::map<Coordinate, std::size_t>& counts)
+        : vertexCounts(counts)
+        {};
+
+    bool isGeometryChanged() const override {
+        return false;
+    }
+
+    bool isDone() const override {
+        return false;
+    }
+
+    void filter_ro(const CoordinateSequence& seq, std::size_t i) override;
+
+    static void count(
+        const std::vector<const Geometry*>& geoms,
+        std::map<Coordinate, std::size_t>& counts);
+
+private:
+
+    std::map<Coordinate, std::size_t>& vertexCounts;
+
+}; // VertexRingCounter
+
+
+
+} // geos::coverage
+} // geos

package/dist/prebuilt/Android-x86_64/include/geos/edgegraph/EdgeGraph.h

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/edgegraph/HalfEdge.h>
+
+#include <geos/export.h>
+#include <string>
+#include <cassert>
+#include <map>
+#include <array>
+#include <memory>
+#include <vector>
+
+#undef EDGEGRAPH_HEAPHACK
+
+namespace geos {
+namespace edgegraph { // geos.edgegraph
+
+
+/**
+ * A graph comprised of {@link HalfEdge}s.
+ * It supports tracking the vertices in the graph
+ * via edges incident on them,
+ * to allow efficient lookup of edges and vertices.
+ *
+ * This class may be subclassed to use a
+ * different subclass of HalfEdge,
+ * by overriding {@link createEdge}.
+ * If additional logic is required to initialize
+ * edges then {@link addEdge}
+ * can be overridden as well.
+ *
+ * @author Martin Davis
+ *
+ */
+
+class GEOS_DLL EdgeGraph {
+
+private:
+
+    std::deque<HalfEdge> edges;
+    std::map<geom::CoordinateXY, HalfEdge*> vertexMap;
+
+    HalfEdge* create(const geom::CoordinateXYZM& p0, const geom::CoordinateXYZM& p1);
+
+
+protected:
+
+    /**
+    * Creates a single HalfEdge.
+    * Override to use a different HalfEdge subclass.
+    *
+    * @param orig the origin location
+    * @return a new HalfEdge with the given origin
+    */
+    HalfEdge* createEdge(const geom::CoordinateXYZM& orig);
+
+    /**
+    * Inserts an edge not already present into the graph.
+    *
+    * @param orig the edge origin location
+    * @param dest the edge destination location
+    * @param eAdj an existing edge with same orig (if any)
+    * @return the created edge
+    */
+    HalfEdge* insert(const geom::CoordinateXYZM& orig, const geom::CoordinateXYZM& dest, HalfEdge* eAdj);
+
+
+public:
+
+    /**
+    * Initialized
+    */
+    EdgeGraph() {};
+
+    /**
+    * Adds an edge between the coordinates orig and dest
+    * to this graph.
+    * Only valid edges can be added (in particular, zero-length segments cannot be added)
+    *
+    * @param orig the edge origin location
+    * @param dest the edge destination location.
+    * @return the created edge
+    * @return null if the edge was invalid and not added
+    *
+    * @see isValidEdge(Coordinate, Coordinate)
+    */
+    HalfEdge* addEdge(const geom::CoordinateXYZM& orig, const geom::CoordinateXYZM& dest);
+
+    /**
+    * Tests if the given coordinates form a valid edge (with non-zero length).
+    *
+    * @param orig the start coordinate
+    * @param dest the end coordinate
+    * @return true if the edge formed is valid
+    */
+    static bool isValidEdge(const geom::CoordinateXY& orig, const geom::CoordinateXY& dest);
+
+    void getVertexEdges(std::vector<const HalfEdge*>& edgesOut);
+
+    /**
+    * Finds an edge in this graph with the given origin
+    * and destination, if one exists.
+    *
+    * @param orig the origin location
+    * @param dest the destination location.
+    * @return an edge with the given orig and dest, or null if none exists
+    */
+    HalfEdge* findEdge(const geom::CoordinateXY& orig, const geom::CoordinateXY& dest);
+
+
+
+
+
+
+};
+
+
+} // namespace geos.edgegraph
+} // namespace geos
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/edgegraph/EdgeGraphBuilder.h

@@ -0,0 +1,91 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/edgegraph/EdgeGraph.h>
+
+#include <geos/export.h>
+#include <string>
+#include <cassert>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class LineString;
+class Geometry;
+class GeometryCollection;
+}
+}
+
+namespace geos {
+namespace edgegraph { // geos.edgegraph
+
+
+/**
+ * Builds an edge graph from geometries containing edges.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL EdgeGraphBuilder {
+
+private:
+
+    /* members */
+    std::unique_ptr<EdgeGraph> graph;
+
+
+
+public:
+
+    EdgeGraphBuilder() :
+        graph(new EdgeGraph())
+        {};
+
+    static std::unique_ptr<EdgeGraph> build(const geom::GeometryCollection* geoms);
+
+    std::unique_ptr<EdgeGraph> getGraph();
+
+    /**
+    * Adds the edges of a Geometry to the graph.
+    * May be called multiple times.
+    * Any dimension of Geometry may be added; the constituent edges are
+    * extracted.
+    *
+    * @param geometry geometry to be added
+    */
+    void add(const geom::Geometry* geometry);
+    void add(const geom::LineString* linestring);
+
+    /**
+    * Adds the edges in a collection of {@link geom::Geometry} to the graph.
+    * May be called multiple times.
+    * Any dimension of Geometry may be added.
+    *
+    * @param geometries the geometries to be added
+    */
+    void add(const geom::GeometryCollection* geometries);
+
+};
+
+
+} // namespace geos.edgegraph
+} // namespace geos
+
+
+
+