contrek 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0d1a364ff39a11f632f5f57d99970448173727e8f5a42e84e1b334521c1e1d1
-  data.tar.gz: 24a52785c8735e9fce60931a1ffc1bd974aa5a50a6fb755229cd25dd5263cab3
+  metadata.gz: 862b863c602031251fedc2dc18a59c9bd270d91acff25761c24164e34e8952e9
+  data.tar.gz: 97f18e804accd2d6ae11f95223c95eebe198eafb07c745261d1110f5edf5eae4
 SHA512:
-  metadata.gz: e321b716a5c16d6c75f24bc6bcdebc302a6ea9785009bad93905321ebc7a97ef29048fb1c6e4e0557611ec9d096dee874bd1ff37f66ad2763c4dacd7176b0ce4
-  data.tar.gz: 38608a89ed8ee0c43a985bf8057d07b860acd524d2e8c0022651e5ec3fdcc8f13e3d515e309d436ad261203e00a58b901dd6cf141bfbeeb93520f7937ccdb4b8
+  metadata.gz: d3d9ce7c0b5ae1a3c62f91480d63856312d89334f181899ccc2ff304c3fef983578838484da18f865ce1d50ea3cb3c291ce49fef1b01dcfaf397ab688bed9e37
+  data.tar.gz: c8f7aade05577e132829e7ffcc6af5e637aa879bb6972f4ba8566c8db7d11b641862e32a170c39db4b8ab57666996a4639ffd3f516ba85712266b7ffd82ac276

data/CHANGELOG.md

@@ -23,3 +23,9 @@ All notable changes to this project will be documented in this file.
 ## [1.0.7] - 2026-01-10
 ### Added
 - Optimized C++/Ruby data transfer: Implemented NumPy-compatible binary serialization for coordinate outputs. This reduces serialization overhead and significantly increases data throughput between the C++ core and the Ruby interface.
+
+## [1.0.8] - 2026-01-25
+### Changed
+- Fixed ARGB/RGBA format discrepancies between Ruby and C++.
+- Updated the multithreading-side algorithm for rejoining mono-connected orphan polygons to other orphan polygons. The algorithm can now identify them and defer their processing within the pipeline.
+- Improved, on the multithreading side, the polygon intersection detection mechanism; the geometric approach has been dropped in favor of a purely topological one.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.0.7)
+    contrek (1.0.8)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -1,5 +1,5 @@
 # Contrek
-Contrek is a Ruby gem with a C++ core for fast contour tracing and edge detection in PNG images. It extracts polygonal contours from bitmap shapes, enabling image processing, shape analysis, and raster-to-vector workflows such as PNG to SVG conversion. Manages png images usign libspng (version 0.7.4) library. May work multithreading.
+Contrek is a Ruby gem with a C++ core for fast contour tracing and edge detection in PNG images. Unlike standard geometric tracers, it employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
 
 ## About Contrek library
 Contrek (**con**tour **trek**king) simply scans your png bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.

data/ext/cpp_polygon_finder/PolygonFinder/Makefile

@@ -2,15 +2,15 @@ CXX = g++
 CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g \
            -fno-omit-frame-pointer -fsanitize=address,undefined \
            -O0
-LDFLAGS = -lpng -pthread -lz -fsanitize=address,undefined
+LDFLAGS = -pthread -lz -fsanitize=address,undefined
 
 # valgrinf or perf setup
-#CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -fno-omit-frame-pointer -march=native -DNDEBUG -O3
-#LDFLAGS = -lpng -pthread -lz
+# CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -fno-omit-frame-pointer -march=native -DNDEBUG -O3
+# LDFLAGS = -lpng -pthread -lz
 
 # best performances
 CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -march=native -DNDEBUG -Ofast -flto
-LDFLAGS = -lpng -pthread -lz -flto=auto
+LDFLAGS = -pthread -lz -flto=auto
 
 SRC = $(shell find src -name '*.cpp')
 C_SRC = $(shell find src -name 'spng.c')

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

@@ -107,7 +107,7 @@ void Tests::test_c()
   Point* p2 = new Point({2, 2});
   Point* p3 = new Point({3, 3});
 
-  Hub* hub = new Hub(4, 4);  // coordinate 0 -> 3 sia x che y, matrice di 4 * 4
+  Hub* hub = new Hub(4, 0, 3);
 
   Position* pos1 = new Position(hub, p1);
   Position* pos2 = new Position(hub, p2);
@@ -176,15 +176,16 @@ void Tests::test_e()
   cpu_timer.start();
   FastPngBitmap png_bitmap("images/sample_10240x10240.png");
   // FastPngBitmap png_bitmap("images/sample_1024x1024.png");
-  std::cout << "immagine =" << cpu_timer.stop() << std::endl;
+  std::cout << "image reading time =" << cpu_timer.stop() << std::endl;
 
-  int color = png_bitmap.value_at(0, 0);
-  std::cout << "color =" << color << std::endl;
+  int color = png_bitmap.rgb_value_at(0, 0);
+  std::cout << "color = " << color << std::endl;
   RGBNotMatcher not_matcher(color);
 
   std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--number_of_tiles=2"};
   Finder pl(2, &png_bitmap, &not_matcher, &arguments);
   ProcessResult *o = pl.process_info();
   o->print_info();
+  std::cout << "polygons =" << o->groups << std::endl;
   delete o;
 }

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

@@ -70,12 +70,10 @@ char FastPngBitmap::value_at(int x, int y) {
   return(0);
 }
 
+// source image format RGBA => returning uint ABGR
 unsigned int FastPngBitmap::rgb_value_at(int x, int y) {
-  int32_t index = ((y * width) + x) * 4;
-  unsigned int color;
-  unsigned char *red = &image[index];
-  std::memcpy(&color, red, 3);
-  return(color);
+  uint32_t index = (uint32_t(y) * width + x) * 4;
+  return *reinterpret_cast<const uint32_t*>(&image[index]);
 }
 
 const unsigned char* FastPngBitmap::get_row_ptr(int y) const {

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

@@ -89,7 +89,7 @@ void PolygonFinder::scan() {
       if (rgb_m) run_loop(rgb_m, fetcher);
       else       run_loop(this->matcher, fetcher);
     } else {
-      auto fetcher = [](const unsigned char* p) { return p[0] | (p[1] << 8) | (p[2] << 16); };
+      auto fetcher = [](const unsigned char* p) { return *reinterpret_cast<const uint32_t*>(p); };
       if (rgb_m) run_loop(rgb_m, fetcher);
       else       run_loop(this->matcher, fetcher);
     }

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

@@ -16,10 +16,10 @@
 #include "Cursor.h"
 #include "../../CpuTimer.h"
 
-Cluster::Cluster(Finder *finder, int height, int width)
+Cluster::Cluster(Finder *finder, int height, int start_x, int end_x)
   : finder(finder)
 { tiles_.reserve(2);  // only two (left|right)
-  this->hub_ = new Hub(height, width);
+  this->hub_ = new Hub(height, start_x, end_x);
 }
 
 Cluster::~Cluster() {

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

@@ -20,7 +20,7 @@ class Cluster {
   std::vector<Tile*> tiles_;
   Hub *hub_ = nullptr;
  public:
-  Cluster(Finder *finder, int height, int width);
+  Cluster(Finder *finder, int height, int start_x, int end_x);
   virtual ~Cluster();
   void add(Tile* tile);
   Tile* merge_tiles();

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

@@ -159,13 +159,36 @@ std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
     }
   }
 
+  std::vector<Shape*> to_delay;
+  to_delay = connect_missings(missing_shapes);
+  while (!to_delay.empty()) {
+    to_delay = connect_missings(to_delay);
+  }
+
+  retme = collect_inner_sequences(outer_seq);
+  for (Polyline* polyline : polylines_sequence) {
+    polyline->turn_on(Polyline::TRACKED_INNER);
+  }
+  return(retme);
+}
+
+std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> missing_shapes) {
+  std::vector<Shape*> delay_shapes;
+
   for (Polyline *polyline : polylines_sequence)
   { for (Shape *missing_shape : missing_shapes)
     { Polyline* outer_polyline = missing_shape->outer_polyline;
-      if (!polyline->vert_intersect(*outer_polyline)) continue;
-      std::vector<Point*> intersection = polyline->intersection(outer_polyline);
+      if ( outer_polyline->is_on(Polyline::TRACKED_OUTER)  ||
+           !polyline->vert_intersect(*outer_polyline)) continue;
+      std::vector<std::pair<int, int>> intersection = polyline->intersection(outer_polyline);
       if (intersection.size() > 0)
-      { auto [inject_sequences_left, inject_sequences_right] = polyline->sew(intersection, outer_polyline);
+      { auto result = polyline->sew(intersection, outer_polyline);
+        if (!result) {
+          delay_shapes.push_back(missing_shape);
+          continue;
+        }
+        auto& inject_sequences_left = result->first;
+        auto& inject_sequences_right = result->second;
         auto combined = combine(inject_sequences_right, inject_sequences_left);
         for (auto& sewn_sequence : combined) {
           std::vector<Point*> unique;
@@ -205,11 +228,8 @@ std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
       }
     }
   }
-  retme = collect_inner_sequences(outer_seq);
-  for (Polyline* polyline : polylines_sequence) {
-    polyline->turn_on(Polyline::TRACKED_INNER);
-  }
-  return(retme);
+
+  return(delay_shapes);
 }
 
 std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {

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

@@ -43,4 +43,5 @@ class Cursor {
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
   std::vector<Point*> duplicates_intersection(const Part& part_a, const Part& part_b);
   std::vector<std::vector<Point*>> combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb);
+  std::vector<Shape*> connect_missings(std::vector<Shape*> missing_shapes);
 };

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

@@ -86,7 +86,17 @@ void Finder::process_tiles() {
 
     if (it != arriving_tiles.end()) {
       Tile* twin_tile = *it;
-      Cluster *cluster = new Cluster(this, this->bitmap->h(), this->bitmap->w());
+      int start_x, end_x;
+      if (twin_tile->start_x() == (tile->end_x() - 1)) {
+        start_x = tile->start_x();
+        end_x = twin_tile->end_x();
+      } else {
+        start_x = twin_tile->start_x();
+        end_x = tile->end_x();
+      }
+
+      Cluster *cluster = new Cluster(this, this->bitmap->h(), start_x, end_x);
+
       if (twin_tile->start_x() == (tile->end_x() - 1)) {
         cluster->add(tile);
         cluster->add(twin_tile);

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

@@ -9,15 +9,15 @@
 #include "Hub.h"
 #include <cstring>
 
-Hub::Hub(int height, int width)
-    : width_(width), height_(height)
-{ size_t total_pixels = static_cast<size_t>(width) * height;
+Hub::Hub(int height, int start_x, int end_x)
+    : width_(end_x - start_x), height_(height), start_x_(start_x)
+{ size_t total_pixels = static_cast<size_t>(width_) * height;
   payloads_.resize(total_pixels);
   bitset_.resize((total_pixels + 63) / 64, 0);
   std::memset(bitset_.data(), 0, bitset_.size() * sizeof(uint64_t));
 }
 
-EndPoint* Hub::spawn_end_point() {
+int Hub::spawn_end_point() {
   endpoint_pool_.emplace_back();
-  return &endpoint_pool_.back();
+  return static_cast<int>(endpoint_pool_.size() - 1);
 }

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

@@ -14,16 +14,19 @@
 class EndPoint;
 class Hub {
  public:
-  explicit Hub(int height, int width);
-  EndPoint* spawn_end_point();
+  explicit Hub(int height, int start_x, int end_x);
+  int spawn_end_point();
   const int width() const { return width_; }
-  inline EndPoint* get(int key) const {
+  const int start_x() const { return start_x_; }
+  inline EndPoint* get(int key) {
     if (!is_set(key)) return nullptr;
-    return payloads_[key];
+    int index = payloads_[key];
+    return &endpoint_pool_[index];
   }
-  inline void put(int key, EndPoint* payload) {
-    payloads_[key] = payload;
+  inline EndPoint* put(int key, int index) {
+    payloads_[key] = index;
     bitset_[key >> 6] |= (1ULL << (key & 63));
+    return &endpoint_pool_[index];
   }
   inline bool is_set(int key) const {
     return (bitset_[key >> 6] & (1ULL << (key & 63)));
@@ -32,7 +35,8 @@ class Hub {
  private:
   int width_;
   int height_;
-  std::vector<EndPoint*> payloads_;
+  int start_x_;
+  std::vector<int> payloads_;
   std::deque<EndPoint> endpoint_pool_;
   Hub(const Hub&) = delete;
   Hub& operator=(const Hub&) = delete;

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

@@ -27,6 +27,7 @@ class Part : public Queueable<Point> {
   bool is(Types type);
   bool inverts = false;
   bool trasmuted = false;
+  bool delayed = false;
   Part* next = nullptr;
   Part* prev = nullptr;
   Part* circular_next = nullptr;
@@ -40,6 +41,7 @@ class Part : public Queueable<Point> {
   const bool touched() const { return touched_; }
   void touch();
   bool intersect_part(Part* other_part);
+  void set_polyline(Polyline* polyline) { this->polyline_ = polyline; }
 
  private:
   bool touched_ = false;

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

@@ -9,6 +9,7 @@
 #include <vector>
 #include <utility>
 #include <iostream>
+#include <algorithm>
 #include "Partitionable.h"
 #include "Polyline.h"
 #include "Sequence.h"
@@ -31,6 +32,17 @@ void Partitionable::add_part(Part* new_part)
   new_part->circular_next = this->parts_.front();
 }
 
+void Partitionable::insert_after(Part* part, Part* new_part) {
+  auto it = std::find(parts_.begin(), parts_.end(), part);
+  if (it != parts_.end()) parts_.insert(it + 1, new_part);
+  new_part->prev = part;
+  new_part->next = part->next;
+  new_part->circular_next = part->next;
+  if (part->next) part->next->prev = new_part;
+  part->next = new_part;
+  part->circular_next = new_part;
+}
+
 void Partitionable::partition()
 { this->parts_.clear();
   Polyline *polyline = dynamic_cast<Polyline*>(this);
@@ -73,85 +85,115 @@ Part* Partitionable::find_first_part_by_position(Position* position) {
   return(nullptr);
 }
 
-std::pair<
-std::vector<std::vector<Point*>>,
-    std::vector<std::vector<Point*>>
->
-Partitionable::sew(std::vector<Point*> intersection, Polyline* other)
-{   std::vector<int> matching_part_indexes;
-  for (int i = 0; i < static_cast<int>(parts_.size()); ++i) {
-    Part* part = parts_[i];
-    if (!part || part->trasmuted) continue;
-    if (part->intersection_with_array(intersection)) {
-      matching_part_indexes.push_back(i);
-    }
-  }
+std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>> intersection, Polyline* other)
+{ std::vector<int> matching_part_indexes;
   std::vector<int> other_matching_part_indexes;
-  for (int i = 0; i < static_cast<int>(other->parts_.size()); ++i) {
-    Part* part = other->parts_[i];
-    if (!part || part->trasmuted) continue;
-    if (part->intersection_with_array(intersection)) {
-        other_matching_part_indexes.push_back(i);
-    }
+  matching_part_indexes.reserve(intersection.size());
+  other_matching_part_indexes.reserve(intersection.size());
+
+  // traspose
+  for (const auto& pair : intersection) {
+    matching_part_indexes.push_back(pair.first);
+    other_matching_part_indexes.push_back(pair.second);
   }
-  std::vector<Part*> before_parts;
-  for (int i = other_matching_part_indexes.back() + 1;
-       i < static_cast<int>(other->parts_.size()); ++i)
-  { before_parts.push_back(other->parts_[i]);
+  std::sort(matching_part_indexes.begin(), matching_part_indexes.end());
+  std::sort(other_matching_part_indexes.begin(), other_matching_part_indexes.end());
+
+  auto start_it_before = other->parts_.begin() + other_matching_part_indexes.back() + 1;
+  auto end_it_before   = other->parts_.end();
+  std::vector<Part*> before_parts(start_it_before, end_it_before);
+  auto start_it_after = other->parts_.begin();
+  auto end_it_after   = other->parts_.begin() + other_matching_part_indexes.front();
+  std::vector<Part*> after_parts(start_it_after, end_it_after);
+
+  int start_idx = matching_part_indexes.front();
+  int end_idx  = matching_part_indexes.back();
+  Part* part_start = parts_[start_idx];
+  Part* part_end   = parts_[end_idx];
+
+  auto collect_sequences = [&](const std::vector<int>& indices, std::vector<Part*>& p_list)
+    -> std::vector<std::vector<Point*>> {
+    std::vector<std::vector<Point*>> result;
+    int last_n = -1;
+    if (indices.size() < 2) return result;
+    for (int n = indices.front() + 1; n < indices.back(); ++n) {
+      if (std::find(indices.begin(), indices.end(), n) == indices.end()) {
+        Part* part = p_list[n];
+        if (part->is(Part::SEAM) && part->size > 0 && !part->delayed) {
+          part->delayed = true;
+          result.clear();
+          result.push_back({nullptr});
+          return result;
+        }
+        if (last_n == (n - 1) && !result.empty()) {
+          std::vector<Point*> pts = part->to_vector();
+          result.back().insert(result.back().end(), pts.begin(), pts.end());
+        } else {
+          result.push_back(part->to_vector());
+        }
+        last_n = n;
+      }
+    }
+    return result;
+  };
+  auto left = collect_sequences(matching_part_indexes, this->parts_);
+  if (!left.empty() && !left[0].empty() && left[0][0] == nullptr) {
+    return std::nullopt;
   }
-  std::vector<Part*> after_parts;
-  for (int i = 0; i < other_matching_part_indexes.front(); ++i) {
-    after_parts.push_back(other->parts_[i]);
+  auto right = collect_sequences(other_matching_part_indexes, other->parts_);
+  if (!right.empty() && !right[0].empty() && right[0][0] == nullptr) {
+    return std::nullopt;
   }
-  Part* part_start = parts_[matching_part_indexes.front()];
-  Part* part_end   = parts_[matching_part_indexes.back()];
-  // They are inverted since they traverse in opposite directions
-  Sequence sequence;
-  sequence.add(part_start->head);
-  for (Part* p : before_parts) sequence.append(*p);
-  for (Part* p : after_parts) sequence.append(*p);
-  if (part_end->tail) sequence.add(part_end->tail);
-  part_start->replace(sequence);
-  part_start->type = Part::EXCLUSIVE;
-  if (part_start != part_end) part_end->reset();
-
-  std::vector<std::vector<Point*>> left;
-
-  for (int n = matching_part_indexes.front() + 1;
-       n <= matching_part_indexes.back() - 1;
-       ++n)
-  { if (std::find(matching_part_indexes.begin(),
-                  matching_part_indexes.end(),
-                  n) == matching_part_indexes.end())
-    { auto pts = parts_[n]->to_vector();
-      left.push_back(pts);
+
+  if (part_start != part_end) {
+    for (int n = end_idx - 1; n > start_idx; --n) {
+      Part* delete_part = parts_[n];
+      // Topological detachment of pointers
+      if (delete_part->prev) delete_part->prev->next = delete_part->next;
+      if (delete_part->next) delete_part->next->prev = delete_part->prev;
+      parts_.erase(parts_.begin() + n);
     }
   }
 
-  // delete parts in reverse order
-  for (int n = matching_part_indexes.back() - 1;
-       n >= matching_part_indexes.front() + 1;
-       --n)
-  { Part* delete_part = parts_[n];
-    if (delete_part->prev) delete_part->prev->next = delete_part->next;
-    if (delete_part->next) delete_part->next->prev = delete_part->prev;
-    parts_.erase(parts_.begin() + n);
+  std::vector<Part*> all_parts;
+  Polyline* polyline = dynamic_cast<Polyline*>(this);
+  all_parts.reserve(before_parts.size() + after_parts.size());
+  all_parts.insert(all_parts.end(), before_parts.begin(), before_parts.end());
+  all_parts.insert(all_parts.end(), after_parts.begin(), after_parts.end());
+  Part* will_be_last = all_parts.empty() ? nullptr : all_parts.back();
+  for (auto it = all_parts.rbegin(); it != all_parts.rend(); ++it) {
+    Part* p = *it;
+    this->insert_after(part_start, p);
+    auto& op = other->parts_;
+    op.erase(std::remove(op.begin(), op.end(), p), op.end());
+    p->set_polyline(polyline);
   }
 
-  std::vector<std::vector<Point*>> right;
-  for (int n = other_matching_part_indexes.front() + 1;
-       n <= other_matching_part_indexes.back() - 1;
-       ++n)
-  { if (std::find(other_matching_part_indexes.begin(),
-                  other_matching_part_indexes.end(),
-                  n) == other_matching_part_indexes.end())
-    { auto pts = other->parts_[n]->to_vector();
-      right.push_back(pts);
+  part_start->type = Part::EXCLUSIVE;
+  PartPool& pool = polyline->tile->cluster->parts_pool;
+  Part* new_end_part = pool.acquire(Part::EXCLUSIVE, polyline);
+  new_end_part->add(part_end->tail);
+  part_start->singleton();
+
+  // deletes part_end
+  if (part_start != part_end) {
+    if (part_end->prev) part_end->prev->next = part_end->next;
+    if (part_end->next) part_end->next->prev = part_end->prev;
+    auto it = std::find(parts_.begin(), parts_.end(), part_end);
+    if (it != parts_.end()) {
+      parts_.erase(it);
     }
   }
-  return { left, right };
+
+  Part* reference_part = (will_be_last != nullptr) ? will_be_last : part_start;
+  this->insert_after(reference_part, new_end_part);
+
+  polyline->reset_tracked_endpoints();
+
+  return std::make_pair(left, right);
 }
 
+
 void Partitionable::trasmute_parts()
 { std::vector<Part*> insides;
   for (Part* p : parts_) {

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

@@ -9,22 +9,24 @@
 #pragma once
 #include <vector>
 #include <utility>
+#include <optional>
 #include "Part.h"
 
+using SewReturnData = std::pair<std::vector<std::vector<Point*>>, std::vector<std::vector<Point*>>>;
+
 class Partitionable {
  public:
   explicit Partitionable() {}
   virtual ~Partitionable() = default;
   void partition();
   Part* find_first_part_by_position(Position* position);
-  std::pair<
-    std::vector<std::vector<Point*>>,
-    std::vector<std::vector<Point*>>> sew(std::vector<Point*> intersection, Polyline* other);
+  std::optional<SewReturnData> sew(std::vector<std::pair<int, int>> intersection, Polyline* other);
 
  protected:
   std::vector<Part*> parts_;
 
  private:
   void add_part(Part* new_part);
+  void insert_after(Part* part, Part* new_part);
   void trasmute_parts();
 };

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

@@ -48,6 +48,10 @@ bool Polyline::boundary() {
   return( tile->tg_border(Point{min_x, 0}) || tile->tg_border(Point{max_x, 0}));
 }
 
+void Polyline::reset_tracked_endpoints() {
+  tracked_endpoints.clear();
+}
+
 void Polyline::find_boundary() {
   if (raw_.empty()) return;
   min_x =  std::numeric_limits<int>::max();
@@ -65,40 +69,41 @@ void Polyline::find_boundary() {
   }
 }
 
-struct PointHash {
-  size_t operator()(const Point* p) const {
-    if (!p) return 0;
-    std::hash<double> hasher;
-    size_t h1 = hasher(p->x);
-    size_t h2 = hasher(p->y);
-    return h1 ^ (h2 << 1);
-  }
-};
-
-struct PointEqual {
-  bool operator()(const Point* p1, const Point* p2) const {
-    if (!p1 || !p2) return p1 == p2;
-    return *p1 == *p2;
+std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) const {
+  if (this->tracked_endpoints.empty()) {
+    for (int i = 0; i < parts_.size(); ++i) {
+      auto& part = parts_[i];
+      if (!part->is(Part::SEAM) && part->trasmuted) continue;
+      part->each([&](QNode<Point>* pos) -> bool {
+        Position *position = dynamic_cast<Position*>(pos);
+        this->tracked_endpoints[position->end_point()] = i;
+        return true;
+      });
+    }
   }
-};
 
-std::vector<Point*> Polyline::intersection(const Polyline* other) const {
-  std::vector<Point*> result;
-  if (!other) return result;
-  std::unordered_set<Point*, PointHash, PointEqual> other_set;
-  other_set.reserve(other->raw().size());
-  for (Point* p : other->raw()) {
-    if (p) other_set.insert(p);
-  }
-  for (Point* p : raw_) {
-    if (!p) continue;
-    if (other_set.count(p)) {
-      result.push_back(p);
+  std::vector<std::pair<int, int>> matching_parts;
+  for (int j = 0; j < other->parts_.size(); ++j) {
+    auto& other_part = other->parts_[j];
+    if (!other_part->is(Part::SEAM) && other_part->trasmuted) {
+      continue;
     }
+    other_part->each([&](QNode<Point>* pos) -> bool {
+      Position *position = dynamic_cast<Position*>(pos);
+      auto it = this->tracked_endpoints.find(position->end_point());
+      if (it != this->tracked_endpoints.end()) {
+        int self_index = it->second;
+        matching_parts.push_back({self_index, j});
+        return false;
+      }
+      return true;
+    });
   }
-  return result;
+
+  return matching_parts;
 }
 
+
 void Polyline::clear() {
   this->raw_.clear();
 }

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

@@ -10,7 +10,9 @@
 #include <list>
 #include <cstdint>
 #include <optional>
+#include <utility>
 #include <vector>
+#include <unordered_map>
 #include "Partitionable.h"
 #include "../RectBounds.h"
 
@@ -37,11 +39,12 @@ class Polyline : public Partitionable {
   std::vector<Point*> raw() const { return raw_; }
   const std::list<Shape*>& next_tile_eligible_shapes() const { return next_tile_eligible_shapes_; }
   const std::vector<Part*>& parts() const { return parts_; }
-  std::vector<Point*> intersection(const Polyline* other) const;
+  std::vector<std::pair<int, int>> intersection(const Polyline* other) const;
   const int max_y() const { return max_y_; }
   void clear();
   bool is_empty();
   bool vert_intersect(Polyline& other);
+  void reset_tracked_endpoints();
 
  private:
   std::vector<Point*> raw_;
@@ -49,4 +52,5 @@ class Polyline : public Partitionable {
   void find_boundary();
   uint32_t flags_ = 0;
   std::list<Shape*> next_tile_eligible_shapes_;
+  mutable std::unordered_map<const EndPoint*, int> tracked_endpoints;
 };

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

@@ -11,11 +11,10 @@
 
 Position::Position(Hub* hub, Point* point)
 : QNode<Point>(point)
-{ int key = point->y * hub->width() + point->x;
+{ int key = point->y * hub->width() + (point->x - hub->start_x());
   EndPoint* existing_ep = hub->get(key);
   if (existing_ep == nullptr)
-  { end_point_ = hub->spawn_end_point();
-    hub->put(key, end_point_);
+  { end_point_ = hub->put(key, hub->spawn_end_point());
   } else {
     end_point_ = existing_ep;
   }

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

@@ -79,9 +79,21 @@ class Queueable {
     head = nullptr;
     tail = nullptr;
     _iterator = nullptr;
+    _started = false;
     size = 0;
   }
 
+  void singleton()
+  { if (head && head->next) {
+      head->next->prev = nullptr;
+      head->next = nullptr;
+    }
+    tail = nullptr;
+    size = 1;
+    _iterator = nullptr;
+    _started = false;
+  }
+
   void replace(Queueable<T>& q) {
     reset();
     append(q);
@@ -130,8 +142,8 @@ class Queueable {
   }
 
   void next_of(QNode<T>* node) {
-    if (!node)  throw std::runtime_error("nil node");
-    if (node->owner != this) throw std::runtime_error("wrong node");
+    // if (!node)  throw std::runtime_error("nil node");
+    // if (node->owner != this) throw std::runtime_error("wrong node");
     _iterator = node->next;
     _started = true;
   }
@@ -181,23 +193,6 @@ class Queueable {
       return out;
   }
 
-  bool intersection_with_array(const std::vector<T*>& array) {
-    if (array.empty() || size == 0) return false;
-
-    QNode<T>* current = head;
-    while (current) {
-      if (current->payload) {
-        for (T* item : array) {
-          if (item && *item == *(current->payload)) {
-            return true;
-          }
-        }
-      }
-      current = current->next;
-    }
-    return false;
-  }
-
   QNode<T>* pop() {
     if (!tail) return nullptr;
     return rem(tail);
@@ -220,7 +215,7 @@ class Queueable {
 
     for (T* current : source) {
       if (!result.empty() && *result.back() == *current) {
-          result.pop_back();  // "Annulla" la coppia invece di ricominciare
+          result.pop_back();
       } else {
           result.push_back(current);
       }

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -267,7 +267,7 @@ void Init_cpp_polygon_finder() {
 
   Data_Type<RGBNotMatcher> rb_cRGBNotMatcher =
     define_class<RGBNotMatcher, Matcher>("CPPRGBNotMatcher")
-    .define_constructor(Constructor<RGBNotMatcher, int>())
+    .define_constructor(Constructor<RGBNotMatcher, unsigned int>())
     .define_method("match", &RGBNotMatcher::match);
 
   Data_Type<PolygonFinder> rb_cPolygonFinder =

data/lib/contrek/bitmaps/rgb_color.rb

@@ -3,23 +3,8 @@ module Contrek
     class RgbColor
       attr_reader :raw
       def initialize(r:, g:, b:, a: 255)
-        @r = r
-        @g = g
-        @b = b
-        @a = a
         @raw = (r << 24) + (g << 16) + (b << 8) + a
       end
-
-      def to_rgb_raw
-        @raw >> 8
-      end
-
-      def self.reverse_raw(raw)
-        [:a, :b, :g, :r].each_with_object({}) do |c, h|
-          h[c] = raw & 0xFF
-          raw >>= 8
-        end
-      end
     end
   end
 end

data/lib/contrek/bitmaps/rgb_cpp_color.rb

@@ -0,0 +1,10 @@
+module Contrek
+  module Bitmaps
+    class RgbCppColor
+      attr_reader :raw
+      def initialize(r:, g:, b:, a: 255)
+        @raw = (a << 24) | (b << 16) | (g << 8) | r
+      end
+    end
+  end
+end

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

@@ -3,10 +3,10 @@ module Contrek
     class Cluster
       attr_reader :tiles, :hub
 
-      def initialize(finder:, height:, width:)
+      def initialize(finder:, height:, start_x:, end_x:)
         @finder = finder
         @tiles = []
-        @hub = Hub.new(height:, width:)
+        @hub = Hub.new(start_x:, end_x:)
       end
 
       def add(tile)

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

@@ -54,34 +54,51 @@ module Contrek
             missing_shapes << shape
           end
         end
+        to_delay = connect_missings(missing_shapes)
+        while to_delay.any?
+          to_delay = connect_missings(to_delay)
+        end
+
+        retme = collect_inner_sequences(outer_seq)
+
+        @polylines_sequence.each do |polyline|
+          polyline.turn_on(Polyline::TRACKED_INNER)
+        end
+        retme
+      end
+
+      private
+
+      def connect_missings(missing_shapes)
+        delay_shapes = []
+
         @polylines_sequence.each do |polyline|
           missing_shapes.each do |missing_shape|
-            outer_polyline = missing_shape.outer_polyline
-            next unless polyline.vert_intersect?(outer_polyline)
-            if (intersection = polyline.intersection(outer_polyline)).any?
-              inject_sequences_left, inject_sequences_right = polyline.sew!(intersection, outer_polyline)
+            missing_outer_polyline = missing_shape.outer_polyline
+            next if missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
+              !polyline.vert_intersect?(missing_outer_polyline)
+
+            if (intersection = polyline.intersection(missing_outer_polyline)).any?
+              inject_sequences_left, inject_sequences_right = polyline.sew!(intersection, missing_outer_polyline)
+              if inject_sequences_left.nil?
+                delay_shapes << missing_shape
+                next
+              end
               combine!(inject_sequences_right, inject_sequences_left).each do |sewn_sequence|
                 sewn_sequence.uniq!
                 @orphan_inners << sewn_sequence if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # segmenti non sono ammessi, solo aree
               end
-              outer_polyline.clear!
-              outer_polyline.turn_on(Polyline::TRACKED_OUTER)
-              outer_polyline.turn_on(Polyline::TRACKED_INNER)
+              missing_outer_polyline.clear!
+              missing_outer_polyline.turn_on(Polyline::TRACKED_OUTER)
+              missing_outer_polyline.turn_on(Polyline::TRACKED_INNER)
               @orphan_inners += missing_shape.inner_polylines
             end
           end
         end
 
-        retme = collect_inner_sequences(outer_seq)
-
-        @polylines_sequence.each do |polyline|
-          polyline.turn_on(Polyline::TRACKED_INNER)
-        end
-        retme
+        delay_shapes
       end
 
-      private
-
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, polylines, shapes, outer_joined_polyline)
         all_parts << act_part if all_parts.last != act_part

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

@@ -98,7 +98,18 @@ module Contrek
             return
           end
           if (twin_tile = arriving_tiles.find { |b| (b.start_x == (tile.end_x - 1)) || ((b.end_x - 1) == tile.start_x) })
-            cluster = Cluster.new(finder: self, height: bitmap.h, width: bitmap.w)
+
+            if twin_tile.start_x == (tile.end_x - 1)
+              start_x = tile.start_x
+              end_x = twin_tile.end_x
+            else
+              start_x = twin_tile.start_x
+              end_x = tile.end_x
+            end
+
+            # puts "start = #{start_x} end = #{end_x}"
+
+            cluster = Cluster.new(finder: self, height: bitmap.h, start_x:, end_x:)
             if twin_tile.start_x == (tile.end_x - 1)
               cluster.add(tile)
               cluster.add(twin_tile)

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

@@ -2,8 +2,8 @@ module Contrek
   module Concurrent
     class Hub
       attr_reader :payloads, :width
-      def initialize(height:, width:)
-        @width = width
+      def initialize(start_x:, end_x:)
+        @width = end_x - start_x
         # @payloads = Array.new(width * height)
         @payloads = {}
       end

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

@@ -8,7 +8,7 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted
+      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted, :delayed
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
@@ -19,12 +19,17 @@ module Contrek
         @touched = false
         @inverts = false
         @trasmuted = false
+        @delayed = false
       end
 
       def is?(type)
         @type == type
       end
 
+      def set_polyline(polyline)
+        @polyline = polyline
+      end
+
       def add_position(position)
         add(Position.new(position: position, hub: polyline.tile.cluster.hub))
       end

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

@@ -16,6 +16,15 @@ module Contrek
         new_part.prev = last
       end
 
+      def insert_after(part, new_part)
+        part_index = @parts.index(part)
+        @parts.insert(part_index + 1, new_part)
+        new_part.prev = part
+        new_part.next = new_part.circular_next = part.next
+        part.next.prev = new_part if part.next
+        part.next = part.circular_next = new_part
+      end
+
       def find_first_part_by_position(position)
         @parts.find do |part|
           part.is?(Part::SEAM) &&
@@ -57,48 +66,67 @@ module Contrek
       end
 
       def sew!(intersection, other)
-        matching_part_indexes = []
-        parts.each_with_index do |part, index|
-          next if part.trasmuted
-          matching_part_indexes << index if part.intersection_with_array?(intersection)
-        end
-        other_matching_part_indexes = []
-        other.parts.each_with_index do |part, index|
-          next if part.trasmuted
-          other_matching_part_indexes << index if part.intersection_with_array?(intersection)
-        end
-        # other_matching_part_indexes and matching_part_indexes always contain at least one element
+        matching_part_indexes, other_matching_part_indexes = intersection.transpose.map(&:sort)
+        # other_matching_part_indexes and matching_part_indexes always must contain at least one element
         before_parts = other.parts[other_matching_part_indexes.last + 1..]
         after_parts = other_matching_part_indexes.first.zero? ? [] : other.parts[0..other_matching_part_indexes.first - 1]
         part_start = parts[matching_part_indexes.first]
         part_end = parts[matching_part_indexes.last]
 
-        # They are inverted since they traverse in opposite directions
-        sequence = Sequence.new
-        sequence.add part_start.head
-        before_parts.each { |part| sequence.append(part) }
-        after_parts.each { |part| sequence.append(part) }
-        sequence.add part_end.tail if part_end.tail # nil when part_start == part_end
-
-        part_start.replace!(sequence)
-        part_start.type = Part::EXCLUSIVE
-        part_end.reset! if part_start != part_end
+        # left and right side reduces will be combined and later converted into orphan inners sequences
+        returning_data = [[matching_part_indexes, parts], [other_matching_part_indexes, other.parts]].map do |matching_part_indexes, parts|
+          lastn = 0
+          result = []
+          (matching_part_indexes.first + 1).upto(matching_part_indexes.last - 1) do |n|
+            if matching_part_indexes.index(n).nil?
+              part = parts[n]
+              if part.is?(Part::SEAM) && part.size > 0 && !part.delayed # fallback, delays the shape
+                part.delayed = true
+                return nil
+              end
+              if (lastn == (n - 1)) && result.any?
+                result.last.concat part.to_a
+              else
+                result << part.to_a
+              end
+              lastn = n
+            end
+          end
+          result
+        end
 
-        left = []
-        (matching_part_indexes.first + 1).upto(matching_part_indexes.last - 1) do |n|
-          left << parts[n].to_a if matching_part_indexes.index(n).nil?
+        if part_start != part_end
+          (matching_part_indexes.last - 1).downto(matching_part_indexes.first + 1) do |n|
+            delete_part = parts[n]
+            delete_part.prev.next = delete_part.next if delete_part.prev
+            delete_part.next.prev = delete_part.prev if delete_part.next
+            parts.delete_at(n)
+          end
         end
-        (matching_part_indexes.last - 1).downto(matching_part_indexes.first + 1) do |n|
-          delete_part = parts[n]
-          delete_part.prev.next = delete_part.next if delete_part.prev
-          delete_part.next.prev = delete_part.prev if delete_part.next
-          parts.delete_at(n)
+
+        all_parts = before_parts + after_parts
+        will_be_last = all_parts.last
+        all_parts.reverse_each do |part|
+          insert_after(part_start, part)
+          other.parts.delete(part)
+          part.set_polyline(self)
         end
-        right = []
-        (other_matching_part_indexes.first + 1).upto(other_matching_part_indexes.last - 1) do |n|
-          right << other.parts[n].to_a if other_matching_part_indexes.index(n).nil?
+
+        part_start.type = Part::EXCLUSIVE
+        new_end_part = Part.new(Part::EXCLUSIVE, self)
+        new_end_part.add(part_end.tail)
+        part_start.singleton! # reduce part to its head only
+
+        if part_start != part_end
+          part_end.prev.next = part_end.next if part_end.prev
+          part_end.next.prev = part_end.prev if part_end.next
+          parts.delete(part_end)
         end
-        [left, right]
+        insert_after(will_be_last, new_end_part)
+
+        reset_tracked_endpoints!
+
+        returning_data
       end
 
       private

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

@@ -27,7 +27,15 @@ module Contrek
       end
 
       def inspect
-        "#{self.class}[b#{@tile.name} S#{@name} #{"B" if boundary?}] (#{raw.count} => #{raw.inspect})"
+        "#{self.class}#{named} (#{raw.count} => #{raw.inspect})"
+      end
+
+      def named
+        "[b#{@tile.name} S#{@name} #{"B" if boundary?}]"
+      end
+
+      def numpy_raw
+        raw.flat_map { |p| [p[:x], p[:y]] }
       end
 
       def info
@@ -46,8 +54,35 @@ module Contrek
         (@flags & flag) != 0
       end
 
+      def reset_tracked_endpoints!
+        @tracked_endpoints = nil
+      end
+
+      # returns for every position of intersection an array composed by the indexes of parts (self,other) involved
+      # es [[1,3],[2,6],...]. The first time the sequence for self is computed is stored.
       def intersection(other)
-        @raw & other.raw
+        if @tracked_endpoints.nil?
+          @tracked_endpoints = {} # memoize found sequence
+          parts.each_with_index do |part, part_index|
+            next if !part.is?(Part::SEAM) && part.trasmuted
+            part.each do |pos|
+              @tracked_endpoints[pos.end_point.object_id] = part_index
+            end
+          end
+        end
+        matching_parts = []
+        other.parts.each_with_index do |part, part_index|
+          next if !part.is?(Part::SEAM) && part.trasmuted
+          part.each do |pos|
+            if (self_index = @tracked_endpoints[pos.end_point.object_id])
+              matching_parts << [self_index, part_index]
+              false
+            else
+              true
+            end
+          end
+        end
+        matching_parts
       end
 
       def empty?
@@ -82,6 +117,13 @@ module Contrek
         !(@max_y < other.min_y || other.max_y < @min_y)
       end
 
+      def get_bounds
+        {min_x: @min_x,
+         max_x: @max_x,
+         min_y: @min_y,
+         max_y: @max_y}
+      end
+
       private
 
       def find_boundary

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

@@ -10,6 +10,16 @@ module Contrek
         @size = 0
       end
 
+      def singleton!
+        if @head&.next
+          @head.next.prev = nil
+          @head.next = nil
+        end
+        @tail = nil
+        @size = 1
+        @iterator = 0
+      end
+
       def rem(node)
         Raise "Not my node" if node.owner != self
 
@@ -84,12 +94,13 @@ module Contrek
         @iterator = 0
       end
 
+      # from yield: false => stop, true => continue
       def each(&block)
         last = nil
         unless @head.nil?
           pointer = @head
           loop do
-            yield(pointer)
+            break unless yield(pointer)
             last = pointer
             break unless (pointer = pointer.next)
           end
@@ -142,25 +153,6 @@ module Contrek
         rem(@tail)
       end
 
-      def intersection_with(queueable)
-        int = []
-        each do |node|
-          int += queueable.map do |e|
-            break [e.payload] if e.payload == node.payload
-          end.compact
-        end
-        int
-      end
-
-      def intersection_with_array?(array)
-        each { |node| return true if array.index(node.payload) }
-        false
-      end
-
-      def intersect_with?(queueable)
-        intersection_with(queueable).any?
-      end
-
       def remove_adjacent_pairs(array = nil)
         array = to_a if array.nil?
         n = array.size

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.0.7"
+  VERSION = "1.0.8"
 end

data/lib/contrek.rb

@@ -5,6 +5,7 @@ require "contrek/bitmaps/chunky_bitmap"
 require "contrek/bitmaps/png_bitmap"
 require "contrek/bitmaps/custom_bitmap"
 require "contrek/bitmaps/rgb_color"
+require "contrek/bitmaps/rgb_cpp_color"
 require "contrek/finder/bounds"
 require "contrek/bitmaps/sample_generator"
 require "contrek/finder/list"
@@ -54,10 +55,10 @@ module Contrek
     private
 
     def compute_cpp(png_file_path, options)
-      color = Bitmaps::RgbColor.new(**options[:color])
+      color = Bitmaps::RgbCppColor.new(**options[:color])
       png_bitmap = CPPPngBitMap.new(png_file_path)
       rgb_matcher_klass = (options[:class] == "value_not_matcher") ? CPPRGBNotMatcher : CPPRGBMatcher
-      rgb_matcher = rgb_matcher_klass.new(color.to_rgb_raw)
+      rgb_matcher = rgb_matcher_klass.new(color.raw)
       if options.key?(:number_of_threads) || options[:finder]&.key?(:number_of_tiles)
         Contrek::Cpp::CPPConcurrentFinder.new(
           number_of_threads: options.dig(:number_of_threads) || 0,
@@ -74,7 +75,7 @@ module Contrek
     end
 
     def compute_ruby_pure(png_file_path, options)
-      color = Bitmaps::RgbColor.new(**options[:color])
+      color = Bitmaps::RgbCppColor.new(**options[:color])
       png_bitmap = Bitmaps::PngBitmap.new(png_file_path)
       rgb_matcher = const_get("Contrek::Matchers::" + camelize("value_not_matcher")).new(color.raw)
       if options.key?(:number_of_threads) || options[:finder]&.key?(:number_of_tiles)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-10 00:00:00.000000000 Z
+date: 2026-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -229,6 +229,7 @@ files:
 - lib/contrek/bitmaps/painting.rb
 - lib/contrek/bitmaps/png_bitmap.rb
 - lib/contrek/bitmaps/rgb_color.rb
+- lib/contrek/bitmaps/rgb_cpp_color.rb
 - lib/contrek/bitmaps/sample_generator.rb
 - lib/contrek/cpp/cpp_concurrent_finder.rb
 - lib/contrek/finder/bounds.rb