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

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

@@ -0,0 +1,159 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <vector>
+#include <memory>
+
+// Forward declarations
+namespace geos {
+	namespace geom {
+        class CoordinateSequence;
+        class CoordinateXY;
+        class Geometry;
+        class GeometryFactory;
+        class LineSegment;
+        class LineString;
+        class Polygon;
+	}
+}
+
+using geos::geom::CoordinateSequence;
+using geos::geom::CoordinateXY;
+using geos::geom::Geometry;
+using geos::geom::GeometryFactory;
+using geos::geom::LineSegment;
+using geos::geom::LineString;
+using geos::geom::Polygon;
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+
+/**
+ * Computes the minimum-area rectangle enclosing a Geometry.
+ * Unlike the Envelope, the rectangle may not be axis-parallel.
+ *
+ * The first step in the algorithm is computing the convex hull of the Geometry.
+ * If the input Geometry is known to be convex, a hint can be supplied to
+ * avoid this computation.
+ *
+ * In degenerate cases the minimum enclosing geometry
+ * may be a LineString or a Point.
+ *
+ * The minimum-area enclosing rectangle does not necessarily
+ * have the minimum possible width.
+ * Use MinimumDiameter to compute this.
+ *
+ * @see MinimumDiameter
+ * @see ConvexHull
+ *
+ */
+class GEOS_DLL MinimumAreaRectangle {
+
+private:
+
+    // Members
+    const Geometry* m_inputGeom;
+    bool m_isConvex;
+
+    // Methods
+    std::unique_ptr<Geometry> getMinimumRectangle();
+
+    std::unique_ptr<Geometry> computeConvex(const Geometry* convexGeom);
+
+    /**
+    * Computes the minimum-area rectangle for a convex ring of Coordinate.
+    *
+    * This algorithm uses the "dual rotating calipers" technique.
+    * Performance is linear in the number of segments.
+    *
+    * @param ring the convex ring to scan
+    */
+    std::unique_ptr<Polygon> computeConvexRing(const CoordinateSequence* ring);
+
+    std::size_t findFurthestVertex(
+        const CoordinateSequence* pts,
+        const LineSegment& baseSeg,
+        std::size_t startIndex,
+        int orient);
+
+    bool isFurtherOrEqual(double d1, double d2, int orient);
+
+    static double orientedDistance(
+        const LineSegment& seg,
+        const CoordinateXY& p,
+        int orient);
+
+    static std::size_t getNextIndex(
+        const CoordinateSequence* ring,
+        std::size_t index);
+
+    /**
+    * Creates a line of maximum extent from the provided vertices
+    * @param pts the vertices
+    * @param factory the geometry factory
+    * @return the line of maximum extent
+    */
+    static std::unique_ptr<LineString> computeMaximumLine(
+        const CoordinateSequence* pts,
+        const GeometryFactory* factory);
+
+
+public:
+
+    /**
+    * Compute a minimum-area rectangle for a given Geometry.
+    *
+    * @param inputGeom a Geometry
+    */
+    MinimumAreaRectangle(const Geometry* inputGeom)
+        : m_inputGeom(inputGeom)
+        , m_isConvex(false)
+        {};
+
+    /**
+    * Compute a minimum rectangle for a Geometry,
+    * with a hint if the geometry is convex
+    * (e.g. a convex Polygon or LinearRing,
+    * or a two-point LineString, or a Point).
+    *
+    * @param inputGeom a Geometry which is convex
+    * @param isConvex true if the input geometry is convex
+    */
+    MinimumAreaRectangle(const Geometry* inputGeom, bool isConvex)
+        : m_inputGeom(inputGeom)
+        , m_isConvex(isConvex)
+        {};
+
+    /**
+    * Gets the minimum-area rectangular Polygon which encloses the input geometry.
+    * If the convex hull of the input is degenerate (a line or point)
+    * a LineString or Point is returned.
+    *
+    * @param geom the geometry
+    * @return the minimum rectangle enclosing the geometry
+    */
+    static std::unique_ptr<Geometry> getMinimumRectangle(const Geometry* geom);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,137 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2019 Paul Ramsey <pramsey@cleverelephant.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/MinimumBoundingCircle.java 2019-01-23
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/Point.h>
+#include <geos/geom/Triangle.h>
+
+#include <vector>
+
+// Forward declarations
+// namespace geos {
+// 	namespace geom {
+// 		class GeometryCollection;
+// 	}
+// }
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+class GEOS_DLL MinimumBoundingCircle {
+
+private:
+
+    // member variables
+    const geom::Geometry* input;
+    std::vector<geom::CoordinateXY> extremalPts;
+    geom::CoordinateXY centre;
+    double radius;
+
+    void computeCentre();
+    void compute();
+    void computeCirclePoints();
+    geom::CoordinateXY lowestPoint(std::vector<geom::CoordinateXY>& pts);
+    geom::CoordinateXY pointWitMinAngleWithX(std::vector<geom::CoordinateXY>& pts, geom::CoordinateXY& P);
+    geom::CoordinateXY pointWithMinAngleWithSegment(std::vector<geom::CoordinateXY>& pts,
+            geom::CoordinateXY& P, geom::CoordinateXY& Q);
+    std::vector<geom::CoordinateXY> farthestPoints(std::vector<geom::CoordinateXY>& pts);
+
+
+public:
+
+    MinimumBoundingCircle(const geom::Geometry* geom):
+        input(nullptr),
+        radius(0.0)
+    {
+        input = geom;
+        centre.setNull();
+    }
+
+    ~MinimumBoundingCircle() {};
+
+    /**
+    * Gets a geometry which represents the Minimum Bounding Circle.
+    * If the input is degenerate (empty or a single unique point),
+    * this method will return an empty geometry or a single Point geometry.
+    * Otherwise, a Polygon will be returned which approximates the
+    * Minimum Bounding Circle.
+    * (Note that because the computed polygon is only an approximation,
+    * it may not precisely contain all the input points.)
+    *
+    * @return a Geometry representing the Minimum Bounding Circle.
+    */
+    std::unique_ptr<geom::Geometry> getCircle();
+
+    /**
+    * Gets a geometry representing a line between the two farthest points
+    * in the input.
+    * These points will be two of the extremal points of the Minimum Bounding Circle.
+    * They also lie on the convex hull of the input.
+    *
+    * @return a LineString between the two farthest points of the input
+    * @return a empty LineString if the input is empty
+    * @return a Point if the input is a point
+    */
+    std::unique_ptr<geom::Geometry> getMaximumDiameter();
+
+    /**
+    * Gets a geometry representing the diameter of the computed Minimum Bounding
+    * Circle.
+    *
+    * @return the diameter LineString of the Minimum Bounding Circle
+    * @return a empty LineString if the input is empty
+    * @return a Point if the input is a point
+    */
+    std::unique_ptr<geom::Geometry> getDiameter();
+
+    /**
+    * Gets the extremal points which define the computed Minimum Bounding Circle.
+    * There may be zero, one, two or three of these points,
+    * depending on the number of points in the input
+    * and the geometry of those points.
+    *
+    * @return the points defining the Minimum Bounding Circle
+    */
+    std::vector<geom::CoordinateXY> getExtremalPoints();
+
+    /**
+    * Gets the centre point of the computed Minimum Bounding Circle.
+    *
+    * @return the centre point of the Minimum Bounding Circle
+    * @return null if the input is empty
+    */
+    geom::CoordinateXY getCentre();
+
+    /**
+    * Gets the radius of the computed Minimum Bounding Circle.
+    *
+    * @return the radius of the Minimum Bounding Circle
+    */
+    double getRadius();
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,185 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2023 Paul Ramsey <pramsey@cleverelephant.ca>
+ * 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/geom/Coordinate.h>
+#include <geos/geom/LineSegment.h>
+
+#include <memory>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class GeometryFactory;
+class Geometry;
+class LineString;
+class CoordinateSequence;
+}
+}
+
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/** \brief
+ * Computes the minimum diameter of a geom::Geometry
+ *
+ * The minimum diameter is defined to be the width of the smallest band that
+ * contains the geometry, where a band is a strip of the plane defined
+ * by two parallel lines. This can be thought of as the smallest hole
+ * that the geometry can be moved through, with a single rotation.
+ *
+ * The first step in the algorithm is computing the convex hull of the Geometry.
+ * If the input Geometry is known to be convex, a hint can be supplied to
+ * avoid this computation.
+ *
+ * This class can also be used to compute a line segment representing
+ * the minimum diameter, the supporting line segment of the minimum diameter,
+ * and a minimum-width rectangle of the input geometry.
+ * This rectangle will have width equal to the minimum diameter, and have
+ * one side parallel to the supporting segment.
+ *
+ * In degenerate cases the rectangle may be a LineString or a Point.
+ * (Note that this may not be the enclosing rectangle with minimum area;
+ * use MinimumAreaRectangle to compute this.)
+ *
+ * @see ConvexHull
+ * @see MinimumAreaRectangle
+ */
+class GEOS_DLL MinimumDiameter {
+private:
+    const geom::Geometry* inputGeom;
+    bool isConvex;
+
+    std::unique_ptr<geom::CoordinateSequence> convexHullPts;
+
+    geom::LineSegment minBaseSeg;
+    geom::Coordinate minWidthPt;
+    std::size_t minPtIndex;
+    double minWidth;
+    void computeMinimumDiameter();
+    void computeWidthConvex(const geom::Geometry* geom);
+
+    /**
+     * Compute the width information for a ring of Coordinate.
+     * Leaves the width information in the instance variables.
+     *
+     * @param pts
+     * @return
+     */
+    void computeConvexRingMinDiameter(const geom::CoordinateSequence* pts);
+
+    unsigned int findMaxPerpDistance(const geom::CoordinateSequence* pts,
+                                     const geom::LineSegment* seg, unsigned int startIndex);
+
+    static unsigned int getNextIndex(const geom::CoordinateSequence* pts,
+                                     unsigned int index);
+
+    static double computeC(double a, double b, const geom::Coordinate& p);
+
+    static geom::LineSegment computeSegmentForLine(double a, double b, double c);
+
+    static std::unique_ptr<geom::Geometry> computeMaximumLine(
+                        const geom::CoordinateSequence* pts,
+                        const geom::GeometryFactory* factory);
+
+public:
+    ~MinimumDiameter() = default;
+
+    /** \brief
+     * Compute a minimum diameter for a given [Geometry](@ref geom::Geometry).
+     *
+     * @param newInputGeom a Geometry
+     */
+    MinimumDiameter(const geom::Geometry* newInputGeom);
+
+    /** \brief
+     * Compute a minimum diameter for a given Geometry,
+     * with a hint if the Geometry is convex
+     * (e.g. a convex Polygon or LinearRing,
+     * or a two-point LineString, or a Point).
+     *
+     * @param newInputGeom a Geometry which is convex
+     * @param newIsConvex `true` if the input geometry is convex
+     */
+    MinimumDiameter(const geom::Geometry* newInputGeom,
+                    const bool newIsConvex);
+
+    /** \brief
+     * Gets the length of the minimum diameter of the input Geometry.
+     *
+     * @return the length of the minimum diameter
+     */
+    double getLength();
+
+    /** \brief
+     * Gets the geom::Coordinate forming one end of the minimum diameter.
+     *
+     * @return a coordinate forming one end of the minimum diameter
+     */
+    const geom::Coordinate& getWidthCoordinate();
+
+    /** \brief
+     * Gets the segment forming the base of the minimum diameter.
+     *
+     * @return the segment forming the base of the minimum diameter
+     */
+    std::unique_ptr<geom::LineString> getSupportingSegment();
+
+    /** \brief
+     * Gets a LineString which is a minimum diameter.
+     *
+     * @return a LineString which is a minimum diameter
+     */
+    std::unique_ptr<geom::LineString> getDiameter();
+
+    /** \brief
+     * Gets the rectangular Polygon which encloses the input geometry
+     * and is based on the minimum diameter supporting segment.
+     *
+     * The rectangle has width equal to the minimum diameter, and a longer
+     * length. If the convex hill of the input is degenerate (a line or point)
+     * a LineString or Point is returned.
+     * This is not necessarily the rectangle with minimum area.
+     * Use MinimumAreaRectangle to compute this.
+     *
+     * @return the the minimum-width rectangle enclosing the geometry
+     * @see MinimumAreaRectangle
+     */
+    std::unique_ptr<geom::Geometry> getMinimumRectangle();
+
+    /** \brief
+     * Gets the minimum rectangle enclosing a geometry.
+     *
+     * @param geom the geometry
+     * @return a rectangle enclosing the input (or a line or point if degenerate)
+     * @see MinimumAreaRectangle
+    */
+    static std::unique_ptr<geom::Geometry> getMinimumRectangle(geom::Geometry* geom);
+
+    /** \brief
+     * Gets the length of the minimum diameter enclosing a geometry.
+     * @param geom the geometry
+     * @return the length of the minimum diameter of the geometry
+     */
+    static std::unique_ptr<geom::Geometry> getMinimumDiameter(geom::Geometry* geom);
+
+};
+
+} // namespace geos::algorithm
+} // namespace geos

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

@@ -0,0 +1,43 @@
+/**********************************************************************
+ *
+ * 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 <string>
+#include <geos/util/GEOSException.h>
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+/**
+ * \class NotRepresentableException
+ * \brief
+ * Indicates that a HCoordinate has been computed which is
+ * not representable on the Cartesian plane.
+ *
+ * @version 1.4
+ * @see HCoordinate
+ */
+class GEOS_DLL NotRepresentableException: public util::GEOSException {
+public:
+    NotRepresentableException();
+    NotRepresentableException(std::string msg);
+    ~NotRepresentableException() noexcept override {}
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,122 @@
+/**********************************************************************
+ *
+ * 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/Orientation.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 the orientation of basic geometric structures
+ * including point triplets (triangles) and rings.
+ *
+ * Orientation is a fundamental property of planar geometries
+ * (and more generally geometry on two-dimensional manifolds).
+ *
+ * Orientation is notoriously subject to numerical precision errors
+ * in the case of collinear or nearly collinear points.
+ * JTS uses extended-precision arithmetic to increase
+ * the robustness of the computation.
+ *
+ * @author Martin Davis
+ */
+class GEOS_DLL Orientation {
+public:
+
+    /* A value that indicates an orientation or turn */
+    enum {
+        CLOCKWISE = -1,
+        COLLINEAR = 0,
+        COUNTERCLOCKWISE = 1,
+        RIGHT = -1,
+        LEFT = 1,
+        STRAIGHT = 0
+    };
+
+    /** \brief
+     * Returns the orientation index of the direction of the point q relative to
+     * a directed infinite line specified by p1-p2.
+     *
+     * The index indicates whether the point lies to the
+     * `Orientation::LEFT` or `Orientation::RIGHT`
+     * of the line, or lies on it `Orientation::COLLINEAR`.
+     * The index also indicates the orientation of the triangle formed
+     * by the three points
+     * ( `Orientation::COUNTERCLOCKWISE`,
+     * `Orientation::CLOCKWISE`, or `Orientation::STRAIGHT` )
+     */
+    static int index(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
+                     const geom::CoordinateXY& q);
+
+    /**
+    * Computes whether a ring defined by a geom::CoordinateSequence is
+    * oriented counter-clockwise.
+    *
+    *  * The list of points is assumed to have the first and last points equal.
+    *  * This handles coordinate lists which contain repeated points.
+    *  * This handles rings which contain collapsed segments
+    *    (in particular, along the top of the ring).
+    *
+    * This algorithm is guaranteed to work with valid rings.
+    * It also works with "mildly invalid" rings
+    * which contain collapsed (coincident) flat segments along the top of the ring.
+    * If the ring is "more" invalid (e.g. self-crosses or touches),
+    * the computed result may not be correct.
+    *
+    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
+    * @return true if the ring is oriented counter-clockwise.
+    * @throws IllegalArgumentException if there are too few points to determine orientation (< 4)
+    */
+    static bool isCCW(const geom::CoordinateSequence* ring);
+
+    /**
+    * Tests if a ring defined by a CoordinateSequence is
+    * oriented counter-clockwise, using the signed area of the ring.
+    *
+    *  * The list of points is assumed to have the first and last points equal.
+    *  * This handles coordinate lists which contain repeated points.
+    *  * This handles rings which contain collapsed segments
+    *    (in particular, along the top of the ring).
+    *  * This handles rings which are invalid due to self-intersection
+    *
+    * This algorithm is guaranteed to work with valid rings.
+    * For invalid rings (containing self-intersections),
+    * the algorithm determines the orientation of
+    * the largest enclosed area (including overlaps).
+    * This provides a more useful result in some situations, such as buffering.
+    *
+    * However, this approach may be less accurate in the case of
+    * rings with almost zero area.
+    * (Note that the orientation of rings with zero area is essentially
+    * undefined, and hence non-deterministic.)
+    *
+    * @param ring a CoordinateSequence forming a ring (with first and last point identical)
+    * @return true if the ring is oriented counter-clockwise.
+    */
+    static bool isCCWArea(const geom::CoordinateSequence* ring);
+
+};
+
+
+} // namespace geos::algorithm
+} // namespace geos
+

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

@@ -0,0 +1,40 @@
+/**********************************************************************
+ *
+ * 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>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+namespace geos {
+namespace algorithm { // geos::algorithm
+
+class GEOS_DLL PointInRing {
+public:
+    virtual
+    ~PointInRing() {}
+    virtual bool isInside(const geom::Coordinate& pt) = 0;
+};
+
+} // namespace geos::algorithm
+} // namespace geos
+
+