@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/relateng/RelateSegmentString.h

@@ -1,161 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/relateng/TopologyComputer.h

@@ -1,236 +0,0 @@
-/**********************************************************************
- *
- * 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/geos.xcframework/ios-arm64_arm64e/Headers/geos/operation/relateng/TopologyPredicate.h

@@ -1,206 +0,0 @@
-/**********************************************************************
- *
- * 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
-