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

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relate/RelateComputer.h

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 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/relate/RelateComputer.java rev. 1.24 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/PointLocator.h> // for RelateComputer composition
+#include <geos/algorithm/LineIntersector.h> // for RelateComputer composition
+#include <geos/geomgraph/NodeMap.h> // for RelateComputer composition
+#include <geos/geom/Coordinate.h> // for RelateComputer composition
+#include <geos/geom/IntersectionMatrix.h>
+
+#include <vector>
+#include <memory>
+
+#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 algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class Geometry;
+}
+namespace geomgraph {
+class GeometryGraph;
+class Edge;
+class EdgeEnd;
+class Node;
+namespace index {
+class SegmentIntersector;
+}
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Computes the topological relationship between two Geometries.
+ *
+ * RelateComputer does not need to build a complete graph structure to compute
+ * the IntersectionMatrix.  The relationship between the geometries can
+ * be computed by simply examining the labelling of edges incident on each node.
+ *
+ * RelateComputer does not currently support arbitrary GeometryCollections.
+ * This is because GeometryCollections can contain overlapping Polygons.
+ * In order to correct compute relate on overlapping Polygons, they
+ * would first need to be noded and merged (if not explicitly, at least
+ * implicitly).
+ *
+ */
+class GEOS_DLL RelateComputer {
+public:
+    RelateComputer(std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& newArg);
+    ~RelateComputer() = default;
+
+    std::unique_ptr<geom::IntersectionMatrix> computeIM();
+private:
+
+    algorithm::LineIntersector li;
+
+    algorithm::PointLocator ptLocator;
+
+    /// the arg(s) of the operation
+    const std::vector<std::unique_ptr<geomgraph::GeometryGraph>>& arg;
+
+    geomgraph::NodeMap nodes;
+
+    /// this intersection matrix will hold the results compute for the relate
+    std::unique_ptr<geom::IntersectionMatrix> im;
+
+    std::vector<geomgraph::Edge*> isolatedEdges;
+
+    /// the intersection point found (if any)
+    geom::Coordinate invalidPoint;
+
+    void insertEdgeEnds(std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& ee);
+
+    void computeProperIntersectionIM(
+        geomgraph::index::SegmentIntersector* intersector,
+        geom::IntersectionMatrix* imX);
+
+    void copyNodesAndLabels(uint8_t argIndex);
+    void computeIntersectionNodes(uint8_t argIndex);
+    void labelIntersectionNodes(uint8_t argIndex);
+
+    /**
+     * If the Geometries are disjoint, we need to enter their dimension and
+     * boundary dimension in the Ext rows in the IM
+     */
+    void computeDisjointIM(geom::IntersectionMatrix* imX,
+                           const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    void labelNodeEdges();
+
+    /**
+     * update the IM with the sum of the IMs for each component
+     */
+    void updateIM(geom::IntersectionMatrix& imX);
+
+    /**
+     * Compute the IM entry for the intersection of the boundary
+     * of a geometry with the Exterior.
+     * This is the nominal dimension of the boundary
+     * unless the boundary is empty, in which case it is {@link Dimension#FALSE}.
+     * For linear geometries the Boundary Node Rule determines
+     * whether the boundary is empty.
+     *
+     * @param geom the geometry providing the boundary
+     * @param boundaryNodeRule  the Boundary Node Rule to use
+     * @return the IM dimension entry
+     */
+    static int getBoundaryDim(const geom::Geometry& geom,
+                              const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    /**
+     * Processes isolated edges by computing their labelling and adding them
+     * to the isolated edges list.
+     * Isolated edges are guaranteed not to touch the boundary of the target
+     * (since if they
+     * did, they would have caused an intersection to be computed and hence would
+     * not be isolated)
+     */
+    void labelIsolatedEdges(uint8_t thisIndex, uint8_t targetIndex);
+
+    /**
+     * Label an isolated edge of a graph with its relationship to the target
+     * geometry.
+     * If the target has dim 2 or 1, the edge can either be in the interior
+     * or the exterior.
+     * If the target has dim 0, the edge must be in the exterior
+     */
+    void labelIsolatedEdge(geomgraph::Edge* e, uint8_t targetIndex,
+                           const geom::Geometry* target);
+
+    /**
+     * Isolated nodes are nodes whose labels are incomplete
+     * (e.g. the location for one Geometry is null).
+     * This is the case because nodes in one graph which don't intersect
+     * nodes in the other are not completely labelled by the initial process
+     * of adding nodes to the nodeList.
+     * To complete the labelling we need to check for nodes that lie in the
+     * interior of edges, and in the interior of areas.
+     */
+    void labelIsolatedNodes();
+
+    /**
+     * Label an isolated node with its relationship to the target geometry.
+     */
+    void labelIsolatedNode(geomgraph::Node* n, uint8_t targetIndex);
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relate/RelateNode.h

@@ -0,0 +1,67 @@
+/**********************************************************************
+ *
+ * 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: operation/relate/RelateNode.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/Node.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+class Coordinate;
+}
+namespace geomgraph {
+class EdgeEndStar;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Represents a node in the topological graph used to compute spatial
+ * relationships.
+ */
+class GEOS_DLL RelateNode final: public geomgraph::Node {
+
+public:
+
+    RelateNode(const geom::Coordinate& coord, geomgraph::EdgeEndStar* edges);
+
+    ~RelateNode() override = default;
+
+    /**
+     * Update the IM with the contribution for the EdgeEnds incident on this node.
+     */
+    void updateIMFromEdges(geom::IntersectionMatrix& im);
+
+protected:
+
+    void computeIM(geom::IntersectionMatrix& im) override;
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relateng/AdjacentEdgeLocator.h

@@ -0,0 +1,124 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2024 Martin Davis
+ * Copyright (C) 2024 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/geom/CoordinateSequence.h>
+#include <geos/geom/Location.h>
+#include <geos/export.h>
+
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+    class NodeSections;
+    class NodeSection;
+}
+}
+namespace geom {
+    class CoordinateXY;
+    class Geometry;
+    class LinearRing;
+    class Polygon;
+}
+}
+
+
+using geos::geom::CoordinateXY;
+using geos::geom::CoordinateSequence;
+using geos::geom::Geometry;
+using geos::geom::LinearRing;
+using geos::geom::Polygon;
+using geos::geom::Location;
+
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng {  // geos.operation.relateng
+
+/**
+ * Determines the location for a point which is known to lie
+ * on at least one edge of a set of polygons.
+ * This provides the union-semantics for determining
+ * point location in a GeometryCollection, which may
+ * have polygons with adjacent edges which are effectively
+ * in the interior of the geometry.
+ * Note that it is also possible to have adjacent edges which
+ * lie on the boundary of the geometry
+ * (e.g. a polygon contained within another polygon with adjacent edges).
+ *
+ * @author mdavis
+ *
+ */
+class GEOS_DLL AdjacentEdgeLocator {
+
+public:
+
+    AdjacentEdgeLocator(const Geometry* geom)
+    {
+        init(geom);
+    }
+
+    Location locate(const CoordinateXY* p);
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    AdjacentEdgeLocator(const AdjacentEdgeLocator&) = delete;
+    AdjacentEdgeLocator& operator=(const AdjacentEdgeLocator&) = delete;
+
+
+private:
+
+    // Members
+
+    std::vector<const CoordinateSequence*> ringList;
+
+    /*
+     * When we have to reorient rings, we end up allocating new
+     * rings, since we cannot reorient the rings of the input
+     * geometry, so this is where we store those "local" rings.
+     */
+    std::vector<std::unique_ptr<CoordinateSequence>> localRingList;
+
+
+    // Methods
+
+    void addSections(
+        const CoordinateXY* p,
+        const CoordinateSequence* ring,
+        NodeSections& sections);
+
+    NodeSection* createSection(
+        const CoordinateXY* p,
+        const CoordinateXY* prev,
+        const CoordinateXY* next);
+
+    void init(const Geometry* geom);
+
+    void addRings(const Geometry* geom);
+
+    void addRing(const LinearRing* ring, bool requireCW);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relateng/BasicPredicate.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2024 Martin Davis
+ * Copyright (C) 2024 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/geom/Location.h>
+#include <geos/operation/relateng/TopologyPredicate.h>
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Envelope;
+}
+}
+
+
+using geos::geom::Envelope;
+using geos::geom::Location;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation.
+namespace relateng {  // geos.operation.relateng
+
+
+class GEOS_DLL BasicPredicate : public TopologyPredicate {
+
+private:
+
+    static constexpr int UNKNOWN = -1;
+    static constexpr int FALSE = 0;
+    static constexpr int TRUE = 1;
+
+    int m_value = UNKNOWN;
+
+    static bool isKnown(int val);
+
+    static bool toBoolean(int val);
+
+    static int toValue(bool val);
+
+
+protected:
+
+    /**
+    * Updates the predicate value to the given state
+    * if it is currently unknown.
+    *
+    * @param val the predicate value to update
+    */
+    void setValue(bool val);
+
+    void setValue(int val);
+
+    void setValueIf(bool val, bool cond);
+
+    void require(bool cond);
+
+    using TopologyPredicate::requireCovers;
+    void requireCovers(const Envelope& a, const Envelope& b);
+
+
+public:
+
+    /**
+    * Tests if two geometries intersect
+    * based on an interaction at given locations.
+    *
+    * @param locA the location on geometry A
+    * @param locB the location on geometry B
+    * @return true if the geometries intersect
+    */
+    static bool isIntersection(Location locA, Location locB);
+
+    std::string name() const override = 0;
+
+    void finish() override = 0;
+
+    bool isKnown() const override;
+
+    bool value() const override;
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relateng/DimensionLocation.h

@@ -0,0 +1,60 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2024 Martin Davis
+ * Copyright (C) 2024 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/geom/Location.h>
+#include <geos/export.h>
+
+
+using geos::geom::Location;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+
+class GEOS_DLL DimensionLocation {
+
+public:
+
+    enum DimensionLocationType {
+        EXTERIOR = 2,           // == Location.EXTERIOR
+        POINT_INTERIOR = 103,
+        LINE_INTERIOR = 110,
+        LINE_BOUNDARY = 111,
+        AREA_INTERIOR = 120,
+        AREA_BOUNDARY = 121
+    };
+
+    static int locationArea(Location loc);
+
+    static int locationLine(Location loc);
+
+    static int locationPoint(Location loc);
+
+    static Location location(int dimLoc);
+
+    static int dimension(int dimLoc);
+
+    static int dimension(int dimLoc, int exteriorDim);
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relateng/EdgeSegmentIntersector.h

@@ -0,0 +1,80 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (c) 2024 Martin Davis
+ * Copyright (C) 2024 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/noding/SegmentIntersector.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/export.h>
+
+
+// Forward declarations
+namespace geos {
+namespace noding {
+    class SegmentString;
+}
+namespace operation {
+namespace relateng {
+    class RelateSegmentString;
+    class TopologyComputer;
+}
+}
+}
+
+
+using geos::noding::SegmentIntersector;
+using geos::noding::SegmentString;
+using geos::algorithm::LineIntersector;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+class GEOS_DLL EdgeSegmentIntersector : public SegmentIntersector {
+
+private:
+
+    // Members
+    LineIntersector li;
+    TopologyComputer& topoComputer;
+
+    // Methods
+
+
+    void addIntersections(
+        RelateSegmentString* ssA, std::size_t segIndexA,
+        RelateSegmentString* ssB, std::size_t segIndexB);
+
+
+public:
+
+    EdgeSegmentIntersector(TopologyComputer& p_topoComputer)
+        : topoComputer(p_topoComputer)
+        {};
+
+    void processIntersections(
+        SegmentString* ss0, std::size_t segIndex0,
+        SegmentString* ss1, std::size_t segIndex1) override;
+
+    bool isDone() const override;
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relateng/EdgeSegmentOverlapAction.h

@@ -0,0 +1,75 @@
+/**********************************************************************
+ *
+ * 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/MonotoneChainOverlapAction.java rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/LineSegment.h>
+#include <geos/index/chain/MonotoneChainOverlapAction.h>
+
+
+// Forward declarations
+namespace geos {
+namespace index {
+namespace chain {
+    class MonotoneChain;
+}
+}
+namespace noding {
+    class SegmentIntersector;
+}
+}
+
+
+using geos::index::chain::MonotoneChain;
+using geos::index::chain::MonotoneChainOverlapAction;
+using geos::noding::SegmentIntersector;
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relateng {  // geos::operation::relateng
+
+/** \brief
+ * The action for the internal iterator for performing
+ * overlap queries on a MonotoneChain.
+ */
+class GEOS_DLL EdgeSegmentOverlapAction : public MonotoneChainOverlapAction {
+
+private:
+
+    SegmentIntersector& si;
+
+
+public:
+
+    EdgeSegmentOverlapAction(SegmentIntersector& p_si)
+        : si(p_si)
+        {}
+
+    void overlap(
+        const MonotoneChain& mc1, std::size_t start1,
+        const MonotoneChain& mc2, std::size_t start2) override;
+
+
+};
+
+} // namespace geos::index::chain
+} // namespace geos::index
+} // namespace geos
+