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

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/valid/RepeatedPointTester.h

@@ -0,0 +1,66 @@
+/**********************************************************************
+ *
+ * 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: operation/valid/RepeatedPointTester.java rev. 1.8 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+//class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class Polygon;
+class MultiPolygon;
+class MultiLineString;
+class GeometryCollection;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Implements the appropriate checks for repeated points
+ * (consecutive identical coordinates) as defined in the
+ * JTS spec.
+ */
+class GEOS_DLL RepeatedPointTester {
+public:
+    RepeatedPointTester() {}
+    geom::CoordinateXY& getCoordinate();
+    bool hasRepeatedPoint(const geom::Geometry* g);
+    bool hasRepeatedPoint(const geom::CoordinateSequence* coord);
+private:
+    geom::CoordinateXY repeatedCoord;
+    bool hasRepeatedPoint(const geom::Polygon* p);
+    bool hasRepeatedPoint(const geom::GeometryCollection* gc);
+    bool hasRepeatedPoint(const geom::MultiPolygon* gc);
+    bool hasRepeatedPoint(const geom::MultiLineString* gc);
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/operation/valid/TopologyValidationError.h

@@ -0,0 +1,76 @@
+/**********************************************************************
+ *
+ * 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: operation/valid/TopologyValidationError.java rev. 1.16 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+// none required
+
+namespace geos {
+namespace operation { // geos::operation
+namespace valid { // geos::operation::valid
+
+/** \brief
+ * Contains information about the nature and location of a geom::Geometry
+ * validation error
+ *
+ */
+class GEOS_DLL TopologyValidationError {
+public:
+
+    enum errorEnum {
+        eError,
+        eRepeatedPoint,
+        eHoleOutsideShell,
+        eNestedHoles,
+        eDisconnectedInterior,
+        eSelfIntersection,
+        eRingSelfIntersection,
+        eNestedShells,
+        eDuplicatedRings,
+        eTooFewPoints,
+        eInvalidCoordinate,
+        eRingNotClosed,
+        oNoInvalidIntersection = -1
+    };
+
+    TopologyValidationError(int newErrorType, const geom::CoordinateXY& newPt);
+    TopologyValidationError(int newErrorType);
+    const geom::CoordinateXY& getCoordinate() const;
+    std::string getMessage() const;
+    int getErrorType() const;
+    std::string toString() const;
+
+private:
+    // Used const char* to reduce dynamic allocations
+    static const char* errMsg[];
+    int errorType;
+    const geom::CoordinateXY pt;
+};
+
+
+} // namespace geos.operation.valid
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/planargraph/DirectedEdge.h

@@ -0,0 +1,237 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/planargraph/GraphComponent.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for composition
+
+#include <vector> // for typedefs
+#include <list> // for typedefs
+
+// Forward declarations
+namespace geos {
+namespace planargraph {
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief Represents a directed edge in a PlanarGraph.
+ *
+ * A DirectedEdge may or may not have a reference to a parent Edge
+ * (some applications of planar graphs may not require explicit Edge
+ * objects to be created). Usually a client using a PlanarGraph
+ * will subclass DirectedEdge to add its own application-specific
+ * data and methods.
+ */
+class GEOS_DLL DirectedEdge: public GraphComponent {
+
+public:
+
+    friend std::ostream& operator << (std::ostream&, const DirectedEdge&);
+
+    typedef std::list<DirectedEdge*> NonConstList;
+    typedef std::list<const DirectedEdge*> ConstList;
+    typedef std::vector<DirectedEdge*> NonConstVect;
+
+protected:
+    Edge* parentEdge;
+    Node* from;
+    Node* to;
+    geom::Coordinate p0, p1;
+    DirectedEdge* sym;  // optional
+    bool edgeDirection;
+    int quadrant;
+    double angle;
+public:
+
+    typedef std::vector<const DirectedEdge*> ConstVect;
+    typedef std::vector<DirectedEdge*> Vect;
+
+    /**
+     * \brief
+     * Returns a List containing the parent Edge (possibly null)
+     * for each of the given DirectedEdges.
+     *
+     * @note Ownership of the returned vector is left to
+     * the caller, see the equivalent function taking a vector
+     * reference to avoid this.
+     */
+    static std::vector<Edge*>* toEdges(
+        std::vector<DirectedEdge*>& dirEdges);
+
+    /**
+     * \brief
+     * Add parent Edge (possibly null) of each of the given DirectedEdges
+     * to the given parentEdges vector.
+     *
+     * @note Parents are pushed to the parentEdges vector, make sure
+     * it is empty if index-based corrispondence is important.
+     */
+    static void toEdges(std::vector<DirectedEdge*>& dirEdges,
+                        std::vector<Edge*>& parentEdges);
+
+    /**
+     * \brief Constructs a DirectedEdge connecting the `from`
+     * node to the `to` node.
+     *
+     * @param newFrom `from` node
+     * @param newTo `to` node
+     * @param directionPt specifies this DirectedEdge's direction
+     *                    (given by an imaginary line from the
+     *                    `from` node to
+     *                    `directionPt`)
+     * @param newEdgeDirection whether this DirectedEdge's direction
+     *                         is the same as or opposite to that of the
+     *                         parent Edge (if any)
+     */
+    DirectedEdge(Node* newFrom, Node* newTo,
+                 const geom::Coordinate& directionPt,
+                 bool newEdgeDirection);
+
+    /**
+     * \brief Returns this DirectedEdge's parent Edge,
+     * or null if it has none.
+     */
+    Edge* getEdge() const;
+
+    /**
+     * \brief Associates this DirectedEdge with an Edge
+     * (possibly null, indicating no associated Edge).
+     */
+    void setEdge(Edge* newParentEdge);
+
+    /**
+     * \brief Returns 0, 1, 2, or 3, indicating the quadrant in which
+     * this DirectedEdge's orientation lies.
+     */
+    int getQuadrant() const;
+
+    /**
+     * \brief Returns a point to which an imaginary line is drawn
+     * from the from-node to specify this DirectedEdge's orientation.
+     */
+    const geom::Coordinate& getDirectionPt() const;
+
+    /**
+     * \brief Returns whether the direction of the parent Edge (if any)
+     * is the same as that of this Directed Edge.
+     */
+    bool getEdgeDirection() const;
+
+    /**
+     * \brief Returns the node from which this DirectedEdge leaves.
+     */
+    Node* getFromNode() const;
+
+    /**
+     * \brief Returns the node to which this DirectedEdge goes.
+     */
+    Node* getToNode() const;
+
+    /**
+     * \brief
+     * Returns the coordinate of the from-node.
+     */
+    geom::Coordinate& getCoordinate() const;
+
+    /**
+     * \brief
+     * Returns the angle that the start of this DirectedEdge makes
+     * with the positive x-axis, in radians.
+     */
+    double getAngle() const;
+
+    /**
+     * \brief
+     * Returns the symmetric DirectedEdge -- the other DirectedEdge
+     * associated with this DirectedEdge's parent Edge.
+     */
+    DirectedEdge* getSym() const;
+
+    /**
+     * \brief
+     * Sets this DirectedEdge's symmetric DirectedEdge, which runs
+     * in the opposite direction.
+     */
+    void setSym(DirectedEdge* newSym);
+
+    /**
+     * \brief
+     * Returns 1 if this DirectedEdge has a greater angle with the
+     * positive x-axis than b", 0 if the DirectedEdges are collinear,
+     * and -1 otherwise.
+     *
+     * Using the obvious algorithm of simply computing the angle is
+     * not robust, since the angle calculation is susceptible to roundoff.
+     * A robust algorithm is:
+     *
+     * - first compare the quadrants.
+     *   If the quadrants are different, it it
+     *   trivial to determine which std::vector is "greater".
+     * - if the vectors lie in the same quadrant, the robust
+     *   Orientation::index(Coordinate, Coordinate, Coordinate)
+     *   function can be used to decide the relative orientation of
+     *   the vectors.
+     *
+     */
+    int compareTo(const DirectedEdge* obj) const;
+
+    /**
+     * \brief
+     * Returns 1 if this DirectedEdge has a greater angle with the
+     * positive x-axis than b", 0 if the DirectedEdges are collinear,
+     * and -1 otherwise.
+     *
+     * Using the obvious algorithm of simply computing the angle is
+     * not robust, since the angle calculation is susceptible to roundoff.
+     * A robust algorithm is:
+     *
+     * - first compare the quadrants.
+     *   If the quadrants are different, it it trivial to determine
+     *   which std::vector is "greater".
+     * - if the vectors lie in the same quadrant, the robust
+     *   Orientation::index(Coordinate, Coordinate, Coordinate)
+     *   function can be used to decide the relative orientation of
+     *   the vectors.
+     *
+     */
+    int compareDirection(const DirectedEdge* e) const;
+
+    /**
+     * \brief
+     * Prints a detailed string representation of this DirectedEdge
+     * to the given PrintStream.
+     */
+    std::string print() const;
+
+};
+
+/// Strict Weak comparator function for containers
+bool pdeLessThan(DirectedEdge* first, DirectedEdge* second);
+
+/// Output operator
+std::ostream& operator << (std::ostream&, const DirectedEdge&);
+
+
+} // namespace geos::planargraph
+} // namespace geos
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/planargraph/DirectedEdgeStar.h

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+
+#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 Coordinate;
+}
+namespace planargraph {
+class DirectedEdge;
+class Edge;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/// A sorted collection of DirectedEdge which leave a Node in a PlanarGraph.
+class GEOS_DLL DirectedEdgeStar {
+protected:
+
+private:
+    /**
+     * \brief The underlying list of outgoing DirectedEdges
+     */
+    mutable std::vector<DirectedEdge*> outEdges;
+    mutable bool sorted;
+    void sortEdges() const;
+
+public:
+    /**
+     * \brief Constructs a DirectedEdgeStar with no edges.
+     */
+    DirectedEdgeStar(): sorted(false) {}
+
+    virtual
+    ~DirectedEdgeStar() {}
+
+    /**
+     * \brief Adds a new member to this DirectedEdgeStar.
+     */
+    void add(DirectedEdge* de);
+
+    /**
+     * \brief Drops a member of this DirectedEdgeStar.
+     */
+    void remove(DirectedEdge* de);
+
+    /**
+     * \brief Returns an Iterator over the DirectedEdges,
+     * in ascending order by angle with the positive x-axis.
+     */
+    std::vector<DirectedEdge*>::iterator
+    iterator()
+    {
+        return begin();
+    }
+    /// Returns an iterator to first DirectedEdge
+    std::vector<DirectedEdge*>::iterator begin();
+
+    /// Returns an iterator to one-past last DirectedEdge
+    std::vector<DirectedEdge*>::iterator end();
+
+    /// Returns an const_iterator to first DirectedEdge
+    std::vector<DirectedEdge*>::const_iterator begin() const;
+
+    /// Returns an const_iterator to one-past last DirectedEdge
+    std::vector<DirectedEdge*>::const_iterator end() const;
+
+    /**
+     * \brief Returns the number of edges around the Node associated
+     * with this DirectedEdgeStar.
+     */
+    std::size_t
+    getDegree() const
+    {
+        return outEdges.size();
+    }
+
+    /**
+     * \brief Returns the coordinate for the node at wich this
+     * star is based
+     */
+    geom::Coordinate& getCoordinate() const;
+
+    /**
+     * \brief Returns the DirectedEdges, in ascending order
+     * by angle with the positive x-axis.
+     */
+    std::vector<DirectedEdge*>& getEdges();
+
+    /**
+     * \brief Returns the zero-based index of the given Edge,
+     * after sorting in ascending order by angle with the
+     * positive x-axis.
+     */
+    int getIndex(const Edge* edge);
+
+    /**
+     * \brief Returns the zero-based index of the given DirectedEdge,
+     * after sorting in ascending order
+     * by angle with the positive x-axis.
+     */
+    int getIndex(const DirectedEdge* dirEdge);
+
+    /**
+     * \brief Returns the remainder when i is divided by the number of
+     * edges in this DirectedEdgeStar.
+     */
+    unsigned int getIndex(int i) const;
+
+    /**
+     * \brief Returns the DirectedEdge on the left-hand side
+     * of the given DirectedEdge (which must be a member of this
+     * DirectedEdgeStar).
+     */
+    DirectedEdge* getNextEdge(DirectedEdge* dirEdge);
+};
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e/Headers/geos/planargraph/Edge.h

@@ -0,0 +1,141 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * Copyright (C) 2005-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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/planargraph/GraphComponent.h> // for inheritance
+
+#include <vector> // for typedefs
+#include <set> // for typedefs
+#include <iosfwd> // ostream
+#include <cstdint>
+
+#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 planargraph {
+class DirectedEdgeStar;
+class DirectedEdge;
+class Edge;
+class Node;
+}
+}
+
+namespace geos {
+namespace planargraph { // geos.planargraph
+
+/**
+ * \brief Represents an undirected edge of a PlanarGraph.
+ *
+ * An undirected edge in fact simply acts as a central point of reference
+ * for two opposite DirectedEdge.
+ *
+ * Usually a client using a PlanarGraph will subclass Edge
+ * to add its own application-specific data and methods.
+ */
+class GEOS_DLL Edge: public GraphComponent {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& os, const Node&);
+
+    /// Set of const Edges pointers
+    typedef std::set<const Edge*> ConstSet;
+
+    /// Set of non-const Edges pointers
+    typedef std::set<Edge*> NonConstSet;
+
+    /// Vector of non-const Edges pointers
+    typedef std::vector<Edge*> NonConstVect;
+
+    /// Vector of const Edges pointers
+    typedef std::vector<const Edge*> ConstVect;
+
+protected:
+
+    /** \brief The two DirectedEdges associated with this Edge */
+    std::vector<DirectedEdge*> dirEdge;
+
+public:
+
+    /** \brief
+     * Constructs a Edge whose DirectedEdges are not yet set.
+     *
+     * Be sure to call
+     * {@link #setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1)}
+     */
+    Edge(): dirEdge() {}
+
+    /**
+     * \brief Constructs an Edge initialized with the given DirectedEdges.
+     *
+     * For each DirectedEdge: sets the Edge, sets the symmetric
+     * DirectedEdge, and adds this Edge to its from-Node.
+     */
+    Edge(DirectedEdge* de0, DirectedEdge* de1)
+        :
+        dirEdge()
+    {
+        setDirectedEdges(de0, de1);
+    }
+
+    /**
+     * \brief Initializes this Edge's two DirectedEdges.
+     *
+     * For each DirectedEdge:
+     * - sets the Edge, sets the symmetric DirectedEdge, and
+     * - adds this Edge to its from-Node.
+     */
+    void setDirectedEdges(DirectedEdge* de0, DirectedEdge* de1);
+
+    /**
+     * \brief Returns one of the DirectedEdges associated with this Edge.
+     * @param i 0 or 1
+     */
+    DirectedEdge* getDirEdge(int i);
+
+    /**
+     * \brief Returns the DirectedEdge that starts from the given node,
+     * or null if the node is not one of the two nodes associated
+     * with this Edge.
+     */
+    DirectedEdge* getDirEdge(Node* fromNode);
+
+    /**
+     * \brief If <code>node</code> is one of the two nodes associated
+     * with this Edge, returns the other node; otherwise returns null.
+     */
+    Node* getOppositeNode(Node* node);
+};
+
+/// Print a Edge
+std::ostream& operator<<(std::ostream& os, const Edge& n);
+
+/// For backward compatibility
+//typedef Edge planarEdge;
+
+} // namespace geos::planargraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+