@crossbind/port-geos-ios 2.0.0-beta.50

package/dist/prebuilt/ios-iphonesimulator-mt-release/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
+

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/algorithm/CGAlgorithmsDD.h

@@ -0,0 +1,170 @@
+/**********************************************************************
+ *
+ * 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>
+#include <cmath>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class CoordinateXY;
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/// Implements basic computational geometry algorithms using extended precision float-point arithmetic.
+class GEOS_DLL CGAlgorithmsDD {
+    using DD = geos::math::DD;
+
+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.
+     *
+     * 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.
+     *
+     * Jonathan Shewchuk
+     * Robust Adaptive Floating-Point Geometric Predicates
+     * Proceedings of the Twelfth Annual Symposium on Computational Geometry, ACM,
+     * May 1996
+     *
+     * Ozaki, K., Bünger, F., Ogita, T. et al.
+     * Simple floating-point filters for the two-dimensional orientation problem.
+     * BitNumer Math 56, 729–749 (2016).
+     * https://doi.org/10.1007/s10543-015-0574-9
+     *
+     */
+    static inline int orientationIndexFilter(
+        double pax, double pay,
+        double pbx, double pby,
+        double pcx, double pcy)
+    {
+        double const detleft = (pax - pcx) * (pby - pcy);
+        double const detright = (pay - pcy) * (pbx - pcx);
+        double const det = detleft - detright;
+        // Coefficient as per Ozaki et al
+        double const error = std::abs(detleft + detright)
+                             * 3.3306690621773724e-16;
+        if (std::abs(det) >= error)
+            return (det > 0) - (det < 0);
+        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

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/algorithm/CentralEndpointIntersector.h

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 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.
+ *
+ **********************************************************************
+ *
+ * Last port: algorithm/CentralEndpointIntersector.java rev. 1.1
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+#include <string>
+#include <limits>
+
+#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 PrecisionModel;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes an approximate intersection of two line segments
+ * by taking the most central of the endpoints of the segments.
+ *
+ * This is effective in cases where the segments are nearly parallel
+ * and should intersect at an endpoint.
+ * It is also a reasonable strategy for cases where the
+ * endpoint of one segment lies on or almost on the interior of another one.
+ * Taking the most central endpoint ensures that the computed intersection
+ * point lies in the envelope of the segments.
+ * Also, by always returning one of the input points, this should result
+ * in reducing segment fragmentation.
+ * Intended to be used as a last resort for
+ * computing ill-conditioned intersection situations which
+ * cause other methods to fail.
+ *
+ * @author Martin Davis
+ * @version 1.8
+ */
+class GEOS_DLL CentralEndpointIntersector {
+
+public:
+
+    static const geom::Coordinate&
+    getIntersection(const geom::Coordinate& p00,
+                    const geom::Coordinate& p01, const geom::Coordinate& p10,
+                    const geom::Coordinate& p11)
+    {
+        CentralEndpointIntersector intor(p00, p01, p10, p11);
+        return intor.getIntersection();
+    }
+
+    CentralEndpointIntersector(const geom::Coordinate& p00,
+                               const geom::Coordinate& p01,
+                               const geom::Coordinate& p10,
+                               const geom::Coordinate& p11)
+        :
+        _pts(4)
+    {
+        _pts[0] = p00;
+        _pts[1] = p01;
+        _pts[2] = p10;
+        _pts[3] = p11;
+        compute();
+    }
+
+    const geom::Coordinate&
+    getIntersection() const
+    {
+        return _intPt;
+    }
+
+
+private:
+
+    // This is likely overkill.. we'll be allocating heap
+    // memory at every call !
+    std::vector<geom::Coordinate> _pts;
+
+    geom::Coordinate _intPt;
+
+    void
+    compute()
+    {
+        geom::Coordinate centroid = average(_pts);
+        _intPt = findNearestPoint(centroid, _pts);
+    }
+
+    static geom::Coordinate
+    average(
+        const std::vector<geom::Coordinate>& pts)
+    {
+        geom::Coordinate avg(0, 0);
+        std::size_t n = pts.size();
+        if(! n) {
+            return avg;
+        }
+        for(std::size_t i = 0; i < n; ++i) {
+            avg.x += pts[i].x;
+            avg.y += pts[i].y;
+        }
+        avg.x /= n;
+        avg.y /= n;
+        return avg;
+    }
+
+    /**
+     * Determines a point closest to the given point.
+     *
+     * @param p the point to compare against
+     * @param p1 a potential result point
+     * @param p2 a potential result point
+     * @param q1 a potential result point
+     * @param q2 a potential result point
+     * @return the point closest to the input point p
+     */
+    geom::Coordinate
+    findNearestPoint(const geom::Coordinate& p,
+                     const std::vector<geom::Coordinate>& pts) const
+    {
+        double minDistSq = DoubleInfinity;
+        geom::Coordinate result = geom::Coordinate::getNull();
+        for(std::size_t i = 0, n = pts.size(); i < n; ++i) {
+            double distSq = p.distanceSquared(pts[i]);
+            if(distSq < minDistSq) {
+                minDistSq = distSq;
+                result = pts[i];
+            }
+        }
+        return result;
+    }
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/algorithm/Centroid.h

@@ -0,0 +1,157 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2013 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/Centroid.java r728 (JTS-0.13+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h> // for composition
+#include <memory> // for std::unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Polygon;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the centroid of a [Geometry](@ref geom::Geometry) of any dimension.
+ *
+ * If the geometry is nomimally of higher dimension, but contains only
+ * components having a lower effective dimension (i.e. zero length or area),
+ * the centroid will be computed appropriately.
+ *
+ * ### Algorithm #
+ *
+ * - **Dimension = 2** - Based on the usual algorithm for calculating
+ *     the centroid as a weighted sum of the centroids
+ *     of a decomposition of the area into (possibly overlapping) triangles.
+ *     The algorithm has been extended to handle holes and multi-polygons.
+ *     See http://www.faqs.org/faqs/graphics/algorithms-faq/
+ *     for further details of the basic approach.
+ * - **Dimension = 1** - Computes the average of the midpoints
+ *     of all line segments weighted by the segment length.
+ * - **Dimension = 0** - Compute the average coordinate over all points.
+ *
+ * If the input geometries are empty, a `null` Coordinate is returned.
+ *
+ */
+class GEOS_DLL Centroid {
+
+public:
+
+    /** \brief
+     * Computes the centroid point of a geometry.
+     *
+     * @param geom the geometry to use
+     * @param cent will be set to the centroid point, if any
+     *
+     * @return `true` if a centroid could be computed,
+     *         `false` otherwise (empty geom)
+     */
+    static bool getCentroid(const geom::Geometry& geom, geom::CoordinateXY& cent);
+
+    /** \brief
+     * Creates a new instance for computing the centroid of a geometry
+     */
+    Centroid(const geom::Geometry& geom)
+        :
+        areasum2(0.0),
+        totalLength(0.0),
+        ptCount(0)
+    {
+        add(geom);
+    }
+
+    /** \brief
+     * Gets the computed centroid.
+     *
+     * @param cent will be set to the centroid point, if any
+     *
+     * @return `true` if a centroid could be computed,
+     *         `false` otherwise (empty geom)
+     */
+    bool getCentroid(geom::CoordinateXY& cent) const;
+
+private:
+
+    std::unique_ptr<geom::CoordinateXY> areaBasePt;
+    geom::CoordinateXY triangleCent3;
+    geom::CoordinateXY cg3;
+    geom::CoordinateXY lineCentSum;
+    geom::CoordinateXY ptCentSum;
+    double areasum2;
+    double totalLength;
+    int ptCount;
+
+    /**
+     * Adds a Geometry to the centroid total.
+     *
+     * @param geom the geometry to add
+     */
+    void add(const geom::Geometry& geom);
+
+    void setAreaBasePoint(const geom::CoordinateXY& basePt);
+
+    void add(const geom::Polygon& poly);
+
+    void addShell(const geom::CoordinateSequence& pts);
+
+    void addHole(const geom::CoordinateSequence& pts);
+
+    void addTriangle(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                     bool isPositiveArea);
+
+    /**
+     * Computes three times the centroid of the triangle p1-p2-p3.
+     * The factor of 3 is
+     * left in to permit division to be avoided until later.
+     */
+    static void centroid3(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2, const geom::CoordinateXY& p3,
+                          geom::CoordinateXY& c);
+
+    /**
+     * Returns twice the signed area of the triangle p1-p2-p3.
+     * The area is positive if the triangle is oriented CCW, and negative if CW.
+     */
+    static double area2(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2, const geom::CoordinateXY& p3);
+
+    /**
+     * Adds the line segments defined by an array of coordinates
+     * to the linear centroid accumulators.
+     *
+     * @param pts an array of {@link Coordinate}s
+     */
+    void addLineSegments(const geom::CoordinateSequence& pts);
+
+    /**
+     * Adds a point to the point centroid accumulator.
+     * @param pt a {@link Coordinate}
+     */
+    void addPoint(const geom::CoordinateXY& pt);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/ios-iphonesimulator-mt-release/include/geos/algorithm/CircularArcs.h

@@ -0,0 +1,37 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2024 ISciences, LLC
+ *
+ * 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/Coordinate.h>
+#include <geos/geom/Envelope.h>
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL CircularArcs {
+public:
+
+    /// Return the circle center of an arc defined by three points
+    static geom::CoordinateXY getCenter(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                                        const geom::CoordinateXY& p2);
+
+    /// Expand an envelope to include an arc defined by three points
+    static void expandEnvelope(geom::Envelope& e, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+                               const geom::CoordinateXY& p2);
+};
+
+}
+}