@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/noding/NodedSegmentString.h

@@ -0,0 +1,218 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Paul Ramsey <pramsey@cleverelephant.ca>
+ * 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: noding/NodedSegmentString.java r320 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h> // for inlines
+#include <geos/noding/NodedSegmentString.h>
+#include <geos/noding/NodableSegmentString.h> // for inheritance
+#include <geos/noding/SegmentNode.h>
+#include <geos/noding/SegmentNodeList.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/util/IllegalArgumentException.h>
+
+#include <cstddef>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251 4355) // warning C4355: 'this' : used in base member initializer list
+#endif
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Represents a list of contiguous line segments,
+ * and supports noding the segments.
+ *
+ * The line segments are represented by an array of [Coordinates](@ref geom::Coordinate).
+ * Intended to optimize the noding of contiguous segments by
+ * reducing the number of allocated objects.
+ * SegmentStrings can carry a context object, which is useful
+ * for preserving topological or parentage information.
+ * All noded substrings are initialized with the same context object.
+ *
+ */
+class GEOS_DLL NodedSegmentString : public NodableSegmentString {
+public:
+
+    // TODO: provide a templated method using an output iterator
+    template <class II>
+    static void
+    getNodedSubstrings(II from, II too_far,
+                       SegmentString::NonConstVect* resultEdgelist)
+    {
+        for(II i = from; i != too_far; ++i) {
+            NodedSegmentString* nss = dynamic_cast<NodedSegmentString*>(*i);
+            assert(nss);
+            nss->getNodeList().addSplitEdges(resultEdgelist);
+        }
+    }
+
+    template <class C>
+    static void
+    getNodedSubstrings(C* segStrings,
+                       SegmentString::NonConstVect* resultEdgelist)
+    {
+        getNodedSubstrings(segStrings->begin(), segStrings->end(), resultEdgelist);
+    }
+
+    static void getNodedSubstrings(const SegmentString::NonConstVect& segStrings,
+                                   SegmentString::NonConstVect* resultEdgeList);
+
+    /// Returns allocated object
+    static SegmentString::NonConstVect* getNodedSubstrings(
+        const SegmentString::NonConstVect& segStrings);
+
+    std::unique_ptr<geom::CoordinateSequence> getNodedCoordinates();
+
+    bool hasNodes() const
+    {
+        return nodeList.size() > 0;
+    }
+
+    /** \brief
+     * Creates a new segment string from a list of vertices.
+     *
+     * @param newPts CoordinateSequence representing the string,
+     *               ownership transferred.
+     * @param constructZ should newly-constructed coordinates store Z values?
+     * @param constructM should newly-constructed coordinates store M values?
+     * @param newContext the user-defined data of this segment string
+     *                   (may be null)
+     */
+    NodedSegmentString(geom::CoordinateSequence* newPts, bool constructZ, bool constructM, const void* newContext)
+        : NodableSegmentString(newContext, newPts)
+        , nodeList(*this, constructZ, constructM)
+    {}
+
+    NodedSegmentString(SegmentString* ss, bool constructZ, bool constructM)
+        : NodableSegmentString(ss->getData(), ss->getCoordinates()->clone().release())
+        , nodeList(*this, constructZ, constructM)
+    {}
+
+    ~NodedSegmentString() override {
+        delete seq;
+    }
+
+    SegmentNodeList& getNodeList();
+
+    const SegmentNodeList& getNodeList() const;
+
+    std::unique_ptr<geom::CoordinateSequence> releaseCoordinates();
+
+    std::ostream& print(std::ostream& os) const override;
+
+
+    /** \brief
+     * Add {@link SegmentNode}s for one or both
+     * intersections found for a segment of an edge to the edge
+     * intersection list.
+     */
+    void addIntersections(algorithm::LineIntersector* li,
+        std::size_t segmentIndex, std::size_t geomIndex)
+    {
+        for (std::size_t i = 0, n = li->getIntersectionNum(); i < n; ++i) {
+            addIntersection(li, segmentIndex, geomIndex, i);
+        }
+    };
+
+    /** \brief
+     * Add an SegmentNode for intersection intIndex.
+     *
+     * An intersection that falls exactly on a vertex
+     * of the SegmentString is normalized
+     * to use the higher of the two possible segmentIndexes
+     */
+    void addIntersection(algorithm::LineIntersector* li,
+        std::size_t segmentIndex,
+        std::size_t geomIndex, std::size_t intIndex)
+    {
+        ::geos::ignore_unused_variable_warning(geomIndex);
+
+        const auto& intPt = li->getIntersection(intIndex);
+        addIntersection(intPt, segmentIndex);
+    };
+
+    /** \brief
+     * Add an SegmentNode for intersection intIndex.
+     *
+     * An intersection that falls exactly on a vertex of the
+     * edge is normalized
+     * to use the higher of the two possible segmentIndexes
+     */
+    template<typename CoordType>
+    void addIntersection(const CoordType& intPt,
+        std::size_t segmentIndex)
+    {
+        std::size_t normalizedSegmentIndex = segmentIndex;
+
+        if (segmentIndex > size() - 2) {
+            throw util::IllegalArgumentException("SegmentString::addIntersection: SegmentIndex out of range");
+        }
+
+        // normalize the intersection point location
+        auto nextSegIndex = normalizedSegmentIndex + 1;
+        if (nextSegIndex < size()) {
+            const auto& nextPt = getCoordinate<geom::CoordinateXY>(nextSegIndex);
+
+            // Normalize segment index if intPt falls on vertex
+            // The check for point equality is 2D only -
+            // Z values are ignored
+            if(intPt.equals2D(nextPt)) {
+                normalizedSegmentIndex = nextSegIndex;
+            }
+        }
+
+        /*
+         * Add the intersection point to edge intersection list
+         * (unless the node is already known)
+         */
+        nodeList.add(intPt, normalizedSegmentIndex);
+    }
+
+private:
+
+    SegmentNodeList nodeList;
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+
+
+
+
+
+
+
+
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/Noder.h

@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <iostream>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+
+/** \brief
+ * Computes all intersections between segments in a set of SegmentString.
+ *
+ * Intersections found are represented as [SegmentNodes](@ref SegmentNode) and
+ * added to the [SegmentStrings](@ref SegmentString) in which they occur.
+ * As a final step in the noding a new set of segment strings split
+ * at the nodes may be returned.
+ *
+ * Last port: noding/Noder.java rev. 1.8 (JTS-1.7)
+ *
+ * TODO: this was really an interface, we should avoid making it a Base class
+ *
+ */
+class GEOS_DLL Noder {
+public:
+    /** \brief
+     * Computes the noding for a collection of [SegmentStrings](@ref SegmentString).
+     *
+     * Some Noders may add all these nodes to the input SegmentStrings;
+     * others may only add some or none at all.
+     *
+     * @param segStrings a collection of {@link SegmentString}s to node
+     *        The caller remains responsible for releasing the memory
+     *        associated with the container and its elements.
+     */
+    virtual void computeNodes(std::vector<SegmentString*>* segStrings) = 0;
+
+    /** \brief
+     * Returns a collection of fully noded [SegmentStrings](@ref SegmentString).
+     * The SegmentStrings have the same context as their parent.
+     *
+     * @return a newly allocated std::vector of newly allocated
+     *         SegmentStrings (copies of input, if needs be).
+     *         Caller is responsible to delete container and elements.
+     */
+    virtual std::vector<SegmentString*>* getNodedSubstrings() const = 0;
+
+    virtual
+    ~Noder() {}
+
+protected:
+    Noder() {}
+};
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/NodingIntersectionFinder.h

@@ -0,0 +1,262 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/noding/SegmentIntersector.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for composition
+#include <geos/noding/SegmentString.h>
+
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace algorithm {
+class LineIntersector;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/**
+ * \brief Finds non-noded intersections in a set of {@link SegmentString}s, if any exist.
+ *
+ * Non-noded intersections include:
+ *
+ * - intersections which lie in the interior of a segment
+ * - intersections at a vertex in the interior of a SegmentString
+ * (e.g. with a segment string endpoint or other interior vertex)
+ *
+ * @version 1.7
+ */
+class NodingIntersectionFinder: public SegmentIntersector {
+
+public:
+
+    /** \brief
+     * Creates an intersection finder which finds an interior intersection
+     * if one exists
+     *
+     * @param newLi the LineIntersector to use
+     */
+    NodingIntersectionFinder(algorithm::LineIntersector& newLi)
+        :
+        li(newLi),
+        interiorIntersection(geom::Coordinate::getNull()),
+        intersectionCount(0),
+        isCheckEndSegmentsOnly(false),
+        findAllIntersections(false)
+    {
+    }
+
+    /** \brief
+     * Tests whether an intersection was found.
+     *
+     * @return true if an intersection was found
+     */
+    bool
+    hasIntersection() const
+    {
+        return !interiorIntersection.isNull();
+    }
+
+    /** \brief
+     * Gets the computed location of the intersection.
+     * Due to round-off, the location may not be exact.
+     *
+     * @return the coordinate for the intersection location
+     */
+    const geom::Coordinate&
+    getInteriorIntersection() const
+    {
+        return interiorIntersection;
+    }
+
+    /** \brief
+    * Gets the count of intersections found.
+    *
+    * @return the intersection count
+    */
+    size_t
+    count() const
+    {
+        return intersectionCount;
+    }
+
+    /** \brief
+     * Sets whether only end segments should be tested for interior intersection.
+     *
+     * This is a performance optimization that may be used if the segments
+     * have been previously noded by an appropriate algorithm.
+     * It may be known that any potential noding failures will occur only in
+     * end segments.
+     *
+     * @param isCESO whether to test only end segments
+     */
+    void
+    setCheckEndSegmentsOnly(bool isCESO)
+    {
+        isCheckEndSegmentsOnly = isCESO;
+    }
+
+
+    /** \brief
+     * Sets whether all intersections should be computed.
+     *
+     * When this is `false` (the default value) the value of
+     * #isDone() is `true` after the first intersection is found.
+     *
+     * Default is `false`.
+     *
+     * @param fAI whether all intersections should be computed
+     */
+    void
+    setFindAllIntersections(bool fAI)
+    {
+        findAllIntersections = fAI;
+    }
+
+    /** \brief
+     * Gets the endpoints of the intersecting segments.
+     *
+     * @return an array of the segment endpoints (p00, p01, p10, p11)
+     */
+    const std::vector<geom::Coordinate>&
+    getIntersectionSegments() const
+    {
+        return intSegments;
+    }
+
+    /** \brief
+     * This method is called by clients of the SegmentIntersector class to process
+     * intersections for two segments of the [SegmentStrings](@ref SegmentString)
+     * being intersected.
+     *
+     * @note Some clients (such as `MonotoneChains`) may optimize away
+     * this call for segment pairs which they have determined do not intersect
+     * (e.g. by an disjoint envelope test).
+     */
+    void processIntersections(
+        SegmentString* e0,  std::size_t segIndex0,
+        SegmentString* e1,  std::size_t segIndex1) override;
+
+    bool
+    isDone() const override
+    {
+        return !interiorIntersection.isNull();
+    }
+
+private:
+    algorithm::LineIntersector& li;
+    geom::Coordinate interiorIntersection;
+    std::size_t intersectionCount;
+    bool isCheckEndSegmentsOnly;
+    bool findAllIntersections;
+    std::vector<geom::Coordinate> intSegments;
+
+    // Declare type as noncopyable
+    NodingIntersectionFinder(const NodingIntersectionFinder& other) = delete;
+    NodingIntersectionFinder& operator=(const NodingIntersectionFinder& rhs) = delete;
+
+    /** \brief
+     * Tests if two vertices with at least one in a segmentString interior
+     * are equal.
+     *
+     * @param p0 a segment vertex
+     * @param p1 a segment vertex
+     * @param isEnd0 true if vertex is a segmentString endpoint
+     * @param isEnd1 true if vertex is a segmentString endpoint
+     * @return true if an intersection is found
+    */
+    static bool isInteriorVertexIntersection(
+        const geom::Coordinate& p0, const geom::Coordinate& p1,
+        bool isEnd0, bool isEnd1)
+    {
+        // Intersections between endpoints are valid nodes, so not reported
+        if (isEnd0 && isEnd1) {
+            return false;
+        }
+
+        if (p0.equals2D(p1)) {
+            return true;
+        }
+
+        return false;
+    };
+
+    /** \brief
+     * Tests if an intersection occurs between a SegmentString interior vertex and another vertex.
+     *
+     * @note intersections between two endpoint vertices are valid noding,
+     * and are not flagged.
+     *
+     * @param p00 a segment vertex
+     * @param p01 a segment vertex
+     * @param p10 a segment vertex
+     * @param p11 a segment vertex
+     * @param isEnd00 true if vertex is a segmentString endpoint
+     * @param isEnd01 true if vertex is a segmentString endpoint
+     * @param isEnd10 true if vertex is a segmentString endpoint
+     * @param isEnd11 true if vertex is a segmentString endpoint
+     * @return true if an intersection is found
+     */
+    static bool isInteriorVertexIntersection(
+        const geom::Coordinate& p00, const geom::Coordinate& p01,
+        const geom::Coordinate& p10, const geom::Coordinate& p11,
+        bool isEnd00, bool isEnd01, bool isEnd10, bool isEnd11)
+    {
+        if (isInteriorVertexIntersection(p00, p10, isEnd00, isEnd10)) {
+            return true;
+        }
+        if (isInteriorVertexIntersection(p00, p11, isEnd00, isEnd11)) {
+            return true;
+        }
+        if (isInteriorVertexIntersection(p01, p10, isEnd01, isEnd10)) {
+            return true;
+        }
+        if (isInteriorVertexIntersection(p01, p11, isEnd01, isEnd11)) {
+            return true;
+        }
+        return false;
+    };
+
+    /** \brief
+     * Tests whether a segment in a SegmentString is an end segment.
+     * (either the first or last).
+     *
+     * @param segStr a segment string
+     * @param index the index of a segment in the segment string
+     * @return true if the segment is an end segment
+     */
+    static bool isEndSegment(const SegmentString* segStr, std::size_t index)
+    {
+        if (index == 0) {
+            return true;
+        }
+        if (index >= segStr->size() - 2) {
+            return true;
+        }
+        return false;
+    };
+
+};
+
+} // namespace geos.noding
+} // namespace geos
+
+

package/dist/prebuilt/Android-x86_64/include/geos/noding/NodingValidator.h

@@ -0,0 +1,109 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <iostream>
+
+#include <geos/algorithm/LineIntersector.h>
+//#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Validates that a collection of {@link SegmentString}s is correctly noded.
+ * Throws a TopologyException if a noding error is found.
+ *
+ * Last port: noding/NodingValidator.java rev. 1.6 (JTS-1.7)
+ *
+ */
+class GEOS_DLL NodingValidator {
+private:
+    algorithm::LineIntersector li;
+    const std::vector<SegmentString*>& segStrings;
+
+    /**
+     * Checks if a segment string contains a segment
+     * pattern a-b-a (which implies a self-intersection)
+     */
+    void checkCollapses() const;
+
+    void checkCollapses(const SegmentString& ss) const;
+
+    void checkCollapse(const geom::Coordinate& p0, const geom::Coordinate& p1,
+                       const geom::Coordinate& p2) const;
+
+    /**
+     * Checks all pairs of segments for intersections at an
+     * interior point of a segment
+     */
+    void checkInteriorIntersections();
+
+    void checkInteriorIntersections(const SegmentString& ss0,
+                                    const SegmentString& ss1);
+
+    void checkInteriorIntersections(
+        const SegmentString& e0, std::size_t segIndex0,
+        const SegmentString& e1, std::size_t segIndex1);
+
+    /**
+     * Checks for intersections between an endpoint of a segment string
+     * and an interior vertex of another segment string
+     */
+    void checkEndPtVertexIntersections() const;
+
+    void checkEndPtVertexIntersections(const geom::Coordinate& testPt,
+                                       const std::vector<SegmentString*>& segStrings) const;
+
+    /**
+     * @return true if there is an intersection point which is not an
+     *         endpoint of the segment p0-p1
+     */
+    bool hasInteriorIntersection(const algorithm::LineIntersector& aLi,
+                                 const geom::Coordinate& p0, const geom::Coordinate& p1) const;
+
+    // Declare type as noncopyable
+    NodingValidator(const NodingValidator& other) = delete;
+    NodingValidator& operator=(const NodingValidator& rhs) = delete;
+
+public:
+
+    NodingValidator(const std::vector<SegmentString*>& newSegStrings):
+        segStrings(newSegStrings)
+    {}
+
+    ~NodingValidator() {}
+
+    void checkValid();
+
+};
+
+
+} // namespace geos.noding
+} // namespace geos
+