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

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

@@ -0,0 +1,69 @@
+/**********************************************************************
+ *
+ * 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 <vector>
+
+#include <geos/geom/GeometryComponentFilter.h>
+#include <geos/geom/Geometry.h> // to be removed when we have the .inl
+#include <geos/geom/Coordinate.h> // to be removed when we have the .inl
+#include <geos/geom/LineString.h> // to be removed when we have the .inl
+#include <geos/geom/Point.h> // to be removed when we have the .inl
+
+namespace geos {
+namespace geom { // geos::geom
+namespace util { // geos::geom::util
+
+/** \brief
+ * Extracts a single representative {@link Coordinate}
+ * from each connected component of a {@link Geometry}.
+ *
+ * @version 1.9
+ */
+class ComponentCoordinateExtracter : public GeometryComponentFilter {
+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 ComponentCoordinateFilter instance
+     * and pass it to multiple geometries.
+     */
+    static void getCoordinates(const Geometry& geom, std::vector<const CoordinateXY*>& ret);
+
+    /**
+     * Constructs a ComponentCoordinateFilter with a list in which
+     * to store Coordinates found.
+     */
+    ComponentCoordinateExtracter(std::vector<const CoordinateXY*>& newComps);
+
+    void filter_rw(Geometry* geom) override;
+
+    void filter_ro(const Geometry* geom) override;
+
+private:
+
+    std::vector<const CoordinateXY*>& comps;
+
+    // Declare type as noncopyable
+    ComponentCoordinateExtracter(const ComponentCoordinateExtracter& other) = delete;
+    ComponentCoordinateExtracter& operator=(const ComponentCoordinateExtracter& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

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

@@ -0,0 +1,70 @@
+/**********************************************************************
+ *
+ * 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/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
+
+/**
+ * A GeometryEditorOperation which modifies the coordinate list of a
+ * Geometry.
+ * Operates on Geometry subclasses which contains a single coordinate list.
+ */
+class GEOS_DLL CoordinateOperation: public GeometryEditorOperation {
+
+public:
+
+    /**
+     * Return a newly created geometry, ownership to caller
+     */
+    std::unique_ptr<Geometry> edit(const Geometry* geometry,
+                                   const GeometryFactory* factory) override;
+
+    /**
+     * Edits the array of Coordinate from a Geometry.
+     *
+     * @param coordinates the coordinate array to operate on
+     * @param geometry the geometry containing the coordinate list
+     * @return an edited coordinate array (which may be the same as
+     *         the input)
+     */
+    virtual std::unique_ptr<CoordinateSequence> edit(const CoordinateSequence* coordinates,
+                                                     const Geometry* geometry) = 0;
+
+
+    ~CoordinateOperation() override = default;
+};
+
+
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

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

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * 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 rev. 1.6 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/util/GeometryTransformer.h>
+#include <geos/geom/util/Densifier.h>
+#include <geos/util/Interrupt.h>
+
+#include <vector>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+/* warning C4251: needs to have dll-interface to be used by */
+/* clients of class */
+#pragma warning(disable: 4251)
+#endif
+
+
+namespace geos {
+namespace geom {
+namespace util {
+
+/**
+ * Densifies a {@link Geometry} by inserting extra vertices along the line segments
+ * contained in the geometry.
+ * All segments in the created densified geometry will be no longer than
+ * than the given distance tolerance.
+ * Densified polygonal geometries are guaranteed to be topologically correct.
+ * The coordinates created during densification respect the input geometry's
+ * {@link PrecisionModel}.
+ * <p>
+ * <b>Note:</b> At some future point this class will
+ * offer a variety of densification strategies.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL Densifier {
+public:
+    Densifier(const Geometry* inputGeom);
+
+    static Geometry::Ptr densify(const Geometry* geom, double distanceTolerance);
+    void setDistanceTolerance(double distanceTolerance);
+    Geometry::Ptr getResultGeometry() const;
+
+private:
+    double distanceTolerance;
+    const Geometry* inputGeom;
+    static std::unique_ptr<CoordinateSequence> densifyPoints(const CoordinateSequence& pts, double distanceTolerance,
+            const PrecisionModel* precModel);
+
+    class GEOS_DLL DensifyTransformer: public GeometryTransformer {
+    public:
+        DensifyTransformer(double distanceTolerance);
+        double distanceTolerance;
+        CoordinateSequence::Ptr transformCoordinates(const CoordinateSequence* coords, const Geometry* parent) override;
+        Geometry::Ptr transformPolygon(const Polygon* geom, const Geometry* parent) override;
+        Geometry::Ptr transformMultiPolygon(const MultiPolygon* geom, const Geometry* parent) override;
+        Geometry::Ptr createValidArea(const Geometry* roughAreaGeom);
+    };
+
+}; // Densifier
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

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

@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2006-2011 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/GeometryCombiner.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+}
+}
+
+namespace geos {
+namespace geom { // geos.geom
+namespace util { // geos.geom.util
+
+/** \brief
+ * Combines [Geometrys](@ref Geometry) to produce a GeometryCollection
+ * of the most appropriate type.
+ *
+ * Input geometries which are already collections will have their elements
+ * extracted first.
+ * No validation of the result geometry is performed.
+ * (The only case where invalidity is possible is where polygonal geometries
+ * are combined and result in a self-intersection).
+ *
+ * @see GeometryFactory#buildGeometry
+ */
+class GEOS_DLL GeometryCombiner {
+public:
+    /** \brief
+     * Copies a collection of geometries and combines the result.
+     *
+     * @param geoms the geometries to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::vector<const Geometry*> const& geoms);
+
+    /** \brief
+     * Combines a collection of geometries.
+     *
+     * @param geoms the geometries to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::vector<std::unique_ptr<Geometry>> && geoms);
+
+    /** \brief
+     * Copies two geometries and combines the result.
+     *
+     * @param g0 a geometry to combine (ownership left to caller)
+     * @param g1 a geometry to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(const Geometry* g0, const Geometry* g1);
+
+    /** \brief
+     * Combines two geometries.
+     *
+     * @param g0 a geometry to combine (ownership transferred to combined geometry)
+     * @param g1 a geometry to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::unique_ptr<Geometry> && g0,
+                                             std::unique_ptr<Geometry> && g1);
+
+    /** \brief
+     * Copies three geometries and combines the result.
+     *
+     * @param g0 a geometry to combine (ownership left to caller)
+     * @param g1 a geometry to combine (ownership left to caller)
+     * @param g2 a geometry to combine (ownership left to caller)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(const Geometry* g0, const Geometry* g1, const Geometry* g2);
+
+    /** \brief
+     * Combines three geometries.
+     *
+     * @param g0 a geometry to combine (ownership transferred to combined geometry)
+     * @param g1 a geometry to combine (ownership transferred to combined geometry)
+     * @param g2 a geometry to combine (ownership transferred to combined geometry)
+     * @return the combined geometry
+     */
+    static std::unique_ptr<Geometry> combine(std::unique_ptr<Geometry> && g0,
+                                             std::unique_ptr<Geometry> && g1,
+                                             std::unique_ptr<Geometry> && g2);
+
+private:
+    std::vector<std::unique_ptr<Geometry>> inputGeoms;
+    bool skipEmpty;
+
+public:
+    /** \brief
+     * Creates a new combiner for a collection of geometries.
+     *
+     * @param geoms the geometries to combine
+     */
+    explicit GeometryCombiner(std::vector<const Geometry*> const& geoms);
+
+    explicit GeometryCombiner(std::vector<std::unique_ptr<Geometry>> && geoms);
+
+    /** \brief
+     * Extracts the GeometryFactory used by the geometries in a collection.
+     *
+     * @return a GeometryFactory
+     */
+    GeometryFactory const* extractFactory() const;
+
+    /** \brief
+     * Computes the combination of the input geometries
+     * to produce the most appropriate Geometry or GeometryCollection.
+     *
+     * @return a Geometry which is the combination of the inputs
+     */
+    std::unique_ptr<Geometry> combine();
+
+    /** \brief
+     * Set a flag indicating that empty geometries should be omitted from the result.
+     */
+    void setSkipEmpty(bool);
+
+    // Declare type as noncopyable
+    GeometryCombiner(const GeometryCombiner& other) = delete;
+    GeometryCombiner& operator=(const GeometryCombiner& rhs) = delete;
+};
+
+} // namespace geos.geom.util
+} // namespace geos.geom
+} // namespace geos
+

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