contrek 1.4.2 → 1.4.4

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

@@ -0,0 +1,301 @@
+/*
+ * TiffSource.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 "TiffSource.h"
+
+#include <geotiff/geotiff.h>
+#include <geotiff/geotiffio.h>
+#include <geotiff/geokeys.h>
+#include <geotiff/xtiffio.h>
+#include <tiffio.h>
+#include <stdexcept>
+#include <string>
+
+static const uint32_t TIFFTAG_MODELPIXELSCALE = 33550;
+static const uint32_t TIFFTAG_MODELTIEPOINT = 33922;
+static const uint32_t TIFFTAG_MODELTRANSFORMATION = 34264;
+
+TiffSource::TiffSource(const std::string& filepath, bool suppress_warnings)
+  : tiff_(nullptr),
+    width_(0),
+    height_(0),
+    bits_per_sample_(0),
+    samples_per_pixel_(0),
+    photometric_(0),
+    planar_config_(0),
+    sample_format_(0),
+    current_row_(0) {
+  if (suppress_warnings) {
+    TIFFSetWarningHandler(nullptr);
+  }
+  tiff_ = XTIFFOpen(filepath.c_str(), "r");
+
+  if (!tiff_) {
+    throw std::runtime_error("Unable to open TIFF: " + filepath);
+  }
+
+  try {
+    read_image_info();
+    read_geo_localization();
+
+    const tmsize_t scanline_size = TIFFScanlineSize(tiff_);
+    if (scanline_size <= 0) throw std::runtime_error("Invalid TIFF scanline size");
+
+    source_row_.resize(static_cast<std::size_t>(scanline_size));
+  }
+  catch (...) {
+    XTIFFClose(tiff_);
+    tiff_ = nullptr;
+    throw;
+  }
+}
+
+TiffSource::~TiffSource() {
+  if (tiff_) {
+    XTIFFClose(tiff_);
+    tiff_ = nullptr;
+  }
+}
+
+uint32_t TiffSource::width() const {
+  return width_;
+}
+
+uint32_t TiffSource::height() const {
+  return height_;
+}
+
+uint32_t TiffSource::get_bytes_per_pixel() const {
+  return 4;
+}
+
+const GeoLocalization& TiffSource::geo_localization() const {
+  return geo_localization_;
+}
+
+void TiffSource::read_image_info() {
+  if (!TIFFGetField(tiff_, TIFFTAG_IMAGEWIDTH, &width_)) throw std::runtime_error("Unable to read TIFF width");
+  if (!TIFFGetField(tiff_, TIFFTAG_IMAGELENGTH, &height_)) throw std::runtime_error("Unable to read TIFF height");
+
+  TIFFGetFieldDefaulted(tiff_, TIFFTAG_BITSPERSAMPLE, &bits_per_sample_);
+  TIFFGetFieldDefaulted(tiff_, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel_);
+
+  if (!TIFFGetField(tiff_, TIFFTAG_PHOTOMETRIC, &photometric_)) throw std::runtime_error("Unable to read TIFF photometric");
+
+  TIFFGetFieldDefaulted(tiff_, TIFFTAG_PLANARCONFIG, &planar_config_);
+  TIFFGetFieldDefaulted(tiff_, TIFFTAG_SAMPLEFORMAT, &sample_format_);
+
+  if (TIFFIsTiled(tiff_)) throw std::runtime_error("Tiled TIFF is not supported yet");
+  if (planar_config_ != PLANARCONFIG_CONTIG) throw std::runtime_error("Unsupported TIFF planar configuration");
+  if (bits_per_sample_ != 8 && bits_per_sample_ != 16) throw std::runtime_error("Unsupported TIFF bits per sample");
+  if (samples_per_pixel_ != 1 && samples_per_pixel_ != 3 && samples_per_pixel_ != 4) throw std::runtime_error("Unsupported TIFF samples per pixel");
+  if (sample_format_ != SAMPLEFORMAT_UINT) throw std::runtime_error("Unsupported TIFF sample format");
+
+  if (photometric_ != PHOTOMETRIC_MINISWHITE &&
+      photometric_ != PHOTOMETRIC_MINISBLACK &&
+      photometric_ != PHOTOMETRIC_RGB) {
+    throw std::runtime_error("Unsupported TIFF photometric");
+  }
+}
+
+void TiffSource::read_geo_localization() {
+  double* matrix = nullptr;
+  uint16_t matrix_count = 0;
+
+  if (TIFFGetField(tiff_, TIFFTAG_MODELTRANSFORMATION, &matrix_count, &matrix) && matrix && matrix_count >= 16) {
+    read_model_transformation(matrix, matrix_count);
+  } else {
+    read_pixel_scale_and_tiepoint();
+  }
+
+  if (geo_localization_.valid) read_crs();
+}
+
+void TiffSource::read_model_transformation(double* matrix, uint16_t count) {
+  if (!matrix || count < 16) return;
+
+  GeoTransform& transform = geo_localization_.transform;
+
+  transform.x_pixel_size = matrix[0];
+  transform.x_row_offset = matrix[1];
+  transform.x_origin = matrix[3];
+
+  transform.y_column_offset = matrix[4];
+  transform.y_pixel_size = matrix[5];
+  transform.y_origin = matrix[7];
+
+  geo_localization_.valid = true;
+}
+
+void TiffSource::read_pixel_scale_and_tiepoint() {
+  double* scale = nullptr;
+  double* tiepoint = nullptr;
+
+  uint16_t scale_count = 0;
+  uint16_t tiepoint_count = 0;
+
+  if (!TIFFGetField(tiff_, TIFFTAG_MODELPIXELSCALE, &scale_count, &scale)) return;
+  if (!TIFFGetField(tiff_, TIFFTAG_MODELTIEPOINT, &tiepoint_count, &tiepoint)) return;
+  if (!scale || !tiepoint || scale_count < 2 || tiepoint_count < 6) return;
+
+  const double pixel_x = tiepoint[0];
+  const double pixel_y = tiepoint[1];
+
+  const double model_x = tiepoint[3];
+  const double model_y = tiepoint[4];
+
+  const double x_pixel_size = scale[0];
+  const double y_pixel_size = scale[1];
+
+  GeoTransform& transform = geo_localization_.transform;
+
+  transform.x_origin = model_x - pixel_x * x_pixel_size;
+  transform.y_origin = model_y + pixel_y * y_pixel_size;
+
+  transform.x_pixel_size = x_pixel_size;
+  transform.y_pixel_size = -y_pixel_size;
+
+  transform.x_row_offset = 0.0;
+  transform.y_column_offset = 0.0;
+
+  geo_localization_.valid = true;
+}
+
+void TiffSource::read_crs() {
+  GTIF* gtif = GTIFNew(tiff_);
+  if (!gtif) return;
+
+  uint16_t model_type = 0;
+  uint16_t code = 0;
+
+  if (GTIFKeyGet(gtif, GTModelTypeGeoKey, &model_type, 0, 1) == 1) {
+    if (model_type == ModelTypeProjected) {
+      if (GTIFKeyGet(gtif, ProjectedCSTypeGeoKey, &code, 0, 1) == 1) {
+        geo_localization_.crs.authority = "EPSG";
+        geo_localization_.crs.code = static_cast<int>(code);
+      }
+    } else if (model_type == ModelTypeGeographic) {
+        if (GTIFKeyGet(gtif, GeographicTypeGeoKey, &code, 0, 1) == 1) {
+          geo_localization_.crs.authority = "EPSG";
+          geo_localization_.crs.code = static_cast<int>(code);
+        }
+      }
+  }
+
+  GTIFFree(gtif);
+}
+
+bool TiffSource::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_) * get_bytes_per_pixel();
+
+  if (row_size != expected_row_size) {
+    throw std::runtime_error("Invalid TIFF destination row size");
+  }
+
+  if (TIFFReadScanline(tiff_, source_row_.data(), current_row_, 0) < 0) {
+    throw std::runtime_error("TIFFReadScanline failed at row " + std::to_string(current_row_));
+  }
+
+  convert_row(destination);
+
+  ++current_row_;
+  return true;
+}
+
+void TiffSource::convert_row(unsigned char* destination) {
+  if (samples_per_pixel_ == 4 && bits_per_sample_ == 8) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      const std::size_t source_offset = static_cast<std::size_t>(x) * 4;
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = source_row_[source_offset];
+      destination[destination_offset + 1] = source_row_[source_offset + 1];
+      destination[destination_offset + 2] = source_row_[source_offset + 2];
+      destination[destination_offset + 3] = source_row_[source_offset + 3];
+    }
+    return;
+  }
+
+  if (samples_per_pixel_ == 3 && bits_per_sample_ == 8) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      const std::size_t source_offset = static_cast<std::size_t>(x) * 3;
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = source_row_[source_offset];
+      destination[destination_offset + 1] = source_row_[source_offset + 1];
+      destination[destination_offset + 2] = source_row_[source_offset + 2];
+      destination[destination_offset + 3] = 255;
+    }
+    return;
+  }
+
+  if (samples_per_pixel_ == 1 && bits_per_sample_ == 8) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      unsigned char value = source_row_[x];
+
+      if (photometric_ == PHOTOMETRIC_MINISWHITE) value = static_cast<unsigned char>(255 - value);
+
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = value;
+      destination[destination_offset + 1] = value;
+      destination[destination_offset + 2] = value;
+      destination[destination_offset + 3] = 255;
+    }
+    return;
+  }
+
+  const uint16_t* source16 = reinterpret_cast<const uint16_t*>(source_row_.data());
+
+  if (samples_per_pixel_ == 4 && bits_per_sample_ == 16) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      const std::size_t source_offset = static_cast<std::size_t>(x) * 4;
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = static_cast<unsigned char>(source16[source_offset] >> 8);
+      destination[destination_offset + 1] = static_cast<unsigned char>(source16[source_offset + 1] >> 8);
+      destination[destination_offset + 2] = static_cast<unsigned char>(source16[source_offset + 2] >> 8);
+      destination[destination_offset + 3] = static_cast<unsigned char>(source16[source_offset + 3] >> 8);
+    }
+    return;
+  }
+
+  if (samples_per_pixel_ == 3 && bits_per_sample_ == 16) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      const std::size_t source_offset = static_cast<std::size_t>(x) * 3;
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = static_cast<unsigned char>(source16[source_offset] >> 8);
+      destination[destination_offset + 1] = static_cast<unsigned char>(source16[source_offset + 1] >> 8);
+      destination[destination_offset + 2] = static_cast<unsigned char>(source16[source_offset + 2] >> 8);
+      destination[destination_offset + 3] = 255;
+    }
+    return;
+  }
+
+  if (samples_per_pixel_ == 1 && bits_per_sample_ == 16) {
+    for (uint32_t x = 0; x < width_; ++x) {
+      unsigned char value = static_cast<unsigned char>(source16[x] >> 8);
+
+      if (photometric_ == PHOTOMETRIC_MINISWHITE) value = static_cast<unsigned char>(255 - value);
+
+      const std::size_t destination_offset = static_cast<std::size_t>(x) * 4;
+
+      destination[destination_offset] = value;
+      destination[destination_offset + 1] = value;
+      destination[destination_offset + 2] = value;
+      destination[destination_offset + 3] = 255;
+    }
+    return;
+  }
+
+  throw std::runtime_error("Unsupported TIFF pixel format");
+}

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

@@ -0,0 +1,51 @@
+/*
+ * TiffSource.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 "RasterSource.h"
+#include "GeoLocalization.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+struct tiff;
+typedef struct tiff TIFF;
+
+class TiffSource : public RasterSource {
+ public:
+  explicit TiffSource(const std::string& filepath, bool suppress_warnings = false);
+  ~TiffSource() 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;
+  const GeoLocalization& geo_localization() const;
+
+ private:
+  void read_image_info();
+  void read_geo_localization();
+  void read_pixel_scale_and_tiepoint();
+  void read_model_transformation(double* matrix, uint16_t count);
+  void read_crs();
+  void convert_row(unsigned char* destination);
+  TIFF* tiff_;
+  uint32_t width_;
+  uint32_t height_;
+  uint16_t bits_per_sample_;
+  uint16_t samples_per_pixel_;
+  uint16_t photometric_;
+  uint16_t planar_config_;
+  uint16_t sample_format_;
+  uint32_t current_row_;
+  std::vector<unsigned char> source_row_;
+  GeoLocalization geo_localization_;
+};

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

@@ -154,6 +154,15 @@ struct ProcessResult {
     to_svg_stream(file);
     file.close();
   }
+
+  void sort_polygons() {
+    polygons.sort([](const Polygon& a, const Polygon& b) {
+      if (a.bounds.min_y != b.bounds.min_y) {
+        return a.bounds.min_y < b.bounds.min_y;
+      }
+      return a.bounds.min_x < b.bounds.min_x;
+    });
+  }
 };
 
 class PolygonFinder {

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

@@ -10,12 +10,51 @@
 #pragma once
 #include <vector>
 #include <string>
+#include <functional>
+#include <stdexcept>
+#include <iomanip>
+#include <limits>
 #include "StreamingMerger.h"
 
 class GeoJsonStreamingMerger : public StreamingMerger {
  private:
   unsigned int target_value;
   bool is_first_feature = true;
+  std::function<void(const Point&)> point_writer;
+
+  void configure_point_writer(const Options& options) {
+    const Options* geo_localization = options.get_options("geo_localization");
+    if (!geo_localization) {
+      point_writer = [this](const Point& point) { *stream << "[" << point.y << "," << point.x << "]"; };
+      return;
+    }
+
+    const Options* transform = geo_localization->get_options("transform");
+    const Options* crs = geo_localization->get_options("crs");
+    if (!transform || !crs) throw std::invalid_argument("Invalid geo_localization.");
+
+    const std::string authority = crs->get<std::string>("authority", "");
+    const auto code = crs->get("code", 0L);
+    if (authority != "EPSG" || code != 4326) throw std::invalid_argument("Unsupported CRS: " + authority + ":" + std::to_string(code));
+    const double x_origin = transform->get<double>("x_origin", 0.0);
+    const double y_origin = transform->get<double>("y_origin", 0.0);
+    const double x_pixel_size = transform->get<double>("x_pixel_size", 1.0);
+    const double y_pixel_size = transform->get<double>("y_pixel_size", 1.0);
+    const double x_row_offset = transform->get<double>("x_row_offset", 0.0);
+    const double y_column_offset = transform->get<double>("y_column_offset", 0.0);
+
+    *stream << std::fixed << std::setprecision(7);
+
+    point_writer = [this, x_origin, y_origin, x_pixel_size, y_pixel_size, x_row_offset, y_column_offset](const Point& point) {
+      const double x = point.y;
+      const double y = point.x;
+      *stream << "[" << x_origin + x * x_pixel_size + y * x_row_offset << "," << y_origin + x * y_column_offset + y * y_pixel_size << "]";
+    };
+  }
+
+  void write_point(const Point& point) {
+    point_writer(point);
+  }
 
  protected:
   void write_header() override {
@@ -40,7 +79,9 @@ class GeoJsonStreamingMerger : public StreamingMerger {
                          std::ofstream* stream_to,
                          unsigned int pixel_value)
       : StreamingMerger(number_of_threads, options, stream_to),
-        target_value(pixel_value) {}
+        target_value(pixel_value) {
+    configure_point_writer(options);
+  }
 
   void stream_raw_polygon(const Polygon& polygon) override {
     if (!stream) return;
@@ -55,12 +96,14 @@ class GeoJsonStreamingMerger : public StreamingMerger {
     const size_t points_size = points.size();
     if (points_size > 0) {
       for (size_t i = 0; i < points_size; ++i) {
-        *stream << "[" << points[i].y << "," << points[i].x << "]";
+        write_point(points[i]);
         if (i < points_size - 1) *stream << ",";
       }
-      *stream << ",[" << points[0].y << "," << points[0].x << "]]";
+      *stream << ",";
+      write_point(points[0]);
+      *stream << "]";
     } else {
-      *stream << "]]";
+      *stream << "]";
     }
 
     for (const std::vector<Point>& inner_points : polygon.inner) {
@@ -68,10 +111,12 @@ class GeoJsonStreamingMerger : public StreamingMerger {
       if (inner_size > 0) {
         *stream << ",[";
         for (size_t i = 0; i < inner_size; ++i) {
-          *stream << "[" << inner_points[i].y << "," << inner_points[i].x << "]";
+          write_point(inner_points[i]);
           if (i < inner_size - 1) *stream << ",";
         }
-        *stream << ",[" << inner_points[0].y << "," << inner_points[0].x << "]]";
+        *stream << ",";
+        write_point(inner_points[0]);
+        *stream << "]";
       }
     }
     *stream << "]}}";

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

@@ -14,6 +14,9 @@
 
 Merger::Merger(int number_of_threads, const Options& options)
 : Finder(number_of_threads, options) {
+  if (options.contains("versus")) {
+    std::cerr << "[Contrek WARNING] The given options 'versus' will be ignored." << std::endl;
+  }
   if (!this->safe()) {
     std::cerr << "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. "
               << "Incompatible result options might lead to unexpected vector geometry.\n";
@@ -58,7 +61,9 @@ void Merger::add_tile(ProcessResult& result)
 
 ProcessResult* Merger::process_info() {
   this->process_tiles();
-  return(Finder::process_info());
+  ProcessResult* result = Finder::process_info();
+  result->versus = this->versus;
+  return result;
 }
 
 void Merger::translate(ProcessResult& result, int offset) {

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

@@ -20,10 +20,10 @@ VerticalMerger::VerticalMerger(int number_of_threads, const Options& options)
 
 void VerticalMerger::add_tile(ProcessResult& result)
 { transpose(result);
+  adjust(result);
   if (this->tiles_.size() > 0) {
     translate(result, this->current_x);
   }
-  adjust(result);
   Merger::add_tile(result);
 }
 
@@ -50,14 +50,32 @@ void VerticalMerger::transpose(ProcessResult& result) {
 }
 
 void VerticalMerger::adjust(ProcessResult& result) {
+  const int tile_width = result.width;
+  const auto number_of_tiles = this->tiles_.size();
+
   for (auto& polygon : result.polygons) {
-    if (!polygon.outer.empty()) {
-      std::rotate(polygon.outer.begin(), polygon.outer.begin() + 1, polygon.outer.end());
+    const auto& bounds = polygon.bounds;
+    const bool needs_left = number_of_tiles > 0 && bounds.min_x == 0;
+    const bool needs_right = bounds.max_x == tile_width;
+
+    if (!needs_left && !needs_right) {
+      continue;
     }
-    for (auto& sequence : polygon.inner) {
-      if (!sequence.empty()) {
-        std::rotate(sequence.begin(), sequence.begin() + 1, sequence.end());
+
+    auto& sequence = polygon.outer;
+    auto best = sequence.end();
+    for (auto it = sequence.begin(); it != sequence.end(); ++it) {
+      if (it->y != bounds.min_y) {
+        continue;
+      }
+      if (best == sequence.end() ||
+         (result.versus == Node::A ? it->x > best->x : it->x < best->x)) {
+        best = it;
       }
     }
+
+    if (best != sequence.end() && best != sequence.begin()) {
+      std::rotate(sequence.begin(), best, sequence.end());
+    }
   }
 }

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -40,6 +40,10 @@
 #include "PolygonFinder/src/polygon/bitmaps/streaming/RasterSource.h"
 #include "PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.h"
 #include "PolygonFinder/src/polygon/bitmaps/streaming/AsciiSource.cpp"
+#ifdef CONTREK_HAS_TIFF
+#include "PolygonFinder/src/polygon/bitmaps/streaming/TiffSource.h"
+#include "PolygonFinder/src/polygon/bitmaps/streaming/TiffSource.cpp"
+#endif
 #include "PolygonFinder/src/polygon/bitmaps/streaming/PngSource.h"
 #include "PolygonFinder/src/polygon/bitmaps/streaming/PngSource.cpp"
 #include "PolygonFinder/src/polygon/bitmaps/streaming/RasterStreamer.h"
@@ -455,6 +459,38 @@ void Init_cpp_polygon_finder() {
     .define_method("height",&PngSource::height)
     .define_method("get_bytes_per_pixel",&PngSource::get_bytes_per_pixel);
 
+#ifdef CONTREK_HAS_TIFF
+  Data_Type<TiffSource> rb_cTiffSource =
+    define_class<TiffSource, RasterSource>("CPPTiffSource")
+    .define_constructor(Constructor<TiffSource, std::string, bool>(),Arg("filepath"),Arg("suppress_warnings") = false)
+    .define_method("width",&TiffSource::width)
+    .define_method("height",&TiffSource::height)
+    .define_method("get_bytes_per_pixel",&TiffSource::get_bytes_per_pixel)
+    .define_method("geo_localization",[](TiffSource& self) {
+      const GeoLocalization& geo = self.geo_localization();
+
+      if (!geo.valid) return Object(Qnil);
+
+      Hash transform;
+      transform[Symbol("x_origin")] = geo.transform.x_origin;
+      transform[Symbol("y_origin")] = geo.transform.y_origin;
+      transform[Symbol("x_pixel_size")] = geo.transform.x_pixel_size;
+      transform[Symbol("y_pixel_size")] = geo.transform.y_pixel_size;
+      transform[Symbol("x_row_offset")] = geo.transform.x_row_offset;
+      transform[Symbol("y_column_offset")] = geo.transform.y_column_offset;
+
+      Hash crs;
+      crs[Symbol("authority")] = geo.crs.authority;
+      crs[Symbol("code")] = geo.crs.code;
+
+      Hash result;
+      result[Symbol("transform")] = transform;
+      result[Symbol("crs")] = crs;
+
+      return Object(result);
+    });
+#endif
+
   Data_Type<RasterStreamer> rb_cRasterStreamer =
     define_class<RasterStreamer>("CPPRasterStreamer")
     .define_constructor(Constructor<RasterStreamer, RasterSource&, uint32_t>(),Arg("source"),Arg("stripe_height"))
@@ -463,13 +499,14 @@ void Init_cpp_polygon_finder() {
         VALUE block = rb_block_proc();
         self.each(
           buffer,
-          [block](Bitmap& bitmap,uint32_t buffer_rows,std::size_t buffer_size) {
+          [block](Bitmap& bitmap,uint32_t buffer_rows,std::size_t buffer_size, std::size_t buffer_read) {
             Rice::Data_Object<Bitmap> rb_bitmap(&bitmap);
             Rice::Object(block).call(
               "call",
               rb_bitmap,
               buffer_rows,
-              buffer_size
+              buffer_size,
+              buffer_read
             );
           }
         );

data/ext/cpp_polygon_finder/extconf.rb

@@ -3,6 +3,8 @@
 require "mkmf-rice"
 
 has_tcmalloc = find_library("tcmalloc", "malloc")
+has_tiff = have_library("tiff", "TIFFOpen", "tiffio.h")
+has_geotiff = has_tiff && have_library("geotiff", "XTIFFOpen", "geotiff/xtiffio.h")
 
 # rubocop:disable Style/GlobalVars
 
@@ -16,6 +18,13 @@ else
   puts "tcmalloc not found; standard malloc will be used."
 end
 
+if has_tiff && has_geotiff
+  $CXXFLAGS << " -DCONTREK_HAS_TIFF"
+  puts "TIFF/GeoTIFF support enabled."
+else
+  puts "TIFF/GeoTIFF support disabled."
+end
+
 $LDFLAGS << " -lz -lstdc++ -flto -pthread"
 
 $objs = [

data/lib/contrek/bitmaps/streaming/raster_streamer.rb

@@ -55,7 +55,7 @@ module Contrek
             buffer_rows = overlap_rows + rows_read
             break if buffer_rows == 0
 
-            yield buffer, buffer_rows, buffer_rows * row_size
+            yield buffer, buffer_rows, buffer_rows * row_size, rows_read
 
             first_stripe = false
           end