@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/simplify/LinkedRing.h

@@ -0,0 +1,69 @@
+/**********************************************************************
+ *
+ * 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 <memory>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/constants.h>
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+
+class LinkedRing
+{
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+
+    private:
+
+        const CoordinateSequence& m_coord;
+        std::size_t m_size;
+        std::vector<std::size_t> m_next;
+        std::vector<std::size_t> m_prev;
+
+        static std::vector<std::size_t> createNextLinks(std::size_t size);
+        static std::vector<std::size_t> createPrevLinks(std::size_t size);
+
+
+    public:
+
+        LinkedRing(const CoordinateSequence& cs)
+            : m_coord(cs)
+            , m_size(cs.size()-1)
+            , m_next(createNextLinks(m_size))
+            , m_prev(createPrevLinks(m_size))
+            {};
+
+        std::size_t size() const;
+        std::size_t next(std::size_t i) const;
+        std::size_t prev(std::size_t i) const;
+        const Coordinate& getCoordinate(std::size_t index) const;
+        const Coordinate& prevCoordinate(std::size_t index) const;
+        const Coordinate& nextCoordinate(std::size_t index) const;
+        bool hasCoordinate(std::size_t index) const;
+        void remove(std::size_t index);
+        std::unique_ptr<CoordinateSequence> getCoordinates() const;
+
+
+}; // LinkedRing
+
+
+} // geos::simplify
+} // geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/simplify/PolygonHullSimplifier.h

@@ -0,0 +1,229 @@
+/**********************************************************************
+ *
+ * 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/Geometry.h>
+#include <geos/util/IllegalArgumentException.h>
+#include <geos/simplify/RingHull.h>
+
+
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class LinearRing;
+class MultiPolygon;
+class Polygon;
+}
+namespace algorithm {
+namespace hull {
+class RingHullIndex;
+}
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+/**
+ * Computes topology-preserving simplified hulls of polygonal geometry.
+ * Both outer and inner hulls can be computed.
+ * Outer hulls contain the input geometry and are larger in area.
+ * Inner hulls are contained by the input geometry and are smaller in area.
+ * In both the hull vertices are a subset of the input vertices.
+ * The hull construction attempts to minimize the area difference
+ * with the input geometry.
+ * Hulls are generally concave if the input is.
+ * Computed hulls are topology-preserving:
+ * they do not contain any self-intersections or overlaps,
+ * so the result polygonal geometry is valid.
+ *
+ * Polygons with holes and MultiPolygons are supported.
+ * The result has the same geometric type and structure as the input.
+ *
+ * The number of vertices in the computed hull is determined by a target parameter.
+ * Two parameters are supported:
+ *
+ *  * Vertex Number fraction: the fraction of the input vertices retained in the result.
+ *    Value 1 produces the original geometry.
+ *    Smaller values produce less concave results.
+ *    For outer hulls, value 0 produces the convex hull (with triangles for any holes).
+ *    For inner hulls, value 0 produces a triangle (if no holes are present).
+ *
+ *  * Area Delta ratio: the ratio of the change in area to the input area.
+ *    Value 0 produces the original geometry.
+ *    Larger values produce less concave results.
+ *
+ * The algorithm ensures that the result does not cause the target parameter
+ * to be exceeded.  This allows computing outer or inner hulls
+ * with a small area delta ratio as an effective way of removing
+ * narrow gores and spikes.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL PolygonHullSimplifier
+{
+    using Envelope = geos::geom::Envelope;
+    using Geometry = geos::geom::Geometry;
+    using GeometryFactory = geos::geom::GeometryFactory;
+    using LinearRing = geos::geom::LinearRing;
+    using MultiPolygon = geos::geom::MultiPolygon;
+    using Polygon = geos::geom::Polygon;
+
+public:
+
+    /**
+    * Creates a new instance
+    * to compute a simplified hull of a polygonal geometry.
+    * An outer or inner hull is computed
+    * depending on the value of "isOuter".
+    *
+    * @param geom the polygonal geometry to process
+    * @param bOuter indicates whether to compute an outer or inner hull
+    */
+    PolygonHullSimplifier(const Geometry* geom, bool bOuter)
+        : inputGeom(geom)
+        , geomFactory(geom->getFactory())
+        , isOuter(bOuter)
+        , vertexNumFraction(-1.0)
+        , areaDeltaRatio(-1.0)
+    {
+        if (!geom->isPolygonal()) {
+            throw util::IllegalArgumentException("Input geometry must be polygonal");
+        }
+    };
+
+    /**
+    * Computes a topology-preserving simplified hull of a polygonal geometry,
+    * with hull shape determined by a target parameter
+    * specifying the fraction of the input vertices retained in the result.
+    * Larger values compute less concave results.
+    * A value of 1 produces the convex hull; a value of 0 produces the original geometry.
+    * Either outer or inner hulls can be computed.
+    *
+    * @param geom the polygonal geometry to process
+    * @param isOuter indicates whether to compute an outer or inner hull
+    * @param vertexNumFraction the target fraction of number of input vertices in result
+    * @return the hull geometry
+    */
+    static std::unique_ptr<Geometry> hull(
+        const Geometry* geom,
+        bool isOuter,
+        double vertexNumFraction);
+
+    /**
+    * Computes a topology-preserving simplified hull of a polygonal geometry,
+    * with hull shape determined by a target parameter
+    * specifying the ratio of maximum difference in area to original area.
+    * Larger values compute less concave results.
+    * A value of 0 produces the original geometry.
+    * Either outer or inner hulls can be computed..
+    *
+    * @param geom the polygonal geometry to process
+    * @param isOuter indicates whether to compute an outer or inner hull
+    * @param areaDeltaRatio the target ratio of area difference to original area
+    * @return the hull geometry
+    */
+    static std::unique_ptr<Geometry> hullByAreaDelta(
+        const Geometry* geom,
+        bool isOuter,
+        double areaDeltaRatio);
+
+
+    /**
+    * Sets the target fraction of input vertices
+    * which are retained in the result.
+    * The value should be in the range [0,1].
+    *
+    * @param p_vertexNumFraction a fraction of the number of input vertices
+    */
+    void setVertexNumFraction(double p_vertexNumFraction);
+    /**
+    * Sets the target maximum ratio of the change in area of the result to the input area.
+    * The value must be 0 or greater.
+    *
+    * @param p_areaDeltaRatio a ratio of the change in area of the result
+    */
+    void setAreaDeltaRatio(double p_areaDeltaRatio);
+
+    /**
+    * Gets the result polygonal hull geometry.
+    *
+    * @return the polygonal geometry for the hull
+    */
+    std::unique_ptr<Geometry> getResult();
+
+
+
+private:
+
+    // Members
+    const Geometry* inputGeom;
+    const GeometryFactory* geomFactory;
+    bool isOuter;
+    double vertexNumFraction;
+    double areaDeltaRatio;
+    // Allocate the RingHull* in here so they are cleaned
+    // up with PolygonHullSimplifier
+    std::vector<std::unique_ptr<RingHull>> ringStore;
+
+    /**
+    * Computes hulls for MultiPolygon elements for
+    * the cases where hulls might overlap.
+    *
+    * @param multiPoly the MultiPolygon to process
+    * @return the hull geometry
+    */
+    std::unique_ptr<Geometry> computeMultiPolygonAll(const MultiPolygon* multiPoly);
+    std::unique_ptr<Geometry> computeMultiPolygonEach(const MultiPolygon* multiPoly);
+    std::unique_ptr<Polygon> computePolygon(const Polygon* poly);
+
+    /**
+    * Create all ring hulls for the rings of a polygon,
+    * so that all are in the hull index if required.
+    *
+    * @param poly the polygon being processed
+    * @param hullIndex the hull index if present, or null
+    * @return the list of ring hulls
+    */
+    std::vector<RingHull*> initPolygon(const Polygon* poly,
+        RingHullIndex& hullIndex);
+
+    double ringArea(const Polygon* poly) const;
+
+    RingHull* createRingHull(
+        const LinearRing* ring,
+        bool isOuter,
+        double areaTotal,
+        RingHullIndex& hullIndex);
+
+    std::unique_ptr<Polygon> polygonHull(
+        const Polygon* poly,
+        std::vector<RingHull*>& ringHulls,
+        RingHullIndex& hullIndex) const;
+
+    /**
+     * Disable copy construction and assignment. Needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    PolygonHullSimplifier(const PolygonHullSimplifier&) = delete;
+    PolygonHullSimplifier& operator=(const PolygonHullSimplifier&) = delete;
+
+}; // PolygonHullSimplifier
+
+
+} // geos::simplify
+} // geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/simplify/RingHull.h

@@ -0,0 +1,208 @@
+/**********************************************************************
+ *
+ * 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/Coordinate.h>
+#include <geos/simplify/LinkedRing.h>
+#include <geos/index/VertexSequencePackedRtree.h>
+
+#include <queue>
+
+namespace geos {
+namespace geom {
+class Envelope;
+class LinearRing;
+class LineString;
+class Polygon;
+}
+namespace simplify {
+class RingHullIndex;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+class RingHull
+{
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using Envelope = geos::geom::Envelope;
+    using LinearRing = geos::geom::LinearRing;
+    using LineString = geos::geom::LineString;
+    using Polygon = geos::geom::Polygon;
+    using VertexSequencePackedRtree = geos::index::VertexSequencePackedRtree;
+
+
+public:
+
+    /*
+    * Creates a new instance.
+    *
+    * @param p_ring the ring vertices to process
+    * @param p_isOuter whether the hull is outer or inner
+    */
+    RingHull(const LinearRing* p_ring, bool p_isOuter);
+
+    void setMinVertexNum(std::size_t minVertexNum);
+
+    void setMaxAreaDelta(double maxAreaDelta);
+
+    const Envelope* getEnvelope() const;
+
+    std::unique_ptr<LinearRing> getHull(RingHullIndex& hullIndex);
+
+    static bool isConvex(const LinkedRing& vertexRing, std::size_t index);
+
+    static double area(const LinkedRing& vertexRing, std::size_t index);
+
+    void compute(RingHullIndex& hullIndex);
+
+    std::unique_ptr<Polygon> toGeometry() const;
+
+
+private:
+
+
+    class Corner
+    {
+
+    private:
+
+        std::size_t index;
+        std::size_t prev;
+        std::size_t next;
+        double area;
+
+    public:
+
+        Corner(std::size_t p_idx, std::size_t p_prev, std::size_t p_next, double p_area)
+            : index(p_idx)
+            , prev(p_prev)
+            , next(p_next)
+            , area(p_area)
+            {};
+
+        inline int compareTo(const Corner& rhs) const {
+            if (area == rhs.getArea()) {
+                if (index == rhs.getIndex())
+                    return 0;
+                else return index < rhs.getIndex() ? -1 : 1;
+            }
+            else return area < rhs.getArea() ? -1 : 1;
+        }
+
+        inline bool operator< (const Corner& rhs) const {
+            return compareTo(rhs) < 0;
+        };
+
+        inline bool operator> (const Corner& rhs) const {
+            return compareTo(rhs) > 0;
+        };
+
+        inline bool operator==(const Corner& rhs) const {
+            return compareTo(rhs) == 0;
+        };
+
+        bool isVertex(std::size_t p_index) const;
+        std::size_t getIndex() const;
+        double getArea() const;
+        void envelope(const LinkedRing& ring, Envelope& env) const;
+        bool intersects(const Coordinate& v, const LinkedRing& ring) const;
+        bool isRemoved(const LinkedRing& ring) const;
+        std::unique_ptr<LineString> toLineString(const LinkedRing& ring);
+
+        struct Greater {
+            inline bool operator()(const Corner & a, const Corner & b) const {
+                return a > b;
+            }
+        };
+
+        using PriorityQueue = std::priority_queue<Corner, std::vector<Corner>, Corner::Greater>;
+
+    }; // class Corner
+
+
+
+    const LinearRing* inputRing;
+    double targetVertexNum = -1.0;
+    double targetAreaDelta = -1.0;
+
+    /**
+    * The polygon vertices are provided in CW orientation.
+    * Thus for convex interior angles
+    * the vertices forming the angle are in CW orientation.
+    */
+    std::unique_ptr<CoordinateSequence> vertex;
+    std::unique_ptr<LinkedRing> vertexRing;
+    double areaDelta = 0;
+
+    /**
+    * Indexing vertices improves corner intersection testing performance.
+    * The ring vertices are contiguous, so are suitable for a
+    * {@link VertexSequencePackedRtree}.
+    */
+    std::unique_ptr<VertexSequencePackedRtree> vertexIndex;
+
+    Corner::PriorityQueue cornerQueue;
+
+
+    void init(CoordinateSequence& ring, bool isOuter);
+    void addCorner(std::size_t i, Corner::PriorityQueue& cornerQueue);
+    bool isAtTarget(const Corner& corner);
+
+    /**
+    * 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(const Corner& corner, Corner::PriorityQueue& cornerQueue);
+    bool isRemovable(const Corner& corner, const RingHullIndex& hullIndex) const;
+
+    /**
+    * Tests if any vertices in a hull intersect the corner triangle.
+    * Uses the vertex spatial index for efficiency.
+    *
+    * @param corner the corner vertices
+    * @param cornerEnv the envelope of the corner
+    * @param hull the hull to test
+    * @return true if there is an intersecting vertex
+    */
+    bool hasIntersectingVertex(
+        const Corner& corner,
+        const Envelope& cornerEnv,
+        const RingHull* hull) const;
+
+    const Coordinate& getCoordinate(std::size_t index) const;
+
+    void query(
+        const Envelope& cornerEnv,
+        std::vector<std::size_t>& result) const;
+
+    void queryHull(const Envelope& queryEnv, std::vector<Coordinate>& pts);
+
+
+
+
+}; // RingHull
+
+
+} // geos::simplify
+} // geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/simplify/RingHullIndex.h

@@ -0,0 +1,55 @@
+/**********************************************************************
+ *
+ * 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/simplify/RingHull.h>
+
+
+namespace geos {
+namespace geom {
+class Envelope;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+class RingHullIndex
+{
+    private:
+
+        std::vector<const RingHull*> hulls;
+        bool m_enabled;
+
+    public:
+
+        RingHullIndex()
+        : m_enabled(true)
+        {};
+
+        bool enabled(void) const { return m_enabled; };
+        void enabled(bool p_enabled) { m_enabled = p_enabled; };
+        void add(const RingHull* ringHull);
+        std::vector<const RingHull*> query(const geos::geom::Envelope& queryEnv) const;
+        std::size_t size() const;
+
+
+}; // RingHullIndex
+
+
+} // geos::simplify
+} // geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/simplify/TaggedLineSegment.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * 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 Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/TaggedLineSegment.java rev. 1.1 (JTS-1.7)
+ *
+ **********************************************************************
+ *
+ * NOTES: Use of this class by DP simplification algorithms
+ * makes it useless for a TaggedLineSegment to store copies
+ * of coordinates. Using pointers would be good enough here.
+ * We don't do it to avoid having to break inheritance from
+ * LineSegment, which has copies instead. Whether LineSegment
+ * itself should be refactored can be discussed.
+ *  --strk 2006-04-12
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/LineSegment.h> // for inheritance
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+/** \brief
+ * A geom::LineSegment which is tagged with its location in a geom::Geometry.
+ *
+ * Used to index the segments in a geometry and recover the segment locations
+ * from the index.
+ */
+class GEOS_DLL TaggedLineSegment: public geom::LineSegment {
+
+public:
+
+    TaggedLineSegment(const geom::Coordinate& p0,
+                      const geom::Coordinate& p1,
+                      const geom::Geometry* parent,
+                      std::size_t index);
+
+    TaggedLineSegment(const geom::Coordinate& p0,
+                      const geom::Coordinate& p1);
+
+    TaggedLineSegment(const TaggedLineSegment& ls);
+
+    const geom::Geometry* getParent() const;
+
+    std::size_t getIndex() const;
+
+private:
+
+    const geom::Geometry* parent;
+
+    std::size_t index;
+
+};
+
+
+
+} // namespace geos::simplify
+} // namespace geos
+