contrek 1.4.6 → 1.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6ed7af7c2661396d55b6ddacd89dfc6c08c4c54744d1443d03a6ba533605ed4
-  data.tar.gz: 3308bedea2f5e89fe8031a65c404c250490542142101dba32fd09f8510cb8cfb
+  metadata.gz: 2d28d3b71b3d867f2899e2f49654decf11a0da8d5d7fa2fff5e08cb3eba265ab
+  data.tar.gz: acee94a59b33f775cd35f0bd28fa1f76b9cf1bce254cb51ff728c7f20b56dcb3
 SHA512:
-  metadata.gz: 250b0ed1bce589beaae764e03226206853f9e9c3bb356fe3bf827cd25c69d72f33ad820f3afa5d9d31aa83e628e67dd8c4500782dcdb668f44b0e098932f6c4f
-  data.tar.gz: 7cf17a172afd9ec9b1788f2abe1779421d204886b99fd54e4729fbf9b616cc3968bb7586cafa5b17da6b5cbcf9641e3f210ee6d3d320e4be67e945022964af13
+  metadata.gz: f43fbf8121cabf433296aaf9a2ea52a77a9564271a3a34a6954600ebc06004602b9a81a53ec784de49ec32e0a5dd70e015d405359627ce97c28df969d29c5c71
+  data.tar.gz: de2c37ca93f6096d202360995b752300a7c69680a50e9a06f2f4e23f9b983afc3ed51f06b05ef6e2a96f2066e1c477896b83cb1e6c0c184237ba8ba9a80ea31c

data/CHANGELOG.md

@@ -173,3 +173,6 @@ All notable changes to this project will be documented in this file.
 
 ## [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.6)
+    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

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;
@@ -181,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>
@@ -280,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/Polyline.cpp

@@ -17,10 +17,11 @@
 #include "Tile.h"
 #include "Shape.h"
 
-Polyline::Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds)
+Polyline::Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds, unsigned int class_id)
 : tile(tile),
   shape_pool(shape_pool),
-  raw_(std::move(polygon))
+  raw_(std::move(polygon)),
+  class_id_(class_id)
 { if (bounds.has_value()) {
     min_x =  bounds->min_x;
     max_x_ = bounds->max_x;

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

@@ -29,7 +29,7 @@ class InnerPolyline;
 class Polyline : public Partitionable {
  public:
   using Partitionable::Partitionable;
-  Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt);
+  Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt, unsigned int class_id = 0);
   enum Flags : uint32_t {
     TRACKED_OUTER = 1 << 0
   };
@@ -47,6 +47,7 @@ class Polyline : public Partitionable {
   int max_y() const { return max_y_; }
   int min_y() const { return min_y_; }
   int max_x() const { return max_x_; }
+  unsigned int class_id() const { return class_id_; }
   void clear();
   bool is_empty();
   bool any_ancients = false;
@@ -63,5 +64,6 @@ class Polyline : public Partitionable {
   void find_boundary();
   uint32_t flags_ = 0;
   int name;
+  unsigned int class_id_;
   std::string named_;
 };

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

@@ -49,6 +49,7 @@ std::string Shape::name() {
 Polygon Shape::to_raw_polygon(bool bounds) {
   Polygon poly;
   poly.outer = this->outer_polyline->raw();
+  poly.class_id = this->outer_polyline->class_id();
   if (bounds) {
     this->outer_polyline->fill_bounds(poly.bounds);
   }

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

@@ -19,8 +19,8 @@ Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<Inne
   return shape;
 }
 
-Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
-  return this->polylines.acquire(this, tile, std::move(polygon), bounds);
+Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, unsigned int class_id, const std::optional<RectBounds>& bounds = std::nullopt) {
+  return this->polylines.acquire(this, tile, std::move(polygon), bounds, class_id);
 }
 
 InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point> coords, Shape* shape) {

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

@@ -29,7 +29,7 @@ class ShapePool {
   Shape* acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   InnerPolyline* acquire_inner_polyline(std::vector<Point> coords, Shape* s);
   InnerPolyline* acquire_inner_polyline(Sequence* seq);
-  Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds);
+  Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, unsigned int class_id, const std::optional<RectBounds>& bounds);
   void set_owner(Tile* tile);
   void detach_shape();
   void detach_polyline();

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

@@ -60,7 +60,7 @@ void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const st
   std::unordered_map<int, Shape*> shapes_map;
   int polyline_index = 0;
   for (const auto& raw_polyline : raw_polylines)
-  { Polyline* polyline = this->shapes_pool->acquire_polyline(this, raw_polyline.outer, raw_polyline.bounds);
+  { Polyline* polyline = this->shapes_pool->acquire_polyline(this, raw_polyline.outer, raw_polyline.class_id, raw_polyline.bounds);
     std::vector<InnerPolyline*> inner_polylines_list;
     for (auto& raw_points : raw_polyline.inner) {
       inner_polylines_list.push_back(this->shapes_pool->acquire_inner_polyline(raw_points, nullptr));

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -277,6 +277,9 @@ class To_Ruby<ProcessResult*>
         poly_hash[Symbol("bounds")] = bounds_hash;
       }
 
+      if(pr->options.contains("multiclass")) {
+        poly_hash[Symbol("class")] = x.class_id;
+      }
       out.push(poly_hash);
     }
     rr->polygons = out;
@@ -317,6 +320,10 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
   for (size_t i = 0; i < rb_polygons.size(); ++i) {
     Rice::Hash rb_poly = (Rice::Hash)rb_polygons[i];
     Polygon poly;
+    Rice::Object rb_class = rb_poly[Symbol("class")];
+    if (!rb_class.is_nil()) {
+      poly.class_id = detail::From_Ruby<unsigned int>().convert(rb_class.value());
+    }
     // BOUNDS
     Rice::Object rb_bounds_obj = rb_poly[Symbol("bounds")];
     if (!rb_bounds_obj.is_nil()) {
@@ -382,10 +389,9 @@ SvgStreamingMerger* create_svg_streaming_merger(Object self,
 GeoJsonStreamingMerger* create_geo_json_streaming_merger(Object self,
                                          int number_of_threads,
                                          Options options,
-                                         Object stream_obj,
-                                         int pixel_val) {
+                                         Object stream_obj) {
   OfstreamWrapper* wrapper = Rice::detail::From_Ruby<OfstreamWrapper*>().convert(stream_obj.value());
-  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream(), pixel_val);
+  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream());
 }
 
 OfstreamWrapper* create_ofstream(Object self, std::string path) {

data/lib/contrek/cpp/cpp_geo_json_concurrent_streaming_merger.rb

@@ -3,8 +3,8 @@
 module Contrek
   module Cpp
     class CPPGeoJsonConcurrentStreamingMerger < CPPGeoJsonStreamingMerger
-      def self.new(stream_to:, number_of_threads: 0, options: nil, pixel_val: 0)
-        super(number_of_threads, options, stream_to, pixel_val)
+      def self.new(stream_to:, number_of_threads: 0, options: nil)
+        super(number_of_threads, options, stream_to)
       end
     end
   end

data/lib/contrek/cpp/cpp_result.rb

@@ -23,7 +23,8 @@ module Contrek
         @to_points ||= raw_list.map do |polygon|
           {bounds: (polygon[:bounds] if polygon.key?(:bounds)),
            outer: self.class.to_points(polygon[:outer]),
-           inner: polygon[:inner].map { |s| self.class.to_points(s) }}.compact
+           inner: polygon[:inner].map { |s| self.class.to_points(s) },
+           class: (polygon[:class] if polygon.key?(:class))}.compact
         end
       end
 

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

@@ -69,7 +69,7 @@ module Contrek
               end.real
               shape.clear_inner!
 
-              polyline = Polyline.new(tile: tile, polygon: new_outer.to_a)
+              polyline = Polyline.new(tile: tile, polygon: new_outer.to_a, class_id: shape.outer_polyline.class_id)
               inserting_new_shape = Shape.init_by(polyline, new_inners)
               new_shapes << inserting_new_shape
               polyline.shape = inserting_new_shape

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

@@ -91,7 +91,9 @@ module Contrek
               new_position.end_point.tracked_outer = true
               versus = act_part.versus
               part = new_position.end_point.queues.find do |p|
-                (p.versus == -versus) && p.polyline.tile != act_part.polyline.tile
+                (p.versus == -versus) &&
+                  p.polyline.tile != act_part.polyline.tile &&
+                  p.polyline.class_id == act_part.polyline.class_id
               end
               if part
                 if all_parts[-2] != part

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

@@ -55,7 +55,8 @@ module Contrek
                   versus: current_versus,
                   bounds: true,
                   treemap: @options[:treemap],
-                  connectivity: @options[:connectivity]
+                  connectivity: @options[:connectivity],
+                  multiclass: @options[:multiclass]
                 }.compact,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x]

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

@@ -3,11 +3,10 @@
 module Contrek
   module Concurrent
     class GeoJsonStreamingMerger < StreamingMerger
-      def initialize(stream_to:, pixel_val:, options: {})
-        @pixel_val = pixel_val
+      def initialize(stream_to:, options: {})
         @point_converter = self.class.coordinates_converter(options[:geo_localization])
 
-        super(stream_to:, options:)
+        super
       end
 
       def write_header
@@ -35,7 +34,7 @@ module Contrek
         end
         feature_hash = {
           type: "Feature",
-          properties: {PixelVal: @pixel_val},
+          properties: {PixelVal: polygon[:class]},
           geometry: {
             type: "Polygon",
             coordinates: polygon_coordinates

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

@@ -7,10 +7,10 @@ module Contrek
 
       TRACKED_OUTER = 1 << 0
 
-      attr_reader :raw, :name, :min_y, :max_y
+      attr_reader :raw, :name, :min_y, :max_y, :class_id
       attr_accessor :shape, :tile, :any_ancients, :inside_inner_polyline
 
-      def initialize(tile:, polygon:, shape: nil, bounds: nil, force_named: nil)
+      def initialize(tile:, polygon:, shape: nil, bounds: nil, force_named: nil, class_id: 0)
         @tile = tile
         @name = tile.shapes.count
         @named = force_named
@@ -19,6 +19,7 @@ module Contrek
         @flags = 0
         @any_ancients = false
         @inside_inner_polyline = nil
+        @class_id = class_id
 
         if bounds.nil?
           find_boundary

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

@@ -40,8 +40,9 @@ module Contrek
         "Shape (outer_polyline = #{outer_polyline.named}, children count = #{@children_shapes.size}"
       end
 
-      def to_raw_polygon(bounds: false)
+      def to_raw_polygon(bounds: false, multiclass: false)
         {bounds: (outer_polyline.get_bounds if bounds),
+         class: (outer_polyline.class_id if multiclass),
          outer: outer_polyline.raw,
          inner: inner_polylines.map(&:raw)}.compact
       end

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

@@ -37,7 +37,7 @@ module Contrek
           bounds = shape.outer_polyline.get_bounds
           if flush || bounds[:max_x] < safe_boundary_x
             @moved += 1
-            polygon = shape.to_raw_polygon
+            polygon = shape.to_raw_polygon(multiclass: true)
             polygons_to_stream << polygon
             false
           else

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

@@ -57,7 +57,8 @@ module Contrek
 
       def to_raw_polygons
         bounds = @finder.options[:bounds]
-        @shapes.map { |s| s.to_raw_polygon(bounds:) }
+        multiclass = @finder.options[:multiclass]
+        @shapes.map { |s| s.to_raw_polygon(bounds:, multiclass:) }
       end
 
       def compute_treemap
@@ -93,7 +94,13 @@ module Contrek
         shapes_map = {}
         raw_polylines.each_with_index do |raw_polyline, polyline_index|
           shape = Shape.new.tap do |shape|
-            shape.outer_polyline = Polyline.new(tile: self, polygon: raw_polyline[:outer], shape: shape, bounds: raw_polyline[:bounds])
+            shape.outer_polyline = Polyline.new(
+              tile: self,
+              polygon: raw_polyline[:outer],
+              shape: shape,
+              bounds: raw_polyline[:bounds],
+              class_id: raw_polyline[:class] || 0
+            )
             shape.inner_polylines = raw_polyline[:inner].map { |raw| InnerPolyline.new(shape: shape, raw_coordinates: raw) }
           end
           @shapes << shape

data/lib/contrek/finder/node.rb

@@ -6,7 +6,7 @@ module Contrek
       include Listable
 
       attr_reader :min_x, :max_x, :y, :name, :tangs_sequence, :tangs_count, :data_pointer,
-        :upper_start, :upper_end, :lower_start, :lower_end
+        :upper_start, :upper_end, :lower_start, :lower_end, :class_id
       attr_accessor :track, :abs_x_index, :outer_index, :inner_index, :inner_left_index, :inner_right_index
 
       T_UP = -1
@@ -27,8 +27,9 @@ module Contrek
       OUTER = 0
       INNER = 1
 
-      def initialize(cluster, min_x, max_x, y, name, connectivity_offset = 0)
+      def initialize(cluster, min_x, max_x, y, name, connectivity_offset = 0, class_id = 0)
         @name = name
+        @class_id = class_id
         @min_x = min_x
         @max_x = max_x + 1
         @y = y
@@ -37,8 +38,6 @@ module Contrek
         @track = 0
         @abs_x_index = 0
         @data_pointer = cluster.lists.get_data_pointer
-        @up_indexer = 0
-        @down_indexer = 0
         @outer_index = -1
         @inner_index = -1
         @inner_left_index = -1
@@ -81,11 +80,8 @@ module Contrek
       end
 
       def my_next(last, versus, mode)
-        last_node_index = if last.y < y
-          last.abs_x_index + @up_indexer
-        else
-          @down_indexer - last.abs_x_index
-        end
+        virtual_index = (last.y < y) ? -(last.abs_x_index + 1) : last.abs_x_index
+        last_node_index = @tangs_sequence.index(virtual_index)
 
         case mode
         when :outer
@@ -117,13 +113,8 @@ module Contrek
       end
 
       def coords_entering_to(enter_to, enter_mode, tracking)
-        enter_to_index = if enter_to.y < y
-          enter_to.abs_x_index + @up_indexer
-        else
-          @down_indexer - enter_to.abs_x_index
-        end
+        tg_index = (enter_to.y < y) ? -(enter_to.abs_x_index + 1) : enter_to.abs_x_index
 
-        tg_index = @tangs_sequence[enter_to_index]
         if tg_index < 0
           node_up = @cluster.vert_nodes[y + T_UP][-(tg_index + 1)]
           if enter_mode == :a
@@ -166,20 +157,19 @@ module Contrek
 
       def precalc_tangs_sequences(cluster:)
         @tangs_sequence = []
-        @up_indexer = -cluster.vert_nodes[@y + T_UP][@upper_start].abs_x_index if @upper_end >= 0
         if @upper_end >= 0
           (@upper_start..@upper_end).each do |upper_pos|
-            @tangs_sequence << -(upper_pos + 1)
+            if cluster.vert_nodes[@y + T_UP][upper_pos].class_id == class_id
+              @tangs_sequence << -(upper_pos + 1)
+            end
           end
         end
-        if @lower_end >= 0
-          lower_size = (@lower_end >= 0) ? (@lower_end - @lower_start + 1) : 0
-          upper_size = (@upper_end >= 0) ? (@upper_end - @upper_start + 1) : 0
-          @down_indexer = (cluster.vert_nodes[@y + T_DOWN][@lower_start].abs_x_index + lower_size + upper_size - 1)
-        end
+
         if @lower_end >= 0
           @lower_end.downto(@lower_start).each do |lower_pos|
-            @tangs_sequence << lower_pos
+            if cluster.vert_nodes[@y + T_DOWN][lower_pos].class_id == class_id
+              @tangs_sequence << lower_pos
+            end
           end
         end
         @tangs_count = tangs_sequence.size

data/lib/contrek/finder/node_cluster.rb

@@ -57,6 +57,8 @@ module Contrek
         versus = @options[:versus]
         inner_v = VERSUS_INVERTER[versus]
         index_order = 0
+        multiclass = @options[:multiclass]
+
         while @root_nodes.size > 0
           root_node = @root_nodes.shift
 
@@ -110,7 +112,12 @@ module Contrek
           draw_sequence(bitmap, "X") unless bitmap.nil?
 
           if @sequence_coords.any?
-            @polygons << {outer: @sequence_coords, inner: [], bounds: (bounds.to_h if @options[:bounds])}.compact
+            @polygons << {
+              outer: @sequence_coords,
+              inner: [],
+              bounds: (bounds.to_h if @options[:bounds]),
+              class: (root_node.class_id if multiclass)
+            }.compact
             @sequences << @plot_sequence
 
             @count = 0
@@ -332,6 +339,7 @@ module Contrek
       end
 
       def add_node(node, offset)
+        multiclass = options[:multiclass]
         @nodes += 1
         node.abs_x_index = @vert_nodes[node.y].size
 
@@ -348,15 +356,19 @@ module Contrek
               up_node = up_nodes[index]
               if ((up_node.max_x - 1) + offset) >= node.min_x
                 if (up_node.min_x - offset) <= (node.max_x - 1)
-                  node.add_intersection(up_node, index)
-                  up_node.add_intersection(node, node.abs_x_index)
+                  unless multiclass && node.class_id != up_node.class_id
+                    node.add_intersection(up_node, index)
+                    up_node.add_intersection(node, node.abs_x_index)
+                  end
                 end
                 return if (index += 1) == up_nodes_count
                 loop do
                   up_node = up_nodes[index]
                   if (up_node.min_x - offset) <= (node.max_x - 1)
-                    node.add_intersection(up_node, index)
-                    up_node.add_intersection(node, node.abs_x_index)
+                    unless multiclass && node.class_id != up_node.class_id
+                      node.add_intersection(up_node, index)
+                      up_node.add_intersection(node, node.abs_x_index)
+                    end
                   else
                     return
                   end

data/lib/contrek/finder/polygon_finder.rb

@@ -21,7 +21,7 @@ module Contrek
 
         # 1 finds matching blocks
         @reports[:scan] = Benchmark.measure do
-          scan
+          @options[:multiclass] ? multiclass_scan : scan
         end
 
         # 2 builds relational spatially tree map
@@ -129,6 +129,34 @@ module Contrek
         end
       end
 
+      def multiclass_scan
+        offset = (@node_cluster.options[:connectivity] == 8) ? 1 : 0
+        current_color = nil
+        min_x = start_x
+        current_y = nil
+        last_x = end_x - 1
+
+        @source_bitmap.scan(start_x: start_x, end_x: end_x, end_y: @processing_height) do |x, y, color|
+          if current_y != y || (current_color && color != current_color)
+            unless current_color.nil?
+              Contrek::Finder::Node.new(@node_cluster, min_x, ((current_y == y) ? x - 1 : last_x), current_y, current_color, offset, current_color.ord)
+            end
+            min_x = x if current_y == y
+          end
+
+          if current_y != y
+            current_y = y
+            min_x = x
+          end
+
+          current_color = color
+          if x == last_x && current_color
+            Contrek::Finder::Node.new(@node_cluster, min_x, last_x, current_y, current_color, offset, current_color.ord)
+            current_color = nil
+          end
+        end
+      end
+
       def format_benchmarks
         r = {}
         total = 0

data/lib/contrek/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.4.6
+  version: 1.4.7
 platform: ruby
 authors:
 - Emanuele Cesaroni