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

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

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * 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/Envelope.h>
+#include <geos/simplify/LinkedLine.h>
+#include <geos/export.h>
+
+#include <vector>
+#include <memory>
+#include <queue>
+
+namespace geos {
+namespace simplify {
+class LinkedLine;
+}
+namespace geom {
+class Coordinate;
+class LineString;
+}
+}
+
+
+using geos::geom::Coordinate;
+using geos::geom::Envelope;
+using geos::geom::LineString;
+using geos::simplify::LinkedLine;
+
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+
+class Corner
+{
+
+public:
+
+    Corner(const LinkedLine* edge, std::size_t i);
+
+    bool isVertex(std::size_t index) const;
+
+    inline std::size_t getIndex() const {
+        return m_index;
+    }
+
+    inline double getArea() const {
+        return m_area;
+    };
+
+    const Coordinate& prev() const;
+    const Coordinate& next() const;
+
+    Envelope envelope() const;
+
+    bool isVertex(const Coordinate& v) const;
+    bool isBaseline(const Coordinate& p0, const Coordinate& p1) const;
+    bool intersects(const Coordinate& v) const;
+    bool isRemoved() const;
+
+    const Coordinate& getCoordinate() {
+        return m_edge->getCoordinate(m_index);
+    }
+
+    std::unique_ptr<LineString> toLineString() const;
+
+    inline int compareTo(const Corner& rhs) const {
+        double area_lhs = getArea();
+        double area_rhs = rhs.getArea();
+
+        if (area_lhs == area_rhs) {
+            std::size_t index_lhs = getIndex();
+            std::size_t index_rhs = rhs.getIndex();
+            if (index_lhs == index_rhs) return 0;
+            else return index_lhs < index_rhs ? -1 : 1;
+        }
+        else
+            return area_lhs < area_rhs ? -1 : 1;
+    }
+
+    bool operator< (const Corner& rhs) const {
+        return compareTo(rhs) < 0;
+    };
+
+    bool operator> (const Corner& rhs) const {
+        return compareTo(rhs) > 0;
+    };
+
+    bool operator==(const Corner& rhs) const {
+        return compareTo(rhs) == 0;
+    };
+
+    struct Greater {
+        inline bool operator()(const Corner & a, const Corner & b) const {
+            return a.compareTo(b) > 0;
+        }
+    };
+
+    // Order using greater for compatibility with the Java PriorityQueue
+    // implementation, which returns the smallest item off the top of the
+    // queue
+    using PriorityQueue = std::priority_queue<Corner, std::vector<Corner>, Corner::Greater>;
+
+
+private:
+
+    // members
+    const LinkedLine* m_edge;
+    std::size_t m_index;
+    std::size_t m_prev;
+    std::size_t m_next;
+    double m_area;
+
+    // methods
+    static double area(const LinkedLine& edge, std::size_t index);
+
+}; // Corner
+
+
+
+GEOS_DLL std::ostream& operator<< (std::ostream& os, const Corner& c);
+
+
+} // geos::coverage
+} // geos

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

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * 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 <unordered_set>
+
+#include <geos/geom/CoordinateSequenceFilter.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/LineSegment.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;
+using geos::geom::LineSegment;
+
+namespace geos {
+namespace coverage { // geos::coverage
+
+class CoverageBoundarySegmentFinder : public CoordinateSequenceFilter
+{
+
+
+public:
+
+    CoverageBoundarySegmentFinder(LineSegment::UnorderedSet& segs)
+        : m_boundarySegs(segs)
+        {};
+
+    bool isGeometryChanged() const override {
+        return false;
+    }
+
+    bool isDone() const override {
+        return false;
+    }
+
+    void filter_ro(const CoordinateSequence& seq, std::size_t i) override;
+
+
+    static LineSegment::UnorderedSet
+        findBoundarySegments(const std::vector<const Geometry*>& geoms);
+
+    static bool isBoundarySegment(
+        const LineSegment::UnorderedSet& boundarySegs,
+        const CoordinateSequence* seq,
+        std::size_t i);
+
+private:
+
+    static LineSegment
+        createSegment(const CoordinateSequence& seq, std::size_t i);
+
+
+    LineSegment::UnorderedSet& m_boundarySegs;
+
+
+}; // CoverageBoundarySegmentFinder
+
+
+
+} // geos::coverage
+} // geos

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

@@ -0,0 +1,171 @@
+
+
+
+/**********************************************************************
+ *
+ * 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/geom/CoordinateSequence.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/util.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class LinearRing;
+class LineString;
+class MultiLineString;
+class GeometryFactory;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+using geos::geom::GeometryFactory;
+using geos::geom::LinearRing;
+using geos::geom::LineString;
+using geos::geom::LineSegment;
+using geos::geom::MultiLineString;
+
+namespace geos {      // geos.
+namespace coverage { // geos.coverage
+
+/**
+ * An edge of a polygonal coverage formed from all or a section of a polygon ring.
+ * An edge may be a free ring, which is a ring which has not node points
+ * (i.e. does not touch any other rings in the parent coverage).
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL CoverageEdge {
+
+private:
+
+    // Members
+    std::unique_ptr<CoordinateSequence> m_pts;
+    std::size_t m_ringCount ;
+    bool m_isFreeRing = true;
+
+    // Methods
+
+    static std::unique_ptr<CoordinateSequence>
+    extractEdgePoints(const CoordinateSequence& ring,
+        std::size_t start, std::size_t end);
+
+    static const Coordinate&
+    findDistinctPoint(
+        const CoordinateSequence& pts,
+        std::size_t index,
+        bool isForward,
+        const Coordinate& pt);
+
+
+public:
+
+    CoverageEdge(std::unique_ptr<CoordinateSequence> && pts, bool isFreeRing)
+        : m_pts(pts ? std::move(pts) : detail::make_unique<CoordinateSequence>())
+        , m_ringCount(0)
+        , m_isFreeRing(isFreeRing)
+        {}
+
+    /**
+    * Computes a key segment for a ring.
+    * The key is the segment starting at the lowest vertex,
+    * towards the lowest adjacent distinct vertex.
+    *
+    * @param ring a linear ring
+    * @return a LineSegment representing the key
+    */
+    static LineSegment key(
+        const CoordinateSequence& ring);
+
+    /**
+    * Computes a distinct key for a section of a linear ring.
+    *
+    * @param ring the linear ring
+    * @param start index of the start of the section
+    * @param end end index of the end of the section
+    * @return a LineSegment representing the key
+    */
+    static LineSegment key(
+        const CoordinateSequence& ring,
+        std::size_t start,
+        std::size_t end);
+
+    static std::unique_ptr<CoverageEdge> createEdge(
+        const CoordinateSequence& ring);
+
+    static std::unique_ptr<CoverageEdge> createEdge(
+        const CoordinateSequence& ring,
+        std::size_t start,
+        std::size_t end);
+
+    static std::unique_ptr<MultiLineString> createLines(
+        const std::vector<CoverageEdge*>& edges,
+        const GeometryFactory* geomFactory);
+
+    std::unique_ptr<LineString> toLineString(
+        const GeometryFactory* geomFactory);
+
+    /* public */
+    void incRingCount()
+    {
+        m_ringCount++;
+    }
+
+    /* public */
+    std::size_t getRingCount() const
+    {
+        return m_ringCount;
+    }
+
+    /**
+    * Returns whether this edge is a free ring;
+    * i.e. one with no constrained nodes.
+    *
+    * @return true if this is a free ring
+    */
+    bool isFreeRing() const
+    {
+        return m_isFreeRing;
+    }
+
+    void setCoordinates(const CoordinateSequence* pts)
+    {
+        m_pts = pts->clone();
+    }
+
+    const CoordinateSequence* getCoordinates() const
+    {
+        return m_pts.get();
+    }
+
+    const Coordinate& getEndCoordinate() const
+    {
+        return m_pts->getAt(m_pts->size() - 1);
+    }
+
+    const Coordinate& getStartCoordinate() const
+    {
+        return m_pts->getAt(0);
+    }
+
+
+};
+
+} // namespace geos.coverage
+} // namespace geos

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

@@ -0,0 +1,106 @@
+/**********************************************************************
+ *
+ * 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;
+class LinearRing;
+}
+}
+
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+
+
+namespace geos {      // geos
+namespace coverage { // geos::coverage
+
+/**
+ * Finds gaps in a polygonal coverage.
+ * Gaps are holes in the coverage which are narrower than a given width.
+ *
+ * The coverage should be valid according to CoverageValidator.
+ * If this is not the case, some gaps may not be reported, or the invocation may fail.
+ *
+ * This is a more accurate way of identifying gaps
+ * than using CoverageValidator::setGapWidth(double).
+ * Gaps which separate the coverage into two disjoint regions are not detected.
+ * Gores are not identified as gaps.
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL CoverageGapFinder {
+
+private:
+
+    std::vector<const Geometry*>& m_coverage;
+
+    bool isGap(const LinearRing* hole, double gapWidth);
+
+
+public:
+
+    /**
+    * Creates a new polygonal coverage gap finder.
+    *
+    * @param coverage a set of polygons forming a polygonal coverage
+    */
+    CoverageGapFinder(std::vector<const Geometry*>& coverage)
+        : m_coverage(coverage)
+        {};
+
+    /**
+    * Finds gaps in a polygonal coverage.
+    * Returns lines indicating the locations of the gaps.
+    *
+    * @param coverage a set of polygons forming a polygonal coverage
+    * @param gapWidth the maximum width of gap to detect
+    * @return a geometry indicating the locations of gaps (which is empty if no gaps were found), or null if the coverage was empty
+    */
+    static std::unique_ptr<Geometry> findGaps(
+        std::vector<const Geometry*>& coverage,
+        double gapWidth);
+
+    /**
+    * Finds gaps in the coverage.
+    * Returns lines indicating the locations of the gaps.
+    *
+    * @param gapWidth the maximum width of gap to detect
+    * @return a geometry indicating the locations of gaps (which is empty if no gaps were found), or null if the coverage was empty
+    */
+    std::unique_ptr<Geometry> findGaps(double gapWidth);
+
+
+};
+
+} // namespace geos::coverage
+} // namespace geos
+
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,57 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 Martin Davis <mtnclimb@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/algorithm/locate/IndexedPointInAreaLocator.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Envelope;
+class Polygon;
+}
+}
+
+using geos::geom::CoordinateXY;
+using geos::geom::Envelope;
+using geos::geom::Polygon;
+using geos::algorithm::locate::IndexedPointInAreaLocator;
+
+namespace geos {        // geos
+namespace coverage {    // geos::coverage
+
+class GEOS_DLL CoveragePolygon {
+
+    // Members
+    const Polygon* m_polygon;
+    Envelope polyEnv;
+    mutable std::unique_ptr<IndexedPointInAreaLocator> m_locator;
+
+public:
+    CoveragePolygon(const Polygon* poly);
+
+    bool intersectsEnv(const Envelope& env) const;
+    bool intersectsEnv(const CoordinateXY& p) const;
+    bool contains(const CoordinateXY& p) const;
+    
+private:
+    IndexedPointInAreaLocator& getLocator() const;  
+
+};
+
+} // namespace geos::coverage
+} // namespace geos
+