@crossbind/port-geos-linuxmusl 0.0.0-bootstrap.0 → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/precision/PrecisionReducerTransformer.h

@@ -0,0 +1,95 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+#include <memory>
+
+#include <geos/geom/util/GeometryTransformer.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class PrecisionModel;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace precision { // geos.precision
+
+/** \brief
+ * Reduces the precision of a {@link geom::Geometry}
+ * according to the supplied {@link geom::PrecisionModel}, without
+ * attempting to preserve valid topology.
+ *
+ * The topology of the resulting geometry may be invalid if
+ * topological collapse occurs due to coordinates being shifted.
+ * It is up to the client to check this and handle it if necessary.
+ * Collapses may not matter for some uses.  An example
+ * is simplifying the input to the buffer algorithm.
+ * The buffer algorithm does not depend on the validity of the input geometry.
+ *
+ */
+class GEOS_DLL PrecisionReducerTransformer : public geom::util::GeometryTransformer {
+
+private:
+
+    const geom::PrecisionModel& targetPM;
+    bool isRemoveCollapsed;
+
+    std::unique_ptr<geom::Geometry> reduceArea(const geom::Geometry* geom) const;
+
+    static void extend(
+        geom::CoordinateSequence& coords,
+        std::size_t minLength);
+
+
+public:
+
+    PrecisionReducerTransformer(
+        const geom::PrecisionModel& p_targetPM,
+        bool p_isRemoveCollapsed = false)
+        : targetPM(p_targetPM)
+        , isRemoveCollapsed(p_isRemoveCollapsed)
+        {};
+
+    static std::unique_ptr<geom::Geometry> reduce(
+        const geom::Geometry& geom,
+        const geom::PrecisionModel& targetPM,
+        bool isRemoveCollapsed = false);
+
+
+protected:
+
+    std::unique_ptr<geom::CoordinateSequence> transformCoordinates(
+        const geom::CoordinateSequence* coords,
+        const geom::Geometry* parent) override;
+
+    std::unique_ptr<geom::Geometry> transformPolygon(
+        const geom::Polygon* geom,
+        const geom::Geometry* parent) override;
+
+    std::unique_ptr<geom::Geometry> transformMultiPolygon(
+        const geom::MultiPolygon* geom,
+        const geom::Geometry* parent) override;
+
+
+};
+
+} // namespace geos.precision
+} // namespace geos
+
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/precision/SimpleGeometryPrecisionReducer.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-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/export.h>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class PrecisionModel;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace precision { // geos.precision
+
+/** \brief
+ * Reduces the precision of a {@link geom::Geometry}
+ * according to the supplied {@link geom::PrecisionModel}, without
+ * attempting to preserve valid topology.
+ *
+ * The topology of the resulting geometry may be invalid if
+ * topological collapse occurs due to coordinates being shifted.
+ * It is up to the client to check this and handle it if necessary.
+ * Collapses may not matter for some uses.  An example
+ * is simplifying the input to the buffer algorithm.
+ * The buffer algorithm does not depend on the validity of the input geometry.
+ *
+ */
+class GEOS_DLL SimpleGeometryPrecisionReducer {
+
+private:
+
+    const geom::PrecisionModel* newPrecisionModel;
+
+    bool removeCollapsed;
+
+    //bool changePrecisionModel;
+
+public:
+
+    SimpleGeometryPrecisionReducer(const geom::PrecisionModel* pm);
+
+    /**
+     * Sets whether the reduction will result in collapsed components
+     * being removed completely, or simply being collapsed to an (invalid)
+     * Geometry of the same type.
+     *
+     * @param nRemoveCollapsed if <code>true</code> collapsed
+     * components will be removed
+     */
+    void setRemoveCollapsedComponents(bool nRemoveCollapsed);
+
+    /*
+     * Sets whether the {@link PrecisionModel} of the new reduced Geometry
+     * will be changed to be the {@link PrecisionModel} supplied to
+     * specify the reduction.  The default is to not change the
+     * precision model
+     *
+     * @param changePrecisionModel if <code>true</code> the precision
+     * model of the created Geometry will be the
+     * the precisionModel supplied in the constructor.
+     */
+    //void setChangePrecisionModel(bool nChangePrecisionModel);
+
+    const geom::PrecisionModel* getPrecisionModel();
+
+    bool getRemoveCollapsed();
+    std::unique_ptr<geom::Geometry> reduce(const geom::Geometry* geom);
+};
+
+} // namespace geos.precision
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/profiler.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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/export.h>
+#include <chrono>
+
+#include <map>
+#include <memory>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#ifndef PROFILE
+#define PROFILE 0
+#endif
+
+#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
+
+namespace geos {
+namespace util {
+
+
+/*
+ * \class Profile utils.h geos.h
+ *
+ * \brief Profile statistics
+ */
+class GEOS_DLL Profile {
+public:
+    using timeunit = std::chrono::microseconds;
+
+    /** \brief Create a named profile */
+    Profile(std::string name);
+
+    /** \brief Destructor */
+    ~Profile() = default;
+
+    /** \brief start a new timer */
+    void
+    start()
+    {
+        starttime = std::chrono::high_resolution_clock::now();
+    }
+
+    /** \brief stop current timer */
+    void
+    stop()
+    {
+        stoptime = std::chrono::high_resolution_clock::now();
+        auto elapsed = std::chrono::duration_cast<timeunit>(stoptime - starttime);
+
+        timings.push_back(elapsed);
+
+        totaltime += elapsed;
+        if(timings.size() == 1) {
+            max = min = elapsed;
+        }
+        else {
+            if(elapsed > max) {
+                max = elapsed;
+            }
+            if(elapsed < min) {
+                min = elapsed;
+            }
+        }
+
+        avg = static_cast<double>(totaltime.count()) / static_cast<double>(timings.size());
+    }
+
+    /** \brief Return Max stored timing */
+    double getMax() const;
+
+    /** \brief Return Min stored timing */
+    double getMin() const;
+
+    /** \brief Return total timing */
+    double getTot() const;
+
+    /** \brief Return total timing */
+    std::string getTotFormatted() const;
+
+    /** \brief Return average timing */
+    double getAvg() const;
+
+    /** \brief Return number of timings */
+    std::size_t getNumTimings() const;
+
+    /** \brief Profile name */
+    std::string name;
+
+
+
+private:
+    /* \brief current start and stop times */
+    std::chrono::high_resolution_clock::time_point starttime, stoptime;
+
+    /* \brief actual times */
+    std::vector<timeunit> timings;
+
+    /* \brief total time */
+    timeunit totaltime;
+
+    /* \brief max time */
+    timeunit max;
+
+    /* \brief max time */
+    timeunit min;
+
+    /* \brief avg time */
+    double avg;
+};
+
+/*
+ * \class Profiler utils.h geos.h
+ *
+ * \brief Profiling class
+ *
+ */
+class GEOS_DLL Profiler {
+
+public:
+
+    Profiler() = default;
+    ~Profiler() = default;
+
+    Profiler(const Profiler&) = delete;
+    Profiler& operator=(const Profiler&) = delete;
+
+    /**
+     * \brief
+     * Return the singleton instance of the
+     * profiler.
+     */
+    static Profiler* instance(void);
+
+    /**
+     * \brief
+     * Start timer for named task. The task is
+     * created if does not exist.
+     */
+    void start(std::string name);
+
+    /**
+     * \brief
+     * Stop timer for named task.
+     * Elapsed time is registered in the given task.
+     */
+    void stop(std::string name);
+
+    /** \brief get Profile of named task */
+    Profile* get(std::string name);
+
+    std::map<std::string, std::unique_ptr<Profile>> profs;
+};
+
+
+/** \brief Return a string representing the Profile */
+GEOS_DLL std::ostream& operator<< (std::ostream& os, const Profile&);
+
+/** \brief Return a string representing the Profiler */
+GEOS_DLL std::ostream& operator<< (std::ostream& os, const Profiler&);
+
+} // namespace geos::util
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/shape/GeometricShapeBuilder.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+*
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Martin Davis
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: shape/GeometricShapeBuilder.java c2e8e1d069
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/LineSegment.h>
+
+#include <cstddef>
+#include <memory>
+
+namespace geos {
+namespace shape {
+
+class GEOS_DLL GeometricShapeBuilder {
+public:
+    GeometricShapeBuilder();
+    explicit GeometricShapeBuilder(const geom::GeometryFactory* gf);
+
+    virtual ~GeometricShapeBuilder() = default;
+
+    /**
+     * Sets the extent as an envelope.
+     *
+     * @param env the extent envelope
+     */
+    void setExtent(const geom::Envelope& env);
+
+    /**
+     * Gets the extent envelope.
+     *
+     * @return the extent envelope
+     */
+    const geom::Envelope& getExtent() const;
+
+    geom::CoordinateXY getCentre() const;
+
+    double getDiameter() const;
+
+    double getRadius() const;
+
+    geom::LineSegment getSquareBaseLine() const;
+
+    geom::Envelope getSquareExtent() const;
+
+    /**
+     * Sets the total number of points in the created {@link Geometry}.
+     * The created geometry will have no more than this number of points,
+     * unless more are needed to create a valid geometry.
+     */
+    void setNumPoints(std::size_t n);
+
+    virtual std::unique_ptr<geom::Geometry> getGeometry() = 0;
+
+protected:
+    geom::CoordinateXY createCoord(double x, double y) const;
+
+    const geom::GeometryFactory* geometryFactory;
+    geom::Envelope extent;
+    std::size_t numPts;
+};
+
+} // namespace shape
+} // namespace geos

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/shape/fractal/HilbertCode.h

@@ -0,0 +1,128 @@
+/**********************************************************************
+ *
+ * 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 finite planar Hilbert curves.
+ *
+ * The planar Hilbert Curve is a continuous space-filling curve.
+ * In the limit the Hilbert curve has infinitely many vertices and fills
+ * the space of the unit square.
+ * A sequence of finite approximations to the infinite Hilbert curve
+ * is defined by the level number.
+ * The finite Hilbert curve at level n H(n) contains 2^n+1 points.
+ * Each finite Hilbert curve defines an ordering of the
+ * points in the 2-dimensional range square containing the curve.
+ * Curves fills the range square of side 2^level.
+ * Curve points have ordinates in the range [0, 2^level - 1].
+ * The index of a point along a Hilbert curve is called the Hilbert code.
+ * The code for a given point is specific to the level chosen.
+ *
+ * This implementation represents codes using 32-bit integers.
+ * This allows levels 0 to 16 to be handled.
+ * The class supports encoding points in the range of a given level curve
+ * and decoding the point for a given code value.
+ *
+ * The Hilbert 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 Hilbert order is an effective way of linearizing space
+ * to support range queries.
+ *
+ * @author Martin Davis
+ *
+ * @see MortonCode
+ */
+class GEOS_DLL HilbertCode {
+
+public:
+
+    /**
+    * The maximum curve level that can be represented.
+    */
+    static constexpr int MAX_LEVEL = 16;
+
+    static geom::Coordinate decode(uint32_t level, uint32_t i);
+
+    static uint32_t encode(uint32_t level, uint32_t x, uint32_t y);
+
+    /**
+    * The number of points in the curve for the given level.
+    * The number of points is 2^(2 * level).
+    *
+    * @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^level - 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 Hilbert 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 uint32_t deinterleave(uint32_t x);
+
+    static uint32_t interleave(uint32_t x);
+
+    static uint32_t prefixScan(uint32_t x);
+
+    static uint32_t descan(uint32_t x);
+
+    static void checkLevel(uint32_t level);
+
+
+};
+
+
+} // namespace geos.shape.fractal
+} // namespace geos.shape
+} // namespace geos
+
+
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/shape/fractal/HilbertEncoder.h

@@ -0,0 +1,97 @@
+/**********************************************************************
+ *
+ * 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 <algorithm>
+#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
+
+
+