contrek 1.3.9 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b6523977828bd1e9398d438e045ed1335826630c472a8d1caff6cf0b09ed94e
-  data.tar.gz: 247332cbd56024ef7e7847294c1ffa32bc59d0a13ef65dc23f5bd6641126b993
+  metadata.gz: eada79f09d6eede09420a2f933496d8839152f741d9c90e7d6b63fc7537bec29
+  data.tar.gz: 5652df8b513dfb26db08a1640cf59e2642a0feba7df2f9ce62eec0fe4e6dc445
 SHA512:
-  metadata.gz: c632b70f8e0130d39a70c7d13e37f0a0fbec38e045a0c681e7327adc9cf62655e9d35897e0b0f0963777297fd04d4be171f1204a4b9b6974c03344d8318910fd
-  data.tar.gz: 8941c3749e72b0d3fbdf90fb5a5516b8e7730c3b71a826e6332a87809333b48d9dd18d2136e3917693d6c0009a035ffce4c904295263a1163fa81e542de2fd7c
+  metadata.gz: 8dc280b616db1de56688ca94f5c1bcef1bf02cb81ff820638ebdf0bed821ba37745799a579a2660da6dc0934afa46a94aae51affdcb3b6fd987710a84f5f85d9
+  data.tar.gz: c815702b9abafa8b5e6de4e1f2e05ab6b03ed91248efe0786807307db6ebff19a7e2c9d002fadf94a12e2c9f41a8c07fe0ca05c01f5a838722090a737c888983

data/CHANGELOG.md

@@ -149,4 +149,10 @@ All notable changes to this project will be documented in this file.
 - Fixed issue found on treemap determination.
 
 ## [1.3.9] - 2026-08-09
-- Removed the curses development dependency along with the old TerminalTracker; actually Bitmaps::Rendering.to_window renders visually better results.
+- Removed the curses development dependency along with the old TerminalTracker; actually Contrek::Bitmaps::PngBitmap.to_window renders visually better results.
+
+## [1.4.0] - 2026-08-13
+- Added deterministic merge mode usefull when you need a byte-for-byte reproducible outputs across different runs (by default, the merge stage is non-deterministic to maximize performance and thread utilization).
+
+## [1.4.1] - 2026-08-23
+- The number_of_threads effective value is now returned inside metadata output struct too.

data/Gemfile.lock

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

data/PERFORMANCE.md

@@ -1,4 +1,4 @@
-# ⚡ Contrek Performance Tuning
+# Contrek Performance Tuning
 
 This document describes optional dependencies and configuration tips to get the best performance out of Contrek on large images.
 
@@ -41,7 +41,7 @@ sudo make install
 sudo ldconfig
 ```
 
-> ⚠️ The `-DZLIB_COMPAT=ON` flag is mandatory. Without it, zlib-ng uses a different ABI and CMake's `find_package(ZLIB)` won't detect it.
+> The `-DZLIB_COMPAT=ON` flag is mandatory. Without it, zlib-ng uses a different ABI and CMake's `find_package(ZLIB)` won't detect it.
 
 **macOS:**
 ```bash
@@ -136,9 +136,45 @@ Consider this depends your system. Probably is better not to saturate all cores
 
 ---
 
-## 4. Combining All Optimizations
+## 4. Transparent Huge Pages (THP) — Kernel Memory Allocation
 
-Install zlib-ng and tcmalloc, then configure:
+When processing high-resolution images, Contrek performs dense dynamic memory allocations. By default, Linux manages memory in standard 4 KiB pages, which creates heavy kernel overhead from frequent page faults and Translation Lookaside Buffer (TLB) misses under multithreaded loads.
+
+Enabling **Transparent Huge Pages (`always`)** forces the Linux kernel to allocate memory in **2 MiB blocks**, reducing page table lookup entries by a factor of 512 and dramatically speeding up memory access.
+
+### Temporary Activation
+
+To enable it immediately for your current Linux session:
+
+```bash
+echo always | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
+```
+
+### Permanent Activation
+To ensure this setting persists across system reboots:
+
+Open /etc/default/grub in an editor:
+
+```bash
+sudo nano /etc/default/grub
+```
+Add transparent_hugepage=always to GRUB_CMDLINE_LINUX_DEFAULT:
+
+```Plaintext
+GRUB_CMDLINE_LINUX_DEFAULT="quiet splash transparent_hugepage=always"
+```
+
+Update GRUB:
+
+```bash
+sudo update-grub
+```
+
+---
+
+## 5. Combining All Optimizations
+
+Install zlib-ng and tcmalloc, enable THP, then configure:
 
 ```ruby
 # Ruby

data/README.md

@@ -166,7 +166,8 @@ Metadata includes timing information (expressed in milliseconds), the number of
   },
   :groups=>2,
   :named_sequence=>"",
-  :treemap=>[]
+  :treemap=>[],
+  :number_of_threads=>0
 }
 ```
 
@@ -376,11 +377,9 @@ The native implementation uses the number of available CPU cores reported by the
 
 ## A note about determinism
 
-The tracing stage itself is deterministic.
+By default, the merge stage is **non-deterministic** to maximize performance and thread utilization.
 
-The merge stage is not.
-
-Each stripe is processed independently and adjacent stripes are merged as soon as they become available. Depending on thread scheduling, the merge order may differ from one execution to another.
+Each stripe is processed independently, and adjacent stripes are merged opportunistically as soon as they become available. Depending on thread scheduling, the merge order may differ between runs.
 
 For example, given three stripes:
 
@@ -400,7 +399,13 @@ while another execution may produce:
 B1 + (B2 + B3)
 ```
 
-Both executions generate equivalent polygons, but the order of intermediate merge operations is differentso the final coordinate sequence is not guaranteed to be byte-for-byte identical across executions.
+Both executions generate equivalent polygons, but the order of intermediate merge operations is different so the final coordinate sequence is not guaranteed to be byte-for-byte identical across executions.
+
+If you require byte-for-byte reproducible outputs across different runs, you can enable the **deterministic merge mode** (setting `deterministic: true`).
+
+In deterministic mode, stripes are merged strictly according to a fixed binary reduction tree based on their order and index.
+
+> **Requirement:** Deterministic mode requires an **even number of stripes/tiles** to process correctly.
 
 ## Native execution
 
@@ -596,7 +601,8 @@ Typical information includes
   benchmarks:{...},
   groups:1,
   treemap:[],
-  options:{...}
+  options:{...},
+  number_of_threads: 4
 }
 ```
 
@@ -713,27 +719,6 @@ Instead, it repeatedly combines smaller topologically consistent pieces into a l
 This strategy makes it possible to process images whose full size would otherwise exceed the available memory.
 
 
-## Merge order
-
-The merge order is intentionally left to the thread scheduler.
-
-For three stripes, both of the following execution orders are valid:
-
-```
-(B1 + B2) + B3
-```
-
-or
-
-```
-B1 + (B2 + B3)
-```
-
-Although the intermediate merge sequence changes, the reconstructed polygons remain geometrically equivalent.
-
-The exact ordering of coordinates may differ because polygon simplification is applied after merging.
-
-
 ## Polygon reconstruction
 
 Internally, polygons crossing a stripe boundary are temporarily divided into smaller pieces.

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

@@ -21,6 +21,11 @@
 
 namespace Contrek {
 
+enum class Versus {
+  A,  // Anticlockwise
+  O   // Clockwise
+};
+
 enum class MatchMode {
   NOT_COLOR,    // Tracks border of what is not target color
   EXACT_COLOR   // Tracks border of what exactly matchs target color
@@ -31,15 +36,22 @@ enum class Connectivity {
   OMNIDIRECTIONAL = 8    // 8 directions
 };
 
+
 struct Config {
   int threads = 4;
   int tiles = 2;
+  Versus versus = Versus::A;
   bool compress_unique = false;
   bool compress_linear = false;
   bool compress_raster = false;
   bool compress_douglas_peucker = false;
   bool compress_visvalingam = false;
+  float compress_visvalingam_tolerance = 0.0f;
   bool treemap = false;
+  bool bounds = false;
+  bool named_sequences = false;
+  bool unsafe_mode = false;
+  bool deterministic = false;
   int32_t target_color = -1;
   MatchMode mode = MatchMode::NOT_COLOR;
   Connectivity connectivity_mode = Connectivity::ORTHOGONAL;
@@ -81,19 +93,33 @@ inline TraceContext trace(const std::string& image_path, const Config& cfg = Con
     ctx.matcher = std::make_unique<RGBMatcher>(color_to_match);
   }
 
+  std::string versus_str = (cfg.versus == Versus::O) ? "o" : "a";
   ctx.internal_args = {
-    {"versus", Identifier{"a"}},
+    {"versus", Identifier{versus_str}},
+    {"number_of_tiles", static_cast<int64_t>(cfg.tiles)},
+    {"treemap", cfg.treemap},
+    {"bounds", cfg.bounds},
+    {"named_sequences", cfg.named_sequences},
+    {"unsafe_mode", cfg.unsafe_mode},
+    {"deterministic", cfg.deterministic}
   };
-  Options compression_opts;
-
-  if (cfg.compress_unique) compression_opts["uniq"] = true;
-  if (cfg.compress_linear) compression_opts["linear"] = true;
-  if (cfg.compress_visvalingam) compression_opts["visvalingam"] = true;
-  if (cfg.compress_unique || cfg.compress_linear || cfg.compress_visvalingam) ctx.internal_args["compression"] = compression_opts;
-  ctx.internal_args["number_of_tiles"] = cfg.tiles;
   if (cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
-    ctx.internal_args["connectivity"] = 8;
+    ctx.internal_args["connectivity"] = static_cast<int64_t>(8);
   }
+  Options compress_opts;
+  if (cfg.compress_unique) compress_opts["uniq"] = true;
+  if (cfg.compress_linear) compress_opts["linear"] = true;
+  if (cfg.compress_raster) compress_opts["raster"] = true;
+  if (cfg.compress_douglas_peucker) compress_opts["douglas_peucker"] = true;
+  if (cfg.compress_visvalingam) compress_opts["visvalingam"] = true;
+  if (cfg.compress_visvalingam_tolerance > 0.0f) {
+    compress_opts["visvalingam_tolerance"] = static_cast<double>(cfg.compress_visvalingam_tolerance);
+  }
+  if (cfg.compress_unique || cfg.compress_linear || cfg.compress_raster ||
+      cfg.compress_douglas_peucker || cfg.compress_visvalingam) {
+    ctx.internal_args["compress"] = compress_opts;
+  }
+
   ctx.finder = std::make_unique<Finder>(cfg.threads, ctx.bitmap.get(), ctx.matcher.get(), ctx.internal_args);
   ctx.result = std::unique_ptr<ProcessResult>(ctx.finder->process_info());
 

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

@@ -28,6 +28,7 @@ void FinderUtils::sanitize_options(pf_Options& options, const Options& incoming_
     options.named_sequences);
   options.bounds = incoming_options.get<bool>("bounds", options.bounds);
   options.unsafe_mode = incoming_options.get<bool>("unsafe_mode", options.unsafe_mode);
+  options.deterministic = incoming_options.get<bool>("deterministic", options.deterministic);
 
   if (const Options* compress = incoming_options.get_options("compress")) {
     options.compress_uniq = compress->get<bool>("uniq", options.compress_uniq);

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

@@ -110,6 +110,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->has_bounds = this->node_cluster->options->bounds;
   pr->versus = this->options.versus;
   pr->options = this->incoming_options_;
+  pr->number_of_threads = 0;
 
   if (this->node_cluster->options->named_sequences && typeid(*this->source_bitmap) == typeid(Bitmap))
   { std::string sequence;

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

@@ -53,6 +53,7 @@ struct pf_Options {
   bool named_sequences = false;
   bool unsafe_mode = false;
   bool bounds = false;
+  bool deterministic = false;
   int connectivity_offset = 0;
   float compress_visvalingam_tolerance = 10.0;
   int number_of_tiles = 1;
@@ -68,6 +69,7 @@ struct ProcessResult {
   int groups;
   int width, height;
   int versus;
+  int number_of_threads;
   bool has_bounds = false;
   std::map<std::string, double> benchmarks;
   std::list<Polygon> polygons;

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

@@ -135,16 +135,17 @@ 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;
+  Tile* first_tile = tiles_.front();
+  Tile* last_tile = tiles_.back();
+  double past_tot_outer = first_tile->benchmarks.outer + last_tile->benchmarks.outer;
+  double past_tot_inner = first_tile->benchmarks.inner + last_tile->benchmarks.inner;
   Benchmarks b{
     tot_outer + past_tot_outer,
     tot_inner + past_tot_inner
   };
 
   Tile* tile = new Tile(
-    this->finder_, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
+    this->finder_, first_tile->start_x(), last_tile->end_x(), first_tile->name() + last_tile->name(), first_tile->index() / 2, b, first_tile->order() + 1);
 
   tile->assign_shapes(new_shapes);
   for (const auto shape : detach_shapes) {

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

@@ -10,6 +10,7 @@
 #include <utility>
 #include <vector>
 #include <string>
+#include <algorithm>
 #include "Finder.h"
 #include "../../bitmaps/Bitmap.h"
 #include "../../matchers/Matcher.h"
@@ -35,6 +36,9 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Op
   if (cw < 1.0) {
     throw std::runtime_error("One pixel tile width minimum!");
   }
+  if (this->options_.deterministic && (this->options_.number_of_tiles % 2 != 0)) {
+    throw std::invalid_argument("Deterministic mode requires an even number of tiles!");
+  }
   int x = 0;
   for (int tile_index = 0; tile_index < this->options_.number_of_tiles; tile_index++)
   { int tile_end_x = static_cast<int>(cw * (tile_index + 1));
@@ -65,14 +69,14 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Op
       }
 
       Tile* tile = new Tile(this, payload.tile_start_x, payload.tile_end_x,
-                            std::to_string(payload.tile_index), Benchmarks {0, 0});
+                            std::to_string(payload.tile_index), payload.tile_index, Benchmarks {0, 0});
       tile->initial_process(finder);
       tiles_.queue_push(tile);
     });
 
     x = tile_end_x - 1;
   }
-  this->process_tiles();
+  this->process_tiles(this->options_.deterministic);
   reports["init"] = cpu_timer.stop();
 }
 
@@ -82,7 +86,7 @@ Finder::Finder(int number_of_threads, const Options& options)
   reports["init"] = 0;
 }
 
-void Finder::process_tiles() {
+void Finder::process_tiles(bool deterministic) {
   std::vector<Tile*> arriving_tiles;
 
   while (true) {
@@ -97,7 +101,14 @@ void Finder::process_tiles() {
       arriving_tiles.begin(),
       arriving_tiles.end(),
       [&](Tile* t) {
-        return (t->start_x() == (tile->end_x() - 1)) || ((t->end_x() - 1) == tile->start_x());
+        bool is_adjacent = (t->start_x() == (tile->end_x() - 1)) ||
+                           ((t->end_x() - 1) == tile->start_x());
+        if (!is_adjacent) return false;
+        if (deterministic && !this->last_couple(tile, t)) {
+          if (tile->order() != t->order()) return false;
+          if (std::min(t->index(), tile->index()) % 2 != 0) return false;
+        }
+        return true;
       });
 
     if (it != arriving_tiles.end()) {
@@ -124,6 +135,13 @@ void Finder::process_tiles() {
   }
 }
 
+bool Finder::last_couple(const Tile* tile_a, const Tile* tile_b) const {
+  bool a_is_first = tile_a->index() < tile_b->index();
+  const Tile* first = a_is_first ? tile_a : tile_b;
+  const Tile* last  = a_is_first ? tile_b : tile_a;
+  return (first->start_x() == 0) && (last->end_x() == this->maximum_width());
+}
+
 Finder::~Finder() {
   if (this->whole_tile) {
     delete this->whole_tile;  // last tile to be deleted (not owned by a cluster)
@@ -148,6 +166,7 @@ ProcessResult* Finder::process_info() {
   pr->has_bounds = this->options_.bounds;
   pr->versus = this->options_.versus;
   pr->options = this->input_options;
+  pr->number_of_threads = this->number_of_threads();
   FakeCluster fake_cluster(pr->polygons, this->options_);
   cpu_timer.start();
   fake_cluster.compress_coords(pr->polygons, this->options_);

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

@@ -40,13 +40,14 @@ class Finder : public Poolable {
   std::mutex finders_mutex;
   std::map<std::string, double> reports;
   CpuTimer cpu_timer;
+  bool last_couple(const Tile* tile_a, const Tile* tile_b) const;
 
  protected:
   Queue<Tile*> tiles_;
   int maximum_width_;
   int height = 0;
   Tile* whole_tile = nullptr;
-  void process_tiles();
+  void process_tiles(bool deterministic = false);
 
  public:
   using Poolable::Poolable;

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

@@ -48,7 +48,7 @@ void Merger::add_tile(ProcessResult& result)
   }
 
   int end_x = this->current_x + result.width;
-  Tile* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), Benchmarks {0, 0});
+  Tile* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), tiles_.size(), Benchmarks {0, 0});
   tile->assign_raw_polygons(result.polygons, result.treemap);
   tiles_.queue_push(tile);
 

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

@@ -38,6 +38,7 @@ class Poolable {
     }
   }
   void wait();
+  int number_of_threads() const { return number_of_threads_; }
 
  private:
   std::vector<std::thread> workers;

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

@@ -20,10 +20,12 @@
 class Shape;
 class Polyline;
 
-Tile::Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b)
+Tile::Tile(Finder *finder, int start_x, int end_x, std::string name, int index, const Benchmarks& b, int order)
 : finder(finder),
   start_x_(start_x),
   end_x_(end_x),
+  index_(index),
+  order_(order),
   name_(name),
   benchmarks(b) {
   this->shapes_pool = new ShapePool();

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

@@ -29,11 +29,13 @@ class Tile {
   Finder *finder;
   int start_x_;
   int end_x_;
+  int index_;
+  int order_;
   std::string name_;
   std::vector<Shape*> shapes_;
 
  public:
-  Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b);
+  Tile(Finder *finder, int start_x, int end_x, std::string name, int index, const Benchmarks& b, int order = 0);
   virtual ~Tile();
   Tile *prev = nullptr;
   Tile *next = nullptr;
@@ -41,6 +43,8 @@ class Tile {
   Cluster *cluster = nullptr;
   int start_x() const { return start_x_; }
   int end_x() const { return end_x_; }
+  int index() const { return index_; }
+  int order() const { return order_; }
   std::string name() const { return name_; }
   const std::vector<Shape*>& shapes() const { return shapes_; }
   std::vector<Shape*>& shapes() { return shapes_; }

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -232,6 +232,7 @@ class To_Ruby<ProcessResult*>
     return_me[Symbol("height")] = pr->height;
     return_me[Symbol("versus")] = Symbol(pr->versus == Node::O ? "o" : "a");
     return_me[Symbol("options")] = options_to_ruby(pr->options);
+    return_me[Symbol("number_of_threads")] = pr->number_of_threads;
 
     Rice::Array out;
     for (Polygon& x : pr->polygons)

data/lib/contrek/finder/concurrent/cluster.rb

@@ -106,6 +106,8 @@ module Contrek
           start_x: @tiles.first.start_x,
           end_x: @tiles.last.end_x,
           benchmarks: {outer: tot_outer + past_tot_outer, inner: tot_inner + past_tot_inner},
+          index: @tiles.first.index / 2,
+          order: @tiles.first.order + 1,
           name: @tiles.first.name + @tiles.last.name
         )
 

data/lib/contrek/finder/concurrent/finder.rb

@@ -39,6 +39,7 @@ module Contrek
           x = 0
           current_versus = options[:versus]
           raise "Define versus!" if current_versus.nil?
+          raise ArgumentError, "Deterministic mode requires an even number of tiles!" if options[:deterministic] && @number_of_tiles.odd?
 
           @number_of_tiles.times do |tile_index|
             tile_end_x = (cw * (tile_index + 1)).to_i
@@ -62,7 +63,7 @@ module Contrek
                 finder: self,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x],
-                name: payload[:tile_index].to_s
+                index: payload[:tile_index]
               )
               tile.initial_process!(finder)
               @tiles << tile
@@ -70,7 +71,7 @@ module Contrek
 
             x = tile_end_x - 1
           end
-          process_tiles!(bitmap, height: bitmap.h)
+          process_tiles!(bitmap, height: bitmap.h, deterministic: @options[:deterministic])
         end.real
       end
 
@@ -94,7 +95,8 @@ module Contrek
           width: @maximum_width,
           height: @height,
           versus: options[:versus],
-          options: options
+          options: options,
+          number_of_threads: @number_of_threads
         }
         metadata[:treemap] = @whole_tile.compute_treemap if options[:treemap]
         Contrek::Finder::Result.new(raw_polygons, metadata)
@@ -106,7 +108,12 @@ module Contrek
 
       private
 
-      def process_tiles!(bitmap, height:)
+      def last_couple?(tile_a, tile_b)
+        ordereds = [tile_a, tile_b].sort_by(&:index)
+        ordereds.first.start_x == 0 && ordereds.last.end_x == maximum_width
+      end
+
+      def process_tiles!(bitmap, height:, deterministic: false)
         arriving_tiles = []
         loop do
           tile = @tiles.pop
@@ -114,7 +121,17 @@ module Contrek
             @whole_tile = tile
             return
           end
-          if (twin_tile = arriving_tiles.find { |b| (b.start_x == (tile.end_x - 1)) || ((b.end_x - 1) == tile.start_x) })
+          twin_tile = arriving_tiles.find do |t|
+            is_adjacent = (t.start_x == (tile.end_x - 1)) || ((t.end_x - 1) == tile.start_x)
+            next false unless is_adjacent
+            if deterministic && !last_couple?(tile, t)
+              next false if tile.order != t.order
+              next false if [t.index, tile.index].min.odd?
+            end
+            true
+          end
+
+          if twin_tile
             cluster = Cluster.new(finder: self, height: height)
             if twin_tile.start_x == (tile.end_x - 1)
               cluster.add(tile)
@@ -126,13 +143,12 @@ module Contrek
             enqueue!(cluster: cluster) do |payload|
               merged_tile = payload[:cluster].merge_tiles!
               @tiles << merged_tile
-              # usefull external access to each merged_tile
-              @block&.call(merged_tile, bitmap)
+              @block&.call(merged_tile, bitmap) # usefull external access to each merged_tile
             end
             arriving_tiles.delete(twin_tile)
-            next
+          else
+            arriving_tiles << tile
           end
-          arriving_tiles << tile
         end
       end
     end

data/lib/contrek/finder/concurrent/merger.rb

@@ -35,7 +35,7 @@ module Contrek
           finder: self,
           start_x: @current_x,
           end_x: end_x,
-          name: @tiles.size.to_s
+          index: @tiles.size
         )
         tile.assign_raw_polygons!(result[:polygons])
 

data/lib/contrek/finder/concurrent/tile.rb

@@ -3,14 +3,16 @@
 module Contrek
   module Concurrent
     class Tile
-      attr_reader :start_x, :end_x, :benchmarks, :shapes, :name
+      attr_reader :start_x, :end_x, :benchmarks, :shapes, :name, :index, :order
       attr_accessor :prev, :next, :circular_next, :cluster
 
-      def initialize(finder:, start_x:, end_x:, name:, benchmarks: {})
+      def initialize(finder:, start_x:, end_x:, index:, name: nil, benchmarks: {}, order: 0)
         @finder = finder
         @start_x = start_x
         @end_x = end_x
-        @name = name
+        @index = index
+        @order = order
+        @name = name || index.to_s
         @prev = nil
         @next = nil
         @benchmarks = {outer: 0, inner: 0}.merge(benchmarks)

data/lib/contrek/finder/polygon_finder.rb

@@ -54,7 +54,8 @@ module Contrek
           height: @source_bitmap.h,
           treemap: (@node_cluster.treemap if @options.has_key?(:treemap)),
           options: @ori_options,
-          versus: @options[:versus]
+          versus: @options[:versus],
+          number_of_threads: 0
         }
         Result.new(@node_cluster.polygons, metadata)
       end

data/lib/contrek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contrek
-  VERSION = "1.3.9"
+  VERSION = "1.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.3.9
+  version: 1.4.1
 platform: ruby
 authors:
 - Emanuele Cesaroni