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

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/linemerge/LineMerger.h

@@ -0,0 +1,149 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/linemerge/LineMerger.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/LineString.h>
+#include <geos/operation/linemerge/LineMergeGraph.h> // for composition
+
+#include <memory>
+#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 GeometryFactory;
+class Geometry;
+}
+namespace planargraph {
+class Node;
+}
+namespace operation {
+namespace linemerge {
+class EdgeString;
+class LineMergeDirectedEdge;
+}
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/**
+ *
+ * \brief
+ * Sews together a set of fully noded LineStrings.
+ *
+ * Sewing stops at nodes of degree 1 or 3 or more.
+ * The exception is an isolated loop, which only has degree-2 nodes,
+ * in which case a node is simply chosen as a starting point.
+ * The direction of each merged LineString will be that of the majority
+ * of the LineStrings from which it was derived.
+ *
+ * Any dimension of Geometry is handled.
+ * The constituent linework is extracted to form the edges.
+ * The edges must be correctly noded; that is, they must only meet
+ * at their endpoints.
+ *
+ * The LineMerger will still run on incorrectly noded input
+ * but will not form polygons from incorrected noded edges.
+ *
+ */
+class GEOS_DLL LineMerger {
+
+private:
+
+    LineMergeGraph graph;
+
+    bool isDirected;
+
+    std::vector<std::unique_ptr<geom::LineString>> mergedLineStrings;
+
+    std::vector<EdgeString*> edgeStrings;
+
+    const geom::GeometryFactory* factory;
+
+    void merge();
+
+    void buildEdgeStringsForObviousStartNodes();
+
+    void buildEdgeStringsForIsolatedLoops();
+
+    void buildEdgeStringsForUnprocessedNodes();
+
+    void buildEdgeStringsForNonDegree2Nodes();
+
+    void buildEdgeStringsStartingAt(planargraph::Node* node);
+
+    EdgeString* buildEdgeStringStartingWith(LineMergeDirectedEdge* start);
+
+public:
+    LineMerger(bool directed = false);
+    ~LineMerger();
+
+    /**
+     * \brief
+     * Adds a collection of Geometries to be processed.
+     * May be called multiple times.
+     *
+     * Any dimension of Geometry may be added; the constituent
+     * linework will be extracted.
+     */
+    void add(std::vector<const geom::Geometry*>* geometries);
+
+    /**
+     * \brief
+     * Adds a Geometry to be processed.
+     * May be called multiple times.
+     *
+     * Any dimension of Geometry may be added; the constituent
+     * linework will be extracted.
+     */
+    void add(const geom::Geometry* geometry);
+
+    /**
+     * \brief
+     * Returns the LineStrings built by the merging process.
+     *
+     * Ownership of vector _and_ its elements to caller.
+     */
+    std::vector<std::unique_ptr<geom::LineString>> getMergedLineStrings();
+
+    void add(const geom::LineString* lineString);
+
+    // Declare type as noncopyable
+    LineMerger(const LineMerger& other) = delete;
+    LineMerger& operator=(const LineMerger& rhs) = delete;
+};
+
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/linemerge/LineSequencer.h

@@ -0,0 +1,295 @@
+/**********************************************************************
+ *
+ * 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: operation/linemerge/LineSequencer.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/operation/linemerge/LineMergeGraph.h> // for composition
+#include <geos/geom/Geometry.h> // for inlines
+#include <geos/geom/LineString.h> // for inlines
+
+#include <vector>
+#include <list>
+#include <memory> // for unique_ptr
+
+#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 GeometryFactory;
+class Geometry;
+class LineString;
+}
+namespace planargraph {
+class DirectedEdge;
+class Subgraph;
+class Node;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace linemerge { // geos::operation::linemerge
+
+/** \brief
+ * Builds a sequence from a set of LineStrings so that
+ * they are ordered end to end.
+ *
+ * A sequence is a complete non-repeating list of the linear
+ * components of the input.  Each linestring is oriented
+ * so that identical endpoints are adjacent in the list.
+ *
+ * A typical use case is to convert a set of unoriented geometric links
+ * from a linear network (e.g. such as block faces on a bus route)
+ * into a continuous oriented path through the network.
+ *
+ * The input linestrings may form one or more connected sets.
+ * The input linestrings should be correctly noded, or the results may
+ * not be what is expected.
+ * The computed output is a single MultiLineString containing the ordered
+ * linestrings in the sequence.
+ *
+ * The sequencing employs the classic **Eulerian path** graph algorithm.
+ * Since Eulerian paths are not uniquely determined, further rules are used
+ * to make the computed sequence preserve as much as possible of the input
+ * ordering. Within a connected subset of lines, the ordering rules are:
+ *
+ * - If there is degree-1 node which is the start
+ *   node of an linestring, use that node as the start of the sequence
+ * - If there is a degree-1 node which is the end
+ *   node of an linestring, use that node as the end of the sequence
+ * - If the sequence has no degree-1 nodes, use any node as the start
+ *
+ * @note Not all arrangements of lines can be sequenced. For a connected
+ * set of edges in a graph, *Euler's Theorem* states that there is a sequence
+ * containing each edge once **if and only if** there are no more than
+ * 2 nodes of odd degree. If it is not possible to find a sequence, the
+ * `isSequenceable` method will return `false`.
+ *
+ */
+class GEOS_DLL LineSequencer {
+
+private:
+    typedef std::list<planargraph::DirectedEdge*> DirEdgeList;
+    typedef std::vector< DirEdgeList* > Sequences;
+
+    LineMergeGraph graph;
+    const geom::GeometryFactory* factory;
+    unsigned int lineCount;
+    bool isRun;
+    std::unique_ptr<geom::Geometry> sequencedGeometry;
+    bool isSequenceableVar;
+
+    void addLine(const geom::LineString* lineString);
+    void computeSequence();
+    Sequences* findSequences();
+    DirEdgeList* findSequence(planargraph::Subgraph& graph);
+
+    void delAll(Sequences&);
+
+    /**
+     * Builds a geometry ({@link LineString} or {@link MultiLineString} )
+     * representing the sequence.
+     *
+     * @param sequences
+     *    a vector of vectors of const planarDirectedEdges
+     *    with LineMergeEdges as their parent edges.
+     *    Ownership of container _and_ contents retained by caller.
+     *
+     * @return the sequenced geometry, possibly NULL
+     *         if no sequence exists
+     */
+    geom::Geometry* buildSequencedGeometry(const Sequences& sequences);
+
+    static const planargraph::Node* findLowestDegreeNode(
+        const planargraph::Subgraph& graph);
+
+    void addReverseSubpath(const planargraph::DirectedEdge* de,
+                           DirEdgeList& deList,
+                           DirEdgeList::iterator lit,
+                           bool expectedClosed);
+
+    /**
+     * Finds an {@link DirectedEdge} for an unvisited edge (if any),
+     * choosing the dirEdge which preserves orientation, if possible.
+     *
+     * @param node the node to examine
+     * @return the dirEdge found, or <code>null</code>
+     *         if none were unvisited
+     */
+    static const planargraph::DirectedEdge* findUnvisitedBestOrientedDE(
+        const planargraph::Node* node);
+
+    /**
+     * Computes a version of the sequence which is optimally
+     * oriented relative to the underlying geometry.
+     *
+     * Heuristics used are:
+     *
+     * - If the path has a degree-1 node which is the start
+     *   node of an linestring, use that node as the start of the sequence
+     * - If the path has a degree-1 node which is the end
+     *   node of an linestring, use that node as the end of the sequence
+     * - If the sequence has no degree-1 nodes, use any node as the start
+     *   (NOTE: in this case could orient the sequence according to the
+     *   majority of the linestring orientations)
+     *
+     * @param seq a List of planarDirectedEdges
+     * @return the oriented sequence, possibly same as input if already
+     *         oriented
+     */
+    DirEdgeList* orient(DirEdgeList* seq);
+
+    /**
+     * Reverse the sequence.
+     * This requires reversing the order of the dirEdges, and flipping
+     * each dirEdge as well
+     *
+     * @param seq a List of DirectedEdges, in sequential order
+     * @return the reversed sequence
+     */
+    DirEdgeList* reverse(DirEdgeList& seq);
+
+    /**
+     * Tests whether a complete unique path exists in a graph
+     * using Euler's Theorem.
+     *
+     * @param graph the subgraph containing the edges
+     * @return <code>true</code> if a sequence exists
+     */
+    bool hasSequence(planargraph::Subgraph& graph);
+
+public:
+
+    static geom::Geometry*
+    sequence(const geom::Geometry& geom)
+    {
+        LineSequencer sequencer;
+        sequencer.add(geom);
+        return sequencer.getSequencedLineStrings();
+    }
+
+    LineSequencer()
+        :
+        factory(nullptr),
+        lineCount(0),
+        isRun(false),
+        sequencedGeometry(nullptr),
+        isSequenceableVar(false)
+    {}
+
+    /** \brief
+     * Tests whether a [Geometry](@ref geom::Geometry) is sequenced correctly.
+     *
+     * [LineStrings](@ref geom::LineString) are trivially sequenced.
+     * [MultiLineStrings](@ref geom::MultiLineString) are checked for
+     * correct sequencing. Otherwise, `isSequenced` is defined
+     * to be `true` for geometries that are not lineal.
+     *
+     * @param geom the geometry to test
+     * @return `true` if the geometry is sequenced or is not lineal
+     */
+    static bool isSequenced(const geom::Geometry* geom);
+
+    /** \brief
+     * Tests whether the arrangement of linestrings has a valid
+     * sequence.
+     *
+     * @return `true` if a valid sequence exists.
+     */
+    bool
+    isSequenceable()
+    {
+        computeSequence();
+        return isSequenceableVar;
+    }
+
+    /** \brief
+     * Adds a [Geometry](@ref geom::Geometry) to be sequenced.
+     *
+     * May be called multiple times.
+     * Any dimension of Geometry may be added; the constituent
+     * linework will be extracted.
+     *
+     * @param geometry the geometry to add
+     */
+    void
+    add(const geom::Geometry& geometry)
+    {
+        geometry.applyComponentFilter(*this);
+    }
+
+    template <class TargetContainer>
+    void
+    add(TargetContainer& geoms)
+    {
+        for(typename TargetContainer::const_iterator i = geoms.begin(),
+                e = geoms.end(); i != e; ++i) {
+            const geom::Geometry* g = *i;
+            add(*g);
+        }
+    }
+
+    /** \brief
+     * Act as a GeometryComponentFilter so to extract
+     * the linearworks
+     */
+    void
+    filter(const geom::Geometry* g)
+    {
+        if(const geom::LineString* ls = dynamic_cast<const geom::LineString*>(g)) {
+            addLine(ls);
+        }
+    }
+
+    /** \brief
+     * Returns the LineString or MultiLineString
+     * built by the sequencing process, if one exists.
+     *
+     * @param release release ownership of computed Geometry
+     * @return the sequenced linestrings,
+     *         or `null` if a valid sequence
+     *         does not exist.
+     */
+    geom::Geometry*
+    getSequencedLineStrings(bool release = 1)
+    {
+        computeSequence();
+        if(release) {
+            return sequencedGeometry.release();
+        }
+        else {
+            return sequencedGeometry.get();
+        }
+    }
+};
+
+} // namespace geos::operation::linemerge
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/MaximalEdgeRing.h

@@ -0,0 +1,105 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/overlay/MaximalEdgeRing.java rev. 1.15 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+
+#include <geos/geomgraph/EdgeRing.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+}
+namespace geomgraph {
+class DirectedEdge;
+//class EdgeRing;
+}
+namespace operation {
+namespace overlay {
+class MinimalEdgeRing;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+
+/** \brief
+ * A ring of [DirectedEdges](@ref geomgraph::DirectedEdge) which may contain nodes of degree > 2.
+ *
+ * A MaximalEdgeRing may represent two different spatial entities:
+ *
+ * - a single polygon possibly containing inversions (if the ring is oriented CW)
+ * - a single hole possibly containing exversions (if the ring is oriented CCW)
+ *
+ * If the MaximalEdgeRing represents a polygon,
+ * the interior of the polygon is strongly connected.
+ *
+ * These are the form of rings used to define polygons under some spatial data models.
+ * However, under the OGC SFS model, [MinimalEdgeRings](@ref MinimalEdgeRing) are required.
+ * A MaximalEdgeRing can be converted to a list of MinimalEdgeRings using the
+ * {@link #buildMinimalRings() } method.
+ *
+ * @see com.vividsolutions.jts.operation.overlay.MinimalEdgeRing
+ */
+class GEOS_DLL MaximalEdgeRing: public geomgraph::EdgeRing {
+
+public:
+
+    MaximalEdgeRing(geomgraph::DirectedEdge* start,
+                    const geom::GeometryFactory* geometryFactory);
+    // throw(const TopologyException &)
+
+    ~MaximalEdgeRing() override = default;
+
+    geomgraph::DirectedEdge* getNext(geomgraph::DirectedEdge* de) override;
+
+    void setEdgeRing(geomgraph::DirectedEdge* de, geomgraph::EdgeRing* er) override;
+
+    /// \brief
+    /// This function returns a newly allocated vector of
+    /// pointers to newly allocated MinimalEdgeRing objects.
+    ///
+    /// @deprecated pass the vector yourself instead
+    ///
+    std::vector<MinimalEdgeRing*>* buildMinimalRings();
+
+    /// \brief
+    /// This function pushes pointers to newly allocated  MinimalEdgeRing
+    /// objects to the provided vector.
+    ///
+    void buildMinimalRings(std::vector<MinimalEdgeRing*>& minEdgeRings);
+    void buildMinimalRings(std::vector<EdgeRing*>& minEdgeRings);
+
+    /// \brief
+    /// For all nodes in this EdgeRing,
+    /// link the DirectedEdges at the node to form minimalEdgeRings
+    ///
+    void linkDirectedEdgesForMinimalEdgeRings();
+};
+
+
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/MinimalEdgeRing.h

@@ -0,0 +1,80 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/overlay/MinimalEdgeRing.java rev. 1.13 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/EdgeRing.h> // for inheritance
+#include <geos/geomgraph/DirectedEdge.h> // for inlines
+
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+}
+namespace geomgraph {
+class DirectedEdge;
+class EdgeRing;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+
+/** \brief
+ * A ring of [Edges](@ref geomgraph::Edge) with the property that no node
+ * has degree greater than 2.
+ *
+ * These are the form of rings required to represent polygons
+ * under the OGC SFS spatial data model.
+ *
+ * @see operation::overlay::MaximalEdgeRing
+ *
+ */
+class GEOS_DLL MinimalEdgeRing: public geomgraph::EdgeRing {
+
+public:
+
+    MinimalEdgeRing(geomgraph::DirectedEdge* start,
+                    const geom::GeometryFactory* geometryFactory);
+
+    ~MinimalEdgeRing() override {};
+
+    geomgraph::DirectedEdge* getNext(geomgraph::DirectedEdge* de) override
+    {
+        return de->getNextMin();
+    };
+
+    void setEdgeRing(geomgraph::DirectedEdge* de,
+                     geomgraph::EdgeRing* er) override
+    {
+        de->setMinEdgeRing(er);
+    };
+
+};
+
+
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/overlay/OverlayNodeFactory.h

@@ -0,0 +1,56 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * 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: operation/overlay/OverlayNodeFactory.java rev. 1.11 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+
+#include <geos/geomgraph/NodeFactory.h> // for inheritance
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Node;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace overlay { // geos::operation::overlay
+
+/** \brief
+ * Creates nodes for use in the geomgraph::PlanarGraph constructed during
+ * overlay operations. NOTE: also used by operation::valid
+ */
+class GEOS_DLL OverlayNodeFactory: public geomgraph::NodeFactory {
+public:
+    OverlayNodeFactory(): geomgraph::NodeFactory() {}
+    geomgraph::Node* createNode(const geom::Coordinate& coord) const override;
+    static const geomgraph::NodeFactory& instance();
+};
+
+
+} // namespace geos::operation::overlay
+} // namespace geos::operation
+} // namespace geos
+