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

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

@@ -0,0 +1,106 @@
+/**********************************************************************
+ *
+ * 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/IncrementalDelaunayTriangulator.java r524
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <list>
+
+#include <geos/triangulate/quadedge/Vertex.h>
+
+
+namespace geos {
+namespace triangulate { //geos.triangulate
+
+namespace quadedge {
+class QuadEdge;
+class QuadEdgeSubdivision;
+}
+
+/** \brief
+ * Computes a Delauanay Triangulation of a set of {@link quadedge::Vertex}es,
+ * using an incrementatal insertion algorithm.
+ *
+ * @author JTS: Martin Davis
+ * @author Benjamin Campbell
+ */
+class GEOS_DLL IncrementalDelaunayTriangulator {
+private:
+    quadedge::QuadEdgeSubdivision* subdiv;
+    bool isUsingTolerance;
+    bool m_isForceConvex;
+
+public:
+    /**
+     * Creates a new triangulator using the given {@link quadedge::QuadEdgeSubdivision}.
+     * The triangulator uses the tolerance of the supplied subdivision.
+     *
+     * @param subdiv
+     *          a subdivision in which to build the TIN
+     */
+    IncrementalDelaunayTriangulator(quadedge::QuadEdgeSubdivision* subdiv);
+
+    typedef std::vector<quadedge::Vertex> VertexList;
+
+    /**
+     * Sets whether the triangulation is forced to have a convex boundary. Because
+     * of the use of a finite-size frame, this condition requires special logic to
+     * enforce. The default is true, since this is a requirement for some uses of
+     * Delaunay Triangulations (such as Concave Hull generation). However, forcing
+     * the triangulation boundary to be convex may cause the overall frame
+     * triangulation to be non-Delaunay. This can cause a problem for Voronoi
+     * generation, so the logic can be disabled via this method.
+     * 
+     * @param isForceConvex true if the triangulation boundary is forced to be convex
+     */
+    void forceConvex(bool isForceConvex);
+
+    /**
+     * Inserts all sites in a collection. The inserted vertices <b>MUST</b> be
+     * unique up to the provided tolerance value. (i.e. no two vertices should be
+     * closer than the provided tolerance value). They do not have to be rounded
+     * to the tolerance grid, however.
+     *
+     * @param vertices a Collection of Vertex
+     *
+     * @throws LocateFailureException if the location algorithm
+     *         fails to converge in a reasonable number of iterations
+     */
+    void insertSites(const VertexList& vertices);
+
+    /**
+     * Inserts a new point into a subdivision representing a Delaunay
+     * triangulation, and fixes the affected edges so that the result
+     * is still a Delaunay triangulation.
+     * <p>
+     *
+     * @return a quadedge containing the inserted vertex
+     */
+    quadedge::QuadEdge& insertSite(const quadedge::Vertex& v);
+
+private:
+
+    bool isConcaveBoundary(const quadedge::QuadEdge& e) const;
+
+    bool isConcaveAtOrigin(const quadedge::QuadEdge& e) const;
+
+    bool isBetweenFrameAndInserted(const quadedge::QuadEdge& e, const quadedge::Vertex& vInsert) const;
+};
+
+} //namespace geos.triangulate
+} //namespace goes
+

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

@@ -0,0 +1,157 @@
+/**********************************************************************
+ *
+ * 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/VoronoiDiagramBuilder.java r524
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/triangulate/quadedge/QuadEdgeSubdivision.h>
+#include <geos/geom/Envelope.h> // for composition
+#include <memory>
+#include <iostream>
+#include <unordered_map>
+
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+class GeometryCollection;
+class GeometryFactory;
+}
+namespace triangulate { //geos.triangulate
+
+/** \brief
+ * A utility class which creates Voronoi Diagrams from collections of points.
+ *
+ * The diagram is returned as a geom::GeometryCollection of {@link geom::Polygon}s,
+ * clipped to the larger of a supplied envelope or to an envelope determined
+ * by the input sites.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL VoronoiDiagramBuilder {
+public:
+    /** \brief
+     * Creates a new Voronoi diagram builder.
+     *
+     */
+    VoronoiDiagramBuilder();
+
+    ~VoronoiDiagramBuilder() = default;
+
+    /** \brief
+     * Sets the sites (point or vertices) which will be diagrammed.
+     * 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);
+
+    /** \brief
+     * Sets the sites (point or vertices) which will be diagrammed
+     * from a collection of {@link geom::Coordinate}s.
+     *
+     * @param coords a collection of Coordinates.
+     */
+    void setSites(const geom::CoordinateSequence& coords);
+
+    /** \brief
+     * Specify whether the geometries in the generated diagram should
+     * reflect the order of coordinates in the input. If the generated
+     * diagram cannot be consistent with the input coordinate order
+     * (e.g., for repeated input points that become a single cell) an
+     * exception will be thrown.
+     *
+     * @param isOrdered should the geometries reflect the input order?
+     */
+    void setOrdered(bool isOrdered);
+
+    /** \brief
+     * Sets the envelope to clip the diagram to.
+     *
+     * The diagram will be clipped to the larger
+     * of this envelope or an envelope surrounding the sites.
+     *
+     * @param clipEnv the clip envelope; must be kept alive by
+     *                caller until done with this instance;
+     *                set to 0 for no clipping.
+     */
+    void setClipEnvelope(const geom::Envelope* clipEnv);
+
+    /** \brief
+     * 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 tolerance the tolerance distance to use
+     */
+    void setTolerance(double tolerance);
+
+    /** \brief
+     * Gets the quadedge::QuadEdgeSubdivision which models the computed diagram.
+     *
+     * @return the subdivision containing the triangulation
+     */
+    std::unique_ptr<quadedge::QuadEdgeSubdivision> getSubdivision();
+
+    /** \brief
+     * Gets the faces of the computed diagram as a {@link geom::GeometryCollection}
+     * of {@link geom::Polygon}s, clipped as specified.
+     *
+     * @param geomFact the geometry factory to use to create the output
+     * @return the faces of the diagram
+     */
+    std::unique_ptr<geom::GeometryCollection> getDiagram(const geom::GeometryFactory& geomFact);
+
+    /** \brief
+     * Gets the edges of the computed diagram as a {@link geom::MultiLineString},
+     * clipped as specified.
+     *
+     * @param geomFact the geometry factory to use to create the output
+     * @return the edges of the diagram
+     */
+    std::unique_ptr<geom::MultiLineString> getDiagramEdges(const geom::GeometryFactory& geomFact);
+
+    void reorderCellsToInput(std::vector<std::unique_ptr<geom::Geometry>> & polys) const;
+
+private:
+    using CoordinateCellMap = std::unordered_map<geom::CoordinateXY, std::unique_ptr<geom::Geometry>, geom::Coordinate::HashCode>;
+
+    std::unique_ptr<geom::CoordinateSequence> siteCoords;
+    double tolerance;
+    std::unique_ptr<quadedge::QuadEdgeSubdivision> subdiv;
+    const geom::Envelope* clipEnv; // externally owned
+    const geom::Geometry* inputGeom;
+    const geom::CoordinateSequence* inputSeq;
+    geom::Envelope diagramEnv;
+    bool isOrdered;
+
+    void create();
+
+    std::size_t getNumInputPoints() const;
+
+    static std::unique_ptr<geom::GeometryCollection>
+    clipGeometryCollection(std::vector<std::unique_ptr<geom::Geometry>> & geoms, const geom::Envelope& clipEnv);
+
+
+    static void addCellsForCoordinates(CoordinateCellMap& cellMap, const geom::Geometry& g, std::vector<std::unique_ptr<geom::Geometry>> & polys);
+    static void addCellsForCoordinates(CoordinateCellMap& cellMap, const geom::CoordinateSequence& g, std::vector<std::unique_ptr<geom::Geometry>> & polys);
+};
+
+} //namespace geos.triangulate
+} //namespace geos

package/dist/prebuilt/linuxmusl-arm64-mt-release/include/geos/triangulate/polygon/ConstrainedDelaunayTriangulator.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/triangulate/tri/TriList.h>
+#include <geos/triangulate/tri/Tri.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+/**
+ * Computes the Constrained Delaunay Triangulation of polygons.
+ * The Constrained Delaunay Triangulation of a polygon is a set of triangles
+ * covering the polygon, with the maximum total interior angle over all
+ * possible triangulations.  It provides the "best quality" triangulation
+ * of the polygon.
+ * <p>
+ * Holes are supported.
+ */
+class GEOS_DLL ConstrainedDelaunayTriangulator {
+    using Geometry = geos::geom::Geometry;
+    using GeometryFactory = geos::geom::GeometryFactory;
+    using Polygon = geos::geom::Polygon;
+    template<typename TriType>
+    using TriList = geos::triangulate::tri::TriList<TriType>;
+    using Tri = geos::triangulate::tri::Tri;
+
+private:
+
+    // Members
+    const Geometry* inputGeom;
+    const GeometryFactory* geomFact;
+
+    std::unique_ptr<Geometry> compute() const;
+
+    static std::unique_ptr<Geometry> toGeometry(
+        const geom::GeometryFactory* geomFact,
+        const std::vector<std::unique_ptr<TriList<Tri>>>& allTriLists);
+
+
+public:
+
+    /**
+    * Constructs a new triangulator.
+    *
+    * @param p_inputGeom the input geometry
+    */
+    ConstrainedDelaunayTriangulator(const Geometry* p_inputGeom)
+        : inputGeom(p_inputGeom)
+        , geomFact(p_inputGeom->getFactory())
+    {}
+
+    /**
+    * Computes the Constrained Delaunay Triangulation of each polygon element in a geometry.
+    *
+    * @param geom the input geometry
+    * @return a GeometryCollection of the computed triangle polygons
+    */
+    static std::unique_ptr<Geometry> triangulate(const Geometry* geom);
+
+    /**
+    * Computes the triangulation of a single polygon
+    * and returns it as a list of {@link geos::triangulate::tri::Tri}s.
+    *
+    * @param poly the input polygon
+    * @param triList the list to store the triangulation in
+    */
+    static void triangulatePolygon(const Polygon* poly, TriList<Tri>& triList);
+
+};
+
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos
+

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

@@ -0,0 +1,219 @@
+/**********************************************************************
+ *
+ * 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/index/VertexSequencePackedRtree.h>
+#include <geos/triangulate/tri/TriList.h>
+#include <geos/triangulate/tri/Tri.h>
+#include <geos/constants.h>
+
+#include <array>
+#include <memory>
+#include <limits>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+class Polygon;
+class Envelope;
+}
+}
+
+namespace geos {
+namespace triangulate {
+namespace polygon {
+
+
+/**
+ * Triangulates a polygon using the Ear-Clipping technique.
+ * The polygon is provided as a closed list of contiguous vertices
+ * defining its boundary.
+ * The vertices must have clockwise orientation.
+ *
+ * The polygon boundary must not self-cross,
+ * but may self-touch at points or along an edge.
+ * It may contain repeated points, which are treated as a single vertex.
+ * By default every vertex is triangulated,
+ * including ones which are "flat" (the adjacent segments are collinear).
+ * These can be removed by setting setSkipFlatCorners(boolean)
+ *
+ * The polygon representation does not allow holes.
+ * Polygons with holes can be triangulated by preparing them
+ * with {@link PolygonHoleJoiner}.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL PolygonEarClipper {
+    using Coordinate = geos::geom::Coordinate;
+    using CoordinateSequence = geos::geom::CoordinateSequence;
+    using Polygon = geos::geom::Polygon;
+    using Envelope = geos::geom::Envelope;
+    using Tri = geos::triangulate::tri::Tri;
+    template<typename TriType>
+    using TriList = geos::triangulate::tri::TriList<TriType>;
+    using VertexSequencePackedRtree = geos::index::VertexSequencePackedRtree;
+
+private:
+
+    // Members
+
+    bool isFlatCornersSkipped = false;
+
+    /**
+    * The polygon vertices are provided in CW orientation.
+    * Thus for convex interior angles
+    * the vertices forming the angle are in CW orientation.
+    */
+    const CoordinateSequence& vertex;
+    std::vector<std::size_t> vertexNext;
+    std::size_t vertexSize;
+
+    // first available vertex index
+    std::size_t vertexFirst;
+
+    // indices for current corner
+    std::array<std::size_t, 3> cornerIndex;
+
+    /**
+    * Indexing vertices improves ear intersection testing performance a lot.
+    * The polyShell vertices are contiguous, so are suitable for an SPRtree.
+    */
+    VertexSequencePackedRtree vertexCoordIndex;
+
+    // Methods
+
+    std::vector<std::size_t> createNextLinks(std::size_t size) const;
+
+    bool isValidEar(std::size_t cornerIndex, const std::array<Coordinate, 3>& corner);
+
+    /**
+    * Finds another vertex intersecting the corner triangle, if any.
+    * Uses the vertex spatial index for efficiency.
+    *
+    * Also finds any vertex which is a duplicate of the corner apex vertex,
+    * which then requires a full scan of the vertices to confirm ear is valid.
+    * This is usually a rare situation, so has little impact on performance.
+    *
+    * @param cornerIndex the index of the corner apex vertex
+    * @param corner the corner vertices
+    * @return the index of an intersecting or duplicate vertex, or NO_COORD_INDEX if none
+    */
+    std::size_t findIntersectingVertex(std::size_t cornerIndex, const std::array<Coordinate, 3>& corner) const;
+
+    /**
+    * Scan all vertices in current ring to check if any are duplicates
+    * of the corner apex vertex, and if so whether the corner ear
+    * intersects the adjacent segments and thus is invalid.
+    *
+    * @param cornerIndex the index of the corner apex
+    * @param corner the corner vertices
+    * @return true if the corner ia a valid ear
+    */
+    bool isValidEarScan(std::size_t cornerIndex, const std::array<Coordinate, 3>& corner) const;
+
+    /* private  */
+    static Envelope envelope(const std::array<Coordinate, 3>& corner);
+
+    /**
+    * Remove the corner apex vertex and update the candidate corner location.
+    */
+    void removeCorner();
+
+    bool isRemoved(std::size_t vertexIndex) const;
+
+    void initCornerIndex();
+
+    /**
+    * Fetch the corner vertices from the indices.
+    *
+    * @param corner an array for the corner vertices
+    */
+    void fetchCorner(std::array<Coordinate, 3>& cornerVertex) const;
+
+    /**
+    * Move to next corner.
+    */
+    void nextCorner(std::array<Coordinate, 3>& cornerVertex);
+
+    /**
+    * Get the index of the next available shell coordinate starting from the given
+    * index.
+    *
+    * @param index candidate position
+    * @return index of the next available shell coordinate
+    */
+    std::size_t nextIndex(std::size_t index) const;
+
+    bool isConvex(const std::array<Coordinate, 3>& pts) const;
+
+    bool isFlat(const std::array<Coordinate, 3>& pts) const;
+
+    /**
+    * Detects if a corner has repeated points (AAB or ABB), or is collapsed (ABA).
+    * @param pts the corner points
+    * @return true if the corner is flat or collapsed
+    */
+    bool isCornerInvalid(const std::array<Coordinate, 3>& pts) const;
+
+
+public:
+
+    /**
+    * Creates a new ear-clipper instance.
+    *
+    * @param polyShell the polygon vertices to process
+    */
+    PolygonEarClipper(const geom::CoordinateSequence& polyShell);
+
+    /**
+    * Triangulates a polygon via ear-clipping.
+    *
+    * @param polyShell the vertices of the polygon
+    * @param triListResult vector to fill in with the resultant Tri s
+    */
+    static void triangulate(const geom::CoordinateSequence& polyShell, TriList<Tri>& triListResult);
+
+    /**
+    * Sets whether flat corners formed by collinear adjacent line segments
+    * are included in the triangulation.
+    * Skipping flat corners reduces the number of triangles in the output.
+    * However, it produces a triangulation which does not include
+    * all input vertices.  This may be undesirable for downstream processes
+    * (such as computing a Constrained Delaunay Triangulation for
+    * purposes of computing the medial axis).
+    *
+    * The default is to include all vertices in the result triangulation.
+    * This still produces a valid triangulation, with no zero-area triangles.
+    *
+    * Note that repeated vertices are always skipped.
+    *
+    * @param p_isFlatCornersSkipped whether to skip collinear vertices
+    */
+    void setSkipFlatCorners(bool p_isFlatCornersSkipped);
+
+    void compute(TriList<Tri>& triList);
+
+    std::unique_ptr<Polygon> toGeometry() const;
+
+
+};
+
+
+
+} // namespace geos.triangulate.polygon
+} // namespace geos.triangulate
+} // namespace geos