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

package/dist/prebuilt/Emscripten-x86_64/include/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 modifed 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/dist/prebuilt/Emscripten-x86_64/include/geos/geom/util/GeometryEditorOperation.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 <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+
+/**
+ * A interface which specifies an edit operation for Geometries.
+ */
+class GEOS_DLL GeometryEditorOperation {
+
+public:
+    /**
+     * Edits a Geometry by returning a new Geometry with a modification.
+     * The returned Geometry might be the same as the Geometry passed in.
+     *
+     * @param geometry the Geometry to modify
+     *
+     * @param factory the factory with which to construct the modified
+     *                Geometry (may be different to the factory of the
+     *                input geometry)
+     *
+     * @return a new Geometry which is a modification of the input Geometry
+     */
+    virtual std::unique_ptr<Geometry> edit(const Geometry* geometry,
+                                           const GeometryFactory* factory) = 0;
+
+    virtual
+    ~GeometryEditorOperation() {}
+};
+
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/Emscripten-x86_64/include/geos/geom/util/GeometryExtracter.h

@@ -0,0 +1,95 @@
+/**********************************************************************
+ *
+ * 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 the components of a given type from a {@link Geometry}.
+ */
+class GEOS_DLL GeometryExtracter {
+
+public:
+
+    /**
+     * Extracts the components of type <tt>clz</tt> from a {@link Geometry}
+     * and adds them to the provided container.
+     *
+     * @param geom the geometry from which to extract
+     * @param lst the list to add the extracted elements to
+     */
+    template <class ComponentType, class TargetContainer>
+    static void
+    extract(const Geometry& geom, TargetContainer& lst)
+    {
+        if(const ComponentType* p_c = dynamic_cast<const ComponentType*>(&geom)) {
+            lst.push_back(p_c);
+        }
+        else if(const GeometryCollection* p_c1 =
+                    dynamic_cast<const GeometryCollection*>(&geom)) {
+            GeometryExtracter::Extracter<ComponentType, TargetContainer> extracter(lst);
+            p_c1->apply_ro(&extracter);
+        }
+    }
+
+private:
+
+    template <class ComponentType, class TargetContainer>
+    struct Extracter: 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)
+         */
+        Extracter(TargetContainer& comps) : comps_(comps) {}
+
+        TargetContainer& comps_;
+
+        void
+        filter_ro(const Geometry* geom) override
+        {
+            if(const ComponentType* c = dynamic_cast<const ComponentType*>(geom)) {
+                comps_.push_back(c);
+            }
+        }
+
+        // Declare type as noncopyable
+        Extracter(const Extracter& other);
+        Extracter& operator=(const Extracter& rhs);
+    };
+
+    // Declare type as noncopyable
+    GeometryExtracter(const GeometryExtracter& other) = delete;
+    GeometryExtracter& operator=(const GeometryExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

package/dist/prebuilt/Emscripten-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/Emscripten-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
+