contrek 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 330f21ed351ac9ec5b507c77c49c0595264d174f5403d00449cd6abf25be9e98
-  data.tar.gz: 33813776ce0b886f1807d08e6e3245fb4a2276cb6da7ae0fdc571886101160ae
+  metadata.gz: 802afd86666e1705cc50240c6f7d79abfd9c7e93c315b1222199e79836fdd9e2
+  data.tar.gz: e9f593c3ef9a661720f2587b44d65406839b25c2bc1690b8c4bfae477f967de6
 SHA512:
-  metadata.gz: d9ee2d8f093dad25a2c6913247a3c719fbf63d6c818ca3b451b27c8ec8984eeaa1760688e4bb5baf799afd3ea6b712c1db3940eb46fea859a6b3336815ad5e1f
-  data.tar.gz: b542aec71f43fa199e300d745838ac5ff25e3c3b34e988ea6e1ca58051ac9f93723d2caa5d0ba2a4102fd0c30daf7b1ad3ced65f4ee3d077d1fff85a824c2960
+  metadata.gz: 8e4d8940a0f6cb93fc0ee685808c8889110bedbfd604fb8de3e3aca6b0fb9caa69d57bec518cc50ce15314a6ffa45e525fc947b60d52d71403510b6c77b7302f
+  data.tar.gz: e12d7f30b9dec7ee474ab5c400f86f8331cc8eaa8e1571e6c8b895ddea4a4f0633806d2ccb0b4fdd12380d77caa714c4b6c85b9f347e3bf6ff70f39b0a1cb9d9

data/CHANGELOG.md

@@ -159,3 +159,6 @@ All notable changes to this project will be documented in this file.
 
 ## [1.4.2] - 2026-09-06
 - Contrek takes care of the streaming process, providing an API that greatly simplifies the implementation of streaming raster processing.
+
+## [1.4.3] - 2026-09-09
+- Added TIFF/GeoTIFF streaming support with geolocation metadata and direct WGS84 GeoJSON output.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.4.2)
+    contrek (1.4.3)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       ffi (~> 1.17)

data/README.md

@@ -2,9 +2,9 @@
 
 **Contrek** is a standalone **C++17 contour tracing and polygonization library** for raster images.
 
-It was originally developed to solve a practical problem: extracting polygons from very large raster images without loading the entire image into memory. Over time the implementation evolved into a reusable library that can process PNG images as well as raw memory buffers, while preserving polygon topology during the entire tracing process.
+It was originally developed to solve a practical problem: extracting polygons from very large raster images without loading the entire image into memory. Over time the implementation evolved into a reusable library that can process PNG and TIFF/GeoTIFF images as well as raw memory buffers, while preserving polygon topology during the entire tracing process.
 
-The engine is based on programmable pixel matchers, allowing the caller to decide which pixels belong to the regions being traced. Polygon coordinates can be streamed as they are produced, making the library suitable for datasets that would otherwise require a large amount of RAM.
+The engine is based on programmable pixel matchers, allowing the caller to decide which pixels belong to the regions being traced. Polygon coordinates can be streamed as they are produced, making the library suitable for datasets that would otherwise require a large amount of RAM. GeoTIFF geolocation can also be preserved when streaming directly to GeoJSON (EPSG:4326).
 
 Although the tracing engine is written in C++, Contrek is also distributed as a Ruby gem exposing almost the complete native API through an idiomatic Ruby interface.
 
@@ -305,6 +305,15 @@ During installation the native C++ extension is compiled automatically.
 
 Once installed, the C++ implementation is used by default. A pure Ruby implementation is also included and can be selected explicitly whenever native extensions are not desired.
 
+### TIFF / GeoTIFF support
+
+TIFF and GeoTIFF streaming support requires the system `libtiff` and `libgeotiff` libraries.
+Ubuntu / Debian:
+
+```bash
+sudo apt install libtiff-dev libgeotiff-dev
+```
+
 # Usage
 
 The simplest way to use Contrek is through the `Contrek.contour!` helper.

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

@@ -102,7 +102,7 @@ void Tests::test_b()
 
   Options options = {
     {"versus", Identifier{"o"}},
-    {"number_of_tiles",2},
+    {"number_of_tiles", 2},
     {"compress", Options{
       {"uniq", true},
       {"linear", true},
@@ -204,7 +204,7 @@ void Tests::test_e()
 
   Options options = {
     {"versus", Identifier{"a"}},
-    {"number_of_tiles",2},
+    {"number_of_tiles", 2},
     {"compress", Options{
       {"uniq", true},
     }},
@@ -245,7 +245,7 @@ void Tests::test_g()
 
   Options options = {
     {"versus", Identifier{"a"}},
-    {"number_of_tiles",2},
+    {"number_of_tiles", 2},
     {"compress", Options{
       {"uniq", true},
     }},
@@ -339,10 +339,10 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
     int stripe_count = 0;
 
     // main stripes loop
-    streamer.each(stripe_bitmap, [&](Bitmap& bitmap, uint32_t buffer_rows, std::size_t) {
+    streamer.each(stripe_bitmap, [&](Bitmap& bitmap, uint32_t buffer_rows, std::size_t, std::size_t) {
       // stripe contour tracing
       Options options = {
-        {"processing_height", (int) buffer_rows},
+        {"processing_height", static_cast<int>(buffer_rows)},
         {"versus", Identifier{"a"}},
       };
       PolygonFinder polygon_finder(&bitmap, &not_matcher, nullptr, options);
@@ -399,7 +399,7 @@ 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) {
+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);
@@ -412,38 +412,33 @@ void stream_progressive_png_image(const std::string& filepath,uint32_t stripe_he
     {{"bounds", true}},
     &stream,
     source.width(),
-    source.height()
-  );
+    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,
+    [&](Bitmap& bitmap, uint32_t buffer_rows, std::size_t, std::size_t) {
+      PolygonFinder finder(&bitmap, &not_matcher, nullptr,
         {
-          {"processing_height", (int) buffer_rows},
+          {"processing_height", static_cast<int>(buffer_rows)},
           {"versus", Identifier{"a"}},
           {"bounds", true},
           {"compress", Options{
             {"uniq", true},
             {"linear", true},
           }},
-        }
-      );
+        });
       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());
+        merger.add_tile(*result, processed_rows == source.height());
         delete result;
       }
       first = false;
-
-    }
-  );
+    });
 
   delete merger.process_info();
 }

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

@@ -7,14 +7,14 @@
  * 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),
@@ -42,11 +42,7 @@ char RawBitmap::value_at(int, int) {
 }
 
 const unsigned char* RawBitmap::get_row_ptr(int y) const {
-  return image.get() + ( 
-    static_cast<std::size_t>(y) * 
-    static_cast<std::size_t>(width) *
-    static_cast<std::size_t>(bpp)
-  );
+  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/streaming/AsciiSource.cpp

@@ -17,53 +17,30 @@ AsciiSource::AsciiSource(Bitmap& bitmap)
 }
 
 uint32_t AsciiSource::width() const {
-  return static_cast<uint32_t>(
-    bitmap_.w()
-  );
+  return static_cast<uint32_t>(bitmap_.w());
 }
 
 uint32_t AsciiSource::height() const {
-  return static_cast<uint32_t>(
-    bitmap_.h()
-  );
+  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()
-  );
+  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()) {
+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()
-    );
+  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"
-    );
+    throw std::runtime_error("Invalid row size");
   }
-
-  std::memcpy(
-    destination,
-    row,
-    row_size
-  );
-
+  std::memcpy(destination, row, row_size);
   ++current_row_;
 
   return true;
-}
+}

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

@@ -16,19 +16,14 @@
 #include "../Bitmap.h"
 
 class AsciiSource : public RasterSource {
-public:
+ 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;
 
-  bool read_next_row(
-    unsigned char* destination,
-    std::size_t row_size
-  ) override;
-
-private:
+ 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

@@ -11,6 +11,7 @@
 
 #include <stdexcept>
 #include <string>
+#include <cstdio>
 
 PngSource::PngSource(const std::string& filepath)
   : fp_(nullptr),
@@ -18,7 +19,7 @@ PngSource::PngSource(const std::string& filepath)
     width_(0),
     height_(0),
     current_row_(0) {
-  fp_ = std::fopen(filepath.c_str(),"rb");
+  fp_ = std::fopen(filepath.c_str(), "rb");
   if (!fp_) {
     throw std::runtime_error("Unable to open PNG file");
   }
@@ -30,7 +31,7 @@ PngSource::PngSource(const std::string& filepath)
     throw std::runtime_error("Unable to create spng context");
   }
 
-  int ret = spng_set_png_file(ctx_,fp_);
+  int ret = spng_set_png_file(ctx_, fp_);
   if (ret != 0) {
     spng_ctx_free(ctx_);
     ctx_ = nullptr;
@@ -52,13 +53,7 @@ PngSource::PngSource(const std::string& filepath)
 
   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
-  );
+  ret = spng_decode_image(ctx_, nullptr, 0, SPNG_FMT_RGBA8, SPNG_DECODE_PROGRESSIVE);
 
   if (ret != 0) {
     spng_ctx_free(ctx_);
@@ -98,11 +93,11 @@ bool PngSource::read_next_row(unsigned char* destination, std::size_t row_size)
   if (row_size != expected_row_size) {
     throw std::runtime_error("Invalid row size");
   }
-  const int ret = spng_decode_row(ctx_,destination,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/RasterStreamer.h

@@ -80,7 +80,7 @@ class RasterStreamer {
       }
       const std::size_t buffer_size = static_cast<std::size_t>(buffer_rows) * row_size;
 
-      std::forward<Callback>(callback)(buffer, buffer_rows, buffer_size);
+      std::forward<Callback>(callback)(buffer, buffer_rows, buffer_size, rows_read);
       previous_buffer_rows = buffer_rows;
       first_stripe = false;
     }

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");
+}