@crossbind/port-geos-linuxmusl 0.0.0-stage → 2.0.0-beta.64

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/ScaledNoder.h

@@ -0,0 +1,132 @@
+/**********************************************************************
+ *
+ * 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: noding/ScaledNoder.java rev. 1.3 (JTS-1.7.1)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+
+#include <cassert>
+#include <vector>
+
+#include <geos/noding/Noder.h> // for inheritance
+#include <geos/util.h>
+
+#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 CoordinateSequence;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/** \brief
+ * Wraps a {@link Noder} and transforms its input
+ * into the integer domain.
+ *
+ * This is intended for use with Snap-Rounding noders,
+ * which typically are only intended to work in the integer domain.
+ * Offsets can be provided to increase the number of digits of
+ * available precision.
+ *
+ */
+class GEOS_DLL ScaledNoder : public Noder { // , public geom::CoordinateFilter { // implements Noder
+
+public:
+
+    bool
+    isIntegerPrecision()
+    {
+        return (scaleFactor == 1.0);
+    }
+
+    ScaledNoder(Noder& n, double nScaleFactor,
+                double nOffsetX = 0.0, double nOffsetY = 0.0)
+        :
+        noder(n),
+        scaleFactor(nScaleFactor),
+        offsetX(nOffsetX),
+        offsetY(nOffsetY),
+        isScaled(nScaleFactor != 1.0)
+    {}
+
+    ~ScaledNoder() override;
+
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+
+    void computeNodes(const std::vector<SegmentString*>& inputSegStr) override;
+
+    //void filter(Coordinate& c);
+
+    void
+    filter_ro(const geom::Coordinate* c)
+    {
+        ::geos::ignore_unused_variable_warning(c);
+        assert(0);
+    }
+
+    void filter_rw(geom::Coordinate* c) const;
+
+private:
+
+    Noder& noder;
+
+    double scaleFactor;
+
+    double offsetX;
+
+    double offsetY;
+
+    bool isScaled;
+
+    void rescale(std::vector<std::unique_ptr<SegmentString>>& segStrings) const;
+
+    void scale(const std::vector<SegmentString*>& segStrings) const;
+
+    class Scaler;
+
+    class ReScaler;
+
+    friend class ScaledNoder::Scaler;
+
+    friend class ScaledNoder::ReScaler;
+
+    mutable std::vector<geom::CoordinateSequence*> newCoordSeq;
+
+    // Declare type as noncopyable
+    ScaledNoder(const ScaledNoder& other) = delete;
+    ScaledNoder& operator=(const ScaledNoder& rhs) = delete;
+};
+
+} // namespace geos.noding
+} // namespace geos
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/SegmentExtractingNoder.h

@@ -0,0 +1,90 @@
+/**********************************************************************
+ *
+ * GEOS - Geometry Engine Open Source
+ * http://geos.osgeo.org
+ *
+ * Copyright (C) 2021 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/Coordinate.h>
+#include <geos/geom/Envelope.h>
+#include <geos/noding/Noder.h>
+#include <geos/noding/snap/SnappingPointIndex.h>
+
+
+// Forward declarations
+namespace geos {
+namespace geom {
+class Envelope;
+class PrecisionModel;
+}
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos::noding
+
+/**
+ * A noder which extracts all line segments
+ * as SegmentString.
+ * This enables fast overlay of geometries which are known to be already fully noded.
+ * In particular, it provides fast union of polygonal and linear coverages.
+ * Unioning a noded set of lines is an effective way
+ * to perform line merging and line dissolving.
+ *
+ * No precision reduction is carried out.
+ * If that is required, another noder must be used (such as a snap-rounding noder),
+ * or the input must be precision-reduced beforehand.
+ *
+ */
+class GEOS_DLL SegmentExtractingNoder : public Noder {
+
+private:
+
+    std::vector<std::unique_ptr<SegmentString>> segList;
+
+    void extractSegments(
+        const std::vector<SegmentString*>& inputSegs,
+        std::vector<std::unique_ptr<SegmentString>>& outputSegs);
+
+    void extractSegments(
+        const SegmentString* ss,
+        std::vector<std::unique_ptr<SegmentString>>& outputSegs);
+
+
+public:
+
+    /**
+    * Creates a new segment-extracting noder.
+    */
+    SegmentExtractingNoder() = default;
+
+    void computeNodes(const std::vector<SegmentString*>& segStrings) override;
+
+    /**
+    * @return a Collection of SegmentString representing the
+    * substrings. Caller takes ownership over vector and contents.
+    */
+    std::vector<std::unique_ptr<SegmentString>> getNodedSubstrings() override;
+
+    // Declare type as noncopyable
+    SegmentExtractingNoder(SegmentExtractingNoder const&) = delete;
+    SegmentExtractingNoder& operator=(SegmentExtractingNoder const&) = delete;
+
+};
+
+
+} // namespace geos::noding
+} // namespace geos

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/SegmentIntersectionDetector.h

@@ -0,0 +1,177 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cstddef>
+#include <geos/noding/SegmentIntersector.h>
+#include <geos/algorithm/LineIntersector.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/noding/SegmentString.h>
+
+namespace geos {
+namespace noding { // geos::noding
+
+/** \brief
+ * Detects and records an intersection between two {@link SegmentString}s,
+ * if one exists.
+ *
+ * This strategy can be configured to search for proper intersections.
+ * In this case, the presence of any intersection will still be recorded,
+ * but searching will continue until either a proper intersection has been found
+ * or no intersections are detected.
+ *
+ * Only a single intersection is recorded.
+ *
+ * @version 1.7
+ */
+class SegmentIntersectionDetector : public SegmentIntersector {
+private:
+    algorithm::LineIntersector* li;
+
+    bool findProper;
+    bool findAllTypes;
+
+    bool _hasIntersection;
+    bool _hasProperIntersection;
+    bool _hasNonProperIntersection;
+
+    const geom::Coordinate* intPt;
+    geom::CoordinateSequence* intSegments;
+
+protected:
+public:
+    SegmentIntersectionDetector(algorithm::LineIntersector* p_li)
+        :
+        li(p_li),
+        findProper(false),
+        findAllTypes(false),
+        _hasIntersection(false),
+        _hasProperIntersection(false),
+        _hasNonProperIntersection(false),
+        intPt(nullptr),
+        intSegments(nullptr)
+    { }
+
+    ~SegmentIntersectionDetector() override
+    {
+        //delete intPt;
+        delete intSegments;
+    }
+
+
+    void
+    setFindProper(bool p_findProper)
+    {
+        this->findProper = p_findProper;
+    }
+
+    void
+    setFindAllIntersectionTypes(bool p_findAllTypes)
+    {
+        this->findAllTypes = p_findAllTypes;
+    }
+
+    /** \brief
+     * Tests whether an intersection was found.
+     *
+     * @return true if an intersection was found
+     */
+    bool
+    hasIntersection() const
+    {
+        return _hasIntersection;
+    }
+
+    /** \brief
+     * Tests whether a proper intersection was found.
+     *
+     * @return `true` if a proper intersection was found
+     */
+    bool
+    hasProperIntersection() const
+    {
+        return _hasProperIntersection;
+    }
+
+    /** \brief
+     * Tests whether a non-proper intersection was found.
+     *
+     * @return true if a non-proper intersection was found
+     */
+    bool
+    hasNonProperIntersection() const
+    {
+        return _hasNonProperIntersection;
+    }
+
+    /** \brief
+    * Gets the computed location of the intersection.
+    * Due to round-off, the location may not be exact.
+    *
+    * @return the coordinate for the intersection location
+    */
+    const geom::Coordinate*
+    getIntersection()  const
+    {
+        return intPt;
+    }
+
+
+    /** \brief
+     * Gets the endpoints of the intersecting segments.
+     *
+     * @return an array of the segment endpoints (p00, p01, p10, p11)
+     */
+    const geom::CoordinateSequence*
+    getIntersectionSegments() const
+    {
+        return intSegments;
+    }
+
+    bool
+    isDone() const override
+    {
+        // If finding all types, we can stop
+        // when both possible types have been found.
+        if(findAllTypes) {
+            return _hasProperIntersection && _hasNonProperIntersection;
+        }
+
+        // If searching for a proper intersection, only stop if one is found
+        if(findProper) {
+            return _hasProperIntersection;
+        }
+
+        return _hasIntersection;
+    }
+
+    /** \brief
+     * This method is called by clients of the SegmentIntersector class to process
+     * intersections for two segments of the {@link SegmentString}s being intersected.
+     *
+     * @note Some clients (such as `MonotoneChains`) may optimize away
+     *       this call for segment pairs which they have determined do not intersect
+     *       (e.g. by an disjoint envelope test).
+     */
+    void processIntersections(noding::SegmentString* e0, std::size_t segIndex0,
+                              noding::SegmentString* e1, std::size_t segIndex1) override;
+
+};
+
+} // namespace geos::noding
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/SegmentIntersector.h

@@ -0,0 +1,89 @@
+/**********************************************************************
+ *
+ * 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.
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <cstddef>
+#include <geos/export.h>
+
+// Forward declarations
+namespace geos {
+namespace noding {
+class SegmentString;
+}
+}
+
+namespace geos {
+namespace noding { // geos.noding
+
+/**
+ * \brief
+ * Processes possible intersections detected by a Noder.
+ *
+ * The SegmentIntersector is passed to a Noder.
+ * The addIntersections method is called whenever the Noder
+ * detects that two SegmentStrings <i>might</i> intersect.
+ * This class may be used either to find all intersections, or
+ * to detect the presence of an intersection.  In the latter case,
+ * Noders may choose to short-circuit their computation by calling the
+ * isDone method.
+ * This class is an example of the <i>Strategy</i> pattern.
+ *
+ * @version 1.7
+ */
+class GEOS_DLL SegmentIntersector {
+
+public:
+
+    /**
+     * This method is called by clients
+     * of the SegmentIntersector interface to process
+     * intersections for two segments of the SegmentStrings
+     * being intersected.
+     */
+    virtual void processIntersections(
+        SegmentString* e0,  std::size_t segIndex0,
+        SegmentString* e1,  std::size_t segIndex1) = 0;
+
+    /**
+     * \brief
+     * Reports whether the client of this class
+     * needs to continue testing all intersections in an arrangement.
+     *
+     * @return true if there is not need to continue testing segments
+     *
+     * The default implementation always return false (process all intersections).
+     */
+    virtual bool
+    isDone() const
+    {
+        return false;
+    }
+
+    virtual
+    ~SegmentIntersector()
+    { }
+
+protected:
+
+    SegmentIntersector() {}
+
+};
+
+/// Temporary typedef for namespace transition
+typedef SegmentIntersector nodingSegmentIntersector;
+
+} // namespace geos.noding
+} // namespace geos
+

package/dist/prebuilt/linuxmusl-x64-mt-release/include/geos/noding/SegmentNode.h

@@ -0,0 +1,161 @@
+/**********************************************************************
+ *
+ * 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: noding/SegmentNode.java 4667170ea (JTS-1.17)
+ *
+ **********************************************************************/
+
+#pragma once
+
+#include <geos/export.h>
+#include <geos/geom/Coordinate.h>
+#include <geos/noding/SegmentPointComparator.h>
+#include <geos/noding/SegmentString.h>
+
+#include <vector>
+#include <iostream>
+
+namespace geos {
+namespace noding { // geos.noding
+
+/**
+ * \brief
+ * Represents an intersection point between two NodedSegmentString.
+ *
+ * Final class.
+ */
+class GEOS_DLL SegmentNode {
+private:
+    int segmentOctant;
+
+    bool isInteriorVar;
+
+public:
+    friend std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
+
+    /// the point of intersection (own copy)
+    geom::CoordinateXYZM coord;
+
+    /// the index of the containing line segment in the parent edge
+    std::size_t segmentIndex;
+
+    /// Construct a node on the given NodedSegmentString
+    ///
+    /// @param ss the parent NodedSegmentString
+    ///
+    /// @param nCoord the coordinate of the intersection, will be copied
+    ///
+    /// @param nSegmentIndex the index of the segment on parent
+    ///                      NodedSegmentString
+    ///        where the Node is located.
+    ///
+    /// @param nSegmentOctant
+    ///
+    template<typename CoordType>
+    SegmentNode(const SegmentString& ss,
+        const CoordType& nCoord,
+        std::size_t nSegmentIndex, int nSegmentOctant)
+        : segmentOctant(nSegmentOctant)
+        , coord(nCoord)
+        , segmentIndex(nSegmentIndex)
+    {
+        // Number of points in NodedSegmentString is one-more number of segments
+        assert(segmentIndex < ss.size());
+        isInteriorVar = !coord.equals2D(ss.getCoordinate(segmentIndex));
+    }
+
+    ~SegmentNode() {}
+
+    /// \brief
+    /// Return true if this Node is *internal* (not on the boundary)
+    /// of the corresponding segment. Currently only the *first*
+    /// segment endpoint is checked, actually.
+    ///
+    bool
+    isInterior() const
+    {
+        return isInteriorVar;
+    }
+
+    bool isEndPoint(unsigned int maxSegmentIndex) const
+    {
+        if(segmentIndex == 0 && ! isInteriorVar) {
+            return true;
+        }
+        if(segmentIndex == maxSegmentIndex) {
+            return true;
+        }
+        return false;
+    };
+
+    /**
+     * @return -1 this EdgeIntersection is located before
+     *            the argument location
+     * @return 0 this EdgeIntersection is at the argument location
+     * @return 1 this EdgeIntersection is located after the
+     *           argument location
+     */
+    int compareTo(const SegmentNode& other) const
+    {
+        if (segmentIndex < other.segmentIndex) {
+            return -1;
+        }
+        if (segmentIndex > other.segmentIndex) {
+            return 1;
+        }
+
+        if (coord.equals2D(other.coord)) {
+
+            return 0;
+        }
+
+        // an exterior node is the segment start point,
+        // so always sorts first
+        // this guards against a robustness problem
+        // where the octants are not reliable
+        if (!isInteriorVar) return -1;
+        if (!other.isInteriorVar) return 1;
+
+        return SegmentPointComparator::compare(
+            segmentOctant, coord,
+            other.coord);
+    };
+
+};
+
+// std::ostream& operator<< (std::ostream& os, const SegmentNode& n);
+
+struct GEOS_DLL SegmentNodeLT {
+    bool
+    operator()(SegmentNode* s1, SegmentNode* s2) const
+    {
+        return s1->compareTo(*s2) < 0;
+    }
+
+    bool
+    operator()(const SegmentNode& s1, const SegmentNode& s2) const
+    {
+        return s1.compareTo(s2) < 0;
+    }
+};
+
+
+} // namespace geos.noding
+} // namespace geos
+
+
+
+
+
+