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

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/polygonize/Polygonizer.h

@@ -1,270 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2010 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2006 Refractions Research Inc.
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- *
- * 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.
- *
- **********************************************************************
- *
- * Last port: operation/polygonize/Polygonizer.java 0b3c7e3eb0d3e
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Polygon.h>
-#include <geos/geom/GeometryComponentFilter.h> // for LineStringAdder inheritance
-#include <geos/operation/polygonize/PolygonizeGraph.h>
-
-#include <memory>
-#include <vector>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
-#endif
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-
-class LineString;
-
-class Polygon;
-}
-namespace operation {
-namespace polygonize {
-class EdgeRing;
-}
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace polygonize { // geos::operation::polygonize
-
-/** \brief
- * Polygonizes a set of Geometrys which contain linework that
- * represents the edges of a planar graph.
- *
- * All types of Geometry are accepted as input; the constituent linework is extracted
- * as the edges to be polygonized.
- * The edges must be correctly noded; that is, they must only meet
- * at their endpoints. Polygonization will accept incorrectly noded input but will
- * not form polygons from non-noded edges, and reports them as errors.
- *
- * The Polygonizer reports the follow kinds of errors:
- *
- * - <b>Dangles</b> - edges which have one or both ends which are
- *   not incident on another edge endpoint
- * - <b>Cut Edges</b> - edges which are connected at both ends but
- *   which do not form part of a polygon
- * - <b>Invalid Ring Lines</b> - edges which form rings which are invalid
- *   (e.g. the component lines contain a self-intersection)
- *
- *   The Polygonizer constructor allows extracting only polygons which form a
- *   valid polygonal result.
- *   The set of extracted polygons is guaranteed to be edge-disjoint.
- *   This is useful when it is known that the input lines form a valid
- *   polygonal geometry (which may include holes or nested polygons).
- *
- */
-class GEOS_DLL Polygonizer {
-private:
-    /**
-     * Add every linear element in a geometry into the polygonizer graph.
-     */
-    class GEOS_DLL LineStringAdder: public geom::GeometryComponentFilter {
-    public:
-        Polygonizer* pol;
-        explicit LineStringAdder(Polygonizer* p);
-        //void filter_rw(geom::Geometry *g);
-        void filter_ro(const geom::Geometry* g) override;
-    };
-
-    // default factory
-    LineStringAdder lineStringAdder;
-
-    /**
-     * Add a linestring to the graph of polygon edges.
-     *
-     * @param line the {@link LineString} to add
-     */
-    void add(const geom::LineString* line);
-
-    /**
-     * Perform the polygonization, if it has not already been carried out.
-     */
-    void polygonize();
-
-    static void findValidRings(const std::vector<EdgeRing*>& edgeRingList,
-                               std::vector<EdgeRing*>& validEdgeRingList,
-                               std::vector<EdgeRing*>& invalidRingList);
-
-    /**
-     * Extracts unique lines for invalid rings,
-     * discarding rings which correspond to outer rings and hence contain
-     * duplicate linework.
-     */
-    std::vector<std::unique_ptr<geom::LineString>> extractInvalidLines(
-            std::vector<EdgeRing*>& invalidRings);
-
-    /**
-     * Tests if a invalid ring should be included in
-     * the list of reported invalid rings.
-     *
-     * Rings are included only if they contain
-     * linework which is not already in a valid ring,
-     * or in an already-included ring.
-     *
-     * Because the invalid rings list is sorted by extent area,
-     * this results in outer rings being discarded,
-     * since all their linework is reported in the rings they contain.
-     *
-     * @param invalidRing the ring to test
-     * @return true if the ring should be included
-     */
-    bool isIncludedInvalid(EdgeRing* invalidRing);
-
-    void findShellsAndHoles(const std::vector<EdgeRing*>& edgeRingList);
-
-    void findDisjointShells();
-
-    static void findOuterShells(std::vector<EdgeRing*>& shellList);
-
-    static std::vector<std::unique_ptr<geom::Polygon>> extractPolygons(std::vector<EdgeRing*> & shellList, bool includeAll);
-
-    bool extractOnlyPolygonal;
-    bool computed;
-
-protected:
-
-    std::unique_ptr<PolygonizeGraph> graph;
-
-    // initialize with empty collections, in case nothing is computed
-    std::vector<const geom::LineString*> dangles;
-    std::vector<const geom::LineString*> cutEdges;
-    std::vector<std::unique_ptr<geom::LineString>> invalidRingLines;
-
-    std::vector<EdgeRing*> holeList;
-    std::vector<EdgeRing*> shellList;
-    std::vector<std::unique_ptr<geom::Polygon>> polyList;
-
-public:
-
-    /** \brief
-     * Create a Polygonizer with the same GeometryFactory
-     * as the input Geometrys.
-     *
-     * @param onlyPolygonal true if only polygons which form a valid polygonal geometry should be extracted
-     */
-    explicit Polygonizer(bool onlyPolygonal = false);
-
-    ~Polygonizer() = default;
-
-    /** \brief
-     * Add a collection of geometries to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param geomList a list of Geometry with linework to be polygonized
-     */
-    void add(std::vector<geom::Geometry*>* geomList);
-
-    /** \brief
-     * Add a collection of geometries to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param geomList a list of Geometry with linework to be polygonized
-     */
-    void add(std::vector<const geom::Geometry*>* geomList);
-
-    /**
-     * Add a geometry to the linework to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param g a Geometry with linework to be polygonized
-     */
-    void add(geom::Geometry* g);
-
-    /**
-     * Add a geometry to the linework to be polygonized.
-     * May be called multiple times.
-     * Any dimension of Geometry may be added;
-     * the constituent linework will be extracted and used
-     *
-     * @param g a Geometry with linework to be polygonized
-     */
-    void add(const geom::Geometry* g);
-
-    /** \brief
-     * Gets the list of polygons formed by the polygonization.
-     *
-     * Ownership of vector is transferred to caller, subsequent
-     * calls will return NULL.
-     * @return a collection of Polygons
-     */
-    std::vector<std::unique_ptr<geom::Polygon>> getPolygons();
-
-    /** \brief
-     * Get the list of dangling lines found during polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are dangles.
-     *
-     */
-    const std::vector<const geom::LineString*>& getDangles();
-
-    bool hasDangles();
-
-    /** \brief
-     * Get the list of cut edges found during polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which are cut edges.
-     *
-     */
-    const std::vector<const geom::LineString*>& getCutEdges();
-
-    bool hasCutEdges();
-
-    /** \brief
-     * Get the list of lines forming invalid rings found during
-     * polygonization.
-     *
-     * @return a (possibly empty) collection of pointers to
-     *         the input LineStrings which form invalid rings
-     *
-     */
-    const std::vector<std::unique_ptr<geom::LineString>>& getInvalidRingLines();
-
-    bool hasInvalidRingLines();
-
-    bool allInputsFormPolygons();
-
-// This seems to be needed by    GCC 2.95.4
-    friend class Polygonizer::LineStringAdder;
-};
-
-} // namespace geos::operation::polygonize
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relate/EdgeEndBundle.h

@@ -1,104 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2006 Refractions Research Inc.
- *
- * 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.
- *
- **********************************************************************
- *
- * Last port: operation/relate/EdgeEndBundle.java rev. 1.17 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geomgraph/EdgeEnd.h> // for EdgeEndBundle inheritance
-
-#include <string>
-
-// Forward declarations
-namespace geos {
-namespace algorithm {
-class BoundaryNodeRule;
-}
-namespace geom {
-class IntersectionMatrix;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace relate { // geos::operation::relate
-
-/** \brief
- * A collection of geomgraph::EdgeEnd objects which
- * originate at the same point and have the same direction.
- */
-class GEOS_DLL EdgeEndBundle: public geomgraph::EdgeEnd {
-public:
-    EdgeEndBundle(geomgraph::EdgeEnd* e);
-    ~EdgeEndBundle() override;
-    const std::vector<geomgraph::EdgeEnd*>& getEdgeEnds();
-    void insert(geomgraph::EdgeEnd* e);
-
-    void computeLabel(const algorithm::BoundaryNodeRule& bnr) override;
-
-    /**
-     * \brief
-     * Update the IM with the contribution for the computed label for
-     * the EdgeStubs.
-     */
-    void updateIM(geom::IntersectionMatrix& im);
-
-    std::string print() const override;
-protected:
-    std::vector<geomgraph::EdgeEnd*> edgeEnds;
-
-    /**
-     * Compute the overall ON location for the list of EdgeStubs.
-     *
-     * (This is essentially equivalent to computing the self-overlay of
-     * a single Geometry)
-     *
-     * edgeStubs can be either on the boundary (eg Polygon edge)
-     * OR in the interior (e.g. segment of a LineString)
-     * of their parent Geometry.
-     *
-     * In addition, GeometryCollections use a algorithm::BoundaryNodeRule
-     * to determine whether a segment is on the boundary or not.
-     *
-     * Finally, in GeometryCollections it can occur that an edge
-     * is both
-     * on the boundary and in the interior (e.g. a LineString segment
-     * lying on
-     * top of a Polygon edge.) In this case the Boundary is
-     * given precendence.
-     *
-     * These observations result in the following rules for computing
-     * the ON location:
-     *  - if there are an odd number of Bdy edges, the attribute is Bdy
-     *  - if there are an even number >= 2 of Bdy edges, the attribute
-     *    is Int
-     *  - if there are any Int edges, the attribute is Int
-     *  - otherwise, the attribute is NULL.
-     *
-     */
-    void computeLabelOn(uint8_t geomIndex,
-                        const algorithm::BoundaryNodeRule& boundaryNodeRule);
-
-    void computeLabelSides(uint8_t geomIndex);
-    void computeLabelSide(uint8_t geomIndex, uint32_t side);
-};
-
-} // namespace geos:operation:relate
-} // namespace geos:operation
-} // namespace geos

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relate/RelateComputer.h

@@ -1,185 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2006 Refractions Research Inc.
- * Copyright (C) 2001-2002 Vivid Solutions Inc.
- *
- * 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.
- *
- **********************************************************************
- *
- * Last port: operation/relate/RelateComputer.java rev. 1.24 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/algorithm/PointLocator.h> // for RelateComputer composition
-#include <geos/algorithm/LineIntersector.h> // for RelateComputer composition
-#include <geos/geomgraph/NodeMap.h> // for RelateComputer composition
-#include <geos/geom/Coordinate.h> // for RelateComputer composition
-#include <geos/geom/IntersectionMatrix.h>
-
-#include <vector>
-#include <memory>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
-#endif
-
-// Forward declarations
-namespace geos {
-namespace algorithm {
-class BoundaryNodeRule;
-}
-namespace geom {
-class Geometry;
-}
-namespace geomgraph {
-class GeometryGraph;
-class Edge;
-class EdgeEnd;
-class Node;
-namespace index {
-class SegmentIntersector;
-}
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace relate { // geos::operation::relate
-
-/** \brief
- * Computes the topological relationship between two Geometries.
- *
- * RelateComputer does not need to build a complete graph structure to compute
- * the IntersectionMatrix.  The relationship between the geometries can
- * be computed by simply examining the labelling of edges incident on each node.
- *
- * RelateComputer does not currently support arbitrary GeometryCollections.
- * This is because GeometryCollections can contain overlapping Polygons.
- * In order to correct compute relate on overlapping Polygons, they
- * would first need to be noded and merged (if not explicitly, at least
- * implicitly).
- *
- */
-class GEOS_DLL RelateComputer {
-public:
-    RelateComputer(std::vector<geomgraph::GeometryGraph*>* newArg);
-    ~RelateComputer() = default;
-
-    std::unique_ptr<geom::IntersectionMatrix> computeIM();
-private:
-
-    algorithm::LineIntersector li;
-
-    algorithm::PointLocator ptLocator;
-
-    /// the arg(s) of the operation
-    std::vector<geomgraph::GeometryGraph*>* arg;
-
-    geomgraph::NodeMap nodes;
-
-    /// this intersection matrix will hold the results compute for the relate
-    std::unique_ptr<geom::IntersectionMatrix> im;
-
-    std::vector<geomgraph::Edge*> isolatedEdges;
-
-    /// the intersection point found (if any)
-    geom::Coordinate invalidPoint;
-
-    void insertEdgeEnds(std::vector<std::unique_ptr<geomgraph::EdgeEnd>>& ee);
-
-    void computeProperIntersectionIM(
-        geomgraph::index::SegmentIntersector* intersector,
-        geom::IntersectionMatrix* imX);
-
-    void copyNodesAndLabels(uint8_t argIndex);
-    void computeIntersectionNodes(uint8_t argIndex);
-    void labelIntersectionNodes(uint8_t argIndex);
-
-    /**
-     * If the Geometries are disjoint, we need to enter their dimension and
-     * boundary dimension in the Ext rows in the IM
-     */
-    void computeDisjointIM(geom::IntersectionMatrix* imX,
-                           const algorithm::BoundaryNodeRule& boundaryNodeRule);
-
-    void labelNodeEdges();
-
-    /**
-     * update the IM with the sum of the IMs for each component
-     */
-    void updateIM(geom::IntersectionMatrix& imX);
-
-    /**
-     * Compute the IM entry for the intersection of the boundary
-     * of a geometry with the Exterior.
-     * This is the nominal dimension of the boundary
-     * unless the boundary is empty, in which case it is {@link Dimension#FALSE}.
-     * For linear geometries the Boundary Node Rule determines
-     * whether the boundary is empty.
-     *
-     * @param geom the geometry providing the boundary
-     * @param boundaryNodeRule  the Boundary Node Rule to use
-     * @return the IM dimension entry
-     */
-    static int getBoundaryDim(const geom::Geometry& geom,
-                              const algorithm::BoundaryNodeRule& boundaryNodeRule);
-
-    /**
-     * Processes isolated edges by computing their labelling and adding them
-     * to the isolated edges list.
-     * Isolated edges are guaranteed not to touch the boundary of the target
-     * (since if they
-     * did, they would have caused an intersection to be computed and hence would
-     * not be isolated)
-     */
-    void labelIsolatedEdges(uint8_t thisIndex, uint8_t targetIndex);
-
-    /**
-     * Label an isolated edge of a graph with its relationship to the target
-     * geometry.
-     * If the target has dim 2 or 1, the edge can either be in the interior
-     * or the exterior.
-     * If the target has dim 0, the edge must be in the exterior
-     */
-    void labelIsolatedEdge(geomgraph::Edge* e, uint8_t targetIndex,
-                           const geom::Geometry* target);
-
-    /**
-     * Isolated nodes are nodes whose labels are incomplete
-     * (e.g. the location for one Geometry is null).
-     * This is the case because nodes in one graph which don't intersect
-     * nodes in the other are not completely labelled by the initial process
-     * of adding nodes to the nodeList.
-     * To complete the labelling we need to check for nodes that lie in the
-     * interior of edges, and in the interior of areas.
-     */
-    void labelIsolatedNodes();
-
-    /**
-     * Label an isolated node with its relationship to the target geometry.
-     */
-    void labelIsolatedNode(geomgraph::Node* n, uint8_t targetIndex);
-};
-
-
-} // namespace geos:operation:relate
-} // namespace geos:operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/relate/RelateNode.h

@@ -1,67 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2006 Refractions Research Inc.
- *
- * 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.
- *
- **********************************************************************
- *
- * Last port: operation/relate/RelateNode.java rev. 1.11 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geomgraph/Node.h> // for inheritance
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class IntersectionMatrix;
-class Coordinate;
-}
-namespace geomgraph {
-class EdgeEndStar;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace relate { // geos::operation::relate
-
-/** \brief
- * Represents a node in the topological graph used to compute spatial
- * relationships.
- */
-class GEOS_DLL RelateNode: public geomgraph::Node {
-
-public:
-
-    RelateNode(const geom::Coordinate& coord, geomgraph::EdgeEndStar* edges);
-
-    ~RelateNode() override = default;
-
-    /**
-     * Update the IM with the contribution for the EdgeEnds incident on this node.
-     */
-    void updateIMFromEdges(geom::IntersectionMatrix& im);
-
-protected:
-
-    void computeIM(geom::IntersectionMatrix& im) override;
-};
-
-
-} // namespace geos:operation:relate
-} // namespace geos:operation
-} // namespace geos
-