@cpp.js/package-geos 1.0.0-beta.22 → 1.0.0

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/EdgeNodingBuilder.h

@@ -0,0 +1,255 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/overlayng/EdgeNodingBuilder.java 6ef89b096
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/algorithm/Orientation.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/GeometryCollection.h>
+#include <geos/geom/LinearRing.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/MultiLineString.h>
+#include <geos/geom/MultiPolygon.h>
+#include <geos/geom/Polygon.h>
+#include <geos/noding/IntersectionAdder.h>
+#include <geos/noding/MCIndexNoder.h>
+#include <geos/noding/Noder.h>
+#include <geos/noding/NodedSegmentString.h>
+#include <geos/noding/SegmentString.h>
+#include <geos/noding/ValidatingNoder.h>
+#include <geos/noding/snapround/SnapRoundingNoder.h>
+#include <geos/operation/overlayng/Edge.h>
+#include <geos/operation/overlayng/EdgeSourceInfo.h>
+#include <geos/operation/overlayng/InputGeometry.h>
+#include <geos/operation/overlayng/LineLimiter.h>
+#include <geos/operation/overlayng/OverlayUtil.h>
+#include <geos/operation/overlayng/RingClipper.h>
+#include <geos/operation/valid/RepeatedPointRemover.h>
+
+
+#include <geos/export.h>
+#include <array>
+#include <memory>
+#include <deque>
+
+using namespace geos::geom;
+using namespace geos::noding;
+using geos::noding::snapround::SnapRoundingNoder;
+using geos::algorithm::LineIntersector;
+
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Builds a set of noded, unique, labelled Edges from
+ * the edges of the two input geometries.
+ *
+ * It performs the following steps:
+ *
+ *  - Extracts input edges, and attaches topological information
+ *  - if clipping is enabled, handles clipping or limiting input geometry
+ *  - chooses a {@link noding::Noder} based on provided precision model, unless a custom one is supplied
+ *  - calls the chosen Noder, with precision model
+ *  - removes any fully collapsed noded edges
+ *  - builds {@link Edge}s and merges them
+ *
+ * @author mdavis
+ */
+class GEOS_DLL EdgeNodingBuilder {
+
+private:
+
+    // Constants
+    static constexpr int MIN_LIMIT_PTS = 20;
+    static constexpr bool IS_NODING_VALIDATED = true;
+
+    // Members
+    const PrecisionModel* pm;
+    std::unique_ptr<std::vector<SegmentString*>> inputEdges;
+    Noder* customNoder;
+    std::array<bool, 2> hasEdges;
+    const Envelope* clipEnv;
+    std::unique_ptr<RingClipper> clipper;
+    std::unique_ptr<LineLimiter> limiter;
+
+    // For use in createFloatingPrecisionNoder()
+    LineIntersector lineInt;
+    IntersectionAdder intAdder;
+    std::unique_ptr<Noder> internalNoder;
+    std::unique_ptr<Noder> spareInternalNoder;
+    // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
+    std::deque<EdgeSourceInfo> edgeSourceInfoQue;
+    std::deque<Edge> edgeQue;
+    bool inputHasZ;
+    bool inputHasM;
+
+    /**
+    * Gets a noder appropriate for the precision model supplied.
+    * This is one of:
+    *
+    * - Fixed precision: a snap-rounding noder (which should be fully robust)
+    * - Floating precision: a conventional model (which may be non-robust).
+    *   In this case, a validation step is applied to the output from the noder.
+    */
+    Noder* getNoder();
+    static std::unique_ptr<Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
+    std::unique_ptr<Noder> createFloatingPrecisionNoder(bool doValidation);
+
+
+    void addCollection(const GeometryCollection* gc, uint8_t geomIndex);
+    void addGeometryCollection(const GeometryCollection* gc, uint8_t geomIndex, int expectedDim);
+    void addPolygon(const Polygon* poly, uint8_t geomIndex);
+    void addPolygonRing(const LinearRing* ring, bool isHole, uint8_t geomIndex);
+    void addLine(const LineString* line, uint8_t geomIndex);
+    void addLine(std::unique_ptr<CoordinateSequence>& pts, uint8_t geomIndex);
+    void addEdge(std::unique_ptr<CoordinateSequence>& cas, const EdgeSourceInfo* info);
+
+    // Create a EdgeSourceInfo* owned by EdgeNodingBuilder
+    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index, int depthDelta, bool isHole);
+    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index);
+
+    /**
+    * Tests whether a geometry (represented by its envelope)
+    * lies completely outside the clip extent(if any).
+    */
+    bool isClippedCompletely(const Envelope* env) const;
+
+    /**
+    * Tests whether it is worth limiting a line.
+    * Lines that have few vertices or are covered
+    * by the clip extent do not need to be limited.
+    */
+    bool isToBeLimited(const LineString* line) const;
+
+    /**
+    * If limiter is provided,
+    * limit the line to the clip envelope.
+    *
+    */
+    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const LineString* line);
+
+    /**
+    * If a clipper is present,
+    * clip the line to the clip extent.
+    * Otherwise, remove duplicate points from the ring.
+    *
+    * If clipping is enabled, then every ring MUST
+    * be clipped, to ensure that holes are clipped to
+    * be inside the shell.
+    * This means it is not possible to skip
+    * clipping for rings with few vertices.
+    *
+    * @param ring the line to clip
+    * @return the points in the clipped line
+    */
+    std::unique_ptr<CoordinateSequence> clip(const LinearRing* line);
+
+    /**
+    * Removes any repeated points from a linear component.
+    * This is required so that noding can be computed correctly.
+    *
+    * @param line the line to process
+    * @return the points of the line with repeated points removed
+    */
+    static std::unique_ptr<CoordinateSequence> removeRepeatedPoints(const LineString* line);
+
+    static int computeDepthDelta(const LinearRing* ring, bool isHole);
+
+    void add(const Geometry* g, uint8_t geomIndex);
+
+    /**
+    * Nodes a set of segment strings and creates {@link Edge}s from the result.
+    * The input segment strings each carry a {@link EdgeSourceInfo} object,
+    * which is used to provide source topology info to the constructed Edges
+    * (and is then discarded).
+    */
+    std::vector<Edge*> node(std::vector<SegmentString*>* segStrings);
+    std::vector<Edge*> createEdges(std::vector<SegmentString*>* segStrings);
+
+
+public:
+
+    /**
+    * Creates a new builder, with an optional custom noder.
+    * If the noder is not provided, a suitable one will
+    * be used based on the supplied precision model.
+    */
+    EdgeNodingBuilder(const PrecisionModel* p_pm, Noder* p_customNoder)
+        : pm(p_pm)
+        , inputEdges(new std::vector<SegmentString*>)
+        , customNoder(p_customNoder)
+        , hasEdges{{false,false}}
+        , clipEnv(nullptr)
+        , intAdder(lineInt)
+        , inputHasZ(false)
+        , inputHasM(false)
+        {};
+
+    ~EdgeNodingBuilder()
+    {
+        for (SegmentString* ss: *inputEdges) {
+            delete ss;
+        }
+    }
+
+    void setClipEnvelope(const Envelope* clipEnv);
+
+    // returns newly allocated vector and segmentstrings
+    // std::vector<SegmentString*>* node();
+
+    /**
+    * Reports whether there are noded edges
+    * for the given input geometry.
+    * If there are none, this indicates that either
+    * the geometry was empty, or has completely collapsed
+    * (because it is smaller than the noding precision).
+    *
+    * @param geomIndex index of input geometry
+    * @return true if there are edges for the geometry
+    */
+    bool hasEdgesFor(uint8_t geomIndex) const;
+
+    /**
+    * Creates a set of labelled {Edge}s.
+    * representing the fully noded edges of the input geometries.
+    * Coincident edges (from the same or both geometries)
+    * are merged along with their labels
+    * into a single unique, fully labelled edge.
+    *
+    * @param geom0 the first geometry
+    * @param geom1 the second geometry
+    * @return the noded, merged, labelled edges
+    */
+    std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
+
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/EdgeSourceInfo.h

@@ -0,0 +1,65 @@
+/**********************************************************************
+ *
+ * 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/Dimension.h>
+#include <geos/export.h>
+#include <cstdint>
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+/**
+ * Records topological information about an
+ * edge representing a piece of linework (lineString or polygon ring)
+ * from a single source geometry.
+ * This information is carried through the noding process
+ * (which may result in many noded edges sharing the same information object).
+ * It is then used to populate the topology info fields
+ * in {@link Edge}s (possibly via merging).
+ * That information is used to construct the topology graph {@link OverlayLabel}s.
+ *
+ * @author mdavis
+ *
+ */
+
+class GEOS_DLL EdgeSourceInfo {
+
+private:
+
+    // Members
+    uint8_t index;
+    int8_t dim;
+    bool edgeIsHole;
+    int depthDelta;
+
+
+public:
+
+    EdgeSourceInfo(uint8_t p_index, int p_depthDelta, bool p_isHole);
+    EdgeSourceInfo(uint8_t p_index);
+
+    uint8_t getIndex() const { return index; }
+    int getDimension() const { return dim; }
+    int getDepthDelta() const { return depthDelta; }
+    bool isHole() const { return edgeIsHole; }
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/ElevationModel.h

@@ -0,0 +1,170 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 Sandro Santilli <strk@kbt.io>
+ *
+ * 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/overlayng/ElevationModel.java 4c88fea52
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Envelope.h> // for composition
+
+// Forward declarations
+namespace geos {
+    namespace geom {
+        class Geometry;
+    }
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+
+/**
+ * \brief
+ * A simple elevation model used to populate missing Z values
+ * in overlay results.
+ *
+ * The model divides the extent of the input geometry(s)
+ * into an NxM grid.
+ * The default grid size is 3x3.
+ * If the input has no extent in the X or Y dimension,
+ * that dimension is given grid size 1.
+ * The elevation of each grid cell is computed as the average of the Z
+ * values
+ * of the input vertices in that cell (if any).
+ * If a cell has no input vertices within it, it is assigned
+ * the average elevation over all cells.
+ *
+ * If no input vertices have Z values, the model does not assign a Z
+ * value.
+ *
+ * The elevation of an arbitrary location is determined as the
+ * Z value of the nearest grid cell.
+ *
+ * An elevation model can be used to populate missing Z values
+ * in an overlay result geometry.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL ElevationModel {
+
+private:
+
+    class ElevationCell {
+    private:
+
+      int numZ = 0;
+      double sumZ = 0.0;
+      double avgZ;
+
+    public:
+
+      bool isNull() const
+      {
+        return numZ == 0;
+      }
+
+      void add(double z)
+      {
+        ++numZ;
+        sumZ += z;
+      }
+
+      void compute()
+      {
+        avgZ = DoubleNotANumber;
+        if (numZ > 0)
+          avgZ = sumZ / numZ;
+      }
+
+      double getZ() const
+      {
+        return avgZ;
+      }
+    };
+
+
+    static const int DEFAULT_CELL_NUM;
+    geom::Envelope extent;
+    int numCellX;
+    int numCellY;
+    double cellSizeX;
+    double cellSizeY;
+    std::vector<ElevationCell> cells;
+    bool isInitialized = false;
+    bool hasZValue = false;
+    double averageZ = DoubleNotANumber;
+
+    void init();
+
+    ElevationCell& getCell(double x, double y); //, bool isCreateIfMissing);
+
+    int getCellOffset(int ix, int iy) {
+        return (numCellX * iy + ix);
+    }
+
+protected:
+
+  void add(double x, double y, double z);
+
+
+public:
+
+    static std::unique_ptr<ElevationModel> create(const geom::Geometry& geom1,
+                                                const geom::Geometry& geom2);
+
+    static std::unique_ptr<ElevationModel> create(const geom::Geometry& geom1);
+
+    ElevationModel(const geom::Envelope& extent, int numCellX, int numCellY);
+
+    void add(const geom::Geometry& geom);
+
+
+    /**
+     * Gets the model Z value at a given location.
+     * If the location lies outside the model grid extent,
+     * this returns the Z value of the nearest grid cell.
+     * If the model has no elevation computed (i.e. due
+     * to empty input), the value is returned as a double NaN.
+     *
+     * @param x the x ordinate of the location
+     * @param y the y ordinate of the location
+     * @return the computed model Z value
+     */
+    double getZ(double x, double y);
+
+
+    /**
+     * \brief
+     * Computes Z values for any missing Z values in a geometry,
+     * using the computed model.
+     *
+     * If the model has no Z value, or the geometry coordinate dimension
+     * does not include Z, no action is taken.
+     *
+     * @param geom the geometry to elevate
+     */
+    void populateZ(geom::Geometry& geom);
+
+
+};
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/IndexedPointOnLineLocator.h

@@ -0,0 +1,64 @@
+/**********************************************************************
+ *
+ * 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/algorithm/locate/PointOnGeometryLocator.h>
+#include <geos/geom/Location.h>
+
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+ * Locates points on a linear geometry,
+ * using a spatial index to provide good performance.
+ *
+ * @author mdavis
+ */
+class IndexedPointOnLineLocator : public algorithm::locate::PointOnGeometryLocator {
+
+private:
+
+    // Members
+    const geom::Geometry& inputGeom;
+
+
+
+public:
+
+    IndexedPointOnLineLocator(const geom::Geometry& geomLinear)
+        : inputGeom(geomLinear)
+        {}
+
+    geom::Location locate(const geom::CoordinateXY* p) override;
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/InputGeometry.h

@@ -0,0 +1,103 @@
+/**********************************************************************
+ *
+ * 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
+ *
+ */
+
+using namespace geos::algorithm::locate;
+using namespace geos::geom;
+
+class GEOS_DLL InputGeometry {
+
+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;
+    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 Coordinate& pt);
+
+    PointOnGeometryLocator* getLocator(uint8_t geomIndex);
+    void setCollapsed(uint8_t geomIndex, bool isGeomCollapsed);
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+