contrek 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b2690fa75c9a6671f9c8ea91522d3adaf8600bfc0739dad4c8eb4a14b80d97e
-  data.tar.gz: 38db9719cc44356ec32d33031e877edda131a970ec0fb5e385f9c31e19699858
+  metadata.gz: 22d05e676f5c4a0f22f02ec2e915257bf1f5da224d468cb0e2f46fc397360242
+  data.tar.gz: '0997b63d2839cc3ba613884eff2e3a565d96502e4606db0bb72d2aee228e514d'
 SHA512:
-  metadata.gz: 4827a05d797400b0245c8225274dc070870e83186d51da4b4f16bb8368359597967012b65cedbff39f808fa9d1eafad5e3012e144f10afb801d564a2ff916dca
-  data.tar.gz: 690435e9531d0c8c47c703e41c4719333b91edbe60232a5183c30e21a2822c06b827498b49afbda4785cff404e3abdaf776f0a0b4aec9c9b58a0a9fbf29c8844
+  metadata.gz: 57bf5e08937ea8fb4cee39e383a8f760e3a36714643c583408af6d02c7fbb84515af8d3089c753319677b8d5223c7a6a07f505c4356e21cd10570abbec358210
+  data.tar.gz: 0ec4babf59251515b05857a459adfd7365b930feaf58b17ca2215ab4b534abe3ac41ae45e7643270ec8acba4c699fbcd311b12eb3ddab6789e5dd1b7275ad220

data/CHANGELOG.md

@@ -58,3 +58,8 @@ All notable changes to this project will be documented in this file.
 ### Changed
 - Fixed an infinite loop bug in multithreading during inner sequence joining in Omnidirectional mode.
 - Optimized C++ and Ruby algorithms for initial spatial tangential sequence determination.
+
+## [1.1.5] - 2026-03-08
+### Changed
+- **RawBitmap Integration (Ruby/C++):** Introduced a native buffer class for direct contour extraction, bypassing PNG encoding to significantly reduce latency and memory overhead.
+- **Tiled Polygon Merger:** Added a spatial merger for `Finder` outputs to stitch polygons from discrete sub-areas (requiring only a 1px overlap). This multi-phase workflow supports coordinate translation and eliminates monolithic buffer requirements, optimizing the peak memory footprint.

data/Gemfile.lock

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

data/README.md

@@ -1,10 +1,10 @@
 # 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. 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</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
 
-Contrek (**con**tour **trek**king) simply scans your png 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.
+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")
@@ -86,6 +86,24 @@ You can also read base64 png images
 png_bitmap = CPPRemotePngBitMap.new("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+P+/HgAFhAJ/wlseKgAAAABJRU5ErkJggg==")
 ```
 
+You can process from a raw stream
+```ruby
+  raw_bitmap = CPPRawBitMap.new
+  # set 20 as width, 30 as height, 4 as bytes per pixel and clears the content (true)
+  raw_bitmap.define(20,30,4,true)
+  # draws a polygon
+  4.upto(5) do |y|
+    5.upto(8) do |x|
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0, 0);
+    end
+  end
+  not_matcher = CPPRGBNotMatcher.new(raw_bitmap.rgb_value_at(0, 0))
+  result = CPPPolygonFinder.new(raw_bitmap, not_matcher, nil,{compress: {uniq: true, linear: true}}).process_info
+  puts result.points.inspect
+  =>
+  [{:outer=>[{:x=>5, :y=>4}, {:x=>5, :y=>5}, {:x=>8, :y=>5}, {:x=>8, :y=>4}], :inner=>[]}]
+```
+
 Multithreaded contour processing is supported. However, on Ruby MRI (the standard Ruby implementation, at least up to 3.x), the Global Interpreter Lock (GIL) prevents more than one thread from executing Ruby code simultaneously. As a consequence, execution remains effectively serialized even on multicore systems, unless the gem is used under JRuby or TruffleRuby (not tested).
 
 ```ruby

data/ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp

@@ -21,7 +21,9 @@ void run_test() {
   // test_suite.test_c();
   // test_suite.test_d();
   // test_suite.test_e();
-  test_suite.test_f();
+  // test_suite.test_f();
+  // test_suite.test_g();
+  // test_suite.test_h();
   std::cout << "compute time =" << cpu_timer.stop() << std::endl;
 }
 

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

@@ -18,6 +18,7 @@
 #include "polygon/finder/concurrent/ClippedPolygonFinder.h"
 #include "polygon/bitmaps/Bitmap.h"
 #include "polygon/bitmaps/FastPngBitmap.h"
+#include "polygon/bitmaps/RawBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "polygon/matchers/Matcher.h"
 #include "polygon/matchers/RGBMatcher.h"
@@ -25,6 +26,7 @@
 #include "polygon/matchers/ValueNotMatcher.h"
 #include "polygon/finder/optionparser.h"
 #include "polygon/finder/concurrent/Finder.h"
+#include "polygon/finder/concurrent/HorizontalMerger.h"
 #include "polygon/finder/concurrent/Sequence.h"
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
@@ -141,7 +143,7 @@ void Tests::test_d()
   FastPngBitmap png_bitmap("../images/sample_10240x10240.png");
   // FastPngBitmap png_bitmap("images/labyrinth.png");
   std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
-  std::cout << "immagine =" << cpu_timer.stop() << std::endl;
+  std::cout << "image reading time =" << cpu_timer.stop() << std::endl;
 
   int color = png_bitmap.value_at(0, 0);
   std::cout << "color =" << color << std::endl;
@@ -169,7 +171,7 @@ void Tests::test_e()
   Finder pl(2, &png_bitmap, &not_matcher, &arguments);
   ProcessResult *o = pl.process_info();
   o->print_info();
-  std::cout << "polygons =" << o->groups << std::endl;
+  std::cout << "polygons = " << o->groups << std::endl;
   delete o;
 }
 
@@ -184,3 +186,70 @@ void Tests::test_f()
   std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
   std::cout << "load_error=" << bitmap.error() << std::endl;
 }
+
+void Tests::test_g()
+{ RawBitmap raw_bitmap;
+  raw_bitmap.define(50, 50, 4);
+
+  // draw a polygon start_x = 5, start_y = 4, end_x = 8, end_y = 5
+  for (int y : {4, 5}) {
+    for (int x = 5; x <= 8; ++x) {
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0);
+    }
+  }
+
+  int color = raw_bitmap.rgb_value_at(0, 0);
+  std::cout << "color = " << color << std::endl;
+  RGBNotMatcher not_matcher(color);
+
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--number_of_tiles=2"};
+  Finder pl(2, &raw_bitmap, &not_matcher, &arguments);
+  ProcessResult *o = pl.process_info();
+  // o->print_info();
+  // o->print_polygons();
+  std::cout << "polygons = " << o->groups << std::endl;
+  delete o;
+}
+
+void Tests::test_h()
+{ std::string left =
+              "0000000000" \
+              "0000000000" \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "0000000000" \
+              "0000000000";
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  ValueNotMatcher matcher(' ');
+  Bitmap b_left(left, 10);
+  PolygonFinder pl_left(&b_left, &matcher, nullptr, &arguments);
+  ProcessResult *left_result = pl_left.process_info();
+
+  std::string right =
+              "0000000000" \
+              "0000000000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "0000000000" \
+              "0000000000";
+  Bitmap b_right(right, 10);
+  PolygonFinder pl_right(&b_right, &matcher, nullptr, &arguments);
+  ProcessResult *right_result = pl_right.process_info();
+
+  std::vector<std::string> merger_arguments = {};
+  HorizontalMerger hmerger(1, &arguments);
+  hmerger.add_tile(*left_result);
+  hmerger.add_tile(*right_result);
+  ProcessResult *merged_result = hmerger.process_info();
+  merged_result->print_polygons();
+
+  delete merged_result;
+  delete left_result;
+  delete right_result;
+}

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

@@ -17,4 +17,6 @@ class Tests {
   virtual void test_d();
   virtual void test_e();
   virtual void test_f();
+  virtual void test_g();
+  virtual void test_h();
 };

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

@@ -20,74 +20,38 @@
 #include "FastPngBitmap.h"
 #include "spng.h"
 
-FastPngBitmap::FastPngBitmap(std::string filename) : Bitmap("", 0) {
-  if (filename.length() > 0)
-  { std::ifstream file(filename, std::ios::binary | std::ios::ate);
-    if (file.is_open())
-    { std::streamsize size = file.tellg();
+FastPngBitmap::FastPngBitmap(std::string filename) : RawBitmap() {
+  if (filename.length() > 0) {
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    if (file.is_open()) {
+      std::streamsize size = file.tellg();
       file.seekg(0, std::ios::beg);
       std::vector<unsigned char> file_buffer(size);
-      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size))
-      { this->png_error = -1;
+      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size)) {
+        this->png_error = -1;
       } else {
         spng_ctx *ctx = spng_ctx_new(0);
         spng_set_png_buffer(ctx, file_buffer.data(), file_buffer.size());
         struct spng_ihdr ihdr;
         spng_get_ihdr(ctx, &ihdr);
-        this->width = ihdr.width;
-        this->height = ihdr.height;
         size_t out_size;
         spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
-        this->image.resize(out_size);
-        madvise(this->image.data(), out_size, MADV_HUGEPAGE);
-        int error = spng_decode_image(ctx, image.data(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
+        this->define(ihdr.width, ihdr.height, 4, false);
+        unsigned char* raw_ptr = this->image.get();
+        madvise(raw_ptr, out_size, MADV_HUGEPAGE);
+        int error = spng_decode_image(ctx, raw_ptr, out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
         spng_ctx_free(ctx);
         this->png_error = error;
       }
     } else {
-      throw std::runtime_error("Unable open file: " + filename);
+      throw std::runtime_error("Unable to open file: " + filename);
     }
   }
 }
 
-bool FastPngBitmap::pixel_match(int x, int y, Matcher *matcher)
-{ int32_t index = ((y * width) + x) * 4;
-  unsigned int color;
-  unsigned char *red = &image[index];
-  std::memcpy(&color, red, 3);
-  if (typeid(*matcher) == typeid(RGBMatcher))  return((reinterpret_cast<RGBMatcher*>(matcher))->match(color));
-  if (typeid(*matcher) == typeid(RGBNotMatcher)) return((reinterpret_cast<RGBNotMatcher*>(matcher))->match(color));
-  return(false);
-}
-
-int FastPngBitmap::w() {
-  return this->width;
-}
-
-int FastPngBitmap::h() {
-  return this->height;
-}
-
 int FastPngBitmap::error() {
   return this->png_error;
 }
-char FastPngBitmap::value_at(int x, int y) {
-  return(0);
-}
-
-// source image format RGBA => returning uint ABGR
-unsigned int FastPngBitmap::rgb_value_at(int x, int y) {
-  uint32_t index = (uint32_t(y) * width + x) * 4;
-  return *reinterpret_cast<const uint32_t*>(&image[index]);
-}
-
-const unsigned char* FastPngBitmap::get_row_ptr(int y) const {
-  return image.data() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
-}
-
-int FastPngBitmap::get_bytes_per_pixel() const {
-  return 4;  // RGBA
-}
 
 void FastPngBitmap::loadFile(std::vector<unsigned char>& buffer, const std::string& filename)  // designed for loading files from hard disk in an std::vector
 { std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

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

@@ -11,29 +11,20 @@
 #include <vector>
 #include <cstddef>
 #include <string>
-#include "Bitmap.h"
+#include "RawBitmap.h"
 
 class RGBMatcher;
 
 static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-class FastPngBitmap : public Bitmap {
+class FastPngBitmap : public RawBitmap {
  public:
   explicit FastPngBitmap(std::string filename);
-  bool pixel_match(int x, int y, Matcher *matcher);
-  int h();
-  int w();
   virtual int error();
-  char value_at(int x, int y);
-  unsigned int rgb_value_at(int x, int y);
-  const unsigned char* get_row_ptr(int y) const;
-  int get_bytes_per_pixel() const;
 
  protected:
   std::vector<unsigned char> buffer;
   std::vector<unsigned char> base64_decode(std::string &encoded_string);
-  std::vector<unsigned char> image;
-  unsigned int width, height;
   int png_error;
   int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true);
 

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

@@ -0,0 +1,64 @@
+/*
+ * RawBitmap.cpp
+ *
+ * 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.
+ */
+
+#include <memory>
+#include "RawBitmap.h"
+
+RawBitmap::RawBitmap() : Bitmap("", 0),
+  width(0),
+  height(0) {
+}
+
+int RawBitmap::w() {
+  return this->width;
+}
+
+int RawBitmap::h() {
+  return this->height;
+}
+
+char RawBitmap::value_at(int x, int y) {
+  return(0);
+}
+
+const unsigned char* RawBitmap::get_row_ptr(int y) const {
+  return image.get() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
+}
+
+int RawBitmap::get_bytes_per_pixel() const {
+  return this->bpp;
+}
+
+// source image format RGBA => returning uint ABGR
+unsigned int RawBitmap::rgb_value_at(int x, int y) {
+  uint32_t index = (static_cast<uint32_t>(y) * width + x) * 4;
+  return *reinterpret_cast<const uint32_t*>(&image[index]);
+}
+
+void RawBitmap::draw_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
+  if (x >= width || y >= height) return;
+  unsigned char* p = &image[(static_cast<size_t>(y) * width + x) * bpp];
+  p[0] = r;
+  if (bpp > 1) p[1] = g;
+  if (bpp > 2) p[2] = b;
+  if (bpp > 3) p[3] = a;
+}
+
+uint32_t RawBitmap::define(uint width, uint height, int bytes_per_pixel, bool clear)
+{ this->width = width;
+  this->height = height;
+  this->bpp = bytes_per_pixel;
+  uint32_t dimension = (static_cast<uint32_t>(width) * static_cast<uint32_t>(height)) * bytes_per_pixel;
+  this->image = std::make_unique<unsigned char[]>(dimension);
+  if (clear) {
+    std::fill(image.get(), image.get() + dimension, 0);
+  }
+  return dimension;
+}
+

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

@@ -0,0 +1,37 @@
+/*
+ * RawBitmap.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 <memory>
+#include <cstddef>
+#include <string>
+#include "Bitmap.h"
+
+class RGBMatcher;
+
+class RawBitmap : public Bitmap {
+ public:
+  explicit RawBitmap();
+  int h();
+  int w();
+  char value_at(int x, int y);
+  unsigned int rgb_value_at(int x, int y);
+  const unsigned char* get_row_ptr(int y) const;
+  int get_bytes_per_pixel() const;
+  uint32_t define(uint width, uint height, int bytes_per_pixel, bool clear = false);
+  void draw_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);
+
+ protected:
+  std::unique_ptr<unsigned char[]> image;
+  unsigned int width, height;
+
+ private:
+  int bpp;
+};

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

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

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

@@ -104,6 +104,8 @@ ProcessResult* PolygonFinder::process_info() {
   pr->polygons = std::move(this->node_cluster->polygons);
   pr->benchmarks = std::move(this->reports);
   pr->treemap = this->node_cluster->treemap;
+  pr->width = this->source_bitmap->w();
+  pr->height = this->source_bitmap->h();
 
   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

@@ -50,6 +50,7 @@ struct pf_Options {
 };
 struct ProcessResult {
   int groups;
+  int width, height;
   std::map<std::string, double> benchmarks;
   std::list<Polygon> polygons;
   std::string named_sequence;
@@ -77,6 +78,17 @@ struct ProcessResult {
     }
     std::cout << std::endl;
   }
+
+  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;
+      }
+      polygon.bounds.min_x += x;
+      polygon.bounds.max_x += x;
+    }
+  }
 };
 
 class PolygonFinder {

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

@@ -27,7 +27,8 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
   bitmap(bitmap),
   matcher(matcher),
   input_options(*options),
-  maximum_width_(bitmap->w())
+  maximum_width_(bitmap->w()),
+  height(bitmap->h())
 { cpu_timer.start();
   if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
 
@@ -67,6 +68,11 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
   reports["init"] = cpu_timer.stop();
 }
 
+Finder::Finder(int number_of_threads, std::vector<std::string> *options)
+: Poolable(number_of_threads), bitmap(nullptr), matcher(nullptr), input_options(*options), maximum_width_(0) {
+  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+  reports["init"] = 0;
+}
 
 void Finder::process_tiles() {
   std::vector<Tile*> arriving_tiles;
@@ -97,7 +103,7 @@ void Finder::process_tiles() {
         end_x = tile->end_x();
       }
 
-      Cluster *cluster = new Cluster(this, this->bitmap->h(), start_x, end_x);
+      Cluster *cluster = new Cluster(this, this->height, start_x, end_x);
 
       if (twin_tile->start_x() == (tile->end_x() - 1)) {
         cluster->add(tile);
@@ -137,6 +143,8 @@ ProcessResult* Finder::process_info() {
   ProcessResult *pr = new ProcessResult();
   pr->polygons = std::move(this->whole_tile->to_raw_polygons());
   pr->groups = pr->polygons.size();
+  pr->width = this->maximum_width_;
+  pr->height = this->height;
   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

@@ -35,19 +35,23 @@ class Finder : public Poolable {
   Matcher *matcher;
   pf_Options options;
   std::vector<std::string> input_options;
-  int maximum_width_;
-  Queue<Tile*> tiles;
   Tile* whole_tile = nullptr;
-  void process_tiles();
   std::queue<ClippedPolygonFinder*> finders;
   std::mutex finders_mutex;
   std::map<std::string, double> reports;
   CpuTimer cpu_timer;
 
+ protected:
+  Queue<Tile*> tiles;
+  int maximum_width_;
+  int height = 0;
+  void process_tiles();
+
  public:
   using Poolable::Poolable;
   Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vector<std::string> *options);
+  Finder(int number_of_threads, std::vector<std::string> *options);
   virtual ~Finder();
   int maximum_width() const { return maximum_width_; }
-  ProcessResult* process_info();
+  virtual ProcessResult* process_info();
 };

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

@@ -0,0 +1,22 @@
+/*
+ * HorizontalMerger.cpp
+ *
+ * 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.
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include "HorizontalMerger.h"
+
+HorizontalMerger::HorizontalMerger(int number_of_threads, std::vector<std::string> *options)
+: Merger(number_of_threads, options) {
+}
+
+void HorizontalMerger::add_tile(ProcessResult& result)
+{ translate(result, this->current_x);
+  Merger::add_tile(result);
+}

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

@@ -0,0 +1,19 @@
+/*
+ * HorizontalMerger.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 <string>
+#include <vector>
+#include "Merger.h"
+
+class HorizontalMerger : public Merger {
+ public:
+  HorizontalMerger(int number_of_threads, std::vector<std::string> *options);
+  void add_tile(ProcessResult& result) override;
+};

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

@@ -0,0 +1,46 @@
+/*
+ * Merger.cpp
+ *
+ * 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.
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include "Merger.h"
+
+Merger::Merger(int number_of_threads, std::vector<std::string> *options)
+: Finder(number_of_threads, options) {
+}
+
+void Merger::add_tile(ProcessResult& result)
+{ if (this->height == 0) {
+    this->height = result.height;
+  }
+  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->assign_raw_polygons(result.polygons);
+  tiles.queue_push(tile);
+
+  this->maximum_width_ = end_x;
+  this->current_x = end_x - 1;
+}
+
+ProcessResult* Merger::process_info() {
+  this->process_tiles();
+  return(Finder::process_info());
+}
+
+void Merger::translate(ProcessResult& result, int offset) {
+  for (auto& polygon : result.polygons) {
+    for (Point* p : polygon.outer) p->x += offset;
+    for (const auto& seq : polygon.inner) {
+      for (Point* p : seq) p->x += offset;
+    }
+    polygon.bounds.min_x += offset;
+    polygon.bounds.max_x += offset;
+  }
+}

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

@@ -0,0 +1,24 @@
+/*
+ * Merger.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 <string>
+#include <vector>
+#include "Finder.h"
+
+class Merger : public Finder {
+ public:
+  Merger(int number_of_threads, std::vector<std::string> *options);
+  virtual void add_tile(ProcessResult& result);
+  ProcessResult* process_info() override;
+
+ protected:
+  void translate(ProcessResult& result, int offset);
+  int current_x = 0;
+};

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

@@ -20,6 +20,7 @@ class Queue {
     std::lock_guard<std::mutex> lock(mutex_);
     queue_.push(value);
     cond_.notify_one();
+    this->size_++;
   }
 
   T queue_pop() {
@@ -27,10 +28,14 @@ class Queue {
     cond_.wait(lock, [this]{ return !queue_.empty(); });
     T value = queue_.front();
     queue_.pop();
+    this->size_--;
     return value;
   }
 
+  int size() { return this->size_; }
+
  private:
+  int size_ = 0;
   std::queue<T> queue_;
   std::mutex mutex_;
   std::condition_variable cond_;

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

@@ -30,7 +30,6 @@ class Tile {
   std::list<Shape*> shapes_;
   std::list<Shape*> boundary_shapes_;
   bool boundary_shapes_initialized_ = false;
-  void assign_raw_polygons(const std::list<Polygon>& raw_polylines);
 
  public:
   Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b);
@@ -52,6 +51,7 @@ class Tile {
   void info();
   bool tg_border(const Point& coord);
   void assign_shapes(std::list<Shape*>& shapes);
+  void assign_raw_polygons(const std::list<Polygon>& raw_polylines);
   std::list<Polygon> to_raw_polygons();
   Benchmarks benchmarks;
 };

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

@@ -0,0 +1,64 @@
+/*
+ * VerticalMerger.cpp
+ *
+ * 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.
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <utility>
+#include "VerticalMerger.h"
+
+VerticalMerger::VerticalMerger(int number_of_threads, std::vector<std::string> *options)
+: Merger(number_of_threads, options) {
+}
+
+void VerticalMerger::add_tile(ProcessResult& result)
+{ transpose(result);
+  if (this->tiles.size() > 0) {
+    translate(result, this->current_x);
+    adjust(result);
+  }
+  Merger::add_tile(result);
+}
+
+ProcessResult* VerticalMerger::process_info() {
+  ProcessResult* result = Merger::process_info();
+  transpose(*result);
+  return(result);
+}
+
+void VerticalMerger::transpose(ProcessResult& result) {
+  std::swap(result.width, result.height);
+
+  for (auto& polygon : result.polygons) {
+    for (Point* p : polygon.outer) {
+      if (p) std::swap(p->x, p->y);
+    }
+    for (auto& sequence : polygon.inner) {
+      for (Point* p : sequence) {
+        if (p) std::swap(p->x, p->y);
+      }
+    }
+    std::swap(polygon.bounds.min_x, polygon.bounds.min_y);
+    std::swap(polygon.bounds.max_x, polygon.bounds.max_y);
+  }
+}
+
+void VerticalMerger::adjust(ProcessResult& result) {
+  for (auto& polygon : result.polygons) {
+    if (!polygon.outer.empty()) {
+      std::rotate(polygon.outer.begin(), polygon.outer.begin() + 1, polygon.outer.end());
+    }
+    for (auto& sequence : polygon.inner) {
+      if (!sequence.empty()) {
+        std::rotate(sequence.begin(), sequence.begin() + 1, sequence.end());
+      }
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+/*
+ * VerticalMerger.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 <string>
+#include <vector>
+#include "Merger.h"
+
+class VerticalMerger : public Merger {
+ public:
+  VerticalMerger(int number_of_threads, std::vector<std::string> *options);
+  void add_tile(ProcessResult& result) override;
+  ProcessResult* process_info() override;
+
+ private:
+  void transpose(ProcessResult& result);
+  void adjust(ProcessResult& result);
+};

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -27,6 +27,8 @@
 #include "PolygonFinder/src/polygon/finder/Polygon.h"
 #include "PolygonFinder/src/polygon/bitmaps/Bitmap.h"
 #include "PolygonFinder/src/polygon/bitmaps/Bitmap.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/RawBitmap.h"
+#include "PolygonFinder/src/polygon/bitmaps/RawBitmap.cpp"
 #include "PolygonFinder/src/polygon/bitmaps/FastPngBitmap.h"
 #include "PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp"
 #include "PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.h"
@@ -81,6 +83,12 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/Sequence.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/PartPool.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/PartPool.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/Merger.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/Merger.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.cpp"
 extern "C" {
   #include "PolygonFinder/src/polygon/bitmaps/spng.h"
 }
@@ -164,6 +172,8 @@ class To_Ruby<ProcessResult*>
     return_me[Symbol("benchmarks")] = benchmarks_rb;
     return_me[Symbol("groups")] = pr->groups;
     return_me[Symbol("named_sequence")] = pr->named_sequence;
+    return_me[Symbol("width")] = pr->width;
+    return_me[Symbol("height")] = pr->height;
 
     Rice::Array out;
     for (Polygon& x : pr->polygons)
@@ -186,6 +196,14 @@ class To_Ruby<ProcessResult*>
         inner_collection.push(sequence_flat);
       }
       poly_hash[Symbol("inner")] = inner_collection;
+      // BOUNDS
+      Rice::Hash bounds_hash = Rice::Hash();
+      bounds_hash[Symbol("min_x")] = x.bounds.min_x;
+      bounds_hash[Symbol("max_x")] = x.bounds.max_x;
+      bounds_hash[Symbol("min_y")] = x.bounds.min_y;
+      bounds_hash[Symbol("max_y")] = x.bounds.max_y;
+      poly_hash[Symbol("bounds")] = bounds_hash;
+
       out.push(poly_hash);
     }
     rr->polygons = out;
@@ -212,6 +230,53 @@ class To_Ruby<ProcessResult*>
   }
 };
 
+// converts back ProcessResult
+ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
+  ProcessResult pr;
+
+  Rice::Hash metadata = rb_result.iv_get("@metadata_storage");
+  pr.width = detail::From_Ruby<int>().convert(metadata[Symbol("width")].value());
+  pr.height = detail::From_Ruby<int>().convert(metadata[Symbol("height")].value());
+
+  Rice::Array rb_polygons = rb_result.iv_get("@polygons_storage");
+  for (size_t i = 0; i < rb_polygons.size(); ++i) {
+    // Cast esplicito a Rice::Hash per evitare il Proxy
+    Rice::Hash rb_poly = (Rice::Hash)rb_polygons[i];
+    Polygon poly;
+    // BOUNDS
+    Rice::Object rb_bounds_obj = rb_poly[Symbol("bounds")];
+    if (!rb_bounds_obj.is_nil()) {
+        Rice::Hash rb_bounds = (Rice::Hash)rb_bounds_obj;
+        poly.bounds.min_x = detail::From_Ruby<int>().convert(rb_bounds[Symbol("min_x")].value());
+        poly.bounds.max_x = detail::From_Ruby<int>().convert(rb_bounds[Symbol("max_x")].value());
+        poly.bounds.min_y = detail::From_Ruby<int>().convert(rb_bounds[Symbol("min_y")].value());
+        poly.bounds.max_y = detail::From_Ruby<int>().convert(rb_bounds[Symbol("max_y")].value());
+    }
+    // OUTER
+    Rice::Array outer_flat = (Rice::Array)rb_poly[Symbol("outer")];
+    for (size_t j = 0; j < outer_flat.size(); j += 2) {
+      int px = detail::From_Ruby<int>().convert(outer_flat[j].value());
+      int py = detail::From_Ruby<int>().convert(outer_flat[j+1].value());
+      poly.outer.push_back(new Point(px, py));
+    }
+    // INNER
+    Rice::Array inner_collection = (Rice::Array)rb_poly[Symbol("inner")];
+    for (size_t j = 0; j < inner_collection.size(); ++j) {
+      Rice::Array sequence_flat = (Rice::Array)inner_collection[j];
+      std::vector<Point*> hole;
+      for (size_t k = 0; k < sequence_flat.size(); k += 2) {
+        int px = detail::From_Ruby<int>().convert(sequence_flat[k].value());
+        int py = detail::From_Ruby<int>().convert(sequence_flat[k+1].value());
+        hole.push_back(new Point(px, py));
+      }
+      poly.inner.push_back(hole);
+    }
+    pr.polygons.push_back(poly);
+  }
+  return pr;
+}
+
+
 }  // namespace Rice::detail
 
 extern "C"
@@ -227,6 +292,15 @@ void Init_cpp_polygon_finder() {
     .define_method("clear", &Bitmap::clear)
     .define_method("print", &Bitmap::print);
 
+  Data_Type<RawBitmap> rb_cRawBitmap =
+    define_class<RawBitmap, Bitmap>("CPPRawBitMap")
+    .define_constructor(Constructor<RawBitmap>())
+    .define_method("rgb_value_at", &RawBitmap::rgb_value_at)
+    .define_method("w", &RawBitmap::w)
+    .define_method("h", &RawBitmap::h)
+    .define_method("define", &RawBitmap::define)
+    .define_method("draw_pixel", &RawBitmap::draw_pixel);
+
   Data_Type<RemoteFastPngBitmap> rb_cRemotePngBitmap =
     define_class<RemoteFastPngBitmap, Bitmap>("CPPRemotePngBitMap")
     .define_constructor(Constructor<RemoteFastPngBitmap, std::string*>(), Arg("url"))
@@ -280,6 +354,23 @@ void Init_cpp_polygon_finder() {
     .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
     .define_method("process_info", &Finder::process_info, Rice::Arg("yield_gvl") = true);
 
+  Data_Type<Merger> rb_cMerger =
+    define_class<Merger, Finder>("CPPMerger")
+    .define_constructor(Constructor<Merger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
+    .define_method("add_tile", [](Merger& self, Object rb_result) {
+      ProcessResult pr = Rice::detail::ruby_result_to_process_result(rb_result);
+      self.add_tile(pr);
+    })
+    .define_method("process_info", &Merger::process_info, Rice::Arg("yield_gvl") = true);
+
+  Data_Type<HorizontalMerger> rb_cHorizontalMerger =
+    define_class<HorizontalMerger, Merger>("CPPHorizontalMerger")
+    .define_constructor(Constructor<HorizontalMerger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Arg("yield_gvl") = true);
+
+    Data_Type<VerticalMerger> rb_cVerticalMerger =
+    define_class<VerticalMerger, Merger>("CPPVerticalMerger")
+    .define_constructor(Constructor<VerticalMerger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Arg("yield_gvl") = true);
+
   Data_Type<RubyResult> rb_cResult =
     define_class_under<RubyResult>(rb_cFinder, "Result")
     .define_constructor(Constructor<RubyResult>())

data/lib/contrek/bitmaps/{custom_bitmap.rb → raw_bitmap.rb}

@@ -1,6 +1,6 @@
 module Contrek
   module Bitmaps
-    class CustomBitmap < PngBitmap
+    class RawBitmap < PngBitmap
       def initialize(w:, h:, color: ChunkyPNG::Color::TRANSPARENT)
         @image = ChunkyPNG::Image.new(w, h, color)
       end

data/lib/contrek/cpp/cpp_concurrent_horizontal_merger.rb

@@ -0,0 +1,9 @@
+module Contrek
+  module Cpp
+    class CPPConcurrentHorizontalMerger < CPPHorizontalMerger
+      def initialize(number_of_threads: 0, options: nil)
+        super(number_of_threads, options)
+      end
+    end
+  end
+end

data/lib/contrek/cpp/cpp_concurrent_merger.rb

@@ -0,0 +1,9 @@
+module Contrek
+  module Cpp
+    class CPPConcurrentMerger < CPPMerger
+      def initialize(number_of_threads: 0, options: nil)
+        super(number_of_threads, options)
+      end
+    end
+  end
+end

data/lib/contrek/cpp/cpp_concurrent_vertical_merger.rb

@@ -0,0 +1,9 @@
+module Contrek
+  module Cpp
+    class CPPConcurrentVerticalMerger < CPPVerticalMerger
+      def initialize(number_of_threads: 0, options: nil)
+        super(number_of_threads, options)
+      end
+    end
+  end
+end

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

@@ -28,6 +28,7 @@ module Contrek
           @options = options
           @clusters = []
           @maximum_width = bitmap.w
+          @height = bitmap.h
           @number_of_tiles = options[:number_of_tiles] || (raise "number_of_tiles params is needed!")
           @number_of_tiles = 1 if @number_of_tiles <= 0
 
@@ -62,11 +63,11 @@ module Contrek
 
             x = tile_end_x - 1
           end
-          process_tiles!(bitmap)
+          process_tiles!(bitmap, height: bitmap.h)
         end.real
       end
 
-      def process_info(bitmap = nil)
+      def process_info
         raw_polygons = @whole_tile.to_raw_polygons
 
         compress_time = Benchmark.measure do
@@ -83,14 +84,16 @@ module Contrek
             outer: (@whole_tile.benchmarks[:outer] * 1000).round(3),
             inner: (@whole_tile.benchmarks[:inner] * 1000).round(3),
             compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
-          }.compact
+          }.compact,
+          width: @maximum_width,
+          height: @height
         }
         Contrek::Finder::Result.new(raw_polygons, metadata)
       end
 
       private
 
-      def process_tiles!(bitmap)
+      def process_tiles!(bitmap, height:)
         arriving_tiles = []
         loop do
           tile = @tiles.pop
@@ -110,7 +113,7 @@ module Contrek
 
             # puts "start = #{start_x} end = #{end_x}"
 
-            cluster = Cluster.new(finder: self, height: bitmap.h, start_x:, end_x:)
+            cluster = Cluster.new(finder: self, height: height, start_x:, end_x:)
             if twin_tile.start_x == (tile.end_x - 1)
               cluster.add(tile)
               cluster.add(twin_tile)

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

@@ -0,0 +1,10 @@
+module Contrek
+  module Concurrent
+    class HorizontalMerger < Merger
+      def add_tile(result)
+        translate(result, @current_x)
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Contrek
+  module Concurrent
+    class Merger < Finder
+      prepend Poolable
+
+      def initialize(options: {})
+        @initialize_time = 0
+        @current_x = 0
+        @tiles = Queue.new
+        @whole_tile = nil
+        @options = options
+      end
+
+      def add_tile(result)
+        @height ||= result.metadata[:height]
+        end_x = @current_x + result.metadata[:width]
+
+        tile = Tile.new(
+          finder: self,
+          start_x: @current_x,
+          end_x: end_x,
+          name: @tiles.size.to_s
+        )
+        tile.assign_raw_polygons!(result[:polygons])
+
+        @tiles << tile
+        @maximum_width = end_x
+        @current_x = end_x - 1
+      end
+
+      def process_info
+        process_tiles!(nil, height: @height)
+        super
+      end
+
+      private
+
+      def translate(result, offset)
+        result.polygons.each do |polygon|
+          polygon[:outer].each { |p| p[:x] += offset }
+          polygon[:inner].each do |sequence|
+            sequence.each { |p| p[:x] += offset }
+          end
+          if polygon.key?(:bounds)
+            polygon[:bounds][:min_x] += offset
+            polygon[:bounds][:max_x] += offset
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -74,8 +74,6 @@ module Contrek
         "#{self.class}[#{@name}]"
       end
 
-      private
-
       def assign_raw_polygons!(raw_polylines)
         @shapes = []
         raw_polylines.each do |raw_polyline|

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

@@ -0,0 +1,44 @@
+module Contrek
+  module Concurrent
+    class VerticalMerger < Merger
+      def add_tile(result)
+        transpose(result)
+        if @tiles.size > 0
+          translate(result, @current_x)
+          adjust(result)
+        end
+        super
+      end
+
+      def process_info
+        transpose(super)
+      end
+
+      private
+
+      def adjust(result)
+        result.polygons.each do |polygon|
+          polygon[:outer].rotate!(1)
+          polygon[:inner].each do |sequence|
+            sequence.rotate!(1)
+          end
+        end
+      end
+
+      def transpose(result)
+        result.metadata_hash[:width], result.metadata_hash[:height] = result.metadata_hash[:height], result.metadata_hash[:width]
+        result.polygons.each do |polygon|
+          polygon[:outer].each { |p| p[:x], p[:y] = p[:y], p[:x] }
+          polygon[:inner].each do |sequence|
+            sequence.each { |p| p[:x], p[:y] = p[:y], p[:x] }
+          end
+          if polygon.key?(:bounds)
+            polygon[:bounds][:min_x], polygon[:bounds][:min_y] = polygon[:bounds][:min_y], polygon[:bounds][:min_x]
+            polygon[:bounds][:max_x], polygon[:bounds][:max_y] = polygon[:bounds][:max_y], polygon[:bounds][:max_x]
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/contrek/finder/polygon_finder.rb

@@ -47,6 +47,8 @@ module Contrek
           groups: @node_cluster.sequences.size,
           groups_names: @node_cluster.root_nodes.map(&:name).join,
           benchmarks: format_benchmarks,
+          width: @source_bitmap.w,
+          height: @source_bitmap.h,
           treemap: (@node_cluster.treemap if @options.has_key?(:treemap))
         }
         Result.new(@node_cluster.polygons, metadata)

data/lib/contrek/reducers/linear_reducer.rb

@@ -5,7 +5,7 @@ module Contrek
         start_p = @points[0]
         end_p = @points[1]
         dir = seq_dir(start_p, end_p)
-        @points[2..].map.with_index do |point, i|
+        @points[2..].each.with_index do |point, i|
           if (act_seq = seq_dir(end_p, point)) == dir
             @points.delete_at(@points.index(end_p))
           else

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end

data/lib/contrek.rb

@@ -3,7 +3,7 @@ require "contrek/bitmaps/painting"
 require "contrek/bitmaps/bitmap"
 require "contrek/bitmaps/chunky_bitmap"
 require "contrek/bitmaps/png_bitmap"
-require "contrek/bitmaps/custom_bitmap"
+require "contrek/bitmaps/raw_bitmap"
 require "contrek/bitmaps/rgb_color"
 require "contrek/bitmaps/rgb_cpp_color"
 require "contrek/finder/bounds"
@@ -32,6 +32,9 @@ require "contrek/finder/concurrent/tile"
 require "contrek/finder/concurrent/polyline"
 require "contrek/finder/concurrent/cluster"
 require "contrek/finder/concurrent/finder"
+require "contrek/finder/concurrent/merger"
+require "contrek/finder/concurrent/horizontal_merger"
+require "contrek/finder/concurrent/vertical_merger"
 require "contrek/finder/concurrent/cursor"
 require "contrek/map/mercator_projection"
 require "contrek/matchers/matcher"
@@ -43,6 +46,9 @@ require "contrek/reducers/uniq_reducer"
 require "contrek/reducers/visvalingam_reducer"
 require "cpp_polygon_finder"
 require "contrek/cpp/cpp_concurrent_finder"
+require "contrek/cpp/cpp_concurrent_merger"
+require "contrek/cpp/cpp_concurrent_horizontal_merger"
+require "contrek/cpp/cpp_concurrent_vertical_merger"
 require "contrek/results/cpp_result"
 
 module Contrek

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.5
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-02-28 00:00:00.000000000 Z
+date: 2026-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -154,6 +154,8 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/Bitmap.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RawBitmap.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RawBitmap.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/spng.c
@@ -184,8 +186,12 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/FakeCluster.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Finder.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Finder.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Hub.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Hub.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Merger.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Merger.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Part.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Part.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/PartPool.cpp
@@ -206,6 +212,8 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Shape.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Tile.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Tile.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/optionparser.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.h
@@ -228,13 +236,16 @@ files:
 - lib/contrek.rb
 - lib/contrek/bitmaps/bitmap.rb
 - lib/contrek/bitmaps/chunky_bitmap.rb
-- lib/contrek/bitmaps/custom_bitmap.rb
 - lib/contrek/bitmaps/painting.rb
 - lib/contrek/bitmaps/png_bitmap.rb
+- lib/contrek/bitmaps/raw_bitmap.rb
 - lib/contrek/bitmaps/rgb_color.rb
 - lib/contrek/bitmaps/rgb_cpp_color.rb
 - lib/contrek/bitmaps/sample_generator.rb
 - lib/contrek/cpp/cpp_concurrent_finder.rb
+- lib/contrek/cpp/cpp_concurrent_horizontal_merger.rb
+- lib/contrek/cpp/cpp_concurrent_merger.rb
+- lib/contrek/cpp/cpp_concurrent_vertical_merger.rb
 - lib/contrek/finder/bounds.rb
 - lib/contrek/finder/concurrent/clipped_polygon_finder.rb
 - lib/contrek/finder/concurrent/cluster.rb
@@ -242,8 +253,10 @@ files:
 - lib/contrek/finder/concurrent/end_point.rb
 - lib/contrek/finder/concurrent/fake_cluster.rb
 - lib/contrek/finder/concurrent/finder.rb
+- lib/contrek/finder/concurrent/horizontal_merger.rb
 - lib/contrek/finder/concurrent/hub.rb
 - lib/contrek/finder/concurrent/listable.rb
+- lib/contrek/finder/concurrent/merger.rb
 - lib/contrek/finder/concurrent/part.rb
 - lib/contrek/finder/concurrent/partitionable.rb
 - lib/contrek/finder/concurrent/polyline.rb
@@ -253,6 +266,7 @@ files:
 - lib/contrek/finder/concurrent/sequence.rb
 - lib/contrek/finder/concurrent/shape.rb
 - lib/contrek/finder/concurrent/tile.rb
+- lib/contrek/finder/concurrent/vertical_merger.rb
 - lib/contrek/finder/list.rb
 - lib/contrek/finder/list_entry.rb
 - lib/contrek/finder/listable.rb