@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/hull/HullTri.h

@@ -0,0 +1,156 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Triangle.h>
+#include <geos/triangulate/tri/Tri.h>
+#include <geos/triangulate/tri/TriList.h>
+#include <geos/triangulate/quadedge/TriangleVisitor.h>
+
+#include <queue>
+#include <deque>
+
+
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace triangulate {
+namespace quadedge {
+}
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::Triangle;
+using geos::triangulate::tri::Tri;
+using geos::triangulate::tri::TriList;
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace hull {      // geos::algorithm::hull
+
+
+
+class HullTri : public Tri
+{
+    private:
+
+        double m_size;
+        bool m_isMarked = false;
+
+        bool isBoundaryTouch(TriIndex index) const;
+
+
+    public:
+
+        HullTri(const Coordinate& c0, const Coordinate& c1, const Coordinate& c2)
+            : Tri(c0, c1, c2)
+            , m_size(Triangle::longestSideLength(c0, c1, c2))
+            {};
+
+        class HullTriCompare {
+            public:
+                HullTriCompare() {};
+                bool operator()(const HullTri* a, const HullTri* b)
+                {
+                    if (a->getSize() == b->getSize())
+                        return a->getArea() < b->getArea();
+                    else
+                        return a->getSize() < b->getSize();
+                }
+        };
+
+
+        double getSize() const;
+
+        /**
+        * Sets the size to be the length of the boundary edges.
+        * This is used when constructing hull without holes,
+        * by erosion from the triangulation border.
+        */
+        void setSizeToBoundary();
+
+        void setSizeToLongestEdge();
+        void setSizeToCircumradius();
+
+
+        bool isMarked() const;
+        void setMarked(bool marked);
+        bool isRemoved();
+        TriIndex boundaryIndex() const;
+        TriIndex boundaryIndexCCW() const;
+        TriIndex boundaryIndexCW() const;
+
+        /**
+        * Tests if a tri is the only one connecting its 2 adjacents.
+        * Assumes that the tri is on the border of the triangulation
+        * and that the triangulation does not contain holes
+        *
+        * @return true if the tri is the only connection
+        */
+        bool isConnecting() const;
+
+        /**
+        * Gets the index of a vertex which is adjacent to two other tris (if any).
+        *
+        * @return the vertex index, or -1
+        */
+        int adjacent2VertexIndex() const;
+
+        /**
+        * Tests whether some vertex of this Tri has degree = 1.
+        * In this case it is not in any other Tris.
+        *
+        * @param tri
+        * @param triList
+        * @return true if a vertex has degree 1
+        */
+        TriIndex isolatedVertexIndex(TriList<HullTri>& triList) const;
+
+        double lengthOfLongestEdge() const;
+
+        /**
+        * Tests if this tri has a vertex which is in the boundary,
+        * but not in a boundary edge.
+        *
+        * @return true if the tri touches the boundary at a vertex
+        */
+        bool hasBoundaryTouch() const;
+
+        static HullTri* findTri(TriList<HullTri>& triList, Tri* exceptTri);
+        static bool isAllMarked(TriList<HullTri>& triList);
+        static void clearMarks(TriList<HullTri>& triList);
+        static void markConnected(HullTri* triStart, HullTri* exceptTri);
+        static bool isConnected(TriList<HullTri>& triList, HullTri* exceptTri);
+
+        friend std::ostream& operator<<(std::ostream& os, const HullTri& ht);
+
+        double lengthOfBoundary() const;
+
+        void remove(TriList<HullTri>& triList);
+
+
+}; // HullTri
+
+
+
+
+
+
+} // geos::algorithm::hull
+} // geos::algorithm
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/hull/HullTriangulation.h

@@ -0,0 +1,139 @@
+/**********************************************************************
+ *
+ * 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 <geos/algorithm/hull/HullTri.h>
+#include <geos/triangulate/tri/Tri.h>
+#include <geos/triangulate/tri/TriList.h>
+#include <geos/triangulate/quadedge/TriangleVisitor.h>
+
+
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class Coordinate;
+}
+namespace triangulate {
+namespace quadedge {
+class QuadEdge;
+class QuadEdgeSubdivision;
+}
+}
+}
+
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::Coordinate;
+using geos::triangulate::tri::Tri;
+using geos::triangulate::tri::TriList;
+using geos::triangulate::quadedge::QuadEdge;
+using geos::triangulate::quadedge::QuadEdgeSubdivision;
+using geos::triangulate::quadedge::TriangleVisitor;
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace hull {      // geos::algorithm::hull
+
+
+class HullTriangulation
+{
+
+private:
+
+    static void toTris(
+        QuadEdgeSubdivision& subdiv,
+        TriList<HullTri>& triList);
+
+    /**
+    * Extracts the coordinates of the edges along the boundary of a triangulation,
+    * by tracing CW around the border triangles.
+    * Assumption: there are at least 2 tris, they are connected,
+    * and there are no holes.
+    * So each tri has at least one non-boundary edge, and there is only one boundary.
+    *
+    * @param triList the triangulation
+    * @return the points in the boundary of the triangulation
+    */
+    static geom::CoordinateSequence traceBoundary(
+        TriList<HullTri>& triList);
+
+    static HullTri* findBorderTri(
+        TriList<HullTri>& triList);
+
+
+
+public:
+
+    HullTriangulation() {};
+
+    static void createDelaunayTriangulation(
+        const Geometry* geom,
+        TriList<HullTri>& triList);
+
+    /**
+    * Creates a Polygon representing the area of a triangulation
+    * which is connected and contains no holes.
+    *
+    * @param triList the triangulation
+    * @param geomFactory the geometry factory to use
+    * @return the area polygon
+    */
+    static std::unique_ptr<Geometry> traceBoundaryPolygon(
+        TriList<HullTri>& triList,
+        const GeometryFactory* factory);
+
+    static HullTri* nextBorderTri(HullTri* triStart);
+
+    /**
+    * Creates a polygonal geometry representing the area of a triangulation
+    * which may be disconnected or contain holes.
+    *
+    * @param triList the triangulation
+    * @param geomFactory the geometry factory to use
+    * @return the area polygonal geometry
+    */
+    static std::unique_ptr<Geometry> geomunion(
+        TriList<HullTri>& triList,
+        const GeometryFactory* factory);
+
+
+    class HullTriVisitor : public TriangleVisitor
+    {
+
+        private:
+
+            TriList<HullTri>& triList;
+
+        public:
+
+            HullTriVisitor(TriList<HullTri>& p_triList)
+                : triList(p_triList)
+                {};
+
+            void visit(std::array<QuadEdge*, 3>& triEdges) override;
+
+    }; // HullTriVisitor
+
+
+}; // HullTriangulation
+
+
+
+} // geos::algorithm::hull
+} // geos::algorithm
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/locate/IndexedPointInAreaLocator.h

@@ -0,0 +1,139 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research Inc.
+ * Copyright (C) 2018 Daniel Baston <dbaston@gmail.com>
+ *
+ * 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/LineSegment.h>
+#include <geos/algorithm/locate/PointOnGeometryLocator.h> // inherited
+#include <geos/index/ItemVisitor.h> // inherited
+#include <geos/index/strtree/TemplateSTRtree.h>
+
+#include <memory>
+#include <vector> // composition
+
+namespace geos {
+namespace algorithm {
+class RayCrossingCounter;
+}
+namespace geom {
+class Geometry;
+class Coordinate;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace locate { // geos::algorithm::locate
+
+/** \brief
+ * Determines the location of [Coordinates](@ref geom::Coordinate) relative to
+ * an areal geometry, using indexing for efficiency.
+ *
+ * The Location is computed precisely, in that points located on the geometry boundary
+ * or segments will return [geom::Location::BOUNDARY](@ref geom::Location).
+ *
+ * Polygonal and [LinearRing](@ref geom::LinearRing) geometries are supported.
+ *
+ * The index is lazy-loaded, which allows creating instances even if they are not used.
+ *
+ */
+class GEOS_DLL IndexedPointInAreaLocator : public PointOnGeometryLocator {
+private:
+    struct SegmentView {
+        SegmentView(const geom::CoordinateXY* p0, const geom::CoordinateXY* p1) {
+            // There is a significant performance benefit in fitting our
+            // line segment into 8 bytes (about 15-20%). Because we know that
+            // p1 follows p0 in a CoordinateSequence, we know that the address
+            // of p1 is 16, 24, or 32 bytes greater than the address of p0.
+            // By packing this offset into the least significant bits of p0,
+            // we can retrieve both p0 and p1 while only using 8 bytes.
+            std::size_t os = static_cast<std::size_t>(reinterpret_cast<const double*>(p1) - reinterpret_cast<const double*>(p0)) - 2u;
+            m_p0 = reinterpret_cast<std::size_t>(p0) | os;
+
+            assert(&this->p0() == p0);
+            assert(&this->p1() == p1);
+        }
+
+        const geom::CoordinateXY& p0() const {
+            auto ret = reinterpret_cast<const geom::CoordinateXY*>(m_p0 >> 2 << 2);
+            return *ret;
+        }
+
+        const geom::CoordinateXY& p1() const {
+            auto offset = (m_p0 & 0x03) + 2;
+            auto ret = reinterpret_cast<const geom::CoordinateXY*>(reinterpret_cast<double*>(m_p0 >> 2 << 2) + offset);
+            return *ret;
+        }
+
+        std::size_t m_p0;
+    };
+
+    class IntervalIndexedGeometry {
+    private:
+
+        index::strtree::TemplateSTRtree<SegmentView, index::strtree::IntervalTraits> index;
+
+        void init(const geom::Geometry& g);
+        void addLine(const geom::CoordinateSequence* pts);
+
+    public:
+        IntervalIndexedGeometry(const geom::Geometry& g);
+
+        template<typename Visitor>
+        void query(double min, double max, Visitor&& f) {
+            index.query(index::strtree::Interval(min, max), f);
+        }
+    };
+
+    const geom::Geometry& areaGeom;
+    std::unique_ptr<IntervalIndexedGeometry> index;
+
+    void buildIndex(const geom::Geometry& g);
+
+    // Declare type as noncopyable
+    IndexedPointInAreaLocator(const IndexedPointInAreaLocator& other) = delete;
+    IndexedPointInAreaLocator& operator=(const IndexedPointInAreaLocator& rhs) = delete;
+
+public:
+    /** \brief
+     * Creates a new locator for a given [Geometry](@ref geom::Geometry).
+     *
+     * Polygonal and [LinearRing](@ref geom::LinearRing) geometries are supported.
+     *
+     * @param g the Geometry to locate in
+     */
+    IndexedPointInAreaLocator(const geom::Geometry& g);
+
+    const geom::Geometry&  getGeometry() const {
+        return areaGeom;
+    }
+
+    /** \brief
+     * Determines the [Location](@ref geom::Location) of a point in an areal
+     * [Geometry](@ref geom::Geometry).
+     *
+     * @param p the point to test
+     * @return the location of the point in the geometry
+     */
+    geom::Location locate(const geom::CoordinateXY* /*const*/ p) override;
+
+};
+
+} // geos::algorithm::locate
+} // geos::algorithm
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/locate/PointOnGeometryLocator.h

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006 Refractions Research Inc.
+ *
+ * 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/Location.h>
+
+namespace geos {
+namespace geom {
+class CoordinateXY;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace locate { // geos::algorithm::locate
+
+/** \brief
+ * An interface for classes which determine the [Location](@ref geom::Location) of
+ * points in [Polygon](@ref geom::Polygon) or [MultiPolygon](@ref geom::MultiPolygon) geometries.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL PointOnGeometryLocator {
+private:
+protected:
+public:
+    virtual
+    ~PointOnGeometryLocator()
+    { }
+
+    /**
+     * Determines the [Location](@ref geom::Location) of a point in an areal [Geometry](@ref geom::Geometry).
+     *
+     * @param p the point to test
+     * @return the location of the point in the geometry
+     */
+    virtual geom::Location locate(const geom::CoordinateXY* /*const*/ p) = 0;
+};
+
+} // geos::algorithm::locate
+} // geos::algorithm
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/locate/SimplePointInAreaLocator.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ *
+ * 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/locate/PointOnGeometryLocator.h> // inherited
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+class Surface;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace locate { // geos::algorithm::locate
+
+/** \brief
+ * Computes the location of points relative to a polygonal
+ * [Geometry](@ref geom::Geometry), using a simple `O(n)` algorithm.
+ *
+ * The algorithm used reports if a point lies in the interior, exterior,
+ * or exactly on the boundary of the Geometry.
+ *
+ * Instance methods are provided to implement the interface `PointInAreaLocator`.
+ * However, they provide no performance advantage over the class methods.
+ *
+ * This algorithm is suitable for use in cases where only a few points will be tested.
+ * If many points will be tested, IndexedPointInAreaLocator may provide better performance.
+ */
+class GEOS_DLL SimplePointInAreaLocator : public PointOnGeometryLocator {
+
+public:
+
+    static geom::Location locate(const geom::CoordinateXY& p,
+                                 const geom::Geometry* geom);
+
+    /** \brief
+     * Determines the Location of a point in a [Surface](@ref geom::Surface).
+     *
+     * The return value is one of:
+     *
+     * - geom::Location::INTERIOR
+     *   if the point is in the geometry interior
+     * - geom::Location::BOUNDARY
+     *   if the point lies exactly on the boundary
+     * - geom::Location::EXTERIOR
+     *   if the point is outside the geometry
+     *
+     * Computes `geom::Location::BOUNDARY` if the point lies exactly
+     * on the polygon boundary.
+     *
+     * @param p the point to test
+     * @param poly the geometry to test
+     * @return the Location of the point in the polygon
+     */
+    static geom::Location locatePointInSurface(const geom::CoordinateXY& p,
+                                               const geom::Surface& poly);
+
+    /** \brief
+     * Determines whether a point is contained in a [Geometry](@ref geom::Geometry),
+     * or lies on its boundary.
+     *
+     * This is a convenience method for
+     *
+     *      Location::EXTERIOR != locate(p, geom)
+     *
+     * @param p the point to test
+     * @param geom the geometry to test
+     * @return true if the point lies in or on the geometry
+     */
+    static bool isContained(const geom::CoordinateXY& p,
+                            const geom::Geometry* geom);
+
+    SimplePointInAreaLocator(const geom::Geometry* p_g)
+        : g(p_g)
+    { }
+
+    SimplePointInAreaLocator(const geom::Geometry& p_g)
+        : g(&p_g)
+    { }
+
+    geom::Location
+    locate(const geom::CoordinateXY* p) override
+    {
+        return locate(*p, g);
+    }
+
+private:
+
+    static geom::Location locateInGeometry(const geom::CoordinateXY& p,
+                                           const geom::Geometry* geom);
+
+    const geom::Geometry* g;
+
+};
+
+} // geos::algorithm::locate
+} // geos::algorithm
+} // geos
+
+

package/dist/prebuilt/Android-x86_64/include/geos/constants.h

@@ -0,0 +1,49 @@
+/**********************************************************************
+ *
+ * constants.h
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018 Vicky Vergara
+ * Copyright (C) 2009 Mateusz Loskot
+ * Copyright (C) 2005-2009 Refractions Research Inc.
+ * Copyright (C) 2001-2009 Vivid Solutions Inc.
+ *
+ * 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
+
+#ifdef _MSC_VER
+#ifndef NOMINMAX
+#define NOMINMAX 1
+typedef __int64 int64;
+#endif
+#endif
+
+#include <cmath>
+#include <limits>
+#include <cinttypes>
+#include <cstddef> // for std::size_t
+
+namespace geos {
+
+constexpr double MATH_PI = 3.14159265358979323846;
+
+// Some handy constants
+constexpr double DoubleNotANumber = std::numeric_limits<double>::quiet_NaN();
+constexpr double DoubleMax = (std::numeric_limits<double>::max)();
+constexpr double DoubleInfinity = (std::numeric_limits<double>::infinity)();
+constexpr double DoubleNegInfinity = (-(std::numeric_limits<double>::infinity)());
+constexpr double DoubleEpsilon = std::numeric_limits<double>::epsilon();
+
+constexpr std::size_t NO_COORD_INDEX = std::numeric_limits<std::size_t>::max();
+constexpr std::size_t INDEX_UNKNOWN = std::numeric_limits<std::size_t>::max();
+
+} // namespace geos
+