contrek 1.4.1 → 1.4.3

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/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/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/cpp_polygon_finder.cpp

@@ -37,6 +37,16 @@
 #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"
+#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"
 #include "PolygonFinder/src/polygon/matchers/Matcher.h"
 #include "PolygonFinder/src/polygon/matchers/Matcher.cpp"
 #include "PolygonFinder/src/polygon/matchers/ValueNotMatcher.h"
@@ -395,6 +405,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 +413,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 +442,77 @@ 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);
+
+#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"))
+    .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, std::size_t buffer_read) {
+            Rice::Data_Object<Bitmap> rb_bitmap(&bitmap);
+            Rice::Object(block).call(
+              "call",
+              rb_bitmap,
+              buffer_rows,
+              buffer_size,
+              buffer_read
+            );
+          }
+        );
+      }
+    );
+
   Data_Type<Matcher> rb_cMatcher =
     define_class<Matcher>("CPPMatcher")
     .define_constructor(Constructor<Matcher, char>())