@cpp.js/package-geos 1.0.0-beta.20

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/FacetSequenceTreeBuilder.h

@@ -0,0 +1,69 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Daniel Baston
+ *
+ * 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/distance/FacetSequenceTreeBuilder.java (f6187ee2 JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/index/ItemVisitor.h>
+#include <geos/index/strtree/TemplateSTRtree.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/operation/distance/FacetSequence.h>
+
+namespace geos {
+namespace operation {
+namespace distance {
+class GEOS_DLL FacetSequenceTreeBuilder {
+private:
+    // 6 seems to be a good facet sequence size
+    static const std::size_t FACET_SEQUENCE_SIZE = 6;
+
+    // Seems to be better to use a minimum node capacity
+    static const std::size_t STR_TREE_NODE_CAPACITY = 4;
+
+    static void addFacetSequences(const geom::Geometry* geom,
+                                  const geom::CoordinateSequence* pts,
+                                  std::vector<FacetSequence> & sections);
+    static std::vector<FacetSequence> computeFacetSequences(const geom::Geometry* g);
+
+    class FacetSequenceTree : public geos::index::strtree::TemplateSTRtree<const FacetSequence*> {
+    public:
+        // TODO support TemplateSTRtree<std::unique_ptr<FacetSequence>> and dispense with holding vector.
+        FacetSequenceTree(std::vector<FacetSequence> &&seq) :
+            TemplateSTRtree(STR_TREE_NODE_CAPACITY, seq.size()), sequences(seq) {
+            for (auto& fs : sequences) {
+                TemplateSTRtree::insert(fs.getEnvelope(), &fs);
+            }
+        }
+
+    private:
+        std::vector<FacetSequence> sequences;
+    };
+
+public:
+    /** \brief
+     * Return a tree of FacetSequences constructed from the supplied Geometry.
+     *
+     * The FacetSequences are owned by the tree and are automatically deleted by
+     * the tree on destruction.
+     */
+    static std::unique_ptr<geos::index::strtree::TemplateSTRtree<const FacetSequence*>> build(const geom::Geometry* g);
+};
+}
+}
+}
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/GeometryLocation.h

@@ -0,0 +1,119 @@
+/**********************************************************************
+ *
+ * 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 Public Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: operation/distance/GeometryLocation.java rev. 1.7 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geom/Coordinate.h> // for composition
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace distance { // geos::operation::distance
+
+
+/** \brief
+ * Represents the location of a point on a Geometry.
+ *
+ * Maintains both the actual point location
+ * (which may not be exact, if the point is not a vertex)
+ * as well as information about the component
+ * and segment index where the point occurs.
+ * Locations inside area Geometrys will not have an associated segment index,
+ * so in this case the segment index will have the sentinel value of
+ * INSIDE_AREA.
+ */
+class GEOS_DLL GeometryLocation {
+private:
+    const geom::Geometry* component;
+    std::size_t segIndex;
+    bool inside_area;
+    geom::CoordinateXY pt;
+public:
+    /** \brief
+     * A Special value of segmentIndex used for locations
+     * inside area geometries.
+     *
+     * These locations are not located on a segment,
+     * and thus do not have an associated segment index.
+     */
+    static const int INSIDE_AREA = -1;
+
+    /** \brief
+     * Constructs a GeometryLocation specifying a point on a geometry,
+     * as well as the segment that the point is on (or INSIDE_AREA if
+     * the point is not on a segment).
+     *
+     * @param component the component of the geometry containing the point
+     * @param segIndex the segment index of the location, or INSIDE_AREA
+     * @param pt the coordinate of the location
+     */
+    GeometryLocation(const geom::Geometry* component,
+                     std::size_t segIndex, const geom::CoordinateXY& pt);
+
+    /** \brief
+     * Constructs a GeometryLocation specifying a point inside an
+     * area geometry.
+     *
+     * @param component the component of the geometry containing the point
+     * @param pt the coordinate of the location
+     */
+    GeometryLocation(const geom::Geometry* component,
+                     const geom::CoordinateXY& pt);
+
+    /**
+     * Returns the geometry component on (or in) which this location occurs.
+     */
+    const geom::Geometry* getGeometryComponent();
+
+    /**
+     * Returns the segment index for this location.
+     *
+     * If the location is inside an
+     * area, the index will have the value INSIDE_AREA;
+     *
+     * @return the segment index for the location, or INSIDE_AREA
+     */
+    std::size_t getSegmentIndex();
+
+    /**
+     * Returns the geom::Coordinate of this location.
+     */
+    geom::CoordinateXY& getCoordinate();
+
+    /** \brief
+     * Tests whether this location represents a point
+     * inside an area geometry.
+     */
+    bool isInsideArea();
+
+    std::string toString();
+};
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/distance/IndexedFacetDistance.h

@@ -0,0 +1,124 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Daniel Baston
+ *
+ * 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/distance/IndexedFacetDistance.java (f6187ee2 JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/operation/distance/FacetSequenceTreeBuilder.h>
+
+namespace geos {
+namespace operation {
+namespace distance {
+
+/// \brief Computes the distance between the facets (segments and vertices)
+/// of two [Geometrys](\ref geom::Geometry) using a Branch-and-Bound algorithm.
+///
+/// The Branch-and-Bound algorithm operates over a traversal of R-trees built
+/// on the target and the query geometries.
+///
+/// This approach provides the following benefits:
+///
+/// - Performance is dramatically improved due to the use of the R-tree index
+///   and the pruning due to the Branch-and-Bound approach
+/// - The spatial index on the target geometry is cached which allow reuse in
+///   an repeated query situation.
+///
+/// Using this technique is usually much more performant than using the
+/// brute-force geom::Geometry::distance() when one
+/// or both input geometries are large, or when evaluating many distance
+/// computations against a single geometry.
+///
+/// \author Martin Davis
+class GEOS_DLL IndexedFacetDistance {
+public:
+
+    /// \brief Creates a new distance-finding instance for a given target geom::Geometry.
+    ///
+    /// Distances will be computed to all facets of the input geometry.
+    /// The facets of the geometry are the discrete segments and points
+    /// contained in its components.
+    /// In the case of lineal and puntal inputs, this is equivalent to computing
+    /// the conventional distance.
+    /// In the case of polygonal inputs, this is equivalent to computing the
+    /// distance to the polygon boundaries.
+    ///
+    /// \param g a Geometry, which may be of any type.
+    IndexedFacetDistance(const geom::Geometry* g) :
+        cachedTree(FacetSequenceTreeBuilder::build(g)),
+        baseGeometry(*g)
+    {}
+
+    /// \brief Computes the distance between facets of two geometries.
+    ///
+    /// For geometries with many segments or points, this can be faster than
+    /// using a simple distance algorithm.
+    ///
+    /// \param g1 a geometry
+    /// \param g2 a geometry
+    /// \return the distance between facets of the geometries
+    static double distance(const geom::Geometry* g1, const geom::Geometry* g2);
+
+    /// \brief Computes the nearest points of the facets of two geometries.
+    ///
+    /// \param g1 a geometry
+    /// \param g2 a geometry
+    /// \return the nearest points on the facets of the geometries
+    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g1, const geom::Geometry* g2);
+
+    /// \brief Computes the distance from the base geometry to the given geometry.
+    ///
+    /// \param g the geometry to compute the distance to
+    ///
+    /// \return the computed distance
+    double distance(const geom::Geometry* g) const;
+
+    /// \brief Tests whether the base geometry lies within a specified distance of the given geometry.
+    ///
+    /// \param g the geometry to test
+    /// \param maxDistance the maximum distance to test
+    ///
+    /// \return true of the geometry lies within the specified distance
+    bool isWithinDistance(const geom::Geometry* g, double maxDistance) const;
+
+    /// \brief Computes the nearest locations on the base geometry and the given geometry.
+    ///
+    /// \param g the geometry to compute the nearest location to
+    /// \return the nearest locations
+    std::vector<GeometryLocation> nearestLocations(const geom::Geometry* g) const;
+
+    /// \brief Compute the nearest locations on the target geometry and the given geometry.
+    ///
+    /// \param g the geometry to compute the nearest point to
+    /// \return the nearest points
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const;
+
+private:
+    struct FacetDistance {
+        double operator()(const FacetSequence* a, const FacetSequence* b) const
+        {
+            return a->distance(*b);
+        }
+    };
+
+    std::unique_ptr<geos::index::strtree::TemplateSTRtree<const FacetSequence*>> cachedTree;
+    const geom::Geometry& baseGeometry;
+
+};
+}
+}
+}
+

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/intersection/Rectangle.h

@@ -0,0 +1,236 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2014 Mika Heiskanen <mika.heiskanen@fmi.fi>
+ *
+ * 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 <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 GeometryFactory;
+class Geometry;
+class Polygon;
+class LinearRing;
+}
+}
+
+namespace geos {
+namespace operation { // geos::operation
+namespace intersection { // geos::operation::intersection
+
+/**
+ * \brief Clipping rectangle
+ *
+ * A clipping rectangle defines the boundaries of the rectangle
+ * by defining the limiting x- and y-coordinates. The clipping
+ * rectangle must be non-empty. In addition, methods are provided
+ * for specifying the location of a given coordinate with respect
+ * to the clipping rectangle similarly to the Cohen-Sutherland
+ * clipping algorithm.
+ *
+ */
+
+class GEOS_DLL Rectangle {
+public:
+
+    /**
+     * \brief Construct a clipping rectangle
+     *
+     * @param x1 x-coordinate of the left edge
+     * @param y1 y-coordinate of the bottom edge
+     * @param x2 x-coordinate of the right edge
+     * @param y2 y-coordinate of the right edge
+     * @throws IllegalArgumentException if the rectangle is empty
+     */
+
+    Rectangle(double x1, double y1, double x2, double y2);
+
+    /**
+     * @return the minimum x-coordinate of the rectangle
+     */
+    double
+    xmin() const
+    {
+        return xMin;
+    }
+
+    /**
+     * @return the minimum y-coordinate of the rectangle
+     */
+
+    double
+    ymin() const
+    {
+        return yMin;
+    }
+
+
+    /**
+     * @return the maximum x-coordinate of the rectangle
+     */
+
+    double
+    xmax() const
+    {
+        return xMax;
+    }
+
+
+    /**
+     * @return the maximum y-coordinate of the rectangle
+     */
+
+    double
+    ymax() const
+    {
+        return yMax;
+    }
+
+    /**
+     * @return the rectangle as a polygon geometry
+     *
+     * @note Ownership transferred to caller
+     */
+    std::unique_ptr<geom::Polygon> toPolygon(const geom::GeometryFactory& f) const;
+
+    std::unique_ptr<geom::LinearRing> toLinearRing(const geom::GeometryFactory& f) const;
+
+    /**
+     * @brief Position with respect to a clipping rectangle
+     */
+
+    enum Position {
+        Inside    = 1,
+        Outside   = 2,
+
+        Left        = 4,
+        Top         = 8,
+        Right       = 16,
+        Bottom      = 32,
+
+        TopLeft     = Top | Left,               // 12
+        TopRight    = Top | Right,              // 24
+        BottomLeft  = Bottom | Left,            // 36
+        BottomRight = Bottom | Right            // 48
+    };
+
+    /**
+     * @brief Test if the given position is on a Rectangle edge
+     * @param pos Rectangle::Position
+     * @return `true`, if the position is on an edge
+     */
+
+    static bool
+    onEdge(Position pos)
+    {
+        return (pos > Outside);
+    }
+
+    /**
+     * @brief Test if the given positions are on the same Rectangle edge
+     * @param pos1 [Position](@ref Rectangle::Position) of first coordinate
+     * @param pos2 [Position](@ref Rectangle::Position) of second coordinate
+     * @return `true`, if the positions are on the same edge
+     */
+
+    static bool
+    onSameEdge(Position pos1, Position pos2)
+    {
+        return onEdge(Position(pos1 & pos2));
+    }
+
+    /**
+     * @brief Establish position of coordinate with respect to a Rectangle
+     * @param x x-coordinate
+     * @param y y-coordinate
+     * @return [Position](@ref Rectangle::Position) of the coordinate
+     */
+
+    Position
+    position(double x, double y) const
+    {
+        // We assume the point to be inside and test it first
+        if(x > xMin && x < xMax && y > yMin && y < yMax) {
+            return Inside;
+        }
+        // Next we assume the point to be outside and test it next
+        if(x < xMin || x > xMax || y < yMin || y > yMax) {
+            return Outside;
+        }
+        // Slower cases
+        unsigned int pos = 0;
+        if(x == xMin) {
+            pos |= Left;
+        }
+        else if(x == xMax) {
+            pos |= Right;
+        }
+        if(y == yMin) {
+            pos |= Bottom;
+        }
+        else if(y == yMax) {
+            pos |= Top;
+        }
+        return Position(pos);
+    }
+
+    /**
+     * @brief Next edge in clock-wise direction
+     * @param pos [Position](@ref Rectangle::Position)
+     * @return next [Position](@ref Rectangle::Position) in clock-wise direction
+     */
+
+    static Position
+    nextEdge(Position pos)
+    {
+        switch(pos) {
+        case BottomLeft:
+        case Left:
+            return Top;
+        case TopLeft:
+        case Top:
+            return Right;
+        case TopRight:
+        case Right:
+            return Bottom;
+        case BottomRight:
+        case Bottom:
+            return Left;
+        /* silences compiler warnings, Inside & Outside are not handled explicitly */
+        default:
+            return pos;
+        }
+    }
+
+private:
+
+    Rectangle();
+    double xMin;
+    double yMin;
+    double xMax;
+    double yMax;
+
+}; // class RectangleIntersection
+
+} // namespace geos::operation::intersection
+} // namespace geos::operation
+} // namespace geos
+