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

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @cpp.js/package-geos
+
+## 1.0.0
+
+### Major Changes
+
+- 🚀 first stable release
+
+## 1.0.0-beta.23
+
+### Patch Changes
+
+- chore: add initial version of CHANGELOGS files

package/README.md

@@ -47,4 +47,4 @@ std::string Native::sample() {
 ## License
 This project includes the precompiled geos library, which is distributed under the [LGPL License](https://github.com/libgeos/geos/blob/main/COPYING).
 
-GEOS Homepage: <https://github.com/libgeos/geos>
+GEOS Homepage: [https://github.com/libgeos/geos](https://github.com/libgeos/geos)

package/dist/prebuilt/Android-x86_64/bin/geos-config

@@ -0,0 +1,79 @@
+#!/bin/sh
+
+prefix=/tmp/cppjs/live/packages/cppjs-package-geos/.cppjs/build/Source-Release/prebuilt/Android-x86_64
+exec_prefix=${prefix}
+includedir=${prefix}/include
+libdir=${exec_prefix}/lib
+
+usage()
+{
+  cat <<EOF
+Usage: geos-config [OPTIONS]
+Options:
+     [--prefix]
+     [--version]
+     [--libs]
+     [--clibs]
+     [--cclibs]
+     [--static-clibs]
+     [--static-cclibs]
+     [--cflags]
+     [--ldflags]
+     [--includes]
+     [--jtsport]
+EOF
+  exit $1
+}
+
+if test $# -eq 0; then
+  usage 1 1>&2
+fi
+
+while test $# -gt 0; do
+  case "$1" in
+    -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+    *) optarg= ;;
+  esac
+  case $1 in
+    --prefix)
+      echo ${prefix}
+      ;;
+    --version)
+      echo 3.13.0
+      ;;
+    --libs)
+      # TODO: make an alias for --clibs
+      # see http://trac.osgeo.org/geos/ticket/497
+      echo -L${libdir} -lgeos
+      ;;
+    --clibs)
+      echo -L${libdir} -lgeos_c
+      ;;
+    --cclibs)
+      echo -L${libdir} -lgeos
+      ;;
+    --static-clibs)
+      echo -L${libdir} -lgeos_c -lgeos -lstdc++ -lm
+      ;;
+    --static-cclibs)
+      echo -L${libdir} -lgeos -lstdc++ -lm
+      ;;
+    --cflags)
+      echo -I${includedir}
+      ;;
+    --ldflags)
+      echo -L${libdir}
+      ;;
+    --includes)
+      echo ${includedir}
+      ;;
+    --jtsport)
+      echo 1.18.0
+      ;;
+    *)
+      usage 1 1>&2
+      ;;
+  esac
+  shift
+done
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/Angle.h

@@ -0,0 +1,247 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009-2011  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: algorithm/Angle.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/Orientation.h> // for constants
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/// Utility functions for working with angles.
+//
+/// Unless otherwise noted, methods in this class express angles in radians.
+///
+class GEOS_DLL Angle {
+public:
+
+    static constexpr double PI_TIMES_2 = 2.0 * MATH_PI;
+    static constexpr double PI_OVER_2 = MATH_PI / 2.0;
+    static constexpr double PI_OVER_4 = MATH_PI / 4.0;
+
+    /// Constant representing counterclockwise orientation
+    static const int COUNTERCLOCKWISE = Orientation::COUNTERCLOCKWISE;
+
+    /// Constant representing clockwise orientation
+    static const int CLOCKWISE = Orientation::CLOCKWISE;
+
+    /// Constant representing no orientation
+    static const int NONE = Orientation::COLLINEAR;
+
+    /// Converts from radians to degrees.
+    ///
+    /// @param radians an angle in radians
+    /// @return the angle in degrees
+    ///
+    static double toDegrees(double radians);
+
+    /// Converts from degrees to radians.
+    ///
+    /// @param angleDegrees an angle in degrees
+    /// @return the angle in radians
+    ///
+    static double toRadians(double angleDegrees);
+
+    /// \brief
+    /// Returns the angle of the vector from p0 to p1,
+    /// relative to the positive X-axis.
+    ///
+    /// The angle is normalized to be in the range [ -Pi, Pi ].
+    ///
+    /// @return the normalized angle (in radians) that p0-p1 makes
+    ///         with the positive x-axis.
+    ///
+    static double angle(const geom::CoordinateXY& p0,
+                        const geom::CoordinateXY& p1);
+
+    /// \brief
+    /// Returns the angle that the vector from (0,0) to p,
+    /// relative to the positive X-axis.
+    //
+    /// The angle is normalized to be in the range ( -Pi, Pi ].
+    ///
+    /// @return the normalized angle (in radians) that p makes
+    ///          with the positive x-axis.
+    ///
+    static double angle(const geom::CoordinateXY& p);
+
+    /// Tests whether the angle between p0-p1-p2 is acute.
+    ///
+    /// An angle is acute if it is less than 90 degrees.
+    ///
+    /// Note: this implementation is not precise (deterministic) for
+    ///       angles very close to 90 degrees.
+    ///
+    /// @param p0 an endpoint of the angle
+    /// @param p1 the base of the angle
+    /// @param p2 the other endpoint of the angle
+    ///
+    static bool isAcute(const geom::CoordinateXY& p0,
+                        const geom::CoordinateXY& p1,
+                        const geom::CoordinateXY& p2);
+
+    /// Tests whether the angle between p0-p1-p2 is obtuse.
+    ///
+    /// An angle is obtuse if it is greater than 90 degrees.
+    ///
+    /// Note: this implementation is not precise (deterministic) for
+    ///       angles very close to 90 degrees.
+    ///
+    /// @param p0 an endpoint of the angle
+    /// @param p1 the base of the angle
+    /// @param p2 the other endpoint of the angle
+    ///
+    static bool isObtuse(const geom::CoordinateXY& p0,
+                         const geom::CoordinateXY& p1,
+                         const geom::CoordinateXY& p2);
+
+    /// Returns the unoriented smallest angle between two vectors.
+    ///
+    /// The computed angle will be in the range [0, Pi).
+    ///
+    /// @param tip1 the tip of one vector
+    /// @param tail the tail of each vector
+    /// @param tip2 the tip of the other vector
+    /// @return the angle between tail-tip1 and tail-tip2
+    ///
+    static double angleBetween(const geom::CoordinateXY& tip1,
+                               const geom::CoordinateXY& tail,
+                               const geom::CoordinateXY& tip2);
+
+    /// Returns the oriented smallest angle between two vectors.
+    ///
+    /// The computed angle will be in the range (-Pi, Pi].
+    /// A positive result corresponds to a counterclockwise rotation
+    /// from v1 to v2;
+    /// a negative result corresponds to a clockwise rotation.
+    ///
+    /// @param tip1 the tip of v1
+    /// @param tail the tail of each vector
+    /// @param tip2 the tip of v2
+    /// @return the angle between v1 and v2, relative to v1
+    ///
+    static double angleBetweenOriented(const geom::CoordinateXY& tip1,
+                                       const geom::CoordinateXY& tail,
+                                       const geom::CoordinateXY& tip2);
+
+    /// Computes the interior angle between two segments of a ring.
+    ///
+    /// The ring is assumed to be oriented in a clockwise direction.
+    /// The computed angle will be in the range [0, 2Pi]
+    ///
+    /// @param p0
+    ///          a point of the ring
+    /// @param p1
+    ///          the next point of the ring
+    /// @param p2
+    ///          the next point of the ring
+    /// @return the interior angle based at <code>p1</code>
+    ///
+    static double interiorAngle(const geom::CoordinateXY& p0,
+                                const geom::CoordinateXY& p1,
+                                const geom::CoordinateXY& p2);
+
+    /// \brief
+    /// Returns whether an angle must turn clockwise or counterclockwise
+    /// to overlap another angle.
+    ///
+    /// @param ang1 an angle (in radians)
+    /// @param ang2 an angle (in radians)
+    /// @return whether a1 must turn CLOCKWISE, COUNTERCLOCKWISE or
+    ///         NONE to overlap a2.
+    ///
+    static int getTurn(double ang1, double ang2);
+
+    /// \brief
+    /// Computes the normalized value of an angle, which is the
+    /// equivalent angle in the range ( -Pi, Pi ].
+    ///
+    /// @param angle the angle to normalize
+    /// @return an equivalent angle in the range (-Pi, Pi]
+    ///
+    static double normalize(double angle);
+
+    /// \brief
+    /// Computes the normalized positive value of an angle,
+    /// which is the equivalent angle in the range [ 0, 2*Pi ).
+    ///
+    /// E.g.:
+    /// - normalizePositive(0.0) = 0.0
+    /// - normalizePositive(-PI) = PI
+    /// - normalizePositive(-2PI) = 0.0
+    /// - normalizePositive(-3PI) = PI
+    /// - normalizePositive(-4PI) = 0
+    /// - normalizePositive(PI) = PI
+    /// - normalizePositive(2PI) = 0.0
+    /// - normalizePositive(3PI) = PI
+    /// - normalizePositive(4PI) = 0.0
+    ///
+    /// @param angle the angle to normalize, in radians
+    /// @return an equivalent positive angle
+    ///
+    static double normalizePositive(double angle);
+
+
+    /// Computes the unoriented smallest difference between two angles.
+    ///
+    /// The angles are assumed to be normalized to the range [-Pi, Pi].
+    /// The result will be in the range [0, Pi].
+    ///
+    /// @param ang1 the angle of one vector (in [-Pi, Pi] )
+    /// @param ang2 the angle of the other vector (in range [-Pi, Pi] )
+    /// @return the angle (in radians) between the two vectors
+    ///         (in range [0, Pi] )
+    ///
+    static double diff(double ang1, double ang2);
+
+    /// \brief
+    /// Computes both sin and cos of an angle, snapping near-zero values
+    /// to zero.
+    ///
+    /// The angle does not need to be normalized. Unlike std::sin
+    /// and std::cos, this method will snap near-zero values to zero
+    /// for (e.g.) sin(pi) and cos(pi/2).
+    ///
+    /// @param ang the input angle (in radians)
+    /// @param rSin the result of sin(ang)
+    /// @param rCos the result of cos(ang)
+    ///
+    static inline void sinCosSnap(const double ang, double& rSin, double& rCos) {
+        // calculate both; may be optimized with FSINCOS instruction
+        rSin = std::sin(ang);
+        rCos = std::cos(ang);
+        // snap near-zero values
+        if (std::fabs(rSin) < 5e-16) rSin = 0.0;
+        if (std::fabs(rCos) < 5e-16) rCos = 0.0;
+    }
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/Area.h

@@ -0,0 +1,82 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018 Paul Ramsey <pramsey@cleverlephant.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.
+ *
+ **********************************************************************
+ *
+ * Last port: algorithm/Area.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+
+namespace geom {
+class Curve;
+}
+
+namespace algorithm { // geos::algorithm
+
+
+class GEOS_DLL Area {
+public:
+
+    static double ofClosedCurve(const geom::Curve& ring);
+
+    /**
+    * Computes the area for a ring.
+    *
+    * @param ring the coordinates forming the ring
+    * @return the area of the ring
+    */
+    static double ofRing(const std::vector<geom::Coordinate>& ring);
+
+    /**
+    * Computes the area for a ring.
+    *
+    * @param ring the coordinates forming the ring
+    * @return the area of the ring
+    */
+    static double ofRing(const geom::CoordinateSequence* ring);
+
+    /**
+    * Computes the signed area for a ring. The signed area is positive if the
+    * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
+    * ring is degenerate or flat.
+    *
+    * @param ring
+    *          the coordinates forming the ring
+    * @return the signed area of the ring
+    */
+    static double ofRingSigned(const std::vector<geom::Coordinate>& ring);
+
+    /**
+    * Computes the signed area for a ring. The signed area is positive if the
+    * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
+    * ring is degenerate or flat.
+    *
+    * @param ring
+    *          the coordinates forming the ring
+    * @return the signed area of the ring
+    */
+    static double ofRingSigned(const geom::CoordinateSequence* ring);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/BoundaryNodeRule.h

@@ -0,0 +1,146 @@
+/**********************************************************************
+ *
+ * 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: algorithm/BoundaryNodeRule.java rev 1.4 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <string>
+
+#include <geos/export.h>
+
+// Forward declarations
+// ...
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/** \brief
+ * An interface for rules which determine whether node points which are
+ * in boundaries of lineal geometry components
+ * are in the boundary of the parent geometry collection.
+ *
+ * The SFS specifies a single kind of boundary node rule,
+ * the `Mod2BoundaryNodeRule` rule.
+ * However, other kinds of Boundary Node Rules are appropriate
+ * in specific situations (for instance, linear network topology
+ * usually follows the `EndPointBoundaryNodeRule`.)
+ * Some JTS operations allow the BoundaryNodeRule to be specified,
+ * and respect this rule when computing the results of the operation.
+ *
+ * @author Martin Davis
+ * @version 1.7
+ *
+ * @see operation::relate::RelateOp
+ * @see operation::valid::IsSimpleOp
+ * @see algorithm::PointLocator
+ */
+class GEOS_DLL BoundaryNodeRule {
+
+public:
+
+    // virtual classes should always have a virtual destructor..
+    virtual
+    ~BoundaryNodeRule() {}
+
+    virtual std::string toString() const = 0;
+
+    /** \brief
+     * Tests whether a point that lies in `boundaryCount`
+     * geometry component boundaries is considered to form part of
+     * the boundary of the parent geometry.
+     *
+     * @param boundaryCount the number of component boundaries that
+     *                      this point occurs in
+     * @return `true` if points in this number of boundaries lie in
+     *         the parent boundary
+     */
+    virtual bool isInBoundary(int boundaryCount) const = 0;
+
+    /** \brief
+     * The Mod-2 Boundary Node Rule (which is the rule specified
+     * in the OGC SFS).
+     *
+     * A BoundaryNodeRule specifies that points are in the boundary of
+     * a lineal geometry iff the point lies on the boundary of an odd number
+     * of components. Under this rule LinearRings and closed LineStrings have
+     * an empty boundary.
+     *
+     * This is the rule specified by the OGC SFS, and is the default
+     * rule used in JTS.
+     */
+    //static const BoundaryNodeRule& MOD2_BOUNDARY_RULE;
+    static const BoundaryNodeRule& getBoundaryRuleMod2();
+
+    /** \brief
+     * The Endpoint Boundary Node Rule.
+     *
+     * A BoundaryNodeRule which specifies that any points which are endpoints
+     * of lineal components are in the boundary of the parent geometry. This
+     * corresponds to the "intuitive" topological definition of boundary. Under
+     * this rule LinearRings have a non-empty boundary (the common endpoint
+     * of the underlying LineString).
+     *
+     * This rule is useful when dealing with linear networks. For example,
+     * it can be used to check whether linear networks are correctly noded.
+     * The usual network topology constraint is that linear segments may
+     * touch only at endpoints. In the case of a segment touching a closed
+     * segment (ring) at one point, the Mod2 rule cannot distinguish between
+     * the permitted case of touching at the node point and the invalid case
+     * of touching at some other interior (non-node) point. The EndPoint rule
+     * does distinguish between these cases, so is more appropriate for use.
+     */
+    //static const BoundaryNodeRule& ENDPOINT_BOUNDARY_RULE;
+    static const BoundaryNodeRule& getBoundaryEndPoint();
+
+    /** \brief
+     * The MultiValent Endpoint Boundary Node Rule.
+     *
+     * A BoundaryNodeRule which determines that only endpoints with valency
+     * greater than 1 are on the boundary. This corresponds to the boundary
+     * of a MultiLineString being all the "attached" endpoints, but not
+     * the "unattached" ones.
+     */
+    //static const BoundaryNodeRule& MULTIVALENT_ENDPOINT_BOUNDARY_RULE;
+    static const BoundaryNodeRule& getBoundaryMultivalentEndPoint();
+
+    /** \brief
+     * The Monovalent Endpoint Boundary Node Rule.
+     *
+     * A BoundaryNodeRule which determines that only endpoints with valency of
+     * exactly 1 are on the boundary. This corresponds to the boundary of
+     * a MultiLineString being all the "unattached" endpoints.
+     */
+    //static const BoundaryNodeRule& MONOVALENT_ENDPOINT_BOUNDARY_RULE;
+    static const BoundaryNodeRule& getBoundaryMonovalentEndPoint();
+
+    /** \brief
+     * The Boundary Node Rule specified by the OGC Simple Features
+     * Specification, which is the same as the Mod-2 rule.
+     *
+     * A BoundaryNodeRule which determines that only endpoints with valency
+     * greater than 1 are on the boundary. This corresponds to the boundary
+     * of a MultiLineString being all the "attached" endpoints, but not the
+     * "unattached" ones.
+     */
+    //static const BoundaryNodeRule& OGC_SFS_BOUNDARY_RULE;
+    static const BoundaryNodeRule& getBoundaryOGCSFS();
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+