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

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/PlanarGraph.h

@@ -0,0 +1,203 @@
+/**********************************************************************
+ *
+ * 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/PlanarGraph.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <map>
+#include <vector>
+#include <memory>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/geomgraph/PlanarGraph.h>
+#include <geos/geomgraph/NodeMap.h> // for typedefs
+#include <geos/geomgraph/DirectedEdgeStar.h> // for inlines
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Edge;
+class Node;
+class EdgeEnd;
+class NodeFactory;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/**
+ * \brief
+ * Represents a directed graph which is embeddable in a planar surface.
+ *
+ * The computation of the IntersectionMatrix relies on the use of a structure
+ * called a "topology graph".  The topology graph contains nodes and edges
+ * corresponding to the nodes and line segments of a Geometry. Each
+ * node and edge in the graph is labeled with its topological location
+ * relative to the source geometry.
+ *
+ * Note that there is no requirement that points of self-intersection
+ * be a vertex.
+ * Thus to obtain a correct topology graph, Geometry objects must be
+ * self-noded before constructing their graphs.
+ *
+ * Two fundamental operations are supported by topology graphs:
+ *
+ *  - Computing the intersections between all the edges and nodes of
+ *    a single graph
+ *  - Computing the intersections between the edges and nodes of two
+ *    different graphs
+ *
+ */
+class GEOS_DLL PlanarGraph /* non-final */ {
+public:
+
+    /** \brief
+     * For nodes in the collection (first..last),
+     * link the DirectedEdges at the node that are in the result.
+     *
+     * This allows clients to link only a subset of nodes in the graph,
+     * for efficiency (because they know that only a subset is of
+     * interest).
+     */
+    template <typename It>
+    static void
+    linkResultDirectedEdges(It first, It last)
+    // throw(TopologyException);
+    {
+        for(; first != last; ++first) {
+            Node* node = *first;
+            assert(node);
+
+            EdgeEndStar* ees = node->getEdges();
+            assert(ees);
+            DirectedEdgeStar* des = dynamic_cast<DirectedEdgeStar*>(ees);
+            assert(des);
+
+            // this might throw an exception
+            des->linkResultDirectedEdges();
+        }
+    }
+
+    PlanarGraph(const NodeFactory& nodeFact);
+
+    PlanarGraph();
+
+    virtual ~PlanarGraph();
+
+    std::vector<Edge*>::iterator getEdgeIterator();
+
+    std::vector<EdgeEnd*>* getEdgeEnds();
+
+    bool isBoundaryNode(uint8_t geomIndex, const geom::Coordinate& coord);
+
+    void add(EdgeEnd* e);
+
+    NodeMap::iterator getNodeIterator();
+
+    void getNodes(std::vector<Node*>&);
+
+    Node* addNode(Node* node);
+
+    Node* addNode(const geom::Coordinate& coord);
+
+    /**
+     * @return the node if found; null otherwise
+     */
+    Node* find(geom::Coordinate& coord);
+
+    /** \brief
+     * Add a set of edges to the graph.  For each edge two DirectedEdges
+     * will be created.  DirectedEdges are NOT linked by this method.
+     */
+    void addEdges(const std::vector<Edge*>& edgesToAdd);
+
+    void linkResultDirectedEdges();
+
+    void linkAllDirectedEdges();
+
+    /** \brief
+     * Returns the EdgeEnd which has edge e as its base edge
+     * (MD 18 Feb 2002 - this should return a pair of edges)
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    EdgeEnd* findEdgeEnd(Edge* e);
+
+    /** \brief
+     * Returns the edge whose first two coordinates are p0 and p1
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    Edge* findEdge(const geom::Coordinate& p0,
+                           const geom::Coordinate& p1);
+
+    /** \brief
+     * Returns the edge which starts at p0 and whose first segment is
+     * parallel to p1
+     *
+     * @return the edge, if found
+     *    <code>null</code> if the edge was not found
+     */
+    Edge* findEdgeInSameDirection(const geom::Coordinate& p0,
+                                          const geom::Coordinate& p1);
+
+    std::string printEdges();
+
+    NodeMap* getNodeMap();
+
+protected:
+
+    std::vector<Edge*>* edges;
+
+    NodeMap* nodes;
+
+    std::vector<EdgeEnd*>* edgeEndList;
+
+    void insertEdge(Edge* e);
+
+private:
+
+    /** \brief
+     * The coordinate pairs match if they define line segments
+     * lying in the same direction.
+     *
+     * E.g. the segments are parallel and in the same quadrant
+     * (as opposed to parallel and opposite!).
+     */
+    bool matchInSameDirection(const geom::Coordinate& p0,
+                              const geom::Coordinate& p1,
+                              const geom::Coordinate& ep0,
+                              const geom::Coordinate& ep1);
+
+    PlanarGraph(const PlanarGraph&) = delete;
+    PlanarGraph& operator=(const PlanarGraph&) = delete;
+};
+
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/bintree/Bintree.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#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 index {
+namespace bintree {
+class Interval;
+class Root;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace bintree { // geos::index::bintree
+
+/** \brief
+ * A BinTree (or "Binary Interval Tree") is a 1-dimensional version of a quadtree.
+ *
+ * It indexes 1-dimensional intervals (which of course may be the projection
+ * of 2-D objects on an axis). It supports range searching (where the range
+ * may be a single point).
+ *
+ * This implementation does not require specifying the extent of the inserted
+ * items beforehand. It will automatically expand to accommodate any extent
+ * of dataset.
+ *
+ * This index is different to the "Interval Tree of Edelsbrunner"
+ * or the "Segment Tree of Bentley".
+ */
+class GEOS_DLL Bintree {
+
+public:
+
+    /** \brief
+     * Ensure that the Interval for the inserted item has non-zero extents.
+     *
+     * Use the current minExtent to pad it, if necessary.
+     *
+     * @note In GEOS this function always return a newly allocated object
+     *       with ownership transferred to caller. TODO: change this ?
+     *
+     * @param itemInterval source interval, ownership left to caller, no references hold
+     * @param minExtent minimal extent
+     */
+    static Interval* ensureExtent(const Interval* itemInterval,
+                                  double minExtent);
+
+    Bintree();
+
+    ~Bintree();
+
+    int depth();
+
+    int size();
+
+    int nodeSize();
+
+    /// @param itemInterval
+    ///     Ownership left to caller, NO reference hold by this class.
+    ///
+    /// @param item
+    ///     Ownership left to caller, reference kept by this class.
+    ///
+    void insert(Interval* itemInterval, void* item);
+
+    std::vector<void*>* iterator();
+
+    std::vector<void*>* query(double x);
+
+    std::vector<void*>* query(Interval* interval);
+
+    void query(Interval* interval,
+               std::vector<void*>* foundItems);
+
+private:
+
+    std::vector<Interval*>newIntervals;
+
+    Root* root;
+
+    /**
+     *  Statistics
+     *
+     * minExtent is the minimum extent of all items
+     * inserted into the tree so far. It is used as a heuristic value
+     * to construct non-zero extents for features with zero extent.
+     * Start with a non-zero extent, in case the first feature inserted has
+     * a zero extent in both directions.  This value may be non-optimal, but
+     * only one feature will be inserted with this value.
+     */
+    double minExtent;
+
+    void collectStats(Interval* interval);
+
+    Bintree(const Bintree&) = delete;
+    Bintree& operator=(const Bintree&) = delete;
+};
+
+} // namespace geos::index::bintree
+} // namespace geos::index
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/chain/MonotoneChain.h

@@ -0,0 +1,206 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: index/chain/MonotoneChain.java rev. 1.15 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/CoordinateSequence.h> // for inline
+#include <geos/geom/Envelope.h> // for inline
+#include <geos/geom/LineSegment.h> // for inline
+
+#include <memory> // for unique_ptr
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class LineSegment;
+class CoordinateSequence;
+}
+namespace index {
+namespace chain {
+class MonotoneChainSelectAction;
+class MonotoneChainOverlapAction;
+}
+}
+}
+
+namespace geos {
+namespace index { // geos::index
+namespace chain { // geos::index::chain
+
+/** \brief
+ * Monotone Chains are a way of partitioning the segments of a linestring to
+ * allow for fast searching of intersections.
+ *
+ * They have the following properties:
+ *
+ * - the segments within a monotone chain never intersect each other
+ * - the envelope of any contiguous subset of the segments in a monotone
+ *   chain is equal to the envelope of the endpoints of the subset.
+ *
+ * Property 1 means that there is no need to test pairs of segments from
+ * within the same monotone chain for intersection.
+ * Property 2 allows an efficient binary search to be used to find the
+ * intersection points of two monotone chains.
+ *
+ * For many types of real-world data, these properties eliminate
+ * a large number of segment comparisons, producing substantial speed gains.
+ *
+ * One of the goals of this implementation of MonotoneChains is to be
+ * as space and time efficient as possible. One design choice that aids this
+ * is that a MonotoneChain is based on a subarray of a list of points.
+ * This means that new arrays of points (potentially very large) do not
+ * have to be allocated.
+ *
+ * MonotoneChains support the following kinds of queries:
+ *
+ * - Envelope select: determine all the segments in the chain which
+ *   intersect a given envelope
+ * - Overlap: determine all the pairs of segments in two chains whose
+ *   envelopes overlap
+ *
+ * This implementation of MonotoneChains uses the concept of internal iterators
+ * to return the resultsets for the above queries.
+ * This has time and space advantages, since it
+ * is not necessary to build lists of instantiated objects to represent the segments
+ * returned by the query.
+ * However, it does mean that the queries are not thread-safe.
+ *
+ */
+class GEOS_DLL MonotoneChain {
+public:
+
+    /// @param pts
+    ///   Ownership left to caller, this class holds a reference.
+    ///
+    /// @param start
+    ///
+    /// @param end
+    ///
+    /// @param context
+    ///   Ownership left to caller, this class holds a reference.
+    ///
+    MonotoneChain(const geom::CoordinateSequence& pts,
+                  std::size_t start, std::size_t end, void* context);
+
+    ~MonotoneChain() = default;
+
+    /// Returned envelope is owned by this class
+    const geom::Envelope& getEnvelope() const;
+    const geom::Envelope& getEnvelope(double expansionDistance) const;
+
+    size_t
+    getStartIndex() const
+    {
+        return start;
+    }
+
+    size_t
+    getEndIndex() const
+    {
+        return end;
+    }
+
+    /** \brief
+     *  Set given LineSegment with points of the segment starting
+     *  at the given index.
+     */
+    void getLineSegment(std::size_t index, geom::LineSegment& ls) const {
+        pts->getAt(index, ls.p0);
+        pts->getAt(index + 1, ls.p1);
+    }
+
+    /**
+     * Return the subsequence of coordinates forming this chain.
+     * Allocates a new CoordinateSequence to hold the Coordinates
+     *
+     */
+    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
+
+    /**
+     * Determine all the line segments in the chain whose envelopes overlap
+     * the searchEnvelope, and process them
+     */
+    void select(const geom::Envelope& searchEnv,
+                MonotoneChainSelectAction& mcs) const;
+
+    void computeOverlaps(const MonotoneChain* mc,
+                         MonotoneChainOverlapAction* mco) const;
+
+    void computeOverlaps(const MonotoneChain* mc, double overlapTolerance,
+                         MonotoneChainOverlapAction* mco) const;
+
+    void*
+    getContext() const
+    {
+        return context;
+    }
+
+private:
+
+    void computeSelect(const geom::Envelope& searchEnv,
+                       std::size_t start0,
+                       std::size_t end0,
+                       MonotoneChainSelectAction& mcs) const;
+
+    void computeOverlaps(std::size_t start0, std::size_t end0, const MonotoneChain& mc,
+                         std::size_t start1, std::size_t end1,
+                         double overlapTolerance,
+                         MonotoneChainOverlapAction& mco) const;
+
+    bool overlaps(std::size_t start0, std::size_t end0,
+                  const MonotoneChain& mc, std::size_t start1, std::size_t end1,
+                  double overlapTolerance) const {
+        if (overlapTolerance > 0.0) {
+            return overlaps(pts->getAt<geom::CoordinateXY>(start0),
+                            pts->getAt<geom::CoordinateXY>(end0),
+                            mc.pts->getAt<geom::CoordinateXY>(start1),
+                            mc.pts->getAt<geom::CoordinateXY>(end1),
+                            overlapTolerance);
+        }
+        return geom::Envelope::intersects(pts->getAt<geom::CoordinateXY>(start0),
+                                          pts->getAt<geom::CoordinateXY>(end0),
+                                          mc.pts->getAt<geom::CoordinateXY>(start1),
+                                          mc.pts->getAt<geom::CoordinateXY>(end1));
+    }
+
+    static bool overlaps(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                  const geom::CoordinateXY& q1, const geom::CoordinateXY& q2,
+                  double overlapTolerance);
+
+    /// Externally owned
+    const geom::CoordinateSequence* pts;
+
+    /// user-defined information
+    void* context;
+
+    /// Index of chain start vertex into the CoordinateSequence, 0 based.
+    std::size_t start;
+
+    /// Index of chain end vertex into the CoordinateSequence, 0 based.
+    std::size_t end;
+
+    /// Owned by this class
+    mutable geom::Envelope env;
+
+};
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+