@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/HCoordinate.h

@@ -1,100 +0,0 @@
-/**********************************************************************
- *
- * 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 homogeneous 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/InteriorPointArea.h

@@ -1,110 +0,0 @@
-/**********************************************************************
- *
- * 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/InteriorPointLine.h

@@ -1,79 +0,0 @@
-/**********************************************************************
- *
- * 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/InteriorPointPoint.h

@@ -1,73 +0,0 @@
-/**********************************************************************
- *
- * 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/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/Interpolate.h

@@ -1,182 +0,0 @@
-/**********************************************************************
- *
- * 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);
-    }
-
-};
-
-}
-}

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/Intersection.h

@@ -1,84 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2019 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.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.h>
-
-namespace geos {
-namespace algorithm {
-
-
-/** \brief
- * Functions to compute intersection points between lines and line segments.
- *
- * In general it is not possible to compute
- * the intersection point of two lines exactly, due to numerical roundoff.
- * This is particularly true when the lines are nearly parallel.
- * These routines uses numerical conditioning on the input values
- * to ensure that the computed value is very close to the correct value.
- *
- * The Z-ordinate is ignored, and not populated.
- */
-class GEOS_DLL Intersection {
-
-public:
-
-/** \brief
- * Computes the intersection point of two lines.
- * If the lines are parallel or collinear this case is detected
- * and <code>null</code> is returned.
- *
- * @param p1 an endpoint of line 1
- * @param p2 an endpoint of line 1
- * @param q1 an endpoint of line 2
- * @param q2 an endpoint of line 2
- * @return the intersection point between the lines, if there is one,
- * or null if the lines are parallel or collinear
- *
- * @see CGAlgorithmsDD#intersection(Coordinate, Coordinate, Coordinate, Coordinate)
- */
-static geom::CoordinateXY intersection(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
-                                       const geom::CoordinateXY& q1, const geom::CoordinateXY& q2);
-
-/**
-* Computes the intersection point of a line and a line segment (if any).
-* There will be no intersection point if:
-*
-*  * the segment does not intersect the line
-*  * the line or the segment are degenerate (have zero length)
-*
-* If the segment is collinear with the line the first segment endpoint is returned.
-*
-* @param line1 a point on the line
-* @param line2 a point on the line
-* @param seg1 an endpoint of the line segment
-* @param seg2 an endpoint of the line segment
-* @return the intersection point, or null if it is not possible to find an intersection
-*/
-static geom::CoordinateXY intersectionLineSegment(
-    const geom::CoordinateXY& line1,
-    const geom::CoordinateXY& line2,
-    const geom::CoordinateXY& seg1,
-    const geom::CoordinateXY& seg2);
-
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/algorithm/Length.h

@@ -1,50 +0,0 @@
-/**********************************************************************
- *
- * 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/Length.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 for computing length.
- *
- * @author Martin Davis
- */
-class GEOS_DLL Length {
-public:
-
-    /**
-     * Computes the length of a linestring specified by a sequence of points.
-     *
-     * @param ring the points specifying the linestring
-     * @return the length of the linestring
-     */
-    static double ofLine(const geom::CoordinateSequence* ring);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-
-