@cpp.js/package-geos 1.0.0 → 2.0.0-beta.1

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/buffer/OffsetSegmentGenerator.h

@@ -1,390 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011  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/OffsetSegmentGenerator.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
-#include <geos/operation/buffer/BufferParameters.h> // for composition
-#include <geos/operation/buffer/OffsetSegmentString.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 geos {
-namespace operation { // geos.operation
-namespace buffer { // geos.operation.buffer
-
-/**
- * Generates segments which form an offset curve.
- * Supports all end cap and join options
- * provided for buffering.
- * Implements various heuristics to
- * produce smoother, simpler curves which are
- * still within a reasonable tolerance of the
- * true curve.
- *
- * @author Martin Davis
- *
- */
-class GEOS_DLL OffsetSegmentGenerator {
-
-public:
-
-    /*
-     * @param nBufParams buffer parameters, this object will
-     *                   keep a reference to the passed parameters
-     *                   so caller must make sure the object is
-     *                   kept alive for the whole lifetime of
-     *                   the buffer builder.
-     */
-    OffsetSegmentGenerator(const geom::PrecisionModel* newPrecisionModel,
-                           const BufferParameters& bufParams, double distance);
-
-    /**
-     * Tests whether the input has a narrow concave angle
-     * (relative to the offset distance).
-     * In this case the generated offset curve will contain self-intersections
-     * and heuristic closing segments.
-     * This is expected behaviour in the case of buffer curves.
-     * For pure offset curves,
-     * the output needs to be further treated
-     * before it can be used.
-     *
-     * @return true if the input has a narrow concave angle
-     */
-    bool
-    hasNarrowConcaveAngle() const
-    {
-        return _hasNarrowConcaveAngle;
-    }
-
-    void initSideSegments(const geom::Coordinate& nS1,
-                          const geom::Coordinate& nS2, int nSide);
-
-    /// Get coordinates by taking ownership of them
-    ///
-    /// After this call, the coordinates reference in
-    /// this object are dropped. Calling twice will
-    /// segfault...
-    ///
-    /// FIXME: refactor memory management of this
-    ///
-    void
-    getCoordinates(std::vector<geom::CoordinateSequence*>& to)
-    {
-        to.push_back(segList.getCoordinates());
-    }
-
-    std::unique_ptr<geom::CoordinateSequence>
-    getCoordinates()
-    {
-        return std::unique_ptr<geom::CoordinateSequence>(segList.getCoordinates());
-    }
-
-    void
-    closeRing()
-    {
-        segList.closeRing();
-    }
-
-    /// Adds a CW circle around a point
-    void createCircle(const geom::Coordinate& p, double distance);
-
-    /// Adds a CW square around a point
-    void createSquare(const geom::Coordinate& p, double distance);
-
-    /// Add first offset point
-    void
-    addFirstSegment()
-    {
-        segList.addPt(offset1.p0);
-    }
-
-    /// Add last offset point
-    void
-    addLastSegment()
-    {
-        segList.addPt(offset1.p1);
-    }
-
-    void addNextSegment(const geom::Coordinate& p, bool addStartPoint);
-
-    /// \brief
-    /// Add an end cap around point p1, terminating a line segment
-    /// coming from p0
-    void addLineEndCap(const geom::Coordinate& p0,
-                       const geom::Coordinate& p1);
-
-    void
-    addSegments(const geom::CoordinateSequence& pts, bool isForward)
-    {
-        segList.addPts(pts, isForward);
-    }
-
-    /** \brief
-     * Compute an offset segment for an input segment on a given
-     * side and at a given distance.
-     *
-     * The offset points are computed in full double precision,
-     * for accuracy.
-     *
-     * @param seg the segment to offset
-     * @param side the side of the segment the offset lies on
-     * @param distance the offset distance
-     * @param offset the points computed for the offset segment
-     */
-    static void computeOffsetSegment(const geom::LineSegment& seg,
-                              int side, double distance,
-                              geom::LineSegment& offset);
-
-private:
-
-    /**
-     * Factor which controls how close offset segments can be to
-     * skip adding a filler or mitre.
-     */
-    static const double OFFSET_SEGMENT_SEPARATION_FACTOR; // 1.0E-3;
-
-    /**
-     * Factor which controls how close curve vertices on inside turns
-     * can be to be snapped
-     */
-    static const double INSIDE_TURN_VERTEX_SNAP_DISTANCE_FACTOR; // 1.0E-3;
-
-    /**
-     * Factor which controls how close curve vertices can be to be snapped
-     */
-    static const double CURVE_VERTEX_SNAP_DISTANCE_FACTOR; //  1.0E-6;
-
-    /**
-     * Factor which determines how short closing segs can be for round buffers
-     */
-    static const int MAX_CLOSING_SEG_LEN_FACTOR = 80;
-
-    /** \brief
-     * the max error of approximation (distance) between a quad segment and
-     * the true fillet curve
-     */
-    double maxCurveSegmentError; // 0.0
-
-    /** \brief
-     * The angle quantum with which to approximate a fillet curve
-     * (based on the input # of quadrant segments)
-     */
-    double filletAngleQuantum;
-
-    /// The Closing Segment Factor controls how long "closing
-    /// segments" are.  Closing segments are added at the middle of
-    /// inside corners to ensure a smoother boundary for the buffer
-    /// offset curve.  In some cases (particularly for round joins
-    /// with default-or-better quantization) the closing segments
-    /// can be made quite short.  This substantially improves
-    /// performance (due to fewer intersections being created).
-    ///
-    /// A closingSegFactor of 0 results in lines to the corner vertex.
-    /// A closingSegFactor of 1 results in lines halfway
-    /// to the corner vertex.
-    /// A closingSegFactor of 80 results in lines 1/81 of the way
-    /// to the corner vertex (this option is reasonable for the very
-    /// common default situation of round joins and quadrantSegs >= 8).
-    ///
-    /// The default is 1.
-    ///
-    int closingSegLengthFactor; // 1;
-
-    /// Owned by this object, destroyed by dtor
-    ///
-    /// This actually gets created multiple times
-    /// and each of the old versions is pushed
-    /// to the ptLists std::vector to ensure all
-    /// created CoordinateSequences are properly
-    /// destroyed.
-    ///
-    OffsetSegmentString segList;
-
-    double distance;
-
-    const geom::PrecisionModel* precisionModel;
-
-    const BufferParameters& bufParams;
-
-    algorithm::LineIntersector li;
-
-    geom::Coordinate s0, s1, s2;
-
-    geom::LineSegment seg0;
-
-    geom::LineSegment seg1;
-
-    geom::LineSegment offset0;
-
-    geom::LineSegment offset1;
-
-    int side;
-
-    bool _hasNarrowConcaveAngle; // =false
-
-    void addCollinear(bool addStartPoint);
-
-    /// The mitre will be beveled if it exceeds the mitre ratio limit.
-    ///
-    /// @param offset0 the first offset segment
-    /// @param offset1 the second offset segment
-    /// @param distance the offset distance
-    ///
-    void addMitreJoin(const geom::Coordinate& cornerPt,
-                      const geom::LineSegment& offset0,
-                      const geom::LineSegment& offset1,
-                      double distance);
-
-
-    /// Adds a limited mitre join connecting two convex offset segments.
-    /// A limited mitre join is beveled at the distance
-    /// determined by the mitre limit factor,
-    /// or as a standard bevel join, whichever is further.
-    ///
-    /// @param offset0 the first offset segment
-    /// @param offset1 the second offset segment
-    /// @param distance the offset distance
-    /// @param mitreLimitDistance the mitre limit ratio
-    ///
-    void addLimitedMitreJoin(
-        const geom::LineSegment& offset0,
-        const geom::LineSegment& offset1,
-        double distance,
-        double mitreLimitDistance);
-
-    /**
-    * Extends a line segment forwards or backwards a given distance.
-    *
-    * @param seg the base line segment
-    * @param dist the distance to extend by
-    * @return the extended segment
-    */
-    static geom::LineSegment extend(const geom::LineSegment& seg, double dist);
-
-    /**
-    * Adds a bevel join connecting the two offset segments
-    * around a reflex corner.
-    * Projects a point to a given distance in a given direction angle.
-    *
-    * @param pt the point to project
-    * @param d the projection distance
-    * @param dir the direction angle (in radians)
-    * @return the projected point
-    */
-    static geom::Coordinate project(const geom::Coordinate& pt, double d, double dir);
-
-    /// \brief
-    /// Adds a bevel join connecting the two offset segments
-    /// around a reflex corner.
-    ///
-    /// @param offset0 the first offset segment
-    /// @param offset1 the second offset segment
-    ///
-    void addBevelJoin(const geom::LineSegment& offset0,
-                      const geom::LineSegment& offset1);
-
-    static const double PI; //  3.14159265358979
-
-    // Not in JTS, used for single-sided buffers
-    int endCapIndex;
-
-    void init(double newDistance);
-
-    /**
-     * Use a value which results in a potential distance error which is
-     * significantly less than the error due to
-     * the quadrant segment discretization.
-     * For QS = 8 a value of 100 is reasonable.
-     * This should produce a maximum of 1% distance error.
-     */
-    static const double SIMPLIFY_FACTOR; // 100.0;
-
-    /// Adds the offset points for an outside (convex) turn
-    ///
-    /// @param orientation
-    /// @param addStartPoint
-    ///
-    void addOutsideTurn(int orientation, bool addStartPoint);
-
-    /// Adds the offset points for an inside (concave) turn
-    ///
-    /// @param orientation
-    /// @param addStartPoint
-    ///
-    void addInsideTurn(int orientation, bool addStartPoint);
-
-    /**
-     * Adds points for a circular fillet around a reflex corner.
-     *
-     * Adds the start and end points
-     *
-     * @param p base point of curve
-     * @param p0 start point of fillet curve
-     * @param p1 endpoint of fillet curve
-     * @param direction the orientation of the fillet
-     * @param radius the radius of the fillet
-     */
-    void addDirectedFillet(const geom::Coordinate& p, const geom::Coordinate& p0,
-                   const geom::Coordinate& p1,
-                   int direction, double radius);
-
-    /**
-     * Adds points for a circular fillet arc between two specified angles.
-     *
-     * The start and end point for the fillet are not added -
-     * the caller must add them if required.
-     *
-     * @param direction is -1 for a CW angle, 1 for a CCW angle
-     * @param radius the radius of the fillet
-     */
-    void addDirectedFillet(const geom::Coordinate& p, double startAngle,
-                   double endAngle, int direction, double radius);
-private:
-    // An OffsetSegmentGenerator cannot be copied because of member "const BufferParameters& bufParams"
-    // Not declaring these functions triggers MSVC warning C4512: "assignment operator could not be generated"
-    OffsetSegmentGenerator(const OffsetSegmentGenerator&);
-    void operator=(const OffsetSegmentGenerator&);
-
-};
-
-} // namespace geos::operation::buffer
-} // namespace geos::operation
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/buffer/OffsetSegmentString.h

@@ -1,215 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
- * Copyright (C) 2007 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/OffsetSegmentString.java r378 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/geom/Coordinate.h> // for inlines
-#include <geos/geom/CoordinateSequence.h> // for inlines
-#include <geos/geom/PrecisionModel.h> // for inlines
-
-#include <vector>
-#include <memory>
-#include <cassert>
-
-namespace geos {
-namespace operation { // geos.operation
-namespace buffer { // geos.operation.buffer
-
-/// A dynamic list of the vertices in a constructed offset curve.
-///
-/// Automatically removes close vertices
-/// which are closer than a given tolerance.
-///
-/// @author Martin Davis
-///
-class OffsetSegmentString {
-
-private:
-
-    geom::CoordinateSequence* ptList;
-
-    const geom::PrecisionModel* precisionModel;
-
-    /** \brief
-     * The distance below which two adjacent points on the curve
-     * are considered to be coincident.
-     *
-     * This is chosen to be a small fraction of the offset distance.
-     */
-    double minimumVertexDistance;
-
-    /** \brief
-     * Tests whether the given point is redundant relative to the previous
-     * point in the list (up to tolerance)
-     *
-     * @param pt
-     * @return true if the point is redundant
-     */
-    bool
-    isRedundant(const geom::Coordinate& pt) const
-    {
-        if(ptList->size() < 1) {
-            return false;
-        }
-        const geom::Coordinate& lastPt = ptList->back();
-        double ptDist = pt.distance(lastPt);
-        if(ptDist < minimumVertexDistance) {
-            return true;
-        }
-        return false;
-    }
-
-    OffsetSegmentString(const OffsetSegmentString&) = delete;
-    OffsetSegmentString& operator=(const OffsetSegmentString&) = delete;
-
-public:
-
-    friend std::ostream& operator<< (std::ostream& os, const OffsetSegmentString& node);
-
-    OffsetSegmentString()
-        :
-        ptList(new geom::CoordinateSequence()),
-        precisionModel(nullptr),
-        minimumVertexDistance(0.0)
-    {
-    }
-
-    ~OffsetSegmentString()
-    {
-        delete ptList;
-    }
-
-    void
-    reset()
-    {
-        if(ptList) {
-            ptList->clear();
-        }
-        else {
-            ptList = new geom::CoordinateSequence();
-        }
-
-        precisionModel = nullptr;
-        minimumVertexDistance = 0.0;
-    }
-
-    void
-    setPrecisionModel(const geom::PrecisionModel* nPrecisionModel)
-    {
-        precisionModel = nPrecisionModel;
-    }
-
-    void
-    setMinimumVertexDistance(double nMinVertexDistance)
-    {
-        minimumVertexDistance = nMinVertexDistance;
-    }
-
-    void
-    addPt(const geom::Coordinate& pt)
-    {
-        assert(precisionModel);
-
-        geom::Coordinate bufPt = pt;
-        precisionModel->makePrecise(bufPt);
-        // don't add duplicate (or near-duplicate) points
-        if(isRedundant(bufPt)) {
-            return;
-        }
-        // we ask to allow repeated as we checked this ourself
-        // (JTS uses a vector for ptList, not a CoordinateSequence,
-        // we should do the same)
-        ptList->add(bufPt, true);
-    }
-
-    void
-    addPts(const geom::CoordinateSequence& pts, bool isForward)
-    {
-        if(isForward) {
-            for(std::size_t i = 0, n = pts.size(); i < n; ++i) {
-                addPt(pts[i]);
-            }
-        }
-        else {
-            for(std::size_t i = pts.size(); i > 0; --i) {
-                addPt(pts[i - 1]);
-            }
-        }
-    }
-
-    /// Check that points are a ring
-    ///
-    /// add the startpoint again if they are not
-    void
-    closeRing()
-    {
-        if(ptList->size() < 1) {
-            return;
-        }
-        const geom::Coordinate& startPt = ptList->front();
-        const geom::Coordinate& lastPt = ptList->back();
-        if(startPt.equals(lastPt)) {
-            return;
-        }
-        // we ask to allow repeated as we checked this ourself
-        ptList->add(startPt, true);
-    }
-
-    /// Get coordinates by taking ownership of them
-    ///
-    /// After this call, the coordinates reference in
-    /// this object are dropped. Calling twice will
-    /// segfault...
-    ///
-    /// FIXME: refactor memory management of this
-    ///
-    geom::CoordinateSequence*
-    getCoordinates()
-    {
-        closeRing();
-        geom::CoordinateSequence* ret = ptList;
-        ptList = nullptr;
-        return ret;
-    }
-
-    inline size_t
-    size() const
-    {
-        return ptList ? ptList->size() : 0 ;
-    }
-
-};
-
-inline std::ostream&
-operator<< (std::ostream& os,
-            const OffsetSegmentString& lst)
-{
-    if(lst.ptList) {
-        os << *(lst.ptList);
-    }
-    else {
-        os << "empty (consumed?)";
-    }
-    return os;
-}
-
-} // namespace geos.operation.buffer
-} // namespace geos.operation
-} // namespace geos
-

package/dist/prebuilt/Android-arm64-v8a/include/geos/operation/buffer/RightmostEdgeFinder.h

@@ -1,105 +0,0 @@
-/**********************************************************************
- *
- * 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/RightmostEdgeFinder.java r320 (JTS-1.12)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Coordinate.h> // for composition
-
-#include <vector>
-
-// Forward declarations
-namespace geos {
-namespace geom {
-}
-namespace geomgraph {
-class DirectedEdge;
-}
-}
-
-namespace geos {
-namespace operation { // geos.operation
-namespace buffer { // geos.operation.buffer
-
-/**
- * \brief
- * A RightmostEdgeFinder find the geomgraph::DirectedEdge in a list which has
- * the highest coordinate, and which is oriented L to R at that point.
- * (I.e. the right side is on the RHS of the edge.)
- */
-class GEOS_DLL RightmostEdgeFinder {
-
-private:
-
-    int minIndex;
-
-    geom::Coordinate minCoord;
-
-    geomgraph::DirectedEdge* minDe;
-
-    geomgraph::DirectedEdge* orientedDe;
-
-    void findRightmostEdgeAtNode();
-
-    void findRightmostEdgeAtVertex();
-
-    void checkForRightmostCoordinate(geomgraph::DirectedEdge* de);
-
-    int getRightmostSide(geomgraph::DirectedEdge* de, int index);
-
-    static int getRightmostSideOfSegment(geomgraph::DirectedEdge* de, int i);
-
-public:
-
-    /** \brief
-     * A RightmostEdgeFinder finds the geomgraph::DirectedEdge with the
-     * rightmost coordinate.
-     *
-     * The geomgraph::DirectedEdge returned is guaranteed to have the R of
-     * the world on its RHS.
-     */
-    RightmostEdgeFinder();
-
-    geomgraph::DirectedEdge* getEdge();
-
-    geom::Coordinate& getCoordinate();
-
-    /// Note that only Forward DirectedEdges will be checked
-    void findEdge(std::vector<geomgraph::DirectedEdge*>* dirEdgeList);
-};
-
-/*public*/
-inline geomgraph::DirectedEdge*
-RightmostEdgeFinder::getEdge()
-{
-    return orientedDe;
-}
-
-/*public*/
-inline geom::Coordinate&
-RightmostEdgeFinder::getCoordinate()
-{
-    return minCoord;
-}
-
-
-} // namespace geos::operation::buffer
-} // namespace geos::operation
-} // namespace geos
-