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

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/PrecisionReducer.h

@@ -0,0 +1,75 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+#include <memory>
+#include <map>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class PrecisionModel;
+class Geometry;
+}
+namespace operation {
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+* Reduces the precision of a geometry by rounding it to the
+* supplied {@link geom::PrecisionModel}.
+*
+* The output is always a valid geometry.  This implies that input components
+* may be merged if they are closer than the grid precision.
+* if merging is not desired, then the individual geometry components
+* should be processed separately.
+*
+* The output is fully noded.
+* This provides an effective way to node / snap-round a collection of {@link geom::LineString}s.
+*/
+class GEOS_DLL PrecisionReducer {
+
+private:
+
+    // Members
+
+    // Methods
+
+
+public:
+
+    PrecisionReducer() {};
+
+    static std::unique_ptr<Geometry> reducePrecision(const Geometry* geom, const PrecisionModel* pm, bool replacePrecisionModel = false);
+
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/PrecisionUtil.h

@@ -0,0 +1,245 @@
+/**********************************************************************
+ *
+ * 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/CoordinateFilter.h>
+#include <geos/geom/Coordinate.h>
+
+#include <vector>
+#include <map>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Envelope;
+class PrecisionModel;
+}
+namespace operation {
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+ * Unions a collection of geometries in an
+ * efficient way, using {@link OverlayNG}
+ * to ensure robust computation.
+ * @author Martin Davis
+ */
+class GEOS_DLL PrecisionUtil {
+
+private:
+
+    static double robustScale(double inherentScale, double safeScale);
+
+    /**
+    * Determines the maximum magnitude (absolute value) of the bounds of an
+    * of an envelope.
+    * This is equal to the largest ordinate value
+    * which must be accommodated by a scale factor.
+    *
+    */
+    static double maxBoundMagnitude(const Envelope* env);
+
+    /**
+    * Computes the scale factor which will
+    * produce a given number of digits of precision (significant digits)
+    * when used to round the given number.
+    *
+    * For example: to provide 5 decimal digits of precision
+    * for the number 123.456 the precision scale factor is 100;
+    * for 3 digits of precision the scale factor is 1;
+    * for 2 digits of precision the scale factor is 0.1.
+    *
+    * Rounding to the scale factor can be performed with {@link PrecisionModel#round}
+    *
+    * @see PrecisionModel.round
+    */
+    static double precisionScale(double value, int precisionDigits);
+
+
+
+public:
+
+    static constexpr int MAX_ROBUST_DP_DIGITS = 14;
+
+    PrecisionUtil() {};
+
+    /**
+    * Determines a precision model to
+    * use for robust overlay operations.
+    * The precision scale factor is chosen to maximize
+    * output precision while avoiding round-off issues.
+    *
+    * NOTE: this is a heuristic determination, so is not guaranteed to
+    * eliminate precision issues.
+    *
+    * WARNING: this is quite slow.
+    */
+    static PrecisionModel robustPM(const Geometry* a, const Geometry* b);
+
+    /**
+    * Determines a precision model to
+    * use for robust overlay operations for one geometry.
+    * The precision scale factor is chosen to maximize
+    * output precision while avoiding round-off issues.
+    *
+    * NOTE: this is a heuristic determination, so is not guaranteed to
+    * eliminate precision issues.
+    *
+    * WARNING: this is quite slow.
+    */
+    static PrecisionModel robustPM(const Geometry* a);
+
+    /**
+    * Determines a scale factor which maximizes
+    * the digits of precision and is
+    * safe to use for overlay operations.
+    * The robust scale is the minimum of the
+    * inherent scale and the safe scale factors.
+    */
+    static double robustScale(const Geometry* a, const Geometry* b);
+
+    /**
+    * Determines a scale factor which maximizes
+    * the digits of precision and is
+    * safe to use for overlay operations.
+    * The robust scale is the minimum of the
+    * inherent scale and the safe scale factors.
+    */
+    static double robustScale(const Geometry* a);
+
+    /**
+    * Computes a safe scale factor for a numeric value.
+    * A safe scale factor ensures that rounded
+    * number has no more than MAX_PRECISION_DIGITS
+    * digits of precision.
+    */
+    static double safeScale(double value);
+
+    /**
+    * Computes a safe scale factor for a geometry.
+    * A safe scale factor ensures that the rounded
+    * ordinates have no more than MAX_PRECISION_DIGITS
+    * digits of precision.
+    */
+    static double safeScale(const Geometry* geom);
+
+    /**
+    * Computes a safe scale factor for two geometries.
+    * A safe scale factor ensures that the rounded
+    * ordinates have no more than MAX_PRECISION_DIGITS
+    * digits of precision.
+    */
+    static double safeScale(const Geometry* a, const Geometry* b);
+
+    /**
+    * Computes the inherent scale of a number.
+    * The inherent scale is the scale factor for rounding
+    * which preserves all digits of precision
+    * (significant digits)
+    * present in the numeric value.
+    * In other words, it is the scale factor which does not
+    * change the numeric value when rounded:
+    *
+    *   num = round( num, inherentScale(num) )
+    */
+    static double inherentScale(double value);
+
+    /**
+    * Computes the inherent scale of a geometry.
+    * The inherent scale is the scale factor for rounding
+    * which preserves <b>all</b> digits of precision
+    * (significant digits)
+    * present in the geometry ordinates.
+    *
+    * This is the maximum inherent scale
+    * of all ordinate values in the geometry.
+    */
+    static double inherentScale(const Geometry* geom);
+
+    /**
+    * Computes the inherent scale of two geometries.
+    * The inherent scale is the scale factor for rounding
+    * which preserves <b>all</b> digits of precision
+    * (significant digits)
+    * present in the geometry ordinates.
+    *
+    * This is the maximum inherent scale
+    * of all ordinate values in the geometries.
+    */
+    static double inherentScale(const Geometry* a, const Geometry* b);
+
+    /**
+    * Determines the
+    * number of decimal places represented in a double-precision
+    * number (as determined by Java).
+    * This uses the Java double-precision print routine
+    * to determine the number of decimal places,
+    * This is likely not optimal for performance,
+    * but should be accurate and portable.
+    */
+    static int numberOfDecimals(double value);
+
+    /**
+    * Applies the inherent scale calculation
+    * to every ordinate in a geometry.
+    */
+    class GEOS_DLL InherentScaleFilter: public CoordinateFilter {
+
+        private:
+
+            double scale;
+
+            void updateScaleMax(double value) {
+                double scaleVal = PrecisionUtil::inherentScale(value);
+                if (scaleVal > scale) {
+                    scale = scaleVal;
+                }
+            }
+
+        public:
+
+            InherentScaleFilter()
+                : scale(0.0)
+                {}
+
+            void filter_ro(const geom::Coordinate* coord) override
+            {
+                updateScaleMax(coord->x);
+                updateScaleMax(coord->y);
+            }
+
+            double getScale() const {
+                return scale;
+            }
+    };
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/RingClipper.h

@@ -0,0 +1,112 @@
+/**********************************************************************
+ *
+ * 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/Envelope.h>
+#include <geos/geom/CoordinateSequence.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+}
+}
+
+using namespace geos::geom;
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Clips rings of points to a rectangle.
+ * Uses a variant of Cohen-Sutherland clipping.
+ *
+ * In general the output is not topologically valid.
+ * In particular, the output may contain coincident non-noded line segments
+ * along the clip rectangle sides.
+ * However, the output is sufficiently well-structured
+ * that it can be used as input to the {@link OverlayNG} algorithm
+ * (which is able to process coincident linework due
+ * to the need to handle topology collapse under precision reduction).
+ *
+ * Because of the likelihood of creating
+ * extraneous line segments along the clipping rectangle sides,
+ * this class is not suitable for clipping linestrings.
+ *
+ * The clipping envelope should be generated using {@link RobustClipEnvelopeComputer},
+ * to ensure that intersecting line segments are not perturbed
+ * by clipping.
+ * This is required to ensure that the overlay of the
+ * clipped geometry is robust and correct (i.e. the same as
+ * if clipping was not used).
+ *
+ * @see LineLimiter
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL RingClipper {
+
+private:
+
+    // Constants
+    static constexpr int BOX_LEFT = 3;
+    static constexpr int BOX_TOP = 2;
+    static constexpr int BOX_RIGHT = 1;
+    static constexpr int BOX_BOTTOM = 0;
+
+    // Members
+    const Envelope clipEnv;
+
+    // Methods
+
+    /**
+    * Clips line to the axis-parallel line defined by a single box edge.
+    */
+    std::unique_ptr<CoordinateSequence> clipToBoxEdge(const CoordinateSequence* pts, int edgeIndex, bool closeRing) const;
+
+    /**
+    * Computes the intersection point of a segment
+    * with an edge of the clip box.
+    * The segment must be known to intersect the edge.
+    */
+    void intersection(const Coordinate& a, const Coordinate& b, int edgeIndex, Coordinate& rsltPt) const;
+    double intersectionLineY(const Coordinate& a, const Coordinate& b, double y) const;
+    double intersectionLineX(const Coordinate& a, const Coordinate& b, double x) const;
+    bool isInsideEdge(const Coordinate& p, int edgeIndex) const;
+
+
+public:
+
+    RingClipper(const Envelope* env)
+        : clipEnv(*env)
+        {};
+
+    /**
+    * Clips a list of points to the clipping rectangle box.
+    */
+    std::unique_ptr<CoordinateSequence> clip(const CoordinateSequence* cs) const;
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/RobustClipEnvelopeComputer.h

@@ -0,0 +1,84 @@
+/**********************************************************************
+ *
+ * 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/Envelope.h>
+
+#include <vector>
+#include <map>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Geometry;
+class GeometryCollection;
+class Polygon;
+class LinearRing;
+}
+namespace operation {
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+using namespace geos::geom;
+
+/**
+ * Computes a robust clipping envelope for a pair of polygonal geometries.
+ * The envelope is computed to be large enough to include the full
+ * length of all geometry line segments which intersect
+ * a given target envelope.
+ * This ensures that line segments which might intersect are
+ * not perturbed when clipped using {@link RingClipper}.
+ * @author mdavis
+ */
+class GEOS_DLL RobustClipEnvelopeComputer {
+
+private:
+
+    // Members
+    const Envelope* targetEnv;
+    Envelope clipEnv;
+
+    // Methods
+    void add(const Geometry* g);
+    void addCollection(const GeometryCollection* gc);
+    void addPolygon(const Polygon* poly);
+    void addPolygonRing(const LinearRing* ring);
+    void addSegment(const Coordinate& p1, const Coordinate& p2);
+    bool intersectsSegment(const Envelope* env, const Coordinate& p1, const Coordinate& p2);
+
+
+
+public:
+
+    RobustClipEnvelopeComputer(const Envelope* p_targetEnv);
+
+    static Envelope getEnvelope(const Geometry* a, const Geometry* b, const Envelope* targetEnv);
+
+    Envelope getEnvelope();
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/UnaryUnionNG.h

@@ -0,0 +1,95 @@
+/**********************************************************************
+ *
+ * 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/PrecisionModel.h>
+#include <geos/operation/union/UnionStrategy.h>
+#include <geos/operation/overlayng/OverlayNG.h>
+#include <geos/operation/overlayng/OverlayUtil.h>
+
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Unions a collection of geometries in an
+ * efficient way, using {@link OverlayNG}
+ * to ensure robust computation.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL UnaryUnionNG {
+
+private:
+
+    // Members
+
+
+
+public:
+
+    /**
+    * Strategy class for NG unions.
+    */
+    class NGUnionStrategy : public operation::geounion::UnionStrategy {
+
+    public:
+
+        NGUnionStrategy(const PrecisionModel& p_pm)
+            : pm(p_pm)
+            {};
+
+        std::unique_ptr<geom::Geometry>
+        Union(const geom::Geometry* g0, const geom::Geometry* g1) override
+        {
+            return OverlayNG::overlay(g0, g1, OverlayNG::UNION, &pm);
+        }
+
+        bool
+        isFloatingPrecision() const override
+        {
+            return OverlayUtil::isFloating(&pm);
+        }
+
+    private:
+
+        const geom::PrecisionModel& pm;
+
+    };
+
+
+    // static methods
+    static std::unique_ptr<Geometry> Union(const Geometry* geom, const PrecisionModel& pm);
+    static std::unique_ptr<Geometry> Union(const Geometry* geom);
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/polygonize/BuildArea.h

@@ -0,0 +1,75 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright 2011-2014 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2019 Even Rouault <even.rouault@spatialys.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.
+ **********************************************************************
+ *
+ * Ported from rtgeom_geos.c from
+ *   rttopo - topology library
+ *   http://git.osgeo.org/gitea/rttopo/librttopo
+ * with relicensing from GPL to LGPL with Copyright holder permission.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <memory>
+
+#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 Geometry;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace polygonize { // geos::operation::polygonize
+
+/** \brief Creates an areal geometry formed by the constituent linework of given geometry.
+ *
+ * The return type can be a Polygon or MultiPolygon, depending on input.
+ * If the input lineworks do not form polygons NULL is returned.
+ * The inputs can be LINESTRINGS, MULTILINESTRINGS, POLYGONS, MULTIPOLYGONS, and GeometryCollections.
+ *
+ * This algorithm will assume all inner geometries represent holes
+ *
+ * This is the equivalent of the PostGIS ST_BuildArea() function.
+ */
+class GEOS_DLL BuildArea {
+
+public:
+
+    /** \brief
+     * Create a BuildArea object.
+     */
+    BuildArea() = default;
+
+    ~BuildArea() = default;
+
+    /** \brief Return the area built from the constituent linework of the input geometry. */
+    std::unique_ptr<geom::Geometry> build(const geom::Geometry* geom);
+};
+
+} // namespace geos::operation::polygonize
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif