@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/MinimumAreaRectangle.h

@@ -1,159 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.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 <vector>
-#include <memory>
-
-// Forward declarations
-namespace geos {
-	namespace geom {
-        class CoordinateSequence;
-        class CoordinateXY;
-        class Geometry;
-        class GeometryFactory;
-        class LineSegment;
-        class LineString;
-        class Polygon;
-	}
-}
-
-using geos::geom::CoordinateSequence;
-using geos::geom::CoordinateXY;
-using geos::geom::Geometry;
-using geos::geom::GeometryFactory;
-using geos::geom::LineSegment;
-using geos::geom::LineString;
-using geos::geom::Polygon;
-
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-
-/**
- * Computes the minimum-area rectangle enclosing a Geometry.
- * Unlike the Envelope, the rectangle may not be axis-parallel.
- *
- * The first step in the algorithm is computing the convex hull of the Geometry.
- * If the input Geometry is known to be convex, a hint can be supplied to
- * avoid this computation.
- *
- * In degenerate cases the minimum enclosing geometry
- * may be a LineString or a Point.
- *
- * The minimum-area enclosing rectangle does not necessarily
- * have the minimum possible width.
- * Use MinimumDiameter to compute this.
- *
- * @see MinimumDiameter
- * @see ConvexHull
- *
- */
-class GEOS_DLL MinimumAreaRectangle {
-
-private:
-
-    // Members
-    const Geometry* m_inputGeom;
-    bool m_isConvex;
-
-    // Methods
-    std::unique_ptr<Geometry> getMinimumRectangle();
-
-    std::unique_ptr<Geometry> computeConvex(const Geometry* convexGeom);
-
-    /**
-    * Computes the minimum-area rectangle for a convex ring of Coordinate.
-    *
-    * This algorithm uses the "dual rotating calipers" technique.
-    * Performance is linear in the number of segments.
-    *
-    * @param ring the convex ring to scan
-    */
-    std::unique_ptr<Polygon> computeConvexRing(const CoordinateSequence* ring);
-
-    std::size_t findFurthestVertex(
-        const CoordinateSequence* pts,
-        const LineSegment& baseSeg,
-        std::size_t startIndex,
-        int orient);
-
-    bool isFurtherOrEqual(double d1, double d2, int orient);
-
-    static double orientedDistance(
-        const LineSegment& seg,
-        const CoordinateXY& p,
-        int orient);
-
-    static std::size_t getNextIndex(
-        const CoordinateSequence* ring,
-        std::size_t index);
-
-    /**
-    * Creates a line of maximum extent from the provided vertices
-    * @param pts the vertices
-    * @param factory the geometry factory
-    * @return the line of maximum extent
-    */
-    static std::unique_ptr<LineString> computeMaximumLine(
-        const CoordinateSequence* pts,
-        const GeometryFactory* factory);
-
-
-public:
-
-    /**
-    * Compute a minimum-area rectangle for a given Geometry.
-    *
-    * @param inputGeom a Geometry
-    */
-    MinimumAreaRectangle(const Geometry* inputGeom)
-        : m_inputGeom(inputGeom)
-        , m_isConvex(false)
-        {};
-
-    /**
-    * Compute a minimum rectangle for a Geometry,
-    * with a hint if the geometry is convex
-    * (e.g. a convex Polygon or LinearRing,
-    * or a two-point LineString, or a Point).
-    *
-    * @param inputGeom a Geometry which is convex
-    * @param isConvex true if the input geometry is convex
-    */
-    MinimumAreaRectangle(const Geometry* inputGeom, bool isConvex)
-        : m_inputGeom(inputGeom)
-        , m_isConvex(isConvex)
-        {};
-
-    /**
-    * Gets the minimum-area rectangular Polygon which encloses the input geometry.
-    * If the convex hull of the input is degenerate (a line or point)
-    * a LineString or Point is returned.
-    *
-    * @param geom the geometry
-    * @return the minimum rectangle enclosing the geometry
-    */
-    static std::unique_ptr<Geometry> getMinimumRectangle(const Geometry* geom);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,137 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2019 Paul Ramsey <pramsey@cleverelephant.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/MinimumBoundingCircle.java 2019-01-23
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/Point.h>
-#include <geos/geom/Triangle.h>
-
-#include <vector>
-
-// Forward declarations
-// namespace geos {
-// 	namespace geom {
-// 		class GeometryCollection;
-// 	}
-// }
-
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-class GEOS_DLL MinimumBoundingCircle {
-
-private:
-
-    // member variables
-    const geom::Geometry* input;
-    std::vector<geom::CoordinateXY> extremalPts;
-    geom::CoordinateXY centre;
-    double radius;
-
-    void computeCentre();
-    void compute();
-    void computeCirclePoints();
-    geom::CoordinateXY lowestPoint(std::vector<geom::CoordinateXY>& pts);
-    geom::CoordinateXY pointWitMinAngleWithX(std::vector<geom::CoordinateXY>& pts, geom::CoordinateXY& P);
-    geom::CoordinateXY pointWithMinAngleWithSegment(std::vector<geom::CoordinateXY>& pts,
-            geom::CoordinateXY& P, geom::CoordinateXY& Q);
-    std::vector<geom::CoordinateXY> farthestPoints(std::vector<geom::CoordinateXY>& pts);
-
-
-public:
-
-    MinimumBoundingCircle(const geom::Geometry* geom):
-        input(nullptr),
-        radius(0.0)
-    {
-        input = geom;
-        centre.setNull();
-    }
-
-    ~MinimumBoundingCircle() {};
-
-    /**
-    * Gets a geometry which represents the Minimum Bounding Circle.
-    * If the input is degenerate (empty or a single unique point),
-    * this method will return an empty geometry or a single Point geometry.
-    * Otherwise, a Polygon will be returned which approximates the
-    * Minimum Bounding Circle.
-    * (Note that because the computed polygon is only an approximation,
-    * it may not precisely contain all the input points.)
-    *
-    * @return a Geometry representing the Minimum Bounding Circle.
-    */
-    std::unique_ptr<geom::Geometry> getCircle();
-
-    /**
-    * Gets a geometry representing a line between the two farthest points
-    * in the input.
-    * These points will be two of the extremal points of the Minimum Bounding Circle.
-    * They also lie on the convex hull of the input.
-    *
-    * @return a LineString between the two farthest points of the input
-    * @return a empty LineString if the input is empty
-    * @return a Point if the input is a point
-    */
-    std::unique_ptr<geom::Geometry> getMaximumDiameter();
-
-    /**
-    * Gets a geometry representing the diameter of the computed Minimum Bounding
-    * Circle.
-    *
-    * @return the diameter LineString of the Minimum Bounding Circle
-    * @return a empty LineString if the input is empty
-    * @return a Point if the input is a point
-    */
-    std::unique_ptr<geom::Geometry> getDiameter();
-
-    /**
-    * Gets the extremal points which define the computed Minimum Bounding Circle.
-    * There may be zero, one, two or three of these points,
-    * depending on the number of points in the input
-    * and the geometry of those points.
-    *
-    * @return the points defining the Minimum Bounding Circle
-    */
-    std::vector<geom::CoordinateXY> getExtremalPoints();
-
-    /**
-    * Gets the centre point of the computed Minimum Bounding Circle.
-    *
-    * @return the centre point of the Minimum Bounding Circle
-    * @return null if the input is empty
-    */
-    geom::CoordinateXY getCentre();
-
-    /**
-    * Gets the radius of the computed Minimum Bounding Circle.
-    *
-    * @return the radius of the Minimum Bounding Circle
-    */
-    double getRadius();
-
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,185 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
- * 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/geom/Coordinate.h>
-#include <geos/geom/LineSegment.h>
-
-#include <memory>
-#include <geos/export.h>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class GeometryFactory;
-class Geometry;
-class LineString;
-class CoordinateSequence;
-}
-}
-
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/** \brief
- * Computes the minimum diameter of a geom::Geometry
- *
- * The minimum diameter is defined to be the width of the smallest band that
- * contains the geometry, where a band is a strip of the plane defined
- * by two parallel lines. This can be thought of as the smallest hole
- * that the geometry can be moved through, with a single rotation.
- *
- * The first step in the algorithm is computing the convex hull of the Geometry.
- * If the input Geometry is known to be convex, a hint can be supplied to
- * avoid this computation.
- *
- * This class can also be used to compute a line segment representing
- * the minimum diameter, the supporting line segment of the minimum diameter,
- * and a minimum-width rectangle of the input geometry.
- * This rectangle will have width equal to the minimum diameter, and have
- * one side parallel to the supporting segment.
- *
- * In degenerate cases the rectangle may be a LineString or a Point.
- * (Note that this may not be the enclosing rectangle with minimum area;
- * use MinimumAreaRectangle to compute this.)
- *
- * @see ConvexHull
- * @see MinimumAreaRectangle
- */
-class GEOS_DLL MinimumDiameter {
-private:
-    const geom::Geometry* inputGeom;
-    bool isConvex;
-
-    std::unique_ptr<geom::CoordinateSequence> convexHullPts;
-
-    geom::LineSegment minBaseSeg;
-    geom::Coordinate minWidthPt;
-    std::size_t minPtIndex;
-    double minWidth;
-    void computeMinimumDiameter();
-    void computeWidthConvex(const geom::Geometry* geom);
-
-    /**
-     * Compute the width information for a ring of Coordinate.
-     * Leaves the width information in the instance variables.
-     *
-     * @param pts
-     * @return
-     */
-    void computeConvexRingMinDiameter(const geom::CoordinateSequence* pts);
-
-    unsigned int findMaxPerpDistance(const geom::CoordinateSequence* pts,
-                                     const geom::LineSegment* seg, unsigned int startIndex);
-
-    static unsigned int getNextIndex(const geom::CoordinateSequence* pts,
-                                     unsigned int index);
-
-    static double computeC(double a, double b, const geom::Coordinate& p);
-
-    static geom::LineSegment computeSegmentForLine(double a, double b, double c);
-
-    static std::unique_ptr<geom::Geometry> computeMaximumLine(
-                        const geom::CoordinateSequence* pts,
-                        const geom::GeometryFactory* factory);
-
-public:
-    ~MinimumDiameter() = default;
-
-    /** \brief
-     * Compute a minimum diameter for a given [Geometry](@ref geom::Geometry).
-     *
-     * @param newInputGeom a Geometry
-     */
-    MinimumDiameter(const geom::Geometry* newInputGeom);
-
-    /** \brief
-     * Compute a minimum diameter for a given Geometry,
-     * with a hint if the Geometry is convex
-     * (e.g. a convex Polygon or LinearRing,
-     * or a two-point LineString, or a Point).
-     *
-     * @param newInputGeom a Geometry which is convex
-     * @param newIsConvex `true` if the input geometry is convex
-     */
-    MinimumDiameter(const geom::Geometry* newInputGeom,
-                    const bool newIsConvex);
-
-    /** \brief
-     * Gets the length of the minimum diameter of the input Geometry.
-     *
-     * @return the length of the minimum diameter
-     */
-    double getLength();
-
-    /** \brief
-     * Gets the geom::Coordinate forming one end of the minimum diameter.
-     *
-     * @return a coordinate forming one end of the minimum diameter
-     */
-    const geom::Coordinate& getWidthCoordinate();
-
-    /** \brief
-     * Gets the segment forming the base of the minimum diameter.
-     *
-     * @return the segment forming the base of the minimum diameter
-     */
-    std::unique_ptr<geom::LineString> getSupportingSegment();
-
-    /** \brief
-     * Gets a LineString which is a minimum diameter.
-     *
-     * @return a LineString which is a minimum diameter
-     */
-    std::unique_ptr<geom::LineString> getDiameter();
-
-    /** \brief
-     * Gets the rectangular Polygon which encloses the input geometry
-     * and is based on the minimum diameter supporting segment.
-     *
-     * The rectangle has width equal to the minimum diameter, and a longer
-     * length. If the convex hill of the input is degenerate (a line or point)
-     * a LineString or Point is returned.
-     * This is not necessarily the rectangle with minimum area.
-     * Use MinimumAreaRectangle to compute this.
-     *
-     * @return the the minimum-width rectangle enclosing the geometry
-     * @see MinimumAreaRectangle
-     */
-    std::unique_ptr<geom::Geometry> getMinimumRectangle();
-
-    /** \brief
-     * Gets the minimum rectangle enclosing a geometry.
-     *
-     * @param geom the geometry
-     * @return a rectangle enclosing the input (or a line or point if degenerate)
-     * @see MinimumAreaRectangle
-    */
-    static std::unique_ptr<geom::Geometry> getMinimumRectangle(geom::Geometry* geom);
-
-    /** \brief
-     * Gets the length of the minimum diameter enclosing a geometry.
-     * @param geom the geometry
-     * @return the length of the minimum diameter of the geometry
-     */
-    static std::unique_ptr<geom::Geometry> getMinimumDiameter(geom::Geometry* geom);
-
-};
-
-} // namespace geos::algorithm
-} // namespace geos

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

@@ -1,43 +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 <string>
-#include <geos/util/GEOSException.h>
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/**
- * \class NotRepresentableException
- * \brief
- * Indicates that a HCoordinate has been computed which is
- * not representable on the Cartesian plane.
- *
- * @version 1.4
- * @see HCoordinate
- */
-class GEOS_DLL NotRepresentableException: public util::GEOSException {
-public:
-    NotRepresentableException();
-    NotRepresentableException(std::string msg);
-    ~NotRepresentableException() noexcept override {}
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,122 +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/Orientation.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 the orientation of basic geometric structures
- * including point triplets (triangles) and rings.
- *
- * Orientation is a fundamental property of planar geometries
- * (and more generally geometry on two-dimensional manifolds).
- *
- * Orientation is notoriously subject to numerical precision errors
- * in the case of collinear or nearly collinear points.
- * JTS uses extended-precision arithmetic to increase
- * the robustness of the computation.
- *
- * @author Martin Davis
- */
-class GEOS_DLL Orientation {
-public:
-
-    /* A value that indicates an orientation or turn */
-    enum {
-        CLOCKWISE = -1,
-        COLLINEAR = 0,
-        COUNTERCLOCKWISE = 1,
-        RIGHT = -1,
-        LEFT = 1,
-        STRAIGHT = 0
-    };
-
-    /** \brief
-     * Returns the orientation index of the direction of the point q relative to
-     * a directed infinite line specified by p1-p2.
-     *
-     * The index indicates whether the point lies to the
-     * `Orientation::LEFT` or `Orientation::RIGHT`
-     * of the line, or lies on it `Orientation::COLLINEAR`.
-     * The index also indicates the orientation of the triangle formed
-     * by the three points
-     * ( `Orientation::COUNTERCLOCKWISE`,
-     * `Orientation::CLOCKWISE`, or `Orientation::STRAIGHT` )
-     */
-    static int index(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
-                     const geom::CoordinateXY& q);
-
-    /**
-    * Computes whether a ring defined by a geom::CoordinateSequence is
-    * oriented counter-clockwise.
-    *
-    *  * The list of points is assumed to have the first and last points equal.
-    *  * This handles coordinate lists which contain repeated points.
-    *  * This handles rings which contain collapsed segments
-    *    (in particular, along the top of the ring).
-    *
-    * This algorithm is guaranteed to work with valid rings.
-    * It also works with "mildly invalid" rings
-    * which contain collapsed (coincident) flat segments along the top of the ring.
-    * If the ring is "more" invalid (e.g. self-crosses or touches),
-    * the computed result may not be correct.
-    *
-    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
-    * @return true if the ring is oriented counter-clockwise.
-    * @throws IllegalArgumentException if there are too few points to determine orientation (< 4)
-    */
-    static bool isCCW(const geom::CoordinateSequence* ring);
-
-    /**
-    * Tests if a ring defined by a CoordinateSequence is
-    * oriented counter-clockwise, using the signed area of the ring.
-    *
-    *  * The list of points is assumed to have the first and last points equal.
-    *  * This handles coordinate lists which contain repeated points.
-    *  * This handles rings which contain collapsed segments
-    *    (in particular, along the top of the ring).
-    *  * This handles rings which are invalid due to self-intersection
-    *
-    * This algorithm is guaranteed to work with valid rings.
-    * For invalid rings (containing self-intersections),
-    * the algorithm determines the orientation of
-    * the largest enclosed area (including overlaps).
-    * This provides a more useful result in some situations, such as buffering.
-    *
-    * However, this approach may be less accurate in the case of
-    * rings with almost zero area.
-    * (Note that the orientation of rings with zero area is essentially
-    * undefined, and hence non-deterministic.)
-    *
-    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
-    * @return true if the ring is oriented counter-clockwise.
-    */
-    static bool isCCWArea(const geom::CoordinateSequence* ring);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,40 +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>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-class GEOS_DLL PointInRing {
-public:
-    virtual
-    ~PointInRing() {}
-    virtual bool isInside(const geom::Coordinate& pt) = 0;
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-
-