From git at osgeo.org Mon Nov 10 09:52:51 2025 From: git at osgeo.org (git at osgeo.org) Date: Mon, 10 Nov 2025 09:52:51 -0800 (PST) Subject: [geos-commits] [SCM] GEOS branch main updated. 93472ce0f6a02dd5dfcbf8e41eca4e75e714209f Message-ID: <20251110175251.5CA2C192042@trac.osgeo.org> This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GEOS". The branch, main has been updated via 93472ce0f6a02dd5dfcbf8e41eca4e75e714209f (commit) from b5960c3a08c3ccaffee019529f847dc02371a790 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 93472ce0f6a02dd5dfcbf8e41eca4e75e714209f Author: Daniel Baston Date: Mon Nov 10 12:52:28 2025 -0500 Buffer: Ensure buffer of single-part returns single-part (#1323) * Buffer: Ensure buffer of single-part returns single-part * Buffer: Move location of fix for #1321 * BufferOp: Add a test case diff --git a/src/operation/buffer/BufferBuilder.cpp b/src/operation/buffer/BufferBuilder.cpp index a5d423e9e..5cc5685d2 100644 --- a/src/operation/buffer/BufferBuilder.cpp +++ b/src/operation/buffer/BufferBuilder.cpp @@ -363,6 +363,25 @@ BufferBuilder::bufferLineSingleSided(const Geometry* g, double distance, } } +static void +keepLargestArea(std::vector> & polyList) { + size_t maxAreaGeom = 0; + double maxArea = polyList[0]->getArea(); + + for (size_t i = 1; i < polyList.size(); i++) { + if (polyList[i]->getArea() > maxArea) { + maxArea = polyList[i]->getArea(); + maxAreaGeom = i; + } + } + + if (maxAreaGeom > 0) { + polyList[0] = std::move(polyList[maxAreaGeom]); + } + + polyList.resize(1); +} + /*public*/ std::unique_ptr BufferBuilder::buffer(const Geometry* g, double distance) @@ -485,9 +504,18 @@ BufferBuilder::buffer(const Geometry* g, double distance) return createEmptyResultGeometry(); } + // Heuristic to remove artifacts caused by topology robustness problems + // or buffer curve generation anomalies. + // Uses fact that for distance > 0 single-element inputs must create single element buffers. + // This does not hold if distance <= 0; + // distance = 0 can create multipolygon results due to topology collapse, + // and distance < 0 may erode polygons so they are disconnected. + if (distance > 0 && g->getNumGeometries() == 1 && resultPolyList.size() > 1) { + keepLargestArea(resultPolyList); + } + // resultPolyList ownership transferred here resultGeom = geomFact->buildGeometry(std::move(resultPolyList)); - } catch(const util::GEOSException& /* exc */) { diff --git a/src/operation/buffer/BufferOp.cpp b/src/operation/buffer/BufferOp.cpp index 379ca1d4d..0bdbbfdb7 100644 --- a/src/operation/buffer/BufferOp.cpp +++ b/src/operation/buffer/BufferOp.cpp @@ -116,6 +116,7 @@ BufferOp::getResultGeometry(double nDistance) } distance = nDistance; computeGeometry(); + return std::unique_ptr(resultGeometry.release()); } diff --git a/tests/unit/operation/buffer/BufferOpTest.cpp b/tests/unit/operation/buffer/BufferOpTest.cpp index b51914ca8..7ac585ccc 100644 --- a/tests/unit/operation/buffer/BufferOpTest.cpp +++ b/tests/unit/operation/buffer/BufferOpTest.cpp @@ -598,7 +598,7 @@ void object::test<26> } // testElementErodedEx -// Checks that a skinny element polygon is eroded with no internal predicision reduction due to topo exes +// Checks that a skinny element polygon is eroded with no internal precision reduction due to topo exes // see https://github.com/libgeos/geos/issues/1182 template<> template<> @@ -623,4 +623,43 @@ void object::test<28> "MULTIPOLYGON (((24 95.239, 24 96, 24 99, 24.816 99, 24 95.239)), ((3 90, 3 93, 3 96, 3 99, 21 99, 21 96, 21 93, 21 90, 3 90)))"); } +template<> +template<> +void object::test<29> +() +{ + set_test_name("GH-1321"); + // Ensure positive buffer of LineString produces a single-part Polygon + // See https://github.com/libgeos/geos/issues/1321 + + std::string wkt = "LINESTRING(640770.332537465 216785.425146015,640770.356311913 216785.560172686,640770.475488952 216786.226162019,640770.647396495 216787.800152365,640770.658978918 216789.268376902,640770.447752096 216792.399898366,640769.98018796 216795.624688816,640769.110287021 216798.527305023,640767.648768098 216801.891389348,640766.02448565 216804.805892778,640764.74005588 216807.134569434,640763.337363474 216809.560477487,640761.650901703 216812.246990061,640759.955600712 216815.327305019,640758.482499366 216817.868732504,640757.383693167 216819.548488661,640756.238862077 216821.226720821,640754.01503683 216824.434442434,640751.366929134 216828.435255234,640749.204368809 216832.450088865,640747.25516891 216836.227787618,640746.014020829 216838.801219168,640745.393751588 216840.360274284,640744.315976633 216842.854457673,640743.400050801 216844.65704848,640742.582575565 216846.277673322,640741.52491745 216848.478638524,640740.503835408 216850.705816576,640739.787553975 2 16852.270967708,640739.053289307 216853.851968469,640738.173025147 216855.546355058,640737.55488951 216856.568961104,640736.817272035 216857.822910812,640735.910795021 216859.35697228,640734.77510795 216861.236982439,640733.832969266 216862.938074642,640732.814325629 216865.039674844,640731.225095251 216869.012141189,640729.979984761 216871.879095724,640729.445974092 216873.02148841,640729.002794006 216873.679857725,640728.952197105 216873.745389857,640728.676962154 216874.089814544)"; + + auto bufGeom = wktreader.read(wkt)->buffer(100); + + ensure_equals(bufGeom->getGeometryTypeId(), geos::geom::GEOS_POLYGON); + ensure(bufGeom->getArea() > 51000); +} + +template<> +template<> +void object::test<30> +() +{ + set_test_name("sf-2552"); + // Ensure positive buffer of LineString produces a single-part Polygon + // See https://github.com/r-spatial/sf/issues/2552 + + std::string wkt = "LINESTRING (245184.6 6045650, 245193.3 6045649, 245201.7 6045651, 245204.3 6045653)"; + + auto geom = wktreader.read(wkt); + + BufferOp bop(geom.get()); + bop.setEndCapStyle(BufferParameters::CAP_SQUARE); + + auto bufGeom = bop.getResultGeometry(50); + ensure_equals(bufGeom->getGeometryTypeId(), geos::geom::GEOS_POLYGON); + + ensure(bufGeom->getArea() > 12000); +} + } // namespace tut diff --git a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp index 73a8a3dd1..83f3e9e45 100644 --- a/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp +++ b/tests/unit/simplify/DouglasPeuckerSimplifierTest.cpp @@ -45,7 +45,7 @@ struct test_dpsimp_data { ensure("Simplified geometry is invalid!", simplified->isValid()); GeomPtr exp(wktreader.read(wkt_expected)); - ensure_equals_geometry(exp.get(), simplified.get()); + ensure_equals_geometry(simplified.get(), exp.get()); } void ----------------------------------------------------------------------- Summary of changes: src/operation/buffer/BufferBuilder.cpp | 30 +++++++++++++++- src/operation/buffer/BufferOp.cpp | 1 + tests/unit/operation/buffer/BufferOpTest.cpp | 41 +++++++++++++++++++++- .../unit/simplify/DouglasPeuckerSimplifierTest.cpp | 2 +- 4 files changed, 71 insertions(+), 3 deletions(-) hooks/post-receive -- GEOS From git at osgeo.org Sun Nov 16 14:11:26 2025 From: git at osgeo.org (git at osgeo.org) Date: Sun, 16 Nov 2025 14:11:26 -0800 (PST) Subject: [geos-commits] [SCM] GEOS branch main updated. e3b518f00ce17fecaed7289323829fc9bb7a1105 Message-ID: <20251116221127.72E4C189C86@trac.osgeo.org> This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "GEOS". The branch, main has been updated via e3b518f00ce17fecaed7289323829fc9bb7a1105 (commit) via 588f656cf4107d7cf34706544be03c9589878d5f (commit) via a1164a680593ef43aaa0bee11578abaac24b5dbd (commit) via b8cb43fc5b175e23496521319742e982192e1638 (commit) via 05ac5c6a2d02a98f4fc566ef86737ba9d324fb12 (commit) from 93472ce0f6a02dd5dfcbf8e41eca4e75e714209f (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit e3b518f00ce17fecaed7289323829fc9bb7a1105 Author: Daniel Baston Date: Wed Nov 12 14:46:37 2025 -0500 BoundaryChainNoder: mark some methods as static diff --git a/include/geos/noding/BoundaryChainNoder.h b/include/geos/noding/BoundaryChainNoder.h index ec98eb9da..a3fc72446 100644 --- a/include/geos/noding/BoundaryChainNoder.h +++ b/include/geos/noding/BoundaryChainNoder.h @@ -170,24 +170,24 @@ private: std::vector> extractChains(std::vector& sections) const; - Coordinate::UnorderedSet findNodePts( - const std::vector>& segStrings) const; + static Coordinate::UnorderedSet findNodePts( + const std::vector>& segStrings); - std::vector> nodeChains( + static std::vector> nodeChains( std::vector> &chains, const Coordinate::UnorderedSet &nodePts); - void nodeChain( + static void nodeChain( std::unique_ptr chain, const Coordinate::UnorderedSet &nodePts, std::vector> &nodedChains); - std::size_t findNodeIndex( + static std::size_t findNodeIndex( const SegmentString* chain, std::size_t start, - const Coordinate::UnorderedSet& nodePts) const; + const Coordinate::UnorderedSet& nodePts); - std::unique_ptr substring( + static std::unique_ptr substring( const SegmentString* segString, std::size_t start, std::size_t end); diff --git a/src/noding/BoundaryChainNoder.cpp b/src/noding/BoundaryChainNoder.cpp index b8348b24c..35b3a6bfe 100644 --- a/src/noding/BoundaryChainNoder.cpp +++ b/src/noding/BoundaryChainNoder.cpp @@ -48,7 +48,7 @@ BoundaryChainNoder::computeNodes(const std::vector& segStrings) /* private */ Coordinate::UnorderedSet -BoundaryChainNoder::findNodePts(const std::vector>& segStrings) const +BoundaryChainNoder::findNodePts(const std::vector>& segStrings) { Coordinate::UnorderedSet interiorVertices; Coordinate::UnorderedSet nodes; @@ -122,7 +122,7 @@ std::size_t BoundaryChainNoder::findNodeIndex( const SegmentString* chain, std::size_t start, - const Coordinate::UnorderedSet& nodePts) const + const Coordinate::UnorderedSet& nodePts) { for (std::size_t i = start + 1; i < chain->size(); i++) { if (nodePts.find(chain->getCoordinate(i)) != nodePts.end()) commit 588f656cf4107d7cf34706544be03c9589878d5f Author: Daniel Baston Date: Wed Nov 12 14:27:02 2025 -0500 BoundaryChainNoder: Add comment diff --git a/src/noding/BoundaryChainNoder.cpp b/src/noding/BoundaryChainNoder.cpp index f4346d9bb..b8348b24c 100644 --- a/src/noding/BoundaryChainNoder.cpp +++ b/src/noding/BoundaryChainNoder.cpp @@ -107,7 +107,10 @@ BoundaryChainNoder::nodeChain( std::unique_ptr BoundaryChainNoder::substring(const SegmentString* segString, std::size_t start, std::size_t end) { - // FIXME: Doesn't this leak "pts" ? + // A BasicSegmentString does not own its CoordinateSequence, so why does this not leak? + // At least in the CoverageUnion case, we end up here from EdgeNodingBuilder::node, where the + // created BasicSegmentStrings are (incorrectly) down-casted to NodedSegmentStrings, and + // the coordinate ownership is transferred to an overlayng::Edge. auto pts = std::make_unique(); pts->add(*segString->getCoordinates(), start, end); return std::make_unique(pts.release(), segString->getData()); commit a1164a680593ef43aaa0bee11578abaac24b5dbd Author: Daniel Baston Date: Wed Nov 12 12:22:44 2025 -0500 Noder::getNodedSubstrings: Return vector of unique_ptr diff --git a/include/geos/coverage/CoverageCleaner.h b/include/geos/coverage/CoverageCleaner.h index 8452a4925..79b0ed855 100644 --- a/include/geos/coverage/CoverageCleaner.h +++ b/include/geos/coverage/CoverageCleaner.h @@ -324,7 +324,7 @@ public: std::vector getMergedGaps(); std::unique_ptr toGeometry( - std::vector& segStrings, + std::vector>& segStrings, const GeometryFactory* geomFact); std::unique_ptr node( diff --git a/include/geos/geomgraph/EdgeNodingValidator.h b/include/geos/geomgraph/EdgeNodingValidator.h index 6f844d1e0..84a506b01 100644 --- a/include/geos/geomgraph/EdgeNodingValidator.h +++ b/include/geos/geomgraph/EdgeNodingValidator.h @@ -54,13 +54,13 @@ namespace geomgraph { // geos.geomgraph class GEOS_DLL EdgeNodingValidator final { private: - std::vector& toSegmentStrings(std::vector& edges); + const std::vector>& toSegmentStrings(std::vector& edges); // Make sure this member is initialized *before* // the NodingValidator, as initialization of // NodingValidator will use toSegmentString(), that // in turn expects this member to be initialized - std::vector segStr; + std::vector> segStr; // Make sure this member is initialized *before* // the NodingValidator, as initialization of diff --git a/include/geos/noding/BoundaryChainNoder.h b/include/geos/noding/BoundaryChainNoder.h index d46007497..ec98eb9da 100644 --- a/include/geos/noding/BoundaryChainNoder.h +++ b/include/geos/noding/BoundaryChainNoder.h @@ -66,8 +66,8 @@ private: SegmentString* segString; std::vector isBoundary; - static SegmentString* createChain( - const SegmentString* segString, + static std::unique_ptr createChain( + const SegmentString *segString, std::size_t startIndex, std::size_t endIndex, bool constructZ, @@ -84,7 +84,7 @@ private: }; void setBoundarySegment(std::size_t index); - void createChains(std::vector& chains, bool constructZ, bool constructM); + void createChains(std::vector> &chains, bool constructZ, bool constructM); }; class Segment { @@ -142,14 +142,14 @@ public: {}; // Noder virtual methods - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; void computeNodes(const std::vector& inputSegStrings) override; private: // Members - std::vector m_chainList; + std::vector> m_chainList; std::vector> m_substrings; bool m_constructZ; bool m_constructM; @@ -168,19 +168,19 @@ private: static void markBoundarySegments(SegmentSet& segSet); - std::vector extractChains(std::vector& sections) const; + std::vector> extractChains(std::vector& sections) const; Coordinate::UnorderedSet findNodePts( - const std::vector& segStrings) const; + const std::vector>& segStrings) const; - std::vector nodeChains( - const std::vector& chains, - const Coordinate::UnorderedSet& nodePts); + std::vector> nodeChains( + std::vector> &chains, + const Coordinate::UnorderedSet &nodePts); void nodeChain( - SegmentString* chain, - const Coordinate::UnorderedSet& nodePts, - std::vector& nodedChains); + std::unique_ptr chain, + const Coordinate::UnorderedSet &nodePts, + std::vector> &nodedChains); std::size_t findNodeIndex( const SegmentString* chain, diff --git a/include/geos/noding/FastNodingValidator.h b/include/geos/noding/FastNodingValidator.h index 6ceadc4a3..f2b004937 100644 --- a/include/geos/noding/FastNodingValidator.h +++ b/include/geos/noding/FastNodingValidator.h @@ -60,13 +60,16 @@ class FastNodingValidator { public: - FastNodingValidator(std::vector& newSegStrings) + FastNodingValidator(const std::vector>& newSegStrings) : li(), // robust... - segStrings(newSegStrings), segInt(), isValidVar(true) { + segStrings.resize(newSegStrings.size()); + for (std::size_t i = 0; i < newSegStrings.size(); ++i) { + segStrings[i] = newSegStrings[i].get(); + } } /** \brief @@ -102,7 +105,7 @@ private: geos::algorithm::LineIntersector li; - std::vector& segStrings; + std::vector segStrings; std::unique_ptr segInt; diff --git a/include/geos/noding/GeometryNoder.h b/include/geos/noding/GeometryNoder.h index 437307fac..ea3b3c347 100644 --- a/include/geos/noding/GeometryNoder.h +++ b/include/geos/noding/GeometryNoder.h @@ -45,6 +45,10 @@ public: std::unique_ptr getNoded(); + // Declare type as noncopyable + GeometryNoder(GeometryNoder const&) = delete; + GeometryNoder& operator=(GeometryNoder const&) = delete; + private: const geom::Geometry& argGeom; @@ -58,10 +62,8 @@ private: std::unique_ptr noder; - std::unique_ptr toGeometry(SegmentString::NonConstVect& noded); + std::unique_ptr toGeometry(std::vector>& noded); - GeometryNoder(GeometryNoder const&); /*= delete*/ - GeometryNoder& operator=(GeometryNoder const&); /*= delete*/ }; } // namespace geos.noding diff --git a/include/geos/noding/IteratedNoder.h b/include/geos/noding/IteratedNoder.h index 6e55ecb8a..1d2bc296a 100644 --- a/include/geos/noding/IteratedNoder.h +++ b/include/geos/noding/IteratedNoder.h @@ -57,7 +57,7 @@ private: const geom::PrecisionModel* pm; algorithm::LineIntersector li; - std::vector nodedSegStrings; + std::vector> nodedSegStrings; int maxIter; /** @@ -96,7 +96,7 @@ public: maxIter = n; } - std::vector + std::vector> getNodedSubstrings() override { return std::move(nodedSegStrings); @@ -113,6 +113,10 @@ public: * @throws TopologyException if the iterated noding fails to converge. */ void computeNodes(const std::vector& inputSegmentStrings) override; // throw(GEOSException); + + // Declare type as noncopyable + IteratedNoder(IteratedNoder const&) = delete; + IteratedNoder& operator=(IteratedNoder const&) = delete; }; } // namespace geos::noding diff --git a/include/geos/noding/MCIndexNoder.h b/include/geos/noding/MCIndexNoder.h index 5a4965710..d2e02453c 100644 --- a/include/geos/noding/MCIndexNoder.h +++ b/include/geos/noding/MCIndexNoder.h @@ -101,7 +101,7 @@ public: return index; } - std::vector getNodedSubstrings() override + std::vector> getNodedSubstrings() override { //assert(nodedSegStrings); // must have called computeNodes before! return NodedSegmentString::getNodedSubstrings(nodedSegStrings); diff --git a/include/geos/noding/NodedSegmentString.h b/include/geos/noding/NodedSegmentString.h index 985b8e722..632ac9493 100644 --- a/include/geos/noding/NodedSegmentString.h +++ b/include/geos/noding/NodedSegmentString.h @@ -62,7 +62,7 @@ public: template static void getNodedSubstrings(II from, II too_far, - SegmentString::NonConstVect* resultEdgelist) + std::vector>& resultEdgelist) { for(II i = from; i != too_far; ++i) { NodedSegmentString* nss = dynamic_cast(*i); @@ -73,16 +73,16 @@ public: template static void - getNodedSubstrings(C* segStrings, - SegmentString::NonConstVect* resultEdgelist) + getNodedSubstrings(const C& segStrings, + std::vector>& resultEdgelist) { - getNodedSubstrings(segStrings->begin(), segStrings->end(), resultEdgelist); + getNodedSubstrings(segStrings.begin(), segStrings.end(), resultEdgelist); } static void getNodedSubstrings(const SegmentString::NonConstVect& segStrings, - SegmentString::NonConstVect* resultEdgeList); + std::vector>& resultEdgeList); - static std::vector getNodedSubstrings( + static std::vector> getNodedSubstrings( const std::vector& segStrings); std::unique_ptr getNodedCoordinates(); @@ -124,7 +124,6 @@ public: std::ostream& print(std::ostream& os) const override; - /** \brief * Add {@link SegmentNode}s for one or both * intersections found for a segment of an edge to the edge diff --git a/include/geos/noding/Noder.h b/include/geos/noding/Noder.h index 03c490160..e41a80e50 100644 --- a/include/geos/noding/Noder.h +++ b/include/geos/noding/Noder.h @@ -16,6 +16,7 @@ #include +#include #include // Forward declarations @@ -50,7 +51,7 @@ public: * * @param segStrings a collection of {@link SegmentString}s to node * The caller remains responsible for releasing the memory - * associated with the container and its elements. + * associated with the SegmentStrings. */ virtual void computeNodes(const std::vector& segStrings) = 0; @@ -62,7 +63,7 @@ public: * Caller is responsible to delete elements of container. * This method may only be called once. */ - virtual std::vector getNodedSubstrings() = 0; + virtual std::vector> getNodedSubstrings() = 0; virtual ~Noder() {} diff --git a/include/geos/noding/NodingValidator.h b/include/geos/noding/NodingValidator.h index 31bdd4e1f..24b24c94b 100644 --- a/include/geos/noding/NodingValidator.h +++ b/include/geos/noding/NodingValidator.h @@ -45,7 +45,7 @@ namespace noding { // geos.noding class GEOS_DLL NodingValidator { private: algorithm::LineIntersector li; - const std::vector& segStrings; + std::vector segStrings; /** * Checks if a segment string contains a segment @@ -93,9 +93,13 @@ private: public: - NodingValidator(const std::vector& newSegStrings): - segStrings(newSegStrings) - {} + NodingValidator(const std::vector>& newSegStrings) + { + segStrings.resize(newSegStrings.size()); + for (size_t i = 0; i < newSegStrings.size(); ++i) { + segStrings[i] = newSegStrings[i].get(); + } + } ~NodingValidator() {} diff --git a/include/geos/noding/ScaledNoder.h b/include/geos/noding/ScaledNoder.h index 2e0d615be..99566d879 100644 --- a/include/geos/noding/ScaledNoder.h +++ b/include/geos/noding/ScaledNoder.h @@ -77,7 +77,7 @@ public: ~ScaledNoder() override; - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; void computeNodes(const std::vector& inputSegStr) override; @@ -104,7 +104,7 @@ private: bool isScaled; - void rescale(std::vector& segStrings) const; + void rescale(std::vector>& segStrings) const; void scale(const std::vector& segStrings) const; diff --git a/include/geos/noding/SegmentExtractingNoder.h b/include/geos/noding/SegmentExtractingNoder.h index 5f4f29d15..71c49e909 100644 --- a/include/geos/noding/SegmentExtractingNoder.h +++ b/include/geos/noding/SegmentExtractingNoder.h @@ -53,15 +53,15 @@ class GEOS_DLL SegmentExtractingNoder : public Noder { private: - std::vector segList; + std::vector> segList; void extractSegments( const std::vector& inputSegs, - std::vector& outputSegs); + std::vector>& outputSegs); void extractSegments( const SegmentString* ss, - std::vector& outputSegs); + std::vector>& outputSegs); public: @@ -77,8 +77,11 @@ public: * @return a Collection of SegmentString representing the * substrings. Caller takes ownership over vector and contents. */ - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; + // Declare type as noncopyable + SegmentExtractingNoder(SegmentExtractingNoder const&) = delete; + SegmentExtractingNoder& operator=(SegmentExtractingNoder const&) = delete; }; diff --git a/include/geos/noding/SegmentNodeList.h b/include/geos/noding/SegmentNodeList.h index d199fde15..6791e9704 100644 --- a/include/geos/noding/SegmentNodeList.h +++ b/include/geos/noding/SegmentNodeList.h @@ -219,10 +219,10 @@ public: * Adds the edges to the input list (this is so a single list * can be used to accumulate all split edges for a Geometry). */ - void addSplitEdges(std::vector& edgeList); + void addSplitEdges(std::vector>& edgeList); void - addSplitEdges(std::vector* edgeList) + addSplitEdges(std::vector>* edgeList) { assert(edgeList); addSplitEdges(*edgeList); diff --git a/include/geos/noding/SegmentString.h b/include/geos/noding/SegmentString.h index af7cee2de..8e08b853b 100644 --- a/include/geos/noding/SegmentString.h +++ b/include/geos/noding/SegmentString.h @@ -171,6 +171,8 @@ public: return seq->front().equals(seq->back()); } + static std::vector toRawPointerVector(const std::vector> & segStrings); + virtual std::ostream& print(std::ostream& os) const; protected: diff --git a/include/geos/noding/SimpleNoder.h b/include/geos/noding/SimpleNoder.h index b2bf4f70c..95468637a 100644 --- a/include/geos/noding/SimpleNoder.h +++ b/include/geos/noding/SimpleNoder.h @@ -58,7 +58,7 @@ public: void computeNodes(const std::vector& inputSegmentStrings) override; - std::vector + std::vector> getNodedSubstrings() override { return NodedSegmentString::getNodedSubstrings(nodedSegStrings); diff --git a/include/geos/noding/SinglePassNoder.h b/include/geos/noding/SinglePassNoder.h index 1c2de5613..b36d94a60 100644 --- a/include/geos/noding/SinglePassNoder.h +++ b/include/geos/noding/SinglePassNoder.h @@ -88,7 +88,7 @@ public: * * @return a Collection of SegmentStrings */ - std::vector getNodedSubstrings() override = 0; + std::vector> getNodedSubstrings() override = 0; }; diff --git a/include/geos/noding/ValidatingNoder.h b/include/geos/noding/ValidatingNoder.h index e6a3af6a2..c8c750ba8 100644 --- a/include/geos/noding/ValidatingNoder.h +++ b/include/geos/noding/ValidatingNoder.h @@ -17,6 +17,7 @@ #include #include +#include #include // for unique_ptr @@ -51,7 +52,7 @@ class GEOS_DLL ValidatingNoder : public Noder { private: - std::vector nodedSS; + std::vector> nodedSS; noding::Noder& noder; @@ -61,11 +62,17 @@ public: : noder(noderArg) {} + ~ValidatingNoder() override; + void computeNodes(const std::vector& segStrings) override; - void validate(); + void validate() const; - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; + + // Declare type as noncopyable + ValidatingNoder(ValidatingNoder const&) = delete; + ValidatingNoder& operator=(ValidatingNoder const&) = delete; }; diff --git a/include/geos/noding/snap/SnappingNoder.h b/include/geos/noding/snap/SnappingNoder.h index 8381f13bd..a143419c5 100644 --- a/include/geos/noding/snap/SnappingNoder.h +++ b/include/geos/noding/snap/SnappingNoder.h @@ -24,6 +24,7 @@ #include #include #include +#include #include @@ -71,7 +72,7 @@ private: // Members double snapTolerance; SnappingPointIndex snapIndex; - std::vector nodedResult; + std::vector> nodedResult; // Methods @@ -79,7 +80,7 @@ private: void snapVertices(const std::vector& segStrings, std::vector& nodedStrings); - SegmentString* snapVertices(SegmentString* ss); + std::unique_ptr snapVertices(const SegmentString* ss); std::unique_ptr snap(const geom::CoordinateSequence* cs); @@ -91,7 +92,7 @@ private: * * @return a list of Coordinates for the intersections */ - std::vector snapIntersections(std::vector& inputSS); + std::vector> snapIntersections(std::vector& inputSS); public: @@ -108,7 +109,7 @@ public: /** * @return a Collection of NodedSegmentStrings representing the substrings */ - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; void computeNodes(const std::vector& inputSegStrings) override; diff --git a/include/geos/noding/snapround/MCIndexSnapRounder.h b/include/geos/noding/snapround/MCIndexSnapRounder.h index ba1ad2db7..19a33addd 100644 --- a/include/geos/noding/snapround/MCIndexSnapRounder.h +++ b/include/geos/noding/snapround/MCIndexSnapRounder.h @@ -83,7 +83,7 @@ public: li.setPrecisionModel(&pm); } - std::vector + std::vector> getNodedSubstrings() override { return NodedSegmentString::getNodedSubstrings(nodedSegStrings); diff --git a/include/geos/noding/snapround/SnapRoundingNoder.h b/include/geos/noding/snapround/SnapRoundingNoder.h index 528c63df8..2cd6a251b 100644 --- a/include/geos/noding/snapround/SnapRoundingNoder.h +++ b/include/geos/noding/snapround/SnapRoundingNoder.h @@ -148,7 +148,7 @@ public: /** * @return a Collection of NodedSegmentStrings representing the substrings */ - std::vector getNodedSubstrings() override; + std::vector> getNodedSubstrings() override; /** * Computes the nodes in the snap-rounding line arrangement. diff --git a/include/geos/operation/overlayng/EdgeNodingBuilder.h b/include/geos/operation/overlayng/EdgeNodingBuilder.h index 8130c1aa1..cae8a44e7 100644 --- a/include/geos/operation/overlayng/EdgeNodingBuilder.h +++ b/include/geos/operation/overlayng/EdgeNodingBuilder.h @@ -178,7 +178,7 @@ private: * (and is then discarded). */ std::vector node(const std::vector& segStrings); - std::vector createEdges(std::vector* segStrings); + std::vector createEdges(std::vector> &segStrings); public: @@ -199,18 +199,10 @@ public: , inputHasM(false) {}; - ~EdgeNodingBuilder() - { - for (noding::SegmentString* ss: *inputEdges) { - delete ss; - } - } + ~EdgeNodingBuilder(); void setClipEnvelope(const Envelope* clipEnv); - // returns newly allocated vector and segmentstrings - // std::vector* node(); - /** * Reports whether there are noded edges * for the given input geometry. @@ -236,8 +228,9 @@ public: */ std::vector build(const Geometry* geom0, const Geometry* geom1); - - + // Declare type as noncopyable + EdgeNodingBuilder(const EdgeNodingBuilder& other) = delete; + EdgeNodingBuilder& operator=(const EdgeNodingBuilder& rhs) = delete; }; diff --git a/src/coverage/CoverageCleaner.cpp b/src/coverage/CoverageCleaner.cpp index 88e30c872..940dcd444 100644 --- a/src/coverage/CoverageCleaner.cpp +++ b/src/coverage/CoverageCleaner.cpp @@ -384,11 +384,11 @@ CoverageCleaner::polygonize(const Geometry* cleanEdges) /* public static */ std::unique_ptr CoverageCleaner::toGeometry( - std::vector& segStrings, + std::vector>& segStrings, const GeometryFactory* geomFact) { std::vector> lines; - for (SegmentString* ss : segStrings) { + for (auto& ss : segStrings) { auto cs = ss->getCoordinates()->clone(); std::unique_ptr line = geomFact->createLineString(std::move(cs)); lines.emplace_back(line.release()); @@ -426,9 +426,6 @@ CoverageCleaner::node(std::vector& p_coverage, double p_snapDis } auto result = toGeometry(nodedSegStrings, geomFactory); - for (SegmentString* ss : nodedSegStrings) { - delete ss; - } return result; } diff --git a/src/geomgraph/EdgeNodingValidator.cpp b/src/geomgraph/EdgeNodingValidator.cpp index 97b9a7d99..eab396e81 100644 --- a/src/geomgraph/EdgeNodingValidator.cpp +++ b/src/geomgraph/EdgeNodingValidator.cpp @@ -30,14 +30,14 @@ using namespace geos::geom; namespace geos { namespace geomgraph { // geos.geomgraph -std::vector& +const std::vector>& EdgeNodingValidator::toSegmentStrings(std::vector& edges) { // convert Edges to SegmentStrings for(std::size_t i = 0, n = edges.size(); i < n; ++i) { Edge* e = edges[i]; auto cs = e->getCoordinates()->clone(); - segStr.push_back(new BasicSegmentString(cs.get(), e)); + segStr.push_back(std::make_unique(cs.get(), e)); newCoordSeq.push_back(cs.release()); } return segStr; @@ -45,13 +45,6 @@ EdgeNodingValidator::toSegmentStrings(std::vector& edges) EdgeNodingValidator::~EdgeNodingValidator() { - for(SegmentString::NonConstVect::iterator - i = segStr.begin(), e = segStr.end(); - i != e; - ++i) { - delete *i; - } - for(std::size_t i = 0, n = newCoordSeq.size(); i < n; ++i) { delete newCoordSeq[i]; } diff --git a/src/noding/BoundaryChainNoder.cpp b/src/noding/BoundaryChainNoder.cpp index 8a7637c08..f4346d9bb 100644 --- a/src/noding/BoundaryChainNoder.cpp +++ b/src/noding/BoundaryChainNoder.cpp @@ -48,11 +48,11 @@ BoundaryChainNoder::computeNodes(const std::vector& segStrings) /* private */ Coordinate::UnorderedSet -BoundaryChainNoder::findNodePts(const std::vector& segStrings) const +BoundaryChainNoder::findNodePts(const std::vector>& segStrings) const { Coordinate::UnorderedSet interiorVertices; Coordinate::UnorderedSet nodes; - for (const SegmentString* ss : segStrings) { + for (const auto& ss : segStrings) { //-- endpoints are nodes nodes.insert(ss->getCoordinate(0)); nodes.insert(ss->getCoordinate(ss->size() - 1)); @@ -70,14 +70,14 @@ BoundaryChainNoder::findNodePts(const std::vector& segStrings) c } /* private */ -std::vector +std::vector> BoundaryChainNoder::nodeChains( - const std::vector& chains, + std::vector>& chains, const Coordinate::UnorderedSet& nodePts) { - std::vector nodedChains; - for (SegmentString* chain : chains) { - nodeChain(chain, nodePts, nodedChains); + std::vector> nodedChains; + for (auto& chain : chains) { + nodeChain(std::move(chain), nodePts, nodedChains); } return nodedChains; } @@ -86,25 +86,21 @@ BoundaryChainNoder::nodeChains( /* private */ void BoundaryChainNoder::nodeChain( - SegmentString* chain, + std::unique_ptr chain, const Coordinate::UnorderedSet& nodePts, - std::vector& nodedChains) + std::vector>& nodedChains) { std::size_t start = 0; while (start < chain->size() - 1) { - std::size_t end = findNodeIndex(chain, start, nodePts); + std::size_t end = findNodeIndex(chain.get(), start, nodePts); //-- if no interior nodes found, keep original chain if (start == 0 && end == chain->size() - 1) { - nodedChains.push_back(chain); + nodedChains.emplace_back(std::move(chain)); return; } - nodedChains.push_back(substring(chain, start, end).release()); + nodedChains.push_back(substring(chain.get(), start, end)); start = end; } - // We replaced this SegmentString with substrings, - // and we are discarding the containing vector later - // so get rid of this chain now - delete chain; } /* private static */ @@ -134,7 +130,7 @@ BoundaryChainNoder::findNodeIndex( /* public */ -std::vector +std::vector> BoundaryChainNoder::getNodedSubstrings() { return std::move(m_chainList); @@ -201,10 +197,10 @@ BoundaryChainNoder::markBoundarySegments(SegmentSet& segSet) } /* private */ -std::vector +std::vector> BoundaryChainNoder::extractChains(std::vector& boundaryChains) const { - std::vector chains; + std::vector> chains; for (BoundaryChainMap& chainMap : boundaryChains) { chainMap.createChains(chains, m_constructZ, m_constructM); } @@ -225,7 +221,7 @@ BoundaryChainNoder::BoundaryChainMap::setBoundarySegment(std::size_t index) /* public */ void BoundaryChainNoder::BoundaryChainMap::createChains( - std::vector& chains, + std::vector>& chains, bool constructZ, bool constructM) { @@ -235,16 +231,16 @@ BoundaryChainNoder::BoundaryChainMap::createChains( if (startIndex >= segString->size() - 1) break; endIndex = findChainEnd(startIndex); - SegmentString* ss = createChain(segString, startIndex, endIndex, constructZ, constructM); - chains.push_back(ss); + auto ss = createChain(segString, startIndex, endIndex, constructZ, constructM); + chains.push_back(std::move(ss)); } } /* private static */ -SegmentString* +std::unique_ptr BoundaryChainNoder::BoundaryChainMap::createChain( - const SegmentString* segString, + const SegmentString *segString, std::size_t startIndex, std::size_t endIndex, bool constructZ, @@ -255,7 +251,7 @@ BoundaryChainNoder::BoundaryChainMap::createChain( pts->reserve(npts); pts->add(*segString->getCoordinates(), startIndex, endIndex); - return new NodedSegmentString(pts.release(), constructZ, constructM, segString->getData()); + return std::make_unique(pts.release(), constructZ, constructM, segString->getData()); } /* private */ diff --git a/src/noding/GeometryNoder.cpp b/src/noding/GeometryNoder.cpp index b552e7f47..5ec79d1f7 100644 --- a/src/noding/GeometryNoder.cpp +++ b/src/noding/GeometryNoder.cpp @@ -97,7 +97,7 @@ GeometryNoder::GeometryNoder(const geom::Geometry& g) /* private */ std::unique_ptr -GeometryNoder::toGeometry(SegmentString::NonConstVect& nodedEdges) +GeometryNoder::toGeometry(std::vector>& nodedEdges) { const geom::GeometryFactory* geomFact = argGeom.getFactory(); @@ -130,7 +130,7 @@ GeometryNoder::getNoded() extractSegmentStrings(argGeom, p_lineList); Noder& p_noder = getNoder(); - std::vector nodedEdges; + std::vector> nodedEdges; try { p_noder.computeNodes(p_lineList); @@ -145,10 +145,6 @@ GeometryNoder::getNoded() std::unique_ptr noded = toGeometry(nodedEdges); - for(auto* elem : nodedEdges) { - delete elem; - } - for(auto* elem : p_lineList) { delete elem; } diff --git a/src/noding/IteratedNoder.cpp b/src/noding/IteratedNoder.cpp index 62e893287..c88b76387 100644 --- a/src/noding/IteratedNoder.cpp +++ b/src/noding/IteratedNoder.cpp @@ -47,9 +47,6 @@ IteratedNoder::node(const std::vector& segStrings, noder.setSegmentIntersector(&si); noder.computeNodes(segStrings); auto updatedSegStrings = noder.getNodedSubstrings(); - for (SegmentString* ss : nodedSegStrings) { - delete ss; - } nodedSegStrings = std::move(updatedSegStrings); numInteriorIntersections = si.numInteriorIntersections; @@ -65,14 +62,18 @@ IteratedNoder::computeNodes(const std::vector& segStrings) int numInteriorIntersections; int nodingIterationCount = 0; int lastNodesCreated = -1; - //std::vector* lastStrings = nullptr; CoordinateXY intersectionPoint = CoordinateXY::getNull(); - const std::vector* toNode = &segStrings; - do { + bool firstPass = true; + do { // NOTE: will change this.nodedSegStrings - node(*toNode, numInteriorIntersections, intersectionPoint); - toNode = &nodedSegStrings; + if (firstPass) { + node(segStrings, numInteriorIntersections, intersectionPoint); + firstPass = false; + } else { + auto nodingInput = SegmentString::toRawPointerVector(nodedSegStrings); + node(nodingInput, numInteriorIntersections, intersectionPoint); + } nodingIterationCount++; int nodesCreated = numInteriorIntersections; @@ -85,11 +86,6 @@ IteratedNoder::computeNodes(const std::vector& segStrings) && nodesCreated >= lastNodesCreated && nodingIterationCount > maxIter) { - // Delete noded strings from previous iteration - for (SegmentString* ss : nodedSegStrings) { - delete ss; - } - std::stringstream s; s << "Iterated noding failed to converge after " << nodingIterationCount << " iterations (near " << diff --git a/src/noding/NodedSegmentString.cpp b/src/noding/NodedSegmentString.cpp index 4d5fe71e8..4074d7342 100644 --- a/src/noding/NodedSegmentString.cpp +++ b/src/noding/NodedSegmentString.cpp @@ -43,16 +43,13 @@ NodedSegmentString::getNodeList() /* public static */ void NodedSegmentString::getNodedSubstrings( - const SegmentString::NonConstVect& segStrings, - SegmentString::NonConstVect* resultEdgeList) + const std::vector& segStrings, + std::vector>& resultEdgeList) { - assert(resultEdgeList); - for(SegmentString::NonConstVect::const_iterator - i = segStrings.begin(), iEnd = segStrings.end(); - i != iEnd; ++i) { - NodedSegmentString* ss = dynamic_cast(*i); - assert(ss); - ss->getNodeList().addSplitEdges(resultEdgeList); + for(SegmentString* ss : segStrings) { + NodedSegmentString* nss = dynamic_cast(ss); + assert(nss); + nss->getNodeList().addSplitEdges(resultEdgeList); } } @@ -64,12 +61,12 @@ NodedSegmentString::getNodedCoordinates() { /* public static */ -std::vector +std::vector> NodedSegmentString::getNodedSubstrings( const std::vector& segStrings) { - std::vector resultEdgelist; - getNodedSubstrings(segStrings, &resultEdgelist); + std::vector> resultEdgelist; + getNodedSubstrings(segStrings, resultEdgelist); return resultEdgelist; } diff --git a/src/noding/ScaledNoder.cpp b/src/noding/ScaledNoder.cpp index 71158db89..02192cac2 100644 --- a/src/noding/ScaledNoder.cpp +++ b/src/noding/ScaledNoder.cpp @@ -135,17 +135,11 @@ private: /*private*/ void -ScaledNoder::rescale(SegmentString::NonConstVect& segStrings) const +ScaledNoder::rescale(std::vector>& segStrings) const { ReScaler rescaler(*this); - for(SegmentString::NonConstVect::const_iterator - i0 = segStrings.begin(), i0End = segStrings.end(); - i0 != i0End; ++i0) { - - SegmentString* ss = *i0; - + for(auto& ss : segStrings) { ss->getCoordinates()->apply_rw(&rescaler); - } } @@ -188,10 +182,10 @@ ScaledNoder::~ScaledNoder() /*public*/ -SegmentString::NonConstVect +std::vector> ScaledNoder::getNodedSubstrings() { - SegmentString::NonConstVect splitSS = noder.getNodedSubstrings(); + auto splitSS = noder.getNodedSubstrings(); #if GEOS_DEBUG > 1 sqlPrint("nodedSegStr", *splitSS); diff --git a/src/noding/SegmentExtractingNoder.cpp b/src/noding/SegmentExtractingNoder.cpp index e63ce5718..0bfb095bf 100644 --- a/src/noding/SegmentExtractingNoder.cpp +++ b/src/noding/SegmentExtractingNoder.cpp @@ -39,7 +39,7 @@ SegmentExtractingNoder::computeNodes( void SegmentExtractingNoder::extractSegments( const std::vector& inputSegs, - std::vector& outputSegs) + std::vector>& outputSegs) { for (SegmentString* ss : inputSegs) { extractSegments(ss, outputSegs); @@ -52,7 +52,7 @@ SegmentExtractingNoder::extractSegments( void SegmentExtractingNoder::extractSegments( const SegmentString* ss, - std::vector& outputSegs) + std::vector>& outputSegs) { const CoordinateSequence* ss_seq = ss->getCoordinates(); @@ -65,12 +65,12 @@ SegmentExtractingNoder::extractSegments( cs->reserve(2); cs->add(*ss_seq, i, i + 1); std::unique_ptr seg(new NodedSegmentString(cs.release(), constructZ, constructM, ss->getData())); - outputSegs.push_back(seg.release()); + outputSegs.push_back(std::move(seg)); } } -std::vector +std::vector> SegmentExtractingNoder::getNodedSubstrings() { return std::move(segList); diff --git a/src/noding/SegmentNodeList.cpp b/src/noding/SegmentNodeList.cpp index 962f4a7c3..5fa6dd7dc 100644 --- a/src/noding/SegmentNodeList.cpp +++ b/src/noding/SegmentNodeList.cpp @@ -164,7 +164,7 @@ SegmentNodeList::findCollapseIndex(const SegmentNode& ei0, const SegmentNode& ei /* public */ void -SegmentNodeList::addSplitEdges(std::vector& edgeList) +SegmentNodeList::addSplitEdges(std::vector>& edgeList) { // testingOnly @@ -193,7 +193,7 @@ SegmentNodeList::addSplitEdges(std::vector& edgeList) } std::unique_ptr newEdge = createSplitEdge(eiPrev, ei); - edgeList.push_back(newEdge.release()); + edgeList.push_back(std::move(newEdge)); #if GEOS_DEBUG testingSplitEdges.push_back(edgeList.back()); #endif diff --git a/src/noding/SegmentString.cpp b/src/noding/SegmentString.cpp index 7531bfd75..b5a56c70f 100644 --- a/src/noding/SegmentString.cpp +++ b/src/noding/SegmentString.cpp @@ -53,6 +53,15 @@ SegmentString::print(std::ostream& os) const return os; } +std::vector +SegmentString::toRawPointerVector(const std::vector> & segStrings) { + std::vector ret(segStrings.size()); + for (std::size_t i = 0; i < segStrings.size(); i++) { + ret[i] = segStrings[i].get(); + } + return ret; +} + } // namespace geos.noding } // namespace geos diff --git a/src/noding/ValidatingNoder.cpp b/src/noding/ValidatingNoder.cpp index 322f9fbb3..001a8c2a2 100644 --- a/src/noding/ValidatingNoder.cpp +++ b/src/noding/ValidatingNoder.cpp @@ -14,7 +14,6 @@ #include #include -#include #include @@ -24,6 +23,7 @@ namespace geos { namespace noding { // geos.noding +ValidatingNoder::~ValidatingNoder() = default; void ValidatingNoder::computeNodes(const std::vector& segStrings) @@ -34,22 +34,18 @@ ValidatingNoder::computeNodes(const std::vector& segStrings) } void -ValidatingNoder::validate() +ValidatingNoder::validate() const { FastNodingValidator nv(nodedSS); try { nv.checkValid(); } catch (const std::exception &) { - for (SegmentString* ss: nodedSS) { - delete ss; - } - throw; } } -std::vector +std::vector> ValidatingNoder::getNodedSubstrings() { return std::move(nodedSS); diff --git a/src/noding/snap/SnappingNoder.cpp b/src/noding/snap/SnappingNoder.cpp index 701170474..614aeac7e 100644 --- a/src/noding/snap/SnappingNoder.cpp +++ b/src/noding/snap/SnappingNoder.cpp @@ -62,7 +62,7 @@ SnappingNoder::snapVertices(const std::vector& segStrings, std:: seedSnapIndex(segStrings); for (SegmentString* ss: segStrings) { - nodedStrings.push_back(snapVertices(ss)); + nodedStrings.push_back(snapVertices(ss).release()); } //sw->stop(); @@ -94,12 +94,12 @@ SnappingNoder::seedSnapIndex(const std::vector& segStrings) } /*private*/ -SegmentString* -SnappingNoder::snapVertices(SegmentString* ss) +std::unique_ptr +SnappingNoder::snapVertices(const SegmentString* ss) { auto snapCoords = snap(ss->getCoordinates()); // FIXME remove hardcoded hasZ, hasM and derive from input - return new NodedSegmentString(snapCoords.release(), false, false, ss->getData()); + return std::make_unique(snapCoords.release(), false, false, ss->getData()); } @@ -120,7 +120,7 @@ SnappingNoder::snap(const CoordinateSequence* cs) /*private*/ -std::vector +std::vector> SnappingNoder::snapIntersections(std::vector& inputSS) { SnappingIntersectionAdder intAdder(snapTolerance, snapIndex); @@ -134,7 +134,7 @@ SnappingNoder::snapIntersections(std::vector& inputSS) } /*public*/ -std::vector +std::vector> SnappingNoder::getNodedSubstrings() { return std::move(nodedResult); diff --git a/src/noding/snapround/SnapRoundingNoder.cpp b/src/noding/snapround/SnapRoundingNoder.cpp index cfaa18be0..30d7b7be5 100644 --- a/src/noding/snapround/SnapRoundingNoder.cpp +++ b/src/noding/snapround/SnapRoundingNoder.cpp @@ -36,10 +36,10 @@ namespace snapround { // geos.noding.snapround /*public*/ -std::vector +std::vector> SnapRoundingNoder::getNodedSubstrings() { - std::vector nssResult = NodedSegmentString::getNodedSubstrings(snappedResult); + auto nssResult = NodedSegmentString::getNodedSubstrings(snappedResult); // Intermediate SegmentStrings are no longer needed for (auto nss: snappedResult) diff --git a/src/operation/buffer/BufferBuilder.cpp b/src/operation/buffer/BufferBuilder.cpp index c2926b40e..1bdf09493 100644 --- a/src/operation/buffer/BufferBuilder.cpp +++ b/src/operation/buffer/BufferBuilder.cpp @@ -202,16 +202,14 @@ BufferBuilder::bufferLineSingleSided(const Geometry* g, double distance, Noder* noder = getNoder(precisionModel); noder->computeNodes(curveList); - std::vector nodedEdges = noder->getNodedSubstrings(); + auto nodedEdges = noder->getNodedSubstrings(); // Create a geometry out of the noded substrings. std::vector> singleSidedNodedEdges; singleSidedNodedEdges.reserve(nodedEdges.size()); - for(std::size_t i = 0, n = nodedEdges.size(); i < n; ++i) { - SegmentString* ss = nodedEdges[i]; - + for(auto& ss : nodedEdges) { auto tmp = geomFact->createLineString(ss->getCoordinates()->clone()); - delete ss; + ss.reset(); singleSidedNodedEdges.push_back(std::move(tmp)); } @@ -654,8 +652,7 @@ BufferBuilder::computeNodedEdges(SegmentString::NonConstVect& bufferSegStrList, noder->computeNodes(bufferSegStrList); - SegmentString::NonConstVect nodedSegStrings = \ - noder->getNodedSubstrings(); + auto nodedSegStrings = noder->getNodedSubstrings(); #if JTS_DEBUG std::cerr << "after noding: " @@ -666,15 +663,11 @@ BufferBuilder::computeNodedEdges(SegmentString::NonConstVect& bufferSegStrList, #endif - for(SegmentString::NonConstVect::iterator - i = nodedSegStrings.begin(), e = nodedSegStrings.end(); - i != e; - ++i) { - SegmentString* segStr = *i; + for(auto& segStr : nodedSegStrings) { const Label* oldLabel = static_cast(segStr->getData()); auto cs = operation::valid::RepeatedPointRemover::removeRepeatedPoints(segStr->getCoordinates()); - delete segStr; + segStr.reset(); if(cs->size() < 2) { // don't insert collapsed edges // we need to take care of the memory here as cs is a new sequence diff --git a/src/operation/overlayng/EdgeNodingBuilder.cpp b/src/operation/overlayng/EdgeNodingBuilder.cpp index c75c2057a..0800e8fcf 100644 --- a/src/operation/overlayng/EdgeNodingBuilder.cpp +++ b/src/operation/overlayng/EdgeNodingBuilder.cpp @@ -42,6 +42,13 @@ using geos::noding::SegmentString; using geos::noding::NodedSegmentString; +EdgeNodingBuilder::~EdgeNodingBuilder() +{ + for (SegmentString* ss: *inputEdges) { + delete ss; + } +} + /*private*/ Noder* EdgeNodingBuilder::getNoder() @@ -121,23 +128,18 @@ EdgeNodingBuilder::node(const std::vector& segStrings) auto nodedSS = noder->getNodedSubstrings(); - nodedEdges = createEdges(&nodedSS); - - // Clean up now that all the info is transferred to Edges - for (SegmentString* ss : nodedSS) { - delete ss; - } + nodedEdges = createEdges(nodedSS); return nodedEdges; } /*private*/ std::vector -EdgeNodingBuilder::createEdges(std::vector* segStrings) +EdgeNodingBuilder::createEdges(std::vector>& segStrings) { std::vector createdEdges; - for (SegmentString* ss : *segStrings) { + for (auto& ss : segStrings) { const CoordinateSequence* pts = ss->getCoordinates(); // don't create edges from collapsed lines @@ -148,7 +150,7 @@ EdgeNodingBuilder::createEdges(std::vector* segStrings) // Record that a non-collapsed edge exists for the parent geometry hasEdges[info->getIndex()] = true; // Allocate the new Edge locally in a std::deque - NodedSegmentString* nss = detail::down_cast(ss); + NodedSegmentString* nss = detail::down_cast(ss.get()); edgeQue.emplace_back(nss->releaseCoordinates(), info); Edge* newEdge = &(edgeQue.back()); createdEdges.push_back(newEdge); diff --git a/tests/unit/noding/NodedSegmentStringTest.cpp b/tests/unit/noding/NodedSegmentStringTest.cpp index 35100878f..26f8cc904 100644 --- a/tests/unit/noding/NodedSegmentStringTest.cpp +++ b/tests/unit/noding/NodedSegmentStringTest.cpp @@ -46,10 +46,10 @@ struct test_nodedsegmentstring_data { } std::unique_ptr - toLines(SegmentString::NonConstVect& ss, const GeometryFactory* gf) + toLines(std::vector>& ss, const GeometryFactory* gf) { std::vector> lines; - for (auto s: ss) + for (auto& s: ss) { std::unique_ptr cs = s->getCoordinates()->clone(); lines.push_back(gf->createLineString(std::move(cs))); @@ -72,13 +72,9 @@ struct test_nodedsegmentstring_data { nss.addIntersection(node->getAt(i), segmentIndex.at(i)); } - SegmentString::NonConstVect nodedSS; + std::vector> nodedSS; nss.getNodeList().addSplitEdges(nodedSS); std::unique_ptr result = toLines(nodedSS, line->getFactory()); - //System.out.println(result); - for (auto ss: nodedSS) { - delete ss; - } std::unique_ptr expected = r.read(wktExpected); ensure_equals_geometry(expected.get(), result.get()); } diff --git a/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp b/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp index 4490dd95a..d9d569a69 100644 --- a/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp +++ b/tests/unit/noding/snapround/MCIndexSnapRounderTest.cpp @@ -137,11 +137,10 @@ void object::test<1> ensure_equals(nodable.size(), 1u); noder.computeNodes(nodable); - SegStrVct noded(noder.getNodedSubstrings()); + auto noded = noder.getNodedSubstrings(); ensure_equals("1e-5", noded.size(), 178u); - freeSegmentStrings(noded); freeSegmentStrings(nodable); } diff --git a/tests/unit/util/NodingTestUtil.cpp b/tests/unit/util/NodingTestUtil.cpp index 5fef421af..edb0b8072 100644 --- a/tests/unit/util/NodingTestUtil.cpp +++ b/tests/unit/util/NodingTestUtil.cpp @@ -92,19 +92,14 @@ NodingTestUtil::nodeValidated(const Geometry* geom1, const Geometry* geom2, Node // which creates new NodedSegmentString and new pts member, so complete // new copy of data. Can be disposed of after geometries are constructed // std::vector* nodedList = noderValid.getNodedSubstrings(); - std::vector nodedList = noderValid.getNodedSubstrings(); + auto nodedList = noderValid.getNodedSubstrings(); // Dispose of ssList for (auto ss: ssList) { delete ss; } - std::unique_ptr lineGeom = toLines(nodedList, geom1->getFactory()); - - // Dispose of nodedList - for (auto nss: nodedList) { - delete nss; - } + std::unique_ptr lineGeom = toLines(SegmentString::toRawPointerVector(nodedList), geom1->getFactory()); return lineGeom; } commit b8cb43fc5b175e23496521319742e982192e1638 Author: Daniel Baston Date: Tue Nov 11 18:59:07 2025 -0500 Noder: Accept std::vector as reference, return as value diff --git a/include/geos/noding/BoundaryChainNoder.h b/include/geos/noding/BoundaryChainNoder.h index 075168a7e..d46007497 100644 --- a/include/geos/noding/BoundaryChainNoder.h +++ b/include/geos/noding/BoundaryChainNoder.h @@ -142,8 +142,8 @@ public: {}; // Noder virtual methods - std::vector* getNodedSubstrings() const override; - void computeNodes(std::vector* inputSegStrings) override; + std::vector getNodedSubstrings() override; + void computeNodes(const std::vector& inputSegStrings) override; private: @@ -155,7 +155,7 @@ private: bool m_constructM; // Methods - void addSegments(std::vector* segStrings, + void addSegments(const std::vector& segStrings, SegmentSet& segSet, std::vector& includedSegs); diff --git a/include/geos/noding/IteratedNoder.h b/include/geos/noding/IteratedNoder.h index 3e82c8aa1..6e55ecb8a 100644 --- a/include/geos/noding/IteratedNoder.h +++ b/include/geos/noding/IteratedNoder.h @@ -57,14 +57,14 @@ private: const geom::PrecisionModel* pm; algorithm::LineIntersector li; - std::vector* nodedSegStrings; + std::vector nodedSegStrings; int maxIter; /** * Node the input segment strings once * and create the split edges between the nodes */ - void node(std::vector* segStrings, + void node(const std::vector& segStrings, int& numInteriorIntersections, geom::CoordinateXY& intersectionPoint); @@ -96,10 +96,10 @@ public: maxIter = n; } - std::vector* - getNodedSubstrings() const override + std::vector + getNodedSubstrings() override { - return nodedSegStrings; + return std::move(nodedSegStrings); } @@ -112,7 +112,7 @@ public: * @param inputSegmentStrings a collection of SegmentStrings to be noded * @throws TopologyException if the iterated noding fails to converge. */ - void computeNodes(std::vector* inputSegmentStrings) override; // throw(GEOSException); + void computeNodes(const std::vector& inputSegmentStrings) override; // throw(GEOSException); }; } // namespace geos::noding diff --git a/include/geos/noding/MCIndexNoder.h b/include/geos/noding/MCIndexNoder.h index cf810abd4..5a4965710 100644 --- a/include/geos/noding/MCIndexNoder.h +++ b/include/geos/noding/MCIndexNoder.h @@ -67,7 +67,7 @@ class GEOS_DLL MCIndexNoder : public SinglePassNoder { private: std::vector monoChains; index::strtree::TemplateSTRtree index; - std::vector* nodedSegStrings; + std::vector nodedSegStrings; // statistics int nOverlaps; double overlapTolerance; @@ -81,7 +81,6 @@ public: MCIndexNoder(SegmentIntersector* nSegInt = nullptr, double p_overlapTolerance = 0.0) : SinglePassNoder(nSegInt) - , nodedSegStrings(nullptr) , nOverlaps(0) , overlapTolerance(p_overlapTolerance) , indexBuilt(false) @@ -102,13 +101,13 @@ public: return index; } - std::vector* getNodedSubstrings() const override + std::vector getNodedSubstrings() override { - assert(nodedSegStrings); // must have called computeNodes before! - return NodedSegmentString::getNodedSubstrings(*nodedSegStrings); + //assert(nodedSegStrings); // must have called computeNodes before! + return NodedSegmentString::getNodedSubstrings(nodedSegStrings); } - void computeNodes(std::vector* inputSegmentStrings) override; + void computeNodes(const std::vector& inputSegmentStrings) override; class SegmentOverlapAction : public index::chain::MonotoneChainOverlapAction { public: diff --git a/include/geos/noding/NodedSegmentString.h b/include/geos/noding/NodedSegmentString.h index 18f6f18d3..985b8e722 100644 --- a/include/geos/noding/NodedSegmentString.h +++ b/include/geos/noding/NodedSegmentString.h @@ -82,9 +82,8 @@ public: static void getNodedSubstrings(const SegmentString::NonConstVect& segStrings, SegmentString::NonConstVect* resultEdgeList); - /// Returns allocated object - static SegmentString::NonConstVect* getNodedSubstrings( - const SegmentString::NonConstVect& segStrings); + static std::vector getNodedSubstrings( + const std::vector& segStrings); std::unique_ptr getNodedCoordinates(); diff --git a/include/geos/noding/Noder.h b/include/geos/noding/Noder.h index 768be8b02..03c490160 100644 --- a/include/geos/noding/Noder.h +++ b/include/geos/noding/Noder.h @@ -17,7 +17,6 @@ #include #include -#include // Forward declarations namespace geos { @@ -40,8 +39,6 @@ namespace noding { // geos.noding * * Last port: noding/Noder.java rev. 1.8 (JTS-1.7) * - * TODO: this was really an interface, we should avoid making it a Base class - * */ class GEOS_DLL Noder { public: @@ -55,17 +52,17 @@ public: * The caller remains responsible for releasing the memory * associated with the container and its elements. */ - virtual void computeNodes(std::vector* segStrings) = 0; + virtual void computeNodes(const std::vector& segStrings) = 0; /** \brief * Returns a collection of fully noded [SegmentStrings](@ref SegmentString). * The SegmentStrings have the same context as their parent. * - * @return a newly allocated std::vector of newly allocated - * SegmentStrings (copies of input, if needs be). - * Caller is responsible to delete container and elements. + * @return a std::vector of SegmentStrings (copies of input, if needs be). + * Caller is responsible to delete elements of container. + * This method may only be called once. */ - virtual std::vector* getNodedSubstrings() const = 0; + virtual std::vector getNodedSubstrings() = 0; virtual ~Noder() {} diff --git a/include/geos/noding/ScaledNoder.h b/include/geos/noding/ScaledNoder.h index 6ca44c680..2e0d615be 100644 --- a/include/geos/noding/ScaledNoder.h +++ b/include/geos/noding/ScaledNoder.h @@ -77,9 +77,9 @@ public: ~ScaledNoder() override; - std::vector* getNodedSubstrings() const override; + std::vector getNodedSubstrings() override; - void computeNodes(std::vector* inputSegStr) override; + void computeNodes(const std::vector& inputSegStr) override; //void filter(Coordinate& c); @@ -106,7 +106,7 @@ private: void rescale(std::vector& segStrings) const; - void scale(std::vector& segStrings) const; + void scale(const std::vector& segStrings) const; class Scaler; diff --git a/include/geos/noding/SegmentExtractingNoder.h b/include/geos/noding/SegmentExtractingNoder.h index 6a7277166..5f4f29d15 100644 --- a/include/geos/noding/SegmentExtractingNoder.h +++ b/include/geos/noding/SegmentExtractingNoder.h @@ -53,7 +53,7 @@ class GEOS_DLL SegmentExtractingNoder : public Noder { private: - std::vector* segList; + std::vector segList; void extractSegments( const std::vector& inputSegs, @@ -69,16 +69,15 @@ public: /** * Creates a new segment-extracting noder. */ - SegmentExtractingNoder() : segList(nullptr) - {}; + SegmentExtractingNoder() = default; - void computeNodes(std::vector* segStrings) override; + void computeNodes(const std::vector& segStrings) override; /** * @return a Collection of SegmentString representing the * substrings. Caller takes ownership over vector and contents. */ - std::vector* getNodedSubstrings() const override; + std::vector getNodedSubstrings() override; }; diff --git a/include/geos/noding/SimpleNoder.h b/include/geos/noding/SimpleNoder.h index bbe6b5420..b2bf4f70c 100644 --- a/include/geos/noding/SimpleNoder.h +++ b/include/geos/noding/SimpleNoder.h @@ -47,7 +47,7 @@ namespace noding { // geos.noding */ class GEOS_DLL SimpleNoder: public SinglePassNoder { private: - std::vector* nodedSegStrings; + std::vector nodedSegStrings; virtual void computeIntersects(SegmentString* e0, SegmentString* e1); public: @@ -56,12 +56,12 @@ public: SinglePassNoder(nSegInt) {} - void computeNodes(std::vector* inputSegmentStrings) override; + void computeNodes(const std::vector& inputSegmentStrings) override; - std::vector* - getNodedSubstrings() const override + std::vector + getNodedSubstrings() override { - return NodedSegmentString::getNodedSubstrings(*nodedSegStrings); + return NodedSegmentString::getNodedSubstrings(nodedSegStrings); } }; diff --git a/include/geos/noding/SinglePassNoder.h b/include/geos/noding/SinglePassNoder.h index 412c19b0f..1c2de5613 100644 --- a/include/geos/noding/SinglePassNoder.h +++ b/include/geos/noding/SinglePassNoder.h @@ -79,7 +79,7 @@ public: * * @param segStrings a collection of {@link SegmentString}s to node */ - void computeNodes(std::vector* segStrings) override = 0; + void computeNodes(const std::vector& segStrings) override = 0; /** \brief * Returns a Collection of fully noded {@link SegmentString}s. @@ -88,7 +88,7 @@ public: * * @return a Collection of SegmentStrings */ - std::vector* getNodedSubstrings() const override = 0; + std::vector getNodedSubstrings() override = 0; }; diff --git a/include/geos/noding/ValidatingNoder.h b/include/geos/noding/ValidatingNoder.h index ce45c74cf..e6a3af6a2 100644 --- a/include/geos/noding/ValidatingNoder.h +++ b/include/geos/noding/ValidatingNoder.h @@ -51,7 +51,7 @@ class GEOS_DLL ValidatingNoder : public Noder { private: - std::vector* nodedSS; + std::vector nodedSS; noding::Noder& noder; @@ -61,11 +61,11 @@ public: : noder(noderArg) {} - void computeNodes(std::vector* segStrings) override; + void computeNodes(const std::vector& segStrings) override; void validate(); - std::vector* getNodedSubstrings() const override; + std::vector getNodedSubstrings() override; }; diff --git a/include/geos/noding/snap/SnappingNoder.h b/include/geos/noding/snap/SnappingNoder.h index 40f057a44..8381f13bd 100644 --- a/include/geos/noding/snap/SnappingNoder.h +++ b/include/geos/noding/snap/SnappingNoder.h @@ -71,13 +71,13 @@ private: // Members double snapTolerance; SnappingPointIndex snapIndex; - std::vector* nodedResult; + std::vector nodedResult; // Methods - void seedSnapIndex(std::vector& segStrings); + void seedSnapIndex(const std::vector& segStrings); - void snapVertices(std::vector& segStrings, std::vector& nodedStrings); + void snapVertices(const std::vector& segStrings, std::vector& nodedStrings); SegmentString* snapVertices(SegmentString* ss); @@ -91,7 +91,7 @@ private: * * @return a list of Coordinates for the intersections */ - std::unique_ptr> snapIntersections(std::vector& inputSS); + std::vector snapIntersections(std::vector& inputSS); public: @@ -108,9 +108,9 @@ public: /** * @return a Collection of NodedSegmentStrings representing the substrings */ - std::vector* getNodedSubstrings() const override; + std::vector getNodedSubstrings() override; - void computeNodes(std::vector* inputSegStrings) override; + void computeNodes(const std::vector& inputSegStrings) override; }; diff --git a/include/geos/noding/snapround/MCIndexSnapRounder.h b/include/geos/noding/snapround/MCIndexSnapRounder.h index 70305f1d5..ba1ad2db7 100644 --- a/include/geos/noding/snapround/MCIndexSnapRounder.h +++ b/include/geos/noding/snapround/MCIndexSnapRounder.h @@ -83,13 +83,13 @@ public: li.setPrecisionModel(&pm); } - std::vector* - getNodedSubstrings() const override + std::vector + getNodedSubstrings() override { - return NodedSegmentString::getNodedSubstrings(*nodedSegStrings); + return NodedSegmentString::getNodedSubstrings(nodedSegStrings); } - void computeNodes(std::vector* segStrings) override; + void computeNodes(const std::vector& segStrings) override; /** * Computes nodes introduced as a result of @@ -99,7 +99,7 @@ public: * NOTE: they *must* be instances of NodedSegmentString, or * an assertion will fail. */ - void computeVertexSnaps(std::vector& edges); + void computeVertexSnaps(const std::vector& edges); private: @@ -110,11 +110,11 @@ private: double scaleFactor; - std::vector* nodedSegStrings; + std::vector nodedSegStrings; std::unique_ptr pointSnapper; - void snapRound(MCIndexNoder& noder, std::vector* segStrings); + void snapRound(MCIndexNoder& noder, const std::vector& segStrings); /** @@ -125,7 +125,7 @@ private: * */ void findInteriorIntersections(MCIndexNoder& noder, - std::vector* segStrings, + const std::vector& segStrings, std::vector& intersections); /** diff --git a/include/geos/noding/snapround/SnapRoundingNoder.h b/include/geos/noding/snapround/SnapRoundingNoder.h index 78dc8c708..528c63df8 100644 --- a/include/geos/noding/snapround/SnapRoundingNoder.h +++ b/include/geos/noding/snapround/SnapRoundingNoder.h @@ -83,7 +83,7 @@ private: std::vector snappedResult; // Methods - void snapRound(std::vector& inputSegStrings, std::vector& resultNodedSegments); + void snapRound(const std::vector& inputSegStrings, std::vector& resultNodedSegments); /** * Creates HotPixels for each vertex in the input segStrings. @@ -92,14 +92,14 @@ private: * if they interact with other segments (or they are already * created as intersection nodes). */ - void addVertexPixels(std::vector& segStrings); + void addVertexPixels(const std::vector& segStrings); /** * Detects interior intersections in the collection of {@link SegmentString}s, * and adds nodes for them to the segment strings. * Also creates HotPixel nodes for the intersection points. */ - void addIntersectionPixels(std::vector& segStrings); + void addIntersectionPixels(const std::vector& segStrings); /** * Gets a list of the rounded coordinates. @@ -148,13 +148,13 @@ public: /** * @return a Collection of NodedSegmentStrings representing the substrings */ - std::vector* getNodedSubstrings() const override; + std::vector getNodedSubstrings() override; /** * Computes the nodes in the snap-rounding line arrangement. * The nodes are added to the {@link NodedSegmentString}s provided as the input. */ - void computeNodes(std::vector* inputSegStrings) override; //override + void computeNodes(const std::vector& inputSegStrings) override; //override }; diff --git a/include/geos/operation/overlayng/EdgeNodingBuilder.h b/include/geos/operation/overlayng/EdgeNodingBuilder.h index 9d2195b35..8130c1aa1 100644 --- a/include/geos/operation/overlayng/EdgeNodingBuilder.h +++ b/include/geos/operation/overlayng/EdgeNodingBuilder.h @@ -177,7 +177,7 @@ private: * which is used to provide source topology info to the constructed Edges * (and is then discarded). */ - std::vector node(std::vector* segStrings); + std::vector node(const std::vector& segStrings); std::vector createEdges(std::vector* segStrings); diff --git a/src/coverage/CoverageCleaner.cpp b/src/coverage/CoverageCleaner.cpp index 80c044eb9..88e30c872 100644 --- a/src/coverage/CoverageCleaner.cpp +++ b/src/coverage/CoverageCleaner.cpp @@ -419,14 +419,14 @@ CoverageCleaner::node(std::vector& p_coverage, double p_snapDis } SnappingNoder noder(p_snapDistance); - noder.computeNodes(&segs); - std::unique_ptr> nodedSegStrings(noder.getNodedSubstrings()); + noder.computeNodes(segs); + auto nodedSegStrings= noder.getNodedSubstrings(); for (auto* ss : segs) { delete ss; } - auto result = toGeometry(*nodedSegStrings, geomFactory); - for (SegmentString* ss : *nodedSegStrings) { + auto result = toGeometry(nodedSegStrings, geomFactory); + for (SegmentString* ss : nodedSegStrings) { delete ss; } diff --git a/src/noding/BoundaryChainNoder.cpp b/src/noding/BoundaryChainNoder.cpp index 6f07bd9e2..8a7637c08 100644 --- a/src/noding/BoundaryChainNoder.cpp +++ b/src/noding/BoundaryChainNoder.cpp @@ -29,11 +29,11 @@ namespace noding { // geos::noding /* public */ void -BoundaryChainNoder::computeNodes(std::vector* segStrings) +BoundaryChainNoder::computeNodes(const std::vector& segStrings) { SegmentSet boundarySegSet; std::vector boundaryChains; - boundaryChains.reserve(segStrings->size()); + boundaryChains.reserve(segStrings.size()); addSegments(segStrings, boundarySegSet, boundaryChains); markBoundarySegments(boundarySegSet); m_chainList = extractChains(boundaryChains); @@ -134,20 +134,20 @@ BoundaryChainNoder::findNodeIndex( /* public */ -std::vector* -BoundaryChainNoder::getNodedSubstrings() const +std::vector +BoundaryChainNoder::getNodedSubstrings() { - return new std::vector(std::move(m_chainList)); + return std::move(m_chainList); } /* private */ void BoundaryChainNoder::addSegments( - std::vector* segStrings, + const std::vector& segStrings, SegmentSet& segSet, std::vector