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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geomgraph/GeometryGraph.h

@@ -0,0 +1,251 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/GeometryGraph.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include <memory>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h> // for unique_ptr<CoordinateSequence>
+#include <geos/geomgraph/PlanarGraph.h>
+#include <geos/geomgraph/index/SegmentIntersector.h>
+#include <geos/geom/LineString.h> // for LineStringLT
+
+#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 LineString;
+class LinearRing;
+class Polygon;
+class Geometry;
+class GeometryCollection;
+class Point;
+class Envelope;
+}
+namespace algorithm {
+class LineIntersector;
+class BoundaryNodeRule;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+namespace index {
+class EdgeSetIntersector;
+}
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A GeometryGraph is a graph that models a given Geometry.
+ */
+class GEOS_DLL GeometryGraph: public PlanarGraph {
+    using PlanarGraph::add;
+    using PlanarGraph::findEdge;
+
+private:
+
+    const geom::Geometry* parentGeom;
+
+    /**
+     * The lineEdgeMap is a map of the linestring components of the
+     * parentGeometry to the edges which are derived from them.
+     * This is used to efficiently perform findEdge queries
+     *
+     * Following the above description there's no need to
+     * compare LineStrings other then by pointer value.
+     */
+    std::unordered_map<const geom::LineString*, Edge*> lineEdgeMap;
+
+    /**
+     * If this flag is true, the Boundary Determination Rule will
+     * used when deciding whether nodes are in the boundary or not
+     */
+    bool useBoundaryDeterminationRule;
+
+    const algorithm::BoundaryNodeRule& boundaryNodeRule;
+
+    /**
+     * the index of this geometry as an argument to a spatial function
+     * (used for labelling)
+     */
+    uint8_t argIndex;
+
+    /// Cache for fast responses to getBoundaryPoints
+    std::unique_ptr< geom::CoordinateSequence > boundaryPoints;
+
+    std::unique_ptr< std::vector<Node*> > boundaryNodes;
+
+    bool hasTooFewPointsVar;
+
+    geom::Coordinate invalidPoint;
+
+    /// Allocates a new EdgeSetIntersector. Remember to delete it!
+    index::EdgeSetIntersector* createEdgeSetIntersector();
+
+    void add(const geom::Geometry* g);
+    // throw(UnsupportedOperationException);
+
+    void addCollection(const geom::GeometryCollection* gc);
+
+    void addPoint(const geom::Point* p);
+
+    void addPolygonRing(const geom::LinearRing* lr,
+                        geom::Location cwLeft, geom::Location cwRight);
+
+    void addPolygon(const geom::Polygon* p);
+
+    void addLineString(const geom::LineString* line);
+
+    void insertPoint(uint8_t p_argIndex, const geom::Coordinate& coord,
+                     geom::Location onLocation);
+
+    /** \brief
+     * Adds candidate boundary points using the current
+     * algorithm::BoundaryNodeRule.
+     *
+     * This is used to add the boundary
+     * points of dim-1 geometries (Curves/MultiCurves).
+     */
+    void insertBoundaryPoint(uint8_t p_argIndex, const geom::Coordinate& coord);
+
+    void addSelfIntersectionNodes(uint8_t p_argIndex);
+
+    /** \brief
+     * Add a node for a self-intersection.
+     *
+     * If the node is a potential boundary node (e.g. came from an edge
+     * which is a boundary) then insert it as a potential boundary node.
+     * Otherwise, just add it as a regular node.
+     */
+    void addSelfIntersectionNode(uint8_t p_argIndex,
+                                 const geom::Coordinate& coord, geom::Location loc);
+
+    // Declare type as noncopyable
+    GeometryGraph(const GeometryGraph& other) = delete;
+    GeometryGraph& operator=(const GeometryGraph& rhs) = delete;
+
+public:
+
+    static bool isInBoundary(int boundaryCount);
+
+    static geom::Location determineBoundary(int boundaryCount);
+
+    static geom::Location determineBoundary(
+        const algorithm::BoundaryNodeRule& boundaryNodeRule,
+        int boundaryCount);
+
+    GeometryGraph(uint8_t newArgIndex, const geom::Geometry* newParentGeom);
+
+    GeometryGraph(uint8_t newArgIndex, const geom::Geometry* newParentGeom,
+                  const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    ~GeometryGraph() override {};
+
+    const geom::Geometry* getGeometry()
+    {
+        return parentGeom;
+    };
+
+    /// Returned object is owned by this GeometryGraph
+    void getBoundaryNodes(std::vector<Node*>& bdyNodes)
+    {
+        nodes->getBoundaryNodes(static_cast<uint8_t>(argIndex), bdyNodes);
+    };
+
+    std::vector<Node*>* getBoundaryNodes();
+
+    /// Returned object is owned by this GeometryGraph
+    geom::CoordinateSequence* getBoundaryPoints();
+
+    Edge* findEdge(const geom::LineString* line) const;
+
+    void computeSplitEdges(std::vector<Edge*>* edgelist);
+
+    void addEdge(Edge* e);
+
+    void addPoint(geom::Coordinate& pt);
+
+    /**
+     * \brief
+     * Compute self-nodes, taking advantage of the Geometry type to minimize
+     * the number of intersection tests. (E.g. rings are not tested for
+     * self-intersection, since they are assumed to be valid).
+     *
+     * @param li the LineIntersector to use
+     * @param computeRingSelfNodes if `false`, intersection checks are optimized
+     *                             to not test rings for self-intersection
+     * @param env an Envelope
+     *
+     * @return the SegmentIntersector used, containing information about
+     *         the intersections found
+     */
+    std::unique_ptr<index::SegmentIntersector>
+    computeSelfNodes(
+        algorithm::LineIntersector* li,
+        bool computeRingSelfNodes,
+        const geom::Envelope* env = nullptr)
+    {
+        return computeSelfNodes(*li, computeRingSelfNodes, env);
+    }
+
+    // Quick inline calling the function above, the above should probably
+    // be deprecated.
+    std::unique_ptr<index::SegmentIntersector> computeSelfNodes(
+        algorithm::LineIntersector& li,
+        bool computeRingSelfNodes, const geom::Envelope* env = nullptr);
+
+    std::unique_ptr<index::SegmentIntersector> computeEdgeIntersections(GeometryGraph* g,
+            algorithm::LineIntersector* li, bool includeProper,
+            const geom::Envelope* env = nullptr);
+
+    std::vector<Edge*>* getEdges();
+
+    bool hasTooFewPoints();
+
+    const geom::Coordinate& getInvalidPoint();
+
+    const algorithm::BoundaryNodeRule&
+    getBoundaryNodeRule() const
+    {
+        return boundaryNodeRule;
+    }
+
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geomgraph/GraphComponent.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/GraphComponent.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/Label.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A GraphComponent is the parent class for the objects'
+ * that form a graph.
+ *
+ * Each GraphComponent can carry a Label.
+ */
+class GEOS_DLL GraphComponent {
+public:
+    GraphComponent();
+
+    /*
+     * GraphComponent copies the given Label.
+     */
+    GraphComponent(const Label& newLabel);
+
+    virtual ~GraphComponent() = default;
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+    const Label&
+    getLabel() const
+    {
+        return label;
+    }
+    void
+    setLabel(const Label& newLabel)
+    {
+        label = newLabel;
+    }
+
+    virtual void
+    setInResult(bool p_isInResult)
+    {
+        isInResultVar = p_isInResult;
+    }
+    virtual bool
+    isInResult() const
+    {
+        return isInResultVar;
+    }
+    virtual void setCovered(bool isCovered);
+    virtual bool
+    isCovered() const
+    {
+        return isCoveredVar;
+    }
+    virtual bool
+    isCoveredSet() const
+    {
+        return isCoveredSetVar;
+    }
+    virtual bool
+    isVisited() const
+    {
+        return isVisitedVar;
+    }
+    virtual void
+    setVisited(bool p_isVisited)
+    {
+        isVisitedVar = p_isVisited;
+    }
+    virtual bool isIsolated() const = 0;
+    virtual void updateIM(geom::IntersectionMatrix& im);
+protected:
+    Label label;
+    virtual void computeIM(geom::IntersectionMatrix& im) = 0;
+private:
+    bool isInResultVar;
+    bool isCoveredVar;
+    bool isCoveredSetVar;
+    bool isVisitedVar;
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e/Headers/geos/geomgraph/Label.h

@@ -0,0 +1,290 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/Label.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <geos/geomgraph/TopologyLocation.h>
+
+#include <iosfwd> // for operator<<
+#include <cassert>
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A <code>Label</code> indicates the topological relationship of a component
+ * of a topology graph to a given <code>Geometry</code>.
+ *
+ * This class supports labels for relationships to two <code>Geometry</code>s,
+ * which is sufficient for algorithms for binary operations.
+ *
+ * Topology graphs support the concept of labeling nodes and edges in the graph.
+ * The label of a node or edge specifies its topological relationship to one or
+ * more geometries.  (In fact, since JTS operations have only two arguments labels
+ * are required for only two geometries).  A label for a node or edge has one or
+ * two elements, depending on whether the node or edge occurs in one or both of the
+ * input <code>Geometry</code>s.  Elements contain attributes which categorize the
+ * topological location of the node or edge relative to the parent
+ * <code>Geometry</code>; that is, whether the node or edge is in the interior,
+ * boundary or exterior of the <code>Geometry</code>.  Attributes have a value
+ * from the set <code>{Interior, Boundary, Exterior}</code>.  In a node each
+ * element has  a single attribute <code>&lt;On&gt;</code>.  For an edge each element has a
+ * triplet of attributes <code>&lt;Left, On, Right&gt;</code>.
+ *
+ * It is up to the client code to associate the 0 and 1 <code>TopologyLocation</code>s
+ * with specific geometries.
+ *
+ */
+class GEOS_DLL Label {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const Label&);
+
+    /** \brief
+     * Converts a Label to a Line label
+     * (that is, one with no side Locations)
+     *
+     */
+    static Label toLineLabel(const Label& label)
+    {
+        Label lineLabel(geom::Location::NONE);
+        for(uint32_t i = 0; i < 2; i++) {
+            lineLabel.setLocation(i, label.getLocation(i));
+        }
+        return lineLabel;
+    };
+
+    /** \brief
+     * Construct a Label with a single location for both Geometries.
+     */
+    Label(geom::Location onLoc)
+        : elt{TopologyLocation(onLoc)
+        , TopologyLocation(onLoc)}
+        {};
+
+    /** \brief
+     * Construct a Label with the location specified
+     * for the given Geometry.
+     *
+     * Other geometry location will be set to
+     * Location::NONE.
+     */
+    Label(uint32_t geomIndex, geom::Location onLoc)
+        : elt{TopologyLocation(geom::Location::NONE)
+        , TopologyLocation(geom::Location::NONE)}
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(onLoc);
+    };
+
+    /** \brief
+     * Construct a Label with On, Left and Right locations for both Geometries.
+     *
+     * Initialize the locations for both Geometries to the given values.
+     */
+    Label(geom::Location onLoc, geom::Location leftLoc, geom::Location rightLoc)
+        : elt {TopologyLocation(onLoc, leftLoc, rightLoc)
+        , TopologyLocation(onLoc, leftLoc, rightLoc)}
+        {};
+
+    /// Copy ctor
+    Label(const Label& l)
+        : elt{TopologyLocation(l.elt[0])
+        , TopologyLocation(l.elt[1])}
+        {};
+
+    /** \brief
+     * Initialize both locations to Location::NONE
+     *
+     * isNull() should return true after this kind of construction
+     */
+    Label()
+        : elt{TopologyLocation(geom::Location::NONE)
+        , TopologyLocation(geom::Location::NONE)}
+        {};
+
+    /** \brief
+     * Construct a Label with On, Left and Right locations for the
+     * given Geometries.
+     * Initialize the locations for the other Geometry to
+     * Location::NONE
+     */
+    Label(uint32_t geomIndex, geom::Location onLoc, geom::Location leftLoc, geom::Location rightLoc)
+    {
+        elt[0] = TopologyLocation(geom::Location::NONE, geom::Location::NONE, geom::Location::NONE);
+        elt[1] = TopologyLocation(geom::Location::NONE, geom::Location::NONE, geom::Location::NONE);
+        elt[geomIndex].setLocations(onLoc, leftLoc, rightLoc);
+    };
+
+    Label&
+    operator=(const Label& l)
+    {
+        elt[0] = TopologyLocation(l.elt[0]);
+        elt[1] = TopologyLocation(l.elt[1]);
+        return *this;
+    };
+
+    void flip()
+    {
+        elt[0].flip();
+        elt[1].flip();
+    };
+
+    /** \brief
+     * Merge this label with another one.
+     *
+     * Merging updates any null attributes of this label with the attributes
+     * from lbl
+     */
+    void merge(const Label& lbl)
+    {
+        for(int i = 0; i < 2; i++) {
+            elt[i].merge(lbl.elt[i]);
+        }
+    };
+
+    int getGeometryCount() const
+    {
+        int count = 0;
+        if(!elt[0].isNull()) {
+            count++;
+        }
+        if(!elt[1].isNull()) {
+            count++;
+        }
+        return count;
+    };
+
+    geom::Location getLocation(uint32_t geomIndex, uint32_t posIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].get(posIndex);
+    };
+
+    geom::Location getLocation(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].get(Position::ON);
+    };
+
+    void setLocation(uint32_t geomIndex, uint32_t posIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(posIndex, location);
+    };
+
+    void setLocation(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(Position::ON, location);
+    };
+
+    void setAllLocations(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setAllLocations(location);
+    };
+
+    void setAllLocationsIfNull(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setAllLocationsIfNull(location);
+    };
+
+    void setAllLocationsIfNull(geom::Location location)
+    {
+        setAllLocationsIfNull(0, location);
+        setAllLocationsIfNull(1, location);
+    };
+
+    bool isNull(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isNull();
+    };
+
+    bool isNull() const
+    {
+        return elt[0].isNull() && elt[1].isNull();
+    };
+
+    bool isAnyNull(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isAnyNull();
+    };
+
+    bool isArea() const
+    {
+        return elt[0].isArea() || elt[1].isArea();
+    };
+
+    bool isArea(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isArea();
+    };
+
+    bool isLine(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isLine();
+    };
+
+    bool isEqualOnSide(const Label& lbl, uint32_t side) const
+    {
+        return elt[0].isEqualOnSide(lbl.elt[0], side)
+                && elt[1].isEqualOnSide(lbl.elt[1], side);
+    };
+
+    bool allPositionsEqual(uint32_t geomIndex, geom::Location loc) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].allPositionsEqual(loc);
+    };
+
+    /** \brief
+     * Converts one GeometryLocation to a Line location
+     */
+    void toLine(uint32_t geomIndex)
+    {
+        assert(geomIndex < 2);
+        if(elt[geomIndex].isArea()) {
+            elt[geomIndex] = TopologyLocation(elt[geomIndex].getLocations()[0]);
+        }
+    };
+
+    std::string toString() const;
+
+private:
+
+    TopologyLocation elt[2];
+
+};
+
+std::ostream& operator<< (std::ostream&, const Label&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+