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

package/dist/prebuilt/Android-x86_64/include/geos/precision/MinimumClearance.h

@@ -0,0 +1,57 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Daniel Baston
+ *
+ * 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: precision/MinimumClearance.java (f6187ee2 JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Geometry.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace precision {
+
+/// Computes the Minimum Clearance of a Geometry.
+class GEOS_DLL MinimumClearance {
+private:
+    const geom::Geometry* inputGeom;
+    double minClearance;
+    std::unique_ptr<geom::CoordinateSequence> minClearancePts;
+
+    void compute();
+public:
+    MinimumClearance(const geom::Geometry* g);
+
+    /**
+     * Gets the Minimum Clearance distance.
+     *
+     * @return the value of the minimum clearance distance
+     * or <tt>DBL_MAX</tt> if no Minimum Clearance distance exists
+     */
+    double getDistance();
+
+    /**
+     * Gets a LineString containing two points
+     * which are at the Minimum Clearance distance.
+     *
+     * @return the value of the minimum clearance distance
+     * or <tt>LINESTRING EMPTY</tt> if no Minimum Clearance distance exists
+     */
+    std::unique_ptr<geom::LineString> getLine();
+};
+}
+}

package/dist/prebuilt/Android-x86_64/include/geos/precision/PointwisePrecisionReducerTransformer.h

@@ -0,0 +1,74 @@
+/**********************************************************************
+ *
+ * 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;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace precision { // geos.precision
+
+
+/**
+ * A transformer to reduce the precision of a geometry pointwise.
+ *
+ * @author mdavis
+ */
+class GEOS_DLL PointwisePrecisionReducerTransformer : public geom::util::GeometryTransformer {
+
+private:
+
+    const geom::PrecisionModel& targetPM;
+
+    std::unique_ptr<geom::CoordinateSequence> reducePointwise(
+        const geom::CoordinateSequence* coordinates);
+
+public:
+
+    PointwisePrecisionReducerTransformer(
+        const geom::PrecisionModel& p_targetPM)
+        : targetPM(p_targetPM)
+        {};
+
+    static std::unique_ptr<geom::Geometry> reduce(
+        const geom::Geometry& geom,
+        const geom::PrecisionModel& targetPM);
+
+
+
+protected:
+
+    std::unique_ptr<geom::CoordinateSequence> transformCoordinates(
+        const geom::CoordinateSequence* coords,
+        const geom::Geometry* parent) override;
+
+
+};
+
+} // namespace geos.precision
+} // namespace geos
+
+

package/dist/prebuilt/Android-x86_64/include/geos/precision/PrecisionReducerCoordinateOperation.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012 Sandro Santilli <strk@kbt.io>
+ *
+ * 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: precision/PrecisionreducerCoordinateOperation.java r591 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/util/CoordinateOperation.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class PrecisionModel;
+class CoordinateSequence;
+class Geometry;
+}
+}
+
+namespace geos {
+namespace precision { // geos.precision
+
+class PrecisionReducerCoordinateOperation :
+    public geom::util::CoordinateOperation {
+    using CoordinateOperation::edit;
+private:
+
+    const geom::PrecisionModel& targetPM;
+
+    bool removeCollapsed;
+
+    PrecisionReducerCoordinateOperation(PrecisionReducerCoordinateOperation const&); /*= delete*/
+    PrecisionReducerCoordinateOperation& operator=(PrecisionReducerCoordinateOperation const&); /*= delete*/
+
+public:
+
+    PrecisionReducerCoordinateOperation(const geom::PrecisionModel& pm,
+                                        bool doRemoveCollapsed)
+        :
+        targetPM(pm),
+        removeCollapsed(doRemoveCollapsed)
+    {}
+
+    /// Ownership of returned CoordinateSequence to caller
+    ///
+    /// virtual function
+    std::unique_ptr<geom::CoordinateSequence> edit(const geom::CoordinateSequence* coordinates,
+                                                   const geom::Geometry* geom) override;
+};
+
+} // namespace geos.precision
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/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);
+
+    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/Android-x86_64/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/Android-x86_64/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/Android-x86_64/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
+
+
+