contrek 1.4.0 → 1.4.2

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

@@ -28,6 +28,8 @@
 #include "polygon/bitmaps/RawBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "polygon/bitmaps/spng.h"
+#include "polygon/bitmaps/streaming/RasterStreamer.h"
+#include "polygon/bitmaps/streaming/PngSource.h"
 #include "polygon/matchers/Matcher.h"
 #include "polygon/matchers/RGBMatcher.h"
 #include "polygon/matchers/RGBNotMatcher.h"
@@ -321,70 +323,29 @@ 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, bool generate_svg = false, bool generate_png = false) {
     std::vector<ProcessResult*> result_clones;
     Options options = {};
     VerticalMerger vmerger(0, options);
 
-    // 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;
+    PngSource source(filepath);
+    RasterStreamer streamer(source, 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);
+    RawBitmap stripe_bitmap(source.width(), stripe_height);
     RGBNotMatcher not_matcher(-1);
 
-    if (spng_decode_image(ctx, NULL, 0, SPNG_FMT_RGBA8, SPNG_DECODE_PROGRESSIVE)) {
-      fclose(fp);
-      spng_ctx_free(ctx);
-      return;
-    }
-
-    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) {
-      uint32_t 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;
-      }
+    streamer.each(stripe_bitmap, [&](Bitmap& bitmap, uint32_t buffer_rows, std::size_t) {
       // stripe contour tracing
       Options options = {
+        {"processing_height", (int) buffer_rows},
         {"versus", Identifier{"a"}},
       };
-      PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, options);
+      PolygonFinder polygon_finder(&bitmap, &not_matcher, nullptr, options);
       ProcessResult *result = polygon_finder.process_info();
       if (result) {
         std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
@@ -392,7 +353,7 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
         vmerger.add_tile(*result);
       }
       stripe_count++;
-    }
+    });
 
     std::cout << "Merging polygons ..." << std::endl;
     ProcessResult *merged_result = vmerger.process_info();
@@ -400,8 +361,7 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
     if (merged_result) {
       std::cout << "Founds total polygons: " << merged_result->groups << std::endl;
       if (generate_png) {
-        RawBitmap full_bitmap;
-        full_bitmap.define(total_width, total_height, 4, true);
+        RawBitmap full_bitmap(source.width(), source.height());
         full_bitmap.fill(255, 255, 255);
         merged_result->draw_on_bitmap(full_bitmap);
         std::cout << "Saving whole png ..." << std::endl;
@@ -413,18 +373,18 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
         merged_result->save_svg("whole.svg");
         std::cout << "Svg saved!" << std::endl;
       }
+      delete merged_result;
     }
-    delete merged_result;
+
     // frees memory
     for (auto c : result_clones) {
       delete c;
     }
-    spng_ctx_free(ctx);
-    fclose(fp);
 }
 
 void Tests::test_i() {
   stream_png_image("../images/graphs_1024x1024.png", 300, true);
+  // stream_png_image("../images/test_20480x20480.png", 2000, true);
   std::cout << "Memory usage peak: " << get_peak_rss() << " MB" << std::endl;
 }
 
@@ -439,104 +399,53 @@ double get_current_rss_mb() {
   return (resident * page_size) / (1024.0 * 1024.0);
 }
 
-void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_height) {
-    std::vector<ProcessResult*> result_clones;
-    Options voptions = {
-        {"bounds", true},
-      };
-    // 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;
-    }
-    std::vector<char> buffer(4 * 1024 * 1024);  // Buffer (4MB)
-    shared_stream.rdbuf()->pubsetbuf(buffer.data(), buffer.size());
-
-    SvgStreamingMerger vmerger(0, voptions, &shared_stream, total_width, total_height);
-    // GeoJsonStreamingMerger vmerger(0, &varguments, &shared_stream, 4294901760);
-    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) {
-        uint32_t 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
-        Options options = {
+void stream_progressive_png_image(const std::string& filepath,uint32_t stripe_height) {
+  PngSource source(filepath);
+  RasterStreamer streamer(source, stripe_height);
+  RawBitmap bitmap(source.width(), stripe_height);
+  RGBNotMatcher not_matcher(-1);
+
+  std::ofstream stream("streaming_buffer.svg");
+
+  SvgStreamingMerger merger(
+    0,
+    {{"bounds", true}},
+    &stream,
+    source.width(),
+    source.height()
+  );
+
+  uint32_t processed_rows = 0;
+  bool first = true;
+  int stripe_count = 0;
+  streamer.each(
+    bitmap,
+    [&](Bitmap& bitmap, uint32_t buffer_rows, std::size_t) {
+
+      PolygonFinder finder(&bitmap,&not_matcher,nullptr,
+        {
+          {"processing_height", (int) buffer_rows},
           {"versus", Identifier{"a"}},
           {"bounds", true},
           {"compress", Options{
             {"uniq", true},
             {"linear", true},
           }},
-        };
-
-        PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, options);
-        ProcessResult *result = polygon_finder.process_info();
-        if (result) {
-          std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-          vmerger.add_tile(*result, !(current_y_offset + stripe_height < total_height));
-          delete result;
-          std::cout << "-> RSS before merge: " << get_current_rss_mb() << " MB" << std::endl;
         }
-        stripe_count++;
+      );
+      ProcessResult* result = finder.process_info();
+      if (result) {
+        std::cout << "stripe " << stripe_count++ << ": found polygons " << result->groups << std::endl;
+        processed_rows += buffer_rows - (first ? 0 : RasterStreamer::OVERLAP);
+        merger.add_tile(*result,processed_rows == source.height());
+        delete result;
       }
-      ProcessResult *merged_result = vmerger.process_info();
-      std::cout << "total found polygons " << merged_result->groups << std::endl;
-      delete merged_result;
-    } catch (const std::exception& e) {
-      std::cerr << "\n[ERROR] Processing exception: " << e.what() << std::endl;
-      if (shared_stream.is_open()) shared_stream.close();
+      first = false;
+
     }
-    spng_ctx_free(ctx);
-    fclose(fp);
+  );
+
+  delete merger.process_info();
 }
 
 void Tests::test_l() {

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

@@ -18,7 +18,15 @@
 
 RawBitmap::RawBitmap() : Bitmap("", 0),
   width(0),
-  height(0) {
+  height(0),
+  bpp(0) {
+}
+
+RawBitmap::RawBitmap(uint width, uint height) : Bitmap("", 0),
+  width(0),
+  height(0),
+  bpp(0) {
+  define(width, height, 4, false);
 }
 
 int RawBitmap::w() {
@@ -34,7 +42,11 @@ char RawBitmap::value_at(int, int) {
 }
 
 const unsigned char* RawBitmap::get_row_ptr(int y) const {
-  return image.get() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
+  return image.get() + ( 
+    static_cast<std::size_t>(y) * 
+    static_cast<std::size_t>(width) *
+    static_cast<std::size_t>(bpp)
+  );
 }
 
 int RawBitmap::get_bytes_per_pixel() const {

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

@@ -19,6 +19,7 @@ class RGBMatcher;
 class RawBitmap : public Bitmap {
  public:
   explicit RawBitmap();
+  RawBitmap(uint width, uint height);
   int h();
   int w();
   char value_at(int x, int y);

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_;
+};