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

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

@@ -1,107 +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/PointLocation.java @ 2017-09-04
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Location.h>
-#include <vector>
-
-namespace geos {
-
-namespace geom {
-class Coordinate;
-class CoordinateXY;
-class CoordinateSequence;
-class Curve;
-}
-
-namespace algorithm { // geos::algorithm
-
-/** \brief
- * Functions for locating points within basic geometric
- * structures such as lines and rings.
- *
- * @author Martin Davis
- *
- */
-class GEOS_DLL PointLocation {
-public:
-
-    /** \brief
-     * Tests whether a point lies on a line segment.
-     * 
-     * @param p the point to test
-     * @param p0 a point of the line segment
-     * @param p1 a point of the line segment
-     * @return true if the point lies on the line segment
-     */
-    static bool isOnSegment(const geom::CoordinateXY& p, const geom::CoordinateXY& p0, const geom::CoordinateXY& p1);
-
-    /** \brief
-     * Tests whether a point lies on the line defined by a
-     * [CoordinateSequence](@ref geom::CoordinateSequence).
-     *
-     * @param p the point to test
-     * @param line the line coordinates
-     * @return true if the point is a vertex of the line or lies in the interior
-     *         of a line segment in the line
-     */
-    static bool isOnLine(const geom::CoordinateXY& p, const geom::CoordinateSequence* line);
-
-    /** \brief
-     * Tests whether a point lies inside or on a ring.
-     *
-     * The ring may be oriented in either direction. A point lying exactly
-     * on the ring boundary is considered to be inside the ring.
-     *
-     * This method does **not** first check the point against the envelope of
-     * the ring.
-     *
-     * @param p point to check for ring inclusion
-     * @param ring an array of coordinates representing the ring (which must have
-     *             first point identical to last point)
-     * @return `true` if p is inside ring
-     *
-     * @see RayCrossingCounter::locatePointInRing()
-     */
-    static bool isInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
-    static bool isInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence* ring);
-
-    /** \brief
-     * Determines whether a point lies in the interior, on the boundary, or in the
-     * exterior of a ring. The ring may be oriented in either direction.
-     *
-     * This method does *not* first check the point against the envelope of
-     * the ring.
-     *
-     * @param p point to check for ring inclusion
-     * @param ring an array of coordinates representing the ring (which must have
-     *             first point identical to last point)
-     * @return the [Location](@ref geom::Location) of p relative to the ring
-     */
-    static geom::Location locateInRing(const geom::CoordinateXY& p, const std::vector<const geom::Coordinate*>& ring);
-    static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::CoordinateSequence& ring);
-    static geom::Location locateInRing(const geom::CoordinateXY& p, const geom::Curve& ring);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,108 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2005-2011 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/PointLocator.java 95fbe34b (JTS-1.15.2-SNAPSHOT)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Location.h> // for inlines
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class CoordinateXY;
-class Geometry;
-class LinearRing;
-class LineString;
-class Polygon;
-class Point;
-}
-}
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/**
- * \class PointLocator
- *
- * \brief
- * Computes the topological relationship (Location)
- * of a single point to a Geometry.
- *
- * The algorithm obeys the SFS boundaryDetermination rule to correctly determine
- * whether the point lies on the boundary or not.
- *
- * Notes:
- *	- instances of this class are not reentrant.
- *	- LinearRing objects do not enclose any area
- *	  (points inside the ring are still in the EXTERIOR of the ring.)
- *
- */
-class GEOS_DLL PointLocator {
-public:
-    PointLocator() {}
-    ~PointLocator() {}
-
-    /**
-     * Computes the topological relationship (Location) of a single point
-     * to a Geometry. It handles both single-element and multi-element Geometries.
-     * The algorithm for multi-part Geometriestakes into account the SFS
-     * Boundary Determination rule.
-     *
-     * @return the Location of the point relative to the input Geometry
-     */
-    geom::Location locate(const geom::CoordinateXY& p, const geom::Geometry* geom);
-
-    /**
-     * Convenience method to test a point for intersection with
-     * a Geometry
-     *
-     * @param p the coordinate to test
-     * @param geom the Geometry to test
-     * @return <code>true</code> if the point is in the interior or boundary of the Geometry
-     */
-    bool
-    intersects(const geom::CoordinateXY& p, const geom::Geometry* geom)
-    {
-        return locate(p, geom) != geom::Location::EXTERIOR;
-    }
-
-private:
-
-    bool isIn;         // true if the point lies in or on any Geometry element
-
-    int numBoundaries;    // the number of sub-elements whose boundaries the point lies in
-
-    void computeLocation(const geom::CoordinateXY& p, const geom::Geometry* geom);
-
-    void updateLocationInfo(geom::Location loc);
-
-    geom::Location locate(const geom::CoordinateXY& p, const geom::Point* pt);
-
-    geom::Location locate(const geom::CoordinateXY& p, const geom::LineString* l);
-
-    geom::Location locateInPolygonRing(const geom::CoordinateXY& p, const geom::LinearRing* ring);
-
-    geom::Location locate(const geom::CoordinateXY& p, const geom::Polygon* poly);
-
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-
-

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

@@ -1,149 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://libgeos.org
- *
- * Copyright (c) 2021 Martin Davis
- * Copyright (C) 2022 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>
-
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class CoordinateXY;
-}
-}
-
-using geos::geom::CoordinateXY;
-
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/**
- * Functions to compute topological information
- * about nodes (ring intersections) in polygonal geometry.
- *
- * @author mdavis
- *
- */
-class GEOS_DLL PolygonNodeTopology {
-
-public:
-
-    /*
-    * Check if the segments at a node between two rings (or one ring) cross.
-    * The node is topologically valid if the rings do not cross.
-    * This function assumes that the segments are not collinear.
-    *
-    * @param nodePt the node location
-    * @param a0 the previous segment endpoint in a ring
-    * @param a1 the next segment endpoint in a ring
-    * @param b0 the previous segment endpoint in the other ring
-    * @param b1 the next segment endpoint in the other ring
-    * @return true if the rings cross at the node
-    */
-    static bool
-    isCrossing(const CoordinateXY* nodePt,
-        const CoordinateXY* a0, const CoordinateXY* a1,
-        const CoordinateXY* b0, const CoordinateXY* b1);
-
-
-    /**
-    * Tests whether an segment node-b lies in the interior or exterior
-    * of a corner of a ring formed by the two segments a0-node-a1.
-    * The ring interior is assumed to be on the right of the corner
-    * (i.e. a CW shell or CCW hole).
-    * The test segment must not be collinear with the corner segments.
-    *
-    * @param nodePt the node location
-    * @param a0 the first vertex of the corner
-    * @param a1 the second vertex of the corner
-    * @param b the other vertex of the test segment
-    * @return true if the segment is interior to the ring corner
-    */
-    static bool isInteriorSegment(const CoordinateXY* nodePt,
-        const CoordinateXY* a0, const CoordinateXY* a1, const CoordinateXY* b);
-
-    /**
-    * Compares the angles of two vectors
-    * relative to the positive X-axis at their origin.
-    * Angles increase CCW from the X-axis.
-    *
-    * @param origin the origin of the vectors
-    * @param p the endpoint of the vector P
-    * @param q the endpoint of the vector Q
-    * @return a negative integer, zero, or a positive integer as this vector P has angle less than, equal to, or greater than vector Q
-    */
-    static int compareAngle(
-        const CoordinateXY* origin,
-        const CoordinateXY* p,
-        const CoordinateXY* q);
-
-
-private:
-
-    /**
-    * Tests if an edge p is between edges e0 and e1,
-    * where the edges all originate at a common origin.
-    * The "inside" of e0 and e1 is the arc which does not include the origin.
-    * The edges are assumed to be distinct (non-collinear).
-    *
-    * @param origin the origin
-    * @param p the destination point of edge p
-    * @param e0 the destination point of edge e0
-    * @param e1 the destination point of edge e1
-    * @return true if p is between e0 and e1
-    */
-    static bool isBetween(const CoordinateXY* origin,
-        const CoordinateXY* p,
-        const CoordinateXY* e0, const CoordinateXY* e1);
-
-    /**
-    * Compares whether an edge p is between or outside the edges e0 and e1,
-    * where the edges all originate at a common origin.
-    * The "inside" of e0 and e1 is the arc which does not include
-    * the positive X-axis at the origin.
-    * If p is collinear with an edge 0 is returned.
-    *
-    * @param origin the origin
-    * @param p the destination point of edge p
-    * @param e0 the destination point of edge e0
-    * @param e1 the destination point of edge e1
-    * @return a negative integer, zero or positive integer as the vector P lies outside, collinear with, or inside the vectors E0 and E1
-    */
-    static int compareBetween(const CoordinateXY* origin, const CoordinateXY* p,
-        const CoordinateXY* e0, const CoordinateXY* e1);
-
-
-    /**
-    * Tests if the angle with the origin of a vector P is greater than that of the
-    * vector Q.
-    *
-    * @param origin the origin of the vectors
-    * @param p the endpoint of the vector P
-    * @param q the endpoint of the vector Q
-    * @return true if vector P has angle greater than Q
-    */
-    static bool isAngleGreater(const CoordinateXY* origin, const CoordinateXY* p, const CoordinateXY* q);
-
-    static int quadrant(const CoordinateXY* origin, const CoordinateXY* p);
-
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-

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

@@ -1,173 +0,0 @@
-/**********************************************************************
- *
- * 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/RayCrossingCounter.java rev. 1.2 (JTS-1.9)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Location.h>
-
-#include <array>
-#include <vector>
-
-// forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class CoordinateXY;
-class CoordinateSequence;
-class CircularArc;
-class Curve;
-}
-}
-
-
-namespace geos {
-namespace algorithm {
-
-/** \brief
- * Counts the number of segments crossed by a horizontal ray extending to the
- * right from a given point, in an incremental fashion.
- *
- * This can be used to determine whether a point lies in a polygonal geometry.
- * The class determines the situation where the point lies exactly on a segment.
- * When being used for Point-In-Polygon determination, this case allows
- * short-circuiting the evaluation.
- *
- * This class handles polygonal geometries with any number of shells and holes.
- * The orientation of the shell and hole rings is unimportant.
- * In order to compute a correct location for a given polygonal geometry,
- * it is essential that **all** segments are counted which
- *
- * - touch the ray
- * - lie in in any ring which may contain the point
- *
- * The only exception is when the point-on-segment situation is detected, in
- * which case no further processing is required.
- * The implication of the above rule is that segments which can be a priori
- * determined to *not* touch the ray (i.e. by a test of their bounding box or
- * Y-extent) do not need to be counted. This allows for optimization by indexing.
- *
- * @author Martin Davis
- */
-class GEOS_DLL RayCrossingCounter {
-private:
-    const geom::CoordinateXY& point;
-
-    std::size_t crossingCount;
-
-    // true if the test point lies on an input segment
-    bool isPointOnSegment;
-
-    // Declare type as noncopyable
-    RayCrossingCounter(const RayCrossingCounter& other) = delete;
-    RayCrossingCounter& operator=(const RayCrossingCounter& rhs) = delete;
-
-public:
-    /** \brief
-     * Determines the [Location](@ref geom::Location) of a point in a ring.
-     *
-     * This method is an exemplar of how to use this class.
-     *
-     * @param p the point to test
-     * @param ring an array of Coordinates forming a ring
-     * @return the location of the point in the ring
-     */
-    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
-                                 const geom::CoordinateSequence& ring);
-
-    /// Semantically equal to the above, just different args encoding
-    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
-                                 const std::vector<const geom::Coordinate*>& ring);
-
-    static geom::Location locatePointInRing(const geom::CoordinateXY& p,
-                                 const geom::Curve& ring);
-
-    RayCrossingCounter(const geom::CoordinateXY& p_point)
-        : point(p_point),
-          crossingCount(0),
-          isPointOnSegment(false)
-    { }
-
-    /** \brief
-     * Counts a segment
-     *
-     * @param p1 an endpoint of the segment
-     * @param p2 another endpoint of the segment
-     */
-    void countSegment(const geom::CoordinateXY& p1,
-                      const geom::CoordinateXY& p2);
-
-    void countArc(const geom::CoordinateXY& p1,
-                  const geom::CoordinateXY& p2,
-                  const geom::CoordinateXY& p3);
-
-    /** \brief
-     *  Counts all segments or arcs in the sequence
-     */
-    void processSequence(const geom::CoordinateSequence& seq, bool isLinear);
-
-    /** \brief
-     * Reports whether the point lies exactly on one of the supplied segments.
-     *
-     * This method may be called at any time as segments are processed.
-     * If the result of this method is `true`, no further segments need
-     * be supplied, since the result will never change again.
-     *
-     * @return `true` if the point lies exactly on a segment
-     */
-    bool
-    isOnSegment() const
-    {
-        return isPointOnSegment;
-    }
-
-    /** \brief
-     * Gets the [Location](@ref geom::Location) of the point relative to
-     * the ring, polygon or multipolygon from which the processed
-     * segments were provided.
-     *
-     * This method only determines the correct location
-     * if **all** relevant segments must have been processed.
-     *
-     * @return the Location of the point
-     */
-    geom::Location getLocation() const;
-
-    /** \brief
-     * Tests whether the point lies in or on the ring, polygon or
-     * multipolygon from which the processed segments were provided.
-     *
-     * This method only determines the correct location if **all** relevant
-     * segments must have been processed.
-     *
-     * @return `true` if the point lies in or on the supplied polygon
-     */
-    bool isPointInPolygon() const;
-
-    std::size_t getCount() const { return crossingCount; };
-
-    static bool shouldCountCrossing(const geom::CircularArc& arc, const geom::CoordinateXY& q);
-
-    static std::array<geom::CoordinateXY, 2>
-    pointsIntersectingHorizontalRay(const geom::CircularArc& arc, const geom::CoordinateXY& origin);
-
-};
-
-} // geos::algorithm
-} // geos

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

@@ -1,96 +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 <geos/geom/LineSegment.h>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Coordinate;
-class GeometryFactory;
-class Polygon;
-}
-}
-
-using geos::geom::CoordinateXY;
-using geos::geom::GeometryFactory;
-using geos::geom::LineSegment;
-using geos::geom::Polygon;
-
-namespace geos {
-namespace algorithm {
-
-class GEOS_DLL Rectangle {
-
-public:
-
-    /**
-    * Creates a rectangular {@link Polygon} from a base segment
-    * defining the position and orientation of one side of the rectangle, and
-    * three points defining the locations of the line segments
-    * forming the opposite, left and right sides of the rectangle.
-    * The base segment and side points must be presented so that the
-    * rectangle has CW orientation.
-    *
-    * The rectangle corners are computed as intersections of
-    * lines, which generally cannot produce exact values.
-    * If a rectangle corner is determined to coincide with a side point
-    * the side point value is used to avoid numerical inaccuracy.
-    *
-    * The first side of the constructed rectangle contains the base segment.
-    *
-    * @param baseRightPt the right point of the base segment
-    * @param baseLeftPt the left point of the base segment
-    * @param oppositePt the point defining the opposite side
-    * @param leftSidePt the point defining the left side
-    * @param rightSidePt the point defining the right side
-    * @param factory the geometry factory to use
-    * @return the rectangular polygon
-    */
-    static std::unique_ptr<Polygon>
-        createFromSidePts(
-            const CoordinateXY& baseRightPt,
-            const CoordinateXY& baseLeftPt,
-            const CoordinateXY& oppositePt,
-            const CoordinateXY& leftSidePt,
-            const CoordinateXY& rightSidePt,
-            const GeometryFactory* factory);
-
-private:
-
-    /**
-    * Computes the constant C in the standard line equation Ax + By = C
-    * from A and B and a point on the line.
-    *
-    * @param a the X coefficient
-    * @param b the Y coefficient
-    * @param p a point on the line
-    * @return the constant C
-    */
-    static double
-        computeLineEquationC(double a, double b, const CoordinateXY& p);
-
-    static LineSegment
-        createLineForStandardEquation(double a, double b, double c);
-
-};
-
-
-} // namespace geos::algorithm
-} // namespace geos
-
-

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

@@ -1,66 +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/RobustDeterminant.java 1.15 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-namespace geos {
-namespace algorithm { // geos::algorithm
-
-/** \brief
- * Implements an algorithm to compute the
- * sign of a 2x2 determinant for double precision values robustly.
- *
- * It is a direct translation of code developed by Olivier Devillers.
- *
- * The original code carries the following copyright notice:
- *
- * <pre>
- *************************************************************************
- * The original code carries the following copyright notice:
- * Author : Olivier Devillers
- * Olivier.Devillers@sophia.inria.fr
- * http:/www.inria.fr:/prisme/personnel/devillers/anglais/determinant.html
- *
- **************************************************************************
- *              Copyright (c) 1995  by  INRIA Prisme Project
- *                  BP 93 06902 Sophia Antipolis Cedex, France.
- *                           All rights reserved
- **********************************************************************
- * </pre>
- *
- */
-class GEOS_DLL RobustDeterminant {
-public:
-
-    /** \brief
-     * Computes the sign of the determinant of the 2x2 matrix
-     * with the given entries, in a robust way.
-     *
-     * @return -1 if the determinant is negative,
-     * @return  1 if the determinant is positive,
-     * @return  0 if the determinant is 0.
-     */
-    static int signOfDet2x2(double x1, double y1, double x2, double y2);
-};
-
-} // namespace geos::algorithm
-} // namespace geos
-