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

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/simplify/TaggedLineString.h

@@ -0,0 +1,144 @@
+/**********************************************************************
+ *
+ * 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 Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/TaggedLineString.java rev. 1.2 (JTS-1.7.1)
+ *
+ **********************************************************************
+ *
+ * NOTES: This class can be optimized to work with vector<Coordinate*>
+ *        rather then with CoordinateSequence. Also, LineSegment should
+ *        be replaced with a class not copying Coordinates.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+#include <memory>
+
+#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 CoordinateSequence;
+class Geometry;
+class LineString;
+class LinearRing;
+}
+namespace simplify {
+class TaggedLineSegment;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+/** \brief
+ * Contains and owns a list of TaggedLineSegments.
+ */
+class GEOS_DLL TaggedLineString {
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+
+public:
+
+    typedef std::vector<Coordinate> CoordVect;
+
+    typedef std::unique_ptr<CoordVect> CoordVectPtr;
+
+    typedef CoordinateSequence CoordSeq;
+
+    typedef std::unique_ptr<CoordinateSequence> CoordSeqPtr;
+
+    TaggedLineString(const geom::LineString* nParentLine,
+                     std::size_t minimumSize,
+                     bool bIsRing);
+
+    ~TaggedLineString();
+
+    std::size_t getMinimumSize() const;
+
+    bool isRing() const;
+
+    const geom::LineString* getParent() const;
+
+    const CoordSeq* getParentCoordinates() const;
+
+    CoordSeqPtr getResultCoordinates() const;
+
+    const Coordinate& getCoordinate(std::size_t i) const;
+
+    std::size_t size() const;
+
+    const Coordinate& getComponentPoint() const;
+
+    std::size_t getResultSize() const;
+
+    TaggedLineSegment* getSegment(std::size_t i);
+
+    const TaggedLineSegment* getSegment(std::size_t i) const;
+
+    std::vector<TaggedLineSegment*>& getSegments();
+
+    const std::vector<TaggedLineSegment*>& getSegments() const;
+
+    const std::vector<TaggedLineSegment*>& getResultSegments() const;
+
+    void addToResult(std::unique_ptr<TaggedLineSegment> seg);
+
+    const TaggedLineSegment* removeRingEndpoint();
+
+    std::unique_ptr<geom::Geometry> asLineString() const;
+
+    std::unique_ptr<geom::Geometry> asLinearRing() const;
+
+private:
+
+    const geom::LineString* parentLine;
+
+    // TaggedLineSegments owned by this object
+    std::vector<TaggedLineSegment*> segs;
+
+    // TaggedLineSegments owned by this object
+    std::vector<TaggedLineSegment*> resultSegs;
+
+    std::size_t minimumSize;
+
+    bool m_isRing;
+
+    void init();
+
+    static std::unique_ptr<CoordinateSequence> extractCoordinates(
+        const std::vector<TaggedLineSegment*>& segs);
+
+    // Copying is turned off
+    TaggedLineString(const TaggedLineString&);
+    TaggedLineString& operator= (const TaggedLineString&);
+
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/simplify/TaggedLineStringSimplifier.h

@@ -0,0 +1,176 @@
+/**********************************************************************
+ *
+ * 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 Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/TaggedLineStringSimplifier.java r536 (JTS-1.12+)
+ *
+ **********************************************************************
+ *
+ * NOTES: This class can be optimized to work with vector<Coordinate*>
+ *        rather then with CoordinateSequence
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <cstddef>
+#include <vector>
+#include <memory>
+
+#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 algorithm {
+class LineIntersector;
+}
+namespace geom {
+class CoordinateSequence;
+class Coordinate;
+class LineSegment;
+}
+namespace simplify {
+class TaggedLineSegment;
+class TaggedLineString;
+class LineSegmentIndex;
+class ComponentJumpChecker;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+
+/** \brief
+ * Simplifies a TaggedLineString, preserving topology
+ * (in the sense that no new intersections are introduced).
+ * Uses the recursive Douglas-Peucker algorithm.
+ *
+ */
+class GEOS_DLL TaggedLineStringSimplifier {
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using Coordinate = geos::geom::Coordinate;
+    using LineSegment = geos::geom::LineSegment;
+
+public:
+
+    TaggedLineStringSimplifier(LineSegmentIndex* inputIndex,
+                               LineSegmentIndex* outputIndex,
+                               const ComponentJumpChecker* jumpChecker);
+
+    /**
+     * Simplifies the given {@link TaggedLineString}
+     * using the distance tolerance specified.
+     *
+     * @param line the linestring to simplify
+     * @param distanceTolerance simplification tolerance
+     */
+    void simplify(TaggedLineString* line, double distanceTolerance);
+
+
+private:
+
+    // externally owned
+    LineSegmentIndex* inputIndex;
+
+    // externally owned
+    LineSegmentIndex* outputIndex;
+
+    const ComponentJumpChecker* jumpChecker;
+
+    std::unique_ptr<algorithm::LineIntersector> li;
+
+    /// non-const as segments are possibly added to it
+    TaggedLineString* line;
+
+    const CoordinateSequence* linePts;
+
+    void simplifySection(std::size_t i, std::size_t j, std::size_t depth, double distanceTolerance);
+
+    void simplifyRingEndpoint(double distanceTolerance);
+
+    static std::size_t findFurthestPoint(
+        const CoordinateSequence* pts,
+        std::size_t i, std::size_t j,
+        double& maxDistance);
+
+    bool isTopologyValid(
+        const TaggedLineString* lineIn,
+        std::size_t sectionStart, std::size_t sectionEnd,
+        const LineSegment& flatSeg);
+
+    bool isTopologyValid(
+        const TaggedLineString* lineIn,
+        const LineSegment* seg1, const LineSegment* seg2,
+        const LineSegment& flatSeg);
+
+    bool hasInputIntersection(const LineSegment& flatSeg);
+
+    bool hasInputIntersection(
+        const TaggedLineString* lineIn,
+        std::size_t excludeStart, std::size_t excludeEnd,
+        const LineSegment& flatSeg);
+
+    bool isCollinear(const Coordinate& pt, const LineSegment& seg) const;
+
+    bool hasOutputIntersection(const LineSegment& flatSeg);
+
+    bool hasInvalidIntersection(
+        const LineSegment& seg0,
+        const LineSegment& seg1) const;
+
+
+    std::unique_ptr<TaggedLineSegment> flatten(
+        std::size_t start, std::size_t end);
+
+    /** \brief
+     * Tests whether a segment is in a section of a TaggedLineString.
+     * Sections may wrap around the endpoint of the line, 
+     * to support ring endpoint simplification.
+     * This is indicated by excludedStart > excludedEnd
+     *
+     * @param line line to be checked for the presence of `seg`
+     * @param excludeStart  the index of the first segment in the excluded section  
+     * @param excludeEnd the index of the last segment in the excluded section
+     * @param seg segment to look for in `line`
+     * @return true if the test segment intersects some segment in the line not in the excluded section
+     */
+    static bool isInLineSection(
+        const TaggedLineString* line,
+        const std::size_t excludeStart, const std::size_t excludeEnd,
+        const TaggedLineSegment* seg);
+
+    /** \brief
+     * Remove the segs in the section of the line
+     *
+     * @param line
+     * @param start
+     * @param end
+     */
+    void remove(const TaggedLineString* line,
+                std::size_t start,
+                std::size_t end);
+
+};
+
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/simplify/TaggedLinesSimplifier.h

@@ -0,0 +1,88 @@
+/**********************************************************************
+ *
+ * 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 Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/TaggedLinesSimplifier.java rev. 1.4 (JTS-1.7.1)
+ *
+ **********************************************************************
+ *
+ * NOTES: changed from JTS design adding a private
+ *        TaggedLineStringSimplifier member and making
+ *        simplify(collection) method become a templated
+ *        function.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <vector>
+#include <memory>
+#include <cassert>
+
+#include <geos/simplify/LineSegmentIndex.h> // for templated function body
+#include <geos/simplify/TaggedLineStringSimplifier.h>
+
+#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 simplify {
+class TaggedLineString;
+}
+}
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+/** \brief
+ * Simplifies a collection of TaggedLineStrings, preserving topology
+ * (in the sense that no new intersections are introduced).
+ */
+class GEOS_DLL TaggedLinesSimplifier {
+
+public:
+
+    TaggedLinesSimplifier();
+
+    /** \brief
+     * Sets the distance tolerance for the simplification.
+     *
+     * All vertices in the simplified geometry will be within this
+     * distance of the original geometry.
+     *
+     * @param tolerance the approximation tolerance to use
+     */
+    void setDistanceTolerance(double tolerance);
+
+    void simplify(std::vector<TaggedLineString*>& tlsVector);
+
+private:
+
+    std::unique_ptr<LineSegmentIndex> inputIndex;
+
+    std::unique_ptr<LineSegmentIndex> outputIndex;
+
+    double distanceTolerance;
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/simplify/TopologyPreservingSimplifier.h

@@ -0,0 +1,93 @@
+/**********************************************************************
+ *
+ * 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 Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: simplify/TopologyPreservingSimplifier.java r536 (JTS-1.12+)
+ *
+ **********************************************************************
+ *
+ * NOTES:
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Geometry.h>
+#include <geos/simplify/TaggedLinesSimplifier.h>
+#include <memory> // for unique_ptr
+#include <map>
+
+#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
+
+namespace geos {
+namespace simplify { // geos::simplify
+
+/** \brief
+ * Simplifies a geometry, ensuring that
+ * the result is a valid geometry having the
+ * same dimension and number of components as the input.
+ *
+ * The simplification uses a maximum distance difference algorithm
+ * similar to the one used in the Douglas-Peucker algorithm.
+ *
+ * In particular, if the input is an areal geometry
+ * ( Polygon or MultiPolygon )
+ *
+ *  -  The result has the same number of shells and holes (rings) as the input,
+ *     in the same order
+ *  -  The result rings touch at <b>no more</b> than the number of touching point in the input
+ *     (although they may touch at fewer points)
+ *
+ */
+class GEOS_DLL TopologyPreservingSimplifier {
+
+public:
+
+    static std::unique_ptr<geom::Geometry> simplify(
+        const geom::Geometry* geom,
+        double tolerance);
+
+    TopologyPreservingSimplifier(const geom::Geometry* geom);
+
+    /** \brief
+     * Sets the distance tolerance for the simplification.
+     *
+     * All vertices in the simplified geometry will be within this
+     * distance of the original geometry.
+     * The tolerance value must be non-negative.  A tolerance value
+     * of zero is effectively a no-op.
+     *
+     * @param tolerance the approximation tolerance to use
+     */
+    void setDistanceTolerance(double tolerance);
+
+    std::unique_ptr<geom::Geometry> getResultGeometry();
+
+private:
+
+    const geom::Geometry* inputGeom;
+
+    std::unique_ptr<TaggedLinesSimplifier> lineSimplifier;
+
+};
+
+} // namespace geos::simplify
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/triangulate/DelaunayTriangulationBuilder.h

@@ -0,0 +1,166 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012 Excensus LLC.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: triangulate/DelaunayTriangulationBuilder.java r524
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/triangulate/IncrementalDelaunayTriangulator.h>
+#include <geos/geom/CoordinateSequence.h>
+
+#include <memory>
+
+namespace geos {
+namespace geom {
+class Geometry;
+class MultiLineString;
+class GeometryCollection;
+class GeometryFactory;
+class Envelope;
+}
+namespace triangulate {
+namespace quadedge {
+class QuadEdgeSubdivision;
+}
+}
+}
+
+namespace geos {
+namespace triangulate { //geos.triangulate
+
+
+/** \brief
+ * A utility class which creates Delaunay Triangulations
+ * from collections of points and extract the resulting
+ * triangulation edges or triangles as geometries.
+ *
+ * @author JTS: Martin Davis
+ * @author Benjamin Campbell
+ *
+ */
+class GEOS_DLL DelaunayTriangulationBuilder {
+public:
+    /**
+     * Extracts the unique {@link geom::Coordinate}s from the given
+     * {@link geom::Geometry}.
+     *
+     * @param geom the geometry to extract from
+     * @return a List of the unique Coordinates. Caller takes ownership of the returned object.
+     */
+    static std::unique_ptr<geom::CoordinateSequence> extractUniqueCoordinates(const geom::Geometry& geom);
+
+    /**
+     * Converts all {@link geom::Coordinate}s in a collection to
+     * {@link quadedge::Vertex}es.
+     *
+     * @param coords the coordinates to convert
+     * @return a List of Vertex objects.
+     */
+    static IncrementalDelaunayTriangulator::VertexList toVertices(const geom::CoordinateSequence& coords);
+
+    /**
+     * Returns a CoordinateSequence containing only the unique coordinates of its input.
+     * @param seq a coordinateSequence
+     * @return a sorted CoordinateSequence with the unique points of seq.
+     */
+    static std::unique_ptr<geom::CoordinateSequence> unique(const geom::CoordinateSequence* seq);
+
+private:
+    std::unique_ptr<geom::CoordinateSequence> siteCoords;
+    double tolerance;
+    std::unique_ptr<quadedge::QuadEdgeSubdivision> subdiv;
+
+public:
+    /**
+     * Creates a new triangulation builder.
+     *
+     */
+    DelaunayTriangulationBuilder();
+
+    ~DelaunayTriangulationBuilder() = default;
+
+    /**
+     * Sets the sites (vertices) which will be triangulated.
+     * All vertices of the given geometry will be used as sites.
+     *
+     * @param geom the geometry from which the sites will be extracted.
+     */
+    void setSites(const geom::Geometry& geom);
+
+    /**
+     * Sets the sites (vertices) which will be triangulated
+     * from a collection of {@link geom::Coordinate}s.
+     *
+     * @param coords a CoordinateSequence.
+     */
+    void setSites(const geom::CoordinateSequence& coords);
+
+    /**
+     * Sets the snapping tolerance which will be used
+     * to improved the robustness of the triangulation computation.
+     * A tolerance of 0.0 specifies that no snapping will take place.
+     *
+     * @param p_tolerance the tolerance distance to use
+     */
+    inline void
+    setTolerance(double p_tolerance)
+    {
+        this->tolerance = p_tolerance;
+    }
+
+private:
+    void create();
+
+public:
+    /**
+     * Gets the {@link quadedge::QuadEdgeSubdivision} which models the computed triangulation.
+     *
+     * @return the subdivision containing the triangulation
+     */
+    quadedge::QuadEdgeSubdivision& getSubdivision();
+
+    /**
+     * Gets the edges of the computed triangulation as a {@link geom::MultiLineString}.
+     *
+     * @param geomFact the geometry factory to use to create the output
+     * @return the edges of the triangulation. The caller takes ownership of the returned object.
+     */
+    std::unique_ptr<geom::MultiLineString> getEdges(const geom::GeometryFactory& geomFact);
+
+    /**
+     * Gets the faces of the computed triangulation as a {@link geom::GeometryCollection}
+     * of {@link geom::Polygon}.
+     *
+     * @param geomFact the geometry factory to use to create the output
+     * @return the faces of the triangulation. The caller takes ownership of the returned object.
+     */
+    std::unique_ptr<geom::GeometryCollection> getTriangles(const geom::GeometryFactory& geomFact);
+
+    /**
+     * Computes the {@link geom::Envelope} of a collection of
+     * {@link geom::Coordinate}s.
+     *
+     * @param coords a List of Coordinates
+     * @return the envelope of the set of coordinates
+     */
+
+    static geom::Envelope envelope(const geom::CoordinateSequence& coords);
+
+};
+
+} //namespace geos.triangulate
+} //namespace goes
+