contrek 1.4.1 → 1.4.3

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

@@ -7,18 +7,26 @@
  * See the LICENSE file in this directory for the full license text.
  */
 
+#include "RawBitmap.h"
+#include "spng.h"
 #include <memory>
 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <cerrno>
 #include <string>
-#include "spng.h"
-#include "RawBitmap.h"
 
 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,7 @@ 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,46 @@
+/*
+ * 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,29 @@
+/*
+ * 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/GeoLocalization.h

@@ -0,0 +1,32 @@
+/*
+ * GeoLocalization.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 <string>
+
+struct GeoTransform {
+  double x_origin = 0.0;
+  double y_origin = 0.0;
+  double x_pixel_size = 1.0;
+  double y_pixel_size = 1.0;
+  double x_row_offset = 0.0;
+  double y_column_offset = 0.0;
+};
+
+struct GeoCrs {
+  std::string authority;
+  int code = 0;
+};
+
+struct GeoLocalization {
+  bool valid = false;
+  GeoTransform transform;
+  GeoCrs crs;
+};

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

@@ -0,0 +1,103 @@
+/*
+ * 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>
+#include <cstdio>
+
+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, rows_read);
+      previous_buffer_rows = buffer_rows;
+      first_stripe = false;
+    }
+  }
+
+ private:
+  RasterSource& source_;
+  uint32_t stripe_height_;
+};