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

package/dist/prebuilt/Android-x86_64/include/geos/geom/Triangle.h

@@ -0,0 +1,230 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+
+namespace geos {
+namespace geom { // geos::geom
+
+/**
+ * \brief
+ * Represents a planar triangle, and provides methods for calculating various
+ * properties of triangles.
+ */
+class GEOS_DLL Triangle {
+public:
+    CoordinateXY p0, p1, p2;
+
+    Triangle(const CoordinateXY& nP0, const CoordinateXY& nP1, const CoordinateXY& nP2)
+        : p0(nP0)
+        , p1(nP1)
+        , p2(nP2) {}
+
+
+    /** \brief
+     * The inCentre of a triangle is the point which is equidistant
+     * from the sides of the triangle.
+     *
+     * This is also the point at which the bisectors of the angles meet.
+     *
+     * @param resultPoint the point into which to write the inCentre of the triangle
+     */
+    void inCentre(CoordinateXY& resultPoint);
+
+    /** \brief
+     * Computes the circumcentre of a triangle.
+     *
+     * The circumcentre is the centre of the circumcircle, the smallest circle
+     * which encloses the triangle. It is also the common intersection point of
+     * the perpendicular bisectors of the sides of the triangle, and is the only
+     * point which has equal distance to all three vertices of the triangle.
+     *
+     * The circumcentre does not necessarily lie within the triangle. For example,
+     * the circumcentre of an obtuse isoceles triangle lies outside the triangle.
+     *
+     * This method uses an algorithm due to J.R.Shewchuk which uses normalization
+     * to the origin to improve the accuracy of computation. (See *Lecture Notes
+     * on Geometric Robustness*, Jonathan Richard Shewchuk, 1999).
+     *
+     * @param resultPoint the point into which to write the inCentre of the triangle
+     */
+    void circumcentre(CoordinateXY& resultPoint);
+
+    /** Calculates the circumcentre using double precision math
+     * @param resultPoint the point into which to write the inCentre of the triangle
+     */
+    void circumcentreDD(CoordinateXY& resultPoint);
+
+    /** Computes the circumcentre of a triangle. The circumcentre is the centre
+     * of the circumcircle, the smallest circle which passes through all the triangle vertices.
+     * It is also the common intersection point of the perpendicular bisectors of the
+     * @param p0 corner of the triangle
+     * @param p1  corner of the triangle
+     * @param p2 corner of the triangle
+     * @return the center of the the smallest circle that encloses the triangle
+     */
+    static const CoordinateXY circumcentre(const CoordinateXY& p0, const CoordinateXY& p1, const CoordinateXY& p2);
+
+    /**
+    * Computes the radius of the circumcircle of a triangle.
+    * Formula is as per https://math.stackexchange.com/a/3610959
+    *
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @return the circumradius of the triangle
+    */
+    static double circumradius(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c);
+
+    /**
+    * Computes the radius of the circumcircle of a triangle.
+    *
+    * @return the triangle circumradius
+    */
+    double circumradius() const
+    {
+        return circumradius(p0, p1, p2);
+    };
+
+    bool isIsoceles();
+
+    /**
+    * Tests whether a triangle is acute. A triangle is acute if all interior
+    * angles are acute. This is a strict test - right triangles will return
+    * <tt>false</tt>. A triangle which is not acute is either right or obtuse.
+    * <p>
+    * Note: this implementation is not robust for angles very close to 90
+    * degrees.
+    *
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @return true if the triangle is acute
+    */
+    static bool isAcute(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c);
+
+    /**
+    * Tests whether a triangle is oriented counter-clockwise.
+    *
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @return true if the triangle orientation is counter-clockwise
+    */
+    static bool isCCW(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c);
+
+
+    /**
+    * Tests whether a triangle intersects a point.
+    *
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @param p the point to test
+    * @return true if the triangle intersects the point
+    */
+    static bool intersects(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c,
+        const CoordinateXY& p);
+
+
+    /**
+    * Tests whether a triangle intersects a point.
+    * @param p the point to test
+    * @return true if the triangle intersects the point
+    */
+    bool intersects(const CoordinateXY& p) { return intersects(p0, p1, p2, p); };
+
+    /**
+    * Tests whether this triangle is oriented counter-clockwise.
+    * @return true if the triangle orientation is counter-clockwise
+    */
+    bool isCCW() { return isCCW(p0, p1, p2); };
+
+    /**
+    * Tests whether this triangle is acute.
+    * @return true if this triangle is acute
+    */
+    bool isAcute() { return isAcute(p0, p1, p2); };
+
+    /**
+    * Computes the length of the longest side of a triangle
+    *
+    * @param a  a vertex of the triangle
+    * @param b  a vertex of the triangle
+    * @param c  a vertex of the triangle
+    * @return the length of the longest side of the triangle
+    */
+    static double longestSideLength(
+        const CoordinateXY& a,
+        const CoordinateXY& b,
+        const CoordinateXY& c);
+
+    /**
+    * Compute the length of the perimeter of a triangle
+    *
+    * @param a a vertex of the triangle
+    * @param b a vertex of the triangle
+    * @param c a vertex of the triangle
+    * @return the length of the triangle perimeter
+    */
+    static double length(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c);
+
+    /**
+    * Computes the length of the perimeter of this triangle.
+    *
+    * @return the length of the perimeter
+    */
+    double length() const;
+
+    /**
+    * Computes the 2D area of a triangle. The area value is always non-negative.
+    *
+    * @param a vertex of the triangle
+    * @param b vertex of the triangle
+    * @param c vertex of the triangle
+    * @return the area of the triangle
+    *
+    */
+    static double area(const CoordinateXY& a, const CoordinateXY& b, const CoordinateXY& c);
+
+    double area() const;
+
+private:
+
+    /**
+     * Computes the determinant of a 2x2 matrix. Uses standard double-precision
+     * arithmetic, so is susceptible to round-off error.
+     *
+     * @param m00
+     *          the [0,0] entry of the matrix
+     * @param m01
+     *          the [0,1] entry of the matrix
+     * @param m10
+     *          the [1,0] entry of the matrix
+     * @param m11
+     *          the [1,1] entry of the matrix
+     * @return the determinant
+     */
+    double det(double m00, double m01, double m10, double m11) const;
+
+};
+
+
+
+} // namespace geos::geom
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/AbstractPreparedPolygonContains.h

@@ -0,0 +1,144 @@
+/**********************************************************************
+ *
+ * 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: geom/prep/AbstractPreparedPolygonContains.java r388 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedPolygonPredicate.h> // inherited
+
+
+// forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+
+namespace prep {
+class PreparedPolygon;
+}
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+/**
+ * \brief
+ * A base class containing the logic for computes the <tt>contains</tt>
+ * and <tt>covers</tt> spatial relationship predicates
+ * for a {@link PreparedPolygon} relative to all other {@link Geometry} classes.
+ *
+ * Uses short-circuit tests and indexing to improve performance.
+ *
+ * Contains and covers are very similar, and differ only in how certain
+ * cases along the boundary are handled.  These cases require
+ * full topological evaluation to handle, so all the code in
+ * this class is common to both predicates.
+ *
+ * It is not possible to short-circuit in all cases, in particular
+ * in the case where line segments of the test geometry touches the polygon
+ * linework.
+ * In this case full topology must be computed.
+ * (However, if the test geometry consists of only points, this
+ * <i>can</i> be evaluated in an optimized fashion.
+ *
+ * @author Martin Davis
+ *
+ */
+class AbstractPreparedPolygonContains : public PreparedPolygonPredicate {
+private:
+    // information about geometric situation
+    bool hasSegmentIntersection;
+    bool hasProperIntersection;
+    bool hasNonProperIntersection;
+
+    bool isProperIntersectionImpliesNotContainedSituation(const geom::Geometry* testGeom);
+
+    /**
+     * Tests whether a geometry consists of a single polygon with no holes.
+     *
+     * @return true if the geometry is a single polygon with no holes
+     */
+    bool isSingleShell(const geom::Geometry& geom);
+
+    void findAndClassifyIntersections(const geom::Geometry* geom);
+
+protected:
+    /**
+     * This flag controls a difference between contains and covers.
+     *
+     * For contains the value is true.
+     * For covers the value is false.
+     */
+    bool requireSomePointInInterior;
+
+    /**
+     * Evaluate the <tt>contains</tt> or <tt>covers</tt> relationship
+     * for the given geometry.
+     *
+     * @param geom the test geometry
+     * @return true if the test geometry is contained
+     */
+    bool eval(const geom::Geometry* geom);
+
+    /**
+     * Evaluate the <tt>contains</tt> or <tt>covers</tt> relationship
+     * for the given Puntal geometry.
+     *
+     * @param geom the test geometry
+     * @param outermostLoc outermost Location of all points in geom
+     * @return true if the test geometry is contained/covered in the target
+     */
+    bool evalPointTestGeom(const geom::Geometry* geom, geom::Location outermostLoc);
+
+    /**
+     * Computes the full topological predicate.
+     * Used when short-circuit tests are not conclusive.
+     *
+     * @param geom the test geometry
+     * @return true if this prepared polygon has the relationship with the test geometry
+     */
+    virtual bool fullTopologicalPredicate(const geom::Geometry* geom) = 0;
+
+public:
+    AbstractPreparedPolygonContains(const PreparedPolygon* const p_prepPoly)
+        :	PreparedPolygonPredicate(p_prepPoly),
+          hasSegmentIntersection(false),
+          hasProperIntersection(false),
+          hasNonProperIntersection(false),
+          requireSomePointInInterior(true)
+    { }
+
+    AbstractPreparedPolygonContains(const PreparedPolygon* const p_prepPoly, bool p_requireSomePointInInterior)
+        :	PreparedPolygonPredicate(p_prepPoly),
+          hasSegmentIntersection(false),
+          hasProperIntersection(false),
+          hasNonProperIntersection(false),
+          requireSomePointInInterior(p_requireSomePointInInterior)
+    { }
+
+    ~AbstractPreparedPolygonContains() override
+    { }
+
+};
+
+} // geos::geom::prep
+} // geos::geom
+} // geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geom/prep/BasicPreparedGeometry.h

@@ -0,0 +1,214 @@
+/**********************************************************************
+ *
+ * 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: geom/prep/BasicPreparedGeometry.java rev. 1.5 (JTS-1.10)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/geom/prep/PreparedGeometry.h> // for inheritance
+#include <geos/geom/Coordinate.h>
+#include <geos/operation/relateng/RelateNG.h>
+
+#include <vector>
+#include <string>
+
+namespace geos {
+namespace geom {
+class Geometry;
+class Coordinate;
+}
+}
+
+
+namespace geos {
+namespace geom { // geos::geom
+namespace prep { // geos::geom::prep
+
+using geos::operation::relateng::RelateNG;
+
+// * \class BasicPreparedGeometry
+
+/**
+ *
+ * \brief
+ * A base class for {@link PreparedGeometry} subclasses.
+ *
+ * Contains default implementations for methods, which simply delegate
+ * to the equivalent {@link Geometry} methods.
+ * This class may be used as a "no-op" class for Geometry types
+ * which do not have a corresponding {@link PreparedGeometry} implementation.
+ *
+ * @author Martin Davis
+ *
+ */
+class BasicPreparedGeometry: public PreparedGeometry {
+private:
+    const geom::Geometry* baseGeom;
+    std::vector<const CoordinateXY*> representativePts;
+    mutable std::unique_ptr<RelateNG> relate_ng;
+
+    RelateNG& getRelateNG() const
+    {
+        if (relate_ng == nullptr)
+            relate_ng = RelateNG::prepare(baseGeom);
+
+        return *relate_ng;
+    }
+
+protected:
+    /**
+     * Sets the original {@link Geometry} which will be prepared.
+     */
+    void setGeometry(const geom::Geometry* geom);
+
+    /**
+     * Determines whether a Geometry g interacts with
+     * this geometry by testing the geometry envelopes.
+     *
+     * @param g a Geometry
+     * @return true if the envelopes intersect
+     */
+    bool envelopesIntersect(const geom::Geometry* g) const;
+
+    /**
+     * Determines whether the envelope of
+     * this geometry covers the Geometry g.
+     *
+     *
+     * @param g a Geometry
+     * @return true if g is contained in this envelope
+     */
+    bool envelopeCovers(const geom::Geometry* g) const;
+
+public:
+    BasicPreparedGeometry(const Geometry* geom);
+
+    ~BasicPreparedGeometry() override = default;
+
+    const geom::Geometry&
+    getGeometry() const override
+    {
+        return *baseGeom;
+    }
+
+    /**
+     * Gets the list of representative points for this geometry.
+     * One vertex is included for every component of the geometry
+     * (i.e. including one for every ring of polygonal geometries)
+     *
+     * @return a List of Coordinate
+     */
+    const std::vector<const CoordinateXY*>*
+    getRepresentativePoints()  const
+    {
+        return &representativePts;
+    }
+
+    /**
+     * Tests whether any representative of the target geometry
+     * intersects the test geometry.
+     * This is useful in A/A, A/L, A/P, L/P, and P/P cases.
+     *
+     * @param testGeom the test geometry
+     * @return true if any component intersects the areal test geometry
+     */
+    bool isAnyTargetComponentInTest(const geom::Geometry* testGeom) const;
+
+    /**
+     * Default implementation.
+     */
+    bool within(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool contains(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool containsProperly(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool coveredBy(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool covers(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool crosses(const geom::Geometry* g) const override;
+
+    /**
+     * Standard implementation for all geometries.
+     * Supports {@link GeometryCollection}s as input.
+     */
+    bool disjoint(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool intersects(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool overlaps(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool touches(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    std::unique_ptr<IntersectionMatrix> relate(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool relate(const geom::Geometry* g, const std::string& pat) const override;
+
+    /**
+     * Default implementation.
+     */
+    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    double distance(const geom::Geometry* g) const override;
+
+    /**
+     * Default implementation.
+     */
+    bool isWithinDistance(const geom::Geometry* geom, double dist) const override;
+
+    std::string toString();
+
+};
+
+} // namespace geos::geom::prep
+} // namespace geos::geom
+} // namespace geos
+