contrek 1.2.9 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f506a5908c11f7ac1de118b4772ad9e85cd00746e4ee57b5d9c1600faea371e
-  data.tar.gz: 81c2807712361d51398962c9496bf3c833b21eb42d34907069c923cd62654f62
+  metadata.gz: 0fff9996602ac84d2a5d96e840150e59cb457bc8050c53758efac88f170bef79
+  data.tar.gz: 40958fef1d22e2458beae7291cfdca85102eda4983bf01ef468c334ddce99ec8
 SHA512:
-  metadata.gz: 76c41016ce95c124ed72beacd5c838bf5fe960483e3cf7b78848d53c3d997948f5de0c8ecacdb08d3c38b8faf7349ec79cef9546415773e5d5201019b04fe3b2
-  data.tar.gz: 1823196730b740221b2e75be9915706b5b96afd91349dd898eda70d1ccce69f569270e134663137523ea3860e5d49a419b59a083a6a11be027bf4e14a1a0e30b
+  metadata.gz: 7f8f1f1368c472fb9770a892874f54817a67745929a0d772c5a9cc3e387fcd868e5662ad67e341d6a53232b6be4eb028438545535adfb05be3d69c497c3918da
+  data.tar.gz: cc7991d57ce63d43c98165c1f3684d1f31d05993a6e4a20e40437d70d5b251a1de0032ca354f44d2bb8efbf30286423f6b2925e01da0f039c71661427f4d2716

data/CHANGELOG.md

@@ -122,3 +122,10 @@ 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.

data/Gemfile.lock

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

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

@@ -60,16 +60,16 @@ void Tests::test_a()
   std::vector<int> array_compare;
 
   for (const auto& x : o->polygons)
-  { for (const Point* p : x.outer) {
-      array_compare.push_back(p->x);
-      array_compare.push_back(p->y);
+  { for (const Point& p : x.outer) {
+      array_compare.push_back(p.x);
+      array_compare.push_back(p.y);
     }
     if (outer_array != array_compare) throw std::runtime_error("Wrong OUTER results!");
     array_compare.clear();
     for (const auto& z : x.inner)
-    { for (const Point* y : z)
-      { array_compare.push_back(y->x);
-        array_compare.push_back(y->y);
+    { for (const Point& y : z)
+      { array_compare.push_back(y.x);
+        array_compare.push_back(y.y);
       }
     }
     if (inner_array != array_compare) throw std::runtime_error("Wrong INNER results!");
@@ -97,9 +97,9 @@ void Tests::test_b()
 
 void Tests::test_c()
 { Sequence sequence;
-  Point* p1 = new Point({1, 1});
-  Point* p2 = new Point({2, 2});
-  Point* p3 = new Point({3, 3});
+  Point p1{1, 1};
+  Point p2{2, 2};
+  Point p3{3, 3};
 
   Hub* hub = new Hub(4);
 
@@ -114,7 +114,7 @@ void Tests::test_c()
   if (sequence.size != 3) throw std::runtime_error("Wrong sequence size");
 
   // iterator() initially gives head
-  Point* head = sequence.head->payload;
+  const Point& head = sequence.head->payload;
   if (head != p1) throw std::runtime_error("Wrong head");
   if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
   if (sequence.iterator() != pos1) throw std::runtime_error("Wrong iterator to head");
@@ -135,10 +135,6 @@ void Tests::test_c()
   sequence.rewind();
   if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
 
-  delete p1;
-  delete p2;
-  delete p3;
-
   delete hub;
 
   delete pos1;
@@ -348,10 +344,8 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
       ProcessResult *result = polygon_finder.process_info();
       if (result) {
         std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-        ProcessResult* safe_result = result->clone();
-        result_clones.push_back(safe_result);
-        vmerger.add_tile(*safe_result);
-        delete result;
+        result_clones.push_back(result);
+        vmerger.add_tile(*result);
       }
       stripe_count++;
     }
@@ -467,22 +461,14 @@ 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;
-          ProcessResult* safe_result = result->clone();
-          result_clones.push_back(safe_result);
-          vmerger.add_tile(*safe_result, !(current_y_offset + stripe_height < total_height));
+          vmerger.add_tile(*result, !(current_y_offset + stripe_height < total_height));
           delete result;
         }
         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();

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

@@ -100,33 +100,31 @@ Node* Node::my_next_outer(Node *last, int versus) {
   return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
-Point* Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
+Point Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
   int enter_to_index;
   if (enter_to->y < this->y) enter_to_index = enter_to->abs_x_index + this->up_indexer;
   else                       enter_to_index = this->down_indexer - enter_to->abs_x_index;
 
   int tg_index = this->tangs_sequence[enter_to_index];
-  Point* point;
   if (tg_index < 0) {
     Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      point = &node_up.end_point;
+      return node_up.end_point;
     } else {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      point = &node_up.start_point;
+      return node_up.start_point;
     }
   } else {
     Node& node_down = cluster->vert_nodes[y + T_DOWN][tg_index];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      point = &node_down.start_point;
+      return node_down.start_point;
     } else {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      point = &node_down.end_point;
+      return node_down.end_point;
     }
   }
-  return point;
 }
 
 Node* Node::get_tangent_node_by_virtual_index(int virtual_index) {

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

@@ -61,6 +61,9 @@ struct Point {
   bool operator==(const Point& other) const {
     return x == other.x && y == other.y;
   }
+  bool operator!=(const Point& other) const {
+    return !(*this == other);
+  }
   Point(int x_, int y_) : x(x_), y(y_) {}
   Point() : x(0), y(0) {}
 };
@@ -96,7 +99,7 @@ class Node : public  Listable {
   NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
   SmallVec tangs_sequence;
-  Point* coords_entering_to(Node *enter_to, int mode, int tracking);
+  Point coords_entering_to(Node *enter_to, int mode, int tracking);
   Node* my_next_outer(Node *last, int versus);
   Node* my_next_inner(Node *last, int versus);
   Node* get_tangent_node_by_virtual_index(int vitual_index);

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

@@ -18,7 +18,6 @@
 #include "NodeCluster.h"
 #include "Node.h"
 #include "RectBounds.h"
-#include "PointPool.h"
 #include "../reducers/UniqReducer.h"
 #include "../reducers/LinearReducer.h"
 #include "../reducers/VisvalingamReducer.h"
@@ -44,7 +43,7 @@ NodeCluster::~NodeCluster() {
 void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options options) {
   if (!(options.compress_linear || options.compress_uniq || options.compress_visvalingam)) return;
 
-  auto compress_sequence = [&](std::vector<Point*>& points_vec) {
+  auto compress_sequence = [&](std::vector<Point>& points_vec) {
     if (points_vec.empty()) return;
 
     if (options.compress_uniq) {
@@ -122,9 +121,9 @@ void NodeCluster::plot(int versus) {
         next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
 
       if (next_node != nullptr)
-      { Point* p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
+      { Point p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
+        poly.bounds.expand(p.x, p.y);
         poly.outer.push_back(p);
-        poly.bounds.expand(p->x, p->y);
       }
       if ((this->nodes > 0) && (next_node != nullptr))
       { plot_node(poly.outer, next_node, root_node, versus, poly.bounds);
@@ -137,7 +136,7 @@ void NodeCluster::plot(int versus) {
         int index_inner = 0;
         while (inner_plot->size() > 0)
         { this->plot_sequence.clear();
-          std::vector<Point*> inner_sequence;
+          std::vector<Point> inner_sequence;
           std::list<Node*>::iterator first_i;
           Node *first = nullptr;
 
@@ -243,7 +242,7 @@ std::pair<int, int> NodeCluster::test_in_hole_o(Node* node)
   return {-1, -1};
 }
 
-void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
+void NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
   Node *current_node = node;
   bool strict_bounds = this->options->strict_bounds;
   while (current_node != nullptr) {
@@ -279,8 +278,8 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
         }
       }
     } else if (strict_bounds) {
-        sequence_coords.push_back(this->points_pool.acquire((first_is_max ? last_node->max_x : last_node->min_x), current_node->y));
-        sequence_coords.push_back(this->points_pool.acquire((first_is_max ? next_node->min_x : next_node->max_x), current_node->y));
+        sequence_coords.push_back(Point{(first_is_max ? last_node->max_x : last_node->min_x), current_node->y});
+        sequence_coords.push_back(Point{(first_is_max ? next_node->min_x : next_node->max_x), current_node->y});
       }
 
     if (current_node->track_uncomplete()) {
@@ -293,7 +292,7 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
   }
 }
 
-void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds) {
+void NodeCluster::plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds) {
   Node *current_node = node;
   bool strict_bounds = this->options->strict_bounds;
 
@@ -315,23 +314,23 @@ void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, No
       plot = (n == next_node);
     }
     if (plot) {
-      Point* p = last_node->coords_entering_to(current_node, versus, Node::OUTER);
+      Point p = last_node->coords_entering_to(current_node, versus, Node::OUTER);
+      bounds.expand(p.x, p.y);
       sequence_coords.push_back(p);
-      bounds.expand(p->x, p->y);
       if (current_node != start_node) {
         inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         if (last_node->y == next_node->y) {
-          Point* p1 = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
+          Point p1 = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
+          bounds.expand(p1.x, p1.y);
           sequence_coords.push_back(p1);
-          bounds.expand(p1->x, p1->y);
           inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         }
       }
     } else if (strict_bounds) {
         bool is_down = current_node->y > last_node->y;
         bool is_a = (versus == Node::A);
-        sequence_coords.push_back(this->points_pool.acquire((is_down == is_a ? last_node->min_x : last_node->max_x), current_node->y));
-        sequence_coords.push_back(this->points_pool.acquire((is_down == is_a ? next_node->max_x : next_node->min_x), current_node->y));
+        sequence_coords.push_back(Point{(is_down == is_a ? last_node->min_x : last_node->max_x), current_node->y});
+        sequence_coords.push_back(Point{(is_down == is_a ? next_node->max_x : next_node->min_x), current_node->y});
       }
 
     if (current_node == start_node) {

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

@@ -18,7 +18,6 @@
 #include "Lists.h"
 #include "RectBounds.h"
 #include "Polygon.h"
-#include "PointPool.h"
 
 class Node;
 struct Point;
@@ -26,8 +25,8 @@ struct pf_Options;
 
 class NodeCluster {
  private:
-  void plot_node(std::vector<Point*>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds);
-  void plot_inner_node(std::vector<Point*>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
+  void plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds);
+  void plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
   std::vector<Node*> plot_sequence;
   List *inner_plot;
   List *inner_new;
@@ -35,7 +34,6 @@ class NodeCluster {
   int count = 0;
   int nodes;
   int width;
-  PointPool points_pool;
 
  public:
   pf_Options *options;

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

@@ -14,8 +14,8 @@
 #include "RectBounds.h"
 
 struct Polygon {
-  std::vector<Point*> outer;
-  std::list<std::vector<Point*>> inner;
+  std::vector<Point> outer;
+  std::list<std::vector<Point>> inner;
   RectBounds bounds;
   Polygon() : bounds(RectBounds::empty()) {}
 };

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

@@ -108,6 +108,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->width = this->source_bitmap->w();
   pr->height = this->source_bitmap->h();
   pr->has_bounds = this->node_cluster->options->bounds;
+  pr->versus = this->options.versus;
 
   if (this->node_cluster->options->named_sequences && typeid(*this->source_bitmap) == typeid(Bitmap))
   { std::string sequence;
@@ -133,25 +134,25 @@ void ProcessResult::draw_on_bitmap(RawBitmap& bitmap) const {
     // --- OUTER ---
     if (!poly.outer.empty()) {
       for (size_t i = 0; i < poly.outer.size() - 1; ++i) {
-        Point* p1 = poly.outer[i];
-        Point* p2 = poly.outer[i+1];
-        bitmap.draw_line(p1->x, p1->y, p2->x, p2->y, 255, 0, 0, 255);
+        const Point& p1 = poly.outer[i];
+        const Point& p2 = poly.outer[i+1];
+        bitmap.draw_line(p1.x, p1.y, p2.x, p2.y, 255, 0, 0, 255);
       }
-      Point* last = poly.outer.back();
-      Point* first = poly.outer.front();
-      bitmap.draw_line(last->x, last->y, first->x, first->y, 255, 0, 0, 255);
+      const Point& last = poly.outer.back();
+      const Point& first = poly.outer.front();
+      bitmap.draw_line(last.x, last.y, first.x, first.y, 255, 0, 0, 255);
     }
     // --- INNER ---
     for (const auto& sequence : poly.inner) {
       if (sequence.empty()) continue;
       for (size_t i = 0; i < sequence.size() - 1; ++i) {
-        Point* p1 = sequence[i];
-        Point* p2 = sequence[i+1];
-        bitmap.draw_line(p1->x, p1->y, p2->x, p2->y, 0, 128, 0, 255);
+        const Point& p1 = sequence[i];
+        const Point& p2 = sequence[i+1];
+        bitmap.draw_line(p1.x, p1.y, p2.x, p2.y, 0, 128, 0, 255);
       }
-      Point* last = sequence.back();
-      Point* first = sequence.front();
-      bitmap.draw_line(last->x, last->y, first->x, first->y, 0, 128, 0, 255);
+      const Point& last = sequence.back();
+      const Point& first = sequence.front();
+      bitmap.draw_line(last.x, last.y, first.x, first.y, 0, 128, 0, 255);
     }
   }
 }

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

@@ -61,12 +61,12 @@ struct pf_Options {
 struct ProcessResult {
   int groups;
   int width, height;
+  int versus;
   bool has_bounds = false;
   std::map<std::string, double> benchmarks;
   std::list<Polygon> polygons;
   std::string named_sequence;
   std::vector<std::pair<int, int>> treemap;
-  std::vector<Point> cloned_points_storage;
 
   void draw_on_bitmap(RawBitmap& canvas) const;
 
@@ -74,12 +74,12 @@ struct ProcessResult {
     int counter = 0;
     for (const auto& polygon : polygons) {
       std::cout << counter << " - " << "outer" << "\n";
-      for (const Point* p : polygon.outer) std::cout << p->toString();
+      for (const Point& p : polygon.outer) std::cout << p.toString();
       bool first = true;
       for (const auto& seq : polygon.inner) {
         if (!first) std::cout << "\n";
         first = false;
-        for (const Point* p : seq) std::cout << p->toString();
+        for (const Point& p : seq) std::cout << p.toString();
       }
       std::cout << "\n" << polygon.bounds.to_string() <<"\n";
       counter++;
@@ -95,61 +95,15 @@ struct ProcessResult {
 
   void translate(int x) {
     for (auto& polygon : polygons) {
-      for (Point* p : polygon.outer) p->x += x;
-      for (const auto& seq : polygon.inner) {
-        for (Point* p : seq) p->x += x;
+      for (Point& p : polygon.outer) p.x += x;
+      for (auto& seq : polygon.inner) {
+        for (Point& p : seq) p.x += x;
       }
       polygon.bounds.min_x += x;
       polygon.bounds.max_x += x;
     }
   }
 
-  ProcessResult* clone() const {
-    ProcessResult* new_res = new ProcessResult();
-    new_res->groups = this->groups;
-    new_res->width = this->width;
-    new_res->height = this->height;
-    new_res->benchmarks = this->benchmarks;
-    new_res->named_sequence = this->named_sequence;
-    new_res->treemap = this->treemap;
-
-    size_t estimated_points = 0;
-    for (const auto& poly : this->polygons) {
-      estimated_points += poly.outer.size();
-      for (const auto& seq : poly.inner) estimated_points += seq.size();
-    }
-    new_res->cloned_points_storage.reserve(estimated_points);
-
-    for (const auto& poly : this->polygons) {
-      Polygon new_poly;
-      new_poly.bounds = poly.bounds;
-      new_poly.outer.reserve(poly.outer.size());
-      // outer
-      for (const Point* p : poly.outer) {
-        if (p) {
-          new_res->cloned_points_storage.push_back(Point(p->x, p->y));
-          size_t idx = new_res->cloned_points_storage.size() - 1;
-          new_poly.outer.push_back(&new_res->cloned_points_storage[idx]);
-        }
-      }
-      // inner
-      for (const auto& seq : poly.inner) {
-        std::vector<Point*> new_seq;
-        new_seq.reserve(seq.size());
-        for (const Point* p : seq) {
-          if (p) {
-            new_res->cloned_points_storage.push_back(Point(p->x, p->y));
-            size_t idx = new_res->cloned_points_storage.size() - 1;
-            new_seq.push_back(&new_res->cloned_points_storage[idx]);
-          }
-        }
-        new_poly.inner.push_back(new_seq);
-      }
-      new_res->polygons.push_back(new_poly);
-    }
-    return new_res;
-  }
-
   void to_svg_stream(std::ostream& os) const {
     os << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
        << "width=\"" << width << "\" height=\"" << height << "\">\n";
@@ -158,11 +112,10 @@ struct ProcessResult {
       if (!poly.outer.empty()) {
         os << "<polygon points=\"";
         bool first = true;
-        for (const Point* p : poly.outer) {
-          if (!p) continue;
+        for (const Point& p : poly.outer) {
           if (!first) os << " ";
           first = false;
-          os << p->x << "," << p->y;
+          os << p.x << "," << p.y;
         }
         os << "\" fill=\"none\" stroke=\"red\" stroke-width=\"1\"/>\n";
       }
@@ -171,11 +124,10 @@ struct ProcessResult {
         if (sequence.empty()) continue;
         os << "<polygon points=\"";
         bool first = true;
-        for (const Point* p : sequence) {
-          if (!p) continue;
+        for (const Point& p : sequence) {
           if (!first) os << " ";
           first = false;
-          os << p->x << "," << p->y;
+          os << p.x << "," << p.y;
         }
         os << "\" fill=\"none\" stroke=\"green\" stroke-width=\"1\"/>\n";
       }

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

@@ -18,7 +18,7 @@
 #include "../../CpuTimer.h"
 
 Cluster::Cluster(Finder *finder, int height, int start_x, int end_x)
-  : finder(finder)
+  : finder_(finder)
 { tiles_.reserve(2);  // only two (left|right)
   this->hub_ = new Hub(height);
 }
@@ -40,16 +40,16 @@ void Cluster::add(Tile* tile) {
   }
 }
 
-void Cluster::list_to_string(std::vector<Point*> list)
+void Cluster::list_to_string(std::vector<Point> list)
 { std::cout << "(" << &list << ") ";
-  for (Point* point : list) {
-    std::cout << point->toString();
+  for (const Point& point : list) {
+    std::cout << point.toString();
   }
   std::cout << std::endl;
 }
 
 Tile* Cluster::merge_tiles() {
-  bool treemap = this->finder->options().treemap;
+  bool treemap = this->finder_->options().treemap;
   double tot_inner = 0;
   double tot_outer = 0;
   CpuTimer timer;
@@ -141,7 +141,7 @@ Tile* Cluster::merge_tiles() {
   };
 
   Tile* tile = new Tile(
-    this->finder, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
+    this->finder_, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
 
   tile->assign_shapes(new_shapes);
   for (Tile* old_tile : tiles_) {

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

@@ -18,7 +18,7 @@
 
 class Cluster {
  private:
-  Finder *finder;
+  Finder *finder_;
   std::vector<Tile*> tiles_;
   Hub *hub_ = nullptr;
   void assign_ancestry(Shape *shape, InnerPolyline* inner_polyline);
@@ -31,7 +31,8 @@ class Cluster {
   Tile* merge_tiles();
   const std::vector<Tile*> tiles() const { return tiles_; }
   Hub* hub() { return hub_; }
-  static void list_to_string(std::vector<Point*> list);
+  static void list_to_string(std::vector<Point> list);
   PartPool parts_pool;
   std::deque<Position> positions_pool;
+  const Finder* finder() const { return finder_; }
 };

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

@@ -29,7 +29,7 @@ Sequence* Cursor::join_outers()
                        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();
 
@@ -61,11 +61,6 @@ 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);
       }
     } else {
@@ -151,11 +146,11 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treema
           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 &&
-              position->payload->y <= bounds.max)) {
+             !(position->payload.y >= bounds.min &&
+              position->payload.y <= bounds.max)) {
             return(false);
           }
-            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->tracked_outer));
+            return(!(polyline->tile->tg_border(position->payload) && position->end_point()->tracked_outer));
           });
         }
         if (retme_sequence->is_not_vertical()) {
@@ -175,7 +170,7 @@ void Cursor::mark_children(std::vector<EndPoint*>& end_points, const Polyline* o
   for (size_t i = 0; i + 1 < end_points.size(); i += 2) {
     const auto& a = end_points[i];
     const auto& b = end_points[i + 1];
-    auto [y_min, y_max] = std::minmax(a->get_point()->y, b->get_point()->y);
+    auto [y_min, y_max] = std::minmax(a->get_point().y, b->get_point().y);
     for (int y = y_min + 1; y < y_max; ++y) {
       EndPoint* end_point = this->cluster.hub()->get(y);
       if (end_point) {
@@ -199,9 +194,9 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
       auto [min_it, max_it] = std::minmax_element(
         points.begin(),
         points.end(),
-        [](Point* a, Point* b) { return a->y < b->y; });
-      bounds.min = std::min(bounds.min, (*min_it)->y);
-      bounds.max = std::max(bounds.max, (*max_it)->y);
+        [](const Point& a, const Point& b) { return a.y < b.y; });
+      bounds.min = std::min(bounds.min, min_it->y);
+      bounds.max = std::max(bounds.max, max_it->y);
     }
     if (act_part->innerable()) {
       all_parts.push_back(act_part);

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

@@ -16,15 +16,15 @@ class Part;
 
 class EndPoint {
  public:
-  EndPoint() : point_(nullptr) {}
+  EndPoint() {}
 
-  void set_point(Point* p) { point_ = p; }
-  Point* get_point() const { return point_; }
+  void set_point(const Point& p) { point_ = p; }
+  const Point& get_point() const { return point_; }
   std::vector<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
   bool tracked_outer = false;
 
  private:
-  Point* point_;
+  Point point_;
   std::vector<Queueable<Point>*> queues_;
 };

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

@@ -56,4 +56,6 @@ class Finder : public Poolable {
   virtual ProcessResult* process_info();
   const pf_Options& options() const { return options_; }
   Queue<Tile*>& tiles() { return tiles_; }
+  virtual bool transpose() const { return false; }
+  int versus;
 };