contrek 1.4.5 → 1.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9350d60698a69dda805ede85e42b80fcc38022a361e52674fd2780d696e0f9ff
-  data.tar.gz: '08d164d2e53bb3c96e7212ac6bc9d46bb673de8f10bb950d43f3d66d0c86d793'
+  metadata.gz: 2d28d3b71b3d867f2899e2f49654decf11a0da8d5d7fa2fff5e08cb3eba265ab
+  data.tar.gz: acee94a59b33f775cd35f0bd28fa1f76b9cf1bce254cb51ff728c7f20b56dcb3
 SHA512:
-  metadata.gz: 1c6d0b73ab8affa0ed17aa3fd803f7aed81cec846db6edd3de5dfcec8103bf23c9e23484819c4a981a4cb0c46da18f0b169122124213a9b4417df108f54c468a
-  data.tar.gz: 57817011679288782915a50ca1adf4155b71732ab73e330e2ac696ea504d7204c08935a6b83487000faac68b37f38aff5b5761d78fc85aab7703752f2700d65f
+  metadata.gz: f43fbf8121cabf433296aaf9a2ea52a77a9564271a3a34a6954600ebc06004602b9a81a53ec784de49ec32e0a5dd70e015d405359627ce97c28df969d29c5c71
+  data.tar.gz: de2c37ca93f6096d202360995b752300a7c69680a50e9a06f2f4e23f9b983afc3ed51f06b05ef6e2a96f2066e1c477896b83cb1e6c0c184237ba8ba9a80ea31c

data/CHANGELOG.md

@@ -170,3 +170,9 @@ All notable changes to this project will be documented in this file.
 
 ## [1.4.5] - 2026-10-11
 - Added tile boundary validation for external geometries, with support for bypassing checks via `unsafe_mode: true`.
+
+## [1.4.6] - 2026-10-18
+- Added tile metadata, polygon bounds, ordering, and shared boundary validation for Ruby and C++ mergers, with `unsafe_mode: true` to bypass validation.
+
+## [1.4.7] - 2026-11-07
+- Added multiclass raster polygonization support, preserving class IDs throughout polygon extraction and tile merging, including streaming mergers.

data/Gemfile.lock

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

data/README.md

@@ -18,6 +18,8 @@ Besides extracting contours, Contrek can also determine the nesting relationship
 
 Several coordinate-compression algorithms are available to reduce polygon size after tracing. The library can also split the work across multiple threads by processing independent vertical stripes and merging the results afterwards into a single topologically consistent representation.
 
+Contrek also supports multiclass polygonization, extracting multiple raster classes in a single pass while preserving their identifiers throughout the merging process.
+
 The image below shows a simple example. Every non-white pixel is considered part of the traced region. The resulting outer contour is shown in red, while inner contours are shown in green.
 
 ![alt text](contrek.png "Contour tracing")
@@ -676,6 +678,27 @@ result = Contrek.contour!(
 
 The choice mainly affects how diagonally touching regions are interpreted.
 
+
+## Multiclass Polygonization
+
+Contrek supports multiclass polygonization, extracting contours for multiple pixel classes in a single processing pass.
+Enable it using the `multiclass: true` option:
+
+```ruby
+result = Contrek.contour!(
+  png_file_path: "classified.png",
+  options: {
+    finder: {
+      multiclass: true,
+      connectivity: 8
+    }
+  }
+)
+```
+
+Each polygon retains its original pixel value in the `class` attribute. Regions belonging to different classes remain separate, while regions of the same class can be merged across tile boundaries.
+Multiclass processing is supported by both the Ruby and native C++ implementations, including streaming mergers.
+
 ## Merging External Geometry
 
 Contrek's merger can process polygon data produced by external contour
@@ -726,17 +749,13 @@ extractors, provided that the input geometry follows the requirements below.
 
 ### 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.
+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.
 
-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.
 
-**Important:** Boundary validation does not verify all the Laws of the Tiles.
-Users supplying external geometries remain responsible for satisfying every
-requirement listed above.
+**Important:** Boundary validation prioritizes correctness over performance and introduce additional processing overhead. Experienced users who can guarantee that their input geometries satisfy the Laws of the Tiles can enable `unsafe_mode: true` to bypass validation entirely and achieve maximum merging performance. This option can also be useful during debugging to isolate merging issues from validation errors.
 
 # Results
 

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

@@ -413,7 +413,7 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
 
   SvgStreamingMerger merger(
     0,
-    {{"bounds", true},{"unsafe_mode", true}},
+    {{"bounds", true}, {"unsafe_mode", true}},
     &stream,
     source.width(),
     source.height());

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/FinderUtils.cpp

@@ -24,6 +24,7 @@ void FinderUtils::sanitize_options(pf_Options& options, const Options& incoming_
   options.named_sequences = incoming_options.get<bool>(
     "named_sequences", options.named_sequences);
   options.bounds = incoming_options.get<bool>("bounds", options.bounds);
+  options.multiclass = incoming_options.get<bool>("multiclass", options.multiclass);
   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>(

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.cpp

@@ -19,16 +19,15 @@
 
 static const int TURNER[2][2] = {{Node::OMAX, Node::OMIN}, {Node::TURN_MAX, Node::TURN_MIN}};
 
-Node::Node(int min_x, int max_x, int y, NodeCluster* cluster, char name)
-: cluster(cluster),
+Node::Node(int min_x, int max_x, int y, NodeCluster* cluster, char name, unsigned int class_id)
+: class_id(class_id),
+  cluster(cluster),
   min_x(min_x),
   max_x(max_x + 1) {
   this->y = y;
   this->name = name;
   this->tangs_count = 0;
   this->abs_x_index = 0;
-  this->down_indexer = 0;
-  this->up_indexer = 0;
   this->track = 0;
   this->outer_index = -1;
   this->inner_index = -1;
@@ -63,47 +62,45 @@ void Node::precalc_tangs_sequences(NodeCluster& cluster) {
   int upper_size = this->upper_end >= 0 ? (this->upper_end - this->upper_start + 1) : 0;
   this->tangs_sequence.reserve(lower_size + upper_size);
 
-  if (this->upper_end >= 0) {
-    this->up_indexer = -cluster.vert_nodes[y + T_UP][this->upper_start].abs_x_index;
-  }
   // --- CLOCKWISE (UP) ---
   for (int upper_pos = this->upper_start; upper_pos <= this->upper_end; upper_pos++) {
-    tangs_sequence.push_back(-(upper_pos + 1));
-  }
-  if (this->lower_end >= 0) {
-    this->down_indexer = (cluster.vert_nodes[y + T_DOWN][this->lower_start].abs_x_index + lower_size + upper_size - 1);
+    if (cluster.vert_nodes[y + T_UP][upper_pos].class_id == this->class_id) {
+      tangs_sequence.push_back(-(upper_pos + 1));
+    }
   }
+
   // --- COUNTER-CLOCKWISE (DOWN) ---
   for (int lower_pos = this->lower_end; lower_pos >= this->lower_start; lower_pos--) {
-    tangs_sequence.push_back(lower_pos);
+    if (cluster.vert_nodes[y + T_DOWN][lower_pos].class_id == this->class_id) {
+      tangs_sequence.push_back(lower_pos);
+    }
   }
   this->tangs_count = this->tangs_sequence.size();
 }
 
 Node* Node::my_next_inner(Node *last, int versus) {
-  unsigned int last_node_index;
-  if (last->y < this->y)       last_node_index = last->abs_x_index + this->up_indexer;
-  else            last_node_index = this->down_indexer - last->abs_x_index;
-  if (versus == Node::O) last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
-  else          last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
+  int virtual_index = (last->y < this->y) ? -(last->abs_x_index + 1) : last->abs_x_index;
+  auto it = std::find(this->tangs_sequence.begin(), this->tangs_sequence.end(), virtual_index);
+  size_t last_node_index = std::distance(this->tangs_sequence.begin(), it);
+  size_t size = this->tangs_sequence.size();
+  if (versus == Node::O) last_node_index = (last_node_index == 0) ? size - 1 : last_node_index - 1;
+  else                   last_node_index = (last_node_index == size - 1) ? 0 : last_node_index + 1;
   return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Node* Node::my_next_outer(Node *last, int versus) {
-  unsigned int last_node_index;
-  if (last->y < this->y) last_node_index = last->abs_x_index + this->up_indexer;
-  else                   last_node_index = this->down_indexer - last->abs_x_index;
-  if (versus == Node::O) last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
-  else                   last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
+  int virtual_index = (last->y < this->y) ? -(last->abs_x_index + 1) : last->abs_x_index;
+  auto it = std::find(this->tangs_sequence.begin(), this->tangs_sequence.end(), virtual_index);
+  size_t last_node_index = std::distance(this->tangs_sequence.begin(), it);
+  size_t size = this->tangs_sequence.size();
+  if (versus == Node::O) last_node_index = (last_node_index == size - 1) ? 0 : last_node_index + 1;
+  else                   last_node_index = (last_node_index == 0) ? size - 1 : last_node_index - 1;
   return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Point Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
-  int enter_to_index;
-  if (enter_to->y < this->y) enter_to_index = enter_to->abs_x_index + this->up_indexer;
-  else                       enter_to_index = this->down_indexer - enter_to->abs_x_index;
+  int tg_index = (enter_to->y < this->y) ? -(enter_to->abs_x_index + 1) : enter_to->abs_x_index;
 
-  int tg_index = this->tangs_sequence[enter_to_index];
   if (tg_index < 0) {
     Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
     if (mode == Node::A) {

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

@@ -86,7 +86,6 @@ class Node : public  Listable {
 
   int y;
   int abs_x_index;
-  int up_indexer, down_indexer;
   int tangs_count;
   int track;
   int outer_index, inner_index;
@@ -94,6 +93,7 @@ class Node : public  Listable {
   int upper_end   = -1;
   int lower_start = std::numeric_limits<int>::max();
   int lower_end   = -1;
+  unsigned int class_id;
   NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
   SmallVec tangs_sequence;
@@ -111,7 +111,7 @@ class Node : public  Listable {
 
  public:
   int min_x, max_x;
-  Node(int min_x, int max_x, int y, NodeCluster* cluster, char name);
+  Node(int min_x, int max_x, int y, NodeCluster* cluster, char name, unsigned int class_id = 0);
   void precalc_tangs_sequences(NodeCluster& cluster);
   void assign_lateral_inner_index(Node* my_prev_node, Node* end_node, int versus);
   bool processed = false;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.cpp

@@ -85,8 +85,8 @@ void NodeCluster::build_tangs_sequence() {
   }
 }
 
-Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset) {
-  vert_nodes[y].emplace_back(min_x, max_x, y, this, name);
+Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset, unsigned int class_id) {
+  vert_nodes[y].emplace_back(min_x, max_x, y, this, name, class_id);
 
   Node& node = vert_nodes[y].back();
   node.abs_x_index = vert_nodes[y].size() - 1;
@@ -104,8 +104,10 @@ Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset)
 
       while (it != up_nodes.end()) {
         if ((it->min_x - offset) > (node.max_x - 1)) break;
-        node.add_intersection(*it, it->abs_x_index);
-        it->add_intersection(node, node.abs_x_index);
+        if (!this->options->multiclass || node.class_id == it->class_id) {
+          node.add_intersection(*it, it->abs_x_index);
+          it->add_intersection(node, node.abs_x_index);
+        }
         ++it;
       }
     }
@@ -123,6 +125,7 @@ void NodeCluster::plot(int versus) {
     this->plot_sequence.clear();
     this->plot_sequence.push_back(root_node);
     Polygon poly;
+      poly.class_id = root_node->class_id;
       Node *next_node = nullptr;
       if ((root_node)->tangs_sequence.size() > 0)  // front() or back() on empty list is undefined
       { versus == Node::A ?

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

@@ -47,7 +47,7 @@ class NodeCluster {
   std::list<Polygon> polygons;
   NodeCluster(int h, int w, pf_Options *options);
   virtual ~NodeCluster();
-  Node* add_node(int min_x, int max_x, int y, char name, int offset);
+  Node* add_node(int min_x, int max_x, int y, char name, int offset, unsigned int class_id = 0);
   void calc_root_nodes();
   void build_tangs_sequence();
   void plot(int versus);

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

@@ -17,5 +17,6 @@ struct Polygon {
   std::vector<Point> outer;
   std::list<std::vector<Point>> inner;
   RectBounds bounds;
+  unsigned int class_id = 0;
   Polygon() : bounds(RectBounds::empty()) {}
 };

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

@@ -49,7 +49,7 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
 
   //= SCAN ==============//
   cpu_timer.start();
-  scan();
+  this->options.multiclass ? multiclass_scan() : scan();
   reports["scan"] = cpu_timer.stop();
   //=====================//
 
@@ -89,20 +89,33 @@ PolygonFinder::~PolygonFinder() {
 }
 
 void PolygonFinder::scan() {
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
-    int offset = options.connectivity_offset;
+  int bpp = this->source_bitmap->get_bytes_per_pixel();
+  int offset = options.connectivity_offset;
+
+  RGBMatcher* rgb_m = dynamic_cast<RGBMatcher*>(this->matcher);
+
+  if (bpp == 1) {
+    auto fetcher = [](const unsigned char* p) { return static_cast<unsigned int>(p[0]); };
+    if (rgb_m) run_loop(rgb_m, fetcher, offset);
+    else       run_loop(this->matcher, fetcher, offset);
+  } else {
+    auto fetcher = [](const unsigned char* p) { return *reinterpret_cast<const uint32_t*>(p); };
+    if (rgb_m) run_loop(rgb_m, fetcher, offset);
+    else       run_loop(this->matcher, fetcher, offset);
+  }
+}
 
-    RGBMatcher* rgb_m = dynamic_cast<RGBMatcher*>(this->matcher);
+void PolygonFinder::multiclass_scan() {
+  int bpp = this->source_bitmap->get_bytes_per_pixel();
+  int offset = options.connectivity_offset;
 
-    if (bpp == 1) {
+  if (bpp == 1) {
       auto fetcher = [](const unsigned char* p) { return static_cast<unsigned int>(p[0]); };
-      if (rgb_m) run_loop(rgb_m, fetcher, offset);
-      else       run_loop(this->matcher, fetcher, offset);
-    } else {
+      run_multiclass_loop(fetcher, offset);
+  } else {
       auto fetcher = [](const unsigned char* p) { return *reinterpret_cast<const uint32_t*>(p); };
-      if (rgb_m) run_loop(rgb_m, fetcher, offset);
-      else       run_loop(this->matcher, fetcher, offset);
-    }
+      run_multiclass_loop(fetcher, offset);
+  }
 }
 
 ProcessResult* PolygonFinder::process_info() {

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

@@ -53,6 +53,7 @@ struct pf_Options {
   bool named_sequences = false;
   bool unsafe_mode = false;
   bool bounds = false;
+  bool multiclass = false;
   bool deterministic = false;
   int processing_height = 0;
   int connectivity_offset = 0;
@@ -68,7 +69,8 @@ struct pf_Options {
 
 struct ProcessResult {
   int groups;
-  int width, height;
+  int width = 0;
+  int height = 0;
   int versus;
   int number_of_threads;
   bool has_bounds = false;
@@ -180,6 +182,7 @@ class PolygonFinder {
   pf_Options options;
   std::map<std::string, double> reports;
   void scan();
+  void multiclass_scan();
   CpuTimer cpu_timer;
 
   template <typename M, typename F>
@@ -279,6 +282,70 @@ class PolygonFinder {
     }
   }
 
+  template <typename F>
+  void run_multiclass_loop(F&& fetch_color, int offset) {
+    int img_h = this->processing_height;
+    int bpp = this->source_bitmap->get_bytes_per_pixel();
+
+    for (int y = 0; y < img_h; y++) {
+      const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
+      const unsigned char* p = row_ptr + (this->start_x * bpp);
+
+      int min_x = this->start_x;
+      bool has_color = false;
+      unsigned int current_color = 0;
+      int x = this->start_x;
+      if (bpp == 4) {
+        for (; x <= this->end_x - 4; x += 4) {
+          unsigned int c0 = fetch_color(p);
+          unsigned int c1 = fetch_color(p + 4);
+          unsigned int c2 = fetch_color(p + 8);
+          unsigned int c3 = fetch_color(p + 12);
+          p += 16;
+
+          if (!has_color) {
+            min_x = x; current_color = c0; has_color = true;
+          } else if (c0 != current_color) {
+            this->node_cluster->add_node(min_x, x - 1, y, current_color, offset, current_color);
+            min_x = x; current_color = c0;
+          }
+
+          if (c1 != current_color) {
+            this->node_cluster->add_node(min_x, x, y, current_color, offset, current_color);
+            min_x = x + 1; current_color = c1;
+          }
+
+          if (c2 != current_color) {
+            this->node_cluster->add_node(min_x, x + 1, y, current_color, offset, current_color);
+            min_x = x + 2; current_color = c2;
+          }
+
+          if (c3 != current_color) {
+            this->node_cluster->add_node(min_x, x + 2, y, current_color, offset, current_color);
+            min_x = x + 3; current_color = c3;
+          }
+        }
+      }
+
+      for (; x < this->end_x; x++) {
+        unsigned int color = fetch_color(p);
+        p += bpp;
+        if (!has_color) {
+          min_x = x;
+          current_color = color;
+          has_color = true;
+        } else if (color != current_color) {
+          this->node_cluster->add_node(min_x, x - 1, y, current_color, offset, current_color);
+          min_x = x;
+          current_color = color;
+        }
+      }
+      if (has_color) {
+        this->node_cluster->add_node(min_x, this->end_x - 1, y, current_color, offset, current_color);
+      }
+    }
+  }
+
  public:
   PolygonFinder(Bitmap *bitmap,
                 Matcher *matcher,

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

@@ -100,7 +100,7 @@ Tile* Cluster::merge_tiles() {
         }
         shape->clear_inner();
 
-        Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer.to_vector(), std::nullopt);
+        Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer.to_vector(), shape->outer_polyline->class_id(), std::nullopt);
         Shape* inserting_new_shape = tile->shapes_pool->acquire_shape(polyline, new_inners);
         new_shapes.push_back(inserting_new_shape);
         polyline->shape = inserting_new_shape;

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

@@ -102,11 +102,17 @@ void Cursor::traverse_outer(Part* start_part,
           return;
         }
         new_position->end_point()->tracked_outer = true;
-        int versus = act_part->versus();
+        int opposite_versus = -act_part->versus();
         auto& q_set = new_position->end_point()->queues();
+        auto* act_part_polyline = act_part->polyline();
         auto it = std::find_if(q_set.begin(), q_set.end(), [&](Queueable<Point>* q) {
           Part* p = static_cast<Part*>(q);
-          return (p->versus() == -versus) && p->polyline()->tile != act_part->polyline()->tile;
+          if (p->versus() != opposite_versus) {
+            return false;
+          }
+          auto* polyline = p->polyline();
+          return  polyline->tile != act_part_polyline->tile &&
+                  polyline->class_id() == act_part_polyline->class_id();
         });
 
         Part* part = nullptr;

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

@@ -60,6 +60,9 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Op
       if (this->options_.processing_height != 0) {
         base_arguments["processing_height"] = this->options_.processing_height;
       }
+      if (this->options_.multiclass) {
+        base_arguments["multiclass"] = true;
+      }
 
       CpuTimer t;
       t.start();

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

@@ -76,10 +76,8 @@ class GeoJsonStreamingMerger : public StreamingMerger {
  public:
   GeoJsonStreamingMerger(int number_of_threads,
                          const Options& options,
-                         std::ofstream* stream_to,
-                         unsigned int pixel_value)
-      : StreamingMerger(number_of_threads, options, stream_to),
-        target_value(pixel_value) {
+                         std::ofstream* stream_to)
+      : StreamingMerger(number_of_threads, options, stream_to) {
     configure_point_writer(options);
   }
 
@@ -90,7 +88,7 @@ class GeoJsonStreamingMerger : public StreamingMerger {
     }
     is_first_feature = false;
 
-    *stream << "{\"type\":\"Feature\",\"properties\":{\"PixelVal\":" << target_value
+    *stream << "{\"type\":\"Feature\",\"properties\":{\"PixelVal\":" << polygon.class_id
             << "},\"geometry\":{\"type\":\"Polygon\",\"coordinates\":[[";
     const std::vector<Point>& points = polygon.outer;
     const size_t points_size = points.size();

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

@@ -12,6 +12,7 @@
 #include <vector>
 #include <algorithm>
 #include <list>
+#include <memory>
 #include "Merger.h"
 
 Merger::Merger(int number_of_threads, const Options& options)
@@ -19,7 +20,9 @@ Merger::Merger(int number_of_threads, const Options& options)
   if (options.contains("versus")) {
     std::cerr << "[Contrek WARNING] The given options 'versus' will be ignored." << std::endl;
   }
-  if (!this->safe()) {
+  if (safe()) {
+    validator_ = std::make_unique<MergerValidator>(*this);
+  } else {
     std::cerr << "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. "
               << "Incompatible result options might lead to unexpected vector geometry.\n";
   }
@@ -30,7 +33,10 @@ bool Merger::safe() {
 }
 
 void Merger::add_tile(ProcessResult& result)
-{ if (this->height == 0) {
+{ if (validator_) {
+    validator_->validate_metadata(result);
+  }
+  if (this->height == 0) {
     this->height = result.height;
   } else {
     if (result.height != this->height && safe()) {
@@ -51,17 +57,15 @@ void Merger::add_tile(ProcessResult& result)
       }
     }
   }
-  if (safe()) validate(result);
 
   int end_x = this->current_x + result.width;
+  if (validator_) {
+    validator_->validate(result, this->current_x, end_x);
+  }
   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;
 }
@@ -84,26 +88,3 @@ void Merger::translate(ProcessResult& result, int 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

@@ -11,7 +11,9 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <memory>
 #include "Finder.h"
+#include "MergerValidator.h"
 #include "../Options.h"
 
 class Merger : public Finder {
@@ -24,7 +26,5 @@ 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_;
+  std::unique_ptr<MergerValidator> validator_;
 };