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

package/dist/prebuilt/Android-x86_64/include/geos/geom/util/GeometryFixer.h

@@ -0,0 +1,169 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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 <memory>
+#include <vector>
+
+#include <geos/geom/Geometry.h>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Point;
+class Polygon;
+class LineString;
+class LinearRing;
+class MultiPoint;
+class MultiPolygon;
+class MultiLineString;
+class GeometryCollection;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * Fixes a geometry to be a valid geometry, while preserving as much as
+ * possible of the shape and location of the input.
+ * Validity is determined according to {@link Geometry#isValid()}.
+ *
+ * Input geometries are always processed, so even valid inputs may
+ * have some minor alterations.  The output is always a new geometry object.
+ *
+ * <h2>Semantic Rules</h2>
+ *
+ * * Vertices with non-finite X or Y ordinates are removed (as per Coordinate::isValid() ).
+ *  * Repeated points are reduced to a single point
+ *  * Empty atomic geometries are valid and are returned unchanged
+ *  * Empty elements are removed from collections
+ *  * <code>Point</code>: keep valid coordinate, or EMPTY
+ *  * <code>LineString</code>: coordinates are fixed
+ *  * <code>LinearRing</code>: coordinates are fixed, Keep valid ring or else convert into <code>LineString</code>
+ *  * <code>Polygon</code>: transform into a valid polygon,
+ *  * preserving as much of the extent and vertices as possible.
+ *    * Rings are fixed to ensure they are valid<
+ *    * Holes intersecting the shell are subtracted from the shell
+ *    * Holes outside the shell are converted into polygons
+ *  * <code>MultiPolygon</code>: each polygon is fixed,
+ *    then result made non-overlapping (via union)
+ *  * <code>GeometryCollection</code>: each element is fixed
+ *  * Collapsed lines and polygons are handled as follows,
+ *    depending on the <code>keepCollapsed</code> setting:
+ *    * <code>false</code>: (default) collapses are converted to empty geometries
+ *    * <code>true</code>: collapses are converted to a valid geometry of lower dimension
+ *
+ * @author Martin Davis
+*/
+class GEOS_DLL GeometryFixer {
+
+private:
+
+    const geom::Geometry* geom;
+    const geom::GeometryFactory* factory;
+    bool isKeepCollapsed; // false
+
+public:
+
+    GeometryFixer(const geom::Geometry* p_geom)
+        : geom(p_geom)
+        , factory(p_geom->getFactory())
+        , isKeepCollapsed(false)
+        {};
+
+    static std::unique_ptr<geom::Geometry> fix(const geom::Geometry* geom);
+
+    /**
+    * Sets whether collapsed geometries are converted to empty,
+    * (which will be removed from collections),
+    * or to a valid geom::Geometry of lower dimension.
+    * The default is to convert collapses to empty geometries.
+    *
+    * @param p_isKeepCollapsed whether collapses should be converted to a lower dimension geometry
+    */
+    void setKeepCollapsed(bool p_isKeepCollapsed);
+
+    /**
+    * Gets the fixed geometry.
+    *
+    * @return the fixed geometry
+    */
+    std::unique_ptr<geom::Geometry> getResult() const;
+
+private:
+
+    std::unique_ptr<geom::Point> fixPoint(const geom::Point* geom) const;
+    std::unique_ptr<geom::Point> fixPointElement(const geom::Point* geom) const;
+    bool isValidPoint(const geom::Point* pt) const;
+    std::unique_ptr<geom::Geometry> fixMultiPoint(const geom::MultiPoint* geom) const;
+    std::unique_ptr<geom::Geometry> fixLinearRing(const geom::LinearRing* geom) const;
+    std::unique_ptr<geom::Geometry> fixLinearRingElement(const geom::LinearRing* geom) const;
+    std::unique_ptr<geom::Geometry> fixLineString(const geom::LineString* geom) const;
+    std::unique_ptr<geom::Geometry> fixLineStringElement(const geom::LineString* geom) const;
+
+    /**
+    * Returns a clean copy of the input coordinate array.
+    *
+    * @param pts coordinates to clean
+    * @return an array of clean coordinates
+    */
+    std::unique_ptr<geom::Geometry> fixMultiLineString(const MultiLineString* geom) const;
+    std::unique_ptr<geom::Geometry> fixPolygon(const geom::Polygon* geom) const;
+    std::unique_ptr<geom::Geometry> fixPolygonElement(const geom::Polygon* geom) const;
+    std::vector<std::unique_ptr<Geometry>> fixHoles(const geom::Polygon* geom) const;
+    std::unique_ptr<geom::Geometry> removeHoles(const geom::Geometry* shell, const geom::Geometry* holes) const;
+    std::unique_ptr<geom::Geometry> fixRing(const geom::LinearRing* ring) const;
+    std::unique_ptr<geom::Geometry> fixMultiPolygon(const geom::MultiPolygon* geom) const;
+    std::unique_ptr<geom::Geometry> fixCollection(const geom::GeometryCollection* geom) const;
+
+    void classifyHoles(
+        const Geometry* shell,
+        std::vector<std::unique_ptr<Geometry>>& holesFixed,
+        std::vector<const Geometry*>& holes,
+        std::vector<const Geometry*>& shells) const;
+
+    /**
+    * Subtracts a list of polygonal geometries from a polygonal geometry.
+    *
+    * @param shell polygonal geometry for shell
+    * @param holes polygonal geometries to subtract
+    * @return the result geometry
+    */
+    std::unique_ptr<Geometry> difference(
+        const Geometry* shell,
+        std::vector<const Geometry*>& holes) const;
+
+    /**
+    * Unions a list of polygonal geometries.
+    * Optimizes case of zero or one input geometries.
+    * Requires that the inputs are net new objects.
+    *
+    * @param polys the polygonal geometries to union
+    * @return the union of the inputs
+    */
+    std::unique_ptr<Geometry> unionGeometry(
+        std::vector<const Geometry*>& polys) const;
+
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+
+

package/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/geos/geom/util/GeometryMapper.h

@@ -0,0 +1,115 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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: geom/util/GeometryMapper.java
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <functional>
+
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryCollection;
+class GeometryFactory;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+
+/**
+ * Methods to map various collections
+ * of {@link Geometry}s
+ * via defined mapping functions.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL GeometryMapper {
+
+public:
+
+    /**
+    * An interface for geometry functions that map a geometry input to a geometry output.
+    * The output may be nullptr if there is no valid output value for
+    * the given input value.
+    */
+    typedef std::function<std::unique_ptr<Geometry>(const Geometry&)> mapOp;
+
+    /**
+    * Maps the members of a {@link Geometry}
+    * (which may be atomic or composite)
+    * into another Geometry of most specific type.
+    * null results are skipped.
+    * In the case of hierarchical {@link GeometryCollection}s,
+    * only the first level of members are mapped.
+    *
+    * @param geom the input atomic or composite geometry
+    * @param op the mapping operation
+    * @return a result collection or geometry of most specific type
+    */
+    static std::unique_ptr<Geometry> map(
+        const Geometry& geom,
+        mapOp op);
+
+    /**
+    * Maps the atomic elements of a {@link Geometry}
+    * (which may be atomic or composite)
+    * using a mapOp mapping operation
+    * into an atomic Geometry or a flat collection
+    * of the most specific type.
+    * null and empty values returned from the mapping operation
+    * are discarded.
+    *
+    * @param geom the geometry to map
+    * @param emptyDim the dimension of empty geometry to create
+    * @param op the mapping operation
+    * @return the mapped result
+    */
+    static std::unique_ptr<Geometry> flatMap(
+        const Geometry& geom,
+        int emptyDim,
+        mapOp op);
+
+
+
+private:
+
+    static void flatMap(
+        const Geometry& geom,
+        mapOp op,
+        std::vector<std::unique_ptr<Geometry>>& mapped);
+
+    static void addFlat(
+        std::unique_ptr<Geometry>& geom,
+        std::vector<std::unique_ptr<Geometry>>& geomList);
+
+
+
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/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/dist/prebuilt/Android-x86_64/include/geos/geom/util/LinearComponentExtracter.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/geom/GeometryComponentFilter.h>
+#include <geos/geom/Geometry.h> // to be removed when we have the .inl
+#include <geos/geom/LineString.h> // to be removed when we have the .inl
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/**
+ * Extracts all the 1-dimensional (LineString) components from a Geometry.
+ */
+class GEOS_DLL LinearComponentExtracter: public GeometryComponentFilter {
+
+private:
+
+    LineString::ConstVect& comps;
+
+    // Declare type as noncopyable
+    LinearComponentExtracter(const LinearComponentExtracter& other) = delete;
+    LinearComponentExtracter& operator=(const LinearComponentExtracter& rhs) = delete;
+
+public:
+    /**
+     * Push the linear components from a single geometry into
+     * the provided vector.
+     * If more than one geometry is to be processed, it is more
+     * efficient to create a single LinearComponentExtracterFilter instance
+     * and pass it to multiple geometries.
+     */
+    static void getLines(const Geometry& geom, std::vector<const LineString*>& ret);
+    /**
+     * Constructs a LinearComponentExtracterFilter with a list in which
+     * to store LineStrings found.
+     */
+    LinearComponentExtracter(std::vector<const LineString*>& newComps);
+
+    void filter_ro(const Geometry* geom) override;
+
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/util/NoOpGeometryOperation.h

@@ -0,0 +1,52 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/util/GeometryEditorOperation.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+class GeometryFactory;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+
+class GEOS_DLL NoOpGeometryOperation: public GeometryEditorOperation {
+
+public:
+
+    /**
+     * Return a newly created geometry, ownership to caller
+     */
+    std::unique_ptr<Geometry> edit(const Geometry* geometry,
+                                   const GeometryFactory* factory) override;
+
+    ~NoOpGeometryOperation() override = default;
+};
+
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+