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

package/geos_c.xcframework/ios-arm64_arm64e/Headers/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/geos_c.xcframework/ios-arm64_arm64e/Headers/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/geos_c.xcframework/ios-arm64_arm64e/Headers/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
+

package/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/algorithm/CGAlgorithmsDD.h

@@ -0,0 +1,193 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2014 Mateusz Loskot <mateusz@loskot.net>
+ *
+ * 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/CGAlgorithmsDD.java r789 (JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/math/DD.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+class CoordinateSequence;
+}
+}
+
+using namespace geos::math;
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/// Implements basic computational geometry algorithms using extended precision float-point arithmetic.
+class GEOS_DLL CGAlgorithmsDD {
+
+public:
+
+    enum {
+        CLOCKWISE = -1,
+        COLLINEAR = 0,
+        COUNTERCLOCKWISE = 1
+    };
+
+    enum {
+        RIGHT = -1,
+        LEFT = 1,
+        STRAIGHT = 0,
+        FAILURE = 2
+    };
+
+    /** \brief
+     * Returns the index of the direction of the point `q` relative to
+     * a vector specified by `p1-p2`.
+     *
+     * @param p1 the origin point of the vector
+     * @param p2 the final point of the vector
+     * @param q the point to compute the direction to
+     *
+     * @return 1 if q is counter-clockwise (left) from p1-p2
+     * @return -1 if q is clockwise (right) from p1-p2
+     * @return 0 if q is collinear with p1-p2
+     */
+    static int orientationIndex(const geom::CoordinateXY& p1,
+                                const geom::CoordinateXY& p2,
+                                const geom::CoordinateXY& q);
+
+
+    static int orientationIndex(double p1x, double p1y,
+                                double p2x, double p2y,
+                                double qx,  double qy);
+
+    /**
+     * A filter for computing the orientation index of three coordinates.
+     *
+     * If the orientation can be computed safely using standard DP arithmetic,
+     * this routine returns the orientation index. Otherwise, a value `i > 1` is
+     * returned. In this case the orientation index must be computed using some
+     * other more robust method.
+     *
+     * The filter is fast to compute, so can be used to avoid the use of slower
+     * robust methods except when they are really needed, thus providing better
+     * average performance.
+     *
+     * Uses an approach due to Jonathan Shewchuk, which is in the public domain.
+     */
+    static inline int orientationIndexFilter(
+        double pax, double pay,
+        double pbx, double pby,
+        double pcx, double pcy)
+    {
+        /**
+         * A value which is safely greater than the relative round-off
+         * error in double-precision numbers
+         */
+        double constexpr DP_SAFE_EPSILON =  1e-15;
+
+        double detsum;
+        double const detleft = (pax - pcx) * (pby - pcy);
+        double const detright = (pay - pcy) * (pbx - pcx);
+        double const det = detleft - detright;
+
+        if(detleft > 0.0) {
+            if(detright <= 0.0) {
+                return orientation(det);
+            }
+            else {
+                detsum = detleft + detright;
+            }
+        }
+        else if(detleft < 0.0) {
+            if(detright >= 0.0) {
+                return orientation(det);
+            }
+            else {
+                detsum = -detleft - detright;
+            }
+        }
+        else {
+            return orientation(det);
+        }
+
+        double const errbound = DP_SAFE_EPSILON * detsum;
+        if((det >= errbound) || (-det >= errbound)) {
+            return orientation(det);
+        }
+        return CGAlgorithmsDD::FAILURE;
+    };
+
+    static int
+    orientation(double x)
+    {
+        if(x < 0) {
+            return CGAlgorithmsDD::RIGHT;
+        }
+        if(x > 0) {
+            return CGAlgorithmsDD::LEFT;
+        }
+        return CGAlgorithmsDD::STRAIGHT;
+    };
+
+    /**
+     * If the lines are parallel (either identical
+     * or separate) a null value is returned.
+     * @param p1 an endpoint of line segment 1
+     * @param p2 an endpoint of line segment 1
+     * @param q1 an endpoint of line segment 2
+     * @param q2 an endpoint of line segment 2
+     * @return an intersection point if one exists, or null if the lines are parallel
+     */
+    static geom::CoordinateXY intersection(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                                           const geom::CoordinateXY& q1, const geom::CoordinateXY& q2);
+
+    static int signOfDet2x2(double dx1, double dy1, double dx2, double dy2);
+
+    static DD detDD(double x1, double y1, double x2, double y2);
+    static DD detDD(const DD& x1, const DD& y1, const DD& x2, const DD& y2);
+
+    /** \brief
+     * Computes the circumcentre of a triangle.
+     *
+     * The circumcentre is the centre of the circumcircle, the smallest circle
+     * which encloses the triangle. It is also the common intersection point of
+     * the perpendicular bisectors of the sides of the triangle, and is the only
+     * point which has equal distance to all three vertices of the triangle.
+     *
+     * The circumcentre does not necessarily lie within the triangle. For example,
+     * the circumcentre of an obtuse isosceles triangle lies outside the triangle.
+     *
+     * This method uses @ref geos::math::DD extended-precision arithmetic to provide more accurate
+     * results than geos::geom::Triangle::circumcentre.
+     *
+     * @param a a vertex of the triangle
+     * @param b a vertex of the triangle
+     * @param c a vertex of the triangle
+     * @return the circumcentre of the triangle
+     */
+    static geom::CoordinateXY circumcentreDD(const geom::CoordinateXY& a, const geom::CoordinateXY& b, const geom::CoordinateXY& c);
+
+protected:
+
+    static int signOfDet2x2(const DD& x1, const DD& y1, const DD& x2, const DD& y2);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+
+