contrek 1.2.8 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6702682d1ddd30acbdc45a4344b1d761473afc336b7c07734f169739228f855
-  data.tar.gz: 8fde7e85a08f0e8037b7711b303fefb0d4edcff1f7c9725a767ff09f815445a6
+  metadata.gz: 58d88411970256b3edc37da05dd9304aaa4593b320e7d73db5966b69d403c4cf
+  data.tar.gz: 6a05687f7ffba4b22eb7ebf02abf2a622931bc3250968fa785fb13720036118e
 SHA512:
-  metadata.gz: f498831ee81c1ff533ce412b39efdfe9c9dc42ff40679749600a2e2cf833cd8193b1f3ca8bf00e8ff98ae3a3798f9670380274d3cf63e485bad4428200256af4
-  data.tar.gz: 4fd128cf5cd14d929f2baaf9c611708cd9bd8ce01550e267f1d93252f5f23a9012b6f66bb59a4ab4390cb02c38b31a37f3fc6fd56d22478cf046359834a3bf0d
+  metadata.gz: 7150e06efce7580fdefd55725db0de52e2805b909e800679a0f99481c3e52333209d1b5ceb750c1fc63a28fa6aaaad7f7662d3baf3ebf377b29cfe4dacf6d19d
+  data.tar.gz: 988e85fd99234df2b3cd0e8bec0d8f68ba0f631111a3fda62e114e185dd1619589223266b5e3db71a2a5c478d2871f862209489df997a13a9da866b84718c609

data/.gitignore

@@ -3,6 +3,7 @@
 .ruby-version
 # rspec failure tracking
 .rspec_status
+/spec/files/performance_history.json
 
 /ext/cpp_polygon_finder/PolygonFinder/build/
 /ext/cpp_polygon_finder/PolygonFinder/contrek
@@ -12,4 +13,4 @@
 /ext/cpp_polygon_finder/cpp_polygon_finder.o
 /ext/cpp_polygon_finder/cpp_polygon_finder.so
 /ext/cpp_polygon_finder/mkmf.log
-/lib/cpp_polygon_finder.so
+/lib/cpp_polygon_finder.so

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  DisabledByDefault: true
+  TargetRubyVersion: 3.1
+  Exclude:
+    - 'bin/**/*'
+    - 'vendor/**/*'
+
+# Attiva l'obbligo del magic comment
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always

data/CHANGELOG.md

@@ -115,4 +115,10 @@ All notable changes to this project will be documented in this file.
 
 ## [1.2.7] - 2026-06-02
 ### Changed
-- **Refactored `bounds` option:** Starting from this release, precalculated bounds for each polygon can now be requested in concurrent mode as well, in addition to single-threaded mode.
+- **Refactored `bounds` option:** Starting from this release, precalculated bounds for each polygon can now be requested in concurrent mode as well, in addition to single-threaded mode.
+
+## [1.2.8] - 2026-06-07
+- **Optimize main pixel scanning loop:** Implemented 4-way loop unrolling to maximize L1 cache hits and eliminate redundant RAM lookups via direct register bit-casting.
+
+## [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.

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec

data/Gemfile.lock

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

data/README.md

@@ -1,5 +1,5 @@
 # Contrek
-Contrek is a Ruby gem powered by a <u>standalone C++17 core library</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 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.
 
 
 ## About Contrek library

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake"
 
 desc "compiles c++ extension"

data/contrek.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "contrek/version"

data/ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt

@@ -11,10 +11,8 @@ if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     list(FILTER CMAKE_CXX_FLAGS EXCLUDE REGEX "-DNDEBUG")
     list(FILTER CMAKE_C_FLAGS EXCLUDE REGEX "-DNDEBUG")
 else()
-    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -march=native -DNDEBUG -Ofast -flto")
-    #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -march=native -fPIC -DNDEBUG")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -march=native -DNDEBUG -Ofast -flto -fopenmp-simd -ftree-vectorize")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -pthread -march=native -DNDEBUG -Ofast -flto -fopenmp-simd -ftree-vectorize")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -march=native -fPIC -DNDEBUG -Ofast -flto -ftree-vectorize")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -pthread -march=native -fPIC -DNDEBUG -Ofast -flto -ftree-vectorize")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread -flto=auto -Wl,--no-as-needed")
     find_library(TCMALLOC_LIB tcmalloc)
     if(TCMALLOC_LIB)

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

@@ -34,6 +34,7 @@
 #include "polygon/finder/concurrent/Finder.h"
 #include "polygon/finder/concurrent/HorizontalMerger.h"
 #include "polygon/finder/concurrent/VerticalMerger.h"
+#include "polygon/finder/concurrent/StreamingMerger.h"
 #include "polygon/finder/concurrent/Sequence.h"
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
@@ -59,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!");
@@ -96,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);
 
@@ -113,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");
@@ -134,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;
@@ -347,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++;
     }
@@ -385,6 +380,110 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
 }
 
 void Tests::test_i() {
-  stream_png_image("../images/graphs_1024x1024.png", 300);
+  stream_png_image("../images/graphs_1024x1024.png", 300, true);
+  std::cout << "Memory usage peak: " << get_peak_rss() << " MB" << std::endl;
+}
+
+void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_height) {
+    std::vector<ProcessResult*> result_clones;
+    std::vector<std::string> varguments = {"--bounds"};
+    // opens image to stream
+    FILE* fp = fopen(filepath.c_str(), "rb");
+    if (!fp) {
+      std::cerr << "Unable open file: " << filepath << std::endl;
+      return;
+    }
+
+    // exams image
+    spng_ctx *ctx = spng_ctx_new(0);
+    spng_set_png_file(ctx, fp);
+    struct spng_ihdr ihdr;
+    if (spng_get_ihdr(ctx, &ihdr)) {
+      fclose(fp);
+      spng_ctx_free(ctx);
+      return;
+    }
+    uint32_t total_width = ihdr.width;
+    uint32_t total_height = ihdr.height;
+
+    // allocates stripe buffer
+    RawBitmap stripe_bitmap;
+    stripe_bitmap.define(total_width, stripe_height, 4, true);
+    RGBNotMatcher not_matcher(-1);
+    if (spng_decode_image(ctx, NULL, 0, SPNG_FMT_RGBA8, SPNG_DECODE_PROGRESSIVE)) {
+      fclose(fp);
+      spng_ctx_free(ctx);
+      return;
+    }
+
+    // allocates streaming svg buffer
+    std::string output_path = "streaming_buffer.svg";
+    std::ofstream shared_stream(output_path, std::ios::out | std::ios::binary);
+    if (!shared_stream) {
+      std::cerr << "Error: Unable creating output streaming file!" << std::endl;
+    }
+
+    StreamingMerger vmerger(0, &varguments, &shared_stream, total_width, total_height);
+    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;
+
+        // copy previous last line to the next new one (each contigue stripe must share one pixel scanline)
+        if (current_y_offset > 0) {
+          unsigned char* last_row_prev = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(stripe_height - 1));
+          unsigned char* first_row_curr = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(0));
+          std::memcpy(first_row_curr, last_row_prev, row_size);
+        }
+        // clears the part of the stripe wont be overwritten by png data
+        if (uncovered_height < stripe_height)
+        { stripe_bitmap.draw_filled_rectangle(0, 1, total_width, stripe_height - 1, 255, 255, 255);
+        }
+        // decoding data directly in the stripe buffer
+        uint32_t lines_to_read = std::min(stripe_height, total_height - current_y_offset);
+        for (uint32_t y = (current_y_offset == 0 ? 0 : 1); y < lines_to_read; y++) {
+          unsigned char* row_ptr = const_cast<unsigned char*>(stripe_bitmap.get_row_ptr(y));
+          int ret = spng_decode_row(ctx, row_ptr, row_size);
+          if (ret != 0 && ret != SPNG_EOI) break;
+        }
+        // stripe contour tracing
+        std::vector<std::string> finder_arguments = {
+          "--versus=a",
+          "--bounds",
+          "--strict_bounds",  // <- this option is strictly needed when working with vertical merger
+          "--compress_uniq",
+          "--compress_linear"
+        };
+
+        PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
+        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));
+        }
+        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();
+    }
+    spng_ctx_free(ctx);
+    fclose(fp);
+}
+
+void Tests::test_l() {
+  stream_progressive_png_image("../images/mixed_shapes_1024x1024.png", 300);
   std::cout << "Memory usage peak: " << get_peak_rss() << " MB" << std::endl;
 }

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

@@ -20,4 +20,5 @@ class Tests {
   virtual void test_g();
   virtual void test_h();
   virtual void test_i();
+  virtual void test_l();
 };

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

@@ -46,7 +46,6 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
   cpu_timer.start();
   scan();
   reports["scan"] = cpu_timer.stop();
-  //std::cout << "scan " << reports["scan"] << std::endl;
   //=====================//
 
   //= BUILD_TANGS_SEQUENCE ===//
@@ -109,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;
@@ -134,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);
     }
   }
 }