@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/EdgeSetIntersector.h

@@ -0,0 +1,93 @@
+/**********************************************************************
+ *
+ * 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/index/strtree/TemplateSTRtree.h>
+#include <geos/index/chain/MonotoneChain.h>
+#include <geos/export.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Geometry;
+    class Envelope;
+}
+namespace noding {
+    class SegmentString;
+}
+namespace operation {
+namespace relateng {
+    class RelateSegmentString;
+    class EdgeSegmentIntersector;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+class GEOS_DLL EdgeSetIntersector {
+    using Envelope = geos::geom::Envelope;
+    using Geometry = geos::geom::Geometry;
+    template <typename ItemType>
+    using TemplateSTRtree = geos::index::strtree::TemplateSTRtree<ItemType>;
+    using MonotoneChain = geos::index::chain::MonotoneChain;
+    using SegmentString = geos::noding::SegmentString;
+    using EdgeSegmentIntersector = geos::operation::relateng::EdgeSegmentIntersector;
+
+private:
+
+    // Members
+    TemplateSTRtree<const MonotoneChain*> index;
+    // HPRtree index = new HPRtree();
+    const Envelope* envelope = nullptr;
+    std::deque<MonotoneChain> monoChains;
+    std::size_t overlapCounter = 0;
+
+
+    // Methods
+
+    void addToIndex(const SegmentString* segStr);
+
+    void addEdges(std::vector<const SegmentString*>& segStrings);
+
+
+public:
+
+    EdgeSetIntersector(
+        std::vector<const SegmentString*>& edgesA,
+        std::vector<const SegmentString*>& edgesB,
+        const Envelope* env)
+        : envelope(env)
+        {
+            addEdges(edgesA);
+            addEdges(edgesB);
+            // build index to ensure thread-safety
+            // index.build();
+        };
+
+    void process(EdgeSegmentIntersector& intersector);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/IMPatternMatcher.h

@@ -0,0 +1,83 @@
+/**********************************************************************
+ *
+ * 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/geom/Dimension.h>
+#include <geos/geom/IntersectionMatrix.h>
+#include <geos/operation/relateng/IMPredicate.h>
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Envelope;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation.
+namespace relateng {  // geos.operation.relateng
+
+
+class GEOS_DLL IMPatternMatcher : public IMPredicate {
+    using Envelope = geos::geom::Envelope;
+    using Location = geos::geom::Location;
+    using Dimension = geos::geom::Dimension;
+    using IntersectionMatrix = geos::geom::IntersectionMatrix;
+
+private:
+
+    std::string imPattern;
+    IntersectionMatrix patternMatrix;
+
+    static bool requireInteraction(const IntersectionMatrix& im);
+
+    static bool isInteraction(int imDim);
+
+
+public:
+
+    IMPatternMatcher(std::string p_imPattern)
+        : imPattern(p_imPattern)
+        , patternMatrix(p_imPattern)
+        {};
+
+    std::string name() const override;
+
+    using IMPredicate::init;
+    void init(const Envelope& envA, const Envelope& envB) override;
+
+    bool requireInteraction() const override;
+
+    bool isDetermined() const override;
+
+    bool valueIM() override;
+
+    std::string toString() const;
+
+    friend std::ostream& operator<<(std::ostream& os, const IMPatternMatcher& imp);
+
+};
+
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/IMPredicate.h

@@ -0,0 +1,129 @@
+/**********************************************************************
+ *
+ * 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/geom/Dimension.h>
+#include <geos/geom/IntersectionMatrix.h>
+#include <geos/operation/relateng/BasicPredicate.h>
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Envelope;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation.
+namespace relateng {  // geos.operation.relateng
+
+
+class GEOS_DLL IMPredicate : public BasicPredicate {
+protected:
+    using Envelope = geos::geom::Envelope;
+    using Location = geos::geom::Location;
+    using Dimension = geos::geom::Dimension;
+    using IntersectionMatrix = geos::geom::IntersectionMatrix;
+
+private:
+
+
+
+protected:
+
+    static constexpr int DIM_UNKNOWN = Dimension::DONTCARE;
+
+    int dimA;
+    int dimB;
+    IntersectionMatrix intMatrix;
+
+    /**
+     * Gets the value of the predicate according to the current
+     * intersection matrix state.
+     *
+     * @return the current predicate value
+     */
+    virtual bool valueIM() = 0;
+
+    /**
+     * Tests whether predicate evaluation can be short-circuited
+     * due to the current state of the matrix providing
+     * enough information to determine the predicate value.
+     *
+     * If this value is true then valueIM()
+     * must provide the correct result of the predicate.
+     *
+     * @return true if the predicate value is determined
+     */
+    virtual bool isDetermined() const = 0;
+
+    /**
+     * Tests whether the exterior of the specified input geometry
+     * is intersected by any part of the other input.
+     *
+     * @param isA the input geometry
+     * @return true if the input geometry exterior is intersected
+     */
+    bool intersectsExteriorOf(bool isA) const;
+
+    bool isIntersects(Location locA, Location locB) const;
+
+
+public:
+
+    IMPredicate()
+    {
+        // intMatrix = new IntersectionMatrix();
+        //-- E/E is always dim = 2
+        intMatrix.set(Location::EXTERIOR, Location::EXTERIOR, Dimension::A);
+    }
+
+    static bool isDimsCompatibleWithCovers(int dim0, int dim1);
+
+    void init(int dA, int dB) override;
+
+    void updateDimension(Location locA, Location locB, int dimension) override;
+
+    bool isDimChanged(Location locA, Location locB, int dimension) const;
+
+    using TopologyPredicate::isKnown;
+    bool isKnown(Location locA, Location locB) const;
+
+    bool isDimension(Location locA, Location locB, int dimension) const;
+
+    int getDimension(Location locA, Location locB) const;
+
+    /**
+     * Sets the final value based on the state of the IM.
+     */
+    void finish() override;
+
+    std::string toString() const;
+
+    friend std::ostream& operator<<(std::ostream& os, const IMPredicate& imp);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/IntersectionMatrixPattern.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+
+#include <string>
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng {  // geos.operation.relateng
+
+
+class GEOS_DLL IntersectionMatrixPattern {
+
+private:
+
+    /**
+     * Cannot be instantiated.
+     */
+    IntersectionMatrixPattern() {};
+
+
+public:
+
+    /**
+     * A DE-9IM pattern to detect whether two polygonal geometries are adjacent along
+     * an edge, but do not overlap.
+     */
+    static constexpr const char* ADJACENT = "F***1****";
+
+    /**
+     * A DE-9IM pattern to detect a geometry which properly contains another
+     * geometry (i.e. which lies entirely in the interior of the first geometry).
+     */
+    static constexpr const char* CONTAINS_PROPERLY = "T**FF*FF*";
+
+    /**
+     * A DE-9IM pattern to detect if two geometries intersect in their interiors.
+     * This can be used to determine if a polygonal coverage contains any overlaps
+     * (although not whether they are correctly noded).
+     */
+    static constexpr const char* INTERIOR_INTERSECTS = "T********";
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/LineStringExtracter.h

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * 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/GeometryFilter.h>
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class LineString;
+    class Geometry;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng {  // geos.operation.relateng
+
+
+class GEOS_DLL LineStringExtracter : public geos::geom::GeometryFilter {
+    using LineString = geos::geom::LineString;
+    using Geometry = geos::geom::Geometry;
+
+private:
+
+    std::vector<const LineString*>& comps;
+
+
+public:
+
+    LineStringExtracter(std::vector<const LineString*>& p_comps)
+        : comps(p_comps)
+        {}
+
+    void filter_ro(const geom::Geometry* geom) override;
+
+    static void getLines(const Geometry* geom, std::vector<const LineString*>& lines);
+
+    static std::vector<const LineString*> getLines(const Geometry* geom);
+
+    /**
+    * Extracts the {@link LineString} elements from a single {@link Geometry}
+    * and returns them as either a {@link LineString} or {@link MultiLineString}.
+    *
+    * @param geom the geometry from which to extract
+    * @return a linear geometry
+    */
+    // static std::unique_ptr<Geometry> getGeometry(const Geometry* geom);
+
+};
+
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/LinearBoundary.h

@@ -0,0 +1,85 @@
+/**********************************************************************
+ *
+ * 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/Coordinate.h>
+#include <geos/export.h>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+    class BoundaryNodeRule;
+}
+namespace geom {
+    class CoordinateXY;
+    class LineString;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+class GEOS_DLL LinearBoundary {
+    using BoundaryNodeRule = geos::algorithm::BoundaryNodeRule;
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using LineString = geos::geom::LineString;
+
+private:
+
+    // Members
+
+    Coordinate::ConstIntMap m_vertexDegree;
+    bool m_hasBoundary;
+    const BoundaryNodeRule& m_boundaryNodeRule;
+
+
+public:
+
+    // Constructors
+
+    LinearBoundary(std::vector<const LineString*>& lines, const BoundaryNodeRule& bnRule);
+
+    bool hasBoundary() const;
+
+    bool isBoundary(const CoordinateXY* pt) const;
+
+
+private:
+
+    // Methods
+
+    bool checkBoundary(Coordinate::ConstIntMap& vertexDegree) const;
+
+    static void computeBoundaryPoints(
+        std::vector<const LineString*>& lines,
+        Coordinate::ConstIntMap& vertexDegree);
+
+    static void addEndpoint(
+        const CoordinateXY *p,
+        Coordinate::ConstIntMap& vertexDegree);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/relateng/NodeSection.h

@@ -0,0 +1,163 @@
+/**********************************************************************
+ *
+ * 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/export.h>
+#include <geos/geom/Coordinate.h>
+
+#include <string>
+#include <sstream>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class Geometry;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+/**
+ * Represents a computed node along with the incident edges on either side of
+ * it (if they exist).
+ * This captures the information about a node in a geometry component
+ * required to determine the component's contribution to the node topology.
+ * A node in an area geometry always has edges on both sides of the node.
+ * A node in a linear geometry may have one or other incident edge missing, if
+ * the node occurs at an endpoint of the line.
+ * The edges of an area node are assumed to be provided
+ * with CW-shell orientation (as per JTS norm).
+ * This must be enforced by the caller.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL NodeSection {
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using Geometry = geos::geom::Geometry;
+
+private:
+
+    // Members
+    bool m_isA;
+    int m_dim;
+    int m_id;
+    int m_ringId;
+    const Geometry* m_poly;
+    bool m_isNodeAtVertex;
+    const CoordinateXY* m_v0;
+    const CoordinateXY m_nodePt;
+    const CoordinateXY* m_v1;
+
+    // Methods
+
+    static int compareWithNull(const CoordinateXY* v0, const CoordinateXY* v1);
+
+    static int compare(int a, int b);
+
+public:
+
+    NodeSection(
+        bool isA,
+        int dim,
+        int id,
+        int ringId,
+        const Geometry* poly,
+        bool isNodeAtVertex,
+        const CoordinateXY* v0,
+        const CoordinateXY nodePt,
+        const CoordinateXY* v1)
+        : m_isA(isA)
+        , m_dim(dim)
+        , m_id(id)
+        , m_ringId(ringId)
+        , m_poly(poly)
+        , m_isNodeAtVertex(isNodeAtVertex)
+        , m_v0(v0)
+        , m_nodePt(nodePt)
+        , m_v1(v1)
+        {};
+
+    NodeSection(const NodeSection* ns)
+        : m_isA(ns->isA())
+        , m_dim(ns->dimension())
+        , m_id(ns->id())
+        , m_ringId(ns->ringId())
+        , m_poly(ns->getPolygonal())
+        , m_isNodeAtVertex(ns->isNodeAtVertex())
+        , m_v0(ns->getVertex(0))
+        , m_nodePt(ns->nodePt())
+        , m_v1(ns->getVertex(1))
+        {};
+
+    const CoordinateXY* getVertex(int i) const;
+
+    const CoordinateXY& nodePt() const;
+
+    int dimension() const;
+
+    int id() const;
+
+    int ringId() const;
+
+    /**
+    * Gets the polygon this section is part of.
+    * Will be null if section is not on a polygon boundary.
+    *
+    * @return the associated polygon, or null
+    */
+    const Geometry* getPolygonal() const;
+
+    bool isShell() const;
+
+    bool isArea() const;
+
+    static bool isAreaArea(const NodeSection& a, const NodeSection& b);
+
+    bool isA() const;
+
+    bool isSameGeometry(const NodeSection& ns) const;
+
+    bool isSamePolygon(const NodeSection& ns) const;
+
+    bool isNodeAtVertex() const;
+
+    bool isProper() const;
+
+    static bool isProper(const NodeSection& a, const NodeSection& b);
+
+    std::string toString() const;
+
+    static std::string edgeRep(const CoordinateXY* p0, const CoordinateXY* p1);
+
+    friend std::ostream& operator<<(std::ostream& os, const NodeSection& ns);
+
+    /**
+    * Compare node sections by parent geometry, dimension, element id and ring id,
+    * and edge vertices.
+    * Sections are assumed to be at the same node point.
+    */
+    int compareTo(const NodeSection& o) const;
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+