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

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/GraphComponent.h

@@ -0,0 +1,117 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/GraphComponent.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/geomgraph/Label.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class IntersectionMatrix;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+
+/** \brief
+ * A GraphComponent is the parent class for the objects'
+ * that form a graph.
+ *
+ * Each GraphComponent can carry a Label.
+ */
+class GEOS_DLL GraphComponent /* non-final */ {
+public:
+    GraphComponent();
+
+    /*
+     * GraphComponent copies the given Label.
+     */
+    GraphComponent(const Label& newLabel);
+
+    virtual ~GraphComponent() = default;
+
+    Label&
+    getLabel()
+    {
+        return label;
+    }
+    const Label&
+    getLabel() const
+    {
+        return label;
+    }
+    void
+    setLabel(const Label& newLabel)
+    {
+        label = newLabel;
+    }
+
+    void
+    setInResult(bool p_isInResult)
+    {
+        isInResultVar = p_isInResult;
+    }
+    bool
+    isInResult() const
+    {
+        return isInResultVar;
+    }
+    void setCovered(bool isCovered);
+    bool
+    isCovered() const
+    {
+        return isCoveredVar;
+    }
+    bool
+    isCoveredSet() const
+    {
+        return isCoveredSetVar;
+    }
+    bool
+    isVisited() const
+    {
+        return isVisitedVar;
+    }
+    void
+    setVisited(bool p_isVisited)
+    {
+        isVisitedVar = p_isVisited;
+    }
+    virtual bool isIsolated() const = 0;
+    void updateIM(geom::IntersectionMatrix& im);
+protected:
+    Label label;
+    virtual void computeIM(geom::IntersectionMatrix& im) = 0;
+private:
+    bool isInResultVar;
+    bool isCoveredVar;
+    bool isCoveredSetVar;
+    bool isVisitedVar;
+};
+
+} // namespace geos.geomgraph
+} // namespace geos
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/Label.h

@@ -0,0 +1,290 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/Label.java r428 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Location.h>
+#include <geos/geomgraph/TopologyLocation.h>
+
+#include <iosfwd> // for operator<<
+#include <cassert>
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief
+ * A <code>Label</code> indicates the topological relationship of a component
+ * of a topology graph to a given <code>Geometry</code>.
+ *
+ * This class supports labels for relationships to two <code>Geometry</code>s,
+ * which is sufficient for algorithms for binary operations.
+ *
+ * Topology graphs support the concept of labeling nodes and edges in the graph.
+ * The label of a node or edge specifies its topological relationship to one or
+ * more geometries.  (In fact, since JTS operations have only two arguments labels
+ * are required for only two geometries).  A label for a node or edge has one or
+ * two elements, depending on whether the node or edge occurs in one or both of the
+ * input <code>Geometry</code>s.  Elements contain attributes which categorize the
+ * topological location of the node or edge relative to the parent
+ * <code>Geometry</code>; that is, whether the node or edge is in the interior,
+ * boundary or exterior of the <code>Geometry</code>.  Attributes have a value
+ * from the set <code>{Interior, Boundary, Exterior}</code>.  In a node each
+ * element has  a single attribute <code>&lt;On&gt;</code>.  For an edge each element has a
+ * triplet of attributes <code>&lt;Left, On, Right&gt;</code>.
+ *
+ * It is up to the client code to associate the 0 and 1 <code>TopologyLocation</code>s
+ * with specific geometries.
+ *
+ */
+class GEOS_DLL Label final {
+
+public:
+
+    friend std::ostream& operator<< (std::ostream&, const Label&);
+
+    /** \brief
+     * Converts a Label to a Line label
+     * (that is, one with no side Locations)
+     *
+     */
+    static Label toLineLabel(const Label& label)
+    {
+        Label lineLabel(geom::Location::NONE);
+        for(uint32_t i = 0; i < 2; i++) {
+            lineLabel.setLocation(i, label.getLocation(i));
+        }
+        return lineLabel;
+    };
+
+    /** \brief
+     * Construct a Label with a single location for both Geometries.
+     */
+    Label(geom::Location onLoc)
+        : elt{TopologyLocation(onLoc)
+        , TopologyLocation(onLoc)}
+        {};
+
+    /** \brief
+     * Construct a Label with the location specified
+     * for the given Geometry.
+     *
+     * Other geometry location will be set to
+     * Location::NONE.
+     */
+    Label(uint32_t geomIndex, geom::Location onLoc)
+        : elt{TopologyLocation(geom::Location::NONE)
+        , TopologyLocation(geom::Location::NONE)}
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(onLoc);
+    };
+
+    /** \brief
+     * Construct a Label with On, Left and Right locations for both Geometries.
+     *
+     * Initialize the locations for both Geometries to the given values.
+     */
+    Label(geom::Location onLoc, geom::Location leftLoc, geom::Location rightLoc)
+        : elt {TopologyLocation(onLoc, leftLoc, rightLoc)
+        , TopologyLocation(onLoc, leftLoc, rightLoc)}
+        {};
+
+    /// Copy ctor
+    Label(const Label& l)
+        : elt{TopologyLocation(l.elt[0])
+        , TopologyLocation(l.elt[1])}
+        {};
+
+    /** \brief
+     * Initialize both locations to Location::NONE
+     *
+     * isNull() should return true after this kind of construction
+     */
+    Label()
+        : elt{TopologyLocation(geom::Location::NONE)
+        , TopologyLocation(geom::Location::NONE)}
+        {};
+
+    /** \brief
+     * Construct a Label with On, Left and Right locations for the
+     * given Geometries.
+     * Initialize the locations for the other Geometry to
+     * Location::NONE
+     */
+    Label(uint32_t geomIndex, geom::Location onLoc, geom::Location leftLoc, geom::Location rightLoc)
+    {
+        elt[0] = TopologyLocation(geom::Location::NONE, geom::Location::NONE, geom::Location::NONE);
+        elt[1] = TopologyLocation(geom::Location::NONE, geom::Location::NONE, geom::Location::NONE);
+        elt[geomIndex].setLocations(onLoc, leftLoc, rightLoc);
+    };
+
+    Label&
+    operator=(const Label& l)
+    {
+        elt[0] = TopologyLocation(l.elt[0]);
+        elt[1] = TopologyLocation(l.elt[1]);
+        return *this;
+    };
+
+    void flip()
+    {
+        elt[0].flip();
+        elt[1].flip();
+    };
+
+    /** \brief
+     * Merge this label with another one.
+     *
+     * Merging updates any null attributes of this label with the attributes
+     * from lbl
+     */
+    void merge(const Label& lbl)
+    {
+        for(int i = 0; i < 2; i++) {
+            elt[i].merge(lbl.elt[i]);
+        }
+    };
+
+    int getGeometryCount() const
+    {
+        int count = 0;
+        if(!elt[0].isNull()) {
+            count++;
+        }
+        if(!elt[1].isNull()) {
+            count++;
+        }
+        return count;
+    };
+
+    geom::Location getLocation(uint32_t geomIndex, uint32_t posIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].get(posIndex);
+    };
+
+    geom::Location getLocation(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].get(Position::ON);
+    };
+
+    void setLocation(uint32_t geomIndex, uint32_t posIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(posIndex, location);
+    };
+
+    void setLocation(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setLocation(Position::ON, location);
+    };
+
+    void setAllLocations(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setAllLocations(location);
+    };
+
+    void setAllLocationsIfNull(uint32_t geomIndex, geom::Location location)
+    {
+        assert(geomIndex < 2);
+        elt[geomIndex].setAllLocationsIfNull(location);
+    };
+
+    void setAllLocationsIfNull(geom::Location location)
+    {
+        setAllLocationsIfNull(0, location);
+        setAllLocationsIfNull(1, location);
+    };
+
+    bool isNull(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isNull();
+    };
+
+    bool isNull() const
+    {
+        return elt[0].isNull() && elt[1].isNull();
+    };
+
+    bool isAnyNull(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isAnyNull();
+    };
+
+    bool isArea() const
+    {
+        return elt[0].isArea() || elt[1].isArea();
+    };
+
+    bool isArea(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isArea();
+    };
+
+    bool isLine(uint32_t geomIndex) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].isLine();
+    };
+
+    bool isEqualOnSide(const Label& lbl, uint32_t side) const
+    {
+        return elt[0].isEqualOnSide(lbl.elt[0], side)
+                && elt[1].isEqualOnSide(lbl.elt[1], side);
+    };
+
+    bool allPositionsEqual(uint32_t geomIndex, geom::Location loc) const
+    {
+        assert(geomIndex < 2);
+        return elt[geomIndex].allPositionsEqual(loc);
+    };
+
+    /** \brief
+     * Converts one GeometryLocation to a Line location
+     */
+    void toLine(uint32_t geomIndex)
+    {
+        assert(geomIndex < 2);
+        if(elt[geomIndex].isArea()) {
+            elt[geomIndex] = TopologyLocation(elt[geomIndex].getLocations()[0]);
+        }
+    };
+
+    std::string toString() const;
+
+private:
+
+    TopologyLocation elt[2];
+
+};
+
+std::ostream& operator<< (std::ostream&, const Label&);
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/Node.h

@@ -0,0 +1,192 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/Node.java r411 (JTS-1.12+)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geomgraph/GraphComponent.h> // for inheritance
+#include <geos/geom/Coordinate.h> // for member
+
+#ifndef NDEBUG
+#include <geos/geomgraph/EdgeEndStar.h> // for testInvariant
+#include <geos/geomgraph/EdgeEnd.h> // for testInvariant
+#endif // ndef NDEBUG
+
+#include <cassert>
+#include <string>
+
+#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 IntersectionMatrix;
+}
+namespace geomgraph {
+class Node;
+class EdgeEndStar;
+class EdgeEnd;
+class Label;
+class NodeFactory;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+/** \brief The node component of a geometry graph. */
+class GEOS_DLL Node /* non-final */: public GraphComponent {
+    using GraphComponent::setLabel;
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& os, const Node& node);
+
+    Node(const geom::Coordinate& newCoord, EdgeEndStar* newEdges);
+
+    ~Node() override;
+
+    const geom::Coordinate& getCoordinate() const;
+
+    EdgeEndStar* getEdges();
+
+    bool isIsolated() const override;
+
+    /** \brief
+     * Add the edge to the list of edges at this node
+     */
+    void add(EdgeEnd* e);
+
+    void mergeLabel(const Node& n);
+
+    /** \brief
+     * To merge labels for two nodes,
+     * the merged location for each LabelElement is computed.
+     *
+     * The location for the corresponding node LabelElement is set
+     * to the result, as long as the location is non-null.
+     */
+    void mergeLabel(const Label& label2);
+
+    void setLabel(uint8_t argIndex, geom::Location onLocation);
+
+    /** \brief
+     * Updates the label of a node to BOUNDARY,
+     * obeying the mod-2 boundaryDetermination rule.
+     */
+    void setLabelBoundary(uint8_t argIndex);
+
+    /**
+     * The location for a given eltIndex for a node will be one
+     * of { null, INTERIOR, BOUNDARY }.
+     * A node may be on both the boundary and the interior of a geometry;
+     * in this case, the rule is that the node is considered to be
+     * in the boundary.
+     * The merged location is the maximum of the two input values.
+     */
+    geom::Location computeMergedLocation(const Label& label2, uint8_t eltIndex);
+
+    std::string print() const;
+
+    const std::vector<double>& getZ() const;
+
+    void addZ(double);
+
+    /** \brief
+     * Tests whether any incident edge is flagged as
+     * being in the result.
+     *
+     * This test can be used to determine if the node is in the result,
+     * since if any incident edge is in the result, the node must be in
+     * the result as well.
+     *
+     * @return <code>true</code> if any indicident edge in the in
+     *         the result
+     */
+    bool isIncidentEdgeInResult() const;
+
+protected:
+
+    void testInvariant() const;
+
+    geom::Coordinate coord;
+
+    EdgeEndStar* edges;
+
+    /** \brief
+     * Basic nodes do not compute IMs
+     */
+    void
+    computeIM(geom::IntersectionMatrix& /*im*/) override {}
+
+private:
+
+    std::vector<double> zvals;
+
+    double ztot;
+
+};
+
+std::ostream& operator<< (std::ostream& os, const Node& node);
+
+inline void
+Node::testInvariant() const
+{
+#ifndef NDEBUG
+    if(edges) {
+        // Each EdgeEnd in the star has this Node's
+        // coordinate as first coordinate
+        for(EdgeEndStar::iterator
+                it = edges->begin(), itEnd = edges->end();
+                it != itEnd; it++) {
+            EdgeEnd* e = *it;
+            assert(e);
+            assert(e->getCoordinate().equals2D(coord));
+        }
+    }
+
+#if 0
+    // We can't rely on numerical stability with FP computations
+    // ztot is the sum of doubnle sin zvals vector
+    double ztot_check = 0.0;
+    for(std::vector<double>::const_iterator
+            i = zvals.begin(), e = zvals.end();
+            i != e;
+            i++) {
+        ztot_check += *i;
+    }
+    assert(ztot_check == ztot);
+#endif // 0
+
+#endif
+}
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/geomgraph/NodeFactory.h

@@ -0,0 +1,51 @@
+/**********************************************************************
+ *
+ * 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: geomgraph/NodeFactory.java rev. 1.3 (JTS-1.10)
+ *
+ **********************************************************************/
+
+
+#pragma once
+
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace geomgraph {
+class Node;
+}
+}
+
+namespace geos {
+namespace geomgraph { // geos.geomgraph
+
+class GEOS_DLL NodeFactory /* non-final */ {
+public:
+    virtual Node* createNode(const geom::Coordinate& coord) const;
+    static const NodeFactory& instance();
+    virtual
+    ~NodeFactory() {}
+protected:
+    NodeFactory() {}
+};
+
+
+} // namespace geos.geomgraph
+} // namespace geos
+