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

package/dist/prebuilt/Android-x86_64/include/geos/triangulate/quadedge/Vertex.h

@@ -0,0 +1,312 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2012 Excensus LLC.
+ *
+ * This is free software; you can redistribute and/or modify it under
+ * the terms of the GNU Lesser General Licence as published
+ * by the Free Software Foundation.
+ * See the COPYING file for more information.
+ *
+ **********************************************************************
+ *
+ * Last port: triangulate/quadedge/Vertex.java r705
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cmath>
+#include <memory>
+#include <cstring>
+
+#include <geos/geom/Coordinate.h>
+#include <geos/algorithm/HCoordinate.h>
+#include <geos/triangulate/quadedge/TrianglePredicate.h>
+
+
+//fwd declarations
+namespace geos {
+namespace triangulate {
+namespace quadedge {
+class QuadEdge;
+}
+}
+}
+
+namespace geos {
+namespace triangulate { //geos.triangulate
+namespace quadedge { //geos.triangulate.quadedge
+
+/** \brief
+ * Models a site (node) in a QuadEdgeSubdivision.
+ *
+ * The sites can be points on a line string representing a linear site.
+ *
+ * The vertex can be considered as a vector with a norm, length, inner product, cross
+ * product, etc. Additionally, point relations (e.g., is a point to the left of a line, the circle
+ * defined by this point and two others, etc.) are also defined in this class.
+ *
+ * It is common to want to attach user-defined data to the vertices of a subdivision.
+ * One way to do this is to subclass `Vertex` to carry any desired information.
+ *
+ * @author JTS: David Skea
+ * @author JTS: Martin Davis
+ * @author Benjamin Campbell
+ * */
+
+class GEOS_DLL Vertex {
+public:
+    static const int LEFT		= 0;
+    static const int RIGHT	   = 1;
+    static const int BEYOND	  = 2;
+    static const int BEHIND	  = 3;
+    static const int BETWEEN	 = 4;
+    static const int ORIGIN	  = 5;
+    static const int DESTINATION = 6;
+private:
+    geom::Coordinate	  p;
+
+public:
+    Vertex(double _x, double _y);
+
+    Vertex(double _x, double _y, double _z);
+
+    Vertex(const geom::Coordinate& _p);
+
+    Vertex();
+    ~Vertex() {};
+
+    inline double
+    getX() const
+    {
+        return p.x;
+    }
+
+    inline double
+    getY() const
+    {
+        return p.y;
+    }
+
+    inline double
+    getZ() const
+    {
+        return p.z;
+    }
+
+    inline void
+    setZ(double _z)
+    {
+        p.z = _z;
+    }
+
+    inline const geom::Coordinate&
+    getCoordinate() const
+    {
+        return p;
+    }
+
+    inline bool
+    equals(const Vertex& _x) const
+    {
+        return p.equals2D(_x.p);
+    }
+
+    inline bool
+    equals(const Vertex& _x, double tolerance) const
+    {
+        if(p.distance(_x.getCoordinate()) < tolerance) {
+            return true;
+        }
+        return false;
+    }
+
+    int classify(const Vertex& p0, const Vertex& p1);
+
+    /**
+     * Computes the cross product k = u X v.
+     *
+     * @param v a vertex
+     * @return returns the magnitude of u X v
+     */
+    inline double
+    crossProduct(const Vertex& v) const
+    {
+        return (p.x * v.getY() - p.y * v.getX());
+    }
+
+    /**
+     * Computes the inner or dot product
+     *
+     * @param v a vertex
+     * @return returns the dot product u.v
+     */
+    inline double
+    dot(Vertex v) const
+    {
+        return (p.x * v.getX() + p.y * v.getY());
+    }
+
+    /**
+     * Computes the scalar product c(v)
+     *
+     * @param c scaling factor
+     * @return returns the scaled vector
+     */
+    inline std::unique_ptr<Vertex>
+    times(double c) const
+    {
+        return std::unique_ptr<Vertex>(new Vertex(c * p.x, c * p.y));
+    }
+
+    /* Vector addition */
+    inline std::unique_ptr<Vertex>
+    sum(Vertex v) const
+    {
+        return std::unique_ptr<Vertex>(new Vertex(p.x + v.getX(), p.y + v.getY()));
+    }
+
+    /* and subtraction */
+    inline std::unique_ptr<Vertex>
+    sub(const Vertex& v) const
+    {
+        return std::unique_ptr<Vertex>(new Vertex(p.x - v.getX(), p.y - v.getY()));
+    }
+
+    /* magnitude of vector */
+    inline double
+    magn() const
+    {
+        return (std::sqrt(p.x * p.x + p.y * p.y));
+    }
+
+    /* returns k X v (cross product). this is a vector perpendicular to v */
+    inline std::unique_ptr<Vertex>
+    cross() const
+    {
+        return std::unique_ptr<Vertex>(new Vertex(p.y, -p.x));
+    }
+
+    /** ************************************************************* */
+    /***********************************************************************************************
+     * Geometric primitives /
+     **********************************************************************************************/
+
+    /**
+     * Tests if the vertex is inside the circle defined by
+     * the triangle with vertices a, b, c (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 this vertex is in the circumcircle of (a,b,c)
+     */
+    bool isInCircle(const Vertex& a, const Vertex& b, const Vertex& c) const {
+        return triangulate::quadedge::TrianglePredicate::isInCircleRobust(a.p, b.p, c.p, this->p) == geom::Location::INTERIOR;
+    }
+
+    /**
+     * Tests whether the triangle formed by this vertex and two
+     * other vertices is in CCW orientation.
+     *
+     * @param b a vertex
+     * @param c a vertex
+     * @returns true if the triangle is oriented CCW
+     */
+    inline bool
+    isCCW(const Vertex& b, const Vertex& c) const
+    {
+        // check if signed area is positive
+        return (b.p.x - p.x) * (c.p.y - p.y)
+               > (b.p.y - p.y) * (c.p.x - p.x);
+    }
+
+    bool rightOf(const QuadEdge& e) const;
+    bool leftOf(const QuadEdge& e) const;
+
+private:
+    static std::unique_ptr<algorithm::HCoordinate> bisector(const Vertex& a, const Vertex& b);
+
+    inline double
+    distance(const Vertex& v1, const Vertex& v2)
+    {
+        return std::sqrt(pow(v2.getX() - v1.getX(), 2.0) +
+                         pow(v2.getY() - v1.getY(), 2.0));
+    }
+
+    /**
+     * Computes the value of the ratio of the circumradius to shortest edge. If smaller than some
+     * given tolerance B, the associated triangle is considered skinny. For an equal lateral
+     * triangle this value is 0.57735. The ratio is related to the minimum triangle angle theta by:
+     * circumRadius/shortestEdge = 1/(2sin(theta)).
+     *
+     * @param b second vertex of the triangle
+     * @param c third vertex of the triangle
+     * @return ratio of circumradius to shortest edge.
+     */
+    double circumRadiusRatio(const Vertex& b, const Vertex& c);
+
+    /**
+     * returns a new vertex that is mid-way between this vertex and another end point.
+     *
+     * @param a the other end point.
+     * @return the point mid-way between this and that.
+     */
+    std::unique_ptr<Vertex> midPoint(const Vertex& a);
+
+    /**
+     * Computes the centre of the circumcircle of this vertex and two others.
+     *
+     * @param b
+     * @param c
+     * @return the Coordinate which is the circumcircle of the 3 points.
+     */
+    std::unique_ptr<Vertex> circleCenter(const Vertex& b, const Vertex& c) const;
+
+    /**
+     * For this vertex enclosed in a triangle defined by three vertices v0, v1 and v2, interpolate
+     * a z value from the surrounding vertices.
+     */
+    double interpolateZValue(const Vertex& v0, const Vertex& v1, const Vertex& v2) const;
+
+    /**
+     * Interpolates the Z-value (height) of a point enclosed in a triangle
+     * whose vertices all have Z values.
+     * The containing triangle must not be degenerate
+     * (in other words, the three vertices must enclose a
+     * non-zero area).
+     *
+     * @param p the point to interpolate the Z value of
+     * @param v0 a vertex of a triangle containing the p
+     * @param v1 a vertex of a triangle containing the p
+     * @param v2 a vertex of a triangle containing the p
+     * @return the interpolated Z-value (height) of the point
+     */
+    static double interpolateZ(const geom::Coordinate& p, const geom::Coordinate& v0,
+                               const geom::Coordinate& v1, const geom::Coordinate& v2);
+
+    /**
+     * Computes the interpolated Z-value for a point p lying on the segment p0-p1
+     *
+     * @param p
+     * @param p0
+     * @param p1
+     * @return the interpolated Z value
+     */
+    static double interpolateZ(const geom::Coordinate& p, const geom::Coordinate& p0,
+                               const geom::Coordinate& p1);
+};
+
+inline bool
+operator<(const Vertex& v1, const Vertex& v2)
+{
+    return v1.getCoordinate() < v2.getCoordinate();
+}
+
+} //namespace geos.triangulate.quadedge
+} //namespace geos.triangulate
+} //namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/triangulate/tri/Tri.h

@@ -0,0 +1,186 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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/geom/Coordinate.h>
+#include <geos/triangulate/tri/TriList.h>
+
+#include <memory>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Geometry;
+class GeometryFactory;
+class Polygon;
+}
+}
+
+using geos::geom::Coordinate;
+using geos::geom::Polygon;
+using geos::geom::GeometryFactory;
+
+namespace geos {        // geos.
+namespace triangulate { // geos.triangulate
+namespace tri {         // geos.triangulate.tri
+
+
+/**
+ * A memory-efficient representation of a triangle in a triangulation.
+ * Contains three vertices, and links to adjacent Tris for each edge.
+ * Tris are constructed independently, and if needed linked
+ * into a triangulation using {@link TriangulationBuilder}.
+ *
+ * @author Martin Davis
+ *
+ */
+class GEOS_DLL Tri {
+
+protected:
+
+    // Members
+    Coordinate p0;
+    Coordinate p1;
+    Coordinate p2;
+
+    /**
+    * triN is the adjacent triangle across the edge pN - pNN.
+    * pNN is the next vertex CW from pN.
+    */
+    Tri* tri0;
+    Tri* tri1;
+    Tri* tri2;
+
+private:
+
+    /**
+    * Replace triOld with triNew
+    *
+    * @param triOld
+    * @param triNew
+    */
+    void replace(Tri* triOld, Tri* triNew);
+    void remove(TriIndex index);
+
+    /**
+    *
+    * Order: 0: opp0-adj0 edge, 1: opp0-adj1 edge,
+    *  2: opp1-adj0 edge, 3: opp1-adj1 edge
+    *
+    * @param tri
+    * @param index0
+    * @param index1
+    * @return list of adjactent tris
+    */
+    std::vector<Tri*> getAdjacentTris(Tri* tri, TriIndex index0, TriIndex index1);
+
+    void setCoordinates(const Coordinate& p0, const Coordinate& p1, const Coordinate& p2);
+
+    void flip(Tri* tri, TriIndex index0, TriIndex index1,
+        const Coordinate& adj0, const Coordinate& adj1,
+        const Coordinate& opp0, const Coordinate& opp1);
+
+
+public:
+
+    Tri(const Coordinate& c0, const Coordinate& c1, const Coordinate& c2)
+        : p0(c0)
+        , p1(c1)
+        , p2(c2)
+        , tri0(nullptr)
+        , tri1(nullptr)
+        , tri2(nullptr)
+        {};
+
+    void setAdjacent(Tri* p_tri0, Tri* p_tri1, Tri* p_tri2);
+    void setAdjacent(const Coordinate& pt, Tri* tri);
+    void setTri(TriIndex edgeIndex, Tri* tri);
+
+    /**
+    * Interchanges the vertices of this triangle and a neighbor
+    * so that their common edge
+    * becomes the the other diagonal of the quadrilateral they form.
+    * Neighbour triangle links are modified accordingly.
+    *
+    * @param index the index of the adjacent tri to flip with
+    */
+    void flip(TriIndex index);
+
+    /**
+    * Removes this triangle from a triangulation.
+    * All adjacent references and the references to this
+    * Tri in the adjacent Tris are set to nullptr.
+    */
+    void remove();
+    void remove(TriList<Tri>& triList);
+
+    void validate();
+    void validateAdjacent(TriIndex index);
+
+    std::pair<const Coordinate&, const Coordinate&> getEdge(Tri* neighbor) const;
+
+    const Coordinate& getEdgeStart(TriIndex i) const;
+    const Coordinate& getEdgeEnd(TriIndex i) const;
+
+    bool hasCoordinate(const Coordinate& v) const;
+    const Coordinate& getCoordinate(TriIndex i) const;
+
+    TriIndex getIndex(const Coordinate& p) const;
+    TriIndex getIndex(const Tri* tri) const;
+
+    Tri* getAdjacent(TriIndex i) const;
+    bool hasAdjacent(TriIndex i) const;
+    bool hasAdjacent() const;
+    bool isAdjacent(Tri* tri) const;
+
+    int numAdjacent() const;
+
+    static TriIndex next(TriIndex i);
+    static TriIndex prev(TriIndex i);
+    static TriIndex oppVertex(TriIndex edgeIndex);
+    static TriIndex oppEdge(TriIndex vertexIndex);
+
+    /**
+    * Tests if a tri vertex is interior.
+    * A vertex of a triangle is interior if it
+    * is fully surrounded by other triangles.
+    *
+    * @param index the vertex index
+    * @return true if the vertex is interior
+    */
+    bool isInteriorVertex(TriIndex index) const;
+
+    bool isBorder() const;
+    bool isBoundary(TriIndex index) const;
+    Coordinate midpoint(TriIndex edgeIndex) const;
+
+    double getArea() const;
+    double getLength() const;
+    double getLength(TriIndex i) const;
+
+    std::unique_ptr<Polygon> toPolygon(const GeometryFactory* gf) const;
+    static std::unique_ptr<Geometry> toGeometry(std::set<Tri*>& tris, const GeometryFactory* gf);
+
+    friend std::ostream& operator << (std::ostream& os, const Tri&);
+
+};
+
+
+
+
+} // namespace geos.triangulate.tri
+} // namespace geos.triangulate
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/triangulate/tri/TriEdge.h

@@ -0,0 +1,80 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2020 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 <iostream>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+}
+
+using geos::geom::Coordinate;
+
+namespace geos {        // geos.
+namespace triangulate { // geos.triangulate
+namespace tri {         // geos.triangulate.tri
+
+
+/**
+ * Represents an edge in a {@link Tri},
+ * to be used as a key for looking up Tris
+ * while building a triangulation.
+ * The edge value is normalized to allow lookup
+ * of adjacent triangles.
+ *
+ * @author mdavis
+ */
+class GEOS_DLL TriEdge {
+
+private:
+
+    void normalize();
+
+
+public:
+
+    // Members
+    Coordinate p0;
+    Coordinate p1;
+
+    TriEdge(const Coordinate& a, const Coordinate& b)
+        : p0(a)
+        , p1(b)
+    {
+        normalize();
+    }
+
+    struct GEOS_DLL HashCode {
+        std::size_t operator()(const TriEdge& te) const;
+    };
+
+    friend bool operator == (const TriEdge& te0, const TriEdge& te1);
+
+    friend std::ostream& operator << (std::ostream& os, const TriEdge& te);
+
+};
+
+
+
+
+} // namespace geos.triangulate.tri
+} // namespace geos.triangulate
+} // namespace geos
+