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

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/RelateNodeGraph.h

@@ -0,0 +1,98 @@
+/**********************************************************************
+ *
+ * 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/RelateNodeGraph.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/NodeMap.h>
+
+#include <map>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+struct CoordinateLessThan;
+}
+namespace geomgraph {
+//class EdgeEndStar;
+class Node;
+class GeometryGraph;
+class EdgeEnd;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Implements the simple graph of Nodes and geomgraph::EdgeEnd which is all that is
+ * required to determine topological relationships between Geometries.
+ *
+ * Also supports building a topological graph of a single Geometry, to
+ * allow verification of valid topology.
+ *
+ * It is <b>not</b> necessary to create a fully linked
+ * PlanarGraph to determine relationships, since it is sufficient
+ * to know how the Geometries interact locally around the nodes.
+ * In fact, this is not even feasible, since it is not possible to compute
+ * exact intersection points, and hence the topology around those nodes
+ * cannot be computed robustly.
+ * The only Nodes that are created are for improper intersections;
+ * that is, nodes which occur at existing vertices of the Geometries.
+ * Proper intersections (e.g. ones which occur between the interior of
+ * line segments)
+ * have their topology determined implicitly, without creating a geomgraph::Node object
+ * to represent them.
+ *
+ */
+class GEOS_DLL RelateNodeGraph {
+
+public:
+
+    RelateNodeGraph();
+
+    virtual ~RelateNodeGraph();
+
+    geomgraph::NodeMap::container& getNodeMap();
+
+    void build(geomgraph::GeometryGraph* geomGraph);
+
+    void computeIntersectionNodes(geomgraph::GeometryGraph* geomGraph,
+                                  uint8_t argIndex);
+
+    void copyNodesAndLabels(geomgraph::GeometryGraph* geomGraph, uint8_t argIndex);
+
+    void insertEdgeEnds(std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& ee);
+
+private:
+
+    geomgraph::NodeMap* nodes;
+
+    RelateNodeGraph(const RelateNodeGraph&) = delete;
+    RelateNodeGraph& operator=(const RelateNodeGraph&) = delete;
+
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/relate/RelateOp.h

@@ -0,0 +1,134 @@
+/**********************************************************************
+ *
+ * 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/RelateOp.java rev. 1.19 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/IntersectionMatrix.h>
+#include <geos/operation/GeometryGraphOperation.h> // for inheritance
+#include <geos/operation/relate/RelateComputer.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class BoundaryNodeRule;
+}
+namespace geom {
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace relate { // geos::operation::relate
+
+/** \brief
+ * Implements the SFS `relate()` operation on two
+ * geom::Geometry objects.
+ *
+ * This class supports specifying a custom algorithm::BoundaryNodeRule
+ * to be used during the relate computation.
+ *
+ * @note Custom Boundary Node Rules do not (currently)
+ * affect the results of other Geometry methods (such
+ * as [Geometry::getBoundary()](@ref geom::Geometry::getBoundary() const)).
+ * The results of these methods may not be consistent with the relationship
+ * computed by a custom Boundary Node Rule.
+ *
+ */
+class GEOS_DLL RelateOp: public GeometryGraphOperation {
+
+public:
+
+    /** \brief
+     * Computes the geom::IntersectionMatrix for the spatial relationship
+     * between two geom::Geometry objects, using the default (OGC SFS)
+     * Boundary Node Rule
+     *
+     * @param a a Geometry to test. Ownership left to caller.
+     * @param b a Geometry to test. Ownership left to caller.
+     *
+     * @return the IntersectonMatrix for the spatial relationship
+     *         between the geometries. Ownership transferred.
+     */
+    static std::unique_ptr<geom::IntersectionMatrix> relate(
+        const geom::Geometry* a,
+        const geom::Geometry* b);
+
+    /** \brief
+     * Computes the geom::IntersectionMatrix for the spatial relationship
+     * between two geom::Geometry objects, using a specified
+     * Boundary Node Rule.
+     *
+     * @param a a Geometry to test. Ownership left to caller.
+     * @param b a Geometry to test. Ownership left to caller.
+     * @param boundaryNodeRule the Boundary Node Rule to use.
+     *
+     * @return the IntersectonMatrix for the spatial relationship
+     *         between the geometries. Ownership transferred.
+     */
+    static std::unique_ptr<geom::IntersectionMatrix> relate(
+        const geom::Geometry* a,
+        const geom::Geometry* b,
+        const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    /** \brief
+     * Creates a new Relate operation, using the default (OGC SFS)
+     * Boundary Node Rule.
+     *
+     * @param g0 a Geometry to relate. Ownership left to caller.
+     * @param g1 another Geometry to relate. Ownership to caller.
+     */
+    RelateOp(const geom::Geometry* g0,
+             const geom::Geometry* g1);
+
+    /** \brief
+     * Creates a new Relate operation with a specified
+     * Boundary Node Rule.
+     *
+     * @param g0 a Geometry to relate. Ownership left to caller.
+     * @param g1 another Geometry to relate. Ownership to caller.
+     * @param boundaryNodeRule the Boundary Node Rule to use
+     */
+    RelateOp(const geom::Geometry* g0,
+             const geom::Geometry* g1,
+             const algorithm::BoundaryNodeRule& boundaryNodeRule);
+
+    ~RelateOp() override = default;
+
+    /** \brief
+     * Gets the IntersectionMatrix for the spatial relationship
+     * between the input geometries.
+     *
+     * @return the geom::IntersectionMatrix for the spatial
+     *         relationship between the input geometries.
+     *         Ownership transferred.
+     */
+    std::unique_ptr<geom::IntersectionMatrix> getIntersectionMatrix();
+
+private:
+
+    RelateComputer relateComp;
+};
+
+
+} // namespace geos:operation:relate
+} // namespace geos:operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/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
+