contrek 1.2.8 → 1.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6702682d1ddd30acbdc45a4344b1d761473afc336b7c07734f169739228f855
-  data.tar.gz: 8fde7e85a08f0e8037b7711b303fefb0d4edcff1f7c9725a767ff09f815445a6
+  metadata.gz: 8f506a5908c11f7ac1de118b4772ad9e85cd00746e4ee57b5d9c1600faea371e
+  data.tar.gz: 81c2807712361d51398962c9496bf3c833b21eb42d34907069c923cd62654f62
 SHA512:
-  metadata.gz: f498831ee81c1ff533ce412b39efdfe9c9dc42ff40679749600a2e2cf833cd8193b1f3ca8bf00e8ff98ae3a3798f9670380274d3cf63e485bad4428200256af4
-  data.tar.gz: 4fd128cf5cd14d929f2baaf9c611708cd9bd8ce01550e267f1d93252f5f23a9012b6f66bb59a4ab4390cb02c38b31a37f3fc6fd56d22478cf046359834a3bf0d
+  metadata.gz: 76c41016ce95c124ed72beacd5c838bf5fe960483e3cf7b78848d53c3d997948f5de0c8ecacdb08d3c38b8faf7349ec79cef9546415773e5d5201019b04fe3b2
+  data.tar.gz: 1823196730b740221b2e75be9915706b5b96afd91349dd898eda70d1ccce69f569270e134663137523ea3860e5d49a419b59a083a6a11be027bf4e14a1a0e30b

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.2.9)
       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"
@@ -385,6 +386,112 @@ 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;
+          ProcessResult* safe_result = result->clone();
+          result_clones.push_back(safe_result);
+          vmerger.add_tile(*safe_result, !(current_y_offset + stripe_height < total_height));
+          delete result;
+        }
+        stripe_count++;
+      }
+
+      ProcessResult *merged_result = vmerger.process_info();
+      std::cout << "total found polygons " << merged_result->groups << std::endl;
+      delete merged_result;
+
+      // frees memory
+      for (auto c : result_clones) {
+        delete c;
+      }
+    } catch (const std::exception& e) {
+      std::cerr << "\n[ERROR] Processing exception: " << e.what() << std::endl;
+      if (shared_stream.is_open()) shared_stream.close();
+    }
+    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/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 ===//

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

@@ -207,330 +207,103 @@ class PolygonFinder {
   std::map<std::string, double> reports;
   void scan();
   CpuTimer cpu_timer;
-/*
+
   template <typename M, typename F>
   void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
     int img_h = this->source_bitmap->h();
     int bpp = this->source_bitmap->get_bytes_per_pixel();
+
     for (int y = 0; y < img_h; y++) {
       const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
       const unsigned char* p = row_ptr + (this->start_x * bpp);
+
       int min_x = 0;
       bool matching = false;
       unsigned char last_red_value = 0;
-      for (int x = this->start_x; x < this->end_x; x++) {
-        unsigned int color = fetch_color(p);
-        unsigned char current_val = p[0];
-        p += bpp;
-        if (specific_matcher->match(color)) {
-          if (!matching) {
-            min_x = x;
-            last_red_value = current_val;
-            matching = true;
-          }
-          if (x == this->end_x - 1) {
-            this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-            matching = false;
-          }
-        } else if (matching) {
-          this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-          matching = false;
-        }
-      }
-    }
-  }*/
 
-template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
+      int x = this->start_x;
 
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // 1. Unico accesso alla RAM per pixel: leggiamo i 4 byte completi
-                unsigned int c0 = fetch_color(p);
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned int c3 = fetch_color(p + 12);
-
-                // 2. Estrazione a costo zero dai registri della CPU (Operazione bitwise, NO RAM)
-                // Se fetch_color ritorna il mascheramento standard, il primo byte si prende con il cast o lo shift
-                unsigned char v0 = static_cast<unsigned char>(c0); 
-                unsigned char v1 = static_cast<unsigned char>(c1);
-                unsigned char v2 = static_cast<unsigned char>(c2);
-                unsigned char v3 = static_cast<unsigned char>(c3);
-
-                p += 16; 
-
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
-
-                // [Resto della logica dei pixel 0, 1, 2, 3 invariata...]
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
-            }
-        }
+      if (bpp == 4) {
+        for (; x <= this->end_x - 4; x += 4) {
+          // read 4 pixels (16 bytes)
+          unsigned int c0 = fetch_color(p);
+          unsigned int c1 = fetch_color(p + 4);
+          unsigned int c2 = fetch_color(p + 8);
+          unsigned int c3 = fetch_color(p + 12);
 
-        // --- CLEANUP SCALARE ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            // Applichiamo la stessa ottimizzazione anche qui
-            unsigned char current_val = static_cast<unsigned char>(color);
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
-            }
-        }
+          // extracts value (used as debugging segment label)
+          unsigned char v0 = static_cast<unsigned char>(c0);
+          unsigned char v1 = static_cast<unsigned char>(c1);
+          unsigned char v2 = static_cast<unsigned char>(c2);
+          unsigned char v3 = static_cast<unsigned char>(c3);
 
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
-        }
-    }
-}
+          p += 16;
 
- /*template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
+          bool m0 = specific_matcher->match(c0);
+          bool m1 = specific_matcher->match(c1);
+          bool m2 = specific_matcher->match(c2);
+          bool m3 = specific_matcher->match(c3);
 
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        // --- IL TUO SWEET SPOT: UNROLLING A 4 VIE RIFINITO ---
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // Leggiamo in sequenza stretta per ottimizzare i register e la cache L1
-                unsigned int c0 = fetch_color(p);
-                unsigned char v0 = p[0];
-                
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned char v1 = p[4];
-                
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned char v2 = p[8];
-                
-                unsigned int c3 = fetch_color(p + 12);
-                unsigned char v3 = p[12];
-
-                p += 16; // Spostato qui: avanza di 4 pixel RGBA precisi
-
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
-
-                // Pixel 0
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 1
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 2
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 3
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
+          if (m0) {
+            if (!matching) {
+              min_x = x; last_red_value = v0; matching = true;
             }
-        }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
+            matching = false;
+          }
 
-        // --- CLEANUP SCALARE PER I RIMANENTI ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            unsigned char current_val = p[0];
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
+          if (m1) {
+            if (!matching) {
+              min_x = x + 1; last_red_value = v1; matching = true;
             }
-        }
-
-        // --- CHIUSURA DI SICUREZZA FINE RIGA ---
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
-        }
-    }
-}*/
-
-
-
-/*
-
-  #include <cstdint>
-
-template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
+            matching = false;
+          }
 
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        // --- LINEA 1: UNROLLING A 4 VIE (SIMD FRIENDLY, NO DEPENDENCY) ---
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // Carichiamo 4 pixel in variabili separate (zero dipendenze tra loro)
-                unsigned int c0 = fetch_color(p);
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned int c3 = fetch_color(p + 12);
-
-                unsigned char v0 = p[0];
-                unsigned char v1 = p[4];
-                unsigned char v2 = p[8];
-                unsigned char v3 = p[12];
-
-                p += 16; // Avanza di 4 pixel (4 * 4 byte)
-
-                // Eseguiamo il match in parallelo. Il compilatore trasforma questo in istruzioni vettoriali
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
-
-                // Pixel 0
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 1
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 2
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 3
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
+          if (m2) {
+            if (!matching) {
+              min_x = x + 2; last_red_value = v2; matching = true;
             }
-        }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
+            matching = false;
+          }
 
-        // --- LINEA 2: SCALAR CLEANUP ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            unsigned char current_val = p[0];
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
+          if (m3) {
+            if (!matching) {
+              min_x = x + 3; last_red_value = v3; matching = true;
             }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
+            matching = false;
+          }
         }
+      }
 
-        // --- CHIUSURA DI SICUREZZA ---
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
+      // remaining pixels (width not a multiple of 4)
+      for (; x < this->end_x; x++) {
+        unsigned int color = fetch_color(p);
+        unsigned char current_val = static_cast<unsigned char>(color);
+        p += bpp;
+        if (specific_matcher->match(color)) {
+          if (!matching) {
+            min_x = x;
+            last_red_value = current_val;
+            matching = true;
+          }
+        } else if (matching) {
+          this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
+          matching = false;
         }
+      }
+
+      if (matching) {
+        this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
+      }
     }
-}*/
+  }
 
  public:
   PolygonFinder(Bitmap *bitmap,

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

@@ -35,7 +35,6 @@ class Finder : public Poolable {
   Matcher *matcher;
   pf_Options options_;
   std::vector<std::string> input_options;
-  Tile* whole_tile = nullptr;
   std::queue<ClippedPolygonFinder*> finders;
   std::mutex finders_mutex;
   std::map<std::string, double> reports;
@@ -45,6 +44,7 @@ class Finder : public Poolable {
   Queue<Tile*> tiles_;
   int maximum_width_;
   int height = 0;
+  Tile* whole_tile = nullptr;
   void process_tiles();
 
  public: