@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

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

@@ -1,267 +0,0 @@
-/**********************************************************************
- *
- * 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-x86_64/include/geos/triangulate/polygon/PolygonNoder.h

@@ -1,101 +0,0 @@
-/**********************************************************************
- *
- * 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-x86_64/include/geos/triangulate/polygon/PolygonTriangulator.h

@@ -1,105 +0,0 @@
-/**********************************************************************
- *
- * 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-x86_64/include/geos/triangulate/polygon/TriDelaunayImprover.h

@@ -1,147 +0,0 @@
-/**********************************************************************
- *
- * 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-x86_64/include/geos/triangulate/quadedge/LastFoundQuadEdgeLocator.h

@@ -1,63 +0,0 @@
-/**********************************************************************
- *
- * 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
-