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

package/dist/prebuilt/Android-x86_64/include/geos/operation/buffer/BufferParameters.h

@@ -0,0 +1,319 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2009  Sandro Santilli <strk@kbt.io>
+ *
+ * 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: operation/buffer/BufferParameters.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+//#include <vector>
+
+//#include <geos/algorithm/LineIntersector.h> // for composition
+//#include <geos/geom/Coordinate.h> // for composition
+//#include <geos/geom/LineSegment.h> // for composition
+
+#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 CoordinateSequence;
+class PrecisionModel;
+}
+namespace operation {
+namespace buffer {
+class OffsetCurveVertexList;
+}
+}
+}
+
+namespace geos {
+namespace operation { // geos.operation
+namespace buffer { // geos.operation.buffer
+
+/** \brief
+ * Contains the parameters which
+ * describe how a buffer should be constructed.
+ *
+ */
+class GEOS_DLL BufferParameters {
+
+public:
+
+    /// End cap styles
+    enum EndCapStyle {
+
+        /// Specifies a round line buffer end cap style.
+        CAP_ROUND = 1,
+
+        /// Specifies a flat line buffer end cap style.
+        CAP_FLAT = 2,
+
+        /// Specifies a square line buffer end cap style.
+        CAP_SQUARE = 3
+    };
+
+    /// Join styles
+    enum JoinStyle {
+
+        /// Specifies a round join style.
+        JOIN_ROUND = 1,
+
+        /// Specifies a mitre join style.
+        JOIN_MITRE = 2,
+
+        /// Specifies a bevel join style.
+        JOIN_BEVEL = 3
+    };
+
+    /// \brief
+    /// The default number of facets into which to divide a fillet
+    /// of 90 degrees.
+    ///
+    /// A value of 8 gives less than 2% max error in the buffer distance.
+    /// For a max error of < 1%, use QS = 12.
+    /// For a max error of < 0.1%, use QS = 18.
+    ///
+    static const int DEFAULT_QUADRANT_SEGMENTS = 8;
+
+    /// The default mitre limit
+    ///
+    /// Allows fairly pointy mitres.
+    ///
+    static const double DEFAULT_MITRE_LIMIT; // 5.0 (in .cpp file)
+
+    /// Creates a default set of parameters
+    BufferParameters();
+
+    /// Creates a set of parameters with the given quadrantSegments value.
+    ///
+    /// @param quadrantSegments the number of quadrant segments to use
+    ///
+    BufferParameters(int quadrantSegments);
+
+    /// \brief
+    /// Creates a set of parameters with the
+    /// given quadrantSegments and endCapStyle values.
+    ///
+    /// @param quadrantSegments the number of quadrant segments to use
+    /// @param endCapStyle the end cap style to use
+    ///
+    BufferParameters(int quadrantSegments, EndCapStyle endCapStyle);
+
+    /// \brief
+    /// Creates a set of parameters with the
+    /// given parameter values.
+    ///
+    /// @param quadrantSegments the number of quadrant segments to use
+    /// @param endCapStyle the end cap style to use
+    /// @param joinStyle the join style to use
+    /// @param mitreLimit the mitre limit to use
+    ///
+    BufferParameters(int quadrantSegments, EndCapStyle endCapStyle,
+                     JoinStyle joinStyle, double mitreLimit);
+
+    /// Gets the number of quadrant segments which will be used
+    ///
+    /// @return the number of quadrant segments
+    ///
+    int
+    getQuadrantSegments() const
+    {
+        return quadrantSegments;
+    }
+
+    /// \brief
+    /// Sets the number of line segments used to approximate
+    /// an angle fillet.
+    ///
+    /// - If <tt>quadSegs</tt> >= 1, joins are round,
+    ///   and <tt>quadSegs</tt> indicates the number of
+    ///   segments to use to approximate a quarter-circle.
+    /// - If <tt>quadSegs</tt> = 0, joins are bevelled (flat)
+    /// - If <tt>quadSegs</tt> < 0, joins are mitred, and the value of qs
+    ///   indicates the mitre ration limit as
+    ///   <pre>
+    ///    mitreLimit = |<tt>quadSegs</tt>|
+    ///    </pre>
+    ///
+    /// For round joins, <tt>quadSegs</tt> determines the maximum
+    /// error in the approximation to the true buffer curve.
+    ///
+    /// The default value of 8 gives less than 2% max error in the
+    /// buffer distance.
+    ///
+    /// For a max error of < 1%, use QS = 12.
+    /// For a max error of < 0.1%, use QS = 18.
+    /// The error is always less than the buffer distance
+    /// (in other words, the computed buffer curve is always inside
+    ///  the true curve).
+    ///
+    /// @param quadSegs the number of segments in a fillet for a quadrant
+    void setQuadrantSegments(int quadSegs);
+
+    /// \brief
+    /// Computes the maximum distance error due to a given level
+    /// of approximation to a true arc.
+    ///
+    /// @param quadSegs the number of segments used to approximate
+    ///                 a quarter-circle
+    /// @return the error of approximation
+    ///
+    static double bufferDistanceError(int quadSegs);
+
+    /// Gets the end cap style.
+    ///
+    /// @return the end cap style
+    ///
+    EndCapStyle
+    getEndCapStyle() const
+    {
+        return endCapStyle;
+    }
+
+    /// Specifies the end cap style of the generated buffer.
+    ///
+    /// The styles supported are CAP_ROUND, CAP_BUTT,
+    /// and CAP_SQUARE.
+    ///
+    /// The default is CAP_ROUND.
+    ///
+    /// @param style the end cap style to specify
+    ///
+    void
+    setEndCapStyle(EndCapStyle style)
+    {
+        endCapStyle = style;
+    }
+
+    /// Gets the join style.
+    ///
+    /// @return the join style
+    ///
+    JoinStyle
+    getJoinStyle() const
+    {
+        return joinStyle;
+    }
+
+    /// \brief
+    /// Sets the join style for outside (reflex) corners between
+    /// line segments.
+    ///
+    /// Allowable values are JOIN_ROUND (which is the default),
+    /// JOIN_MITRE and JOIN_BEVEL.
+    ///
+    /// @param style the code for the join style
+    ///
+    void
+    setJoinStyle(JoinStyle style)
+    {
+        joinStyle = style;
+    }
+
+    /// Gets the mitre ratio limit.
+    ///
+    /// @return the limit value
+    ///
+    double
+    getMitreLimit() const
+    {
+        return mitreLimit;
+    }
+
+    /// Sets the limit on the mitre ratio used for very sharp corners.
+    ///
+    /// The mitre ratio is the ratio of the distance from the corner
+    /// to the end of the mitred offset corner.
+    /// When two line segments meet at a sharp angle,
+    /// a miter join will extend far beyond the original geometry.
+    /// (and in the extreme case will be infinitely far.)
+    /// To prevent unreasonable geometry, the mitre limit
+    /// allows controlling the maximum length of the join corner.
+    /// Corners with a ratio which exceed the limit will be beveled.
+    ///
+    /// @param limit the mitre ratio limit
+    ///
+    void
+    setMitreLimit(double limit)
+    {
+        mitreLimit = limit;
+    }
+
+    /**
+     * Sets whether the computed buffer should be single-sided.
+     * A single-sided buffer is constructed on only one side of each input line.
+     *
+     * The side used is determined by the sign of the buffer distance:
+     * - a positive distance indicates the left-hand side
+     * - a negative distance indicates the right-hand side
+     *
+     * The single-sided buffer of point geometries is
+     * the same as the regular buffer.
+     *
+     * The End Cap Style for single-sided buffers is
+     * always ignored,
+     * and forced to the equivalent of <tt>CAP_FLAT</tt>.
+     *
+     * @param p_isSingleSided true if a single-sided buffer should be constructed
+     */
+    void
+    setSingleSided(bool p_isSingleSided)
+    {
+        _isSingleSided = p_isSingleSided;
+    }
+
+    /**
+     * Tests whether the buffer is to be generated on a single side only.
+     *
+     * @return true if the generated buffer is to be single-sided
+     */
+    bool
+    isSingleSided() const
+    {
+        return _isSingleSided;
+    }
+
+
+private:
+
+    /// Defaults to DEFAULT_QUADRANT_SEGMENTS;
+    int quadrantSegments;
+
+    /// Defaults to CAP_ROUND;
+    EndCapStyle endCapStyle;
+
+    /// Defaults to JOIN_ROUND;
+    JoinStyle joinStyle;
+
+    /// Defaults to DEFAULT_MITRE_LIMIT;
+    double mitreLimit;
+
+    bool _isSingleSided;
+};
+
+} // namespace geos::operation::buffer
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/Android-x86_64/include/geos/operation/buffer/BufferSubgraph.h

@@ -0,0 +1,202 @@
+/**********************************************************************
+ *
+ * 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: operation/buffer/BufferSubgraph.java r378 (JTS-1.12)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <geos/operation/buffer/RightmostEdgeFinder.h> // for composition
+
+#include <vector>
+#include <set>
+
+#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 Coordinate;
+class Envelope;
+}
+namespace algorithm {
+class CGAlgorithms;
+}
+namespace geomgraph {
+class DirectedEdge;
+class Node;
+}
+}
+
+namespace geos {
+namespace operation { // geos.operation
+namespace buffer { // geos.operation.buffer
+
+/**
+ * \brief
+ * A connected subset of the graph of DirectedEdge and geomgraph::Node.
+ *
+ * Its edges will generate either
+ * - a single polygon in the complete buffer, with zero or more holes, or
+ * -  ne or more connected holes
+ */
+class GEOS_DLL BufferSubgraph {
+private:
+    RightmostEdgeFinder finder;
+
+    std::vector<geomgraph::DirectedEdge*> dirEdgeList;
+
+    std::vector<geomgraph::Node*> nodes;
+
+    geom::Coordinate* rightMostCoord;
+
+    geom::Envelope* env;
+
+    /** \brief
+     * Adds all nodes and edges reachable from this node to the subgraph.
+     *
+     * Uses an explicit stack to avoid a large depth of recursion.
+     *
+     * @param startNode a node known to be in the subgraph
+     */
+    void addReachable(geomgraph::Node* startNode);
+
+    /// Adds the argument node and all its out edges to the subgraph
+    ///
+    /// @param node the node to add
+    /// @param nodeStack the current set of nodes being traversed
+    ///
+    void add(geomgraph::Node* node, std::vector<geomgraph::Node*>* nodeStack);
+
+    void clearVisitedEdges();
+
+    /** \brief
+     * Compute depths for all dirEdges via breadth-first traversal
+     * of nodes in graph
+     *
+     * @param startEdge edge to start processing with
+     */
+    // <FIX> MD - use iteration & queue rather than recursion, for speed and robustness
+    void computeDepths(geomgraph::DirectedEdge* startEdge);
+
+    void computeNodeDepth(geomgraph::Node* n);
+
+    void copySymDepths(geomgraph::DirectedEdge* de);
+
+    bool contains(std::set<geomgraph::Node*>& nodes, geomgraph::Node* node);
+
+public:
+
+    friend std::ostream& operator<< (std::ostream& os, const BufferSubgraph& bs);
+
+    BufferSubgraph();
+
+    ~BufferSubgraph();
+
+    std::vector<geomgraph::DirectedEdge*>* getDirectedEdges();
+
+    std::vector<geomgraph::Node*>* getNodes();
+
+    /** \brief
+     * Gets the rightmost coordinate in the edges of the subgraph
+     */
+    geom::Coordinate* getRightmostCoordinate();
+
+    /** \brief
+     * Creates the subgraph consisting of all edges reachable from
+     * this node.
+     *
+     * Finds the edges in the graph and the rightmost coordinate.
+     *
+     * @param node a node to start the graph traversal from
+     */
+    void create(geomgraph::Node* node);
+
+    void computeDepth(int outsideDepth);
+
+    /** \brief
+     * Find all edges whose depths indicates that they are in the
+     * result area(s).
+     *
+     * Since we want polygon shells to be
+     * oriented CW, choose dirEdges with the interior of the result
+     * on the RHS.
+     * Mark them as being in the result.
+     * Interior Area edges are the result of dimensional collapses.
+     * They do not form part of the result area boundary.
+     */
+    void findResultEdges();
+
+    /** \brief
+     * BufferSubgraphs are compared on the x-value of their rightmost
+     * Coordinate.
+     *
+     * This defines a partial ordering on the graphs such that:
+     *
+     * g1 >= g2 <==> Ring(g2) does not contain Ring(g1)
+     *
+     * where Polygon(g) is the buffer polygon that is built from g.
+     *
+     * This relationship is used to sort the BufferSubgraphs so
+     * that shells are guaranteed to
+     * be built before holes.
+     */
+    int compareTo(BufferSubgraph*);
+
+    /** \brief
+     * Computes the envelope of the edges in the subgraph.
+     * The envelope is cached after being computed.
+     *
+     * @return the envelope of the graph.
+     */
+    geom::Envelope* getEnvelope();
+};
+
+std::ostream& operator<< (std::ostream& os, const BufferSubgraph& bs);
+
+// INLINES
+inline geom::Coordinate*
+BufferSubgraph::getRightmostCoordinate()
+{
+    return rightMostCoord;
+}
+
+inline std::vector<geomgraph::Node*>*
+BufferSubgraph::getNodes()
+{
+    return &nodes;
+}
+
+inline std::vector<geomgraph::DirectedEdge*>*
+BufferSubgraph::getDirectedEdges()
+{
+    return &dirEdgeList;
+}
+
+bool BufferSubgraphGT(BufferSubgraph* first, BufferSubgraph* second);
+
+} // namespace geos::operation::buffer
+} // namespace geos::operation
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+