@cpp.js/package-geos 1.0.0-beta.20 → 1.0.0-beta.22

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/chain/MonotoneChain.h

@@ -1,205 +0,0 @@
-/**********************************************************************
- *
- * GEOS - Geometry Engine Open Source
- * http://geos.osgeo.org
- *
- * 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: index/chain/MonotoneChain.java rev. 1.15 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/CoordinateSequence.h> // for inline
-#include <geos/geom/Envelope.h> // for inline
-#include <geos/geom/LineSegment.h> // for inline
-
-#include <memory> // for unique_ptr
-
-// Forward declarations
-namespace geos {
-namespace geom {
-class LineSegment;
-class CoordinateSequence;
-}
-namespace index {
-namespace chain {
-class MonotoneChainSelectAction;
-class MonotoneChainOverlapAction;
-}
-}
-}
-
-namespace geos {
-namespace index { // geos::index
-namespace chain { // geos::index::chain
-
-/** \brief
- * Monotone Chains are a way of partitioning the segments of a linestring to
- * allow for fast searching of intersections.
- *
- * They have the following properties:
- *
- * - the segments within a monotone chain never intersect each other
- * - the envelope of any contiguous subset of the segments in a monotone
- *   chain is equal to the envelope of the endpoints of the subset.
- *
- * Property 1 means that there is no need to test pairs of segments from
- * within the same monotone chain for intersection.
- * Property 2 allows an efficient binary search to be used to find the
- * intersection points of two monotone chains.
- *
- * For many types of real-world data, these properties eliminate
- * a large number of segment comparisons, producing substantial speed gains.
- *
- * One of the goals of this implementation of MonotoneChains is to be
- * as space and time efficient as possible. One design choice that aids this
- * is that a MonotoneChain is based on a subarray of a list of points.
- * This means that new arrays of points (potentially very large) do not
- * have to be allocated.
- *
- * MonotoneChains support the following kinds of queries:
- *
- * - Envelope select: determine all the segments in the chain which
- *   intersect a given envelope
- * - Overlap: determine all the pairs of segments in two chains whose
- *   envelopes overlap
- *
- * This implementation of MonotoneChains uses the concept of internal iterators
- * to return the resultsets for the above queries.
- * This has time and space advantages, since it
- * is not necessary to build lists of instantiated objects to represent the segments
- * returned by the query.
- * However, it does mean that the queries are not thread-safe.
- *
- */
-class GEOS_DLL MonotoneChain {
-public:
-
-    /// @param pts
-    ///   Ownership left to caller, this class holds a reference.
-    ///
-    /// @param start
-    ///
-    /// @param end
-    ///
-    /// @param context
-    ///   Ownership left to caller, this class holds a reference.
-    ///
-    MonotoneChain(const geom::CoordinateSequence& pts,
-                  std::size_t start, std::size_t end, void* context);
-
-    ~MonotoneChain() = default;
-
-    /// Returned envelope is owned by this class
-    const geom::Envelope& getEnvelope() const;
-    const geom::Envelope& getEnvelope(double expansionDistance) const;
-
-    size_t
-    getStartIndex() const
-    {
-        return start;
-    }
-
-    size_t
-    getEndIndex() const
-    {
-        return end;
-    }
-
-    /** \brief
-     *  Set given LineSegment with points of the segment starting
-     *  at the given index.
-     */
-    void getLineSegment(std::size_t index, geom::LineSegment& ls) const {
-        pts->getAt(index, ls.p0);
-        pts->getAt(index + 1, ls.p1);
-    }
-
-    /**
-     * Return the subsequence of coordinates forming this chain.
-     * Allocates a new CoordinateSequence to hold the Coordinates
-     *
-     */
-    std::unique_ptr<geom::CoordinateSequence> getCoordinates() const;
-
-    /**
-     * Determine all the line segments in the chain whose envelopes overlap
-     * the searchEnvelope, and process them
-     */
-    void select(const geom::Envelope& searchEnv,
-                MonotoneChainSelectAction& mcs) const;
-
-    void computeOverlaps(const MonotoneChain* mc,
-                         MonotoneChainOverlapAction* mco) const;
-
-    void computeOverlaps(const MonotoneChain* mc, double overlapTolerance,
-                         MonotoneChainOverlapAction* mco) const;
-
-    void*
-    getContext() const
-    {
-        return context;
-    }
-
-private:
-
-    void computeSelect(const geom::Envelope& searchEnv,
-                       std::size_t start0,
-                       std::size_t end0,
-                       MonotoneChainSelectAction& mcs) const;
-
-    void computeOverlaps(std::size_t start0, std::size_t end0, const MonotoneChain& mc,
-                         std::size_t start1, std::size_t end1,
-                         double overlapTolerance,
-                         MonotoneChainOverlapAction& mco) const;
-
-    bool overlaps(std::size_t start0, std::size_t end0,
-                  const MonotoneChain& mc, std::size_t start1, std::size_t end1,
-                  double overlapTolerance) const {
-        if (overlapTolerance > 0.0) {
-            return overlaps(pts->getAt<geom::CoordinateXY>(start0),
-                            pts->getAt<geom::CoordinateXY>(end0),
-                            mc.pts->getAt<geom::CoordinateXY>(start1),
-                            mc.pts->getAt<geom::CoordinateXY>(end1),
-                            overlapTolerance);
-        }
-        return geom::Envelope::intersects(pts->getAt<geom::CoordinateXY>(start0),
-                                          pts->getAt<geom::CoordinateXY>(end0),
-                                          mc.pts->getAt<geom::CoordinateXY>(start1),
-                                          mc.pts->getAt<geom::CoordinateXY>(end1));
-    }
-
-    static bool overlaps(const geom::CoordinateXY& p1, const geom::CoordinateXY& p2,
-                  const geom::CoordinateXY& q1, const geom::CoordinateXY& q2,
-                  double overlapTolerance);
-
-    /// Externally owned
-    const geom::CoordinateSequence* pts;
-
-    /// user-defined information
-    void* context;
-
-    /// Index of chain start vertex into the CoordinateSequence, 0 based.
-    std::size_t start;
-
-    /// Index of chain end vertex into the CoordinateSequence, 0 based.
-    std::size_t end;
-
-    /// Owned by this class
-    mutable geom::Envelope env;
-};
-
-} // namespace geos::index::chain
-} // namespace geos::index
-} // namespace geos
-

package/dist/prebuilt/geos_c.xcframework/ios-arm64_arm64e_x86_64-simulator/Headers/geos/index/quadtree/Quadtree.h

@@ -1,200 +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: index/quadtree/Quadtree.java rev. 1.16 (JTS-1.10)
- *
- **********************************************************************/
-
-#pragma once
-
-#include <geos/export.h>
-#include <geos/geom/Envelope.h>
-#include <geos/index/SpatialIndex.h> // for inheritance
-#include <geos/index/quadtree/Root.h> // for composition
-
-#include <memory>
-#include <vector>
-#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 index {
-namespace quadtree {
-// class Root;
-}
-}
-}
-
-namespace geos {
-namespace index { // geos::index
-namespace quadtree { // geos::index::quadtree
-
-/**
- * \brief
- * A Quadtree is a spatial index structure for efficient querying
- * of 2D rectangles.  If other kinds of spatial objects
- * need to be indexed they can be represented by their
- * envelopes
- *
- * The quadtree structure is used to provide a primary filter
- * for range rectangle queries.  The query() method returns a list of
- * all objects which <i>may</i> intersect the query rectangle.  Note that
- * it may return objects which do not in fact intersect.
- * A secondary filter is required to test for exact intersection.
- * Of course, this secondary filter may consist of other tests besides
- * intersection, such as testing other kinds of spatial relationships.
- *
- * This implementation does not require specifying the extent of the inserted
- * items beforehand.  It will automatically expand to accomodate any extent
- * of dataset.
- *
- * This data structure is also known as an <i>MX-CIF quadtree</i>
- * following the usage of Samet and others.
- */
-class GEOS_DLL Quadtree: public SpatialIndex {
-
-private:
-
-    std::vector<std::unique_ptr<geom::Envelope>> newEnvelopes;
-
-    void collectStats(const geom::Envelope& itemEnv);
-
-    Root root;
-
-    /**
-     *  Statistics
-     *
-     * minExtent is the minimum envelope extent of all items
-     * inserted into the tree so far. It is used as a heuristic value
-     * to construct non-zero envelopes for features with zero X and/or
-     * Y extent.
-     * Start with a non-zero extent, in case the first feature inserted has
-     * a zero extent in both directions.  This value may be non-optimal, but
-     * only one feature will be inserted with this value.
-     */
-    double minExtent;
-
-public:
-    /**
-     * \brief
-     * Ensure that the envelope for the inserted item has non-zero extents.
-     *
-     * Use the current minExtent to pad the envelope, if necessary.
-     * Can return a new Envelope or the given one (casted to non-const).
-     */
-    static geom::Envelope* ensureExtent(const geom::Envelope* itemEnv,
-                                        double minExtent);
-
-    /**
-     * \brief
-     * Constructs a Quadtree with zero items.
-     */
-    Quadtree()
-        :
-        root(),
-        minExtent(1.0)
-    {}
-
-    ~Quadtree() override = default;
-
-    /// Returns the number of levels in the tree.
-    std::size_t depth();
-
-    /// Returns the number of items in the tree.
-    std::size_t size();
-
-    void insert(const geom::Envelope* itemEnv, void* item) override;
-
-    /** \brief
-     * Queries the tree and returns items which may lie
-     * in the given search envelope.
-     *
-     * Precisely, the items that are returned are all items in the tree
-     * whose envelope <b>may</b> intersect the search Envelope.
-     * Note that some items with non-intersecting envelopes may be
-     * returned as well;
-     * the client is responsible for filtering these out.
-     * In most situations there will be many items in the tree which do not
-     * intersect the search envelope and which are not returned - thus
-     * providing improved performance over a simple linear scan.
-     *
-     * @param searchEnv the envelope of the desired query area.
-     * @param ret a vector where items which may intersect the
-     * 	      search envelope are pushed
-     */
-    void query(const geom::Envelope* searchEnv, std::vector<void*>& ret) override;
-
-
-    /** \brief
-     * Queries the tree and visits items which may lie in
-     * the given search envelope.
-     *
-     * Precisely, the items that are visited are all items in the tree
-     * whose envelope <b>may</b> intersect the search Envelope.
-     * Note that some items with non-intersecting envelopes may be
-     * visited as well;
-     * the client is responsible for filtering these out.
-     * In most situations there will be many items in the tree which do not
-     * intersect the search envelope and which are not visited - thus
-     * providing improved performance over a simple linear scan.
-     *
-     * @param searchEnv the envelope of the desired query area.
-     * @param visitor a visitor object which is passed the visited items
-     */
-    void
-    query(const geom::Envelope* searchEnv, ItemVisitor& visitor) override
-    {
-        /*
-         * the items that are matched are the items in quads which
-         * overlap the search envelope
-         */
-        root.visit(searchEnv, visitor);
-    }
-
-    /**
-     * Removes a single item from the tree.
-     *
-     * @param itemEnv the Envelope of the item to be removed
-     * @param item the item to remove
-     * @return <code>true</code> if the item was found (and thus removed)
-     */
-    bool remove(const geom::Envelope* itemEnv, void* item) override;
-
-    /// Return a list of all items in the Quadtree
-    std::vector<void*>* queryAll();
-
-    std::string toString() const;
-
-    /**
-     * Disable copy construction and assignment. Apparently needed to make this
-     * class compile under MSVC. (See https://stackoverflow.com/q/29565299)
-     */
-    Quadtree(const Quadtree&) = delete;
-    Quadtree& operator=(const Quadtree&) = delete;
-
-};
-
-} // namespace geos::index::quadtree
-} // namespace geos::index
-} // namespace geos
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-