npm - @cpp.js/package-geos - Versions diffs - 1.0.0 → 2.0.0-beta.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4678) hide show

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/relateng/RelateMatrixPredicate.h DELETED Viewed

@@ -1,85 +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/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;
-}
-}
-using geos::geom::Envelope;
-using geos::geom::Location;
-using geos::geom::Dimension;
-using geos::geom::IntersectionMatrix;
-namespace geos {      // geos.
-namespace operation { // geos.operation.
-namespace relateng {  // geos.operation.relateng
-class GEOS_DLL RelateMatrixPredicate : public IMPredicate {
-public:
-    RelateMatrixPredicate() {};
-    std::string name() const override {
-        return "relateMatrix";
-    };
-    bool requireInteraction() const override {
-        //-- ensure entire matrix is computed
-        return false;
-    };
-    bool isDetermined() const override {
-        //-- ensure entire matrix is computed
-        return false;
-    };
-    bool valueIM() override {
-        //-- indicates full matrix is being evaluated
-        return false;
-    };
-    /**
-    * Gets the current state of the IM matrix (which may only be partially complete).
-    *
-    * @return the IM matrix
-    */
-    std::unique_ptr<IntersectionMatrix> getIM() {
-        return std::unique_ptr<IntersectionMatrix>(new IntersectionMatrix(intMatrix));
-    }
-};
-} // namespace geos.operation.relateng
-} // namespace geos.operation
-} // namespace geos

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/relateng/RelateNG.h DELETED Viewed

@@ -1,295 +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/export.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/noding/MCIndexSegmentSetMutualIntersector.h>
-#include <geos/operation/relateng/RelateGeometry.h>
-#include <string>
-#include <sstream>
-// Forward declarations
-namespace geos {
-namespace algorithm {
-    class BoundaryNodeRule;
-}
-namespace geom {
-    class Geometry;
-}
-namespace noding {
-}
-namespace operation {
-namespace relateng {
-    class TopologyPredicate;
-    class TopologyComputer;
-    class EdgeSegmentIntersector;
-}
-}
-}
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace relateng { // geos.operation.relateng
-using geos::geom::CoordinateXY;
-using geos::geom::Geometry;
-using geos::algorithm::BoundaryNodeRule;
-using geos::noding::MCIndexSegmentSetMutualIntersector;
-/**
- * Computes the value of topological predicates between two geometries based on the
- * Dimensionally-Extended 9-Intersection Model <https://en.wikipedia.org/wiki/DE-9IM> (DE-9IM).
- * Standard and custom topological predicates are provided by RelatePredicate.
- *
- * The RelateNG algorithm has the following capabilities:
- *
- *   * Efficient short-circuited evaluation of topological predicates
- *     (including matching custom DE-9IM matrix patterns)
- *   * Optimized repeated evaluation of predicates against a single geometry
- *     via cached spatial indexes (AKA "prepared mode")
- *   * Robust computation (only point-local topology is required,
- *     so invalid geometry topology does not cause failures)
- *   * GeometryCollection inputs containing mixed types and overlapping polygons
- *     are supported, using union semantics.
- *   * Zero-length LineStrings are treated as being topologically identical to Points.
- *   * Support for BoundaryNodeRule.
- *
- * See IntersectionMatrixPattern for a description of DE-9IM patterns.
- *
- * If not specified, the standard BoundaryNodeRule::MOD2_BOUNDARY_RULE is used.
- *
- * RelateNG operates in 2D only; it ignores any Z ordinates.
- *
- * This implementation replaces RelateOp and PreparedGeometry.
- *
- * FUTURE WORK
- *
- *   * Support for a distance tolerance to provide "approximate" predicate evaluation
- *
- * @author Martin Davis
- *
- * @see RelateOp
- * @see PreparedGeometry
- */
-class GEOS_DLL RelateNG {
-private:
-    // Members
-    const BoundaryNodeRule& boundaryNodeRule;
-    RelateGeometry geomA;
-    std::unique_ptr<MCIndexSegmentSetMutualIntersector> edgeMutualInt = nullptr;
-    // Methods
-    RelateNG(const Geometry* inputA, bool isPrepared, const BoundaryNodeRule& bnRule)
-        : boundaryNodeRule(bnRule)
-        , geomA(inputA, isPrepared, bnRule)
-        {}
-    RelateNG(const Geometry* inputA, bool isPrepared)
-        : RelateNG(inputA, isPrepared, BoundaryNodeRule::getBoundaryRuleMod2())
-        {}
-    bool hasRequiredEnvelopeInteraction(const Geometry* b, TopologyPredicate& predicate);
-    bool finishValue(TopologyPredicate& predicate);
-    void computePP(RelateGeometry& geomB, TopologyComputer& topoComputer);
-    void computeAtPoints(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    bool computePoints(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    void computePoint(bool isA, const CoordinateXY* pt, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    bool computeLineEnds(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    /**
-     * Compute the topology of a line endpoint.
-     * Also reports if the line end is in the exterior of the target geometry,
-     * to optimize testing multiple exterior endpoints.
-     *
-     * @param geom
-     * @param isA
-     * @param pt
-     * @param geomTarget
-     * @param topoComputer
-     * @return true if the line endpoint is in the exterior of the target
-     */
-    bool computeLineEnd(RelateGeometry& geom, bool isA, const CoordinateXY* pt, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    bool computeAreaVertex(RelateGeometry& geom, bool isA, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    bool computeAreaVertex(RelateGeometry& geom, bool isA, const LinearRing* ring, RelateGeometry& geomTarget, TopologyComputer& topoComputer);
-    void computeAtEdges(RelateGeometry& geomB, TopologyComputer& topoComputer);
-    void computeEdgesAll(std::vector<const SegmentString*>& edgesB, const Envelope* envInt, EdgeSegmentIntersector& intersector);
-    void computeEdgesMutual(std::vector<const SegmentString*>& edgesB, const Envelope* envInt, EdgeSegmentIntersector& intersector);
-public:
-    /**
-     * Tests whether the topological relationship between two geometries
-     * satisfies a topological predicate.
-     *
-     * @param a the A input geometry
-     * @param b the B input geometry
-     * @param pred the topological predicate
-     * @return true if the topological relationship is satisfied
-     */
-    static bool relate(const Geometry* a, const Geometry* b, TopologyPredicate& pred);
-    /**
-     * Tests whether the topological relationship between two geometries
-     * satisfies a topological predicate,
-     * using a given BoundaryNodeRule.
-     *
-     * @param a the A input geometry
-     * @param b the B input geometry
-     * @param pred the topological predicate
-     * @param bnRule the Boundary Node Rule to use
-     * @return true if the topological relationship is satisfied
-     */
-    static bool relate(const Geometry* a, const Geometry* b, TopologyPredicate& pred, const BoundaryNodeRule& bnRule);
-    /**
-     * Tests whether the topological relationship to a geometry
-     * matches a DE-9IM matrix pattern.
-     *
-     * @param a the A input geometry
-     * @param b the B input geometry
-     * @param imPattern the DE-9IM pattern to match
-     * @return true if the geometries relationship matches the DE-9IM pattern
-     *
-     * @see IntersectionMatrixPattern
-     */
-    static bool relate(const Geometry* a, const Geometry* b, const std::string& imPattern);
-    /**
-     * Computes the DE-9IM matrix
-     * for the topological relationship between two geometries.
-     *
-     * @param a the A input geometry
-     * @param b the B input geometry
-     * @return the DE-9IM matrix for the topological relationship
-     */
-    static std::unique_ptr<IntersectionMatrix> relate(const Geometry* a, const Geometry* b);
-    /**
-     * Computes the DE-9IM matrix
-     * for the topological relationship between two geometries.
-     *
-     * @param a the A input geometry
-     * @param b the B input geometry
-     * @param bnRule the Boundary Node Rule to use
-     * @return the DE-9IM matrix for the relationship
-     */
-    static std::unique_ptr<IntersectionMatrix> relate(const Geometry* a, const Geometry* b, const BoundaryNodeRule& bnRule);
-    /**
-     * Creates a prepared RelateNG instance to optimize the
-     * evaluation of relationships against a single geometry.
-     *
-     * @param a the A input geometry
-     * @return a prepared instance
-     */
-    static std::unique_ptr<RelateNG> prepare(const Geometry* a);
-    /**
-     * Creates a prepared RelateNG instance to optimize the
-     * computation of predicates against a single geometry,
-     * using a given BoundaryNodeRule.
-     *
-     * @param a the A input geometry
-     * @param bnRule the required BoundaryNodeRule
-     * @return a prepared instance
-     */
-    static std::unique_ptr<RelateNG> prepare(const Geometry* a, const BoundaryNodeRule& bnRule);
-    /**
-     * Computes the DE-9IM matrix for the topological relationship to a geometry.
-     *
-     * @param b the B geometry to test against
-     * @return the DE-9IM matrix
-     */
-    std::unique_ptr<IntersectionMatrix> evaluate(const Geometry* b);
-    /**
-     * Tests whether the topological relationship to a geometry
-     * matches a DE-9IM matrix pattern.
-     *
-     * @param b the B geometry to test against
-     * @param imPattern the DE-9IM pattern to match
-     * @return true if the geometries' topological relationship matches the DE-9IM pattern
-     *
-     * @see IntersectionMatrixPattern
-     */
-    bool evaluate(const Geometry* b, const std::string& imPattern);
-    /**
-     * Tests whether the topological relationship to a geometry
-     * satisfies a topology predicate.
-     *
-     * @param b the B geometry to test against
-     * @param predicate the topological predicate
-     * @return true if the predicate is satisfied
-     */
-    bool evaluate(const Geometry* b, TopologyPredicate& predicate);
-    static bool intersects(const Geometry* a, const Geometry* b);
-    static bool crosses(const Geometry* a, const Geometry* b);
-    static bool disjoint(const Geometry* a, const Geometry* b);
-    static bool touches(const Geometry* a, const Geometry* b);
-    static bool within(const Geometry* a, const Geometry* b);
-    static bool contains(const Geometry* a, const Geometry* b);
-    static bool overlaps(const Geometry* a, const Geometry* b);
-    static bool covers(const Geometry* a, const Geometry* b);
-    static bool coveredBy(const Geometry* a, const Geometry* b);
-    static bool equalsTopo(const Geometry* a, const Geometry* b);
-    bool intersects(const Geometry* a);
-    bool crosses(const Geometry* a);
-    bool disjoint(const Geometry* a);
-    bool touches(const Geometry* a);
-    bool within(const Geometry* a);
-    bool contains(const Geometry* a);
-    bool overlaps(const Geometry* a);
-    bool covers(const Geometry* a);
-    bool coveredBy(const Geometry* a);
-    bool equalsTopo(const Geometry* a);
-    bool relate(const Geometry* a, const std::string& pat);
-    std::unique_ptr<IntersectionMatrix> relate(const Geometry* a);
-};
-} // namespace geos.operation.relateng
-} // namespace geos.operation
-} // namespace geos

package/dist/prebuilt/Emscripten-x86_64/include/geos/operation/relateng/RelateNode.h DELETED Viewed

@@ -1,146 +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/RelateEdge.h>
-#include <vector>
-#include <memory>
-#include <cassert>
-#include <geos/export.h>
-// Forward declarations
-namespace geos {
-namespace operation {
-namespace relateng {
-    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 RelateNode {
-private:
-    // Members
-    /**
-    * A list of the edges around the node in CCW order,
-    * ordered by their CCW angle with the positive X-axis.
-    */
-    std::vector<std::unique_ptr<RelateEdge>> edges;
-    const CoordinateXY* nodePt;
-    // Methods
-    void updateEdgesInArea(bool isA, std::size_t indexFrom, std::size_t indexTo);
-    void updateIfAreaPrev(bool isA, std::size_t index);
-    void updateIfAreaNext(bool isA, std::size_t index);
-    const RelateEdge* addLineEdge(bool isA, const CoordinateXY* dirPt);
-    const RelateEdge* addAreaEdge(bool isA, const CoordinateXY* dirPt, bool isForward);
-    /**
-    * Adds or merges an edge to the node.
-    *
-    * @param isA
-    * @param dirPt
-    * @param dim dimension of the geometry element containing the edge
-    * @param isForward the direction of the edge
-    *
-    * @return the created or merged edge for this point
-    */
-    const RelateEdge* addEdge(bool isA, const CoordinateXY* dirPt, int dim, bool isForward);
-    void finishNode(bool isA, bool isAreaInterior);
-    void propagateSideLocations(bool isA, std::size_t startIndex);
-    static std::size_t prevIndex(std::vector<std::unique_ptr<RelateEdge>>& list, std::size_t index);
-    static std::size_t nextIndex(std::vector<std::unique_ptr<RelateEdge>>& list, std::size_t i);
-    std::size_t indexOf(
-        const std::vector<std::unique_ptr<RelateEdge>>& edges,
-        const RelateEdge* edge) const;
-public:
-    RelateNode(const CoordinateXY* pt)
-        : nodePt(pt)
-        {};
-    const CoordinateXY* getCoordinate() const;
-    const std::vector<std::unique_ptr<RelateEdge>>& getEdges() const;
-    void addEdges(std::vector<const NodeSection *>& nss);
-    void addEdges(std::vector<std::unique_ptr<NodeSection>>& nss);
-    void addEdges(const NodeSection* ns);
-    /**
-    * Computes the final topology for the edges around this node.
-    * Although nodes lie on the boundary of areas or the interior of lines,
-    * in a mixed GC they may also lie in the interior of an area.
-    * This changes the locations of the sides and line to Interior.
-    *
-    * @param isAreaInteriorA true if the node is in the interior of A
-    * @param isAreaInteriorB true if the node is in the interior of B
-    */
-    void finish(bool isAreaInteriorA, bool isAreaInteriorB);
-    std::string toString() const;
-    bool hasExteriorEdge(bool isA);
-    friend std::ostream& operator<<(std::ostream& os, const RelateNode& ns);
-    /**
-     * Disable copy construction and assignment. Apparently needed to make this
-     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
-     */
-    RelateNode(const RelateNode&) = delete;
-    RelateNode& operator=(const RelateNode&) = delete;
-};
-} // namespace geos.operation.relateng
-} // namespace geos.operation
-} // namespace geos