contrek 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58d88411970256b3edc37da05dd9304aaa4593b320e7d73db5966b69d403c4cf
-  data.tar.gz: 6a05687f7ffba4b22eb7ebf02abf2a622931bc3250968fa785fb13720036118e
+  metadata.gz: 8fcfc790a324e42855e8b8e816f946da8ea764943a44f4d9999b4cc7a360209d
+  data.tar.gz: 8f0d0f42350fc8236a9c2e5ca974ab11d91a5bcfbdd4a7fdef9cf310bf764306
 SHA512:
-  metadata.gz: 7150e06efce7580fdefd55725db0de52e2805b909e800679a0f99481c3e52333209d1b5ceb750c1fc63a28fa6aaaad7f7662d3baf3ebf377b29cfe4dacf6d19d
-  data.tar.gz: 988e85fd99234df2b3cd0e8bec0d8f68ba0f631111a3fda62e114e185dd1619589223266b5e3db71a2a5c478d2871f862209489df997a13a9da866b84718c609
+  metadata.gz: b7a5c008b6811b36ce143642d6300e89d7975dd0861cfc429880bbd76bf8a4b2eadf6c24351ca6d3de746ddbecaec849b4aed2052e973e34a386a9ae20e4a4a6
+  data.tar.gz: 8ff2d2465df0afcd376255bb575a46581d27888ec5e7293d9971e27f624550dc83e1fb47ca11814cbeb220c0b38c51b7179087361fbab9140ca181a728de706e

data/CHANGELOG.md

@@ -122,3 +122,13 @@ All notable changes to this project will be documented in this file.
 
 ## [1.2.9] - 2026-06-13
 - **Streaming merger:** The streaming merger class extends VerticalMerger and adds a useful feature: the progressive extraction of contours into a disk buffer (SVG file). In this way, all extracted polygons that are no longer within the junction zone of the next stripe are removed from the system and streamed directly to disk. This incredibly reduces memory consumption, allowing the processing of very large files on machines with low memory availability, at the expense of increased processing times. An example of this technique is available in both C++ and Ruby in the repository.
+
+## [1.3.0] - 2026-06-17
+- **Streaming merger:** Improvements and bug fixing.
+- **CPP code:** All structures now own 'Point' instances by value instead of raw pointers. Removed now-redundant `clone()` method; results from `process_info()` are already self-contained since points are owned by value, so the defensive deep copy is no longer needed.
+
+## [1.3.1] - 2026-06-20
+- **Streaming merger:** The progressive streaming extraction mode has now reached new heights of efficiency on the C++ side. This mode allows the data source to be processed in contiguous blocks. All isolated polygons, as well as those extending into the bottom strips, are removed from the list and streamed directly to the SVG file. This drastically reduces RAM requirements. An extreme test on an 81920×81920 pixel image containing a massive number of polygons (20,000,000) was processed using roughly 40 strips of 2000 pixels each in less than 300 seconds, peaking at a RAM usage of just 13GB.
+
+## [1.3.2] - 2026-06-27
+- **Streaming merger:** A series of optimizations have been implemented at the C++ memory pool level; using a different strategy, these are now freed as soon as possible depending on the source data content and the morphology of the containing polygons. This has allowed for a further reduction in the peak memory indicated in the previous changelog, specifically from 13GB to 4.3GB, on the same image with 20,000,000 polygons.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.3.0)
+    contrek (1.3.2)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -1,12 +1,12 @@
 # Contrek
-Contrek is a Ruby gem powered by a <u>[standalone C++17 core library](#-c-standalone-library-usage)</u> for fast contour tracing and edge detection in PNG images and raw memory streams. It employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
-
+**Contrek** is a standalone <u>[C++17 topology-preserving streaming polygonization engine](#-c-standalone-library-usage)</u> for raster-to-vector conversion. It extracts polygonal contours from PNG images and raw memory streams using programmable pixel matchers, representing shapes as connected graphs of shared vertices to guarantee topological consistency. Its streaming architecture supports gigapixel-scale datasets, multithreaded execution, and incremental vector serialization to multiple formats such as SVG while keeping memory consumption bounded. A fully featured Ruby wrapper is also available, exposing the complete C++ API through an idiomatic Ruby interface.
 
 ## About Contrek library
 
 Contrek (**con**tour **trek**king) simply scans your png/raw bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.
 
 In the following image all the non-white pixels have been examined and the result is the red polygon for the outer contour and the green one for the inner one
+
 ![alt text](contrek.png "Contour tracing")
 
 ## 🚀 Why Contrek?
@@ -58,7 +58,7 @@ The **Stripe-Merging** algorithm has been validated through a dedicated testing
 * **Extraction Fidelity:** Verifying polygon precision across both engines.
 
 The complete testing suite, source code, and raw benchmarks are available here:
-👉 **[test_opencv_contrek](https://github.com/runout77/test_opencv_contrek)**
+👉 **[test_contrek](https://github.com/runout77/test_contrek)**
 
 ## Prerequisites
 

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -18,6 +18,8 @@
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
+#include <fstream>
+#include <unistd.h>
 
 #include "polygon/finder/PolygonFinder.h"
 #include "polygon/finder/concurrent/ClippedPolygonFinder.h"
@@ -35,6 +37,8 @@
 #include "polygon/finder/concurrent/HorizontalMerger.h"
 #include "polygon/finder/concurrent/VerticalMerger.h"
 #include "polygon/finder/concurrent/StreamingMerger.h"
+#include "polygon/finder/concurrent/SvgStreamingMerger.h"
+#include "polygon/finder/concurrent/GeoJsonStreamingMerger.h"
 #include "polygon/finder/concurrent/Sequence.h"
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
@@ -316,7 +320,7 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
     int stripe_count = 0;
     // main stripes loop
     for (uint32_t current_y_offset = 0; current_y_offset < total_height; current_y_offset += stripe_height) {
-      int uncovered_height = total_height - current_y_offset;
+      uint32_t uncovered_height = total_height - current_y_offset;
 
       // copy previous last line to the next new one (each contigue stripe must share one pixel scanline)
       if (current_y_offset > 0) {
@@ -384,6 +388,17 @@ void Tests::test_i() {
   std::cout << "Memory usage peak: " << get_peak_rss() << " MB" << std::endl;
 }
 
+double get_current_rss_mb() {
+  std::ifstream statm("/proc/self/statm");
+  uint32_t size = 0;
+  uint32_t resident = 0;
+
+  statm >> size >> resident;
+
+  uint32_t page_size = sysconf(_SC_PAGESIZE);
+  return (resident * page_size) / (1024.0 * 1024.0);
+}
+
 void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_height) {
     std::vector<ProcessResult*> result_clones;
     std::vector<std::string> varguments = {"--bounds"};
@@ -422,14 +437,17 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
     if (!shared_stream) {
       std::cerr << "Error: Unable creating output streaming file!" << std::endl;
     }
+    std::vector<char> buffer(4 * 1024 * 1024);  // Buffer (4MB)
+    shared_stream.rdbuf()->pubsetbuf(buffer.data(), buffer.size());
 
-    StreamingMerger vmerger(0, &varguments, &shared_stream, total_width, total_height);
+    SvgStreamingMerger vmerger(0, &varguments, &shared_stream, total_width, total_height);
+    // GeoJsonStreamingMerger vmerger(0, &varguments, &shared_stream, total_width, total_height, 4294901760);
     try {
       size_t row_size = static_cast<size_t>(total_width) * 4;
       int stripe_count = 0;
       // main stripes loop
       for (uint32_t current_y_offset = 0; current_y_offset < total_height; current_y_offset += stripe_height) {
-        int uncovered_height = total_height - current_y_offset;
+        uint32_t uncovered_height = total_height - current_y_offset;
 
         // copy previous last line to the next new one (each contigue stripe must share one pixel scanline)
         if (current_y_offset > 0) {
@@ -461,20 +479,15 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
         ProcessResult *result = polygon_finder.process_info();
         if (result) {
           std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-          result_clones.push_back(result);
           vmerger.add_tile(*result, !(current_y_offset + stripe_height < total_height));
+          delete result;
+          std::cout << "-> RSS before merge: " << get_current_rss_mb() << " MB" << std::endl;
         }
         stripe_count++;
       }
-
       ProcessResult *merged_result = vmerger.process_info();
       std::cout << "total found polygons " << merged_result->groups << std::endl;
       delete merged_result;
-
-      // frees memory
-      for (auto c : result_clones) {
-        delete c;
-      }
     } catch (const std::exception& e) {
       std::cerr << "\n[ERROR] Processing exception: " << e.what() << std::endl;
       if (shared_stream.is_open()) shared_stream.close();
@@ -485,5 +498,6 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
 
 void Tests::test_l() {
   stream_progressive_png_image("../images/mixed_shapes_1024x1024.png", 300);
+  // stream_progressive_png_image("../images/test_20480x20480.png", 2000);
   std::cout << "Memory usage peak: " << get_peak_rss() << " MB" << std::endl;
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp

@@ -32,9 +32,9 @@ FastPngBitmap::FastPngBitmap(std::string filename) : RawBitmap() {
       } else {
         spng_ctx *ctx = spng_ctx_new(0);
         spng_set_png_buffer(ctx, file_buffer.data(), file_buffer.size());
-        struct spng_ihdr ihdr;
+        struct spng_ihdr ihdr = {};
         spng_get_ihdr(ctx, &ihdr);
-        size_t out_size;
+        size_t out_size = 0;
         spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
         this->define(ihdr.width, ihdr.height, 4, false);
         unsigned char* raw_ptr = this->image.get();

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RawBitmap.cpp

@@ -29,7 +29,7 @@ int RawBitmap::h() {
   return this->height;
 }
 
-char RawBitmap::value_at(int x, int y) {
+char RawBitmap::value_at(int, int) {
   return(0);
 }
 
@@ -48,7 +48,7 @@ unsigned int RawBitmap::rgb_value_at(int x, int y) {
 }
 
 void RawBitmap::draw_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
-  if (x < 0 || x >= width || y < 0 || y >= height) return;
+  if (x < 0 || x >= static_cast<int>(width) || y < 0 || y >= static_cast<int>(height)) return;
   unsigned char* p = &image[(static_cast<size_t>(y) * width + x) * bpp];
   p[0] = r;
   if (bpp > 1) p[1] = g;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.cpp

@@ -30,7 +30,7 @@ RemoteFastPngBitmap::RemoteFastPngBitmap(std::string *dataurl) : FastPngBitmap("
     struct spng_ihdr ihdr;
     int error = spng_get_ihdr(ctx, &ihdr);
     if (!error) {
-      size_t out_size;  // RGBA8 dimension
+      size_t out_size = 0;  // RGBA8 dimension
       spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
       this->define(ihdr.width, ihdr.height, 4, false);
       error = spng_decode_image(ctx, image.get(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.h

@@ -43,7 +43,7 @@ struct SmallVec {
       ptr = np; cap = n;
   }
   void clear() { sz = 0; ptr = buf; cap = INLINE_CAP; }
-  int  size()  const { return sz; }
+  unsigned int size() const { return static_cast<unsigned int>(sz); }
   int& operator[](int i) { return ptr[i]; }
   int  operator[](int i) const { return ptr[i]; }
   int* begin() { return ptr; }
@@ -88,7 +88,6 @@ class Node : public  Listable {
   int abs_x_index;
   int up_indexer, down_indexer;
   int tangs_count;
-  char name;
   int track;
   int outer_index, inner_index;
   int upper_start = std::numeric_limits<int>::max();
@@ -112,6 +111,7 @@ class Node : public  Listable {
   Node(int min_x, int max_x, int y, NodeCluster* cluster, char name);
   void precalc_tangs_sequences(NodeCluster& cluster);
   bool processed = false;
+  char name;
   int inner_left_index = -1;
   int inner_right_index = -1;
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.h

@@ -14,7 +14,6 @@
 #include <map>
 #include <string>
 #include <utility>
-#include "PolygonFinder.h"
 #include "Lists.h"
 #include "RectBounds.h"
 #include "Polygon.h"
@@ -34,8 +33,10 @@ class NodeCluster {
   int count = 0;
   int nodes;
   int width;
+  int height;
 
  public:
+  int get_height() const { return height; }
   pf_Options *options;
   std::vector<std::pair<int, int>> treemap;  // [a,b] a = index of parent outer, b = index of inner of parent outer
   std::pair<int, int> test_in_hole_a(Node* node);
@@ -43,7 +44,6 @@ class NodeCluster {
   std::vector<std::deque<Node>> vert_nodes;
   void compress_coords(std::list<Polygon>& polygons, pf_Options options);
   List *root_nodes;
-  int height;
   std::list<Polygon> polygons;
   NodeCluster(int h, int w, pf_Options *options);
   virtual ~NodeCluster();
@@ -55,3 +55,5 @@ class NodeCluster {
   std::list<Node*>::iterator exam(std::list<Node*>::iterator inode, Node *node, Node *father, Node *root_node);
   std::vector<std::vector<Node*>> sequences;
 };
+
+#include "PolygonFinder.h"

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/PolygonFinder.cpp

@@ -29,14 +29,14 @@
 
 PolygonFinder::PolygonFinder(Bitmap *bitmap,
                              Matcher *matcher,
-                             Bitmap *test_bitmap,
+                             Bitmap *,
                              std::vector<std::string> *options,
                              int start_x,
                              int end_x)
-    : source_bitmap(bitmap),
-      matcher(matcher),
-      start_x(start_x),
-      end_x(end_x == -1 ? bitmap->w() : end_x)
+    : start_x(start_x),
+      end_x(end_x == -1 ? bitmap->w() : end_x),
+      source_bitmap(bitmap),
+      matcher(matcher)
 { this->rgb_matcher = dynamic_cast<RGBMatcher*>(matcher);
   if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
 
@@ -70,7 +70,7 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
 
 std::list<ShapeLine*> *PolygonFinder::get_shapelines() {
   std::list<ShapeLine*> *sll = new std::list<ShapeLine*>();
-  for (int line = 0; line < this->node_cluster->height; line++) {
+  for (int line = 0; line < this->node_cluster->get_height(); line++) {
     for (Node& node : this->node_cluster->vert_nodes[line]) {
       ShapeLine *sl = new ShapeLine({node.min_x, node.max_x, node.y});
       sll->push_back(sl);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Cluster.cpp

@@ -17,7 +17,7 @@
 #include "Cursor.h"
 #include "../../CpuTimer.h"
 
-Cluster::Cluster(Finder *finder, int height, int start_x, int end_x)
+Cluster::Cluster(Finder *finder, int height)
   : finder_(finder)
 { tiles_.reserve(2);  // only two (left|right)
   this->hub_ = new Hub(height);
@@ -55,6 +55,7 @@ Tile* Cluster::merge_tiles() {
   CpuTimer timer;
 
   std::vector<Shape*> new_shapes;
+  std::vector<Shape*> detach_shapes;
   std::vector<InnerPolyline*> all_new_inner_polylines;
 
   timer.start();
@@ -78,34 +79,34 @@ Tile* Cluster::merge_tiles() {
 
       if (shape->outer_polyline->any_ancients) {
         Cursor cursor(*this, shape);
-        Sequence* new_outer = nullptr;
-
         timer.start();
-        new_outer = cursor.join_outers();
+        Sequence new_outer = cursor.join_outers();
         tot_outer += timer.stop();
 
         timer.start();
         std::vector<InnerPolyline*> new_inners = shape->inner_polylines;
-        std::vector<InnerPolyline*> new_inner_polylines = cursor.join_inners(new_outer, treemap);
+        std::vector<InnerPolyline*> new_inner_polylines = cursor.join_inners(treemap);
         tot_inner += timer.stop();
 
         for (InnerPolyline* inner_polyline : new_inner_polylines) {
           new_inners.push_back(inner_polyline);
           if (treemap) {
-            inner_polyline->sequence()->compute_vertical_bounds();
+            inner_polyline->compute_vertical_bounds();
             all_new_inner_polylines.push_back(inner_polyline);
           }
         }
         for (auto s : cursor.orphan_inners()) {
           new_inners.push_back(s);
         }
-        Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer->to_vector(), std::nullopt);
+        shape->clear_inner();
+
+        Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer.to_vector(), std::nullopt);
         Shape* inserting_new_shape = tile->shapes_pool->acquire_shape(polyline, new_inners);
         new_shapes.push_back(inserting_new_shape);
         polyline->shape = inserting_new_shape;
 
         for (InnerPolyline* inner_polyline : new_inner_polylines) {
-          inner_polyline->sequence()->shape = inserting_new_shape;
+          inner_polyline->shape = inserting_new_shape;
         }
         if (treemap) {
           for (const auto merged_shape : cursor.shapes_sequence()) {
@@ -116,6 +117,9 @@ Tile* Cluster::merge_tiles() {
             assign_ancestry(inserting_new_shape, inside_inner_polyline);
           }
         }
+        for (const auto merged_shape : cursor.shapes_sequence()) {
+          detach_shapes.push_back(merged_shape);
+        }
       } else {
         if (treemap) {
           if (shape->fixed) {
@@ -134,7 +138,6 @@ Tile* Cluster::merge_tiles() {
 
   double past_tot_outer = tiles_.front()->benchmarks.outer + tiles_.back()->benchmarks.outer;
   double past_tot_inner = tiles_.front()->benchmarks.inner + tiles_.back()->benchmarks.inner;
-
   Benchmarks b{
     tot_outer + past_tot_outer,
     tot_inner + past_tot_inner
@@ -144,6 +147,9 @@ Tile* Cluster::merge_tiles() {
     this->finder_, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
 
   tile->assign_shapes(new_shapes);
+  for (const auto shape : detach_shapes) {
+    shape->detach_from_pool();
+  }
   for (Tile* old_tile : tiles_) {
     tile->adopt(old_tile);
   }
@@ -151,7 +157,7 @@ Tile* Cluster::merge_tiles() {
 }
 
 void Cluster::assign_ancestry(Shape *shape, InnerPolyline* inner_polyline)
-{ shape->set_parent_shape(inner_polyline->sequence()->shape);
+{ shape->set_parent_shape(inner_polyline->shape);
   shape->parent_inner_polyline = inner_polyline;
   shape->fixed = true;
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Cluster.h

@@ -25,7 +25,7 @@ class Cluster {
   void is_children(Shape* shape, std::vector<InnerPolyline*> inner_polylines);
 
  public:
-  Cluster(Finder *finder, int height, int start_x, int end_x);
+  Cluster(Finder *finder, int height);
   virtual ~Cluster();
   void add(Tile* tile);
   Tile* merge_tiles();
@@ -34,5 +34,5 @@ class Cluster {
   static void list_to_string(std::vector<Point> list);
   PartPool parts_pool;
   std::deque<Position> positions_pool;
-  const Finder* finder() const { return finder_; };
+  const Finder* finder() const { return finder_; }
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Cursor.cpp

@@ -18,20 +18,20 @@ Cursor::Cursor(Cluster& cluster, Shape* shape)
 : cluster(cluster), shape(shape) {
 }
 
-Sequence* Cursor::join_outers()
+Sequence Cursor::join_outers()
 { Polyline* outer_polyline = shape->outer_polyline;
   this->shapes_sequence_.push_back(this->shape);
   this->shapes_sequence_lookup.insert(this->shape);
-  Sequence* outer_joined_polyline = outer_polyline->tile->shapes_pool->acquire_sequence();
+  Sequence outer_joined_polyline;
   std::vector<Part*> all_parts;
   this->traverse_outer(outer_polyline->parts().front(),
                        all_parts,
                        this->shapes_sequence_,
                        outer_joined_polyline);
 
-  if (outer_joined_polyline->head->payload == outer_joined_polyline->tail->payload &&
+  if (outer_joined_polyline.head->payload == outer_joined_polyline.tail->payload &&
       this->cluster.tiles().front()->left() &&
-      this->cluster.tiles().back()->right()) outer_joined_polyline->pop();
+      this->cluster.tiles().back()->right()) outer_joined_polyline.pop();
 
   for (Shape* shape : shapes_sequence_) {
     shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
@@ -50,7 +50,7 @@ Sequence* Cursor::join_outers()
 void Cursor::traverse_outer(Part* act_part,
                             std::vector<Part*>& all_parts,
                             std::vector<Shape*>& shapes_sequence,
-                            Sequence* outer_joined_polyline) {
+                            Sequence& outer_joined_polyline) {
   while (act_part != nullptr) {
     Part* last_part = (!all_parts.empty()) ? all_parts.back() : nullptr;
     if (all_parts.empty() || last_part != act_part) {
@@ -61,12 +61,7 @@ void Cursor::traverse_outer(Part* act_part,
       if (act_part->size == 0) return;
 
       while (Position *position = act_part->next_position(nullptr)) {
-        if (outer_joined_polyline->size > 1 &&
-          outer_joined_polyline->head->payload == position->payload &&
-          act_part == all_parts.front()) {
-          return;
-        }
-        outer_joined_polyline->add(position);
+        outer_joined_polyline.add(position);
       }
     } else {
       if (act_part->dead_end &&
@@ -74,13 +69,13 @@ void Cursor::traverse_outer(Part* act_part,
          last_part->is(Part::SEAM) &&
          last_part->polyline() == act_part->polyline()) return;
       while (Position *new_position = static_cast<Position*>(act_part->iterator())) {
-        if (outer_joined_polyline->size > 1 &&
-          outer_joined_polyline->head->payload == new_position->payload &&
+        if (outer_joined_polyline.size > 1 &&
+          outer_joined_polyline.head->payload == new_position->payload &&
           act_part == all_parts.front()) {
           return;
         }
         this->cluster.positions_pool.emplace_back(this->cluster.hub(), new_position->payload);
-        outer_joined_polyline->add(&this->cluster.positions_pool.back());
+        outer_joined_polyline.add(&this->cluster.positions_pool.back());
         new_position->end_point()->tracked_outer = true;
         int versus = act_part->versus();
         auto& q_set = new_position->end_point()->queues();
@@ -130,7 +125,7 @@ void Cursor::traverse_outer(Part* act_part,
   }
 }
 
-std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treemap) {
+std::vector<InnerPolyline*> Cursor::join_inners(bool treemap) {
   std::vector<InnerPolyline*> return_inner_polylines;
   std::vector<Shape*> processing_queue = shapes_sequence_;
   for (size_t i = 0; i < shapes_sequence_.size(); ++i)
@@ -145,10 +140,10 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treema
           .max = 0
         };
         traverse_inner(part, all_parts, bounds, tracked_end_points);
-        Sequence* retme_sequence = shape->outer_polyline->tile->shapes_pool->acquire_sequence();
+        Sequence retme_sequence;
         for (Part* part : all_parts)
         { part->touch();
-          retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
+          retme_sequence.move_from(*part, [&](QNode<Point>* pos) -> bool {
           Position *position = static_cast<Position*>(pos);
           if (part->is(Part::ADDED) &&
              !(position->payload.y >= bounds.min &&
@@ -158,8 +153,8 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treema
             return(!(polyline->tile->tg_border(position->payload) && position->end_point()->tracked_outer));
           });
         }
-        if (retme_sequence->is_not_vertical()) {
-          InnerPolyline* inner_polyline = polyline->tile->shapes_pool->acquire_inner_polyline(retme_sequence);
+        if (retme_sequence.is_not_vertical()) {
+          InnerPolyline* inner_polyline = polyline->tile->shapes_pool->acquire_inner_polyline(&retme_sequence);
           return_inner_polylines.push_back(inner_polyline);
           if (treemap) {
             mark_children(tracked_end_points, polyline, inner_polyline);
@@ -206,7 +201,7 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     if (act_part->innerable()) {
       all_parts.push_back(act_part);
       bool jumped = false;
-      while (act_part = act_part->circular_next) {
+      while ((act_part = act_part->circular_next)) {
         if (act_part->innerable()) {
             all_parts.push_back(act_part);
         } else {
@@ -238,6 +233,7 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
                   orphan_inners_.end(),
                   shape->inner_polylines.begin(),
                   shape->inner_polylines.end());
+                shape->clear_inner();
               }
               dest_part->polyline()->turn_on(Polyline::TRACKED_OUTER);
               if (!dest_part->touched()) {

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Cursor.h

@@ -20,8 +20,8 @@
 class Cursor {
  public:
   Cursor(Cluster& cluster, Shape* shape);
-  Sequence* join_outers();
-  std::vector<InnerPolyline*> join_inners(Sequence* outer_seq, bool treemap);
+  Sequence join_outers();
+  std::vector<InnerPolyline*> join_inners(bool treemap);
   std::list<InnerPolyline*> orphan_inners() { return orphan_inners_; }
   const std::vector<Shape*>& shapes_sequence() const { return shapes_sequence_; }
 
@@ -34,7 +34,7 @@ class Cursor {
   void traverse_outer(Part* act_part,
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
-                      Sequence* outer_joined_polyline);
+                      Sequence& outer_joined_polyline);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds, std::vector<EndPoint*>& tracked_end_points);
   std::vector<Shape*> connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes);
   void mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Finder.cpp

@@ -95,16 +95,8 @@ void Finder::process_tiles() {
 
     if (it != arriving_tiles.end()) {
       Tile* twin_tile = *it;
-      int start_x, end_x;
-      if (twin_tile->start_x() == (tile->end_x() - 1)) {
-        start_x = tile->start_x();
-        end_x = twin_tile->end_x();
-      } else {
-        start_x = twin_tile->start_x();
-        end_x = tile->end_x();
-      }
 
-      Cluster *cluster = new Cluster(this, this->height, start_x, end_x);
+      Cluster *cluster = new Cluster(this, this->height);
 
       if (twin_tile->start_x() == (tile->end_x() - 1)) {
         cluster->add(tile);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/GeoJsonStreamingMerger.h

@@ -0,0 +1,81 @@
+/*
+ * GeoJsonStreamingMerger.h
+ *
+ * Copyright (c) 2025-2026 Emanuele Cesaroni
+ *
+ * Licensed under the GNU Affero General Public License v3 (AGPLv3).
+ * See the LICENSE file in this directory for the full license text.
+ */
+
+#pragma once
+#include <vector>
+#include <string>
+#include "StreamingMerger.h"
+
+class GeoJsonStreamingMerger : public StreamingMerger {
+ private:
+  unsigned int target_value;
+  bool is_first_feature = true;
+
+ protected:
+  void write_header() override {
+    if (stream) {
+      *stream << "{\"type\":\"FeatureCollection\",\"features\":[\n";
+    }
+  }
+
+  void write_footer() override {
+    if (stream) {
+      *stream << "\n]}";
+    }
+  }
+  void write_outer_polygon_start() override {}
+  void write_outer_polygon_end() override {}
+  void write_inner_polygon_start() override {}
+  void write_inner_polygon_end() override {}
+
+ public:
+  GeoJsonStreamingMerger(int number_of_threads,
+                         std::vector<std::string>* options,
+                         std::ofstream* stream_to,
+                         int total_width, int total_height,
+                         unsigned int pixel_value)
+      : StreamingMerger(number_of_threads, options, stream_to, total_width, total_height),
+        target_value(pixel_value) {}
+
+  void stream_raw_polygon(const Shape* shape) override {
+    if (!stream) return;
+    if (!is_first_feature) {
+      *stream << ",\n";
+    }
+    is_first_feature = false;
+
+    *stream << "{\"type\":\"Feature\",\"properties\":{\"value\":" << target_value
+            << "},\"geometry\":{\"type\":\"Polygon\",\"coordinates\":[ [";
+    const std::vector<Point>& points = shape->outer_polyline->raw();
+    const size_t points_size = points.size();
+    if (points_size > 0) {
+      for (size_t i = 0; i < points_size; ++i) {
+        *stream << "[" << points[i].y << "," << points[i].x << "]";
+        if (i < points_size - 1) *stream << ",";
+      }
+      *stream << ",[" << points[0].y << "," << points[0].x << "]]";
+    } else {
+      *stream << "]]";
+    }
+
+    for (const auto& inner_polyline : shape->inner_polylines) {
+      const std::vector<Point>& inner_points = inner_polyline->raw();
+      const size_t inner_size = inner_points.size();
+      if (inner_size > 0) {
+        *stream << ",[";
+        for (size_t i = 0; i < inner_size; ++i) {
+          *stream << "[" << inner_points[i].y << "," << inner_points[i].x << "]";
+          if (i < inner_size - 1) *stream << ",";
+        }
+        *stream << ",[" << inner_points[0].y << "," << inner_points[0].x << "]]";
+      }
+    }
+    *stream << "]}}";
+  }
+};