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

package/dist/prebuilt/Android-x86_64/include/geos/shape/fractal/HilbertEncoder.h

@@ -0,0 +1,96 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+#include <geos/geom/Geometry.h>
+#include <string>
+#include <vector>
+#include <cstdint>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace shape {   // geos.shape
+namespace fractal { // geos.shape.fractal
+
+
+class GEOS_DLL HilbertEncoder {
+
+public:
+
+    HilbertEncoder(uint32_t p_level, geom::Envelope& extent);
+    uint32_t encode(const geom::Envelope* env);
+    static void sort(std::vector<geom::Geometry*>& geoms);
+
+    template<typename T>
+    static geom::Envelope getEnvelope(T begin, T end) {
+        geom::Envelope extent;
+        for (auto it = begin; it != end; ++it) {
+            const auto* g = *it;
+            if (extent.isNull())
+                extent = *(g->getEnvelopeInternal());
+            else
+                extent.expandToInclude(*(g->getEnvelopeInternal()));
+        }
+
+        return extent;
+    }
+
+    template<typename T>
+    static void sort(T begin, T end) {
+        auto extent = getEnvelope(begin, end);
+        HilbertEncoder encoder(12, extent);
+        HilbertComparator hilbertCompare(encoder);
+        std::sort(begin, end, hilbertCompare);
+    }
+
+private:
+
+    uint32_t level;
+    double minx;
+    double miny;
+    double strideX;
+    double strideY;
+
+    struct HilbertComparator {
+
+        HilbertEncoder& enc;
+
+        HilbertComparator(HilbertEncoder& e)
+            : enc(e) {};
+
+        bool
+        operator()(const geom::Geometry* a, const geom::Geometry* b)
+        {
+            return enc.encode(a->getEnvelopeInternal()) > enc.encode(b->getEnvelopeInternal());
+        }
+    };
+
+};
+
+
+} // namespace geos.shape.fractal
+} // namespace geos.shape
+} // namespace geos
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/shape/fractal/MortonCode.h

@@ -0,0 +1,140 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+#include <string>
+#include <cstdint>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace shape {   // geos.shape
+namespace fractal { // geos.shape.fractal
+
+
+/**
+ * Encodes points as the index along the planar Morton (Z-order) curve.
+ *
+ * The planar Morton (Z-order) curve is a continuous space-filling curve.
+ * The Morton curve defines an ordering of the
+ * points in the positive quadrant of the plane.
+ * The index of a point along the Morton curve is called the Morton code.
+ *
+ * A sequence of subsets of the Morton curve can be defined by a level number.
+ * Each level subset occupies a square range.
+ * The curve at level n M(n) contains 2^(n + 1) points.
+ * It fills the range square of side 2^level.
+ * Curve points have ordinates in the range [0, 2^level - 1].
+ * The code for a given point is identical at all levels.
+ * The level simply determines the number of points in the curve subset
+ * and the size of the range square.
+ *
+ * This implementation represents codes using 32-bit integers.
+ * This allows levels 0 to 16 to be handled.
+ * The class supports encoding points
+ * and decoding the point for a given code value.
+ *
+ * The Morton order has the property that it tends to preserve locality.
+ * This means that codes which are near in value will have spatially proximate
+ * points.  The converse is not always true - the delta between
+ * codes for nearby points is not always small.  But the average delta
+ * is small enough that the Morton order is an effective way of linearizing space
+ * to support range queries.
+ *
+ * @author Martin Davis
+ *
+ * @see HilbertCode
+ */
+class GEOS_DLL MortonCode {
+
+public:
+
+    /**
+    * The maximum curve level that can be represented.
+    */
+    static constexpr int MAX_LEVEL = 16;
+
+    /**
+    * Computes the index of the point (x,y)
+    * in the Morton curve ordering.
+    *
+    * @param x the x ordinate of the point
+    * @param y the y ordinate of the point
+    * @return the index of the point along the Morton curve
+    */
+    static uint32_t encode(int x, int y);
+
+    /**
+    * Computes the point on the Morton curve
+    * for a given index.
+    *
+    * @param index the index of the point on the curve
+    * @return the point on the curve
+    */
+    static geom::Coordinate decode(uint32_t index);
+
+    /**
+    * The number of points in the curve for the given level.
+    * The number of points is 2<sup>2 * level</sup>.
+    *
+    * @param level the level of the curve
+    * @return the number of points
+    */
+    static uint32_t levelSize(uint32_t level);
+
+    /**
+    * The maximum ordinate value for points
+    * in the curve for the given level.
+    * The maximum ordinate is 2<sup>level</sup> - 1.
+    *
+    * @param level the level of the curve
+    * @return the maximum ordinate value
+    */
+    static uint32_t maxOrdinate(uint32_t level);
+
+    /**
+    * The level of the finite Morton curve which contains at least
+    * the given number of points.
+    *
+    * @param numPoints the number of points required
+    * @return the level of the curve
+    */
+    static uint32_t level(uint32_t numPoints);
+
+
+private:
+
+    static void checkLevel(uint32_t level) ;
+
+    static  uint32_t interleave(uint32_t x);
+
+    static  uint32_t deinterleave(uint32_t x);
+
+};
+
+
+} // namespace geos.shape.fractal
+} // namespace geos.shape
+} // namespace geos
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/simplify/ComponentJumpChecker.h

@@ -0,0 +1,120 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://libgeos.org
+ *
+ * Copyright (C) 2006 Refractions Research Inc.
+ * Copyright (C) 2023 Martin Davis <mtnclimb@gmail.com>
+ * 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 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 Coordinate;
+class CoordinateSequence;
+class Envelope;
+class LineSegment;
+}
+namespace simplify {
+class TaggedLineString;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::Envelope;
+using geos::geom::LineSegment;
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+class GEOS_DLL ComponentJumpChecker {
+
+private:
+
+    const std::vector<TaggedLineString*>& components;
+
+    static bool hasJumpAtComponent(
+        const Coordinate& compPt,
+        const TaggedLineString* line,
+        std::size_t start, std::size_t end,
+        const LineSegment& seg);
+
+    static bool hasJumpAtComponent(
+        const Coordinate& compPt,
+        const LineSegment* seg1, const LineSegment* seg2,
+        const LineSegment& seg);
+
+    static std::size_t crossingCount(
+        const Coordinate& compPt,
+        const LineSegment& seg);
+
+    static std::size_t crossingCount(
+        const Coordinate& compPt,
+        const LineSegment* seg1, const LineSegment* seg2);
+
+    std::size_t static  crossingCount(
+        const Coordinate& compPt,
+        const TaggedLineString* line,
+        std::size_t start, std::size_t end);
+
+    static Envelope computeEnvelope(
+        const LineSegment* seg1, const LineSegment* seg2);
+
+    static Envelope computeEnvelope(
+        const TaggedLineString* line,
+        std::size_t start, std::size_t end);
+
+
+public:
+
+    ComponentJumpChecker(const std::vector<TaggedLineString*>& taggedLines)
+        : components(taggedLines)
+    {}
+
+    bool hasJump(
+        const TaggedLineString* line,
+        std::size_t start, std::size_t end,
+        const LineSegment& seg) const;
+
+    /**
+    * Checks if two consecutive segments jumps a component if flattened.
+    * The segments are assumed to be consecutive.
+    * (so the seg1.p1 = seg2.p0).
+    * The flattening segment must be the segment between seg1.p0 and seg2.p1.
+    *
+    * @param line the line containing the section being flattened
+    * @param seg1 the first replaced segment
+    * @param seg2 the next replaced segment
+    * @param seg the flattening segment
+    * @return true if the flattened segment jumps a component
+    */
+    bool hasJump(
+        const TaggedLineString* line,
+        const LineSegment* seg1,
+        const LineSegment* seg2,
+        const LineSegment& seg) const;
+
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/simplify/DouglasPeuckerLineSimplifier.h

@@ -0,0 +1,103 @@
+/**********************************************************************
+ *
+ * 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/DouglasPeuckerLineSimplifier.java rev. 1.4
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <vector>
+#include <memory> // for unique_ptr
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+/** \brief
+ * Simplifies a linestring (sequence of points) using
+ * the standard Douglas-Peucker algorithm.
+ */
+class GEOS_DLL DouglasPeuckerLineSimplifier {
+
+public:
+
+    /** \brief
+     * Returns a newly allocated Coordinate vector, wrapped
+     * into an unique_ptr
+     */
+    static std::unique_ptr<geom::CoordinateSequence> simplify(
+        const geom::CoordinateSequence& nPts,
+        double distanceTolerance,
+        bool preserveClosedEndpoint);
+
+    DouglasPeuckerLineSimplifier(const geom::CoordinateSequence& nPts);
+
+    /** \brief
+     * Sets the distance tolerance for the simplification.
+     *
+     * All vertices in the simplified linestring will be within this
+     * distance of the original linestring.
+     *
+     * @param nDistanceTolerance the approximation tolerance to use
+     */
+    void setDistanceTolerance(double nDistanceTolerance);
+
+    /** \brief
+     * Sets whether the endpoint of a closed LineString should be preserved
+     *
+     * @param preserve `true` if the endpoint should be preserved
+     */
+    void setPreserveClosedEndpoint(bool preserve);
+
+    /** \brief
+     * Returns a newly allocated Coordinate vector, wrapped
+     * into an unique_ptr
+     */
+    std::unique_ptr<geom::CoordinateSequence> simplify();
+
+private:
+
+    const geom::CoordinateSequence& pts;
+    std::vector<bool> usePt;
+    double distanceTolerance;
+    bool preserveEndpoint;
+
+    void simplifySection(std::size_t i, std::size_t j);
+
+    // Declare type as noncopyable
+    DouglasPeuckerLineSimplifier(const DouglasPeuckerLineSimplifier& other) = delete;
+    DouglasPeuckerLineSimplifier& operator=(const DouglasPeuckerLineSimplifier& rhs) = delete;
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/simplify/DouglasPeuckerSimplifier.h

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * 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/DouglasPeuckerSimplifier.java rev. 1.5 (JTS-1.7)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+/** \brief
+ * Simplifies a Geometry using the standard Douglas-Peucker algorithm.
+ *
+ * Ensures that any polygonal geometries returned are valid.
+ * Simple lines are not guaranteed to remain simple after simplification.
+ *
+ * Note that in general D-P does not preserve topology -
+ * e.g. polygons can be split, collapse to lines or disappear
+ * holes can be created or disappear,
+ * and lines can cross.
+ * To simplify geometry while preserving topology use TopologyPreservingSimplifier.
+ * (However, using D-P is significantly faster).
+ *
+ */
+class GEOS_DLL DouglasPeuckerSimplifier {
+
+public:
+
+    static std::unique_ptr<geom::Geometry> simplify(
+        const geom::Geometry* geom,
+        double tolerance);
+
+    DouglasPeuckerSimplifier(const geom::Geometry* geom);
+
+    /** \brief
+     * Sets the distance tolerance for the simplification.
+     *
+     * All vertices in the simplified geometry will be within this
+     * distance of the original geometry.
+     * The tolerance value must be non-negative.  A tolerance value
+     * of zero is effectively a no-op.
+     *
+     * @param tolerance the approximation tolerance to use
+     */
+    void setDistanceTolerance(double tolerance);
+
+    std::unique_ptr<geom::Geometry> getResultGeometry();
+
+
+private:
+
+    const geom::Geometry* inputGeom;
+
+    double distanceTolerance;
+};
+
+
+} // namespace geos::simplify
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/simplify/LineSegmentIndex.h

@@ -0,0 +1,87 @@
+/**********************************************************************
+ *
+ * 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/LineSegmentIndex.java rev. 1.1 (JTS-1.7.1)
+ *
+ **********************************************************************
+ *
+ * NOTES
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Envelope.h>
+#include <geos/index/quadtree/Quadtree.h>
+#include <vector>
+#include <memory> // for unique_ptr
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
+#endif
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineSegment;
+}
+namespace simplify {
+class TaggedLineString;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+class GEOS_DLL LineSegmentIndex {
+
+public:
+
+    LineSegmentIndex() = default;
+
+    ~LineSegmentIndex() = default;
+
+    void add(const TaggedLineString& line);
+
+    void add(const geom::LineSegment* seg);
+
+    void remove(const geom::LineSegment* seg);
+
+    std::vector<const geom::LineSegment*>
+    query(const geom::LineSegment* seg);
+
+
+private:
+
+    index::quadtree::Quadtree index;
+
+    std::vector<std::unique_ptr<geom::Envelope>> newEnvelopes;
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    LineSegmentIndex(const LineSegmentIndex&) = delete;
+    LineSegmentIndex& operator=(const LineSegmentIndex&) = delete;
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/simplify/LinkedLine.h

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+
+#include <vector>
+#include <memory>
+
+
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::CoordinateSequence;
+
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+class LinkedLine
+{
+
+public:
+
+    LinkedLine(const CoordinateSequence& pts);
+
+    bool isRing() const;
+    bool isCorner(std::size_t i) const;
+
+    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;
+
+
+private:
+
+    // Members
+    const CoordinateSequence&  m_coord;
+    bool m_isRing;
+    std::size_t m_size;
+    std::vector<std::size_t> m_next;
+    std::vector<std::size_t> m_prev;
+
+    void createNextLinks(std::size_t size);
+
+    void createPrevLinks(std::size_t size);
+
+
+}; // LinkedLine
+
+GEOS_DLL std::ostream& operator<< (std::ostream& os, const LinkedLine& ll);
+
+
+} // geos::simplify
+} // geos