@cpp.js/package-geos 1.0.0 → 2.0.0-beta.2

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

@@ -1,211 +0,0 @@
-/**********************************************************************
- *
- * 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

@@ -1,116 +0,0 @@
-/**********************************************************************
- *
- * 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

@@ -1,100 +0,0 @@
-/**********************************************************************
- *
- * 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

@@ -1,110 +0,0 @@
-/**********************************************************************
- *
- * 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

@@ -1,79 +0,0 @@
-/**********************************************************************
- *
- * 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

@@ -1,73 +0,0 @@
-/**********************************************************************
- *
- * 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
-
-