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

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/OverlayLabel.h

@@ -0,0 +1,404 @@
+/**********************************************************************
+ *
+ * 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 <cstdint>
+
+#include <geos/geom/Location.h>
+#include <geos/geom/Position.h>
+#include <geos/export.h>
+
+using geos::geom::Location;
+using geos::geom::Position;
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+/**
+* A label for a pair of {@link OverlayEdge}s which records
+* the topological information for the edge
+* in the {@link OverlayGraph} containing it.
+* The label is shared between both OverlayEdges
+* of a symmetric pair.
+* Accessors for orientation-sensitive information
+* require the orientation of the containing OverlayEdge.
+*
+* A label contains the topological {@link geom::Location}s for
+* the two overlay input geometries.
+* A labelled input geometry may be either a Line or an Area.
+* In both cases, the label locations are populated
+* with the locations for the edge {@link geom::Position}s
+* once they are computed by topological evaluation.
+* The label also records the dimension of each geometry,
+* and in the case of area boundary edges, the role
+* of the originating ring (which allows
+* determination of the edge role in collapse cases).
+*
+* For each input geometry, the label indicates that an edge
+* is in one of the following states (identified by the "dim" field).
+* Each state has some additional information about the edge.
+*
+* * A Boundary edge of an input Area (polygon)
+*
+*   * dim = DIM_BOUNDARY
+*   * locLeft, locRight : the locations of the edge sides for the input Area
+*   * isHole : whether the edge was in a shell or a hole
+*
+* * A Collapsed edge of an input Area
+*   (which had two or more parent edges)
+*
+*   * dim = DIM_COLLAPSE
+*   * locLine : the location of the
+*     edge relative to the input Area
+*   * isHole : whether some
+*     contributing edge was in a shell (false),
+*     or otherwise that all were in holes (true)
+*
+* * An edge from an input Line
+*
+*   * dim = DIM_LINE
+*   * locLine : initialized to LOC_UNKNOWN, to simplify logic.
+*
+* * An edge which is Not Part of an input geometry
+*   (and thus must be part of the other geometry).
+*
+*   * dim = NOT_PART
+*
+* Note that:
+*
+* * an edge cannot be both a Collapse edge and a Line edge in the same input geometry,
+*   because each input geometry must be homogeneous.
+* * an edge may be an Boundary edge in one input geometry
+*   and a Line or Collapse edge in the other input.
+*
+* @author Martin Davis
+*/
+class GEOS_DLL OverlayLabel {
+
+private:
+
+    // Members
+    int aDim = DIM_NOT_PART;
+    bool aIsHole = false;
+    Location aLocLeft = LOC_UNKNOWN;
+    Location aLocRight = LOC_UNKNOWN;
+    Location aLocLine = LOC_UNKNOWN;
+    int bDim = DIM_NOT_PART;
+    bool bIsHole = false;
+    Location bLocLeft = LOC_UNKNOWN;
+    Location bLocRight = LOC_UNKNOWN;
+    Location bLocLine = LOC_UNKNOWN;
+
+    std::string dimensionSymbol(int dim) const;
+    void locationString(uint8_t index, bool isForward, std::ostream& os) const;
+
+
+public:
+
+    static constexpr Location LOC_UNKNOWN = Location::NONE;
+
+    enum {
+        DIM_UNKNOWN = -1,
+        DIM_NOT_PART = -1,
+        DIM_LINE = 1,
+        DIM_BOUNDARY = 2,
+        DIM_COLLAPSE = 3
+    };
+
+    OverlayLabel()
+        : aDim(DIM_NOT_PART)
+        , aIsHole(false)
+        , aLocLeft(LOC_UNKNOWN)
+        , aLocRight(LOC_UNKNOWN)
+        , aLocLine(LOC_UNKNOWN)
+        , bDim(DIM_NOT_PART)
+        , bIsHole(false)
+        , bLocLeft(LOC_UNKNOWN)
+        , bLocRight(LOC_UNKNOWN)
+        , bLocLine(LOC_UNKNOWN) {};
+
+    explicit OverlayLabel(uint8_t p_index)
+        : OverlayLabel()
+    {
+        initLine(p_index);
+    };
+
+    OverlayLabel(uint8_t p_index, Location p_locLeft, Location p_locRight, bool p_isHole)
+        : OverlayLabel()
+    {
+        initBoundary(p_index, p_locLeft, p_locRight, p_isHole);
+    };
+
+    int dimension(uint8_t index) const { return index == 0 ? aDim : bDim; };
+    void initBoundary(uint8_t index, Location locLeft, Location locRight, bool p_isHole);
+    void initCollapse(uint8_t index, bool p_isHole);
+    void initLine(uint8_t index);
+    void initNotPart(uint8_t index);
+
+    /**
+    * Sets the line location.
+    *
+    * This is used to set the locations for linear edges
+    * encountered during area label propagation.
+    *
+    * @param index source to update
+    * @param loc location to set
+    */
+    void setLocationLine(uint8_t index, Location loc);
+    void setLocationAll(uint8_t index, Location loc);
+    void setLocationCollapse(uint8_t index);
+
+    /*
+    * Tests whether at least one of the sources is a Line.
+    *
+    * @return true if at least one source is a line
+    */
+    bool isLine() const
+    {
+        return aDim == DIM_LINE || bDim == DIM_LINE;
+    };
+
+    bool isLine(uint8_t index) const
+    {
+        return index == 0 ? aDim == DIM_LINE : bDim == DIM_LINE;
+    };
+
+    bool isLinear(uint8_t index) const
+    {
+        if (index == 0) {
+            return aDim == DIM_LINE || aDim == DIM_COLLAPSE;
+        }
+        return bDim == DIM_LINE || bDim == DIM_COLLAPSE;
+    };
+
+    bool isKnown(uint8_t index) const
+    {
+        if (index == 0) {
+            return aDim != DIM_UNKNOWN;
+        }
+        return bDim != DIM_UNKNOWN;
+    };
+
+    bool isNotPart(uint8_t index) const
+    {
+        if (index == 0) {
+            return aDim == DIM_NOT_PART;
+        }
+        return bDim == DIM_NOT_PART;
+    };
+
+    bool isBoundaryEither() const
+    {
+        return aDim == DIM_BOUNDARY || bDim == DIM_BOUNDARY;
+    };
+
+    bool isBoundaryBoth() const
+    {
+        return aDim == DIM_BOUNDARY && bDim == DIM_BOUNDARY;
+    };
+
+    /**
+    * Tests if the label is for a collapsed
+    * edge of an area
+    * which is coincident with the boundary of the other area.
+    *
+    * @return true if the label is for a collapse coincident with a boundary
+    */
+    bool isBoundaryCollapse() const
+    {
+        if (isLine()) return false;
+        return ! isBoundaryBoth();
+    };
+
+    /**
+    * Tests if a label is for an edge where two
+    * area touch along their boundary.
+    */
+    bool isBoundaryTouch() const
+    {
+        return isBoundaryBoth() &&
+               getLocation(0, Position::RIGHT, true) != getLocation(1, Position::RIGHT, true);
+    };
+
+    bool isBoundary(uint8_t index) const
+    {
+        if (index == 0) {
+            return aDim == DIM_BOUNDARY;
+        }
+        return bDim == DIM_BOUNDARY;
+    };
+
+    bool isLineLocationUnknown(int index) const
+    {
+        if (index == 0) {
+            return aLocLine == LOC_UNKNOWN;
+        }
+        else {
+            return bLocLine == LOC_UNKNOWN;
+        }
+    };
+
+    /**
+    * Tests whether a label is for an edge which is a boundary of one geometry
+    * and not part of the other.
+    */
+    bool isBoundarySingleton() const
+    {
+        if (aDim == DIM_BOUNDARY && bDim == DIM_NOT_PART) {
+            return true;
+        }
+
+        if (bDim == DIM_BOUNDARY && aDim == DIM_NOT_PART) {
+            return true;
+        }
+
+        return false;
+    };
+
+    /**
+    * Tests if a line edge is inside
+    * @param index
+    * @return
+    */
+    bool isLineInArea(int8_t index) const
+    {
+        if (index == 0) {
+            return aLocLine == Location::INTERIOR;
+        }
+        return bLocLine == Location::INTERIOR;
+    };
+
+    bool isHole(uint8_t index) const
+    {
+        if (index == 0) {
+            return aIsHole;
+        }
+        else {
+            return bIsHole;
+        }
+    };
+
+    bool isCollapse(uint8_t index) const
+    {
+        return dimension(index) == DIM_COLLAPSE;
+    };
+
+    Location getLineLocation(uint8_t index) const
+    {
+        if (index == 0) {
+            return aLocLine;
+        }
+        else {
+            return bLocLine;
+        }
+    };
+
+    /**
+    * Tests if a label is a Collapse has location INTERIOR,
+    * to at least one source geometry.
+    */
+    bool isInteriorCollapse() const
+    {
+        if (aDim == DIM_COLLAPSE && aLocLine == Location::INTERIOR)
+            return true;
+        if (bDim == DIM_COLLAPSE && bLocLine == Location::INTERIOR)
+            return true;
+
+        return false;
+    };
+
+    /**
+    * Tests if a label is a Collapse
+    * and NotPart with location INTERIOR for the other geometry.
+    */
+    bool isCollapseAndNotPartInterior() const;
+
+    /**
+    * Tests if a line is in the interior of a source geometry.
+    *
+    * @param index source geometry
+    * @return true if the label is a line and is interior
+    */
+    bool isLineInterior(uint8_t index) const
+    {
+        if (index == 0) {
+            return aLocLine == Location::INTERIOR;
+        }
+        return bLocLine == Location::INTERIOR;
+    };
+
+    /**
+    * Gets the location for this label for either
+    * a Boundary or a Line edge.
+    * This supports a simple determination of
+    * whether the edge should be included as a result edge.
+    *
+    * @param index the source index
+    * @param position the position for a boundary label
+    * @param isForward the direction for a boundary label
+    * @return the location for the specified position
+    */
+    Location getLocationBoundaryOrLine(
+        uint8_t index,
+        int position,
+        bool isForward) const
+    {
+        if (isBoundary(index)) {
+            return getLocation(index, position, isForward);
+        }
+        return getLineLocation(index);
+    };
+
+    /**
+    * Gets the linear location for the given source.
+    *
+    * @param index the source index
+    * @return the linear location for the source
+    */
+    Location getLocation(uint8_t index) const {
+        if (index == 0) {
+            return aLocLine;
+        }
+        return bLocLine;
+    };
+
+    Location getLocation(uint8_t index, int position, bool isForward) const;
+
+    bool hasSides(uint8_t index) const {
+        if (index == 0) {
+            return aLocLeft != LOC_UNKNOWN
+                   || aLocRight != LOC_UNKNOWN;
+        }
+        return bLocLeft != LOC_UNKNOWN
+               || bLocRight != LOC_UNKNOWN;
+    };
+
+    OverlayLabel copy() const
+    {
+        OverlayLabel lbl = *this;
+        return lbl;
+    };
+
+    friend std::ostream& operator<<(std::ostream& os, const OverlayLabel& ol);
+    void toString(bool isForward, std::ostream& os) const;
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos

package/dist/prebuilt/Android-x86_64/include/geos/operation/overlayng/OverlayLabeller.h

@@ -0,0 +1,207 @@
+/**********************************************************************
+ *
+ * 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 <geos/geom/Location.h>
+#include <geos/operation/overlayng/OverlayGraph.h>
+
+#include <vector>
+#include <deque>
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Coordinate;
+}
+namespace operation {
+namespace overlayng {
+class OverlayLabel;
+class OverlayGraph;
+class OverlayEdge;
+class InputGeometry;
+}
+}
+}
+
+namespace geos {      // geos.
+namespace operation { // geos.operation
+namespace overlayng { // geos.operation.overlayng
+
+
+class GEOS_DLL OverlayLabeller {
+
+private:
+
+    // Members
+    OverlayGraph* graph;
+    InputGeometry* inputGeometry;
+    std::vector<OverlayEdge*>& edges;
+
+    /**
+    * Finds a boundary edge for this geom, if one exists.
+    */
+    static OverlayEdge* findPropagationStartEdge(OverlayEdge* nodeEdge, uint8_t geomIndex);
+
+    /**
+    * At this point collapsed edges with unknown location
+    * must be disconnected from the boundary edges of the parent
+    * (because otherwise the location would have
+    * been propagated from them).
+    * This can occur with a collapsed hole or shell.
+    * The edges can be labeled based on their parent ring role (shell or hole).
+    * (This cannot be done earlier, because the location
+    * based on the boundary edges must take precedence.
+    * There are situations where a collapsed edge has a location
+    * which is different to its ring role -
+    * e.g. a narrow gore in a polygon, which is in
+    * the interior of the reduced polygon, but whose
+    * ring role would imply the location EXTERIOR.)
+    *
+    * Note that collapsed edges can NOT have location determined via a PIP location check,
+    * because that is done against the unreduced input geometry,
+    * which may give an invalid result due to topology collapse.
+    *
+    * The labeling is propagated to other connected linear edges,
+    * since there may be NOT_PART edges which are connected,
+    * and they can be labeled in the same way.
+    * (These would get labeled anyway during subsequent disconnected labeling pass,
+    * but may be more efficient and accurate to do it here.)
+    */
+    void labelCollapsedEdges();
+    static void labelCollapsedEdge(OverlayEdge* edge, uint8_t geomIndex);
+
+    /**
+    * There can be edges which have unknown location
+    * but are connected to a Line edge with known location.
+    * In this case line location is propagated to the connected edges.
+    */
+    void labelConnectedLinearEdges();
+    void propagateLinearLocations(uint8_t geomIndex);
+    static void propagateLinearLocationAtNode(OverlayEdge* eNode, uint8_t geomIndex, bool isInputLine, std::deque<OverlayEdge*>& edgeStack);
+
+    /**
+    * Finds all OverlayEdges which are linear
+    * (i.e. line or collapsed) and have a known location
+    * for the given input geometry.
+    */
+    static std::vector<OverlayEdge*> findLinearEdgesWithLocation(const std::vector<OverlayEdge *> &edges, uint8_t geomIndex);
+
+    /**
+    * At this point there may still be edges which have unknown location
+    * relative to an input geometry.
+    * This must be because they are NOT_PART edges for that geometry,
+    * and are disconnected from any edges of that geometry.
+    * An example of this is rings of one geometry wholly contained
+    * in another geometry.
+    * The location must be fully determined to compute a
+    * correct result for all overlay operations.
+    *
+    * If the input geometry is an Area the edge location can
+    * be determined via a PIP test.
+    * If the input is not an Area the location is EXTERIOR.
+    */
+    void labelDisconnectedEdges();
+
+    /**
+    * Determines the location of an edge relative to a target input geometry.
+    * The edge has no location information
+    * because it is disconnected from other
+    * edges that would provide that information.
+    * The location is determined by checking
+    * if the edge lies inside the target geometry area (if any).
+    */
+    void labelDisconnectedEdge(OverlayEdge* edge, uint8_t geomIndex);
+
+    /**
+    * Determines the {@link Location} for an edge within an Area geometry
+    * via point-in-polygon location.
+    *
+    * NOTE this is only safe to use for disconnected edges,
+    * since the test is carried out against the original input geometry,
+    * and precision reduction may cause incorrect results for edges
+    * which are close enough to a boundary to become connected.
+    */
+    geom::Location locateEdge(uint8_t geomIndex, OverlayEdge* edge);
+
+    /**
+    * Determines the {@link Location} for an edge within an Area geometry
+    * via point-in-polygon location,
+    * by checking that both endpoints are interior to the target geometry.
+    * Checking both endpoints ensures correct results in the presence of topology collapse.
+    * <p>
+    * NOTE this is only safe to use for disconnected edges,
+    * since the test is carried out against the original input geometry,
+    * and precision reduction may cause incorrect results for edges
+    * which are close enough to a boundary to become connected.
+    */
+    geom::Location locateEdgeBothEnds(uint8_t geomIndex, OverlayEdge* edge);
+
+    /**
+    * Labels edges around nodes based on the arrangement
+    * of incident area boundary edges.
+    * Also propagates the labelling to connected linear edges.
+    */
+    void labelAreaNodeEdges(std::vector<OverlayEdge*>& nodes);
+
+
+
+public:
+
+    OverlayLabeller(OverlayGraph* p_graph, InputGeometry* p_inputGeometry)
+        : graph(p_graph)
+        , inputGeometry(p_inputGeometry)
+        , edges(p_graph->getEdges())
+    {}
+
+    /**
+    * Computes the topological labelling for the edges in the graph->
+    */
+    void computeLabelling();
+
+    /**
+    * Scans around a node CCW, propagating the side labels
+    * for a given area geometry to all edges (and their sym)
+    * with unknown locations for that geometry.
+    */
+    void propagateAreaLocations(OverlayEdge* nodeEdge, uint8_t geomIndex);
+
+    void markResultAreaEdges(int overlayOpCode);
+
+    /**
+    * Marks an edge which forms part of the boundary of the result area.
+    * This is determined by the overlay operation being executed,
+    * and the location of the edge.
+    * The relevant location is either the right side of a boundary edge,
+    * or the line location of a non-boundary edge.
+    */
+    static void markInResultArea(OverlayEdge* e, int overlayOpCode);
+
+    /**
+    * Unmarks result area edges where the sym edge
+    * is also marked as in the result.
+    * This has the effect of merging edge-adjacent result areas,
+    * as required by polygon validity rules.
+    */
+    void unmarkDuplicateEdgesFromResultArea();
+
+
+};
+
+
+} // namespace geos.operation.overlayng
+} // namespace geos.operation
+} // namespace geos
+