@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

package/dist/prebuilt/iOS-iphonesimulator/include/geos/triangulate/IncrementalDelaunayTriangulator.h

@@ -1,106 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphonesimulator/include/geos/triangulate/VoronoiDiagramBuilder.h

@@ -1,157 +0,0 @@
-/**********************************************************************
- *
- * 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/iOS-iphonesimulator/include/geos/triangulate/polygon/ConstrainedDelaunayTriangulator.h

@@ -1,101 +0,0 @@
-/**********************************************************************
- *
- * 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;
-}
-}
-
-using geos::geom::Geometry;
-using geos::geom::GeometryFactory;
-using geos::geom::Polygon;
-using geos::triangulate::tri::TriList;
-using geos::triangulate::tri::Tri;
-
-
-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 {
-
-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/iOS-iphonesimulator/include/geos/triangulate/polygon/PolygonEarClipper.h

@@ -1,218 +0,0 @@
-/**********************************************************************
- *
- * 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;
-}
-}
-
-using geos::geom::Coordinate;
-using geos::geom::Polygon;
-using geos::geom::Envelope;
-using geos::triangulate::tri::Tri;
-using geos::triangulate::tri::TriList;
-using geos::index::VertexSequencePackedRtree;
-
-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 {
-
-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