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

package/dist/prebuilt/Android-x86_64/include/geos/operation/relateng/NodeSections.h

@@ -0,0 +1,102 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+#include <memory>
+#include <geos/operation/relateng/NodeSection.h>
+#include <geos/export.h>
+
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+class RelateNode;
+// class NodeSection;
+}
+}
+namespace geom {
+    class CoordinateXY;
+    class Geometry;
+}
+}
+
+
+using geos::geom::CoordinateXY;
+using geos::geom::Geometry;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+
+class GEOS_DLL NodeSections {
+
+private:
+
+    // Members
+    const CoordinateXY* nodePt;
+    std::vector<std::unique_ptr<NodeSection>> sections;
+
+    // Methods
+
+    /**
+    * Sorts the sections so that:
+    *  * lines are before areas
+    *  * edges from the same polygon are contiguous
+    */
+    void prepareSections();
+
+    static bool hasMultiplePolygonSections(
+        std::vector<std::unique_ptr<NodeSection>>& sections,
+        std::size_t i);
+
+    static std::vector<const NodeSection*> collectPolygonSections(
+        std::vector<std::unique_ptr<NodeSection>>& sections,
+        std::size_t i);
+
+
+public:
+
+    NodeSections(const CoordinateXY* pt)
+        : nodePt(pt)
+        {};
+
+    const CoordinateXY* getCoordinate() const;
+
+    void addNodeSection(NodeSection* e);
+
+    bool hasInteractionAB() const;
+
+    const Geometry* getPolygonal(bool isA) const;
+
+    std::unique_ptr<RelateNode> createNode();
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    NodeSections(const NodeSections&) = delete;
+    NodeSections& operator=(const NodeSections&) = delete;
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/relateng/PolygonNodeConverter.h

@@ -0,0 +1,112 @@
+/**********************************************************************
+ *
+ * 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/operation/relateng/NodeSection.h>
+#include <geos/export.h>
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+// class NodeSection;
+}
+}
+}
+
+
+// using geos::geom::CoordinateXY;
+// using geos::geom::Geometry;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng {  // geos.operation.relateng
+
+/**
+ * Converts the node sections at a polygon node where
+ * a shell and one or more holes touch, or two or more holes touch.
+ * This converts the node topological structure from
+ * the OGC "touching-rings" (AKA "minimal-ring") model to the equivalent "self-touch"
+ * (AKA "inverted/exverted ring" or "maximal ring") model.
+ * In the "self-touch" model the converted NodeSection corners enclose areas
+ * which all lies inside the polygon
+ * (i.e. they does not enclose hole edges).
+ * This allows RelateNode to use simple area-additive semantics
+ * for adding edges and propagating edge locations.
+ *
+ * The input node sections are assumed to have canonical orientation
+ * (CW shells and CCW holes).
+ * The arrangement of shells and holes must be topologically valid.
+ * Specifically, the node sections must not cross or be collinear.
+ *
+ * This supports multiple shell-shell touches
+ * (including ones containing holes), and hole-hole touches,
+ * This generalizes the relate algorithm to support
+ * both the OGC model and the self-touch model.
+ *
+ * @author Martin Davis
+ * @see RelateNode
+ */
+class GEOS_DLL PolygonNodeConverter {
+
+public:
+
+    /**
+    * Converts a list of sections of valid polygon rings
+    * to have "self-touching" structure.
+    * There are the same number of output sections as input ones.
+    *
+    * @param polySections the original sections
+    * @return the converted sections
+    */
+    static std::vector<std::unique_ptr<NodeSection>> convert(
+        std::vector<const NodeSection*>& polySections);
+
+
+private:
+
+    static std::size_t convertShellAndHoles(
+        std::vector<const NodeSection*>& sections,
+        std::size_t shellIndex,
+        std::vector<std::unique_ptr<NodeSection>>& convertedSections);
+
+    static std::vector<std::unique_ptr<NodeSection>> convertHoles(
+        std::vector<const NodeSection*>& sections);
+
+    static NodeSection* createSection(
+        const NodeSection* ns,
+        const CoordinateXY* v0,
+        const CoordinateXY* v1);
+
+    static std::vector<const NodeSection*> extractUnique(
+        std::vector<const NodeSection*>& sections);
+
+    static std::size_t next(
+        std::vector<const NodeSection *>& ns, std::size_t i);
+
+    static std::size_t findShell(
+        std::vector<const NodeSection *>& polySections);
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/relateng/RelateEdge.h

@@ -0,0 +1,176 @@
+/**********************************************************************
+ *
+ * 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>
+
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+class RelateNode;
+}
+}
+namespace geom {
+    class CoordinateXY;
+    class Geometry;
+}
+}
+
+
+using geos::geom::CoordinateXY;
+using geos::geom::Geometry;
+using geos::geom::Location;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+
+class GEOS_DLL RelateEdge {
+
+private:
+
+    /**
+    * Indicates that the location is currently unknown
+    */
+    static constexpr Location LOC_UNKNOWN = Location::NONE;
+
+    // Members
+    const RelateNode* node;
+    const CoordinateXY* dirPt;
+
+    int aDim = DIM_UNKNOWN;
+    Location aLocLeft = LOC_UNKNOWN;
+    Location aLocRight = LOC_UNKNOWN;
+    Location aLocLine = LOC_UNKNOWN;
+
+    int bDim = DIM_UNKNOWN;
+    Location bLocLeft = LOC_UNKNOWN;
+    Location bLocRight = LOC_UNKNOWN;
+    Location bLocLine = LOC_UNKNOWN;
+
+
+public:
+
+    // Constants
+    static constexpr bool IS_FORWARD = true;
+    static constexpr bool IS_REVERSE = false;
+    static constexpr int DIM_UNKNOWN = -1;
+
+    // Constructors
+    RelateEdge(
+        const RelateNode* node, const CoordinateXY* pt,
+        bool isA, bool isForward);
+
+    RelateEdge(
+        const RelateNode* node, const CoordinateXY* pt,
+        bool isA);
+
+    RelateEdge(
+        const RelateNode* node, const CoordinateXY* pt,
+        bool isA, Location locLeft, Location locRight, Location locLine);
+
+    // Methods
+    static RelateEdge* create(
+        const RelateNode* node,
+        const CoordinateXY* dirPt,
+        bool isA, int dim, bool isForward);
+
+    static std::size_t findKnownEdgeIndex(
+        std::vector<std::unique_ptr<RelateEdge>>& edges,
+        bool isA);
+
+    static void setAreaInterior(
+        std::vector<std::unique_ptr<RelateEdge>>& edges,
+        bool isA);
+
+    bool isInterior(bool isA, int position) const;
+
+    Location location(bool isA, int position) const;
+
+    int compareToEdge(const CoordinateXY* edgeDirPt) const;
+
+    void setDimLocations(bool isA, int dim, Location loc);
+
+    void setAreaInterior(bool isA);
+
+    void setLocation(bool isA, int pos, Location loc);
+
+    void setAllLocations(bool isA, Location loc);
+
+    void setUnknownLocations(bool isA, Location loc);
+
+    void merge(bool isA, int dim, bool isForward);
+
+    std::string toString() const;
+
+    friend std::ostream& operator<<(std::ostream& os, const RelateEdge& re);
+
+
+private:
+
+    // Methods
+    void mergeSideLocation(bool isA, int pos, Location loc);
+
+    /**
+    * Area edges override Line edges.
+    * Merging edges of same dimension is a no-op for
+    * the dimension and on location.
+    * But merging an area edge into a line edge
+    * sets the dimension to A and the location to BOUNDARY.
+    *
+    * @param isA
+    * @param locEdge
+    */
+    void mergeDimEdgeLoc(bool isA, Location locEdge);
+
+    void setDimension(bool isA, int dimension);
+
+    void setLeft(bool isA, Location loc);
+
+    void setRight(bool isA, Location loc);
+
+    void setOn(bool isA, Location loc);
+
+    int dimension(bool isA) const;
+
+    bool isKnown(bool isA) const;
+
+    bool isKnown(bool isA, int pos) const;
+
+    void setLocations(bool isA, Location locLeft, Location locRight, Location locLine);
+
+    void setLocationsLine(bool isA);
+
+    void setLocationsArea(bool isA, bool isForward);
+
+    std::string labelString() const;
+
+    std::string locationString(bool isA) const;
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/relateng/RelateGeometry.h

@@ -0,0 +1,272 @@
+/**********************************************************************
+ *
+ * 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/algorithm/BoundaryNodeRule.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Dimension.h>
+#include <geos/geom/Location.h>
+#include <geos/operation/relateng/RelatePointLocator.h>
+#include <geos/operation/relateng/RelateSegmentString.h>
+#include <geos/export.h>
+
+#include <string>
+#include <sstream>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class CoordinateSequence;
+    class Envelope;
+    class Geometry;
+    class LinearRing;
+    class LineString;
+    class MultiPolygon;
+    class Point;
+}
+namespace noding {
+    class SegmentString;
+}
+}
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+using namespace geos::geom;
+using geos::algorithm::BoundaryNodeRule;
+using geos::noding::SegmentString;
+
+
+class GEOS_DLL RelateGeometry {
+
+private:
+
+    // Members
+
+    const Geometry* geom;
+    bool m_isPrepared = false;
+    const Envelope* geomEnv;
+    const BoundaryNodeRule& boundaryNodeRule;
+    int geomDim = Dimension::False;
+    bool isLineZeroLen = false;
+    bool isGeomEmpty = false;
+
+    Coordinate::ConstXYSet uniquePoints;
+    std::unique_ptr<RelatePointLocator> locator;
+    int elementId = 0;
+    bool hasPoints = false;
+    bool hasLines = false;
+    bool hasAreas = false;
+
+    /*
+     * Memory contexts for lower level allocations
+     */
+    std::vector<std::unique_ptr<const RelateSegmentString>> segStringTempStore;
+    std::vector<std::unique_ptr<const RelateSegmentString>> segStringPermStore;
+    std::vector<std::unique_ptr<CoordinateSequence>> csStore;
+
+
+    // Methods
+
+    void analyzeDimensions();
+
+    /**
+    * Tests if all geometry linear elements are zero-length.
+    * For efficiency the test avoids computing actual length.
+    *
+    * @param geom
+    * @return
+    */
+    static bool isZeroLength(const Geometry* geom);
+
+    static bool isZeroLength(const LineString* line);
+
+    bool isZeroLengthLine(const Geometry* g) const {
+        // avoid expensive zero-length calculation if not linear
+        if (getDimension() != Dimension::L)
+            return false;
+        return isZeroLength(g);
+    };
+
+    RelatePointLocator* getLocator();
+
+    Coordinate::ConstXYSet createUniquePoints();
+
+    void extractSegmentStringsFromAtomic(bool isA,
+        const Geometry* geom, const MultiPolygon* parentPolygonal,
+        const Envelope* env,
+        std::vector<const SegmentString*>& segStrings,
+        std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
+    void extractRingToSegmentString(bool isA,
+        const LinearRing* ring, int ringId, const Envelope* env,
+        const Geometry* parentPoly,
+        std::vector<const SegmentString*>& segStrings,
+        std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
+    void extractSegmentStrings(bool isA,
+        const Envelope* env, const Geometry* geom,
+        std::vector<const SegmentString*>& segStrings,
+        std::vector<std::unique_ptr<const RelateSegmentString>>& segStore);
+
+    const CoordinateSequence* orientAndRemoveRepeated(
+        const CoordinateSequence* cs, bool orientCW);
+
+    const CoordinateSequence* removeRepeated(
+        const CoordinateSequence* cs);
+
+public:
+
+    static constexpr bool GEOM_A = true;
+    static constexpr bool GEOM_B = false;
+
+    RelateGeometry(const Geometry* input)
+        : RelateGeometry(input, false, BoundaryNodeRule::getBoundaryRuleMod2())
+        {};
+
+    RelateGeometry(const Geometry* input, const BoundaryNodeRule& bnRule)
+        : RelateGeometry(input, false, bnRule)
+        {};
+
+    RelateGeometry(const Geometry* input, bool p_isPrepared, const BoundaryNodeRule& bnRule);
+
+    static std::string name(bool isA);
+
+    const Geometry* getGeometry() const {
+        return geom;
+    }
+
+    bool isPrepared() const {
+        return m_isPrepared;
+    }
+
+    const Envelope* getEnvelope() const {
+        return geomEnv;
+    }
+
+    inline int getDimension() const {
+        return geomDim;
+    }
+
+    bool hasDimension(int dim) const {
+        switch (dim) {
+            case Dimension::P: return hasPoints;
+            case Dimension::L: return hasLines;
+            case Dimension::A: return hasAreas;
+        }
+        return false;
+    }
+
+    /**
+    * Gets the actual non-empty dimension of the geometry.
+    * Zero-length LineStrings are treated as Points.
+    *
+    * @return the real (non-empty) dimension
+    */
+    int getDimensionReal() const;
+
+    bool hasEdges() const;
+
+    bool isNodeInArea(const CoordinateXY* nodePt, const Geometry* parentPolygonal);
+
+    int locateLineEndWithDim(const CoordinateXY* p);
+
+    /**
+     * Locates a vertex of a polygon.
+     * A vertex of a Polygon or MultiPolygon is on
+     * the {@link Location#BOUNDARY}.
+     * But a vertex of an overlapped polygon in a GeometryCollection
+     * may be in the {@link Location#INTERIOR}.
+     *
+     * @param pt the polygon vertex
+     * @return the location of the vertex
+     */
+    Location locateAreaVertex(const CoordinateXY* pt);
+
+    Location locateNode(const CoordinateXY* pt, const Geometry* parentPolygonal);
+
+    int locateWithDim(const CoordinateXY* pt);
+
+    /**
+     * Indicates whether the geometry requires self-noding
+     * for correct evaluation of specific spatial predicates.
+     * Self-noding is required for geometries which may self-cross
+     * - i.e. lines, and overlapping elements in GeometryCollections.
+     * Self-noding is not required for polygonal geometries,
+     * since they can only touch at vertices.
+     * This ensures that the coordinates of nodes created by
+     * crossing segments are computed explicitly.
+     * This ensures that node locations match in situations
+     * where a self-crossing and mutual crossing occur at the same logical location.
+     * E.g. a self-crossing line tested against a single segment
+     * identical to one of the crossed segments.
+     *
+     * @return true if self-noding is required for this geometry
+     */
+    bool isSelfNodingRequired() const;
+
+    /**
+     * Tests whether the geometry has polygonal topology.
+     * This is not the case if it is a GeometryCollection
+     * containing more than one polygon (since they may overlap
+     * or be adjacent).
+     * The significance is that polygonal topology allows more assumptions
+     * about the location of boundary vertices.
+     *
+     * @return true if the geometry has polygonal topology
+     */
+    bool isPolygonal() const;
+
+    bool isEmpty() const;
+
+    bool hasBoundary();
+
+    Coordinate::ConstXYSet& getUniquePoints();
+
+    std::vector<const Point*> getEffectivePoints();
+
+    /**
+     * Extract RSegmentStrings from the geometry which
+     * intersect a given envelope.
+     * If the envelope is null all edges are extracted.
+     * @param geomA
+     *
+     * @param env the envelope to extract around (may be null)
+     * @return a list of SegmentStrings
+     */
+    std::vector<const SegmentString*> extractSegmentStrings(bool isA, const Envelope* env);
+
+    std::string toString() const;
+
+    friend std::ostream& operator<<(std::ostream& os, const RelateGeometry& rg);
+
+    /**
+     * Disable copy construction and assignment. Needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     * Classes with members that are vector<> of unique_ptr<> need this.
+     */
+    RelateGeometry(const RelateGeometry&) = delete;
+    RelateGeometry& operator=(const RelateGeometry&) = delete;
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+