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

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/Distance.h

@@ -0,0 +1,116 @@
+/**********************************************************************
+ *
+ * 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/Distance.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Functions to compute distance between basic geometric structures.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL Distance {
+public:
+
+    /**
+     * Computes the distance from a line segment AB to a line segment CD
+     *
+     * Note: NON-ROBUST!
+     *
+     * @param A
+     *          a point of one line
+     * @param B
+     *          the second point of (must be different to A)
+     * @param C
+     *          one point of the line
+     * @param D
+     *          another point of the line (must be different to A)
+     */
+    // formerly distanceLineLine
+    static double segmentToSegment(
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B,
+        const geom::CoordinateXY& C,
+        const geom::CoordinateXY& D);
+
+    /**
+    * Computes the distance from a point to a sequence of line segments.
+    *
+    * @param p
+    *          a point
+    * @param seq
+    *          a sequence of contiguous line segments defined by their vertices
+    * @return the minimum distance between the point and the line segments
+    */
+    static double pointToSegmentString(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateSequence* seq);
+
+    /**
+    * Computes the distance from a point p to a line segment AB
+    *
+    * Note: NON-ROBUST!
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line segment AB
+    */
+    // formerly distancePointLine
+    static double pointToSegment(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    /**
+    * Computes the perpendicular distance from a point p to the (infinite) line
+    * containing the points AB
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line AB
+    */
+    // formerly distancePointLinePerpendicular
+    static double pointToLinePerpendicular(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    static double pointToLinePerpendicularSigned(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/HCoordinate.h

@@ -0,0 +1,100 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011      Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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/HCoordinate.java r386 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <iosfwd>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/** \brief
+ * Represents a homogeneous coordinate in a 2-D coordinate space.
+ *
+ * HCoordinate are used as a clean way
+ * of computing intersections between line segments.
+ */
+class GEOS_DLL HCoordinate {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+    /** \brief
+     * Computes the (approximate) intersection point between two line
+     * segments using homogeneous coordinates.
+     *
+     * @note this algorithm is  not numerically stable; i.e. it can
+     * produce intersection points which lie outside the envelope of the
+     * line segments themselves. In order to increase the precision of
+     * the calculation input points should be normalized before
+     * passing them to this routine.
+     */
+    static void intersection(const geom::Coordinate& p1,
+                             const geom::Coordinate& p2,
+                             const geom::Coordinate& q1,
+                             const geom::Coordinate& q2,
+                             geom::Coordinate& ret);
+
+    double x, y, w;
+
+    HCoordinate();
+
+    HCoordinate(double _x, double _y, double _w);
+
+    HCoordinate(const geom::Coordinate& p);
+
+    /** \brief
+     * Constructs a homogeneous coordinate which is the intersection
+     * of the lines define by the homogenous coordinates represented
+     * by two [Coordinates](@ref geom::Coordinate).
+     *
+     * @param p1
+     * @param p2
+     */
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2);
+
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2,
+                const geom::Coordinate& q1, const geom::Coordinate& q2);
+
+    HCoordinate(const HCoordinate& p1, const HCoordinate& p2);
+
+    double getX() const;
+
+    double getY() const;
+
+    void getCoordinate(geom::Coordinate& ret) const;
+
+};
+
+std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/InteriorPointArea.h

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Martin Davis <mtnclimb@gmail.com>
+ *
+ * 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/InteriorPointArea.java (JTS-1.17+)
+ * https://github.com/locationtech/jts/commit/a140ca30cc51be4f65c950a30b0a8f51a6df75ba
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an areal geometry.
+ * The point will lie in the geometry interior
+ * in all except certain pathological cases.
+ *
+ * <h2>Algorithm</h2>
+ * For each input polygon:
+ * <ul>
+ * <li>Determine a horizontal scan line on which the interior
+ * point will be located.
+ * To increase the chance of the scan line
+ * having non-zero-width intersection with the polygon
+ * the scan line Y ordinate is chosen to be near the centre of the polygon's
+ * Y extent but distinct from all of vertex Y ordinates.
+ * <li>Compute the sections of the scan line
+ * which lie in the interior of the polygon.
+ * <li>Choose the widest interior section
+ * and take its midpoint as the interior point.
+ * </ul>
+ * The final interior point is chosen as
+ * the one occurring in the widest interior section.
+ * <p>
+ * This algorithm is a tradeoff between performance
+ * and point quality (where points further from the geometry
+ * boundary are considered to be higher quality)
+ * Priority is given to performance.
+ * This means that the computed interior point
+ * may not be suitable for some uses
+ * (such as label positioning).
+ * <p>
+ * The algorithm handles some kinds of invalid/degenerate geometry,
+ * including zero-area and self-intersecting polygons.
+ * <p>
+ * Empty geometry is handled by returning a <code>null</code> point.
+ *
+ * <h3>KNOWN BUGS</h3>
+ * <ul>
+ * <li>If a fixed precision model is used, in some cases this method may return
+ * a point which does not lie in the interior.
+ * <li>If the input polygon is <i>extremely</i> narrow the computed point
+ * may not lie in the interior of the polygon.
+ * </ul>
+ */
+class GEOS_DLL InteriorPointArea {
+
+public:
+    /**
+     * Creates a new interior point finder
+     * for an areal geometry.
+     *
+     * @param g an areal geometry
+     */
+    InteriorPointArea(const geom::Geometry* g);
+
+    /**
+     * Gets the computed interior point.
+     *
+     * @return the coordinate of an interior point
+     *  or <code>null</code> if the input geometry is empty
+     */
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+    geom::Coordinate interiorPoint;
+    double maxWidth;
+
+    void process(const geom::Geometry* geom);
+
+    void processPolygon(const geom::Polygon* polygon);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/InteriorPointLine.h

@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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/InteriorPointLine.java r317 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an linear geometry.
+ *
+ * <h2>Algorithm</h2>
+ *
+ * - Find an interior vertex which is closest to
+ *   the centroid of the linestring.
+ * - If there is no interior vertex, find the endpoint which is
+ *   closest to the centroid.
+ */
+class GEOS_DLL InteriorPointLine {
+public:
+
+    InteriorPointLine(const geom::Geometry* g);
+    //Coordinate* getInteriorPoint() const;
+
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+
+    bool hasInterior;
+
+    geom::Coordinate centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    void addInterior(const geom::Geometry* geom);
+
+    void addInterior(const geom::CoordinateSequence* pts);
+
+    void addEndpoints(const geom::Geometry* geom);
+
+    void addEndpoints(const geom::CoordinateSequence* pts);
+
+    void add(const geom::Coordinate& point);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/InteriorPointPoint.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class InteriorPointPoint
+ * \brief
+ * Computes a point in the interior of an point geometry.
+ *
+ * Algorithm:
+ *
+ * Find a point which is closest to the centroid of the geometry.
+ */
+class GEOS_DLL InteriorPointPoint {
+private:
+
+    bool hasInterior;
+
+    geom::CoordinateXY centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    /**
+     * Tests the point(s) defined by a Geometry for the best inside point.
+     * If a Geometry is not of dimension 0 it is not tested.
+     * @param geom the geometry to add
+     */
+    void add(const geom::Geometry* geom);
+
+    void add(const geom::CoordinateXY* point);
+
+public:
+
+    InteriorPointPoint(const geom::Geometry* g);
+
+    ~InteriorPointPoint() {}
+
+    bool getInteriorPoint(geom::CoordinateXY& ret) const;
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+

package/dist/prebuilt/iOS-iphoneos/include/geos/algorithm/Interpolate.h

@@ -0,0 +1,182 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Vivid Solutions Inc.
+ * Copyright (C) 2023 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 <cmath>
+
+namespace geos {
+namespace algorithm {
+
+class GEOS_DLL Interpolate {
+
+private:
+
+    template<geom::Ordinate Ord, typename CoordType>
+    static double
+    interpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        double p1z = p1.template get<Ord>();
+        double p2z = p2.template get<Ord>();
+
+        if (std::isnan(p1z)) {
+            return p2z; // may be NaN
+        }
+        if (std::isnan(p2z)) {
+            return p1z; // may be NaN
+        }
+        if (p.equals2D(p1)) {
+            return p1z; // not NaN
+        }
+        if (p.equals2D(p2)) {
+            return p2z; // not NaN
+        }
+        double dz = p2z - p1z;
+        if (dz == 0.0) {
+            return p1z;
+        }
+
+        // interpolate Z from distance of p along p1-p2
+        double dx = (p2.x - p1.x);
+        double dy = (p2.y - p1.y);
+        // seg has non-zero length since p1 < p < p2
+        double seglen = (dx * dx + dy * dy);
+        double xoff = (p.x - p1.x);
+        double yoff = (p.y - p1.y);
+        double plen = (xoff * xoff + yoff * yoff);
+        double frac = std::sqrt(plen / seglen);
+        double zoff = dz * frac;
+        double zInterpolated = p1z + zoff;
+
+        return zInterpolated;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    interpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        double zp = interpolate<Ord>(p, p1, p2);
+        double zq = interpolate<Ord>(p, q1, q2);
+
+        if (std::isnan(zp)) {
+          return zq; // may be NaN
+        }
+        if (std::isnan(zq)) {
+          return zp; // may be NaN
+        }
+
+        return (zp + zq) / 2.0;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    get(const C1& p, const C2& q)
+    {
+        double a = p.template get<Ord>();
+        double b = q.template get<Ord>();
+        if (std::isnan(a)) {
+            return b;
+        }
+        return a;
+    }
+
+    template<geom::Ordinate Ord, typename C1, typename C2>
+    static double
+    getOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        double z = p.template get<Ord>();
+        if (!std::isnan(z)) return z;
+        return interpolate<Ord>(p, p1, p2);
+    }
+
+    static double
+    interpolate(const geom::CoordinateXY& p, const geom::CoordinateXY& p1, const geom::CoordinateXY& p2)
+    {
+        (void) p; (void) p1; (void) p2;
+        return DoubleNotANumber;
+    }
+
+public:
+    /// Interpolate a Z value for a coordinate from two other coordinates.
+    template<typename CoordType>
+    static double
+    zInterpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        return interpolate<geom::Ordinate::Z>(p, p1, p2);
+    }
+
+    /// Calculate an average interpolated Z value from two pairs of other coordinates.
+    template<typename C1, typename C2>
+    static double
+    zInterpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        return interpolate<geom::Ordinate::Z>(p, p1, p2, q1, q2);
+    }
+
+    /// Interpolate an M value for a coordinate from two other coordinates.
+    template<typename CoordType>
+    static double
+    mInterpolate(const geom::CoordinateXY& p, const CoordType& p1, const CoordType& p2)
+    {
+        return interpolate<geom::Ordinate::M>(p, p1, p2);
+    }
+
+    /// Calculate an average interpolated M value from two pairs of other coordinates.
+    template<typename C1, typename C2>
+    static double
+    mInterpolate(const geom::CoordinateXY& p, const C1& p1, const C1& p2, const C2& q1, const C2& q2)
+    {
+        return interpolate<geom::Ordinate::M>(p, p1, p2, q1, q2);
+    }
+
+    /// Return the first non-NaN Z value from two coordinates, or NaN if both values are NaN.
+    template<typename C1, typename C2>
+    static double
+    zGet(const C1& p, const C2& q)
+    {
+        return get<geom::Ordinate::Z>(p, q);
+    }
+
+    /// Return the first non-NaN M value from two coordinates, or NaN if both values are NaN.
+    template<typename C1, typename C2>
+    static double
+    mGet(const C1& p, const C2& q)
+    {
+        return get<geom::Ordinate::M>(p, q);
+    }
+
+    /// Return a coordinates's non-NaN Z value or interpolate it from two other coordinates if it is NaN.
+    template<typename C1, typename C2>
+    static double
+    zGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        return getOrInterpolate<geom::Ordinate::Z>(p, p1, p2);
+    }
+
+    /// Return a coordinates's non-NaN M value or interpolate it from two other coordinates if it is NaN.
+    template<typename C1, typename C2>
+    static double
+    mGetOrInterpolate(const C1& p, const C2& p1, const C2& p2)
+    {
+        return getOrInterpolate<geom::Ordinate::M>(p, p1, p2);
+    }
+
+};
+
+}
+}