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

package/dist/prebuilt/iOS-iphoneos/include/geos/operation/distance/FacetSequenceTreeBuilder.h

@@ -1,69 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2016 Daniel Baston
- *
- * 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/distance/FacetSequenceTreeBuilder.java (f6187ee2 JTS-1.14)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/index/ItemVisitor.h>
-#include <geos/index/strtree/TemplateSTRtree.h>
-#include <geos/geom/Geometry.h>
-#include <geos/geom/CoordinateSequence.h>
-#include <geos/operation/distance/FacetSequence.h>
-
-namespace geos {
-namespace operation {
-namespace distance {
-class GEOS_DLL FacetSequenceTreeBuilder {
-private:
-    // 6 seems to be a good facet sequence size
-    static const std::size_t FACET_SEQUENCE_SIZE = 6;
-
-    // Seems to be better to use a minimum node capacity
-    static const std::size_t STR_TREE_NODE_CAPACITY = 4;
-
-    static void addFacetSequences(const geom::Geometry* geom,
-                                  const geom::CoordinateSequence* pts,
-                                  std::vector<FacetSequence> & sections);
-    static std::vector<FacetSequence> computeFacetSequences(const geom::Geometry* g);
-
-    class FacetSequenceTree : public geos::index::strtree::TemplateSTRtree<const FacetSequence*> {
-    public:
-        // TODO support TemplateSTRtree<std::unique_ptr<FacetSequence>> and dispense with holding vector.
-        FacetSequenceTree(std::vector<FacetSequence> &&seq) :
-            TemplateSTRtree(STR_TREE_NODE_CAPACITY, seq.size()), sequences(seq) {
-            for (auto& fs : sequences) {
-                TemplateSTRtree::insert(fs.getEnvelope(), &fs);
-            }
-        }
-
-    private:
-        std::vector<FacetSequence> sequences;
-    };
-
-public:
-    /** \brief
-     * Return a tree of FacetSequences constructed from the supplied Geometry.
-     *
-     * The FacetSequences are owned by the tree and are automatically deleted by
-     * the tree on destruction.
-     */
-    static std::unique_ptr<geos::index::strtree::TemplateSTRtree<const FacetSequence*>> build(const geom::Geometry* g);
-};
-}
-}
-}
-

package/dist/prebuilt/iOS-iphoneos/include/geos/operation/distance/GeometryLocation.h

@@ -1,126 +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/distance/GeometryLocation.java rev. 1.7 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-
-#include <geos/geom/Coordinate.h> // for composition
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class Geometry;
-}
-}
-
-
-namespace geos {
-namespace operation { // geos::operation
-namespace distance { // geos::operation::distance
-
-
-/** \brief
- * Represents the location of a point on a Geometry.
- *
- * Maintains both the actual point location
- * (which may not be exact, if the point is not a vertex)
- * as well as information about the component
- * and segment index where the point occurs.
- * Locations inside area Geometrys will not have an associated segment index,
- * so in this case the segment index will have the sentinel value of
- * INSIDE_AREA.
- */
-class GEOS_DLL GeometryLocation {
-private:
-    const geom::Geometry* component;
-    std::size_t segIndex;
-    bool inside_area;
-    geom::CoordinateXY pt;
-public:
-    /** \brief
-     * A Special value of segmentIndex used for locations
-     * inside area geometries.
-     *
-     * These locations are not located on a segment,
-     * and thus do not have an associated segment index.
-     */
-    static const int INSIDE_AREA = -1;
-
-    GeometryLocation() :
-        component(nullptr),
-        segIndex(0),
-        inside_area(false),
-        pt()
-    {}
-
-    /** \brief
-     * Constructs a GeometryLocation specifying a point on a geometry,
-     * as well as the segment that the point is on (or INSIDE_AREA if
-     * the point is not on a segment).
-     *
-     * @param component the component of the geometry containing the point
-     * @param segIndex the segment index of the location, or INSIDE_AREA
-     * @param pt the coordinate of the location
-     */
-    GeometryLocation(const geom::Geometry* component,
-                     std::size_t segIndex, const geom::CoordinateXY& pt);
-
-    /** \brief
-     * Constructs a GeometryLocation specifying a point inside an
-     * area geometry.
-     *
-     * @param component the component of the geometry containing the point
-     * @param pt the coordinate of the location
-     */
-    GeometryLocation(const geom::Geometry* component,
-                     const geom::CoordinateXY& pt);
-
-    /**
-     * Returns the geometry component on (or in) which this location occurs.
-     */
-    const geom::Geometry* getGeometryComponent();
-
-    /**
-     * Returns the segment index for this location.
-     *
-     * If the location is inside an
-     * area, the index will have the value INSIDE_AREA;
-     *
-     * @return the segment index for the location, or INSIDE_AREA
-     */
-    std::size_t getSegmentIndex();
-
-    /**
-     * Returns the geom::Coordinate of this location.
-     */
-    geom::CoordinateXY& getCoordinate();
-
-    /** \brief
-     * Tests whether this location represents a point
-     * inside an area geometry.
-     */
-    bool isInsideArea();
-
-    std::string toString();
-};
-
-} // namespace geos::operation::distance
-} // namespace geos::operation
-} // namespace geos
-

package/dist/prebuilt/iOS-iphoneos/include/geos/operation/distance/IndexedFacetDistance.h

@@ -1,124 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2016 Daniel Baston
- *
- * 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/distance/IndexedFacetDistance.java (f6187ee2 JTS-1.14)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/operation/distance/FacetSequenceTreeBuilder.h>
-
-namespace geos {
-namespace operation {
-namespace distance {
-
-/// \brief Computes the distance between the facets (segments and vertices)
-/// of two [Geometrys](\ref geom::Geometry) using a Branch-and-Bound algorithm.
-///
-/// The Branch-and-Bound algorithm operates over a traversal of R-trees built
-/// on the target and the query geometries.
-///
-/// This approach provides the following benefits:
-///
-/// - Performance is dramatically improved due to the use of the R-tree index
-///   and the pruning due to the Branch-and-Bound approach
-/// - The spatial index on the target geometry is cached which allow reuse in
-///   an repeated query situation.
-///
-/// Using this technique is usually much more performant than using the
-/// brute-force geom::Geometry::distance() when one
-/// or both input geometries are large, or when evaluating many distance
-/// computations against a single geometry.
-///
-/// \author Martin Davis
-class GEOS_DLL IndexedFacetDistance {
-public:
-
-    /// \brief Creates a new distance-finding instance for a given target geom::Geometry.
-    ///
-    /// Distances will be computed to all facets of the input geometry.
-    /// The facets of the geometry are the discrete segments and points
-    /// contained in its components.
-    /// In the case of lineal and puntal inputs, this is equivalent to computing
-    /// the conventional distance.
-    /// In the case of polygonal inputs, this is equivalent to computing the
-    /// distance to the polygon boundaries.
-    ///
-    /// \param g a Geometry, which may be of any type.
-    IndexedFacetDistance(const geom::Geometry* g) :
-        cachedTree(FacetSequenceTreeBuilder::build(g)),
-        baseGeometry(*g)
-    {}
-
-    /// \brief Computes the distance between facets of two geometries.
-    ///
-    /// For geometries with many segments or points, this can be faster than
-    /// using a simple distance algorithm.
-    ///
-    /// \param g1 a geometry
-    /// \param g2 a geometry
-    /// \return the distance between facets of the geometries
-    static double distance(const geom::Geometry* g1, const geom::Geometry* g2);
-
-    /// \brief Computes the nearest points of the facets of two geometries.
-    ///
-    /// \param g1 a geometry
-    /// \param g2 a geometry
-    /// \return the nearest points on the facets of the geometries
-    static std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g1, const geom::Geometry* g2);
-
-    /// \brief Computes the distance from the base geometry to the given geometry.
-    ///
-    /// \param g the geometry to compute the distance to
-    ///
-    /// \return the computed distance
-    double distance(const geom::Geometry* g) const;
-
-    /// \brief Tests whether the base geometry lies within a specified distance of the given geometry.
-    ///
-    /// \param g the geometry to test
-    /// \param maxDistance the maximum distance to test
-    ///
-    /// \return true of the geometry lies within the specified distance
-    bool isWithinDistance(const geom::Geometry* g, double maxDistance) const;
-
-    /// \brief Computes the nearest locations on the base geometry and the given geometry.
-    ///
-    /// \param g the geometry to compute the nearest location to
-    /// \return the nearest locations
-    std::vector<GeometryLocation> nearestLocations(const geom::Geometry* g) const;
-
-    /// \brief Compute the nearest locations on the target geometry and the given geometry.
-    ///
-    /// \param g the geometry to compute the nearest point to
-    /// \return the nearest points
-    std::unique_ptr<geom::CoordinateSequence> nearestPoints(const geom::Geometry* g) const;
-
-private:
-    struct FacetDistance {
-        double operator()(const FacetSequence* a, const FacetSequence* b) const
-        {
-            return a->distance(*b);
-        }
-    };
-
-    std::unique_ptr<geos::index::strtree::TemplateSTRtree<const FacetSequence*>> cachedTree;
-    const geom::Geometry& baseGeometry;
-
-};
-}
-}
-}
-

package/dist/prebuilt/iOS-iphoneos/include/geos/operation/intersection/Rectangle.h

@@ -1,236 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * Copyright (C) 2014 Mika Heiskanen <mika.heiskanen@fmi.fi>
- *
- * 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 <memory>
-
-#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 GeometryFactory;
-class Geometry;
-class Polygon;
-class LinearRing;
-}
-}
-
-namespace geos {
-namespace operation { // geos::operation
-namespace intersection { // geos::operation::intersection
-
-/**
- * \brief Clipping rectangle
- *
- * A clipping rectangle defines the boundaries of the rectangle
- * by defining the limiting x- and y-coordinates. The clipping
- * rectangle must be non-empty. In addition, methods are provided
- * for specifying the location of a given coordinate with respect
- * to the clipping rectangle similarly to the Cohen-Sutherland
- * clipping algorithm.
- *
- */
-
-class GEOS_DLL Rectangle {
-public:
-
-    /**
-     * \brief Construct a clipping rectangle
-     *
-     * @param x1 x-coordinate of the left edge
-     * @param y1 y-coordinate of the bottom edge
-     * @param x2 x-coordinate of the right edge
-     * @param y2 y-coordinate of the right edge
-     * @throws IllegalArgumentException if the rectangle is empty
-     */
-
-    Rectangle(double x1, double y1, double x2, double y2);
-
-    /**
-     * @return the minimum x-coordinate of the rectangle
-     */
-    double
-    xmin() const
-    {
-        return xMin;
-    }
-
-    /**
-     * @return the minimum y-coordinate of the rectangle
-     */
-
-    double
-    ymin() const
-    {
-        return yMin;
-    }
-
-
-    /**
-     * @return the maximum x-coordinate of the rectangle
-     */
-
-    double
-    xmax() const
-    {
-        return xMax;
-    }
-
-
-    /**
-     * @return the maximum y-coordinate of the rectangle
-     */
-
-    double
-    ymax() const
-    {
-        return yMax;
-    }
-
-    /**
-     * @return the rectangle as a polygon geometry
-     *
-     * @note Ownership transferred to caller
-     */
-    std::unique_ptr<geom::Polygon> toPolygon(const geom::GeometryFactory& f) const;
-
-    std::unique_ptr<geom::LinearRing> toLinearRing(const geom::GeometryFactory& f) const;
-
-    /**
-     * @brief Position with respect to a clipping rectangle
-     */
-
-    enum Position {
-        Inside    = 1,
-        Outside   = 2,
-
-        Left        = 4,
-        Top         = 8,
-        Right       = 16,
-        Bottom      = 32,
-
-        TopLeft     = Top | Left,               // 12
-        TopRight    = Top | Right,              // 24
-        BottomLeft  = Bottom | Left,            // 36
-        BottomRight = Bottom | Right            // 48
-    };
-
-    /**
-     * @brief Test if the given position is on a Rectangle edge
-     * @param pos Rectangle::Position
-     * @return `true`, if the position is on an edge
-     */
-
-    static bool
-    onEdge(Position pos)
-    {
-        return (pos > Outside);
-    }
-
-    /**
-     * @brief Test if the given positions are on the same Rectangle edge
-     * @param pos1 [Position](@ref Rectangle::Position) of first coordinate
-     * @param pos2 [Position](@ref Rectangle::Position) of second coordinate
-     * @return `true`, if the positions are on the same edge
-     */
-
-    static bool
-    onSameEdge(Position pos1, Position pos2)
-    {
-        return onEdge(Position(pos1 & pos2));
-    }
-
-    /**
-     * @brief Establish position of coordinate with respect to a Rectangle
-     * @param x x-coordinate
-     * @param y y-coordinate
-     * @return [Position](@ref Rectangle::Position) of the coordinate
-     */
-
-    Position
-    position(double x, double y) const
-    {
-        // We assume the point to be inside and test it first
-        if(x > xMin && x < xMax && y > yMin && y < yMax) {
-            return Inside;
-        }
-        // Next we assume the point to be outside and test it next
-        if(x < xMin || x > xMax || y < yMin || y > yMax) {
-            return Outside;
-        }
-        // Slower cases
-        unsigned int pos = 0;
-        if(x == xMin) {
-            pos |= Left;
-        }
-        else if(x == xMax) {
-            pos |= Right;
-        }
-        if(y == yMin) {
-            pos |= Bottom;
-        }
-        else if(y == yMax) {
-            pos |= Top;
-        }
-        return Position(pos);
-    }
-
-    /**
-     * @brief Next edge in clock-wise direction
-     * @param pos [Position](@ref Rectangle::Position)
-     * @return next [Position](@ref Rectangle::Position) in clock-wise direction
-     */
-
-    static Position
-    nextEdge(Position pos)
-    {
-        switch(pos) {
-        case BottomLeft:
-        case Left:
-            return Top;
-        case TopLeft:
-        case Top:
-            return Right;
-        case TopRight:
-        case Right:
-            return Bottom;
-        case BottomRight:
-        case Bottom:
-            return Left;
-        /* silences compiler warnings, Inside & Outside are not handled explicitly */
-        default:
-            return pos;
-        }
-    }
-
-private:
-
-    Rectangle();
-    double xMin;
-    double yMin;
-    double xMax;
-    double yMax;
-
-}; // class RectangleIntersection
-
-} // namespace geos::operation::intersection
-} // namespace geos::operation
-} // namespace geos
-