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

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

@@ -0,0 +1,211 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: algorithm/ConvexHull.java r407 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <memory>
+#include <vector>
+#include <cassert>
+
+// FIXME: avoid using Coordinate:: typedefs to avoid full include
+#include <geos/algorithm/ConvexHull.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/util/UniqueCoordinateArrayFilter.h>
+#include <geos/util/CoordinateArrayFilter.h>
+
+#include "geos/util.h"
+
+#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;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the convex hull of a Geometry.
+ *
+ * The convex hull is the smallest convex Geometry that contains all the
+ * points in the input Geometry.
+ *
+ * Uses the Graham Scan algorithm.
+ *
+ * Last port: algorithm/ConvexHull.java rev. 1.26 (JTS-1.7)
+ *
+ */
+class GEOS_DLL ConvexHull {
+private:
+
+    static constexpr std::size_t TUNING_REDUCE_SIZE = 50;
+
+    const geom::Geometry* inputGeom;
+    const geom::GeometryFactory* geomFactory;
+    geom::Coordinate::ConstVect inputPts;
+
+    /// Create a CoordinateSequence from the Coordinate::ConstVect
+    /// This is needed to construct the geometries.
+    /// Here coordinate copies happen
+    /// The returned object is newly allocated !NO EXCEPTION SAFE!
+    std::unique_ptr<geom::CoordinateSequence> toCoordinateSequence(geom::Coordinate::ConstVect& cv);
+
+    void computeInnerOctolateralPts(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
+
+    bool computeInnerOctolateralRing(
+        const geom::Coordinate::ConstVect& src,
+        geom::Coordinate::ConstVect& tgt);
+
+    /**
+     * Uses a heuristic to reduce the number of points scanned
+     * to compute the hull.
+     * The heuristic is to find a polygon guaranteed to
+     * be in (or on) the hull, and eliminate all points inside it.
+     * A quadrilateral defined by the extremal points
+     * in the four orthogonal directions
+     * can be used, but even more inclusive is
+     * to use an octilateral defined by the points in the
+     * 8 cardinal directions.
+     *
+     * Note that even if the method used to determine the polygon
+     * vertices is not 100% robust, this does not affect the
+     * robustness of the convex hull.
+     *
+     * To satisfy the requirements of the Graham Scan algorithm,
+     * the resulting array has at least 3 entries.
+     *
+     * @param pts The vector of const Coordinate pointers
+     *            to be reduced (to at least 3 elements)
+     *
+     * WARNING: the parameter will be modified
+     *
+     */
+    void reduce(geom::Coordinate::ConstVect& pts);
+
+    /// parameter will be modified
+    void padArray3(geom::Coordinate::ConstVect& pts);
+
+    /// parameter will be modified
+    void preSort(geom::Coordinate::ConstVect& pts);
+
+    /**
+     * Given two points p and q compare them with respect to their radial
+     * ordering about point o.  First checks radial ordering.
+     * If points are collinear, the comparison is based
+     * on their distance to the origin.
+     *
+     * p < q iff
+     *
+     * - ang(o-p) < ang(o-q) (e.g. o-p-q is CCW)
+     * - or ang(o-p) == ang(o-q) && dist(o,p) < dist(o,q)
+     *
+     * @param o the origin
+     * @param p a point
+     * @param q another point
+     * @return -1, 0 or 1 depending on whether p is less than,
+     * equal to or greater than q
+     */
+    int polarCompare(const geom::Coordinate& o,
+                     const geom::Coordinate& p,
+                     const geom::Coordinate& q);
+
+    void grahamScan(const geom::Coordinate::ConstVect& c,
+                    geom::Coordinate::ConstVect& ps);
+
+    /**
+     * @param  vertices  the vertices of a linear ring,
+     *                   which may or may not be
+     *                   flattened (i.e. vertices collinear)
+     *
+     * @return           a 2-vertex LineString if the vertices are
+     *                   collinear; otherwise, a Polygon with unnecessary
+     *                   (collinear) vertices removed
+     */
+    std::unique_ptr<geom::Geometry> lineOrPolygon(const geom::Coordinate::ConstVect& vertices);
+
+    /**
+     * Write in 'cleaned' a version of 'input' with collinear
+     * vertices removed.
+     */
+    void cleanRing(const geom::Coordinate::ConstVect& input,
+                   geom::Coordinate::ConstVect& cleaned);
+
+    /**
+     * @return  whether the three coordinates are collinear
+     *          and c2 lies between c1 and c3 inclusive
+     */
+    bool isBetween(
+        const geom::Coordinate& c1,
+        const geom::Coordinate& c2,
+        const geom::Coordinate& c3);
+
+    bool extractUnique(geom::Coordinate::ConstVect& pts, std::size_t maxPts);
+    std::unique_ptr<geom::Geometry> createFewPointsResult();
+
+
+
+public:
+
+    /**
+     * Create a new convex hull construction for the input Geometry.
+     */
+    ConvexHull(const geom::Geometry* newGeometry)
+        : inputGeom(newGeometry)
+        , geomFactory(newGeometry->getFactory())
+    {
+      util::ensureNoCurvedComponents(inputGeom);
+    };
+
+    ~ConvexHull() {};
+
+    /**
+     * Returns a Geometry that represents the convex hull of
+     * the input geometry.
+     * The returned geometry contains the minimal number of points
+     * needed to represent the convex hull.
+     * In particular, no more than two consecutive points
+     * will be collinear.
+     *
+     * @return if the convex hull contains 3 or more points,
+     *         a Polygon; 2 points, a LineString;
+     *         1 point, a Point; 0 points, an empty GeometryCollection.
+     */
+    std::unique_ptr<geom::Geometry> getConvexHull();
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+

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

@@ -0,0 +1,116 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2018 Paul Ramsey <pramsey@cleverlephant.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: algorithm/Distance.java @ 2017-09-04
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Functions to compute distance between basic geometric structures.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL Distance {
+public:
+
+    /**
+     * Computes the distance from a line segment AB to a line segment CD
+     *
+     * Note: NON-ROBUST!
+     *
+     * @param A
+     *          a point of one line
+     * @param B
+     *          the second point of (must be different to A)
+     * @param C
+     *          one point of the line
+     * @param D
+     *          another point of the line (must be different to A)
+     */
+    // formerly distanceLineLine
+    static double segmentToSegment(
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B,
+        const geom::CoordinateXY& C,
+        const geom::CoordinateXY& D);
+
+    /**
+    * Computes the distance from a point to a sequence of line segments.
+    *
+    * @param p
+    *          a point
+    * @param seq
+    *          a sequence of contiguous line segments defined by their vertices
+    * @return the minimum distance between the point and the line segments
+    */
+    static double pointToSegmentString(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateSequence* seq);
+
+    /**
+    * Computes the distance from a point p to a line segment AB
+    *
+    * Note: NON-ROBUST!
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line segment AB
+    */
+    // formerly distancePointLine
+    static double pointToSegment(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    /**
+    * Computes the perpendicular distance from a point p to the (infinite) line
+    * containing the points AB
+    *
+    * @param p
+    *          the point to compute the distance for
+    * @param A
+    *          one point of the line
+    * @param B
+    *          another point of the line (must be different to A)
+    * @return the distance from p to line AB
+    */
+    // formerly distancePointLinePerpendicular
+    static double pointToLinePerpendicular(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+
+    static double pointToLinePerpendicularSigned(
+        const geom::CoordinateXY& p,
+        const geom::CoordinateXY& A,
+        const geom::CoordinateXY& B);
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,100 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2011      Sandro Santilli <strk@kbt.io>
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: algorithm/HCoordinate.java r386 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <iosfwd>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/** \brief
+ * Represents a homogeneous coordinate in a 2-D coordinate space.
+ *
+ * HCoordinate are used as a clean way
+ * of computing intersections between line segments.
+ */
+class GEOS_DLL HCoordinate {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+    /** \brief
+     * Computes the (approximate) intersection point between two line
+     * segments using homogeneous coordinates.
+     *
+     * @note this algorithm is  not numerically stable; i.e. it can
+     * produce intersection points which lie outside the envelope of the
+     * line segments themselves. In order to increase the precision of
+     * the calculation input points should be normalized before
+     * passing them to this routine.
+     */
+    static void intersection(const geom::Coordinate& p1,
+                             const geom::Coordinate& p2,
+                             const geom::Coordinate& q1,
+                             const geom::Coordinate& q2,
+                             geom::Coordinate& ret);
+
+    double x, y, w;
+
+    HCoordinate();
+
+    HCoordinate(double _x, double _y, double _w);
+
+    HCoordinate(const geom::Coordinate& p);
+
+    /** \brief
+     * Constructs a homogeneous coordinate which is the intersection
+     * of the lines define by the homogeneous coordinates represented
+     * by two [Coordinates](@ref geom::Coordinate).
+     *
+     * @param p1
+     * @param p2
+     */
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2);
+
+    HCoordinate(const geom::Coordinate& p1, const geom::Coordinate& p2,
+                const geom::Coordinate& q1, const geom::Coordinate& q2);
+
+    HCoordinate(const HCoordinate& p1, const HCoordinate& p2);
+
+    double getX() const;
+
+    double getY() const;
+
+    void getCoordinate(geom::Coordinate& ret) const;
+
+};
+
+std::ostream& operator<< (std::ostream& o, const HCoordinate& c);
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,110 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Martin Davis <mtnclimb@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: algorithm/InteriorPointArea.java (JTS-1.17+)
+ * https://github.com/locationtech/jts/commit/a140ca30cc51be4f65c950a30b0a8f51a6df75ba
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class Polygon;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an areal geometry.
+ * The point will lie in the geometry interior
+ * in all except certain pathological cases.
+ *
+ * <h2>Algorithm</h2>
+ * For each input polygon:
+ * <ul>
+ * <li>Determine a horizontal scan line on which the interior
+ * point will be located.
+ * To increase the chance of the scan line
+ * having non-zero-width intersection with the polygon
+ * the scan line Y ordinate is chosen to be near the centre of the polygon's
+ * Y extent but distinct from all of vertex Y ordinates.
+ * <li>Compute the sections of the scan line
+ * which lie in the interior of the polygon.
+ * <li>Choose the widest interior section
+ * and take its midpoint as the interior point.
+ * </ul>
+ * The final interior point is chosen as
+ * the one occurring in the widest interior section.
+ * <p>
+ * This algorithm is a tradeoff between performance
+ * and point quality (where points further from the geometry
+ * boundary are considered to be higher quality)
+ * Priority is given to performance.
+ * This means that the computed interior point
+ * may not be suitable for some uses
+ * (such as label positioning).
+ * <p>
+ * The algorithm handles some kinds of invalid/degenerate geometry,
+ * including zero-area and self-intersecting polygons.
+ * <p>
+ * Empty geometry is handled by returning a <code>null</code> point.
+ *
+ * <h3>KNOWN BUGS</h3>
+ * <ul>
+ * <li>If a fixed precision model is used, in some cases this method may return
+ * a point which does not lie in the interior.
+ * <li>If the input polygon is <i>extremely</i> narrow the computed point
+ * may not lie in the interior of the polygon.
+ * </ul>
+ */
+class GEOS_DLL InteriorPointArea {
+
+public:
+    /**
+     * Creates a new interior point finder
+     * for an areal geometry.
+     *
+     * @param g an areal geometry
+     */
+    InteriorPointArea(const geom::Geometry* g);
+
+    /**
+     * Gets the computed interior point.
+     *
+     * @return the coordinate of an interior point
+     *  or <code>null</code> if the input geometry is empty
+     */
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+    geom::Coordinate interiorPoint;
+    double maxWidth;
+
+    void process(const geom::Geometry* geom);
+
+    void processPolygon(const geom::Polygon* polygon);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,79 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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: algorithm/InteriorPointLine.java r317 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes a point in the interior of an linear geometry.
+ *
+ * <h2>Algorithm</h2>
+ *
+ * - Find an interior vertex which is closest to
+ *   the centroid of the linestring.
+ * - If there is no interior vertex, find the endpoint which is
+ *   closest to the centroid.
+ */
+class GEOS_DLL InteriorPointLine {
+public:
+
+    InteriorPointLine(const geom::Geometry* g);
+    //Coordinate* getInteriorPoint() const;
+
+    bool getInteriorPoint(geom::Coordinate& ret) const;
+
+private:
+
+    bool hasInterior;
+
+    geom::Coordinate centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    void addInterior(const geom::Geometry* geom);
+
+    void addInterior(const geom::CoordinateSequence* pts);
+
+    void addEndpoints(const geom::Geometry* geom);
+
+    void addEndpoints(const geom::CoordinateSequence* pts);
+
+    void add(const geom::Coordinate& point);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,73 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2005-2006 Refractions Research Inc.
+ * Copyright (C) 2001-2002 Vivid Solutions 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class InteriorPointPoint
+ * \brief
+ * Computes a point in the interior of an point geometry.
+ *
+ * Algorithm:
+ *
+ * Find a point which is closest to the centroid of the geometry.
+ */
+class GEOS_DLL InteriorPointPoint {
+private:
+
+    bool hasInterior;
+
+    geom::CoordinateXY centroid;
+
+    double minDistance;
+
+    geom::Coordinate interiorPoint;
+
+    /**
+     * Tests the point(s) defined by a Geometry for the best inside point.
+     * If a Geometry is not of dimension 0 it is not tested.
+     * @param geom the geometry to add
+     */
+    void add(const geom::Geometry* geom);
+
+    void add(const geom::CoordinateXY* point);
+
+public:
+
+    InteriorPointPoint(const geom::Geometry* g);
+
+    ~InteriorPointPoint() {}
+
+    bool getInteriorPoint(geom::CoordinateXY& ret) const;
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+