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

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/distance/DiscreteFrechetDistance.h

@@ -0,0 +1,175 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2016 Shinichi SUGIYAMA (shin.sugi@gmail.com)
+ *
+ * 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: original work
+ *
+ * Developed by Shinichi SUGIYAMA (shin.sugi@gmail.com)
+ * based on http://www.kr.tuwien.ac.at/staff/eiter/et-archive/cdtr9464.pdf
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/distance/PointPairDistance.h> // for composition
+#include <geos/algorithm/distance/DistanceToPoint.h> // for composition
+#include <geos/util/IllegalArgumentException.h> // for inlines
+#include <geos/geom/Geometry.h> // for inlines
+#include <geos/util/math.h> // for inlines
+#include <geos/geom/CoordinateFilter.h> // for inheritance
+#include <geos/geom/CoordinateSequence.h> // for inheritance
+
+#include <cstddef>
+#include <vector>
+
+#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
+
+namespace geos {
+namespace algorithm {
+//class RayCrossingCounter;
+}
+namespace geom {
+class Geometry;
+class Coordinate;
+//class CoordinateSequence;
+}
+namespace index {
+namespace intervalrtree {
+//class SortedPackedIntervalRTree;
+}
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace distance { // geos::algorithm::distance
+
+/** \brief
+ * An algorithm for computing a distance metric
+ * which is an approximation to the Frechet Distance
+ * based on a discretization of the input {@link geom::Geometry}.
+ *
+ * The algorithm computes the Frechet distance restricted to discrete points
+ * for one of the geometries.
+ * The points can be either the vertices of the geometries (the default),
+ * or the geometries with line segments densified by a given fraction.
+ * Also determines two points of the Geometries which are separated by the
+ * computed distance.
+ *
+ * This algorithm is an approximation to the standard Frechet distance.
+ * Specifically,
+ * <pre>
+ *    for all geometries a, b:    DFD(a, b) >= FD(a, b)
+ * </pre>
+ * The approximation can be made as close as needed by densifying the
+ * input geometries.
+ * In the limit, this value will approach the true Frechet distance:
+ * <pre>
+ *    DFD(A, B, densifyFactor) -> FD(A, B) as densifyFactor -> 0.0
+ * </pre>
+ * The default approximation is exact or close enough for a large subset of
+ * useful cases.
+ *
+ * The difference between DFD and FD is bounded
+ * by the length of the longest edge of the polygonal curves.
+ *
+ * Fréchet distance sweep continuously along their respective curves
+ * and the direction of curves is significant.
+ * This makes a better measure of similarity than Hausdorff distance.
+ *
+ * An example showing how different DHD and DFD are:
+ * <pre>
+ *   A  = LINESTRING (0 0, 50 200, 100 0, 150 200, 200 0)
+ *   B  = LINESTRING (0 200, 200 150, 0 100, 200 50, 0 0)
+ *   B' = LINESTRING (0 0, 200 50, 0 100, 200 150, 0 200)
+ *
+ *   DHD(A, B)  = DHD(A, B') = 48.5071250072666
+ *   DFD(A, B)  = 200
+ *   DFD(A, B') = 282.842712474619
+ * </pre>
+ */
+class GEOS_DLL DiscreteFrechetDistance {
+public:
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1);
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1, double densifyFrac);
+
+    DiscreteFrechetDistance(const geom::Geometry& p_g0,
+                            const geom::Geometry& p_g1)
+        :
+        g0(p_g0),
+        g1(p_g1),
+        ptDist(),
+        densifyFrac(0.0)
+    {}
+
+    /**
+     * Sets the fraction by which to densify each segment.
+     * Each segment will be (virtually) split into a number of equal-length
+     * subsegments, whose fraction of the total length is closest
+     * to the given fraction.
+     *
+     * @param dFrac
+     */
+    void setDensifyFraction(double dFrac);
+
+    double
+    distance()
+    {
+        compute(g0, g1);
+        return ptDist.getDistance();
+    }
+
+    const std::array<geom::CoordinateXY, 2>
+    getCoordinates() const
+    {
+        return ptDist.getCoordinates();
+    }
+
+private:
+    geom::Coordinate getSegmentAt(const geom::CoordinateSequence& seq, std::size_t index);
+
+    PointPairDistance& getFrechetDistance(std::vector< std::vector<PointPairDistance> >& ca, std::size_t i, std::size_t j,
+                                         const geom::CoordinateSequence& p, const geom::CoordinateSequence& q);
+
+    void compute(const geom::Geometry& discreteGeom, const geom::Geometry& geom);
+
+    const geom::Geometry& g0;
+
+    const geom::Geometry& g1;
+
+    PointPairDistance ptDist;
+
+    /// Value of 0.0 indicates that no densification should take place
+    double densifyFrac; // = 0.0;
+
+    // Declare type as noncopyable
+    DiscreteFrechetDistance(const DiscreteFrechetDistance& other) = delete;
+    DiscreteFrechetDistance& operator=(const DiscreteFrechetDistance& rhs) = delete;
+};
+
+} // geos::algorithm::distance
+} // geos::algorithm
+} // geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/distance/DiscreteHausdorffDistance.h

@@ -0,0 +1,252 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  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: algorithm/distance/DiscreteHausdorffDistance.java 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/algorithm/distance/PointPairDistance.h> // for composition
+#include <geos/algorithm/distance/DistanceToPoint.h> // for composition
+#include <geos/util/IllegalArgumentException.h> // for inlines
+#include <geos/geom/Geometry.h> // for inlines
+#include <geos/util/math.h> // for inlines
+#include <geos/geom/CoordinateFilter.h> // for inheritance
+#include <geos/geom/CoordinateSequenceFilter.h> // for inheritance
+
+#include <cstddef>
+#include <vector>
+
+#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
+
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+//class CoordinateSequence;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace distance { // geos::algorithm::distance
+
+/** \brief
+ * An algorithm for computing a distance metric
+ * which is an approximation to the Hausdorff Distance
+ * based on a discretization of the input {@link geom::Geometry}.
+ *
+ * The algorithm computes the Hausdorff distance restricted to discrete points
+ * for one of the geometries.
+ * The points can be either the vertices of the geometries (the default),
+ * or the geometries with line segments densified by a given fraction.
+ * Also determines two points of the Geometries which are separated by the
+ * computed distance.
+ *
+ * This algorithm is an approximation to the standard Hausdorff distance.
+ * Specifically,
+ * <pre>
+ *    for all geometries a, b:    DHD(a, b) <= HD(a, b)
+ * </pre>
+ * The approximation can be made as close as needed by densifying the
+ * input geometries.
+ * In the limit, this value will approach the true Hausdorff distance:
+ * <pre>
+ *    DHD(A, B, densifyFactor) -> HD(A, B) as densifyFactor -> 0.0
+ * </pre>
+ * The default approximation is exact or close enough for a large subset of
+ * useful cases.
+ * Examples of these are:
+ *
+ * - computing distance between Linestrings that are roughly parallel to
+ *   each other, and roughly equal in length.  This occurs in matching
+ *   linear networks.
+ * - Testing similarity of geometries.
+ *
+ * An example where the default approximation is not close is:
+ * <pre>
+ *   A = LINESTRING (0 0, 100 0, 10 100, 10 100)
+ *   B = LINESTRING (0 100, 0 10, 80 10)
+ *
+ *   DHD(A, B) = 22.360679774997898
+ *   HD(A, B) ~= 47.8
+ * </pre>
+ */
+class GEOS_DLL DiscreteHausdorffDistance {
+public:
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1);
+
+    static double distance(const geom::Geometry& g0,
+                           const geom::Geometry& g1, double densifyFrac);
+
+    DiscreteHausdorffDistance(const geom::Geometry& p_g0,
+                              const geom::Geometry& p_g1)
+        :
+        g0(p_g0),
+        g1(p_g1),
+        ptDist(),
+        densifyFrac(0.0)
+    {}
+
+    /**
+     * Sets the fraction by which to densify each segment.
+     * Each segment will be (virtually) split into a number of equal-length
+     * subsegments, whose fraction of the total length is closest
+     * to the given fraction.
+     *
+     * @param dFrac
+     */
+    void setDensifyFraction(double dFrac);
+
+    double
+    distance()
+    {
+        compute(g0, g1);
+        return ptDist.getDistance();
+    }
+
+    double
+    orientedDistance()
+    {
+        computeOrientedDistance(g0, g1, ptDist);
+        return ptDist.getDistance();
+    }
+
+    const std::array<geom::CoordinateXY, 2>
+    getCoordinates() const
+    {
+        return ptDist.getCoordinates();
+    }
+
+    class MaxPointDistanceFilter : public geom::CoordinateFilter {
+    public:
+        MaxPointDistanceFilter(const geom::Geometry& p_geom)
+            :
+            geom(p_geom)
+        {}
+
+        void
+        filter_ro(const geom::CoordinateXY* pt) override
+        {
+            minPtDist.initialize();
+            DistanceToPoint::computeDistance(geom, *pt,
+                                             minPtDist);
+            maxPtDist.setMaximum(minPtDist);
+        }
+
+        const PointPairDistance&
+        getMaxPointDistance() const
+        {
+            return maxPtDist;
+        }
+
+    private:
+        PointPairDistance maxPtDist;
+        PointPairDistance minPtDist;
+        DistanceToPoint euclideanDist;
+        const geom::Geometry& geom;
+
+        // Declare type as noncopyable
+        MaxPointDistanceFilter(const MaxPointDistanceFilter& other);
+        MaxPointDistanceFilter& operator=(const MaxPointDistanceFilter& rhs);
+    };
+
+    class MaxDensifiedByFractionDistanceFilter
+        : public geom::CoordinateSequenceFilter {
+    public:
+
+        MaxDensifiedByFractionDistanceFilter(
+            const geom::Geometry& p_geom, double fraction)
+            :
+            geom(p_geom),
+            // Validity of the cast to size_t has been verified in setDensifyFraction()
+            numSubSegs(std::size_t(util::round(1.0 / fraction)))
+        {
+        }
+
+        void filter_ro(const geom::CoordinateSequence& seq,
+                       std::size_t index) override;
+
+        bool
+        isGeometryChanged() const override
+        {
+            return false;
+        }
+
+        bool
+        isDone() const override
+        {
+            return false;
+        }
+
+        const PointPairDistance&
+        getMaxPointDistance() const
+        {
+            return maxPtDist;
+        }
+
+    private:
+        PointPairDistance maxPtDist;
+        PointPairDistance minPtDist;
+        const geom::Geometry& geom;
+        std::size_t numSubSegs; // = 0;
+
+        // Declare type as noncopyable
+        MaxDensifiedByFractionDistanceFilter(const MaxDensifiedByFractionDistanceFilter& other);
+        MaxDensifiedByFractionDistanceFilter& operator=(const MaxDensifiedByFractionDistanceFilter& rhs);
+    };
+
+private:
+
+    void
+    compute(const geom::Geometry& p_g0,
+            const geom::Geometry& p_g1)
+    {
+        computeOrientedDistance(p_g0, p_g1, ptDist);
+        computeOrientedDistance(p_g1, p_g0, ptDist);
+    }
+
+    void computeOrientedDistance(const geom::Geometry& discreteGeom,
+                                 const geom::Geometry& geom,
+                                 PointPairDistance& ptDist);
+
+    const geom::Geometry& g0;
+
+    const geom::Geometry& g1;
+
+    PointPairDistance ptDist;
+
+    /// Value of 0.0 indicates that no densification should take place
+    double densifyFrac; // = 0.0;
+
+    // Declare type as noncopyable
+    DiscreteHausdorffDistance(const DiscreteHausdorffDistance& other) = delete;
+    DiscreteHausdorffDistance& operator=(const DiscreteHausdorffDistance& rhs) = delete;
+};
+
+} // geos::algorithm::distance
+} // geos::algorithm
+} // geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/distance/DistanceToPoint.h

@@ -0,0 +1,72 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  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: algorithm/distance/DistanceToPoint.java 1.1 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/LineSegment.h> // for composition
+
+namespace geos {
+namespace algorithm {
+namespace distance {
+class PointPairDistance;
+}
+}
+namespace geom {
+class Geometry;
+class Coordinate;
+class LineString;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace distance { // geos::algorithm::distance
+
+/**
+ * Computes the Euclidean distance (L2 metric) from a Point to a Geometry.
+ *
+ * Also computes two points which are separated by the distance.
+ */
+class DistanceToPoint {
+public:
+
+    DistanceToPoint() {}
+
+    static void computeDistance(const geom::Geometry& geom,
+                                const geom::CoordinateXY& pt,
+                                PointPairDistance& ptDist);
+
+    static void computeDistance(const geom::LineString& geom,
+                                const geom::CoordinateXY& pt,
+                                PointPairDistance& ptDist);
+
+    static void computeDistance(const geom::LineSegment& geom,
+                                const geom::CoordinateXY& pt,
+                                PointPairDistance& ptDist);
+
+    static void computeDistance(const geom::Polygon& geom,
+                                const geom::CoordinateXY& pt,
+                                PointPairDistance& ptDist);
+
+};
+
+} // geos::algorithm::distance
+} // geos::algorithm
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/algorithm/distance/PointPairDistance.h

@@ -0,0 +1,151 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  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: algorithm/distance/PointPairDistance.java 1.1 (JTS-1.9)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/constants.h> // for DoubleNotANumber
+#include <geos/geom/Coordinate.h> // for inlines
+
+#include <array>
+#include <cassert>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+namespace distance { // geos::algorithm::distance
+
+/**
+ * Contains a pair of points and the distance between them.
+ * Provides methods to update with a new point pair with
+ * either maximum or minimum distance.
+ */
+class PointPairDistance {
+public:
+
+    PointPairDistance()
+        :
+        distanceSquared(DoubleNotANumber),
+        isNull(true)
+    {}
+
+    void
+    initialize()
+    {
+        isNull = true;
+    }
+
+    void
+    initialize(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        pt[0] = p0;
+        pt[1] = p1;
+        distanceSquared = p0.distanceSquared(p1);
+        isNull = false;
+    }
+
+    double
+    getDistance() const
+    {
+        return std::sqrt(distanceSquared);
+    }
+
+    const std::array<geom::CoordinateXY, 2>&
+    getCoordinates() const
+    {
+        return pt;
+    }
+
+    const geom::CoordinateXY&
+    getCoordinate(std::size_t i) const
+    {
+        assert(i < pt.size());
+        return pt[i];
+    }
+
+    void
+    setMaximum(const PointPairDistance& ptDist)
+    {
+        setMaximum(ptDist.pt[0], ptDist.pt[1]);
+    }
+
+    void
+    setMaximum(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        if(isNull) {
+            initialize(p0, p1);
+            return;
+        }
+        double distSq = p0.distanceSquared(p1);
+        if(distSq > distanceSquared) {
+            initialize(p0, p1, distSq);
+        }
+    }
+
+    void
+    setMinimum(const PointPairDistance& ptDist)
+    {
+        setMinimum(ptDist.pt[0], ptDist.pt[1]);
+    }
+
+    void
+    setMinimum(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1)
+    {
+        if(isNull) {
+            initialize(p0, p1);
+            return;
+        }
+        double distSq = p0.distanceSquared(p1);
+        if(distSq < distanceSquared) {
+            initialize(p0, p1, distSq);
+        }
+    }
+
+    bool
+    getIsNull()
+    {
+        return isNull;
+    }
+
+private:
+
+    /**
+     * Initializes the points, avoiding recomputing the distance.
+     * @param p0
+     * @param p1
+     * @param dist the distance between p0 and p1
+     */
+    void
+    initialize(const geom::CoordinateXY& p0, const geom::CoordinateXY& p1,
+               double distSquared)
+    {
+        pt[0] = p0;
+        pt[1] = p1;
+        distanceSquared = distSquared;
+        isNull = false;
+    }
+
+    std::array<geom::CoordinateXY, 2> pt;
+
+    double distanceSquared;
+
+    bool isNull;
+};
+
+} // geos::algorithm::distance
+} // geos::algorithm
+} // geos
+