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

package/dist/prebuilt/Android-x86_64/include/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
+
+
+

package/dist/prebuilt/Android-x86_64/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/Android-x86_64/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/Android-x86_64/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);
+};
+
+}
+}