contrek 1.2.6 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca0c4f7e37692b2d2e5b17556ed67bee4b624511ddf1dc3865ecf910e8f46aeb
-  data.tar.gz: 66b9af71020dc6a86da1abace1d0467807b9212e207b71a7f6337b2257a34192
+  metadata.gz: d6702682d1ddd30acbdc45a4344b1d761473afc336b7c07734f169739228f855
+  data.tar.gz: 8fde7e85a08f0e8037b7711b303fefb0d4edcff1f7c9725a767ff09f815445a6
 SHA512:
-  metadata.gz: 63ba135c86c7849fda12e542af23a2746681f8aade888daa9269438c1601e8184215b3fe5081ee9caabce923e7dfafd8bcc3613fb06cf2ec9997193ff831e5c7
-  data.tar.gz: dd691e542a8722be9532d3c0f206d4b2a2499874f0be52786c99822036d3e0e463ffb6d301bceae44e8f487f434eeff98c9a931cffe27eab3ed5d249daf060e5
+  metadata.gz: f498831ee81c1ff533ce412b39efdfe9c9dc42ff40679749600a2e2cf833cd8193b1f3ca8bf00e8ff98ae3a3798f9670380274d3cf63e485bad4428200256af4
+  data.tar.gz: 4fd128cf5cd14d929f2baaf9c611708cd9bd8ce01550e267f1d93252f5f23a9012b6f66bb59a4ab4390cb02c38b31a37f3fc6fd56d22478cf046359834a3bf0d

data/CHANGELOG.md

@@ -112,3 +112,7 @@ All notable changes to this project will be documented in this file.
 - **Refactored `spng.c` function `rgb8_row_to_rgba8`:** Extended a loop counter to `size_t` (previously limited to `uint32_t`), which was causing segmentation faults when reading massive images (e.g., 81920x81920).
 - **Refactored `RawBitmap.define` function:** Updated area and size calculations to use full 64-bit integers.
 - **Refactored `PolygonFinder.to_svg_stream()` function:** Optimized performance to efficiently handle massive SVG streams of 2 GB and beyond.
+
+## [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.

data/Gemfile.lock

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

data/README.md

@@ -286,6 +286,18 @@ result.points
 For pure Ruby implementations (`{ native: false }`), coordinates are always expressed as points.  
 In this case, both `polygons` and `points` return the same data, represented as hashes with `x` and `y` keys.
 
+For each returned polygon, it is possible to get its bounding box. You just need to request it as an option (`bounds`), for example:
+```ruby
+{named_sequences: true, bounds: true, compress: {uniq: true, linear: true}}
+```
+Each entry will contain the precalculated bounds key:
+```ruby
+[{:bounds=>{:min_x=>3, :max_x=>11, :min_y=>1, :max_y=>3},
+  :outer=>[{:x=>3, :y=>1}, {:x=>3, :y=>3}, {:x=>11, :y=>3}, {:x=>11, :y=>1}],
+  :inner=>[]}]
+```
+
+
 ## Metadata
 
 Metadata associated with the result can be accessed via:

data/ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt

@@ -11,8 +11,10 @@ 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")
+    #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_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/polygon/finder/FinderUtils.cpp

@@ -108,12 +108,13 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
       break;
     }
   }
-  /*std::cout << "-----------" << std::endl;
+  /* std::cout << "-----------" << std::endl;
   std::cout << "versus " << options.versus << std::endl;
+  std::cout << "bounds " << options.bounds << std::endl;
   std::cout << "number_of_tiles " << options.number_of_tiles << std::endl;
   std::cout << "uniq " << options.compress_uniq << std::endl;
   std::cout << "linear " << options.compress_linear << std::endl;
   std::cout << "visvalingam " << options.compress_visvalingam << std::endl;
-  std::cout << options.compress_visvalingam_tolerance << std::endl;
-  std::cout << "-----------" << std::endl;*/
+  std::cout << "visvalingam tolernace " << options.compress_visvalingam_tolerance << std::endl;
+  std::cout << "-----------" << std::endl; */
 }

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

@@ -46,6 +46,7 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
   cpu_timer.start();
   scan();
   reports["scan"] = cpu_timer.stop();
+  //std::cout << "scan " << reports["scan"] << std::endl;
   //=====================//
 
   //= BUILD_TANGS_SEQUENCE ===//
@@ -107,6 +108,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->treemap = this->node_cluster->treemap;
   pr->width = this->source_bitmap->w();
   pr->height = this->source_bitmap->h();
+  pr->has_bounds = this->node_cluster->options->bounds;
 
   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

@@ -20,6 +20,8 @@
 #include <sstream>
 #include <stdexcept>
 #include <limits>
+#include <cstdint>
+
 #include "../bitmaps/Bitmap.h"
 #include "NodeCluster.h"
 #include "Node.h"
@@ -59,6 +61,7 @@ struct pf_Options {
 struct ProcessResult {
   int groups;
   int width, height;
+  bool has_bounds = false;
   std::map<std::string, double> benchmarks;
   std::list<Polygon> polygons;
   std::string named_sequence;
@@ -204,7 +207,7 @@ 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();
@@ -235,7 +238,299 @@ class PolygonFinder {
         }
       }
     }
-  }
+  }*/
+
+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;
+        
+        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;
+                }
+            }
+        }
+
+        // --- 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;
+            }
+        }
+
+        if (matching) {
+            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
+        }
+    }
+}
+
+ /*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;
+        
+        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;
+                }
+            }
+        }
+
+        // --- 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;
+            }
+        }
+
+        // --- 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();
+
+    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;
+                }
+            }
+        }
+
+        // --- 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;
+            }
+        }
+
+        // --- CHIUSURA DI SICUREZZA ---
+        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.cpp

@@ -60,7 +60,7 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
       Tile* tile = new Tile(this, payload.tile_start_x, payload.tile_end_x,
                             std::to_string(payload.tile_index), Benchmarks {0, 0});
       tile->initial_process(finder);
-      tiles.queue_push(tile);
+      tiles_.queue_push(tile);
     });
 
     x = tile_end_x - 1;
@@ -79,7 +79,7 @@ void Finder::process_tiles() {
   std::vector<Tile*> arriving_tiles;
 
   while (true) {
-    Tile* tile = tiles.queue_pop();
+    Tile* tile = tiles_.queue_pop();
 
     if (tile->whole()) {
       this->whole_tile = tile;
@@ -116,7 +116,7 @@ void Finder::process_tiles() {
       arriving_tiles.erase(it);
       enqueue(cluster, [this](Cluster* c) {
         Tile* merged_tile = c->merge_tiles();
-        tiles.queue_push(merged_tile);
+        tiles_.queue_push(merged_tile);
         delete c;
       });
     } else {
@@ -146,6 +146,7 @@ ProcessResult* Finder::process_info() {
   pr->groups = pr->polygons.size();
   pr->width = this->maximum_width_;
   pr->height = this->height;
+  pr->has_bounds = this->options_.bounds;
   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

@@ -42,7 +42,7 @@ class Finder : public Poolable {
   CpuTimer cpu_timer;
 
  protected:
-  Queue<Tile*> tiles;
+  Queue<Tile*> tiles_;
   int maximum_width_;
   int height = 0;
   void process_tiles();
@@ -55,4 +55,5 @@ class Finder : public Poolable {
   int maximum_width() const { return maximum_width_; }
   virtual ProcessResult* process_info();
   const pf_Options& options() const { return options_; }
+  Queue<Tile*>& tiles() { return tiles_; }
 };

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

@@ -21,9 +21,9 @@ void Merger::add_tile(ProcessResult& result)
     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* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), Benchmarks {0, 0});
   tile->assign_raw_polygons(result.polygons, result.treemap);
-  tiles.queue_push(tile);
+  tiles_.queue_push(tile);
 
   this->maximum_width_ = end_x;
   this->current_x = end_x - 1;

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

@@ -95,3 +95,10 @@ std::string Polyline::named() {
     return this->named_;
   }
 }
+
+void Polyline::fill_bounds(RectBounds& target_bounds) const {
+  target_bounds.min_x = this->min_x;
+  target_bounds.max_x = this->max_x;
+  target_bounds.min_y = this->min_y_;
+  target_bounds.max_y = this->max_y_;
+}

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

@@ -52,6 +52,7 @@ class Polyline : public Partitionable {
   InnerPolyline* inside_inner_polyline = nullptr;
   std::string named();
   void set_named(std::string force_named) { this->named_ = force_named; }
+  void fill_bounds(RectBounds& target_bounds) const;
 
  private:
   std::vector<Point*> raw_;

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

@@ -107,10 +107,14 @@ std::string Tile::toString() {
 
 std::list<Polygon> Tile::to_raw_polygons()
 { std::list<Polygon> retme;
+  bool bounds = this->finder->options().bounds;
   for (Shape* s : shapes_)
   { if (s->outer_polyline && !s->outer_polyline->is_empty())
     { Polygon poly;
       poly.outer = s->outer_polyline->raw();
+      if (bounds) {
+        s->outer_polyline->fill_bounds(poly.bounds);
+      }
       if (!s->inner_polylines.empty()) {
         for (auto inner : s->inner_polylines) {
           poly.inner.push_back(inner->raw());

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

@@ -21,7 +21,7 @@ VerticalMerger::VerticalMerger(int number_of_threads, std::vector<std::string> *
 
 void VerticalMerger::add_tile(ProcessResult& result)
 { transpose(result);
-  if (this->tiles.size() > 0) {
+  if (this->tiles_.size() > 0) {
     translate(result, this->current_x);
   }
   adjust(result);

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -172,6 +172,7 @@ class To_Ruby<ProcessResult*>
     }
     RubyResult* rr = new RubyResult();
     Rice::Data_Object<RubyResult> rb_result(rr);
+    bool inject_bounds = pr->has_bounds;
 
     Rice::Hash return_me = Rice::Hash();
     Rice::Hash benchmarks_rb;
@@ -206,12 +207,14 @@ class To_Ruby<ProcessResult*>
       }
       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;
+      if (inject_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);
     }

data/lib/contrek/cpp/cpp_result.rb

@@ -19,8 +19,9 @@ module Contrek
       def points
         raw_list = polygons.to_a
         @to_points ||= raw_list.map do |polygon|
-          {outer: self.class.to_points(polygon[:outer]),
-           inner: polygon[:inner].map { |s| self.class.to_points(s) }}
+          {bounds: (polygon[:bounds] if polygon.key?(:bounds)),
+           outer: self.class.to_points(polygon[:outer]),
+           inner: polygon[:inner].map { |s| self.class.to_points(s) }}.compact
         end
       end
 

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

@@ -54,8 +54,9 @@ module Contrek
       def to_raw_polygons
         @shapes.filter_map do |shape|
           unless shape.outer_polyline.empty?
-            {outer: shape.outer_polyline.raw,
-             inner: shape.inner_polylines.map(&:raw)}
+            {bounds: (shape.outer_polyline.get_bounds if @finder.options[:bounds]),
+             outer: shape.outer_polyline.raw,
+             inner: shape.inner_polylines.map(&:raw)}.compact
           end
         end
       end

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.2.6"
+  VERSION = "1.2.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.2.8
 platform: ruby
 authors:
 - Emanuele Cesaroni
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-31 00:00:00.000000000 Z
+date: 2026-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -301,7 +301,7 @@ metadata:
   homepage_uri: https://github.com/runout77/contrek
   documentation_uri: https://github.com/runout77/contrek#readme
   changelog_uri: https://github.com/runout77/contrek/blob/main/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -317,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.22
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Fast PNG contour tracing and shape detection for Ruby
 test_files: []