contrek 1.4.1 → 1.4.2

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.cpp

@@ -0,0 +1,69 @@
+/*
+ * AsciiSource.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 "AsciiSource.h"
+#include <cstring>
+#include <stdexcept>
+
+AsciiSource::AsciiSource(Bitmap& bitmap)
+  : bitmap_(bitmap),
+    current_row_(0) {
+}
+
+uint32_t AsciiSource::width() const {
+  return static_cast<uint32_t>(
+    bitmap_.w()
+  );
+}
+
+uint32_t AsciiSource::height() const {
+  return static_cast<uint32_t>(
+    bitmap_.h()
+  );
+}
+
+uint32_t AsciiSource::get_bytes_per_pixel() const {
+  return static_cast<uint32_t>(
+    bitmap_.get_bytes_per_pixel()
+  );
+}
+
+bool AsciiSource::read_next_row(
+  unsigned char* destination,
+  std::size_t row_size
+) {
+  if (current_row_ >= height()) {
+    return false;
+  }
+
+  const unsigned char* row =
+    bitmap_.get_row_ptr(current_row_);
+
+  const std::size_t expected_row_size =
+    static_cast<std::size_t>(width()) *
+    static_cast<std::size_t>(
+      get_bytes_per_pixel()
+    );
+
+  if (expected_row_size != row_size) {
+    throw std::runtime_error(
+      "Invalid row size"
+    );
+  }
+
+  std::memcpy(
+    destination,
+    row,
+    row_size
+  );
+
+  ++current_row_;
+
+  return true;
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.h

@@ -0,0 +1,34 @@
+/*
+ * AsciiSource.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 <cstddef>
+#include <cstdint>
+
+#include "RasterSource.h"
+#include "../Bitmap.h"
+
+class AsciiSource : public RasterSource {
+public:
+  explicit AsciiSource(Bitmap& bitmap);
+
+  uint32_t width() const override;
+  uint32_t height() const override;
+  uint32_t get_bytes_per_pixel() const override;
+
+  bool read_next_row(
+    unsigned char* destination,
+    std::size_t row_size
+  ) override;
+
+private:
+  Bitmap& bitmap_;
+  uint32_t current_row_;
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/PngSource.cpp

@@ -0,0 +1,108 @@
+/*
+ * PngSource.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 "PngSource.h"
+
+#include <stdexcept>
+#include <string>
+
+PngSource::PngSource(const std::string& filepath)
+  : fp_(nullptr),
+    ctx_(nullptr),
+    width_(0),
+    height_(0),
+    current_row_(0) {
+  fp_ = std::fopen(filepath.c_str(),"rb");
+  if (!fp_) {
+    throw std::runtime_error("Unable to open PNG file");
+  }
+
+  ctx_ = spng_ctx_new(0);
+  if (!ctx_) {
+    std::fclose(fp_);
+    fp_ = nullptr;
+    throw std::runtime_error("Unable to create spng context");
+  }
+
+  int ret = spng_set_png_file(ctx_,fp_);
+  if (ret != 0) {
+    spng_ctx_free(ctx_);
+    ctx_ = nullptr;
+    std::fclose(fp_);
+    fp_ = nullptr;
+    throw std::runtime_error(std::string("spng_set_png_file failed: ") + spng_strerror(ret));
+  }
+
+  spng_ihdr ihdr{};
+  ret = spng_get_ihdr(ctx_, &ihdr);
+
+  if (ret != 0) {
+    spng_ctx_free(ctx_);
+    ctx_ = nullptr;
+    std::fclose(fp_);
+    fp_ = nullptr;
+    throw std::runtime_error(std::string("spng_get_ihdr failed: ") + spng_strerror(ret));
+  }
+
+  width_ = static_cast<uint32_t>(ihdr.width);
+  height_ = static_cast<uint32_t>(ihdr.height);
+  ret = spng_decode_image(
+    ctx_,
+    nullptr,
+    0,
+    SPNG_FMT_RGBA8,
+    SPNG_DECODE_PROGRESSIVE
+  );
+
+  if (ret != 0) {
+    spng_ctx_free(ctx_);
+    ctx_ = nullptr;
+    std::fclose(fp_);
+    fp_ = nullptr;
+    throw std::runtime_error(std::string("spng_decode_image failed: ") + spng_strerror(ret));
+  }
+}
+
+PngSource::~PngSource()
+{ if (ctx_) {
+    spng_ctx_free(ctx_);
+  }
+  if (fp_) {
+    std::fclose(fp_);
+  }
+}
+
+uint32_t PngSource::width() const {
+  return width_;
+}
+
+uint32_t PngSource::height() const {
+  return height_;
+}
+
+uint32_t PngSource::get_bytes_per_pixel() const {
+  return 4;
+}
+
+bool PngSource::read_next_row(unsigned char* destination, std::size_t row_size) {
+  if (current_row_ >= height_) {
+    return false;
+  }
+  const std::size_t expected_row_size = static_cast<std::size_t>(width_) * 4;
+  if (row_size != expected_row_size) {
+    throw std::runtime_error("Invalid row size");
+  }
+  const int ret = spng_decode_row(ctx_,destination,row_size);
+
+  if (ret != 0 && ret != SPNG_EOI) {
+    throw std::runtime_error(std::string("spng_decode_row failed: ") + spng_strerror(ret));
+  }
+  ++current_row_;
+  return true;
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/PngSource.h

@@ -0,0 +1,40 @@
+/*
+ * PngSource.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 <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+
+extern "C" {
+#include "../spng.h"
+}
+
+#include "RasterSource.h"
+
+class PngSource : public RasterSource {
+ public:
+  explicit PngSource(const std::string& filepath);
+  ~PngSource() override;
+
+  uint32_t width() const override;
+  uint32_t height() const override;
+  uint32_t get_bytes_per_pixel() const override;
+  bool read_next_row(unsigned char* destination, std::size_t row_size) override;
+
+ private:
+  FILE* fp_;
+  spng_ctx* ctx_;
+
+  uint32_t width_;
+  uint32_t height_;
+  uint32_t current_row_;
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/RasterSource.h

@@ -0,0 +1,22 @@
+/*
+ * RasterSource.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.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+class RasterSource {
+ public:
+  virtual ~RasterSource() = default;
+  virtual uint32_t width() const = 0;
+  virtual uint32_t height() const = 0;
+  virtual uint32_t get_bytes_per_pixel() const = 0;
+  virtual bool read_next_row(unsigned char* destination, std::size_t row_size) = 0;
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/streaming/RasterStreamer.h

@@ -0,0 +1,92 @@
+/*
+ * RasterStreamer.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 <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include "RasterSource.h"
+#include "../RawBitmap.h"
+
+class RasterStreamer {
+ public:
+  static constexpr uint32_t OVERLAP = 1;
+
+  RasterStreamer(RasterSource& source, uint32_t stripe_height)
+    : source_(source),
+      stripe_height_(stripe_height) {
+    if (stripe_height_ <= OVERLAP) {
+      throw std::invalid_argument("stripe_height must be greater than 1");
+    }
+  }
+  uint32_t stripe_height() const { return stripe_height_; }
+
+  template <typename Callback>
+  void each(Bitmap& buffer, Callback&& callback)
+  { const uint32_t width = source_.width();
+    const uint32_t height = source_.height();
+    const uint32_t bytes_per_pixel = source_.get_bytes_per_pixel();
+    const std::size_t row_size = static_cast<std::size_t>(width) * static_cast<std::size_t>(bytes_per_pixel);
+    uint32_t source_row = 0;
+    uint32_t previous_buffer_rows = 0;
+    bool first_stripe = true;
+
+    while (source_row < height) {
+      std::vector<unsigned char> overlap_row;
+      if (!first_stripe) {
+        overlap_row.resize(row_size);
+        const unsigned char* previous_last_row = buffer.get_row_ptr(previous_buffer_rows - 1);
+        std::memcpy(overlap_row.data(), previous_last_row, row_size);
+      }
+
+      const uint32_t overlap_rows = first_stripe ? 0 : OVERLAP;
+      const uint32_t available_rows = stripe_height_ - overlap_rows;
+      const uint32_t remaining_rows = height - source_row;
+      const uint32_t rows_to_read = std::min(available_rows, remaining_rows);
+      const uint32_t buffer_rows = overlap_rows + rows_to_read;
+
+      if (!first_stripe) {
+        unsigned char* first_row = const_cast<unsigned char*>(buffer.get_row_ptr(0));
+        std::memcpy(first_row, overlap_row.data(), row_size);
+      }
+      uint32_t rows_read = 0;
+      for (uint32_t i = 0; i < rows_to_read; ++i) {
+        const uint32_t buffer_y = overlap_rows + i;
+        unsigned char* destination = const_cast<unsigned char*>(buffer.get_row_ptr(buffer_y));
+        if (!source_.read_next_row(destination, row_size)) {
+          break;
+        }
+        ++source_row;
+        ++rows_read;
+      }
+      if (rows_read == 0) {
+        break;
+      }
+      const uint32_t actual_buffer_rows = overlap_rows + rows_read;
+      if (actual_buffer_rows != buffer_rows) {
+        throw std::runtime_error("Raster source ended before expected image height!");
+      }
+      const std::size_t buffer_size = static_cast<std::size_t>(buffer_rows) * row_size;
+
+      std::forward<Callback>(callback)(buffer, buffer_rows, buffer_size);
+      previous_buffer_rows = buffer_rows;
+      first_stripe = false;
+    }
+  }
+
+ private:
+  RasterSource& source_;
+  uint32_t stripe_height_;
+};

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

@@ -17,18 +17,17 @@ void FinderUtils::sanitize_options(pf_Options& options, const Options& incoming_
   const Identifier versus = incoming_options.get<Identifier>("versus", options.versus == Node::A ? "a" : "o");
   options.versus = versus == "a" ? Node::A : Node::O;
   options.number_of_tiles = std::max(1, static_cast<int>(incoming_options.get<std::int64_t>(
-    "number_of_tiles",
-    options.number_of_tiles)));
+    "number_of_tiles", options.number_of_tiles)));
   options.connectivity_offset = incoming_options.get<std::int64_t>(
-    "connectivity",
-    options.connectivity_offset == 1 ? 8 : 4) == 8;
+    "connectivity", options.connectivity_offset == 1 ? 8 : 4) == 8;
   options.treemap = incoming_options.get<bool>("treemap", options.treemap);
   options.named_sequences = incoming_options.get<bool>(
-    "named_sequences",
-    options.named_sequences);
+    "named_sequences", options.named_sequences);
   options.bounds = incoming_options.get<bool>("bounds", options.bounds);
   options.unsafe_mode = incoming_options.get<bool>("unsafe_mode", options.unsafe_mode);
   options.deterministic = incoming_options.get<bool>("deterministic", options.deterministic);
+  options.processing_height = static_cast<int>(incoming_options.get<std::int64_t>(
+    "processing_height", options.processing_height));
 
   if (const Options* compress = incoming_options.get_options("compress")) {
     options.compress_uniq = compress->get<bool>("uniq", options.compress_uniq);
@@ -39,8 +38,7 @@ void FinderUtils::sanitize_options(pf_Options& options, const Options& incoming_
     if (compress->contains("visvalingam_tolerance")) {
       options.compress_visvalingam = true;
       options.compress_visvalingam_tolerance = static_cast<float>(compress->get<double>(
-        "visvalingam_tolerance",
-        options.compress_visvalingam_tolerance));
+        "visvalingam_tolerance", options.compress_visvalingam_tolerance));
     }
   }
 

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

@@ -11,6 +11,7 @@
 #include <list>
 #include <map>
 #include <ctime>
+#include <cmath>
 #include <typeinfo>
 #include <string>
 #include <vector>
@@ -40,7 +41,11 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
 { this->rgb_matcher = dynamic_cast<RGBMatcher*>(matcher);
   FinderUtils::sanitize_options(this->options, options);
 
-  this->node_cluster = new NodeCluster(source_bitmap->h(), source_bitmap->w(), &this->options);
+  this->processing_height = std::abs(this->options.processing_height == 0 ? source_bitmap->h() : this->options.processing_height);
+  if (this->processing_height > source_bitmap->h()) {
+    throw std::invalid_argument("Option processing_height must be less or equal than image height!");
+  }
+  this->node_cluster = new NodeCluster(this->processing_height, source_bitmap->w(), &this->options);
 
   //= SCAN ==============//
   cpu_timer.start();
@@ -106,7 +111,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->benchmarks = std::move(this->reports);
   pr->treemap = this->node_cluster->treemap;
   pr->width = this->source_bitmap->w();
-  pr->height = this->source_bitmap->h();
+  pr->height = this->processing_height;
   pr->has_bounds = this->node_cluster->options->bounds;
   pr->versus = this->options.versus;
   pr->options = this->incoming_options_;

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

@@ -54,6 +54,7 @@ struct pf_Options {
   bool unsafe_mode = false;
   bool bounds = false;
   bool deterministic = false;
+  int processing_height = 0;
   int connectivity_offset = 0;
   float compress_visvalingam_tolerance = 10.0;
   int number_of_tiles = 1;
@@ -159,6 +160,7 @@ class PolygonFinder {
  protected:
   int start_x;
   int end_x;
+  int processing_height;
   Options incoming_options_;
 
  private:
@@ -173,7 +175,7 @@ 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 img_h = this->processing_height;
     int bpp = this->source_bitmap->get_bytes_per_pixel();
 
     for (int y = 0; y < img_h; y++) {

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

@@ -32,6 +32,9 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Op
 { cpu_timer.start();
   FinderUtils::sanitize_options(this->options_, options);
 
+  if (this->options_.processing_height != 0) {
+    this->height = std::abs(this->options_.processing_height);
+  }
   double cw = static_cast<double>(this->maximum_width_) / this->options_.number_of_tiles;
   if (cw < 1.0) {
     throw std::runtime_error("One pixel tile width minimum!");
@@ -54,6 +57,9 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Op
       if (this->options_.treemap) {
         base_arguments["treemap"] = true;
       }
+      if (this->options_.processing_height != 0) {
+        base_arguments["processing_height"] = this->options_.processing_height;
+      }
 
       CpuTimer t;
       t.start();

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -37,6 +37,12 @@
 #include "PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp"
 #include "PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "PolygonFinder/src/polygon/bitmaps/RemoteFastPngBitmap.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/RasterSource.h"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.h"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/PngSource.h"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/PngSource.cpp"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/RasterStreamer.h"
 #include "PolygonFinder/src/polygon/matchers/Matcher.h"
 #include "PolygonFinder/src/polygon/matchers/Matcher.cpp"
 #include "PolygonFinder/src/polygon/matchers/ValueNotMatcher.h"
@@ -395,6 +401,7 @@ void Init_cpp_polygon_finder() {
     .define_method("value_at", &Bitmap::value_at)
     .define_method("w", &Bitmap::w)
     .define_method("h", &Bitmap::h)
+    .define_method("get_bytes_per_pixel", &Bitmap::get_bytes_per_pixel)
     .define_method("error", &Bitmap::error)
     .define_method("clear", &Bitmap::clear)
     .define_method("print", &Bitmap::print);
@@ -402,6 +409,7 @@ void Init_cpp_polygon_finder() {
   Data_Type<RawBitmap> rb_cRawBitmap =
     define_class<RawBitmap, Bitmap>("CPPRawBitMap")
     .define_constructor(Constructor<RawBitmap>())
+    .define_constructor(Constructor<RawBitmap, uint, uint>())
     .define_method("rgb_value_at", &RawBitmap::rgb_value_at)
     .define_method("w", &RawBitmap::w)
     .define_method("h", &RawBitmap::h)
@@ -430,6 +438,44 @@ void Init_cpp_polygon_finder() {
     .define_method("error", &FastPngBitmap::error)
     .define_method("print", &FastPngBitmap::print);
 
+  Data_Type<RasterSource> rb_cRasterSource =
+    define_class<RasterSource>("CPPRasterSource");
+
+  Data_Type<AsciiSource> rb_cAsciiSource =
+    define_class<AsciiSource, RasterSource>("CPPAsciiSource")
+    .define_constructor(Constructor<AsciiSource, Bitmap&>(),Arg("bitmap"))
+    .define_method("width",&AsciiSource::width)
+    .define_method("height",&AsciiSource::height)
+    .define_method("get_bytes_per_pixel",&AsciiSource::get_bytes_per_pixel);
+
+  Data_Type<PngSource> rb_cPngSource =
+    define_class<PngSource, RasterSource>("CPPPngSource")
+    .define_constructor(Constructor<PngSource, std::string>(),Arg("filepath"))
+    .define_method("width",&PngSource::width)
+    .define_method("height",&PngSource::height)
+    .define_method("get_bytes_per_pixel",&PngSource::get_bytes_per_pixel);
+
+  Data_Type<RasterStreamer> rb_cRasterStreamer =
+    define_class<RasterStreamer>("CPPRasterStreamer")
+    .define_constructor(Constructor<RasterStreamer, RasterSource&, uint32_t>(),Arg("source"),Arg("stripe_height"))
+    .define_method("stripe_height",&RasterStreamer::stripe_height)
+    .define_method("each",[](RasterStreamer& self, Bitmap& buffer) {
+        VALUE block = rb_block_proc();
+        self.each(
+          buffer,
+          [block](Bitmap& bitmap,uint32_t buffer_rows,std::size_t buffer_size) {
+            Rice::Data_Object<Bitmap> rb_bitmap(&bitmap);
+            Rice::Object(block).call(
+              "call",
+              rb_bitmap,
+              buffer_rows,
+              buffer_size
+            );
+          }
+        );
+      }
+    );
+
   Data_Type<Matcher> rb_cMatcher =
     define_class<Matcher>("CPPMatcher")
     .define_constructor(Constructor<Matcher, char>())

data/lib/contrek/bitmaps/bitmap.rb

@@ -5,7 +5,7 @@ module Contrek
     class Bitmap
       include Painting
 
-      def scan(start_x: 0, end_x: w)
+      def scan(start_x: 0, end_x: w, end_y: h)
         x = start_x
         y = 0
         loop do
@@ -14,7 +14,7 @@ module Contrek
           if x == end_x
             x = start_x
             y += 1
-            break if y == h
+            break if y == end_y
           end
         end
       end

data/lib/contrek/bitmaps/chunky_bitmap.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require "ffi"
+
 module Contrek
   module Bitmaps
     class ChunkyBitmap < Bitmap
       def initialize(data, mod)
-        @raw = data.dup
         @module = mod
+        @height = data.bytesize / @module
+        @raw = FFI::MemoryPointer.new(:uint8, data.bytesize)
+        @raw.put_bytes(0, data)
       end
 
       def clear(val = "0")
-        @raw = val * @module * h
+        @raw.put_bytes(0, val * @module * h)
       end
 
       def w
@@ -17,22 +21,30 @@ module Contrek
       end
 
       def h
-        @raw.size / @module
+        @height
+      end
+
+      def get_bytes_per_pixel
+        1
+      end
+
+      def get_row_ptr(y)
+        @raw + (@module * y)
       end
 
       def value_at(x, y)
-        @raw[y * @module + x]
+        @raw.get_uint8(y * @module + x).chr
       end
 
       def value_set(x, y, value)
         return if y >= h
         return if x >= w
 
-        @raw[y * @module + x] = value
+        @raw.put_uint8(y * @module + x, value.ord)
       end
 
       def dup!
-        ChunkyBitmap.new(@raw, @module)
+        ChunkyBitmap.new(@raw.read_bytes(@module * h), @module)
       end
 
       def draw_rect(x:, y:, width:, height:, color: "o", filled: true)
@@ -80,7 +92,7 @@ module Contrek
         puts label if label
         puts "  " + (0...@module).map { |i| (i % 10).to_s }.join
         n = 0
-        @raw.scan(/.{1,#{@module}}/).each do |line|
+        @raw.read_bytes(@module * h).scan(/.{1,#{@module}}/).each do |line|
           colored_line = line.chars.map { |c| colorize_char(c) }.join
           puts "#{n} #{colored_line}"
           n += 1
@@ -96,8 +108,11 @@ module Contrek
             transposed += value_at(x, y)
           end
         end
-        @raw = transposed
+        old_width = w
         @module = h
+        @height = old_width
+        @raw = FFI::MemoryPointer.new(:uint8, transposed.bytesize)
+        @raw.put_bytes(0, transposed)
       end
 
       private

data/lib/contrek/bitmaps/png_bitmap.rb

@@ -20,6 +20,10 @@ module Contrek
         @image.dimension.height
       end
 
+      def get_bytes_per_pixel
+        4
+      end
+
       def draw_line(start_x, start_y, end_x, end_y, value)
         @image.line_xiaolin_wu(start_x, start_y, end_x, end_y, value)
       end