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

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/GeometryEditor.h

@@ -0,0 +1,127 @@
+/**********************************************************************
+ *
+ * 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: geom/util/GeometryEditor.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class GeometryCollection;
+class Polygon;
+namespace util {
+class GeometryEditorOperation;
+}
+}
+}
+
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * Supports creating a new Geometry which is a modification of an existing one.
+ * Geometry objects are intended to be treated as immutable.
+ * This class allows you to "modify" a Geometry
+ * by traversing it and creating a new Geometry with the same overall
+ * structure but possibly modified components.
+ *
+ * The following kinds of modifications can be made:
+ *
+ * - the values of the coordinates may be changed.
+ *   Changing coordinate values may make the result Geometry invalid;
+ *   this is not checked by the GeometryEditor
+ * - the coordinate lists may be changed
+ *   (e.g. by adding or deleting coordinates).
+ *   The modified coordinate lists must be consistent with their original
+ *   parent component
+ *   (e.g. a LinearRing must always have at least 4 coordinates, and the
+ *   first and last coordinate must be equal)
+ * - components of the original geometry may be deleted
+ *   (e.g. holes may be removed from a Polygon, or LineStrings removed
+ *   from a MultiLineString). Deletions will be propagated up the component
+ *   tree appropriately.
+ *
+ * Note that all changes must be consistent with the original Geometry's
+ * structure
+ * (e.g. a Polygon cannot be collapsed into a LineString).
+ *
+ * The resulting Geometry is not checked for validity.
+ * If validity needs to be enforced, the new Geometry's isValid should
+ * be checked.
+ *
+ * @see Geometry::isValid
+ *
+ */
+class GEOS_DLL GeometryEditor {
+private:
+    /**
+     * The factory used to create the modified Geometry
+     */
+    const GeometryFactory* factory;
+
+    std::unique_ptr<Polygon> editPolygon(const Polygon* polygon,
+                                         GeometryEditorOperation* operation);
+
+    std::unique_ptr<GeometryCollection> editGeometryCollection(
+            const GeometryCollection* collection,
+            GeometryEditorOperation* operation);
+
+public:
+
+    /**
+     * Creates a new GeometryEditor object which will create
+     * an edited Geometry with the same GeometryFactory as the
+     * input Geometry.
+     */
+    GeometryEditor();
+
+    /**
+     * Creates a new GeometryEditor object which will create
+     * the edited Geometry with the given GeometryFactory
+     *
+     * @param newFactory the GeometryFactory to create the edited
+     *                   Geometry with
+     */
+    GeometryEditor(const GeometryFactory* newFactory);
+
+    /**
+     * Edit the input Geometry with the given edit operation.
+     * Clients will create subclasses of GeometryEditorOperation or
+     * CoordinateOperation to perform required modifications.
+     *
+     * @param geometry the Geometry to edit
+     * @param operation the edit operation to carry out
+     * @return a new Geometry which is the result of the editing
+     *
+     */
+    std::unique_ptr<Geometry> edit(const Geometry* geometry,
+                                   GeometryEditorOperation* operation); // final
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/GeometryLister.h

@@ -0,0 +1,92 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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: geom/util/GeometryExtracter.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/GeometryFilter.h>
+#include <geos/geom/GeometryCollection.h>
+#include <vector>
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * Extracts all the components of a collection, or just echoes back a
+ * pointers to singletons.
+ */
+class GEOS_DLL GeometryLister {
+
+public:
+
+    /**
+     * Extracts the components from a {@link Geometry}
+     * and adds them to the provided container.
+     *
+     * Useful for iterating over components of a collection.
+     *
+     * @param geom the geometry from which to extract
+     * @param lst the list to add the extracted elements to
+     */
+    static void
+    list(const Geometry* geom, std::vector<const Geometry*>& lst)
+    {
+        if(geom->isCollection()) {
+            GeometryLister::Lister lister(lst);
+            geom->apply_ro(&lister);
+        }
+        else {
+            lst.push_back(geom);
+        }
+    }
+
+private:
+
+    struct Lister : public GeometryFilter {
+
+        /**
+         * Constructs a filter with a list in which to store the elements found.
+         *
+         * @param comps the container to extract into (will push_back to it)
+         */
+        Lister(std::vector<const Geometry*>& p_geoms) : geoms(p_geoms) {}
+
+        std::vector<const Geometry*>& geoms;
+
+        void
+        filter_ro(const Geometry* geom) override
+        {
+            if(!geom->isCollection()) {
+                geoms.push_back(geom);
+            }
+        }
+
+        // // Declare type as noncopyable
+        // Lister(const Lister& other);
+        // Lister& operator=(const Lister& rhs);
+    };
+};
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/GeometryTransformer.h

@@ -0,0 +1,181 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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: geom/util/GeometryTransformer.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h> // destructor visibility for vector
+#include <geos/geom/Geometry.h> // destructor visibility for unique_ptr
+#include <geos/geom/CoordinateSequence.h> // destructor visibility for unique_ptr
+
+#include <memory> // for unique_ptr
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class Point;
+class LinearRing;
+class LineString;
+class Polygon;
+class MultiPoint;
+class MultiPolygon;
+class MultiLineString;
+class GeometryCollection;
+namespace util {
+//class GeometryEditorOperation;
+}
+}
+}
+
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/** \brief
+ * A framework for processes which transform an input Geometry into
+ * an output Geometry, possibly changing its structure and type(s).
+ *
+ * This class is a framework for implementing subclasses which perform
+ * transformations on various different Geometry subclasses.
+ * It provides an easy way of applying specific transformations
+ * to given geometry types, while allowing unhandled types to be simply copied.
+ * Also, the framework ensures that if subcomponents change type
+ * the parent geometries types change appropriately to maintain valid structure.
+ * Subclasses will override whichever `transformX` methods
+ * they need to to handle particular Geometry types.
+ *
+ * A typically usage would be a transformation that may transform Polygons into
+ * Polygons, LineStrings or Points. This class would likely need to override the
+ * `GeometryTransformer::transformMultiPolygon(const MultiPolygon* geom,
+ * const Geometry* parent)` method to ensure that if input Polygons change type
+ * the result is a GeometryCollection, not a MultiPolygon
+ *
+ * The default behaviour of this class is to simply recursively transform
+ * each Geometry component into an identical object by copying.
+ *
+ * Note that all `transformX` methods may return `null`, to avoid creating
+ * empty geometry objects. This will be handled correctly by the transformer.
+ * The `GeometryTransformer::transform(const Geometry* nInputGeom)` method
+ * itself will always return a geometry object.
+ *
+ * @see GeometryEditor
+ *
+ * Possible extensions:
+ * getParent() method to return immediate parent e.g. of LinearRings in Polygons
+ *
+ */
+class GEOS_DLL GeometryTransformer {
+
+public:
+
+    GeometryTransformer();
+
+    virtual ~GeometryTransformer() = default;
+
+    std::unique_ptr<Geometry> transform(const Geometry* nInputGeom);
+
+    void setSkipTransformedInvalidInteriorRings(bool b);
+
+protected:
+
+    const GeometryFactory* factory;
+
+    virtual CoordinateSequence::Ptr transformCoordinates(
+        const CoordinateSequence* coords,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformPoint(
+        const Point* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformMultiPoint(
+        const MultiPoint* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformLinearRing(
+        const LinearRing* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformLineString(
+        const LineString* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformMultiLineString(
+        const MultiLineString* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformPolygon(
+        const Polygon* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformMultiPolygon(
+        const MultiPolygon* geom,
+        const Geometry* parent);
+
+    virtual Geometry::Ptr transformGeometryCollection(
+        const GeometryCollection* geom,
+        const Geometry* parent);
+
+private:
+
+    const Geometry* inputGeom;
+
+    // these could eventually be exposed to clients
+    /**
+     * `true` if empty geometries should not be included in the result
+     */
+    bool pruneEmptyGeometry;
+
+    /**
+     * `true` if a homogeneous collection result
+     * from a {@link GeometryCollection} should still
+     * be a general GeometryCollection
+     */
+    bool preserveGeometryCollectionType;
+
+    /**
+     * `true` if the output from a collection argument should still be a collection
+     */
+    // bool preserveCollections;
+
+    /**
+     * `true` if the type of the input should be preserved
+     */
+    bool preserveType;
+
+    /**
+     * `true` if transformed invalid interior rings should be skipped
+     */
+    bool skipTransformedInvalidInteriorRings;
+
+    // Declare type as noncopyable
+    GeometryTransformer(const GeometryTransformer& other) = delete;
+    GeometryTransformer& operator=(const GeometryTransformer& rhs) = delete;
+};
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geom/util/PolygonalExtracter.h

@@ -0,0 +1,54 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2001-2002 Vivid Solutions Inc.
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <vector>
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * \brief Extracts the polygonal (Polygon and MultiPolygon) elements from a Geometry.
+ */
+class GEOS_DLL PolygonalExtracter {
+
+public:
+
+    /**
+     * Pushes the polygonal (Polygon and MultiPolygon) elements from a geometry into
+     * the provided vector.
+     * 
+     * @param geom the geometry to extract from
+     * @param polys the vector to add the polygonal elements to
+     */
+    static void getPolygonals(const Geometry& geom, std::vector<const Geometry*>& polys);
+
+private:
+
+    static void getPolygonals(const Geometry* geom, std::vector<const Geometry*>& polys);
+
+    // Declare type as noncopyable
+    PolygonalExtracter(const PolygonalExtracter& other) = delete;
+    PolygonalExtracter& operator=(const PolygonalExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/geomgraph/DirectedEdge.h

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-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: geomgraph/DirectedEdge.java r428 (JTS-1.12)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <string>
+
+#include <geos/geom/Location.h>
+#include <geos/geomgraph/EdgeEnd.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geomgraph {
+class Edge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/// A directed EdgeEnd
+class GEOS_DLL DirectedEdge final: public EdgeEnd {
+
+public:
+
+    /** \brief
+     * Computes the factor for the change in depth when moving from
+     * one location to another.
+     * E.g. if crossing from the INTERIOR to the EXTERIOR the depth
+     * decreases, so the factor is -1
+     */
+    static int depthFactor(geom::Location currLocation, geom::Location nextLocation);
+
+    //DirectedEdge();
+    //virtual ~DirectedEdge();
+
+    DirectedEdge(Edge* newEdge, bool newIsForward);
+
+    // this is no different from Base class, no need to override
+    //Edge* getEdge();
+
+    void setInResult(bool v)
+    {
+        isInResultVar = v;
+    };
+
+    bool isInResult() const
+    {
+        return isInResultVar;
+    };
+
+    bool isVisited() const
+    {
+        return isVisitedVar;
+    };
+
+
+    void setVisited(bool v)
+    {
+        isVisitedVar = v;
+    };
+
+    void setEdgeRing(EdgeRing* er)
+    {
+        edgeRing = er;
+    };
+
+    EdgeRing* getEdgeRing() const
+    {
+        return edgeRing;
+    };
+
+    void setMinEdgeRing(EdgeRing* mer)
+    {
+        minEdgeRing = mer;
+    };
+
+    EdgeRing* getMinEdgeRing() const
+    {
+        return minEdgeRing;
+    };
+
+    int getDepth(int position) const
+    {
+        return depth[position];
+    };
+
+    void setDepth(int position, int newDepth);
+
+    int getDepthDelta() const;
+
+    /// Marks both DirectedEdges attached to a given Edge.
+    ///
+    /// This is used for edges corresponding to lines, which will only
+    /// appear oriented in a single direction in the result.
+    ///
+    void setVisitedEdge(bool newIsVisited);
+
+    /** \brief
+     * Each Edge gives rise to a pair of symmetric DirectedEdges,
+     * in opposite directions.
+     *
+     * @return the DirectedEdge for the same Edge but in the
+     *         opposite direction
+     */
+    DirectedEdge* getSym() const
+    {
+        return sym;
+    };
+
+    bool isForward() const
+    {
+        return isForwardVar;
+    };
+
+    void setSym(DirectedEdge* de)
+    {
+        sym = de;
+    };
+
+    DirectedEdge* getNext() const
+    {
+        return next;
+    };
+
+    void setNext(DirectedEdge* newNext)
+    {
+        next = newNext;
+    };
+
+    DirectedEdge* getNextMin() const
+    {
+        return nextMin;
+    };
+
+    void setNextMin(DirectedEdge* nm)
+    {
+        nextMin = nm;
+    };
+
+    /** \brief
+     * Tells whether this edge is a Line
+     *
+     * This edge is a line edge if
+     * - at least one of the labels is a line label
+     * - any labels which are not line labels have all Locations = EXTERIOR
+     *
+     */
+    bool isLineEdge();
+
+    /** \brief
+     * Tells whether this edge is an Area
+     *
+     * This is an interior Area edge if
+     * - its label is an Area label for both Geometries
+     * - and for each Geometry both sides are in the interior.
+     *
+     * @return true if this is an interior Area edge
+     */
+    bool isInteriorAreaEdge();
+
+    /** \brief
+     * Set both edge depths.
+     *
+     * One depth for a given side is provided.
+     * The other is computed depending on the Location transition and the
+     * depthDelta of the edge.
+     */
+    void setEdgeDepths(int position, int newDepth);
+
+    std::string print() const override;
+
+    std::string printEdge();
+
+
+protected:
+
+    bool isForwardVar;
+
+
+private:
+
+    bool isInResultVar;
+
+    bool isVisitedVar;
+
+    /// the symmetric edge
+    DirectedEdge* sym;
+
+    /// the next edge in the edge ring for the polygon containing this edge
+    DirectedEdge* next;
+
+    /// the next edge in the MinimalEdgeRing that contains this edge
+    DirectedEdge* nextMin;
+
+    /// the EdgeRing that this edge is part of
+    EdgeRing* edgeRing;
+
+    /// the MinimalEdgeRing that this edge is part of
+    EdgeRing* minEdgeRing;
+
+    /** \brief
+     * The depth of each side (position) of this edge.
+     * The 0 element of the array is never used.
+     */
+    int depth[3];
+
+    /// Compute the label in the appropriate orientation for this DirEdge
+    void computeDirectedLabel();
+
+
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+