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

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/distance/DistanceOp.h

@@ -0,0 +1,255 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * 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/DistanceOp.java r335 (JTS-1.12-)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/algorithm/PointLocator.h> // for composition
+#include <geos/operation/distance/GeometryLocation.h>
+#include <geos/geom/CoordinateSequence.h>
+
+#include <array>
+#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 CircularString;
+class Coordinate;
+class Polygon;
+class LineString;
+class Point;
+class Geometry;
+class SimpleCurve;
+class Surface;
+}
+}
+
+
+namespace geos {
+namespace operation { // geos::operation
+namespace distance { // geos::operation::distance
+
+/**
+ * \brief
+ * Find two points on two {@link geom::Geometry}s which lie
+ * within a given distance, or else are the nearest points
+ * on the geometries (in which case this also
+ * provides the distance between the geometries).
+ *
+ * The distance computation also finds a pair of points in the
+ * input geometries which have the minimum distance between them.
+ * If a point lies in the interior of a line segment,
+ * the coordinate computed is a close
+ * approximation to the exact point.
+ *
+ * Empty geometry collection components are ignored.
+ *
+ * The algorithms used are straightforward O(n^2)
+ * comparisons.  This worst-case performance could be improved on
+ * by using Voronoi techniques or spatial indexes.
+ *
+ */
+class GEOS_DLL DistanceOp {
+public:
+    /**
+     * \brief
+     * Compute the distance between the nearest points of two geometries.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     * @return the distance between the geometries
+     * @return 0 if either input geometry is empty
+     * @throws IllegalArgumentException if either input geometry is null
+     */
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1);
+
+    /// @deprecated, use the version taking references
+    static double distance(const geom::Geometry* g0,
+                           const geom::Geometry* g1);
+
+    /**
+     * \brief
+     * Test whether two geometries lie within a given distance of
+     * each other.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     * @param distance the distance to test
+     * @return true if g0.distance(g1) <= distance
+     */
+    static bool isWithinDistance(const geom::Geometry& g0,
+                                 const geom::Geometry& g1,
+                                 double distance);
+
+    /**
+     * Report the locations of the nearest points in the input geometries.
+     * The locations are presented in the same order as the input geometries.
+     *
+     * @return a pair of {@link GeometryLocation}s for the nearest points
+     */
+    const std::array<GeometryLocation, 2>& nearestLocations();
+
+    /**
+     * Compute the nearest points of two geometries.
+     *
+     * The points are presented in the same order as the input Geometries.
+     *
+     * @param g0 a {@link geom::Geometry}
+     * @param g1 another {@link geom::Geometry}
+     *
+     * @return the nearest points in the geometries, ownership to caller.
+     *         A NULL return means one of the geometries is empty.
+     *
+     */
+    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(
+        const geom::Geometry* g0,
+        const geom::Geometry* g1);
+
+    /// @deprecated use the one taking references
+    DistanceOp(const geom::Geometry* g0, const geom::Geometry* g1);
+
+    /**
+     * \brief
+     * Constructs a DistanceOp that computes the distance and
+     * nearest points between the two specified geometries.
+     *
+     * @param g0 a Geometry
+     * @param g1 a Geometry
+     */
+    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1);
+
+    /**
+     * \brief
+     * Constructs a DistanceOp that computes the distance and nearest
+     * points between the two specified geometries.
+     *
+     * @param g0 a Geometry
+     * @param g1 a Geometry
+     * @param terminateDistance the distance on which to terminate
+     *                          the search
+     */
+    DistanceOp(const geom::Geometry& g0, const geom::Geometry& g1,
+               double terminateDistance);
+
+    ~DistanceOp() = default;
+
+    /**
+     * Report the distance between the closest points on the input geometries.
+     *
+     * @return the distance between the geometries
+     */
+    double distance();
+
+    /**
+     * Report the coordinates of the nearest points in the input geometries.
+     * The points are presented in the same order as the input Geometries.
+     *
+     * @return a pair of {@link geom::Coordinate}s of the nearest points
+     *         as a newly allocated object (ownership to caller)
+     *
+     */
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints();
+
+private:
+
+    // input
+    std::array<geom::Geometry const*, 2> geom;
+    double terminateDistance;
+
+    // working
+    algorithm::PointLocator ptLocator;
+    std::array<GeometryLocation, 2> minDistanceLocation;
+    double minDistance;
+    bool computed = false;
+
+    void updateMinDistance(std::array<GeometryLocation, 2> & locGeom, bool flip);
+
+    void computeMinDistance();
+
+    void computeContainmentDistance();
+
+    void computeInside(std::vector<GeometryLocation> & locs,
+                       const std::vector<const geom::Surface*>& polys,
+                       std::array<GeometryLocation, 2> & locPtPoly);
+
+
+    /**
+     * Computes distance between facets (lines and points)
+     * of input geometries.
+     */
+    void computeFacetDistance();
+
+    void computeMinDistanceLines(
+        const std::vector<const geom::SimpleCurve*>& lines0,
+        const std::vector<const geom::SimpleCurve*>& lines1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistancePoints(
+        const std::vector<const geom::Point*>& points0,
+        const std::vector<const geom::Point*>& points1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistanceLinesPoints(
+        const std::vector<const geom::SimpleCurve*>& lines0,
+        const std::vector<const geom::Point*>& points1,
+        std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::CircularString* cs0,
+                            const geom::LineString* line1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line0,
+                            const geom::CircularString* cs1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line0,
+                            const geom::LineString* line1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::CircularString* cs0,
+                            const geom::CircularString* cs1,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::LineString* line,
+                            const geom::Point* pt,
+                            std::array<GeometryLocation, 2> & locGeom);
+
+    void computeMinDistance(const geom::CircularString* cs,
+                            const geom::Point* pt,
+                            std::array<GeometryLocation, 2> & locGeom);
+};
+
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/distance/FacetSequence.h

@@ -0,0 +1,94 @@
+/**********************************************************************
+ *
+ * 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/FacetSequence.java (f6187ee2 JTS-1.14)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/Envelope.h>
+#include <geos/geom/Coordinate.h>
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace operation {
+namespace distance {
+
+class FacetSequence {
+
+private:
+
+    const geom::CoordinateSequence* pts;
+    const std::size_t start;
+    const std::size_t end;
+
+    /*
+    * Unlike JTS, we store the envelope in the FacetSequence so
+    * that it has a clear owner.  This is helpful when making a
+    * tree of FacetSequence objects (FacetSequenceTreeBuilder)
+    */
+    geom::Envelope env;
+
+    double computeDistanceLineLine(const FacetSequence& facetSeq,
+                                   std::vector<geom::Coordinate> *locs) const;
+
+    double computeDistancePointLine(const geom::Coordinate& pt,
+                                    const FacetSequence& facetSeq,
+                                    std::vector<geom::Coordinate> *locs) const;
+
+    void updateNearestLocationsPointLine(const geom::Coordinate& pt,
+                                         const geom::Coordinate& q0, const geom::Coordinate &q1,
+                                         std::vector<geom::Coordinate> *locs) const;
+
+    void updateNearestLocationsLineLine(const geom::Coordinate& p0, const geom::Coordinate& p1,
+                                        const geom::Coordinate& q0, const geom::Coordinate &q1,
+                                        std::vector<geom::Coordinate> *locs) const;
+
+    void computeEnvelope();
+
+public:
+
+    const geom::Envelope* getEnvelope() const;
+
+    const geom::Coordinate* getCoordinate(std::size_t index) const;
+
+    std::size_t size() const;
+
+    bool isPoint() const;
+
+    double distance(const FacetSequence& facetSeq) const;
+
+    FacetSequence(const geom::CoordinateSequence* pts, std::size_t start, std::size_t end);
+
+    /**
+     * Computes the locations of the nearest points between this sequence
+     * and another sequence.
+     * The locations are presented in the same order as the input sequences.
+     *
+     * @return a pair of {@link Coordinate}s for the nearest points
+     */
+    std::vector<geom::Coordinate> nearestLocations(const FacetSequence& facetSeq) const;
+
+};
+
+}
+}
+}
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/distance/FacetSequenceTreeBuilder.h

@@ -0,0 +1,78 @@
+/**********************************************************************
+ *
+ * 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/strtree/TemplateSTRtree.h>
+#include <geos/operation/distance/FacetSequence.h>
+
+
+namespace geos {
+namespace geom {
+class CoordinateSequence;
+class Geometry;
+}
+}
+
+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::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/linuxmusl-x64-mt-release/include/geos/operation/distance/GeometryLocation.h

@@ -0,0 +1,126 @@
+/**********************************************************************
+ *
+ * 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;
+
+    GeometryLocation() :
+        component(nullptr),
+        segIndex(0),
+        inside_area(false),
+        pt()
+    {}
+
+    /** \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() const;
+
+    /**
+     * 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() const;
+
+    /**
+     * Returns the geom::Coordinate of this location.
+     */
+    const geom::CoordinateXY& getCoordinate() const;
+
+    /** \brief
+     * Tests whether this location represents a point
+     * inside an area geometry.
+     */
+    bool isInsideArea() const;
+
+    std::string toString() const;
+};
+
+} // namespace geos::operation::distance
+} // namespace geos::operation
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/operation/distance/IndexedFacetDistance.h

@@ -0,0 +1,121 @@
+/**********************************************************************
+ *
+ * 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;
+
+    static bool isWithinDistance(const geom::Geometry* g1, const geom::Geometry* g2, double distance);
+
+    /// \brief Computes the nearest points on the base 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;
+
+};
+}
+}
+}
+