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

package/dist/prebuilt/geos.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/operation/overlayng/EdgeNodingBuilder.h

@@ -1,255 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2020 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.
- *
- **********************************************************************
- *
- * Last port: operation/overlayng/EdgeNodingBuilder.java 6ef89b096
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/algorithm/LineIntersector.h>
-#include <geos/algorithm/Orientation.h>
-#include <geos/geom/Coordinate.h>
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/geom/Envelope.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/GeometryCollection.h>
-#include <geos/geom/LinearRing.h>
-#include <geos/geom/LineString.h>
-#include <geos/geom/MultiLineString.h>
-#include <geos/geom/MultiPolygon.h>
-#include <geos/geom/Polygon.h>
-#include <geos/noding/IntersectionAdder.h>
-#include <geos/noding/MCIndexNoder.h>
-#include <geos/noding/Noder.h>
-#include <geos/noding/NodedSegmentString.h>
-#include <geos/noding/SegmentString.h>
-#include <geos/noding/ValidatingNoder.h>
-#include <geos/noding/snapround/SnapRoundingNoder.h>
-#include <geos/operation/overlayng/Edge.h>
-#include <geos/operation/overlayng/EdgeSourceInfo.h>
-#include <geos/operation/overlayng/InputGeometry.h>
-#include <geos/operation/overlayng/LineLimiter.h>
-#include <geos/operation/overlayng/OverlayUtil.h>
-#include <geos/operation/overlayng/RingClipper.h>
-#include <geos/operation/valid/RepeatedPointRemover.h>
-
-
-#include <geos/export.h>
-#include <array>
-#include <memory>
-#include <deque>
-
-using namespace geos::geom;
-using namespace geos::noding;
-using geos::noding::snapround::SnapRoundingNoder;
-using geos::algorithm::LineIntersector;
-
-
-namespace geos {      // geos.
-namespace operation { // geos.operation
-namespace overlayng { // geos.operation.overlayng
-
-/**
- * Builds a set of noded, unique, labelled Edges from
- * the edges of the two input geometries.
- *
- * It performs the following steps:
- *
- *  - Extracts input edges, and attaches topological information
- *  - if clipping is enabled, handles clipping or limiting input geometry
- *  - chooses a {@link noding::Noder} based on provided precision model, unless a custom one is supplied
- *  - calls the chosen Noder, with precision model
- *  - removes any fully collapsed noded edges
- *  - builds {@link Edge}s and merges them
- *
- * @author mdavis
- */
-class GEOS_DLL EdgeNodingBuilder {
-
-private:
-
-    // Constants
-    static constexpr int MIN_LIMIT_PTS = 20;
-    static constexpr bool IS_NODING_VALIDATED = true;
-
-    // Members
-    const PrecisionModel* pm;
-    std::unique_ptr<std::vector<SegmentString*>> inputEdges;
-    Noder* customNoder;
-    std::array<bool, 2> hasEdges;
-    const Envelope* clipEnv;
-    std::unique_ptr<RingClipper> clipper;
-    std::unique_ptr<LineLimiter> limiter;
-
-    // For use in createFloatingPrecisionNoder()
-    LineIntersector lineInt;
-    IntersectionAdder intAdder;
-    std::unique_ptr<Noder> internalNoder;
-    std::unique_ptr<Noder> spareInternalNoder;
-    // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
-    std::deque<EdgeSourceInfo> edgeSourceInfoQue;
-    std::deque<Edge> edgeQue;
-    bool inputHasZ;
-    bool inputHasM;
-
-    /**
-    * Gets a noder appropriate for the precision model supplied.
-    * This is one of:
-    *
-    * - Fixed precision: a snap-rounding noder (which should be fully robust)
-    * - Floating precision: a conventional nodel (which may be non-robust).
-    *   In this case, a validation step is applied to the output from the noder.
-    */
-    Noder* getNoder();
-    static std::unique_ptr<Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
-    std::unique_ptr<Noder> createFloatingPrecisionNoder(bool doValidation);
-
-
-    void addCollection(const GeometryCollection* gc, uint8_t geomIndex);
-    void addGeometryCollection(const GeometryCollection* gc, uint8_t geomIndex, int expectedDim);
-    void addPolygon(const Polygon* poly, uint8_t geomIndex);
-    void addPolygonRing(const LinearRing* ring, bool isHole, uint8_t geomIndex);
-    void addLine(const LineString* line, uint8_t geomIndex);
-    void addLine(std::unique_ptr<CoordinateSequence>& pts, uint8_t geomIndex);
-    void addEdge(std::unique_ptr<CoordinateSequence>& cas, const EdgeSourceInfo* info);
-
-    // Create a EdgeSourceInfo* owned by EdgeNodingBuilder
-    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index, int depthDelta, bool isHole);
-    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index);
-
-    /**
-    * Tests whether a geometry (represented by its envelope)
-    * lies completely outside the clip extent(if any).
-    */
-    bool isClippedCompletely(const Envelope* env) const;
-
-    /**
-    * Tests whether it is worth limiting a line.
-    * Lines that have few vertices or are covered
-    * by the clip extent do not need to be limited.
-    */
-    bool isToBeLimited(const LineString* line) const;
-
-    /**
-    * If limiter is provided,
-    * limit the line to the clip envelope.
-    *
-    */
-    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const LineString* line);
-
-    /**
-    * If a clipper is present,
-    * clip the line to the clip extent.
-    * Otherwise, remove duplicate points from the ring.
-    *
-    * If clipping is enabled, then every ring MUST
-    * be clipped, to ensure that holes are clipped to
-    * be inside the shell.
-    * This means it is not possible to skip
-    * clipping for rings with few vertices.
-    *
-    * @param ring the line to clip
-    * @return the points in the clipped line
-    */
-    std::unique_ptr<CoordinateSequence> clip(const LinearRing* line);
-
-    /**
-    * Removes any repeated points from a linear component.
-    * This is required so that noding can be computed correctly.
-    *
-    * @param line the line to process
-    * @return the points of the line with repeated points removed
-    */
-    static std::unique_ptr<CoordinateSequence> removeRepeatedPoints(const LineString* line);
-
-    static int computeDepthDelta(const LinearRing* ring, bool isHole);
-
-    void add(const Geometry* g, uint8_t geomIndex);
-
-    /**
-    * Nodes a set of segment strings and creates {@link Edge}s from the result.
-    * The input segment strings each carry a {@link EdgeSourceInfo} object,
-    * which is used to provide source topology info to the constructed Edges
-    * (and is then discarded).
-    */
-    std::vector<Edge*> node(std::vector<SegmentString*>* segStrings);
-    std::vector<Edge*> createEdges(std::vector<SegmentString*>* segStrings);
-
-
-public:
-
-    /**
-    * Creates a new builder, with an optional custom noder.
-    * If the noder is not provided, a suitable one will
-    * be used based on the supplied precision model.
-    */
-    EdgeNodingBuilder(const PrecisionModel* p_pm, Noder* p_customNoder)
-        : pm(p_pm)
-        , inputEdges(new std::vector<SegmentString*>)
-        , customNoder(p_customNoder)
-        , hasEdges{{false,false}}
-        , clipEnv(nullptr)
-        , intAdder(lineInt)
-        , inputHasZ(false)
-        , inputHasM(false)
-        {};
-
-    ~EdgeNodingBuilder()
-    {
-        for (SegmentString* ss: *inputEdges) {
-            delete ss;
-        }
-    }
-
-    void setClipEnvelope(const Envelope* clipEnv);
-
-    // returns newly allocated vector and segmentstrings
-    // std::vector<SegmentString*>* node();
-
-    /**
-    * Reports whether there are noded edges
-    * for the given input geometry.
-    * If there are none, this indicates that either
-    * the geometry was empty, or has completely collapsed
-    * (because it is smaller than the noding precision).
-    *
-    * @param geomIndex index of input geometry
-    * @return true if there are edges for the geometry
-    */
-    bool hasEdgesFor(uint8_t geomIndex) const;
-
-    /**
-    * Creates a set of labelled {Edge}s.
-    * representing the fully noded edges of the input geometries.
-    * Coincident edges (from the same or both geometries)
-    * are merged along with their labels
-    * into a single unique, fully labelled edge.
-    *
-    * @param geom0 the first geometry
-    * @param geom1 the second geometry
-    * @return the noded, merged, labelled edges
-    */
-    std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
-
-
-
-};
-
-
-} // namespace geos.operation.overlayng
-} // namespace geos.operation
-} // namespace geos
-

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

@@ -1,75 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright 2011-2014 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2019 Even Rouault <even.rouault@spatialys.com>
- *
- * 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.
- **********************************************************************
- *
- * Ported from rtgeom_geos.c from
- *   rttopo - topology library
- *   http://git.osgeo.org/gitea/rttopo/librttopo
- * with relicensing from GPL to LGPL with Copyright holder permission.
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#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 geom {
-class Geometry;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace polygonize { // geos::operation::polygonize
-
-/** \brief Creates an areal geometry formed by the constituent linework of given geometry.
- *
- * The return type can be a Polygon or MultiPolygon, depending on input.
- * If the input lineworks do not form polygons NULL is returned.
- * The inputs can be LINESTRINGS, MULTILINESTRINGS, POLYGONS, MULTIPOLYGONS, and GeometryCollections.
- *
- * This algorithm will assume all inner geometries represent holes
- *
- * This is the equivalent of the PostGIS ST_BuildArea() function.
- */
-class GEOS_DLL BuildArea {
-
-public:
-
-    /** \brief
-     * Create a BuildArea object.
-     */
-    BuildArea() = default;
-
-    ~BuildArea() = default;
-
-    /** \brief Return the area built fromthe constituent linework of the input geometry. */
-    std::unique_ptr<geom::Geometry> build(const geom::Geometry* geom);
-};
-
-} // namespace geos::operation::polygonize
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

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

@@ -1,214 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * 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/PolygonizeGraph.java rev. 974
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/planargraph/PlanarGraph.h> // for inheritance
-
-#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 LineString;
-class GeometryFactory;
-class Coordinate;
-class CoordinateSequence;
-}
-namespace planargraph {
-class Node;
-class Edge;
-class DirectedEdge;
-}
-namespace operation {
-namespace polygonize {
-class EdgeRing;
-class PolygonizeDirectedEdge;
-}
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace polygonize { // geos::operation::polygonize
-
-
-/** \brief
- * Represents a planar graph of edges that can be used to compute a
- * polygonization, and implements the algorithms to compute the
- * EdgeRings formed by the graph.
- *
- * The marked flag on DirectedEdge is used to indicate that a directed edge
- * has be logically deleted from the graph.
- *
- */
-class GEOS_DLL PolygonizeGraph: public planargraph::PlanarGraph {
-
-public:
-
-    /**
-     * \brief
-     * Deletes all edges at a node
-     */
-    static void deleteAllEdges(planargraph::Node* node);
-
-    /**
-     * \brief
-     * Create a new polygonization graph.
-     */
-    explicit PolygonizeGraph(const geom::GeometryFactory* newFactory);
-
-    /**
-     * \brief
-     * Destroy a polygonization graph.
-     */
-    ~PolygonizeGraph() override;
-
-    /**
-     * \brief
-     * Add a LineString forming an edge of the polygon graph.
-     * @param line the line to add
-     */
-    void addEdge(const geom::LineString* line);
-
-    /**
-     * \brief
-     * Computes the EdgeRings formed by the edges in this graph.
-     *
-     * @param edgeRingList : the EdgeRing found by the
-     * 	polygonization process will be pushed here.
-     *
-     */
-    void getEdgeRings(std::vector<EdgeRing*>& edgeRingList);
-
-    /**
-     * \brief
-     * Finds and removes all cut edges from the graph.
-     *
-     * @param cutLines : the list of the LineString forming the removed
-     *                   cut edges will be pushed here.
-     *
-     * TODO: document ownership of the returned LineStrings
-     */
-    void deleteCutEdges(std::vector<const geom::LineString*>& cutLines);
-
-    /** \brief
-     * Marks all edges from the graph which are "dangles".
-     *
-     * Dangles are which are incident on a node with degree 1.
-     * This process is recursive, since removing a dangling edge
-     * may result in another edge becoming a dangle.
-     * In order to handle large recursion depths efficiently,
-     * an explicit recursion stack is used
-     *
-     * @param dangleLines : the LineStrings that formed dangles will
-     *                      be push_back'ed here
-     */
-    void deleteDangles(std::vector<const geom::LineString*>& dangleLines);
-
-private:
-
-    static int getDegreeNonDeleted(planargraph::Node* node);
-
-    static int getDegree(planargraph::Node* node, long label);
-
-    const geom::GeometryFactory* factory;
-
-    planargraph::Node* getNode(const geom::Coordinate& pt);
-
-    void computeNextCWEdges();
-
-    /**
-     * \brief
-     * Convert the maximal edge rings found by the initial graph traversal
-     * into the minimal edge rings required by JTS polygon topology rules.
-     *
-     * @param ringEdges
-     * 	the list of start edges for the edgeRings to convert.
-     *
-     */
-    void convertMaximalToMinimalEdgeRings(
-        std::vector<PolygonizeDirectedEdge*>& ringEdges);
-
-    /**
-     * \brief
-     * Finds all nodes in a maximal edgering
-     * which are self-intersection nodes
-     *
-     * @param startDE
-     * @param label
-     * @param intNodes : intersection nodes found will be pushed here
-     *                   the vector won't be cleared before pushing.
-     */
-    static void findIntersectionNodes(PolygonizeDirectedEdge* startDE,
-                                      long label, std::vector<planargraph::Node*>& intNodes
-                                     );
-
-    /**
-     * Finds and labels all edgerings in the graph.
-     *
-     * The edge rings are labeling with unique integers.
-     * The labeling allows detecting cut edges.
-     *
-     * @param dirEdgesIn  a list of the DirectedEdges in the graph
-     * @param dirEdgesOut each ring found will be pushed here
-     */
-    static void findLabeledEdgeRings(
-        std::vector<planargraph::DirectedEdge*>& dirEdgesIn,
-        std::vector<PolygonizeDirectedEdge*>& dirEdgesOut);
-
-    static void label(std::vector<PolygonizeDirectedEdge*>& dirEdges, long label);
-    static void label(std::vector<planargraph::DirectedEdge*>& dirEdges, long label);
-
-    static void computeNextCWEdges(planargraph::Node* node);
-
-    /**
-     * \brief
-     * Computes the next edge pointers going CCW around the given node,
-     * for the given edgering label.
-     * This algorithm has the effect of converting maximal edgerings
-     * into minimal edgerings
-     */
-    static void computeNextCCWEdges(planargraph::Node* node, long label);
-
-    EdgeRing* findEdgeRing(PolygonizeDirectedEdge* startDE);
-
-    /* Tese are for memory management */
-    std::vector<planargraph::Edge*> newEdges;
-    std::vector<planargraph::DirectedEdge*> newDirEdges;
-    std::vector<planargraph::Node*> newNodes;
-    std::vector<EdgeRing*> newEdgeRings;
-    std::vector<geom::CoordinateSequence*> newCoords;
-};
-
-} // namespace geos::operation::polygonize
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-