@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/Android-arm64-v8a/include/geos/triangulate/polygon/PolygonHoleJoiner.h

@@ -0,0 +1,267 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 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/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/noding/SegmentIntersector.h>
+#include <geos/noding/BasicSegmentString.h>
+#include <geos/noding/SegmentSetMutualIntersector.h>
+#include <geos/constants.h>
+
+#include <set>
+#include <limits>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Envelope;
+class Geometry;
+class LinearRing;
+}
+namespace noding {
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::Polygon;
+using geos::geom::LinearRing;
+using geos::noding::BasicSegmentString;
+using geos::noding::SegmentSetMutualIntersector;
+
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+
+/**
+ * Transforms a polygon with holes into a single self-touching (invalid) ring
+ * by joining holes to the exterior shell or to another hole
+ * with out-and-back line segments.
+ * The holes are added in order of their envelopes (leftmost/lowest first).
+ * As the result shell develops, a hole may be added to what was
+ * originally another hole.
+ *
+ * There is no attempt to optimize the quality of the join lines.
+ * In particular, holes may be joined by lines longer than is optimal.
+ * However, holes which touch the shell or other holes are joined at the touch point.
+ *
+ * The class does not require the input polygon to have normal
+ * orientation (shell CW and rings CCW).
+ * The output ring is always CW.
+ */
+class GEOS_DLL PolygonHoleJoiner {
+
+private:
+
+    // Members
+
+    const Polygon* inputPolygon;
+
+    //-- normalized, sorted and noded polygon rings
+    std::unique_ptr<CoordinateSequence> shellRing;
+    std::vector<std::unique_ptr<CoordinateSequence>> holeRings;
+
+    //-- indicates whether a hole should be testing for touching
+    std::vector<bool> isHoleTouchingHint;
+
+    CoordinateSequence joinedRing;
+
+    // a sorted and searchable version of the joinedRing
+    std::set<Coordinate> joinedPts;
+
+    std::unique_ptr<SegmentSetMutualIntersector> boundaryIntersector;
+
+    // holding place for some BasicSegmentStrings
+    std::vector<std::unique_ptr<BasicSegmentString>> polySegStringStore;
+
+
+    // Classes
+    class InteriorIntersectionDetector;
+    friend class PolygonHoleJoiner::InteriorIntersectionDetector;
+
+
+    void extractOrientedRings(const Polygon* polygon);
+    static std::unique_ptr<CoordinateSequence> extractOrientedRing(const LinearRing* ring, bool isCW);
+    void nodeRings();
+    void joinHoles();
+
+    void joinHole(std::size_t index, const CoordinateSequence& holeCoords);
+
+    /**
+    * Joins a hole to the shell only if the hole touches the shell.
+    * Otherwise, reports the hole is non-touching.
+    *
+    * @param holeCoords the hole to join
+    * @return true if the hole was touching, false if not
+    */
+    bool joinTouchingHole(const CoordinateSequence& holeCoords);
+
+    /**
+    * Finds the vertex index of a hole where it touches the
+    * current shell (if it does).
+    * If a hole does touch, it must touch at a single vertex
+    * (otherwise, the polygon is invalid).
+    *
+    * @param holeCoords the hole
+    * @return the index of the touching vertex, or -1 if no touch
+    */
+    std::size_t findHoleTouchIndex(const CoordinateSequence& holeCoords);
+
+    /**
+    * Joins a single non-touching hole to the current joined ring.
+    *
+    * @param holeCoords the hole to join
+    */
+    void joinNonTouchingHole(
+        const CoordinateSequence& holeCoords);
+
+    const Coordinate& findJoinableVertex(
+        const Coordinate& holeJoinCoord);
+
+    /**
+    * Gets the join ring vertex index that the hole is joined after.
+    * A vertex can occur multiple times in the join ring, so it is necessary
+    * to choose the one which forms a corner having the
+    * join line in the ring interior.
+    *
+    * @param joinCoord the join ring vertex
+    * @param holeJoinCoord the hole join vertex
+    * @return the join ring vertex index to join after
+    */
+    std::size_t findJoinIndex(
+        const Coordinate& joinCoord,
+        const Coordinate& holeJoinCoord);
+
+    /**
+    * Tests if a line between a ring corner vertex and a given point
+    * is interior to the ring corner.
+    *
+    * @param ring a ring of points
+    * @param ringIndex the index of a ring vertex
+    * @param linePt the point to be joined to the ring
+    * @return true if the line to the point is interior to the ring corner
+    */
+    static bool isLineInterior(
+        const CoordinateSequence& ring,
+        std::size_t ringIndex,
+        const Coordinate& linePt);
+
+    static std::size_t prev(std::size_t i, std::size_t size);
+    static std::size_t next(std::size_t i, std::size_t size);
+
+    /**
+    * Add hole vertices at proper position in shell vertex list.
+    * This code assumes that if hole touches (shell or other hole),
+    * it touches at a node.  This requires an initial noding step.
+    * In this case, the code avoids duplicating join vertices.
+    *
+    * Also adds hole points to ordered coordinates.
+    *
+    * @param joinIndex index of join vertex in shell
+    * @param holeCoords the vertices of the hole to be inserted
+    * @param holeJoinIndex index of join vertex in hole
+    */
+    void addJoinedHole(
+        std::size_t joinIndex,
+        const CoordinateSequence& holeCoords,
+        std::size_t holeJoinIndex);
+
+    /**
+    * Creates the new section of vertices for ad added hole,
+    * including any required vertices from the shell at the join point,
+    * and ensuring join vertices are not duplicated.
+    *
+    * @param holeCoords the hole vertices
+    * @param holeJoinIndex the index of the join vertex
+    * @param joinPt the shell join vertex
+    * @return a list of new vertices to be added
+    */
+    std::vector<Coordinate> createHoleSection(
+        const CoordinateSequence& holeCoords,
+        std::size_t holeJoinIndex,
+        const Coordinate& joinPt);
+
+    /**
+    * Sort the hole rings by minimum X, minimum Y.
+    *
+    * @param poly polygon that contains the holes
+    * @return a list of sorted hole rings
+    */
+    static std::vector<const LinearRing*> sortHoles(
+        const Polygon* poly);
+
+    static std::size_t findLowestLeftVertexIndex(
+        const CoordinateSequence& holeCoords);
+
+    /**
+    * Tests whether the interior of a line segment intersects the polygon boundary.
+    * If so, the line is not a valid join line.
+    *
+    * @param p0 a segment vertex
+    * @param p1 the other segment vertex
+    * @return true if the segment interior intersects a polygon boundary segment
+    */
+    bool intersectsBoundary(
+        const Coordinate& p0,
+        const Coordinate& p1);
+
+    std::unique_ptr<SegmentSetMutualIntersector> createBoundaryIntersector();
+
+
+public:
+
+    PolygonHoleJoiner(const Polygon* p_inputPolygon)
+        : inputPolygon(p_inputPolygon)
+        , boundaryIntersector(nullptr)
+        {};
+
+    /**
+    * Joins the shell and holes of a polygon
+    * and returns the result as an (invalid) Polygon.
+    *
+    * @param p_inputPolygon the polygon to join
+    * @return the result polygon
+    */
+    static std::unique_ptr<Polygon> joinAsPolygon(
+        const Polygon* p_inputPolygon);
+
+    /**
+    * Joins the shell and holes of a polygon
+    * and returns the result as sequence of Coordinates.
+    *
+    * @param p_inputPolygon the polygon to join
+    * @return the result coordinates
+    */
+    static std::unique_ptr<CoordinateSequence> join(
+        const Polygon* p_inputPolygon);
+
+    /**
+    * Computes the joined ring.
+    *
+    * @return the points in the joined ring
+    */
+    std::unique_ptr<CoordinateSequence> compute();
+
+};
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos

package/dist/prebuilt/Android-arm64-v8a/include/geos/triangulate/polygon/PolygonNoder.h

@@ -0,0 +1,101 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 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/algorithm/LineIntersector.h>
+// #include <geos/geom/Coordinate.h>
+//#include <geos/geom/CoordinateSequence.h>
+
+#include <map>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+}
+namespace noding {
+class NodedSegmentString;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::noding::NodedSegmentString;
+using geos::algorithm::LineIntersector;
+
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+/**
+ * Adds node vertices to the rings of a polygon
+ * where holes touch the shell or each other.
+ * The structure of the polygon is preserved.
+ *
+ * This does not fix invalid polygon topology
+ * (such as self-touching or crossing rings).
+ * Invalid input remains invalid after noding,
+ * and does not trigger an error.
+ */
+class GEOS_DLL PolygonNoder {
+
+public:
+
+    PolygonNoder(
+        std::unique_ptr<CoordinateSequence>& shellRing,
+        std::vector<std::unique_ptr<CoordinateSequence>>& holeRings);
+
+    void node();
+    bool isShellNoded();
+    bool isHoleNoded(std::size_t i);
+    std::unique_ptr<CoordinateSequence> getNodedShell();
+    std::unique_ptr<CoordinateSequence> getNodedHole(std::size_t i);
+    std::vector<bool>& getHolesTouching();
+
+
+
+private:
+
+    // Members
+    std::vector<bool> isHoleTouching;
+    std::map<NodedSegmentString*, std::size_t> nodedRingIndexes;
+    std::vector<std::unique_ptr<NodedSegmentString>> nodedRings;
+
+    // Classes
+    class NodeAdder;
+    friend class PolygonNoder::NodeAdder;
+
+    // Methods
+    NodedSegmentString*
+        createNodedSegString(std::unique_ptr<CoordinateSequence>& ringPts, std::size_t i);
+
+    void createNodedSegmentStrings(
+        std::unique_ptr<CoordinateSequence>& shellRing,
+        std::vector<std::unique_ptr<CoordinateSequence>>& holeRings);
+
+    /* Turn off copy constructors for MSVC */
+    PolygonNoder(const PolygonNoder&) = delete;
+    PolygonNoder& operator=(const PolygonNoder&) = delete;
+
+};
+
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos

package/dist/prebuilt/Android-arm64-v8a/include/geos/triangulate/polygon/PolygonTriangulator.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * 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/triangulate/tri/TriList.h>
+#include <geos/triangulate/tri/Tri.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class Polygon;
+}
+}
+
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::Polygon;
+using geos::triangulate::tri::TriList;
+using geos::triangulate::tri::Tri;
+
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+/**
+ * Computes a triangulation of each polygon in a {@link geos::geom::Geometry}.
+ * A polygon triangulation is a non-overlapping set of triangles which
+ * cover the polygon and have the same vertices as the polygon.
+ * The priority is on performance rather than triangulation quality,
+ * so that the output may contain many narrow triangles.
+ *
+ * Holes are handled by joining them to the shell to form a
+ * (self-touching) polygon shell with no holes.
+ * Although invalid, this can be triangulated effectively.
+ *
+ * For better-quality triangulation use geos::triangulate::polygon::ConstrainedDelaunayTriangulator.
+ *
+ * @see geos::triangulate::polygon::ConstrainedDelaunayTriangulator
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL PolygonTriangulator {
+
+private:
+
+    // Members
+
+    const Geometry* inputGeom;
+    const GeometryFactory* geomFact;
+
+    std::unique_ptr<Geometry> compute();
+
+    /**
+    * Computes the triangulation of a single polygon
+    *
+    * @return GeometryCollection of triangular polygons
+    */
+    void triangulatePolygon(const Polygon* poly, TriList<Tri>& triList);
+
+
+public:
+
+    /**
+    * Constructs a new triangulator.
+    *
+    * @param p_inputGeom the input geometry
+    */
+    PolygonTriangulator(const Geometry* p_inputGeom)
+        : inputGeom(p_inputGeom)
+        , geomFact(p_inputGeom->getFactory())
+    {}
+
+    /**
+    * Computes a triangulation of each polygon in a geometry.
+    *
+    * @param geom a geometry containing polygons
+    * @return a GeometryCollection containing the triangle polygons
+    */
+    static std::unique_ptr<Geometry> triangulate(const Geometry* geom);
+
+};
+
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/triangulate/polygon/TriDelaunayImprover.h

@@ -0,0 +1,147 @@
+/**********************************************************************
+ *
+ * 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/triangulate/tri/TriEdge.h>
+#include <geos/triangulate/tri/Tri.h>
+#include <geos/triangulate/tri/TriList.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::triangulate::tri::TriList;
+using geos::triangulate::tri::Tri;
+
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+/**
+ * Improves the quality of a triangulation of Tri via
+ * iterated Delaunay flipping.
+ * This produces the Constrained Delaunay Triangulation
+ * with the constraints being the boundary of the input triangulation.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL TriDelaunayImprover {
+
+private:
+
+    // Members
+    static constexpr std::size_t MAX_ITERATION = 200;
+    TriList<Tri>& triList;
+
+    /**
+    * Improves a triangulation by examining pairs of adjacent triangles
+    * (forming a quadrilateral) and testing if flipping the diagonal of
+    * the quadrilateral would produce two new triangles with larger minimum
+    * interior angles.
+    *
+    * @return the number of flips that were made
+    */
+    std::size_t improveScan(TriList<Tri>& triList);
+
+    /**
+    * Does a flip of the common edge of two Tris if the Delaunay condition is not met.
+    *
+    * @param tri0 a Tri
+    * @param tri1 a Tri
+    * @return true if the triangles were flipped
+    */
+    bool improveNonDelaunay(Tri* tri, TriIndex index);
+
+    /**
+    * Tests if the quadrilateral formed by two adjacent triangles is convex.
+    * opp0-adj0-adj1 and opp1-adj1-adj0 are the triangle corners
+    * and hence are known to be convex.
+    * The quadrilateral is convex if the other corners opp0-adj0-opp1
+    * and opp1-adj1-opp0 have the same orientation (since at least one must be convex).
+    *
+    * @param adj0 adjacent edge vertex 0
+    * @param adj1 adjacent edge vertex 1
+    * @param opp0 corner vertex of triangle 0
+    * @param opp1 corner vertex of triangle 1
+    * @return true if the quadrilateral is convex
+    */
+    static bool isConvex(const Coordinate& adj0, const Coordinate& adj1,
+                         const Coordinate& opp0, const Coordinate& opp1);
+
+    /**
+    * Tests if either of a pair of adjacent triangles satisfy the Delaunay condition.
+    * The triangles are opp0-adj0-adj1 and opp1-adj1-adj0.
+    * The Delaunay condition is not met if one opposite vertex
+    * lies is in the circumcircle of the other triangle.
+    *
+    * @param adj0 adjacent edge vertex 0
+    * @param adj1 adjacent edge vertex 1
+    * @param opp0 corner vertex of triangle 0
+    * @param opp1 corner vertex of triangle 1
+    * @return true if the triangles are Delaunay
+    */
+    static bool isDelaunay(const Coordinate& adj0, const Coordinate& adj1,
+                           const Coordinate& opp0, const Coordinate& opp1);
+
+    /**
+    * Tests whether a point p is in the circumcircle of a triangle abc
+    * (oriented clockwise).
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @param p the point
+    *
+    * @return true if the point is in the circumcircle
+    */
+    static bool
+    isInCircle(const Coordinate& a, const Coordinate& b,
+               const Coordinate& c, const Coordinate& p);
+
+    void improve();
+
+
+public:
+
+    TriDelaunayImprover(TriList<Tri>& p_triList)
+        : triList(p_triList)
+        {};
+
+    /**
+    * Improves the quality of a triangulation of Tri via
+    * iterated Delaunay flipping.
+    * The Tris are assumed to be linked into a Triangulation
+    * (e.g. via TriangulationBuilder).
+    *
+    * @param triList the list of Tris to flip.
+    */
+    static void improve(TriList<Tri>& triList);
+
+
+};
+
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/triangulate/quadedge/LastFoundQuadEdgeLocator.h

@@ -0,0 +1,63 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012 Excensus LLC.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: triangulate/quadedge/LastFoundQuadEdgeLocator.java r524
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/triangulate/quadedge/QuadEdge.h>
+#include <geos/triangulate/quadedge/QuadEdgeLocator.h>
+
+namespace geos {
+namespace triangulate { //geos.triangulate
+namespace quadedge { //geos.triangulate.quadedge
+
+//fwd declarations
+class QuadEdgeSubdivision;
+
+/** \brief
+ * Locates {@link QuadEdge}s in a {@link QuadEdgeSubdivision}, optimizing the
+ * search by starting in the locality of the last edge found.
+ *
+ * @author JTS: Martin Davis
+ * @author Benjamin Campbell
+ */
+class LastFoundQuadEdgeLocator : public QuadEdgeLocator {
+private:
+    QuadEdgeSubdivision* subdiv;
+    QuadEdge*			lastEdge;
+
+public:
+    LastFoundQuadEdgeLocator(QuadEdgeSubdivision* subdiv);
+
+private:
+    virtual void init();
+
+    virtual QuadEdge* findEdge();
+
+public:
+    /**
+     * Locates an edge e, such that either v is on e, or e is an edge of a triangle containing v.
+     * The search starts from the last located edge amd proceeds on the general direction of v.
+     * @return The caller _does not_ take ownership of the returned object.
+     */
+    QuadEdge* locate(const Vertex& v) override;
+};
+
+} //namespace geos.triangulate.quadedge
+} //namespace geos.triangulate
+} //namespace goes
+