@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.63

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/buffer/BufferSubgraph.h

@@ -0,0 +1,202 @@
+/**********************************************************************
+ *
+ * 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/buffer/BufferSubgraph.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/operation/buffer/RightmostEdgeFinder.h> // for composition
+
+#include <vector>
+#include <set>
+
+#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 Coordinate;
+class Envelope;
+}
+namespace algorithm {
+class CGAlgorithms;
+}
+namespace geomgraph {
+class DirectedEdge;
+class Node;
+}
+}
+
+namespace geos {
+namespace operation { // geos.operation
+namespace buffer { // geos.operation.buffer
+
+/**
+ * \brief
+ * A connected subset of the graph of DirectedEdge and geomgraph::Node.
+ *
+ * Its edges will generate either
+ * - a single polygon in the complete buffer, with zero or more holes, or
+ * -  ne or more connected holes
+ */
+class GEOS_DLL BufferSubgraph {
+private:
+    RightmostEdgeFinder finder;
+
+    std::vector<geomgraph::DirectedEdge*> dirEdgeList;
+
+    std::vector<geomgraph::Node*> nodes;
+
+    geom::Coordinate* rightMostCoord;
+
+    geom::Envelope* env;
+
+    /** \brief
+     * Adds all nodes and edges reachable from this node to the subgraph.
+     *
+     * Uses an explicit stack to avoid a large depth of recursion.
+     *
+     * @param startNode a node known to be in the subgraph
+     */
+    void addReachable(geomgraph::Node* startNode);
+
+    /// Adds the argument node and all its out edges to the subgraph
+    ///
+    /// @param node the node to add
+    /// @param nodeStack the current set of nodes being traversed
+    ///
+    void add(geomgraph::Node* node, std::vector<geomgraph::Node*>* nodeStack);
+
+    void clearVisitedEdges();
+
+    /** \brief
+     * Compute depths for all dirEdges via breadth-first traversal
+     * of nodes in graph
+     *
+     * @param startEdge edge to start processing with
+     */
+    // <FIX> MD - use iteration & queue rather than recursion, for speed and robustness
+    void computeDepths(geomgraph::DirectedEdge* startEdge);
+
+    void computeNodeDepth(geomgraph::Node* n);
+
+    void copySymDepths(geomgraph::DirectedEdge* de);
+
+    bool contains(std::set<geomgraph::Node*>& nodes, geomgraph::Node* node);
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& os, const BufferSubgraph& bs);
+
+    BufferSubgraph();
+
+    ~BufferSubgraph();
+
+    std::vector<geomgraph::DirectedEdge*>* getDirectedEdges();
+
+    std::vector<geomgraph::Node*>* getNodes();
+
+    /** \brief
+     * Gets the rightmost coordinate in the edges of the subgraph
+     */
+    geom::Coordinate* getRightmostCoordinate();
+
+    /** \brief
+     * Creates the subgraph consisting of all edges reachable from
+     * this node.
+     *
+     * Finds the edges in the graph and the rightmost coordinate.
+     *
+     * @param node a node to start the graph traversal from
+     */
+    void create(geomgraph::Node* node);
+
+    void computeDepth(int outsideDepth);
+
+    /** \brief
+     * Find all edges whose depths indicates that they are in the
+     * result area(s).
+     *
+     * Since we want polygon shells to be
+     * oriented CW, choose dirEdges with the interior of the result
+     * on the RHS.
+     * Mark them as being in the result.
+     * Interior Area edges are the result of dimensional collapses.
+     * They do not form part of the result area boundary.
+     */
+    void findResultEdges();
+
+    /** \brief
+     * BufferSubgraphs are compared on the x-value of their rightmost
+     * Coordinate.
+     *
+     * This defines a partial ordering on the graphs such that:
+     *
+     * g1 >= g2 <==> Ring(g2) does not contain Ring(g1)
+     *
+     * where Polygon(g) is the buffer polygon that is built from g.
+     *
+     * This relationship is used to sort the BufferSubgraphs so
+     * that shells are guaranteed to
+     * be built before holes.
+     */
+    int compareTo(BufferSubgraph*);
+
+    /** \brief
+     * Computes the envelope of the edges in the subgraph.
+     * The envelope is cached after being computed.
+     *
+     * @return the envelope of the graph.
+     */
+    geom::Envelope* getEnvelope();
+};
+
+std::ostream& operator<< (std::ostream& os, const BufferSubgraph& bs);
+
+// INLINES
+inline geom::Coordinate*
+BufferSubgraph::getRightmostCoordinate()
+{
+    return rightMostCoord;
+}
+
+inline std::vector<geomgraph::Node*>*
+BufferSubgraph::getNodes()
+{
+    return &nodes;
+}
+
+inline std::vector<geomgraph::DirectedEdge*>*
+BufferSubgraph::getDirectedEdges()
+{
+    return &dirEdgeList;
+}
+
+bool BufferSubgraphGT(BufferSubgraph* first, BufferSubgraph* second);
+
+} // namespace geos::operation::buffer
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/buffer/MaximalEdgeRing.h

@@ -0,0 +1,104 @@
+/**********************************************************************
+ *
+ * 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;
+}
+namespace operation {
+namespace buffer {
+class MinimalEdgeRing;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace buffer { // geos::operation::buffer
+
+/** \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::buffer
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/buffer/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 buffer { // geos::operation::buffer
+
+/** \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::buffer::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::buffer
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/buffer/OffsetCurve.h

@@ -0,0 +1,329 @@
+/**********************************************************************
+ *
+ * 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 <geos/export.h>
+
+#include <geos/operation/buffer/BufferParameters.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/constants.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class CoordinateSequence;
+class Geometry;
+class LineString;
+class Polygon;
+}
+namespace operation {
+namespace buffer {
+class OffsetCurveSection;
+class SegmentMCIndex;
+}
+}
+}
+
+namespace geos {
+namespace operation {
+namespace buffer {
+
+/**
+ * Computes an offset curve from a geometry.
+ * An offset curve is a linear geometry which is offset a given distance
+ * from the input.
+ * If the offset distance is positive the curve lies on the left side of the input;
+ * if it is negative the curve is on the right side.
+ * The curve(s) have the same direction as the input line(s).
+ *
+ * The offset curve is based on the boundary of the buffer for the geometry
+ * at the offset distance (see BufferOp).
+ * The normal mode of operation is to return the sections of the buffer boundary
+ * which lie on the raw offset curve
+ * (obtained via rawOffset(LineString, double).
+ * The offset curve will contain multiple sections
+ * if the input self-intersects or has close approaches.
+ * The computed sections are ordered along the raw offset curve.
+ * Sections are disjoint.  They never self-intersect, but may be rings.
+ *
+ *   * For a LineString the offset curve is a linear geometry
+ *     (LineString or MultiLineString).
+ *   * For a Point or MultiPoint the offset curve is an empty LineString.
+ *   * For a Polygon the offset curve is the boundary of the polygon buffer (which
+ *     may be a MultiLineString.
+ *   * For a collection the output is a MultiLineString containing
+ *     the offset curves of the elements.
+ *
+ * In "joined" mode (see setJoined(bool))
+ * the sections computed for each input line are joined into a single offset curve line.
+ * The joined curve may self-intersect.
+ * At larger offset distances the curve may contain "flat-line" artifacts
+ * in places where the input self-intersects.
+ *
+ * Offset curves support setting the number of quadrant segments,
+ * the join style, and the mitre limit (if applicable) via
+ * the BufferParameters.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL OffsetCurve {
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using Geometry = geos::geom::Geometry;
+    using GeometryFactory = geos::geom::GeometryFactory;
+    using LineString = geos::geom::LineString;
+    using Polygon = geos::geom::Polygon;
+
+private:
+
+    // Members
+    const Geometry& inputGeom;
+    double distance;
+    bool isJoined = false;
+
+    BufferParameters bufferParams;
+    double matchDistance;
+    const GeometryFactory* geomFactory;
+
+    // Methods
+
+    std::unique_ptr<Geometry> computePolygonCurve(
+        const Polygon& polyGeom, double distance);
+
+    std::unique_ptr<Geometry> computeCurve(
+        const LineString& lineGeom, double distance);
+
+    std::vector<std::unique_ptr<OffsetCurveSection>> computeSections(
+        const LineString& lineGeom, double distance);
+
+    std::unique_ptr<LineString> offsetSegment(
+        const CoordinateSequence* pts, double distance);
+
+    static std::unique_ptr<Polygon> getBufferOriented(
+        const LineString& geom, double distance,
+        BufferParameters& bufParams);
+
+    /**
+    * Extracts the largest polygon by area from a geometry.
+    * Used here to avoid issues with non-robust buffer results
+    * which have spurious extra polygons.
+    *
+    * @param geom a geometry
+    * @return the polygon element of largest area
+    */
+    static const Polygon* extractMaxAreaPolygon(const Geometry* geom);
+
+    void computeCurveSections(
+        const CoordinateSequence* bufferRingPts,
+        const CoordinateSequence& rawCurve,
+        std::vector<std::unique_ptr<OffsetCurveSection>>& sections);
+
+    /**
+    * Matches the segments in a buffer ring to the raw offset curve
+    * to obtain their match positions (if any).
+    *
+    * @param raw0 a raw curve segment start point
+    * @param raw1 a raw curve segment end point
+    * @param rawCurveIndex the index of the raw curve segment
+    * @param bufferSegIndex the spatial index of the buffer ring segments
+    * @param bufferPts the points of the buffer ring
+    * @param rawCurvePos the raw curve positions of the buffer ring segments
+    * @return the index of the minimum matched buffer segment
+    */
+    std::size_t matchSegments(
+        const Coordinate& raw0, const Coordinate& raw1,
+        std::size_t rawCurveIndex,
+        SegmentMCIndex& bufferSegIndex,
+        const CoordinateSequence* bufferPts,
+        std::vector<double>& rawCurvePos);
+
+    static double segmentMatchFrac(
+        const Coordinate& p0,   const Coordinate& p1,
+        const Coordinate& seg0, const Coordinate& seg1,
+        double matchDistance);
+
+    /**
+    * This is only called when there is at least one ring segment matched
+    * (so rawCurvePos has at least one entry != NOT_IN_CURVE).
+    * The start index of the first section must be provided.
+    * This is intended to be the section with lowest position
+    * along the raw curve.
+    * @param ringPts the points in a buffer ring
+    * @param rawCurveLoc the position of buffer ring segments along the raw curve
+    * @param startIndex the index of the start of a section
+    * @param sections the list of extracted offset curve sections
+    */
+    void extractSections(
+        const CoordinateSequence* ringPts,
+        std::vector<double>& rawCurveLoc,
+        std::size_t startIndex,
+        std::vector<std::unique_ptr<OffsetCurveSection>>& sections);
+
+    std::size_t findSectionStart(
+        const std::vector<double>& loc,
+        std::size_t end);
+
+    std::size_t findSectionEnd(
+        const std::vector<double>& loc,
+        std::size_t start,
+        std::size_t firstStartIndex);
+
+    static std::size_t nextIndex(std::size_t i, std::size_t size);
+    static std::size_t prevIndex(std::size_t i, std::size_t size);
+
+
+public:
+
+    // Constants
+    static constexpr int MATCH_DISTANCE_FACTOR = 10000;
+
+    /**
+    * A QuadSegs minimum value that will prevent generating
+    * unwanted offset curve artifacts near end caps.
+    */
+    static constexpr int MIN_QUADRANT_SEGMENTS = 8;
+
+    /**
+    * Creates a new instance for computing an offset curve for a geometry at a given distance.
+    * with default quadrant segments (BufferParameters::DEFAULT_QUADRANT_SEGMENTS)
+    * and join style (BufferParameters::JOIN_STYLE).
+    *
+    * @param geom the geometry to offset
+    * @param dist the offset distance (positive for left, negative for right)
+    *
+    * @see BufferParameters
+    */
+    OffsetCurve(const Geometry& geom, double dist)
+        : inputGeom(geom)
+        , distance(dist)
+        , matchDistance(std::abs(dist)/MATCH_DISTANCE_FACTOR)
+        , geomFactory(geom.getFactory())
+        {
+            if (!std::isfinite(dist)) {
+                throw util::IllegalArgumentException("OffsetCurve distance must be a finite value");
+            }
+        };
+
+    /**
+    * Creates a new instance for computing an offset curve for a geometry at a given distance.
+    * setting the quadrant segments and join style and mitre limit
+    * via {@link BufferParameters}.
+    *
+    * @param geom the geometry to offset
+    * @param dist the offset distance (positive for left, negative for right)
+    * @param bp the buffer parameters to use
+    */
+    OffsetCurve(const Geometry& geom, double dist, BufferParameters& bp)
+        : inputGeom(geom)
+        , distance(dist)
+        , matchDistance(std::abs(dist)/MATCH_DISTANCE_FACTOR)
+        , geomFactory(geom.getFactory())
+        {
+            if (!std::isfinite(dist)) {
+                throw util::IllegalArgumentException("OffsetCurve distance must be a finite value");
+            }
+            //-- set buffer params, leaving cap style as the default CAP_ROUND
+
+            /**
+            * Prevent using a very small QuadSegs value, to avoid
+            * offset curve artifacts near the end caps.
+            */
+            int quadSegs = bp.getQuadrantSegments();
+            if (quadSegs < MIN_QUADRANT_SEGMENTS) {
+                quadSegs = MIN_QUADRANT_SEGMENTS;
+            }
+            bufferParams.setQuadrantSegments(quadSegs);
+
+            bufferParams.setJoinStyle( bp.getJoinStyle());
+            bufferParams.setMitreLimit( bp.getMitreLimit());
+        };
+
+    /**
+    * Computes a single curve line for each input linear component,
+    * by joining curve sections in order along the raw offset curve.
+    * The default mode is to compute separate curve sections.
+    *
+    * @param pIsJoined true if joined mode should be used.
+    */
+    void setJoined(bool pIsJoined);
+
+    static std::unique_ptr<Geometry> getCurve(
+        const Geometry& geom,
+        double dist,
+        int quadSegs,
+        BufferParameters::JoinStyle joinStyle,
+        double mitreLimit);
+
+    static std::unique_ptr<Geometry> getCurve(
+        const Geometry& geom, double dist);
+
+    /**
+    * Computes the offset curve of a geometry at a given distance,
+    * joining curve sections into a single line for each input line.
+    *
+    * @param geom a geometry
+    * @param dist the offset distance (positive for left, negative for right)
+    * @return the joined offset curve
+    */
+    static std::unique_ptr<Geometry> getCurveJoined(
+        const Geometry& geom, double dist);
+
+    /**
+    * Gets the computed offset curve lines.
+    *
+    * @return the offset curve geometry
+    */
+    std::unique_ptr<Geometry> getCurve();
+
+    /**
+    * Gets the raw offset curve for a line at a given distance.
+    * The quadrant segments, join style and mitre limit can be specified
+    * via BufferParameters.
+    *
+    * The raw offset line may contain loops and other artifacts which are
+    * not present in the true offset curve.
+    *
+    * @param line the line to offset
+    * @param distance the offset distance (positive for left, negative for right)
+    * @param bufParams the buffer parameters to use
+    * @return the raw offset curve points
+    */
+    static std::unique_ptr<CoordinateSequence> rawOffsetCurve(
+        const LineString& line,
+        double distance,
+        BufferParameters& bufParams);
+
+    /**
+    * Gets the raw offset curve for a line at a given distance,
+    * with default buffer parameters.
+    *
+    * @param line the line to offset
+    * @param distance the offset distance (positive for left, negative for right)
+    * @return the raw offset curve points
+    */
+    static std::unique_ptr<CoordinateSequence> rawOffset(
+        const LineString& line,
+        double distance);
+
+};
+
+} // namespace geos::operation::buffer
+} // namespace geos::operation
+} // namespace geos
+
+
+