contrek 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0d1a364ff39a11f632f5f57d99970448173727e8f5a42e84e1b334521c1e1d1
-  data.tar.gz: 24a52785c8735e9fce60931a1ffc1bd974aa5a50a6fb755229cd25dd5263cab3
+  metadata.gz: 15c162c3876502f8e8710ce261825dfe7fa66e1b600db084763e02ef70876a37
+  data.tar.gz: 32203f85040726d71ac519aac811d4078474c85dcd7c7b08227f1cea7e3b485f
 SHA512:
-  metadata.gz: e321b716a5c16d6c75f24bc6bcdebc302a6ea9785009bad93905321ebc7a97ef29048fb1c6e4e0557611ec9d096dee874bd1ff37f66ad2763c4dacd7176b0ce4
-  data.tar.gz: 38608a89ed8ee0c43a985bf8057d07b860acd524d2e8c0022651e5ec3fdcc8f13e3d515e309d436ad261203e00a58b901dd6cf141bfbeeb93520f7937ccdb4b8
+  metadata.gz: c9f8d2a44f087f96cfeacc8df8dec0973bf301f770ae45e82e6bf7d01902546c280c0446ee9c281c850a8e7c8965309e20d1a723ec269e60a99d386c288af0e7
+  data.tar.gz: 4d2c5c834fca24731866d0a56cc64d4aeac12437fac11b78389c38f7fbed9e637c785eb2a3357fb5c90a5fc257b2d010fe36cac2f84db3888f2b311276c42895

data/CHANGELOG.md

@@ -23,3 +23,14 @@ 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.
+
+## [1.0.9] - 2026-01-31
+### Added
+- **CMake Integration**: The library is now fully modularized via CMake, enabling seamless integration as a dependency in external C++ projects.
+- Multithreading Algorithm Optimization.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.0.7)
+    contrek (1.0.9)
       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 powered by a <u>standalone C++17 core library</u> for fast contour tracing and edge detection in PNG images. 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.
@@ -99,7 +99,7 @@ Regarding multithreading:
 
 - The treemap option is currently ignored (multithreaded treemap support will be introduced in upcoming revisions).
 
-By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 2 threads working on 2 tiles (total compute time about 2 secs).
+By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 2 threads working on 2 tiles (total compute time about 1.66 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
@@ -113,11 +113,13 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{"compress"=>14.596786999999999,
-  "init"=>2078.745861,
-  "inner"=>1183.143734,
-  "outer"=>118.94489599999999,
-  "total"=>2093.342648}
+{ "compress"=>13.423765,
+  "init"=>612.654121,
+  "inner"=>14.8930669,
+  "outer"=>33.0693249,
+  "total"=>626.0778879
+}
+
 ```
 
 ## Result
@@ -262,7 +264,77 @@ This the one for the native C++
 }
 ```
 
-About 75x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro. 
+About 75x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
+
+## 🛠 C++ Standalone Library Usage
+
+The core of **Contrek** is a high-performance `C++17` library. It is designed to be **standalone**, meaning it has zero dependencies on Ruby and can be integrated into any `C++` project.
+
+
+### Prerequisites
+* **CMake** (3.10+)
+* **ZLIB** (Required for PNG processing)
+* **C++17 Compiler**
+
+### 1. Build & Run Examples
+If you want to test the performances or see the library in action:
+
+```bash
+# Navigate to the core folder
+cd ext/cpp_polygon_finder/PolygonFinder
+
+# Setup build directory
+mkdir build && cd build
+
+# Configure with examples enabled
+cmake -DBUILD_EXAMPLES=ON ..
+
+# Build and run
+make
+./contrek_test
+```
+
+### 2. How to integrate it into your project
+
+To use Contrek's engine in your own C++ application without Ruby:
+
+1. **Copy the core folder**: Take the `ext/cpp_polygon_finder/PolygonFinder` directory and place it inside your project (e.g., in a `libs/` or `third_party/` folder).
+2. **Update your CMakeLists.txt**: Add these lines to link the library:
+
+```cmake
+# Tell CMake to include Contrek
+add_subdirectory(libs/PolygonFinder)
+
+# Link it to your executable
+add_executable(my_app main.cpp)
+target_link_libraries(my_app PRIVATE ContrekLib)
+```
+
+### 3. C++ API Quick Start
+
+Contrek provides a high-level C++ API. Here is how you can use it in your standalone projects:
+
+```cpp
+#include "ContrekApi.h"
+#include <iostream>
+
+int main() {
+    // 1. Configure the engine
+    Contrek::Config cfg;
+    cfg.threads = 4;
+    cfg.tiles = 2;
+
+    // 2. Run the tracing process
+    // Supports PNG files via internal spng integration
+    auto result = Contrek::trace("path/to/image.png", cfg);
+
+    // 3. Access results
+    result->print_info(); // prints generic infos
+    std::cout << "Found polygons: " << result->groups << std::endl;
+
+    return 0;
+}
+```
 
 ## License
 

data/ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.10)
+project(ContrekCore C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -march=native -DNDEBUG -Ofast -flto")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -march=native -fPIC -DNDEBUG")
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread -flto=auto -Wl,--no-as-needed")
+
+find_package(ZLIB REQUIRED)
+
+file(GLOB_RECURSE CPP_SOURCES "*.cpp")
+file(GLOB_RECURSE C_SOURCES "*.c")
+
+list(FILTER CPP_SOURCES EXCLUDE REGEX "examples/.*\\.cpp")
+
+add_library(ContrekLib STATIC ${CPP_SOURCES} ${C_SOURCES})
+
+file(GLOB_RECURSE ALL_HEADERS "*.h")
+foreach(header_file ${ALL_HEADERS})
+    get_filename_component(header_dir ${header_file} DIRECTORY)
+    list(APPEND ALL_INCLUDE_DIRS ${header_dir})
+endforeach()
+list(REMOVE_DUPLICATES ALL_INCLUDE_DIRS)
+
+target_include_directories(ContrekLib PUBLIC ${ALL_INCLUDE_DIRS} ${ZLIB_INCLUDE_DIRS})
+target_link_libraries(ContrekLib PRIVATE ${ZLIB_LIBRARIES} pthread)
+
+option(BUILD_EXAMPLES "Build the example application" OFF)
+
+if(BUILD_EXAMPLES)
+    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples/example.cpp")
+        message(STATUS "Contrek: Compiling example option ON")
+        add_executable(contrek_test examples/example.cpp)
+        target_link_libraries(contrek_test PRIVATE ContrekLib)
+    else()
+        message(WARNING "Contrek: examples/example.cpp not found!")
+    endif()
+endif()

data/ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp

@@ -0,0 +1,43 @@
+//============================================================================
+// Name        : example.cpp
+// Author      : Emanuele Cesaroni
+// Version     :
+// Copyright   : 2025 Emanuele Cesaroni
+// Description :
+//============================================================================
+
+#include <iostream>
+#include "ContrekApi.h"
+#include "Tests.h"
+
+void run_test() {
+  CpuTimer cpu_timer;
+  Tests test_suite;
+  cpu_timer.start();
+
+  // test_suite.test_a();
+  // test_suite.test_b();
+  // test_suite.test_c();
+  // test_suite.test_d();
+  // test_suite.test_e();
+  test_suite.test_f();
+  std::cout << "compute time =" << cpu_timer.stop() << std::endl;
+}
+
+int main() {
+  Contrek::Config cfg;
+  cfg.threads = 2;
+  cfg.tiles = 2;
+  cfg.compress_unique = true;
+
+  CpuTimer cpu_timer;
+  cpu_timer.start();
+  std::cout << "--- Start Native Benchmark ---" << std::endl;
+  auto result = Contrek::trace("../images/sample_10240x10240.png", cfg);
+  result->print_info();
+  std::cout << "Found polygons: " << result->groups << std::endl;
+  std::cout << "Time: " << cpu_timer.stop() << " ms" << std::endl;
+
+  // run_test();
+  return 0;
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h

@@ -0,0 +1,72 @@
+/*
+ * ContrekApi.h
+ *
+ *  Created on: 25 gen 2026
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <cstdint>
+
+#include "Finder.h"
+#include "FastPngBitmap.h"
+#include "RGBNotMatcher.h"
+#include "RGBMatcher.h"
+
+namespace Contrek {
+
+enum class MatchMode {
+  NOT_COLOR,    // Tracks border of what is not target color
+  EXACT_COLOR   // Tracks border of what exactly matchs target color
+};
+
+struct Config {
+  int threads = 4;
+  int tiles = 2;
+  bool compress_unique = false;
+  bool compress_linear = false;
+  bool compress_visvalingam = false;
+  bool treemap = false;
+  int32_t target_color = -1;
+  MatchMode mode = MatchMode::NOT_COLOR;
+};
+
+inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const Config& cfg = Config()) {
+  auto bitmap = std::make_unique<FastPngBitmap>(image_path);
+
+  int32_t color_to_match = (cfg.target_color == -1)
+                           ? bitmap->rgb_value_at(0, 0)
+                           : cfg.target_color;
+
+  std::unique_ptr<Matcher> matcher;
+  if (cfg.mode == MatchMode::NOT_COLOR) {
+    matcher = std::make_unique<RGBNotMatcher>(color_to_match);
+  } else {
+    matcher = std::make_unique<RGBMatcher>(color_to_match);
+  }
+
+  std::vector<std::string> internal_args = {"--versus=a"};
+  struct Mapping { bool flag; std::string_view arg; };
+  const Mapping mappings[] = {
+    {cfg.compress_unique,      "--compress_uniq"},
+    {cfg.compress_linear,      "--compress_linear"},
+    {cfg.compress_visvalingam, "--compress_visvalingam"},
+    {cfg.treemap,              "--treemap"}
+  };
+
+  for (auto& m : mappings) {
+      if (m.flag) internal_args.emplace_back(m.arg);
+  }
+  internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
+
+  Finder finder(cfg.threads, bitmap.get(), matcher.get(), &internal_args);
+
+  return std::unique_ptr<ProcessResult>(finder.process_info());
+}
+
+}  // namespace Contrek

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

@@ -28,12 +28,6 @@
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
 
-Tests::Tests() {
-}
-
-Tests::~Tests() {
-}
-
 void Tests::test_a()
 { std::string chunk =
       "0000000000000000"\
@@ -79,22 +73,10 @@ void Tests::test_b()
       "  XX       XX   "\
       "  XX       XX   "\
       "  XXXXXXXXXXX   ";
-//        "0123456789012345"
-  /*chunk = "  XXXXXXXXXXX   "\
-          "  XX   XX  XX   "\
-          "  XX   XX  XX   "\
-          "  XX   XX  XX   "\
-          "  XXXXXXXXXXX   ";*/
 
   std::vector<std::string> arguments = {"--versus=o", "--number_of_tiles=2", "--compress_uniq", "--compress_linear", "--treemap"};
   ValueNotMatcher matcher(' ');
   Bitmap b(chunk, 16);
-
-  /*ClippedPolygonFinder pl(&b, &matcher, 0, 16, &arguments);
-  ProcessResult *pr = pl.process_info();
-  pr->print_polygons();
-  delete pr;*/
-
   Finder concurrentFinder(2, &b, &matcher, &arguments);
   ProcessResult *pro = concurrentFinder.process_info();
   pro->print_polygons();
@@ -107,7 +89,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);
@@ -155,7 +137,7 @@ void Tests::test_c()
 void Tests::test_d()
 { CpuTimer cpu_timer;
   cpu_timer.start();
-  FastPngBitmap png_bitmap("images/sample_10240x10240.png");
+  FastPngBitmap png_bitmap("../images/sample_10240x10240.png");
   // FastPngBitmap png_bitmap("images/labyrinth.png");
   std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
   std::cout << "immagine =" << cpu_timer.stop() << std::endl;
@@ -174,17 +156,30 @@ void Tests::test_d()
 void Tests::test_e()
 { CpuTimer cpu_timer;
   cpu_timer.start();
-  FastPngBitmap png_bitmap("images/sample_10240x10240.png");
+  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;
 }
+
+void Tests::test_f()
+{ FastPngBitmap png_bitmap("../images/labyrinth.png");
+  std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
+  std::cout << "load_error=" << png_bitmap.error() << std::endl;
+
+  std::string data_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+P+/HgAFhAJ/wlseKgAAAABJRU5ErkJggg==";
+  data_url.erase(0, 22);
+  RemoteFastPngBitmap bitmap(&data_url);
+  std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
+  std::cout << "load_error=" << bitmap.error() << std::endl;
+}

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

@@ -10,11 +10,10 @@
 
 class Tests {
  public:
-  Tests();
-  virtual ~Tests();
   virtual void test_a();
   virtual void test_b();
   virtual void test_c();
   virtual void test_d();
   virtual void test_e();
+  virtual void test_f();
 };

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) {
@@ -269,7 +289,7 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
         } else {
           for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
             for (Part* dest_part : shape->outer_polyline->parts()) {
-              if (dest_part->trasmuted) continue;
+              if (dest_part->trasmuted || dest_part->is(Part::EXCLUSIVE)) continue;
               if (dest_part->intersect_part(act_part)) {
                 std::vector<Point*> link_seq = duplicates_intersection(*dest_part, *act_part);
                 if (!link_seq.empty()) {

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,16 @@
 #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>(height);
   payloads_.resize(total_pixels);
   bitset_.resize((total_pixels + 63) / 64, 0);
   std::memset(bitset_.data(), 0, bitset_.size() * sizeof(uint64_t));
+  endpoint_pool_.resize(total_pixels);
 }
 
-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,8 +35,9 @@ class Hub {
  private:
   int width_;
   int height_;
-  std::vector<EndPoint*> payloads_;
-  std::deque<EndPoint> endpoint_pool_;
+  int start_x_;
+  std::vector<int> payloads_;
+  std::vector<EndPoint> endpoint_pool_;
   Hub(const Hub&) = delete;
   Hub& operator=(const Hub&) = delete;
   std::vector<uint64_t> bitset_;

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

@@ -44,7 +44,8 @@ Position* Part::next_position(Position* force_position) {
 
 void Part::add_position(Point* point) {
   Cluster* c = this->polyline_->tile->cluster;
-  c->positions_pool.emplace_back(c->hub(), point);
+  Hub* hub = is(EXCLUSIVE) ? nullptr : c->hub();
+  c->positions_pool.emplace_back(hub, point);
   this->add(&c->positions_pool.back());
 }
 

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;