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

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

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * 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/BasicSegmentString.h>
+#include <geos/export.h>
+
+
+#include <string>
+#include <sstream>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+    class CoordinateXY;
+    class CoordinateSequence;
+    class Geometry;
+}
+namespace operation {
+namespace relateng {
+    class RelateGeometry;
+    class NodeSection;
+}
+}
+}
+
+
+using geos::noding::BasicSegmentString;
+using geos::geom::Geometry;
+using geos::geom::CoordinateXY;
+using geos::geom::CoordinateSequence;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+
+
+class GEOS_DLL RelateSegmentString : public BasicSegmentString {
+
+private:
+
+    // Members
+    bool m_isA;
+    int m_dimension;
+    int m_id;
+    int m_ringId;
+    const RelateGeometry* m_inputGeom;
+    const Geometry* m_parentPolygonal = nullptr;
+
+    // Constructor
+    RelateSegmentString(
+        const CoordinateSequence* pts,
+        bool isA,
+        int dimension,
+        int id,
+        int ringId,
+        const Geometry* poly,
+        const RelateGeometry* inputGeom)
+        : BasicSegmentString(const_cast<CoordinateSequence*>(pts), nullptr)
+        , m_isA(isA)
+        , m_dimension(dimension)
+        , m_id(id)
+        , m_ringId(ringId)
+        , m_inputGeom(inputGeom)
+        , m_parentPolygonal(poly)
+        {}
+
+
+    // Methods
+
+    static const RelateSegmentString* createSegmentString(
+        const CoordinateSequence* pts,
+        bool isA, int dim, int elementId, int ringId,
+        const Geometry* poly, const RelateGeometry* parent);
+
+    /**
+     *
+     * @param ss
+     * @param segIndex
+     * @param pt
+     * @return the previous vertex, or null if none exists
+     */
+    const CoordinateXY* prevVertex(
+        std::size_t segIndex,
+        const CoordinateXY* pt) const;
+
+    /**
+     * @param ss
+     * @param segIndex
+     * @param pt
+     * @return the next vertex, or null if none exists
+     */
+    const CoordinateXY* nextVertex(
+        std::size_t segIndex,
+        const CoordinateXY* pt) const;
+
+
+public:
+
+    static const RelateSegmentString* createLine(
+        const CoordinateSequence* pts,
+        bool isA, int elementId,
+        const RelateGeometry* parent);
+
+    static const RelateSegmentString* createRing(
+        const CoordinateSequence* pts,
+        bool isA, int elementId, int ringId,
+        const Geometry* poly, const RelateGeometry* parent);
+
+    inline bool isA() const {
+        return m_isA;
+    }
+
+    inline const RelateGeometry* getGeometry() const {
+        return m_inputGeom;
+    }
+
+    inline const Geometry* getPolygonal() const {
+        return m_parentPolygonal;
+    }
+
+    NodeSection* createNodeSection(std::size_t segIndex, const CoordinateXY intPt) const;
+
+    /**
+     * Tests if a segment intersection point has that segment as its
+     * canonical containing segment.
+     * Segments are half-closed, and contain their start point but not the endpoint,
+     * except for the final segment in a non-closed segment string, which contains
+     * its endpoint as well.
+     * This test ensures that vertices are assigned to a unique segment in a segment string.
+     * In particular, this avoids double-counting intersections which lie exactly
+     * at segment endpoints.
+     *
+     * @param segIndex the segment the point may lie on
+     * @param pt the point
+     * @return true if the segment contains the point
+     */
+    bool isContainingSegment(std::size_t segIndex, const CoordinateXY* pt) const;
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

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

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * 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/NodeSections.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Location.h>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace operation {
+namespace relateng {
+    class NodeSection;
+    class RelateGeometry;
+    class RelateNode;
+    class TopologyPredicate;
+}
+}
+}
+
+
+using geos::geom::CoordinateXY;
+using geos::geom::Location;
+using geos::operation::relateng::NodeSection;
+using geos::operation::relateng::NodeSections;
+using geos::operation::relateng::RelateGeometry;
+using geos::operation::relateng::RelateNode;
+using geos::operation::relateng::TopologyPredicate;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace relateng { // geos.operation.relateng
+
+
+class GEOS_DLL TopologyComputer {
+
+private:
+
+    // Members
+    TopologyPredicate& predicate;
+    RelateGeometry& geomA;
+    RelateGeometry& geomB;
+    std::map<CoordinateXY, NodeSections*> nodeMap;
+    std::deque<std::unique_ptr<NodeSections>> nodeSectionsStore;
+
+    // Methods
+
+    /**
+    * Determine a priori partial EXTERIOR topology based on dimensions.
+    */
+    void initExteriorDims();
+
+    void initExteriorEmpty(bool geomNonEmpty);
+
+    inline RelateGeometry& getGeometry(bool isA) const {
+        return isA ? geomA : geomB;
+    };
+
+    void updateDim(Location locA, Location locB, int dimension);
+
+    void updateDim(bool isAB, Location loc1, Location loc2, int dimension);
+
+    /**
+     * Update topology for an intersection between A and B.
+     *
+     * @param a the section for geometry A
+     * @param b the section for geometry B
+     */
+    void updateIntersectionAB(const NodeSection* a, const NodeSection* b);
+
+    /**
+     * Updates topology for an AB Area-Area crossing node.
+     * Sections cross at a node if (a) the intersection is proper
+     * (i.e. in the interior of two segments)
+     * or (b) if non-proper then whether the linework crosses
+     * is determined by the geometry of the segments on either side of the node.
+     * In these situations the area geometry interiors intersect (in dimension 2).
+     *
+     * @param a the section for geometry A
+     * @param b the section for geometry B
+     */
+    void updateAreaAreaCross(const NodeSection* a, const NodeSection* b);
+
+    /**
+     * Updates topology for a node at an AB edge intersection.
+     *
+     * @param a the section for geometry A
+     * @param b the section for geometry B
+     */
+    void updateNodeLocation(const NodeSection* a, const NodeSection* b);
+
+    void addNodeSections(NodeSection* ns0, NodeSection* ns1);
+
+    void addLineEndOnLine(bool isLineA, Location locLineEnd, Location locLine, const CoordinateXY* pt);
+
+    void addLineEndOnArea(bool isLineA, Location locLineEnd, Location locArea, const CoordinateXY* pt);
+
+    /**
+     * Updates topology for an area vertex (in Interior or on Boundary)
+     * intersecting a point.
+     * Note that because the largest dimension of intersecting target is determined,
+     * the intersecting point is not part of any other target geometry,
+     * and hence its neighbourhood is in the Exterior of the target.
+     *
+     * @param isAreaA whether the area is the A input
+     * @param locArea the location of the vertex in the area
+     * @param pt the point at which topology is being updated
+     */
+    void addAreaVertexOnPoint(bool isAreaA, Location locArea, const CoordinateXY* pt);
+
+    void addAreaVertexOnLine(bool isAreaA, Location locArea, Location locTarget, const CoordinateXY* pt);
+
+    void evaluateNode(NodeSections* nodeSections);
+
+    void evaluateNodeEdges(const RelateNode* node);
+
+    NodeSections* getNodeSections(const CoordinateXY& nodePt);
+
+
+
+public:
+
+    TopologyComputer(
+        TopologyPredicate& p_predicate,
+        RelateGeometry& p_geomA,
+        RelateGeometry& p_geomB)
+        : predicate(p_predicate)
+        , geomA(p_geomA)
+        , geomB(p_geomB)
+        {
+            initExteriorDims();
+        };
+
+    int getDimension(bool isA) const;
+
+    bool isAreaArea() const;
+
+    /**
+     * Indicates whether the input geometries require self-noding
+     * for correct evaluation of specific spatial predicates.
+     * Self-noding is required for geometries which may
+     * have self-crossing linework.
+     * This causes the coordinates of nodes created by
+     * crossing segments to be computed explicitly.
+     * This ensures that node locations match in situations
+     * where a self-crossing and mutual crossing occur at the same logical location.
+     * The canonical example is a self-crossing line tested against a single segment     * identical to one of the crossed segments.
+     *
+     * @return true if self-noding is required
+     */
+    bool isSelfNodingRequired() const;
+
+    bool isExteriorCheckRequired(bool isA) const;
+
+    bool isResultKnown() const;
+
+    bool getResult() const;
+
+    /**
+     * Finalize the evaluation.
+     */
+    void finish();
+
+    void addIntersection(NodeSection* a, NodeSection* b);
+
+    void addPointOnPointInterior(const CoordinateXY* pt);
+
+    void addPointOnPointExterior(bool isGeomA, const CoordinateXY* pt);
+
+    void addPointOnGeometry(bool isA, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
+    /**
+     * Add topology for a line end.
+     * The line end point must be "significant";
+     * i.e. not contained in an area if the source is a mixed-dimension GC.
+     *
+     * @param isLineA the input containing the line end
+     * @param locLineEnd the location of the line end (Interior or Boundary)
+     * @param locTarget the location on the target geometry
+     * @param dimTarget the dimension of the interacting target geometry element,
+     *    (if any), or the dimension of the target
+     * @param pt the line end coordinate
+     */
+    void addLineEndOnGeometry(bool isLineA, Location locLineEnd, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
+    /**
+     * Adds topology for an area vertex interaction with a target geometry element.
+     * Assumes the target geometry element has highest dimension
+     * (i.e. if the point lies on two elements of different dimension,
+     * the location on the higher dimension element is provided.
+     * This is the semantic provided by {@link RelatePointLocator}.
+     *
+     * Note that in a GeometryCollection containing overlapping or adjacent polygons,
+     * the area vertex location may be INTERIOR instead of BOUNDARY.
+     *
+     * @param isAreaA the input that is the area
+     * @param locArea the location on the area
+     * @param locTarget the location on the target geometry element
+     * @param dimTarget the dimension of the target geometry element
+     * @param pt the point of interaction
+     */
+    void addAreaVertex(bool isAreaA, Location locArea, Location locTarget, int dimTarget, const CoordinateXY* pt);
+
+    void addAreaVertexOnArea(bool isAreaA, Location locArea, Location locTarget, const CoordinateXY* pt);
+
+    void evaluateNodes();
+
+    /**
+     * Disable copy construction and assignment. Apparently needed to make this
+     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
+     */
+    TopologyComputer(const TopologyComputer&) = delete;
+    TopologyComputer& operator=(const TopologyComputer&) = delete;
+
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+

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

@@ -0,0 +1,206 @@
+/**********************************************************************
+ *
+ * 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>
+
+
+// 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 TopologyPredicate {
+
+public:
+
+    /* Virtual destructor to ensure proper cleanup of derived classes */
+    virtual ~TopologyPredicate() {};
+
+    /**
+     * Gets the name of the predicate.
+     *
+     * @return the predicate name
+     */
+    virtual std::string name() const = 0;
+
+    /**
+     * Indicates that the value of the predicate can be finalized
+     * based on its current state.
+     */
+    virtual void finish() = 0;
+
+    /**
+     * Tests if the predicate value is known.
+     *
+     * @return true if the result is known
+     */
+    virtual bool isKnown() const = 0;
+
+    /**
+     * Gets the current value of the predicate result.
+     * The value is only valid if isKnown() is true.
+     *
+     * @return the predicate result value
+     */
+    virtual bool value() const = 0;
+
+    /**
+     * Reports whether this predicate requires self-noding for
+     * geometries which contain crossing edges
+     * (for example, LineString, or GeometryCollection
+     * containing lines or polygons which may self-intersect).
+     * Self-noding ensures that intersections are computed consistently
+     * in cases which contain self-crossings and mutual crossings.
+     *
+     * Most predicates require this, but it can
+     * be avoided for simple intersection detection
+     * (such as in RelatePredicate#intersects()
+     * and RelatePredicate#disjoint().
+     * Avoiding self-noding improves performance for polygonal inputs.
+     *
+     * @return true if self-noding is required.
+     */
+    virtual bool requireSelfNoding() const {
+        return true;
+    };
+
+    /**
+     * Reports whether this predicate requires interaction between
+     * the input geometries.
+     * This is the case if
+     *
+     * IM[I, I] >= 0 or IM[I, B] >= 0 or IM[B, I] >= 0 or IM[B, B] >= 0
+     *
+     * This allows a fast result if
+     * the envelopes of the geometries are disjoint.
+     *
+     * @return true if the geometries must interact
+     */
+    virtual bool requireInteraction() const {
+        return true;
+    };
+
+    /**
+     * Reports whether this predicate requires that the source
+     * cover the target.
+     * This is the case if
+     *
+     * IM[Ext(Src), Int(Tgt)] = F and IM[Ext(Src), Bdy(Tgt)] = F
+     *
+     * If true, this allows a fast result if
+     * the source envelope does not cover the target envelope.
+     *
+     * @param isSourceA indicates the source input geometry
+     * @return true if the predicate requires checking whether the source covers the target
+     */
+    virtual bool requireCovers(bool isSourceA) {
+        (void)isSourceA;
+        return false;
+    }
+
+    /**
+     * Reports whether this predicate requires checking if the source input intersects
+     * the Exterior of the target input.
+     * This is the case if:
+     *
+     * IM[Int(Src), Ext(Tgt)] >= 0 or IM[Bdy(Src), Ext(Tgt)] >= 0
+     *
+     * If false, this may permit a faster result in some geometric situations.
+     *
+     * @param isSourceA indicates the source input geometry
+     * @return true if the predicate requires checking whether the source intersects the target exterior
+     */
+    virtual bool requireExteriorCheck(bool isSourceA) const {
+        (void)isSourceA;
+        return true;
+    }
+
+    /**
+     * Initializes the predicate for a specific geometric case.
+     * This may allow the predicate result to become known
+     * if it can be inferred from the dimensions.
+     *
+     * @param dimA the dimension of geometry A
+     * @param dimB the dimension of geometry B
+     *
+     * @see Dimension
+     */
+    virtual void init(int dimA, int dimB) {
+        (void)dimA;
+        (void)dimB;
+    };
+
+    /**
+     * Initializes the predicate for a specific geometric case.
+     * This may allow the predicate result to become known
+     * if it can be inferred from the envelopes.
+     *
+     * @param envA the envelope of geometry A
+     * @param envB the envelope of geometry B
+     */
+    virtual void init(const Envelope& envA, const Envelope& envB)
+    {
+        //-- default if envelopes provide no information
+        (void)envA;
+        (void)envB;
+    };
+
+    /**
+     * Updates the entry in the DE-9IM intersection matrix
+     * for given Location in the input geometries.
+     *
+     * If this method is called with a {@link Dimension} value
+     * which is less than the current value for the matrix entry,
+     * the implementing class should avoid changing the entry
+     * if this would cause information loss.
+     *
+     * @param locA the location on the A axis of the matrix
+     * @param locB the location on the B axis of the matrix
+     * @param dimension the dimension value for the entry
+     *
+     * @see Dimension
+     * @see Location
+     */
+    virtual void updateDimension(Location locA, Location locB, int dimension) = 0;
+
+
+    friend std::ostream&
+    operator<<(std::ostream& os, const TopologyPredicate& ns)
+    {
+        os << ns.name();
+        return os;
+    }
+
+};
+
+} // namespace geos.operation.relateng
+} // namespace geos.operation
+} // namespace geos
+