contrek 1.2.5 → 1.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32d1d662c0c6c0c1dc6ffcde36090b188e7d3abd39fc5dd7ba0887aa62526b27
-  data.tar.gz: df8b75836abf466043587f22995f12e13c3ed908b60a4fcda97216e803458540
+  metadata.gz: ae46fa52ddce3383ef534142814ed28ddc5cae45042e677c8f445140bee67e82
+  data.tar.gz: 57cbaf53a0d6e8c7d31bdfcef0718c94654ceaf0fd7b2be84325751dc29f6224
 SHA512:
-  metadata.gz: 33c9e4906109bcd7cee694401b3946b0fe2e5800c551bc20a4ea428bdb7cbe7eb456a2e7cadd57327ca93bf65491284e4566b2caaa9e0ea28a5c771c8e50510b
-  data.tar.gz: ede6984f06ebef2b9672e1f1c0569428b25332e9bb14249a8341fdc1e4f11c493a066015a496bd9d19baec57a97bf98d4d99d23262a4a7dac93757c129e8c441
+  metadata.gz: ee922b6b787ac0f91b98a2e7d608c351499ea5405e325a0eb6d23f751a29075b390c08d757824132c7fbef7d64cef9f3af7dbb11709506e84777ff652f9f15fc
+  data.tar.gz: 848102a6980857b1f4d3914e60de04408d0f7a4cc4c950a20b3fa8ef7231e31db029220eb6e3fb71847b6986a09c0d7b1fedae70f8e30e8ef758a3adeabeddcd

data/CHANGELOG.md

@@ -106,3 +106,13 @@ All notable changes to this project will be documented in this file.
 ## [1.2.5] - 2026-05-27
 ### Changed
 - **Refactored `ProcessResult.clone()`:** Switched from fragmented dynamic allocation to a contiguous `std::vector` with explicit `.reserve()`. Eliminates heap fragmentation during high-res streaming.
+
+## [1.2.6] - 2026-05-31
+### Changed
+- **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.4)
+    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/src/Tests.cpp

@@ -8,6 +8,7 @@
  */
 
 #include "Tests.h"
+#include <sys/resource.h>
 #include <string.h>
 #include <iostream>
 #include <list>
@@ -17,7 +18,6 @@
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
-#include <sys/resource.h>
 
 #include "polygon/finder/PolygonFinder.h"
 #include "polygon/finder/concurrent/ClippedPolygonFinder.h"
@@ -279,7 +279,7 @@ double get_peak_rss() {
   This approach allows for processing large PNG files on systems where memory
   would otherwise be insufficient.
 */
-void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
+void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool generate_svg = false, bool generate_png = false) {
     std::vector<ProcessResult*> result_clones;
     std::vector<std::string> varguments = {};
     VerticalMerger vmerger(0, &varguments);
@@ -305,6 +305,7 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
 
     // allocates stripe buffer
     RawBitmap stripe_bitmap;
+    std::cout << total_width << " " << stripe_height << std::endl;
     stripe_bitmap.define(total_width, stripe_height, 4, true);
     RGBNotMatcher not_matcher(-1);
 
@@ -315,6 +316,7 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
     }
 
     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;
@@ -344,12 +346,13 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
       PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
       ProcessResult *result = polygon_finder.process_info();
       if (result) {
-        std::cout << "Founds polygons: " << result->groups << std::endl;
+        std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
         ProcessResult* safe_result = result->clone();
         result_clones.push_back(safe_result);
         vmerger.add_tile(*safe_result);
         delete result;
       }
+      stripe_count++;
     }
 
     std::cout << "Merging polygons ..." << std::endl;
@@ -357,15 +360,20 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
 
     if (merged_result) {
       std::cout << "Founds total polygons: " << merged_result->groups << std::endl;
-      /*RawBitmap full_bitmap;
-      full_bitmap.define(total_width, total_height, 4, true);
-      full_bitmap.fill(255, 255, 255);
-      merged_result->draw_on_bitmap(full_bitmap);
-      std::cout << "Saving whole png ..." << std::endl;
-      if (full_bitmap.save_to_png("whole.png")) {
-        std::cout << "Png saved!" << std::endl;
-      }*/
-      merged_result->save_svg("whole.svg");
+      if (generate_png) {
+        RawBitmap full_bitmap;
+        full_bitmap.define(total_width, total_height, 4, true);
+        full_bitmap.fill(255, 255, 255);
+        merged_result->draw_on_bitmap(full_bitmap);
+        std::cout << "Saving whole png ..." << std::endl;
+        if (full_bitmap.save_to_png("whole.png")) {
+          std::cout << "Png saved!" << std::endl;
+        }
+      }
+      if (generate_svg) {
+        merged_result->save_svg("whole.svg");
+        std::cout << "Svg saved!" << std::endl;
+      }
     }
     delete merged_result;
     // frees memory

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

@@ -56,16 +56,16 @@ void RawBitmap::draw_pixel(int x, int y, unsigned char r, unsigned char g, unsig
   if (bpp > 3) p[3] = a;
 }
 
-uint32_t RawBitmap::define(uint width, uint height, int bytes_per_pixel, bool clear)
-{ this->width = width;
+size_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;
+  size_t dimension = static_cast<size_t>(width) * static_cast<size_t>(height) * static_cast<size_t>(bytes_per_pixel);
   this->image = std::make_unique<unsigned char[]>(dimension);
   if (clear) {
     std::fill(image.get(), image.get() + dimension, 0);
   }
-  return dimension;
+  return static_cast<uint32_t>(dimension);
 }
 
 void RawBitmap::fill(unsigned char r, unsigned char g, unsigned char b, unsigned char a) {

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

@@ -25,7 +25,7 @@ class RawBitmap : public Bitmap {
   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);
+  size_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);
   bool save_to_png(const std::string& filename);
   void fill(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/spng.c

@@ -534,7 +534,7 @@ static void u16_row_to_bigendian(void *row, size_t size)
         write_u16(&px[i], px[i]);
     }
 }
-
+/*
 static void rgb8_row_to_rgba8(const unsigned char *row, unsigned char *out, uint32_t n)
 {
     uint32_t i;
@@ -543,6 +543,22 @@ static void rgb8_row_to_rgba8(const unsigned char *row, unsigned char *out, uint
         memcpy(out + i * 4, row + i * 3, 3);
         out[i*4+3] = 255;
     }
+}*/
+
+/* Fix overflow Gigapixel images */
+static void rgb8_row_to_rgba8(const unsigned char *row, unsigned char *out, uint32_t n)
+{
+    size_t i;
+    for(i=0; i < n; i++)
+    {
+        out[0] = row[0];
+        out[1] = row[1];
+        out[2] = row[2];
+        out[3] = 255;
+
+        out += 4;
+        row += 3;
+    }
 }
 
 static unsigned num_channels(const struct spng_ihdr *ihdr)

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

@@ -107,6 +107,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

@@ -59,6 +59,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;
@@ -147,50 +148,37 @@ struct ProcessResult {
     return new_res;
   }
 
-  std::string to_svg() const {
-    std::vector<std::string> lines;
-    lines.push_back(
-      "<svg xmlns=\"http://www.w3.org/2000/svg\" "
-      "width=\"" + std::to_string(width) +
-      "\" height=\"" + std::to_string(height) + "\">");
+  void to_svg_stream(std::ostream& os) const {
+    os << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
+       << "width=\"" << width << "\" height=\"" << height << "\">\n";
     for (const auto& poly : polygons) {
-      { // outer
-        std::ostringstream pts;
+      // --- OUTER (Red) ---
+      if (!poly.outer.empty()) {
+        os << "<polygon points=\"";
         bool first = true;
         for (const Point* p : poly.outer) {
           if (!p) continue;
-          if (!first)
-              pts << " ";
+          if (!first) os << " ";
           first = false;
-          pts << p->x << "," << p->y;
+          os << p->x << "," << p->y;
         }
-        lines.push_back(
-          "<polygon points=\"" + pts.str() +
-          "\" fill=\"none\" stroke=\"red\" stroke-width=\"1\"/>");
+        os << "\" fill=\"none\" stroke=\"red\" stroke-width=\"1\"/>\n";
       }
-      // inner
+      // --- INNER (Green) ---
       for (const auto& sequence : poly.inner) {
         if (sequence.empty()) continue;
-        std::ostringstream pts;
+        os << "<polygon points=\"";
         bool first = true;
         for (const Point* p : sequence) {
           if (!p) continue;
-          if (!first) pts << " ";
+          if (!first) os << " ";
           first = false;
-          pts << p->x << "," << p->y;
+          os << p->x << "," << p->y;
         }
-        lines.push_back(
-          "<polygon points=\"" + pts.str() +
-          "\" fill=\"none\" stroke=\"green\" stroke-width=\"1\"/>");
+        os << "\" fill=\"none\" stroke=\"green\" stroke-width=\"1\"/>\n";
       }
     }
-    lines.push_back("</svg>");
-    std::ostringstream result;
-    for (size_t i = 0; i < lines.size(); ++i) {
-      result << lines[i];
-      if (i + 1 < lines.size()) result << "\n";
-    }
-    return result.str();
+    os << "</svg>";
   }
 
   void save_svg(const std::string& filename) const {
@@ -198,7 +186,7 @@ struct ProcessResult {
     if (!file.is_open()) {
       throw std::runtime_error("Unable to open SVG file: " + filename);
     }
-    file << to_svg();
+    to_svg_stream(file);
     file.close();
   }
 };

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.5"
+  VERSION = "1.2.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.7
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec