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

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/overlayng/InputGeometry.h

@@ -0,0 +1,107 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/algorithm/locate/IndexedPointInAreaLocator.h>
+#include <geos/algorithm/locate/PointOnGeometryLocator.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Location.h>
+#include <geos/export.h>
+
+#include <array>
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+
+/**
+ * Manages the input geometries for an overlay operation.
+ * The second geometry is allowed to be null,
+ * to support for instance precision reduction.
+ *
+ * @author Martin Davis
+ *
+ */
+
+class GEOS_DLL InputGeometry {
+    using Geometry = geos::geom::Geometry;
+    using Envelope = geos::geom::Envelope;
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using Location = geos::geom::Location;
+    using PointOnGeometryLocator = geos::algorithm::locate::PointOnGeometryLocator;
+
+private:
+
+    // Members
+    std::array<const Geometry*, 2> geom;
+    std::unique_ptr<PointOnGeometryLocator> ptLocatorA;
+    std::unique_ptr<PointOnGeometryLocator> ptLocatorB;
+    std::array<bool, 2> isCollapsed;
+
+
+
+public:
+
+    InputGeometry(const Geometry* geomA, const Geometry* geomB);
+
+    bool isSingle() const;
+    int getDimension(uint8_t index) const;
+    uint8_t getCoordinateDimension(uint8_t index) const;
+    const Geometry* getGeometry(uint8_t geomIndex) const;
+    const Envelope* getEnvelope(uint8_t geomIndex) const;
+    bool isEmpty(uint8_t geomIndex) const;
+    bool isArea(uint8_t geomIndex) const;
+    int getAreaIndex() const;
+    bool isLine(uint8_t geomIndex) const;
+    bool isAllPoints() const;
+    bool hasPoints() const;
+
+    /**
+    * Tests if an input geometry has edges.
+    * This indicates that topology needs to be computed for them.
+    *
+    * @param geomIndex
+    * @return true if the input geometry has edges
+    */
+    bool hasEdges(uint8_t geomIndex) const;
+
+    /**
+    * Determines the location within an area geometry.
+    * This allows disconnected edges to be fully
+    * located.
+    *
+    * @param geomIndex the index of the geometry
+    * @param pt the coordinate to locate
+    * @return the location of the coordinate
+    *
+    * @see Location
+    */
+    Location locatePointInArea(uint8_t geomIndex, const CoordinateXY& pt);
+
+    PointOnGeometryLocator* getLocator(uint8_t geomIndex);
+    void setCollapsed(uint8_t geomIndex, bool isGeomCollapsed);
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/overlayng/IntersectionPointBuilder.h

@@ -0,0 +1,113 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/geom/Point.h>
+#include <geos/operation/overlayng/OverlayNG.h>
+
+#include <geos/export.h>
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+}
+namespace operation {
+namespace overlayng {
+class OverlayEdge;
+class OverlayGraph;
+class OverlayLabel;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Extracts Point resultants from an overlay graph
+ * created by an Intersection operation
+ * between non-Point inputs.
+ * Points may be created during intersection
+ * if lines or areas touch one another at single points.
+ * Intersection is the only overlay operation which can
+ * result in Points from non-Point inputs.
+ * <p>
+ * Overlay operations where one or more inputs
+ * are Points are handled via a different code path.
+ *
+ *
+ * @author Martin Davis
+ *
+ * @see OverlayPoints
+ *
+ */
+class GEOS_DLL IntersectionPointBuilder {
+
+private:
+
+    // Members
+    OverlayGraph* graph;
+    const geom::GeometryFactory* geometryFactory;
+    std::vector<std::unique_ptr<geom::Point>> points;
+    /**
+    * Controls whether lines created by area topology collapses
+    * to participate in the result computation.
+    * True provides the original JTS semantics.
+    */
+    bool isAllowCollapseLines;
+
+    // Methods
+    void addResultPoints();
+
+    /**
+    * Tests if a node is a result point.
+    * This is the case if the node is incident on edges from both
+    * inputs, and none of the edges are themselves in the result.
+    */
+    bool isResultPoint(OverlayEdge* nodeEdge) const;
+    bool isEdgeOf(const OverlayLabel* label, uint8_t i) const;
+
+
+public:
+
+
+    IntersectionPointBuilder(OverlayGraph* p_graph, const geom::GeometryFactory* geomFact)
+        : graph(p_graph)
+        , geometryFactory(geomFact)
+        , isAllowCollapseLines(!OverlayNG::STRICT_MODE_DEFAULT)
+        {}
+
+    std::vector<std::unique_ptr<geom::Point>> getPoints();
+
+    IntersectionPointBuilder(const IntersectionPointBuilder&) = delete;
+    IntersectionPointBuilder& operator=(const IntersectionPointBuilder&) = delete;
+
+    void setStrictMode(bool p_isStrictMode)
+    {
+        isAllowCollapseLines = ! p_isStrictMode;
+    }
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/overlayng/LineBuilder.h

@@ -0,0 +1,189 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/overlayng/InputGeometry.h>
+#include <geos/operation/overlayng/OverlayNG.h>
+#include <geos/geom/Location.h>
+#include <geos/geom/LineString.h>
+
+#include <vector>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class LineString;
+}
+namespace operation {
+namespace overlayng {
+class OverlayEdge;
+class OverlayGraph;
+class OverlayLabel;
+class InputGeometry;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Finds and builds overlay result lines from the overlay graph.
+ * Output linework has the following semantics:
+ *
+ *  - Linework is fully noded
+ *  - Lines are as long as possible between nodes
+ *
+ * Various strategies are possible for how to
+ * merge graph edges into lines.
+ * This implementation uses the approach
+ * of having output lines run contiguously from node to node.
+ * For rings a node point is chosen arbitrarily.
+ *
+ * Another possible strategy would be to preserve input linework
+ * as far as possible (i.e. any sections of input lines which are not
+ * coincident with other linework would be preserved).
+ *
+ * It would also be possible to output LinearRings,
+ * if the input is a LinearRing and is unchanged.
+ * This will require additional info from the input linework.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL LineBuilder {
+
+private:
+
+    // Members
+    OverlayGraph* graph;
+    int opCode;
+    const geom::GeometryFactory* geometryFactory;
+    bool hasResultArea;
+    int8_t inputAreaIndex;
+    std::vector<std::unique_ptr<geom::Curve>> lines;
+
+    /**
+    * Indicates whether intersections are allowed to produce
+    * heterogeneous results including proper boundary touches.
+    * This does not control inclusion of touches along collapses.
+    * True provides the original JTS semantics.
+    */
+    bool isAllowMixedResult = ! OverlayNG::STRICT_MODE_DEFAULT;
+
+    /**
+    * Allow lines created by area topology collapses
+    * to appear in the result.
+    * True provides the original JTS semantics.
+    */
+    bool isAllowCollapseLines = ! OverlayNG::STRICT_MODE_DEFAULT;
+
+    void markResultLines();
+
+    /**
+    * Checks if the topology indicated by an edge label
+    * determines that this edge should be part of a result line.
+    *
+    * Note that the logic here relies on the semantic
+    * that for intersection lines are only returned if
+    * there is no result area components.
+    */
+    bool isResultLine(const OverlayLabel* lbl) const;
+
+    /**
+    * Determines the effective location for a line,
+    * for the purpose of overlay operation evaluation.
+    * Line edges and Collapses are reported as INTERIOR
+    * so they may be included in the result
+    * if warranted by the effect of the operation
+    * on the two edges.
+    * (For instance, the intersection of line edge and a collapsed boundary
+    * is included in the result).
+    */
+    static geom::Location effectiveLocation(const OverlayLabel* lbl, uint8_t geomIndex);
+
+    void addResultLines();
+    void addResultLinesMerged();
+
+    std::unique_ptr<geom::Curve> toLine(OverlayEdge* edge) const;
+
+    void addResultLinesForNodes();
+
+    /**
+    * Adds lines which form rings (i.e. have only degree-2 vertices).
+    */
+    void addResultLinesRings();
+
+    /**
+    * Traverses edges from edgeStart which
+    * lie in a single line (have degree = 2).
+    *
+    * The direction of the linework is preserved as far as possible.
+    * Specifically, the direction of the line is determined
+    * by the start edge direction. This implies
+    * that if all edges are reversed, the created line
+    * will be reversed to match.
+    * (Other more complex strategies would be possible.
+    * E.g. using the direction of the majority of segments,
+    * or preferring the direction of the A edges.)
+    */
+    std::unique_ptr<geom::Curve> buildLine(OverlayEdge* node) const;
+
+    /*
+    * Finds the next edge around a node which forms
+    * part of a result line.
+    */
+    static OverlayEdge* nextLineEdgeUnvisited(OverlayEdge* node) ;
+
+    /**
+    * Computes the degree of the line edges incident on a node
+    */
+    static int degreeOfLines(OverlayEdge* node) ;
+
+
+
+public:
+
+    LineBuilder(const InputGeometry* inputGeom, OverlayGraph* p_graph, bool p_hasResultArea, int p_opCode, const geom::GeometryFactory* geomFact)
+        : graph(p_graph)
+        , opCode(p_opCode)
+        , geometryFactory(geomFact)
+        , hasResultArea(p_hasResultArea)
+        , inputAreaIndex((int8_t)inputGeom->getAreaIndex())
+        , isAllowMixedResult(! OverlayNG::STRICT_MODE_DEFAULT)
+        , isAllowCollapseLines(! OverlayNG::STRICT_MODE_DEFAULT)
+        {}
+
+    LineBuilder(const LineBuilder&) = delete;
+    LineBuilder& operator=(const LineBuilder&) = delete;
+
+    std::vector<std::unique_ptr<geom::Curve>> getLines();
+
+    void setStrictMode(bool p_isStrictResultMode)
+    {
+        isAllowCollapseLines = ! p_isStrictResultMode;
+        isAllowMixedResult = ! p_isStrictResultMode;
+    }
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/overlayng/LineLimiter.h

@@ -0,0 +1,100 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/geom/CoordinateSequence.h>
+
+#include <geos/export.h>
+#include <array>
+#include <memory>
+#include <vector>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Envelope;
+class Coordinate;
+class CoordinateSequence;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Limits the segments in a list of segments
+ * to those which intersect an envelope.
+ * This creates zero or more sections of the input segment sequences,
+ * containing only line segments which intersect the limit envelope.
+ * Segments are not clipped, since that can move
+ * line segments enough to alter topology,
+ * and it happens in the overlay in any case.
+ * This can substantially reduce the number of vertices which need to be
+ * processed during overlay.
+ *
+ * This optimization is only applicable to Line geometries,
+ * since it does not maintain the closed topology of rings.
+ * Polygonal geometries are optimized using the {@link RingClipper}.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL LineLimiter {
+    using Envelope = geos::geom::Envelope;
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateXY = geos::geom::CoordinateXY;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+
+private:
+
+    // Members
+    const Envelope* limitEnv;
+    std::unique_ptr<geom::CoordinateSequence> ptList;
+    const CoordinateXY* lastOutside;
+    std::vector<std::unique_ptr<CoordinateSequence>> sections;
+    bool hasZ{false};
+    bool hasM{false};
+
+    // Methods
+    template<typename CoordType>
+    void addPoint(const CoordType& p);
+
+    template<typename CoordType>
+    void addOutside(const CoordType& p);
+    bool isLastSegmentIntersecting(const CoordinateXY& p) const;
+    bool isSectionOpen() const;
+
+    template<typename CoordType>
+    void startSection();
+    void finishSection();
+
+
+public:
+
+    LineLimiter(const Envelope* env)
+        : limitEnv(env)
+        , ptList(nullptr)
+        , lastOutside(nullptr)
+        {};
+
+    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const CoordinateSequence *pts);
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/operation/overlayng/MaximalEdgeRing.h

@@ -0,0 +1,133 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/operation/overlayng/OverlayEdgeRing.h>
+
+#include <vector>
+#include <memory>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class GeometryFactory;
+}
+namespace operation {
+namespace overlayng {
+class OverlayEdge;
+class EdgeRing;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+class GEOS_DLL MaximalEdgeRing {
+    using Coordinate = geos::geom::Coordinate;
+    using GeometryFactory = geos::geom::GeometryFactory;
+
+private:
+
+    // Constants
+    static constexpr int STATE_FIND_INCOMING = 1;
+    static constexpr int STATE_LINK_OUTGOING = 2;
+
+    // Members
+    OverlayEdge* startEdge;
+
+    // Methods
+    void attachEdges(OverlayEdge* startEdge);
+    void linkMinimalRings();
+
+    /**
+    * Links the edges of a {@link MaximalEdgeRing} around this node
+    * into minimal edge rings ({@link OverlayEdgeRing}s).
+    * Minimal ring edges are linked in the opposite orientation (CW)
+    * to the maximal ring.
+    * This changes self-touching rings into a two or more separate rings,
+    * as per the OGC SFS polygon topology semantics.
+    * This relinking must be done to each max ring separately,
+    * rather than all the node result edges, since there may be
+    * more than one max ring incident at the node.
+    *
+    * @param nodeEdge an edge originating at this node
+    * @param maxRing the maximal ring to link
+    */
+    static void linkMinRingEdgesAtNode(OverlayEdge* nodeEdge, MaximalEdgeRing* maxRing);
+
+    /**
+    * Tests if an edge of the maximal edge ring is already linked into
+    * a minimal {@link OverlayEdgeRing}.  If so, this node has already been processed
+    * earlier in the maximal edgering linking scan.
+    *
+    * @param edge an edge of a maximal edgering
+    * @param maxRing the maximal edgering
+    * @return true if the edge has already been linked into a minimal edgering.
+    */
+    static bool isAlreadyLinked(OverlayEdge* edge, MaximalEdgeRing* maxRing);
+
+    static OverlayEdge* selectMaxOutEdge(OverlayEdge* currOut, MaximalEdgeRing* maxEdgeRing);
+    static OverlayEdge* linkMaxInEdge(OverlayEdge* currOut, OverlayEdge* currMaxRingOut, MaximalEdgeRing* maxEdgeRing);
+
+
+public:
+
+    MaximalEdgeRing(OverlayEdge* e)
+        : startEdge(e)
+    {
+        attachEdges(e);
+    };
+
+    std::vector<std::unique_ptr<OverlayEdgeRing>> buildMinimalRings(const GeometryFactory* geometryFactory);
+
+    /**
+    * Traverses the star of edges originating at a node
+    * and links consecutive result edges together
+    * into maximal edge rings.
+    * To link two edges the resultNextMax< pointer
+    * for an incoming< result edge
+    * is set to the next outgoing result edge.
+    *
+    * Edges are linked when:
+    * - they belong to an area (i.e. they have sides)
+    * - they are marked as being in the result
+    *
+    * Edges are linked in CCW order
+    * (which is the order they are linked in the underlying graph).
+    * This means that rings have their face on the Right
+    * (in other words,
+    * the topological location of the face is given by the RHS label of the DirectedEdge).
+    * This produces rings with CW orientation.
+    *
+    * PRECONDITIONS:
+    * - This edge is in the result
+    * - This edge is not yet linked
+    * - The edge and its sym are NOT both marked as being in the result
+    */
+    static void linkResultAreaMaxRingAtNode(OverlayEdge* nodeEdge);
+
+    friend std::ostream& operator<<(std::ostream& os, const MaximalEdgeRing& mer);
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+