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

package/dist/prebuilt/Android-x86_64/include/geos/math/DD.h

@@ -0,0 +1,200 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Crunchy Data
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+/**
+ * Implements extended-precision floating-point numbers
+ * which maintain 106 bits (approximately 30 decimal digits) of precision.
+ * <p>
+ * A DoubleDouble uses a representation containing two double-precision values.
+ * A number x is represented as a pair of doubles, x.hi and x.lo,
+ * such that the number represented by x is x.hi + x.lo, where
+ * <pre>
+ *    |x.lo| &lt;= 0.5*ulp(x.hi)
+ * </pre>
+ * and ulp(y) means "unit in the last place of y".
+ * The basic arithmetic operations are implemented using
+ * convenient properties of IEEE-754 floating-point arithmetic.
+ * <p>
+ * The range of values which can be represented is the same as in IEEE-754.
+ * The precision of the representable numbers
+ * is twice as great as IEEE-754 double precision.
+ * <p>
+ * The correctness of the arithmetic algorithms relies on operations
+ * being performed with standard IEEE-754 double precision and rounding.
+ * This is the Java standard arithmetic model, but for performance reasons
+ * Java implementations are not
+ * constrained to using this standard by default.
+ * Some processors (notably the Intel Pentium architecture) perform
+ * floating point operations in (non-IEEE-754-standard) extended-precision.
+ * A JVM implementation may choose to use the non-standard extended-precision
+ * as its default arithmetic mode.
+ * To prevent this from happening, this code uses the
+ * Java <tt>strictfp</tt> modifier,
+ * which forces all operations to take place in the standard IEEE-754 rounding model.
+ * <p>
+ * The API provides both a set of value-oriented operations
+ * and a set of mutating operations.
+ * Value-oriented operations treat DoubleDouble values as
+ * immutable; operations on them return new objects carrying the result
+ * of the operation.  This provides a simple and safe semantics for
+ * writing DoubleDouble expressions.  However, there is a performance
+ * penalty for the object allocations required.
+ * The mutable interface updates object values in-place.
+ * It provides optimum memory performance, but requires
+ * care to ensure that aliasing errors are not created
+ * and constant values are not changed.
+ * <p>
+ * For example, the following code example constructs three DD instances:
+ * two to hold the input values and one to hold the result of the addition.
+ * <pre>
+ *     DD a = new DD(2.0);
+ *     DD b = new DD(3.0);
+ *     DD c = a.add(b);
+ * </pre>
+ * In contrast, the following approach uses only one object:
+ * <pre>
+ *     DD a = new DD(2.0);
+ *     a.selfAdd(3.0);
+ * </pre>
+ * <p>
+ * This implementation uses algorithms originally designed variously by
+ * Knuth, Kahan, Dekker, and Linnainmaa.
+ * Douglas Priest developed the first C implementation of these techniques.
+ * Other more recent C++ implementation are due to Keith M. Briggs and David Bailey et al.
+ *
+ * <h3>References</h3>
+ * <ul>
+ * <li>Priest, D., <i>Algorithms for Arbitrary Precision Floating Point Arithmetic</i>,
+ * in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic,
+ * IEEE Computer Society Press, Los Alamitos, Calif., 1991.
+ * <li>Yozo Hida, Xiaoye S. Li and David H. Bailey,
+ * <i>Quad-Double Arithmetic: Algorithms, Implementation, and Application</i>,
+ * manuscript, Oct 2000; Lawrence Berkeley National Laboratory Report BNL-46996.
+ * <li>David Bailey, <i>High Precision Software Directory</i>;
+ * <tt>http://crd.lbl.gov/~dhbailey/mpdist/index.html</tt>
+ * </ul>
+ *
+ *
+ * @author Martin Davis
+ *
+ */
+
+#pragma once
+
+#include <cmath>
+#include <geos/export.h>
+
+namespace geos {
+namespace math { // geos.math
+
+/**
+ * \class DD
+ *
+ * \brief
+ * Wrapper for DoubleDouble higher precision mathematics
+ * operations.
+ */
+class GEOS_DLL DD {
+    private:
+        static constexpr double SPLIT = 134217729.0; // 2^27+1, for IEEE double
+        double hi;
+        double lo;
+
+        int signum() const;
+        DD rint() const;
+
+
+    public:
+        DD(double p_hi, double p_lo) : hi(p_hi), lo(p_lo) {};
+        DD(double x) : hi(x), lo(0.0) {};
+        DD() : hi(0.0), lo(0.0) {};
+
+        bool operator==(const DD &rhs) const
+        {
+            return hi == rhs.hi && lo == rhs.lo;
+        }
+
+        bool operator!=(const DD &rhs) const
+        {
+            return hi != rhs.hi || lo != rhs.lo;
+        }
+
+        bool operator<(const DD &rhs) const
+        {
+            return (hi < rhs.hi) || (hi == rhs.hi && lo < rhs.lo);
+        }
+
+        bool operator<=(const DD &rhs) const
+        {
+            return (hi < rhs.hi) || (hi == rhs.hi && lo <= rhs.lo);
+        }
+
+        bool operator>(const DD &rhs) const
+        {
+            return (hi > rhs.hi) || (hi == rhs.hi && lo > rhs.lo);
+        }
+
+        bool operator>=(const DD &rhs) const
+        {
+            return (hi > rhs.hi) || (hi == rhs.hi && lo >= rhs.lo);
+        }
+
+        friend GEOS_DLL DD operator+ (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator+ (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator- (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator- (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator* (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator* (const DD &lhs, double rhs);
+        friend GEOS_DLL DD operator/ (const DD &lhs, const DD &rhs);
+        friend GEOS_DLL DD operator/ (const DD &lhs, double rhs);
+
+        static DD determinant(const DD &x1, const DD &y1, const DD &x2, const DD &y2);
+        static DD determinant(double x1, double y1, double x2, double y2);
+        static DD abs(const DD &d);
+        static DD pow(const DD &d, int exp);
+        static DD trunc(const DD &d);
+
+        bool isNaN() const;
+        bool isNegative() const;
+        bool isPositive() const;
+        bool isZero() const;
+        double doubleValue() const;
+        double ToDouble() const { return doubleValue(); }
+        int intValue() const;
+        DD negate() const;
+        DD reciprocal() const;
+        DD floor() const;
+        DD ceil() const;
+
+        void selfAdd(const DD &d);
+        void selfAdd(double p_hi, double p_lo);
+        void selfAdd(double y);
+
+        void selfSubtract(const DD &d);
+        void selfSubtract(double p_hi, double p_lo);
+        void selfSubtract(double y);
+
+        void selfMultiply(double p_hi, double p_lo);
+        void selfMultiply(const DD &d);
+        void selfMultiply(double y);
+
+        void selfDivide(double p_hi, double p_lo);
+        void selfDivide(const DD &d);
+        void selfDivide(double y);
+};
+
+
+} // namespace geos::math
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/namespaces.h

@@ -0,0 +1,317 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2019      Nicklas Larsson
+ *
+ * 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
+
+namespace geos {
+
+/// \brief
+/// Contains classes and interfaces implementing fundamental computational
+/// geometry algorithms.
+///
+/// ### Robustness
+///
+/// Geometrical algorithms involve a combination of combinatorial and numerical
+/// computation. As with all numerical computation using finite-precision
+/// numbers, the algorithms chosen are susceptible to problems of robustness.
+/// A robustness problem occurs when a numerical calculation produces an
+/// incorrect answer for some inputs due to round-off errors.  Robustness
+/// problems are especially serious in geometric computation, since they can
+/// result in errors during topology building.
+///
+/// There are many approaches to dealing with the problem of robustness in
+/// geometrical computation. Not surprisingly, most robust algorithms are
+/// substantially more complex and less performant than the non-robust
+/// versions. Fortunately, JTS is sensitive to robustness problems in only a
+/// few key functions (such as line intersection and the point-in-polygon
+/// test). There are efficient robust algorithms available for these
+/// functions, and these algorithms are implemented in JTS.
+///
+/// ### Computational Performance
+///
+/// Runtime performance is an important consideration for a production-quality
+/// implementation of geometric algorithms. The most computationally intensive
+/// algorithm used in JTS is intersection detection. JTS methods need to
+/// determine both all intersection between the line segments in a single
+/// Geometry (self-intersection) and all intersections between the line
+/// segments of two different Geometries.
+///
+/// The obvious naive algorithm for intersection detection (comparing every
+/// segment with every other) has unacceptably slow performance. There is a
+/// large literature of faster algorithms for intersection detection.
+/// Unfortunately, many of them involve substantial code complexity. JTS tries
+/// to balance code simplicity with performance gains. It uses some simple
+/// techniques to produce substantial performance gains for common types of
+/// input data.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///       OpenGIS Simple Features Specification for SQL</A>
+    namespace algorithm { // geos::algorithm
+
+    /// Classes to compute distance metrics between geometries.
+    namespace distance {}
+
+    /// Classes which determine the Location of points in geometries.
+    namespace locate {}
+} // namespace geos::algorithm
+
+namespace geom { // geos.geom
+
+    /// \brief
+    /// Contains classes and interfaces implementing algorithms that optimize
+    /// the performance of repeated calls to specific geometric operations.
+    namespace prep {}
+
+    /// \brief
+    /// Provides classes that parse and modify Geometry objects.
+    namespace util {}
+} // namespace geos.geom
+
+/// \brief
+/// Contains classes that implement topology graphs.
+///
+/// The Java Topology Suite (JTS) is a Java API that implements a core set of
+/// spatial data operations using an explicit precision model and robust
+/// geometric algorithms. JTS is int ended to be used in the development of
+/// applications that support the validation, cleaning, integration and
+/// querying of spatial datasets.
+///
+/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
+/// as accurately as possible.  In some cases the SFS is unclear or omits a
+/// specification; in this case JTS attempts to choose a reasonable and
+/// consistent alternative.  Differences from and elaborations of the SFS are
+/// documented in this specification.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///   OpenGIS Simple Features Specification for SQL</A>
+namespace geomgraph { // geos.geomgraph
+
+    /// \brief
+    /// Contains classes that implement indexes for performing noding on
+    /// geometry graph edges.
+    namespace index {}
+} // namespace geos.geomgraph
+
+
+/// Provides classes for various kinds of spatial indexes.
+namespace index { // geos.index
+
+    /// Contains classes that implement a Binary Interval Tree index
+    namespace bintree {}
+
+    /// Contains classes that implement Monotone Chains
+    namespace chain {}
+
+    /// \brief Contains classes that implement a static index on a set of
+    /// 1-dimensional intervals, using an R-Tree packed based on the order of
+    /// the interval midpoints.
+    namespace intervalrtree {}
+
+    /// Contains classes that implement a Quadtree spatial index
+    namespace quadtree {}
+
+    /// \brief Contains 2-D and 1-D versions of the Sort-Tile-Recursive (STR)
+    /// tree, a query-only R-tree.
+    namespace strtree {}
+
+    /// \brief Contains classes which implement a sweepline algorithm for
+    /// scanning geometric data structures.
+    namespace sweepline {}
+} // namespace geos.index
+
+/// \brief
+/// Contains the interfaces for converting JTS objects to and from other
+/// formats.
+///
+/// The Java Topology Suite (JTS) is a Java API that implements a core set of
+/// spatial data operations using an explicit precision model and robust
+/// geometric algorithms. JTS is intended to be used in the devel opment of
+/// applications that support the validation, cleaning, integration and
+/// querying of spatial data sets.
+///
+/// JTS attempts to implement the OpenGIS Simple Features Specification (SFS)
+/// as accurately as possible.  In some cases the SFS is unclear or omits a
+/// specification; in this case JTS attempts to choose a reasonable and
+/// consistent alternative.  Differences from and elaborations of the SFS are
+/// documented in this specification.
+///
+/// ### Package Specification
+///
+/// - Java Topology Suite Technical Specifications
+/// - <A HREF="http://www.opengis.org/techno/specs.htm">
+///   OpenGIS Simple Features Specification for SQL</A>
+///
+namespace io {}
+
+/// \brief Contains classes and interfaces implementing linear referencing on
+/// linear geometries.
+namespace linearref {}
+
+/// \brief Classes to compute nodings for arrangements of line segments and
+/// line segment sequences.
+namespace noding { // geos.noding
+
+    /// \brief Contains classes to implement the Snap Rounding algorithm for
+    /// noding linestrings.
+    namespace snapround {}
+} // namespace geos.noding
+
+/// Provides classes for implementing operations on geometries.
+namespace operation { // geos.operation
+
+    /// Provides classes for computing buffers of geometries
+    namespace buffer {}
+
+    /// Provides classes for computing the distance between geometries.
+    namespace distance {}
+
+    /// \brief Provides classes for computing the intersection of a Geometry
+    /// and a clipping Rectangle.
+    namespace intersection {}
+
+    /// Line merging package.
+    namespace linemerge {}
+
+    /// \brief
+    /// Contains classes that perform a topological overlay to compute boolean
+    /// spatial functions.
+    ///
+    /// The Overlay Algorithm is used in spatial analysis methods for computing
+    /// set-theoretic operations (boolean combinations) of input
+    /// [Geometrys](\ref geom::Geometry).
+    /// The algorithm for computing the overlay uses the intersection operations
+    /// supported by topology graphs. To compute an overlay it is necessary to
+    /// explicitly compute the resultant graph formed by the computed
+    /// intersections.
+    ///
+    /// The algorithm to compute a set-theoretic spatial analysis method has the
+    /// following steps:
+    ///
+    /// - Build topology graphs of the two input geometries. For each geometry
+    ///   all self-intersection nodes are computed and added to the graph.
+    /// - Compute nodes for all intersections between edges and nodes of the
+    ///   graphs.
+    /// - Compute the labeling for the computed nodes by merging the labels from
+    ///   the input graphs.
+    /// - Compute new edges between the compute intersection nodes.
+    ///   Label the edges appropriately.
+    /// - Build the resultant graph from the new nodes and edges.
+    /// - Compute the labeling for isolated components of the graph. Add the
+    ///   isolated components to the resultant graph.
+    /// - Compute the result of the boolean combination by selecting the node
+    ///   and edges with the appropriate labels. Polygonize areas and sew linear
+    ///   geometries together.
+    ///
+    /// ### Package Specification
+    ///
+    /// - Java Topology Suite Technical Specifications
+    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
+    ///   OpenGIS Simple Features Specification for SQL</A>
+    namespace overlay {}
+
+    /// An API for polygonizing sets of lines.
+    namespace polygonize {}
+
+    /// \brief Classes which implement topological predicates optimized for
+    /// particular kinds of geometries.
+    namespace predicate {}
+
+    /// \brief Contains classes to implement the computation of the spatial
+    /// relationships of `Geometry`s.
+    ///
+    /// The `relate` algorithm computes the `IntersectionMatrix` describing the
+    /// relationship of two `Geometry`s. The algorithm for computing `relate`
+    /// uses the intersection operations supported by topology graphs. Although
+    /// the `relate` result depends on the resultant graph formed by the
+    /// computed intersections, there is no need to explicitly compute the
+    /// entire graph. It is sufficient to compute the local structure of the
+    /// graph at each intersection node.
+    ///
+    /// The algorithm to compute `relate` has the following steps:
+    ///
+    /// - Build topology graphs of the two input geometries. For each geometry
+    ///   all self-intersection nodes are computed and added to the graph.
+    /// - Compute nodes for all intersections between edges and nodes of the
+    ///   graphs.
+    /// - Compute the labeling for the computed nodes by merging the labels
+    ///   from the input graphs.
+    /// - Compute the labeling for isolated components of the graph (see below)
+    /// - Compute the `IntersectionMatrix` from the labels on the nodes and
+    ///   edges.
+    ///
+    /// ### Labeling isolated components
+    ///
+    /// Isolated components are components (edges or nodes) of an input
+    /// `Geometry` which do not contain any intersections with the other input
+    /// `Geometry`. The topological relationship of these components to the
+    /// other input `Geometry` must be computed in order to determine the
+    /// complete labeling of the component. This can be done by testing whether
+    /// the component lies in the interior or exterior of the other `Geometry`.
+    /// If the other `Geometry` is 1-dimensional, the isolated component must
+    /// lie in the exterior (since otherwise it would have an intersection with
+    /// an edge of the `Geometry`). If the other `Geometry` is 2-dimensional,
+    /// a Point-In-Polygon test can be used to determine whether the isolated
+    /// component is in the interior or exterior.
+    ///
+    /// ### Package Specification
+    ///
+    /// - Java Topology Suite Technical Specifications
+    /// - <A HREF="http://www.opengis.org/techno/specs.htm">
+    ///    OpenGIS Simple Features Specification for SQL</A>
+    namespace relate {}
+
+    /// Find shared paths among two linear Geometry objects.
+    namespace sharedpaths {}
+
+    /// Classes to perform efficient unioning of collections of geometries.
+    namespace geounion {}
+
+    /// Provides classes for testing the validity of geometries.
+    namespace valid {}
+} // namespace geos.operation
+
+/// Contains classes to implement a planar graph data structure.
+namespace planargraph { // geos::planargraph
+
+    /// Planargraph algorithms.
+    namespace algorithm {}
+} // namespace geos::planargraph
+
+/// Provides classes for manipulating the precision model of Geometries.
+namespace precision {}
+
+/// Classes which implement algorithms for simplifying or generalizing geometries.
+namespace simplify {}
+
+/// Classes to compute Delaunay triangulations.
+namespace triangulate { // geos.triangulate
+
+    /// \brief Classes to implement a topological subdivision of quadeges, to
+    /// support creating triangulations and Voronoi diagrams.
+    namespace quadedge {}
+} // namespace geos.triangulate
+
+/// Utility classes for GEOS.
+namespace util {}
+
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/BasicSegmentString.h

@@ -0,0 +1,89 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009 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: noding/BasicSegmentString.java rev. 1.1 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/noding/BasicSegmentString.h>
+#include <geos/noding/Octant.h>
+#include <geos/noding/SegmentString.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // for inlines (size())
+
+
+#include <vector>
+
+// Forward declarations
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Represents a list of contiguous line segments, and supports noding the segments.
+ *
+ * The line segments are represented by an array of [Coordinates](@ref geom::Coordinate).
+ * Intended to optimize the noding of contiguous segments by reducing the number
+ * of allocated objects. SegmentStrings can carry a context object, which is
+ * useful for preserving topological or parentage information.
+ * All noded substrings are initialized with the same context object.
+ */
+class GEOS_DLL BasicSegmentString : public SegmentString {
+
+public:
+
+    /// \brief Construct a BasicSegmentString.
+    ///
+    /// @param newPts CoordinateSequence representing the string, externally owned
+    /// @param newContext the context associated to this SegmentString
+    ///
+    BasicSegmentString(geom::CoordinateSequence* newPts,
+                       const void* newContext)
+        :
+        SegmentString(newContext, newPts)
+    {}
+
+    ~BasicSegmentString() override
+    {}
+
+    // see dox in SegmentString.h
+    std::ostream& print(std::ostream& os) const override;
+
+    /** \brief
+     * Gets the octant of the segment starting at vertex index.
+     *
+     * @param index the index of the vertex starting the segment.
+     *        Must not be the last index in the vertex list
+     * @return the octant of the segment at the vertex
+     */
+    int getSegmentOctant(std::size_t index) const
+    {
+        if(index >= size() - 1) {
+            return -1;
+        }
+        return Octant::octant(getCoordinate(index), getCoordinate(index + 1));
+    };
+
+private:
+
+    // Declare type as noncopyable
+    BasicSegmentString(const BasicSegmentString& other) = delete;
+    BasicSegmentString& operator=(const BasicSegmentString& rhs) = delete;
+
+};
+
+} // namespace geos.noding
+} // namespace geos