contrek 1.4.3 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 802afd86666e1705cc50240c6f7d79abfd9c7e93c315b1222199e79836fdd9e2
-  data.tar.gz: e9f593c3ef9a661720f2587b44d65406839b25c2bc1690b8c4bfae477f967de6
+  metadata.gz: 9350d60698a69dda805ede85e42b80fcc38022a361e52674fd2780d696e0f9ff
+  data.tar.gz: '08d164d2e53bb3c96e7212ac6bc9d46bb673de8f10bb950d43f3d66d0c86d793'
 SHA512:
-  metadata.gz: 8e4d8940a0f6cb93fc0ee685808c8889110bedbfd604fb8de3e3aca6b0fb9caa69d57bec518cc50ce15314a6ffa45e525fc947b60d52d71403510b6c77b7302f
-  data.tar.gz: e12d7f30b9dec7ee474ab5c400f86f8331cc8eaa8e1571e6c8b895ddea4a4f0633806d2ccb0b4fdd12380d77caa714c4b6c85b9f347e3bf6ff70f39b0a1cb9d9
+  metadata.gz: 1c6d0b73ab8affa0ed17aa3fd803f7aed81cec846db6edd3de5dfcec8103bf23c9e23484819c4a981a4cb0c46da18f0b169122124213a9b4417df108f54c468a
+  data.tar.gz: 57817011679288782915a50ca1adf4155b71732ab73e330e2ac696ea504d7204c08935a6b83487000faac68b37f38aff5b5761d78fc85aab7703752f2700d65f

data/CHANGELOG.md

@@ -161,4 +161,12 @@ All notable changes to this project will be documented in this file.
 - 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.
+- Added TIFF/GeoTIFF streaming support with geolocation metadata and direct WGS84 GeoJSON output.
+
+## [1.4.4] - 2026-09-19
+- Fixed `VerticalMerger` handling of polygon orientation and starting points.
+- Added `detach()` to `RawBitmap` on the C++ side.
+- Added an OpenCV coordinate converter helper for converting contours to Contrek-compatible polygons.
+
+## [1.4.5] - 2026-10-11
+- Added tile boundary validation for external geometries, with support for bypassing checks via `unsafe_mode: true`.

data/Gemfile.lock

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

data/README.md

@@ -676,6 +676,68 @@ result = Contrek.contour!(
 
 The choice mainly affects how diagonally touching regions are interpreted.
 
+## Merging External Geometry
+
+Contrek's merger can process polygon data produced by external contour
+extractors, provided that the input geometry follows the requirements below.
+
+### The Laws of the Tiles
+
+1. **Adjacent tiles must share an overlap and have identical exposed boundary sequences.**
+   Adjacent tiles must share a single scanline of overlap. The exposed contour
+   segments on their shared boundary must have identical coordinate sequences,
+   including all intermediate vertices, expressed in the same coordinate system.
+   Any mismatch between the two sequences makes the tiles incompatible for merging.
+
+2. **Coordinates must describe cell boundaries.**
+   A cell is the square area occupied by a pixel in the raster. Coordinates
+   must describe the boundaries of these cells, rather than representing a
+   pixel by its center or by a single vertex.
+
+3. **Contours must follow cell boundaries.**
+   Contour segments supplied to the merger must follow the horizontal and
+   vertical edges of the raster cells. Diagonal segments are not allowed in
+   the geometry passed to the merger.
+
+4. **Polygon orientation (`versus`) must be consistent across all tiles.**
+   All polygons must follow the orientation declared by the result, either
+   clockwise or counterclockwise. The same orientation must be used by every
+   tile submitted to the merger.
+
+5. **Every contour must start at the canonical point of its first scanline.**
+   A *scanline* is a horizontal raster row scanned from left to right, like
+   the electron beam of a CRT display. Consider the topmost scanline
+   intersecting the contour. On that scanline, a **counterclockwise** contour
+   must start from the **leftmost** point, while a **clockwise** contour must
+   start from the **rightmost** point.
+
+6. **The bounding box must match the contour geometry.**
+   `min_x`, `max_x`, `min_y`, and `max_y` must correctly describe the spatial
+   extent of the contour.
+
+7. **Tile metadata must match the supplied geometry.**
+   `width`, `height`, and `versus` must correctly describe the tile. In
+   particular, `height` must represent the actual height of the result.
+
+8. **Polygons must be sorted in raster scan order.**
+   Polygons must be ordered by increasing **Y**, and then by increasing **X**
+   when they have the same Y: top to bottom, and left to right at the same
+   vertical position.
+
+### Boundary Validation
+
+By default, Contrek validates the shared boundaries of adjacent tiles when
+merging externally supplied geometries. Boundary coordinates must match
+exactly, including intermediate vertices. Otherwise, the merger raises a
+`Tile boundary mismatch` error.
+
+This validation can be disabled by setting `unsafe_mode: true`, avoiding
+validation overhead when the input geometries are known to be valid.
+
+**Important:** Boundary validation does not verify all the Laws of the Tiles.
+Users supplying external geometries remain responsible for satisfying every
+requirement listed above.
+
 # Results
 
 The tracing result contains two kinds of information:

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

@@ -294,7 +294,9 @@ void Tests::test_h()
   PolygonFinder pl_right(&b_right, &matcher, nullptr, options);
   ProcessResult *right_result = pl_right.process_info();
 
-  Options merger_options = {};
+  Options merger_options = {
+    {"unsafe_mode", true}
+  };
   HorizontalMerger hmerger(1, merger_options);
   hmerger.add_tile(*left_result);
   hmerger.add_tile(*right_result);
@@ -326,7 +328,9 @@ double get_peak_rss() {
 
 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 = {};
+    Options options = {
+      {"unsafe_mode", true}
+    };
     VerticalMerger vmerger(0, options);
 
     PngSource source(filepath);
@@ -409,7 +413,7 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
 
   SvgStreamingMerger merger(
     0,
-    {{"bounds", true}},
+    {{"bounds", true},{"unsafe_mode", true}},
     &stream,
     source.width(),
     source.height());

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

@@ -8,13 +8,14 @@
  */
 
 #include "RawBitmap.h"
-#include "spng.h"
 #include <memory>
 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <cerrno>
 #include <string>
+#include <utility>
+#include "spng.h"
 
 RawBitmap::RawBitmap() : Bitmap("", 0),
   width(0),
@@ -169,3 +170,16 @@ bool RawBitmap::save_to_png(const std::string& filename) {
 
   return (ret == 0);
 }
+
+std::unique_ptr<RawBitmap> RawBitmap::detach() {
+  auto detached = std::make_unique<RawBitmap>();
+
+  detached->width = width;
+  detached->height = height;
+  detached->bpp = bpp;
+  detached->image = std::move(image);
+
+  define(width, height, bpp, false);
+
+  return detached;
+}

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

@@ -32,6 +32,7 @@ class RawBitmap : public Bitmap {
   void fill(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);
   void draw_line(int x0, int y0, int x1, int y1, unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);
   void draw_filled_rectangle(int x, int y, int w, int h, unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);
+  std::unique_ptr<RawBitmap> detach();
 
  protected:
   std::unique_ptr<unsigned char[]> image;

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

@@ -40,17 +40,10 @@ class RasterStreamer {
     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;
+    std::vector<unsigned char> overlap_row(row_size);
 
     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;
@@ -80,8 +73,10 @@ class RasterStreamer {
       }
       const std::size_t buffer_size = static_cast<std::size_t>(buffer_rows) * row_size;
 
+      const unsigned char* last_row = buffer.get_row_ptr(buffer_rows - 1);
+      std::memcpy(overlap_row.data(), last_row, row_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/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

@@ -34,7 +34,7 @@ class GeoJsonStreamingMerger : public StreamingMerger {
     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);
+    const auto code = crs->get("code", std::int64_t{0});
     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);

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

@@ -10,10 +10,15 @@
 #include <iostream>
 #include <string>
 #include <vector>
+#include <algorithm>
+#include <list>
 #include "Merger.h"
 
 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";
@@ -46,19 +51,26 @@ void Merger::add_tile(ProcessResult& result)
       }
     }
   }
+  if (safe()) validate(result);
 
   int end_x = this->current_x + result.width;
   Tile* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), tiles_.size(), Benchmarks {0, 0});
   tile->assign_raw_polygons(result.polygons, result.treemap);
   tiles_.queue_push(tile);
 
+  if (safe()) {
+    previous_boundary_ = boundary_coordinates(result.polygons, end_x);
+  }
+
   this->maximum_width_ = end_x;
   this->current_x = end_x - 1;
 }
 
 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) {
@@ -71,3 +83,27 @@ void Merger::translate(ProcessResult& result, int offset) {
     polygon.bounds.max_x += offset;
   }
 }
+
+std::vector<int> Merger::boundary_coordinates(const std::list<Polygon>& polygons, int boundary_x) {
+  std::vector<int> coordinates;
+
+  for (const auto& polygon : polygons) {
+    for (const auto& point : polygon.outer) {
+      if (point.x == boundary_x) {
+        coordinates.push_back(point.y);
+      }
+    }
+  }
+
+  std::sort(coordinates.begin(), coordinates.end());
+  return coordinates;
+}
+
+void Merger::validate(const ProcessResult& result) {
+  if (tiles_.size() == 0) return;
+
+  const auto current = boundary_coordinates(result.polygons, current_x);
+  if (previous_boundary_ != current) {
+    throw std::invalid_argument("Tile boundary mismatch: adjacent tiles have different edge coordinates");
+  }
+}

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

@@ -10,6 +10,7 @@
 #pragma once
 #include <string>
 #include <vector>
+#include <list>
 #include "Finder.h"
 #include "../Options.h"
 
@@ -23,4 +24,7 @@ class Merger : public Finder {
  protected:
   void translate(ProcessResult& result, int offset);
   int current_x = 0;
+  void validate(const ProcessResult& result);
+  static std::vector<int> boundary_coordinates(const std::list<Polygon>& polygons, int boundary_x);
+  std::vector<int> previous_boundary_;
 };

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/PolygonFinder/src/polygon/shared/OpencvConverter.cpp

@@ -0,0 +1,51 @@
+/*
+ * OpencvConverter.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 "OpencvConverter.h"
+
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <utility>
+#include <vector>
+
+std::size_t OpencvConverter::EdgeKeyHash::operator()(const EdgeKey& key) const {
+  return std::hash<uint64_t>{}(key.a) ^
+         (std::hash<uint64_t>{}(key.b) << 1);
+}
+
+uint64_t OpencvConverter::point_key(const Point& p) {
+  return (static_cast<uint64_t>(static_cast<uint32_t>(p.x)) << 32) |
+         static_cast<uint32_t>(p.y);
+}
+
+OpencvConverter::EdgeKey OpencvConverter::edge_key(const Point& a, const Point& b) {
+  uint64_t ka = point_key(a);
+  uint64_t kb = point_key(b);
+  if (ka > kb) {
+    std::swap(ka, kb);
+  }
+  return {ka, kb};
+}
+
+void OpencvConverter::rotate_to_scanline_start(std::vector<Point>& points, const RectBounds& bounds) {
+  if (points.empty()) return;
+
+  std::size_t index = points.size();
+  int min_x = std::numeric_limits<int>::max();
+  for (std::size_t i = 0; i < points.size(); ++i) {
+    if (points[i].y == bounds.min_y && points[i].x < min_x) {
+      min_x = points[i].x;
+      index = i;
+    }
+  }
+  if (index != points.size() && index > 0) {
+    std::rotate(points.begin(), points.begin() + index, points.end());
+  }
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/shared/OpencvConverter.h

@@ -0,0 +1,205 @@
+/*
+ * OpencvConverter.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 <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <cstdint>
+#include <stdexcept>
+#include <cstdlib>
+
+#include "polygon/finder/Node.h"
+#include "RectBounds.h"
+
+class OpencvConverter {
+ private:
+  static constexpr int chain_dir[3][3] = {
+    {3, 4, 5},
+    {2, -1, 6},
+    {1, 0, 7}
+  };
+
+  static constexpr int corner_x[4] = {0, 1, 1, 0};
+  static constexpr int corner_y[4] = {1, 1, 0, 0};
+
+  struct BoundaryEdge {
+    Point a;
+    Point b;
+  };
+
+  struct EdgeKey {
+    uint64_t a;
+    uint64_t b;
+    bool operator==(const EdgeKey& other) const {
+      return a == other.a && b == other.b;
+    }
+  };
+
+  struct EdgeKeyHash {
+    std::size_t operator()(const EdgeKey& key) const;
+  };
+
+  static uint64_t point_key(const Point& p);
+  static EdgeKey edge_key(const Point& a, const Point& b);
+  static void rotate_to_scanline_start(std::vector<Point>& points, const RectBounds& bounds);
+
+  template<typename P>
+  static int chain_direction(const P& from, const P& to) {
+    const int dx = to.x - from.x;
+    const int dy = to.y - from.y;
+
+    if (dx == 0 && dy == 0)
+      throw std::invalid_argument("Zero-length contour step");
+
+    if (std::abs(dx) > 1 || std::abs(dy) > 1)
+      throw std::invalid_argument("Non-adjacent contour step");
+
+    return chain_dir[dx + 1][dy + 1];
+  }
+
+ public:
+  template<typename P>
+  static std::vector<Point> contour_to_cell_boundary(const std::vector<P>& contour, const RectBounds& bounds) {
+    std::vector<Point> raw;
+    const std::size_t n = contour.size();
+
+    if (n == 0) {
+      return raw;
+    }
+
+    if (n == 1) {
+      const int x = contour[0].x;
+      const int y = contour[0].y;
+      return {
+        Point(x, y + 1),
+        Point(x + 1, y + 1),
+        Point(x + 1, y),
+        Point(x, y)
+      };
+    }
+
+    raw.reserve(n * 2);
+
+    for (std::size_t i = 0; i < n; ++i) {
+      const P& previous = contour[(i + n - 1) % n];
+      const P& current  = contour[i];
+      const P& next     = contour[(i + 1) % n];
+      const int incoming = chain_direction(previous, current);
+      const int outgoing = chain_direction(current, next);
+      int corner = incoming >> 1;
+      const int last_corner = ((outgoing + 1) >> 1) & 3;
+      for (;;) {
+        raw.emplace_back(current.x + corner_x[corner], current.y + corner_y[corner]);
+        if (corner == last_corner) {
+          break;
+        }
+        corner = (corner + 1) & 3;
+      }
+    }
+
+    std::vector<BoundaryEdge> edges;
+    edges.reserve(raw.size());
+
+    for (std::size_t i = 0; i < raw.size(); ++i) {
+      const Point& a = raw[i];
+      const Point& b = raw[(i + 1) % raw.size()];
+      if (a.x == b.x && a.y == b.y) {
+        continue;
+      }
+      edges.push_back({a, b});
+    }
+
+    std::unordered_map<EdgeKey, int, EdgeKeyHash> counts;
+
+    for (const auto& edge : edges) {
+      ++counts[edge_key(edge.a, edge.b)];
+    }
+
+    std::unordered_set<EdgeKey, EdgeKeyHash> kept;
+    std::vector<BoundaryEdge> filtered;
+    filtered.reserve(edges.size());
+
+    for (const auto& edge : edges) {
+      const EdgeKey key = edge_key(edge.a, edge.b);
+      if (((counts[key] & 1) == 0) ||
+          (kept.find(key) != kept.end())) {
+        continue;
+      }
+      kept.insert(key);
+      filtered.push_back(edge);
+    }
+
+    if (filtered.empty()) {
+      return {};
+    }
+
+    std::unordered_map<uint64_t, std::vector<std::size_t>> outgoing;
+    for (std::size_t i = 0; i < filtered.size(); ++i) {
+      outgoing[point_key(filtered[i].a)].push_back(i);
+    }
+
+    std::vector<bool> used(filtered.size(), false);
+    std::size_t used_count = 0;
+    std::vector<Point> result;
+    result.reserve(filtered.size());
+
+    auto first_unused = [&]() {
+      for (std::size_t i = 0; i < used.size(); ++i) {
+        if (!used[i])
+          return i;
+      }
+      return used.size();
+    };
+
+    std::size_t current = 0;
+
+    while (used_count < filtered.size()) {
+      if (used[current]) {
+        current = first_unused();
+        if (current == used.size()) {
+          break;
+        }
+      }
+
+      const BoundaryEdge& edge = filtered[current];
+
+      used[current] = true;
+      ++used_count;
+
+      result.push_back(edge.a);
+
+      const uint64_t finish = point_key(edge.b);
+
+      auto it = outgoing.find(finish);
+      std::size_t next_edge = filtered.size();
+
+      if (it != outgoing.end()) {
+        for (std::size_t candidate : it->second) {
+          if (!used[candidate]) {
+            next_edge = candidate;
+            break;
+          }
+        }
+      }
+
+      if (next_edge != filtered.size()) {
+        current = next_edge;
+      } else {
+        current = first_unused();
+        if (current == used.size())
+          break;
+      }
+    }
+
+    rotate_to_scanline_start(result, bounds);
+    return result;
+  }
+};

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -571,6 +571,7 @@ void Init_cpp_polygon_finder() {
     rb_cstd_ofstream.define_method("closed?", [](OfstreamWrapper& self) { return self.closed(); });
     rb_cstd_ofstream.define_method("rewind",  [](OfstreamWrapper& self) { self.rewind(); });
     rb_cstd_ofstream.define_method("read",    [](OfstreamWrapper& self) { return self.read(); });
+    rb_cstd_ofstream.define_method("path",    [](OfstreamWrapper& self) { return self.path; });
 
   Data_Type<StreamingMerger> rb_cstreaming_merger = define_class<StreamingMerger, VerticalMerger>("CPPStreamingMerger");
     rb_cstreaming_merger.define_method("add_tile", [](StreamingMerger& self, Object rb_result, bool flush) {

data/lib/contrek/finder/concurrent/merger.rb

@@ -6,13 +6,19 @@ module Contrek
       attr_reader :tiles
       prepend Poolable
 
+      IGNORE_OPTIONS = [:versus]
+
       def initialize(options: {})
         @initialize_time = 0
         @current_x = 0
         @tiles = Queue.new
         @whole_tile = nil
+        @previous_boundary = nil
         @user_options = options
-        @options = {unsafe_mode: false}.merge(@user_options)
+        if (warn_options = @user_options.keys & IGNORE_OPTIONS).any?
+          warn "[Contrek WARNING] The given options '#{warn_options.join(",")}' will be ignored."
+        end
+        @options = {unsafe_mode: false}.merge(@user_options).except(*IGNORE_OPTIONS)
         unless safe?
           warn "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. Incompatible result options might lead to unexpected vector geometry."
         end
@@ -23,12 +29,13 @@ module Contrek
         raise ArgumentError, "All results must have the same height" if @height != result.metadata[:height] && safe?
         @options[:versus] ||= result.metadata[:versus]
         raise ArgumentError, "All results must have the same versus option" if @options[:versus] != result.metadata[:versus] && safe?
-        if safe? && result.metadata[:options].key?(:compress)
+        if safe? && result.metadata[:options]&.key?(:compress)
           if (result.metadata[:options][:compress].keys - [:uniq, :linear]).any?
             raise ArgumentError, "Result with not supported postprocessing compression mode"
           end
         end
 
+        validate(result) if safe?
         end_x = @current_x + result.metadata[:width]
 
         tile = Tile.new(
@@ -40,6 +47,9 @@ module Contrek
         tile.assign_raw_polygons!(result[:polygons])
 
         @tiles << tile
+
+        @previous_boundary = boundary_coordinates(result.polygons, end_x) if safe?
+
         @maximum_width = end_x
         @current_x = end_x - 1
       end
@@ -55,6 +65,25 @@ module Contrek
 
       private
 
+      def validate(result)
+        return unless @previous_boundary
+
+        current = boundary_coordinates(result.polygons, @current_x)
+        unless @previous_boundary == current
+          raise ArgumentError, "Tile boundary mismatch: adjacent tiles have different edge coordinates"
+        end
+      end
+
+      def boundary_coordinates(polygons, boundary_x)
+        coordinates = []
+        polygons.each do |polygon|
+          polygon[:outer].each do |point|
+            coordinates << point[:y] if point[:x] == boundary_x
+          end
+        end
+        coordinates.sort!
+      end
+
       def translate(result, offset)
         result.polygons.each do |polygon|
           polygon[:outer].each { |p| p[:x] += offset }

data/lib/contrek/finder/concurrent/vertical_merger.rb

@@ -5,10 +5,10 @@ module Contrek
     class VerticalMerger < Merger
       def add_tile(result)
         transpose(result)
+        adjust(result)
         if @tiles.size > 0
           translate(result, @current_x)
         end
-        adjust(result)
         super
       end
 
@@ -22,12 +22,32 @@ module Contrek
 
       private
 
+      # After transposing the polygon, select the correct starting vertex according to its versus.
+      # On the topmost scanline, use the rightmost vertex for counterclockwise polygons and the leftmost
+      # vertex for clockwise polygons.
+      # TODO: is useless the really rotate coords. Probably you can save rotation index here computed
+      #       using later in partition() to get the starting point sequence parts begins
       def adjust(result)
+        versus = result.metadata[:versus]
+        tile_width = result.metadata[:width]
+        number_of_tiles = @tiles.size
+
         result.polygons.each do |polygon|
-          polygon[:outer].rotate!(1)
-          polygon[:inner].each do |sequence|
-            sequence.rotate!(1)
+          bounds = polygon[:bounds]
+          needs_left = number_of_tiles > 0 && bounds[:min_x] == 0
+          needs_right = bounds[:max_x] == tile_width
+          next unless needs_left || needs_right
+          sequence = polygon[:outer]
+          index = nil
+          best_x = nil
+          sequence.each_with_index do |point, i|
+            next unless point[:y] == bounds[:min_y]
+            if index.nil? || ((versus == :a) ? point[:x] > best_x : point[:x] < best_x)
+              index = i
+              best_x = point[:x]
+            end
           end
+          sequence.rotate!(index) if index && index != 0
         end
       end
 

data/lib/contrek/finder/result.rb

@@ -8,6 +8,12 @@ module Contrek
       def points
         polygons
       end
+
+      def sort_polygons!
+        polygons.sort_by! do |polygon|
+          [polygon[:bounds][:min_y], polygon[:bounds][:min_x]]
+        end
+      end
     end
   end
 end

data/lib/contrek/shared/opencv_converter.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Shared
+    class OpencvConverter
+      CHAIN_DIR = [
+        [3, 4, 5],
+        [2, -1, 6],
+        [1, 0, 7]
+      ].freeze
+
+      CORNER_X = [0, 1, 1, 0].freeze
+      CORNER_Y = [1, 1, 0, 0].freeze
+
+      def contour_to_cell_boundary(contour, rect)
+        raw = []
+        n = contour.size
+
+        return raw if n == 0
+        if n == 1
+          x = contour[0][:x]
+          y = contour[0][:y]
+          return [
+            {x: x, y: y + 1},
+            {x: x + 1, y: y + 1},
+            {x: x + 1, y: y},
+            {x: x, y: y}
+          ]
+        end
+
+        n.times do |i|
+          previous = contour[(i - 1) % n]
+          current = contour[i]
+          next_p = contour[(i + 1) % n]
+
+          incoming = chain_direction(previous, current)
+          outgoing = chain_direction(current, next_p)
+
+          corner = incoming >> 1
+          last_corner = ((outgoing + 1) >> 1) & 3
+
+          loop do
+            raw << {
+              x: current[:x] + CORNER_X[corner],
+              y: current[:y] + CORNER_Y[corner]
+            }
+            break if corner == last_corner
+            corner = (corner + 1) & 3
+          end
+        end
+
+        # build path parts
+        edges = []
+        raw.size.times do |i|
+          a = raw[i]
+          b = raw[(i + 1) % raw.size]
+          next if a == b
+
+          key = [
+            [a[:x], a[:y]],
+            [b[:x], b[:y]]
+          ].sort
+          edges << {a: a, b: b, key: key}
+        end
+
+        counts = Hash.new(0)
+        edges.each do |edge|
+          counts[edge[:key]] += 1
+        end
+
+        kept = {}
+        edges.select! do |edge|
+          key = edge[:key]
+          next false if counts[key].even?
+          next false if kept[key]
+
+          kept[key] = true
+          true
+        end
+        return [] if edges.empty?
+
+        outgoing = Hash.new { |h, k| h[k] = [] }
+        edges.each_with_index do |edge, i|
+          outgoing[[edge[:a][:x], edge[:a][:y]]] << i
+        end
+
+        used = Array.new(edges.size, false)
+        result = []
+        current = 0
+
+        loop do
+          break if used.all?
+          if used[current]
+            current = used.index(false)
+            break unless current
+          end
+
+          edge = edges[current]
+          used[current] = true
+          result << edge[:a]
+          finish = edge[:b]
+          candidates = outgoing[[finish[:x], finish[:y]]]
+          next_edge = candidates.find { |index| !used[index] }
+
+          if next_edge
+            current = next_edge
+          else
+            current = used.index(false)
+            break unless current
+          end
+        end
+        rotate_to_scanline_start(result, rect)
+      end
+
+      def rect_to_bounds(rect)
+        {min_x: rect[:x],
+         max_x: rect[:x] + rect[:width],
+         min_y: rect[:y],
+         max_y: rect[:y] + rect[:height]}
+      end
+
+      private
+
+      def rotate_to_scanline_start(points, rect)
+        return points if points.empty?
+
+        min_y = rect[:y]
+        min_x = points.select { |p| p[:y] == min_y }.map { |p| p[:x] }.min
+        index = points.index { |p| p[:x] == min_x && p[:y] == min_y }
+        (index && index > 0) ? points.rotate(index) : points
+      end
+
+      def chain_direction(from, to)
+        dx = to[:x] - from[:x]
+        dy = to[:y] - from[:y]
+
+        raise ArgumentError, "Zero-length contour step" if dx == 0 && dy == 0
+        if dx.abs > 1 || dy.abs > 1
+          raise ArgumentError, "Non-adjacent contour step"
+        end
+
+        CHAIN_DIR[dx + 1][dy + 1]
+      end
+    end
+  end
+end

data/lib/contrek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contrek
-  VERSION = "1.4.3"
+  VERSION = "1.4.5"
 end

data/lib/contrek.rb

@@ -17,6 +17,7 @@ require "contrek/bitmaps/streaming/sources/ascii"
 require "contrek/bitmaps/streaming/sources/png"
 require "contrek/bitmaps/streaming/sources/tiff"
 require "contrek/shared/result"
+require "contrek/shared/opencv_converter"
 require "contrek/finder/bounds"
 require "contrek/finder/list"
 require "contrek/finder/list_entry"
@@ -50,7 +51,6 @@ require "contrek/finder/concurrent/streaming_merger"
 require "contrek/finder/concurrent/svg_streaming_merger"
 require "contrek/finder/concurrent/geo_json_streaming_merger"
 require "contrek/finder/concurrent/cursor"
-require "contrek/map/mercator_projection"
 require "contrek/matchers/matcher"
 require "contrek/matchers/matcher_hsb"
 require "contrek/matchers/value_not_matcher"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.4.5
 platform: ruby
 authors:
 - Emanuele Cesaroni
@@ -263,6 +263,8 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/shared/OpencvConverter.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/shared/OpencvConverter.h
 - ext/cpp_polygon_finder/cpp_polygon_finder.cpp
 - ext/cpp_polygon_finder/extconf.rb
 - lib/LICENSE-MIT.md
@@ -323,7 +325,6 @@ files:
 - lib/contrek/finder/node_cluster.rb
 - lib/contrek/finder/polygon_finder.rb
 - lib/contrek/finder/result.rb
-- lib/contrek/map/mercator_projection.rb
 - lib/contrek/matchers/matcher.rb
 - lib/contrek/matchers/matcher_hsb.rb
 - lib/contrek/matchers/value_not_matcher.rb
@@ -333,6 +334,7 @@ files:
 - lib/contrek/reducers/reducer.rb
 - lib/contrek/reducers/uniq_reducer.rb
 - lib/contrek/reducers/visvalingam_reducer.rb
+- lib/contrek/shared/opencv_converter.rb
 - lib/contrek/shared/result.rb
 - lib/contrek/version.rb
 homepage: https://github.com/runout77/contrek

data/lib/contrek/map/mercator_projection.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Map
-  class MercatorProjection
-    MERCATOR_RANGE = 256
-
-    class LatLng
-      attr_reader :lat, :lng
-      def initialize(lat:, lng:)
-        @lat = lat
-        @lng = lng
-      end
-    end
-
-    class Point
-      attr_accessor :x, :y
-      def initialize(x: 0, y: 0)
-        @x = x
-        @y = y
-      end
-    end
-
-    def initialize
-      @pixel_origin = Point.new(x: MERCATOR_RANGE / 2, y: MERCATOR_RANGE / 2)
-      @pixels_per_lon_degree = MERCATOR_RANGE.to_f / 360
-      @pixels_per_lon_radian = MERCATOR_RANGE.to_f / (2 * Math::PI)
-    end
-
-    def self.get_corners(center, zoom, map_width, map_height)
-      scale = 2**zoom
-      proj = Map::MercatorProjection.new
-      center_px = proj.from_lat_lng_to_point(lat_lng: center)
-      sw_point = Point.new(x: center_px.x - ((map_width / 2).to_f / scale), y: center_px.y + ((map_height / 2).to_f / scale))
-      sw_lat_lon = proj.from_point_to_lat_lng(sw_point)
-      ne_point = Point.new(x: center_px.x + ((map_width / 2).to_f / scale), y: center_px.y - ((map_height / 2).to_f / scale))
-      ne_lat_lon = proj.from_point_to_lat_lng(ne_point)
-      {
-        N: ne_lat_lon.lat,
-        E: ne_lat_lon.lng,
-        S: sw_lat_lon.lat,
-        W: sw_lat_lon.lng
-      }
-    end
-
-    def from_lat_lng_to_point(lat_lng:, opt_point: nil)
-      point = opt_point.nil? ? Point.new(x: 0, y: 0) : opt_point
-      origin = @pixel_origin
-      point.x = origin.x + (lat_lng.lng * @pixels_per_lon_degree)
-      siny = bound(Math.sin(degreesToRadians(lat_lng.lat)), -0.9999, 0.9999)
-      point.y = origin.y + (0.5 * Math.log((1 + siny) / (1 - siny)) * -@pixels_per_lon_radian)
-      point
-    end
-
-    def from_point_to_lat_lng(point)
-      origin = @pixel_origin
-      lng = (point.x - origin.x) / @pixels_per_lon_degree
-      lat_radians = (point.y - origin.y) / -@pixels_per_lon_radian
-      lat = radiansToDegrees(2 * Math.atan(Math.exp(lat_radians)) - (Math::PI / 2))
-      LatLng.new(lat: lat, lng: lng)
-    end
-
-    private
-
-    def degreesToRadians(deg)
-      deg * (Math::PI / 180)
-    end
-
-    def radiansToDegrees(rad)
-      rad / (Math::PI / 180)
-    end
-
-    def bound(value, opt_min, opt_max)
-      value = [value, opt_min].max if !opt_min.nil?
-      value = [value, opt_max].min if !opt_max.nil?
-      value
-    end
-  end
-end