contrek 1.1.9 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87e8665985a5c9b3818f5f405609c8bf0f9d81dfaa197054e0801acdc60dc56c
-  data.tar.gz: 450c56eda5bd65ab936fcd52b37e3f8edbc2ec0ac852aa0cc4c052ee6d81ab7e
+  metadata.gz: 3e7576fef74116c62a018f66a13d9e29d215f7b505637b40bcb16631250fed0d
+  data.tar.gz: 7ba2f39e97a44eaddd13361b4dc5a8f8cb1790a93dab327c1794d61e0ffc45a0
 SHA512:
-  metadata.gz: e4cc2ea0d61819436e922eacdcad551658deceac1b5a907cea03d306de65fa2f71b96018acf6fcc6f88163775cabf0ba9b8d6ded3e9067dfcf3cc3e70d3e3e6d
-  data.tar.gz: ca933647465baca8a294176a1fbbc336bf1956c8eebab2cf48dd45ac4e55ba55ea84b00d38cbdd9ee0cf012b332684b8902c5e98a8cbaaafbfc846b374a12801
+  metadata.gz: 748e4750b607bc2a9e9e916fc0a00a96db530e94658822d1d6eb97508fa9e302e5def958a63e621a2f97be1396bb0acad4971aea936cbca700c1ea93ac5acdaf
+  data.tar.gz: 804a329359ea6648e4bcbf4babdb8af53a12205851d669b562fa37d5aa69a49f8b6988a143f2783c85b2681432f65ff52b82db8f207718bd29b16c46882f518d

data/CHANGELOG.md

@@ -80,3 +80,7 @@ All notable changes to this project will be documented in this file.
 ## [1.1.9] - 2026-04-24
 ### Changed
 - Improved the internal parts joining algorithm, which was imprecise in some circumstances.
+
+## [1.2.0] - 2026-05-02
+### Changed
+- Further improvements have been applied to the internal parts joining algorithm using a new structural approach. This update is faster and resolves edge cases where inner parts were mistakenly classified as outer perimeters, ensuring precise contour hierarchy. The simplified logic has led to a significant reduction in codebase complexity and the removal of substantial redundant code.

data/Gemfile.lock

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

data/README.md

@@ -49,6 +49,17 @@ The core strength of Contrek is its **Topologically Consistent Merging** algorit
   </tr>
 </table>
 
+## 📊 Benchmarking & Performance
+The **Stripe-Merging** algorithm has been validated through a dedicated testing suite comparing **Contrek** against **OpenCV** (industry-standard contour extraction).
+
+### Key Metrics:
+* **Execution Latency:** Single-threaded OpenCV vs. Contrek's parallel thread management.
+* **Memory Footprint:** RAM consumption during ultra-high-resolution processing.
+* **Extraction Fidelity:** Verifying polygon precision across both engines.
+
+The complete testing suite, source code, and raw benchmarks are available here:
+👉 **[test_opencv_contrek](https://github.com/runout77/test_opencv_contrek)**
+
 ## Prerequisites
 
 For optimal performance and efficient memory management with large images (20k+), it is highly recommended to install **tcmalloc**.
@@ -57,7 +68,11 @@ For optimal performance and efficient memory management with large images (20k+)
 ```bash
 sudo apt-get install libgoogle-perftools-dev
 ```
+> For advanced performance tuning (zlib-ng, tcmalloc, thread configuration) see [PERFORMANCE.md](PERFORMANCE.md).
 
+> ⚠️ **Platform support:** Contrek native extensions are supported on **Linux** and **macOS** only. 
+> Windows is not supported due to the use of POSIX threading primitives and platform-specific 
+> memory management. On Windows, consider using WSL2 (Windows Subsystem for Linux).
 
 ## Install
 
@@ -167,7 +182,7 @@ Regarding multithreading:
 
 - The algorithm splits the contour-detection workflow into multiple phases that can be executed in parallel. The initial contour extraction on each band and the subsequent merging of coordinates between adjacent bands—performed pairwise, recursively, and in a non-deterministic order—results in a final output that is not idempotent. Idempotence is guaranteed only when the exact same merging sequence is repeated.
 
-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 4 threads working on 4 tiles (total compute time about 1.2 secs with image load).
+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 4 threads working on 4 tiles (total compute time about 0.816 secs with image load (0.37 secs)).
 
 ```ruby
 result = Contrek.contour!(
@@ -181,11 +196,11 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{ compress: 26.37,
-  init: 354.339,
-  inner: 17.9427,
-  outer: 93.6252,
-  total: 380.709
+{ compress: 23.83,
+  init: 313.179,
+  inner: 6.16,
+  outer: 78.791,
+  total: 337.013
 }
 
 ```
@@ -232,9 +247,10 @@ Engineered for **Pixel-Perfect** precision.
 * **Result:** 100% topologically faithful geometry with no micro-gaps between adjacent polygons.
 
 Below are two images illustrating the difference in tracing modes. In the first case, with **strict_bounds ON**, the anti-clockwise sequence includes two additional points, **H** and **I**, which trace the shape more accurately. In the second case, the transition between **G** and **H** is approximated, omitting the indentation.
+
 | Strict Bounds ON | Strict Bounds OFF |
 |:---:|:---:|
-| ![Originale](./docs/images/strict_bounds_on.png) | ![Poligoni](./docs/images/strict_bounds_off.png) |
+| <img src="./docs/images/strict_bounds_on.png" alt="Originale" width="60%"/> | <img src="./docs/images/strict_bounds_off.png" alt="Poligoni" width="60%"/> |
 
 
 ## Result
@@ -411,6 +427,8 @@ This the one for the native C++
 
 About 130x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
 
+**Note:** Benchmarks were measured inside a VMware virtual machine.
+
 ## 🛠 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.
@@ -483,9 +501,12 @@ int main() {
 
 ## License
 
-This project is licensed under the terms of a dual-license.
+Contrek uses a dual-license model:
+
+- **Ruby gem and wrappers** — [MIT](lib/LICENSE-MIT.md). Free to use in any project, including commercial ones.
+- **C++17 core engine** (`ext/cpp_polygon_finder/PolygonFinder`) — [AGPLv3](ext/cpp_polygon_finder/PolygonFinder/LICENSE_AGPL.txt). If you use the core in a SaaS or closed-source product, you must either open your source or [contact the author](https://github.com/runout77) for a commercial license.
 
-See [LICENSE.md](LICENSE.md).
+See [LICENSE.md](LICENSE.md) for full details.
 
 ## Changelog
 

data/Rakefile

@@ -6,7 +6,7 @@ task :compile do |t|
     Dir.glob("**/*.o").each { |f| File.delete(f) }
     File.delete("Makefile") if File.exist?("Makefile")
     system "ruby", "extconf.rb"
-    system "make", "-B"
+    system "make", "-j#{`nproc`.strip}", "-B"
     Dir.glob("**/*.o").each { |f| File.delete(f) }
     system "cp cpp_polygon_finder.so ./../../lib"
   end

data/ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt

@@ -1,6 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
 project(ContrekCore C CXX)
-
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_C_STANDARD 11)
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -22,28 +21,27 @@ else()
         message(WARNING "Contrek: tcmalloc not found; standard one will be used.")
     endif()
 endif()
-
 find_package(ZLIB REQUIRED)
-
+message(STATUS "Contrek: ZLIB path found at ${ZLIB_LIBRARIES}")
 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)
-
+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")
@@ -56,4 +54,4 @@ if(BUILD_EXAMPLES)
     else()
         message(WARNING "Contrek: examples/example.cpp not found!")
     endif()
-endif()
+endif()

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

@@ -8,6 +8,7 @@
  */
 
 #include <iostream>
+#include <gperftools/malloc_extension.h>
 #include "ContrekApi.h"
 #include "Tests.h"
 
@@ -29,6 +30,11 @@ void run_test() {
 }
 
 int main() {
+  MallocExtension::instance()->SetNumericProperty(
+      "tcmalloc.max_total_thread_cache_bytes",
+      1024 * 1024 * 1024
+  );
+
   Contrek::Config cfg;
   cfg.threads = 4;
   cfg.tiles = 4;

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

@@ -98,7 +98,7 @@ void Tests::test_c()
   Point* p2 = new Point({2, 2});
   Point* p3 = new Point({3, 3});
 
-  Hub* hub = new Hub(4, 0, 3);
+  Hub* hub = new Hub(4);
 
   Position* pos1 = new Position(hub, p1);
   Position* pos2 = new Position(hub, p2);

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

@@ -17,6 +17,8 @@
 #include "Node.h"
 #include "NodeCluster.h"
 
+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)
 : start_point(min_x, y),
   end_point(max_x, y),

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

@@ -14,8 +14,43 @@
 #include <limits>
 #include <algorithm>
 #include <map>
+#include <cstring>
+#include <cstddef>
 #include "List.h"
 
+struct SmallVec {
+  static constexpr int INLINE_CAP = 6;
+  int  buf[INLINE_CAP];
+  int* ptr = buf;
+  int  sz = 0, cap = INLINE_CAP;
+  int  front() const { return ptr[0]; }
+  int  back()  const { return ptr[sz - 1]; }
+  void push_back(int v) {
+      if (sz == cap) {
+          cap *= 2;
+          int* np = new int[cap];
+          std::memcpy(np, ptr, sz * sizeof(int));
+          if (ptr != buf) delete[] ptr;
+          ptr = np;
+      }
+      ptr[sz++] = v;
+  }
+  void reserve(int n) {
+      if (n <= cap) return;
+      int* np = new int[n];
+      std::memcpy(np, ptr, sz * sizeof(int));
+      if (ptr != buf) delete[] ptr;
+      ptr = np; cap = n;
+  }
+  void clear() { sz = 0; ptr = buf; cap = INLINE_CAP; }
+  int  size()  const { return sz; }
+  int& operator[](int i) { return ptr[i]; }
+  int  operator[](int i) const { return ptr[i]; }
+  int* begin() { return ptr; }
+  int* end()   { return ptr + sz; }
+  ~SmallVec() { if (ptr != buf) delete[] ptr; }
+};
+
 class NodeCluster;
 struct Point {
   int x;
@@ -42,7 +77,6 @@ class Node : public  Listable {
   static const int OCOMPLETE = OMIN | OMAX;
   static const int TURN_MAX = IMAX | OMAX;
   static const int TURN_MIN = IMIN | OMIN;
-  const int TURNER[2][2] = {{OMAX, OMIN}, {TURN_MAX, TURN_MIN}};
   static const int OUTER = 0;
   static const int INNER = 1;
 
@@ -60,7 +94,7 @@ class Node : public  Listable {
   Point start_point, end_point;
   NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
-  std::vector<int> tangs_sequence;
+  SmallVec tangs_sequence;
   Point* coords_entering_to(Node *enter_to, int mode, int tracking);
   Node* my_next_outer(Node *last, int versus);
   Node* my_next_inner(Node *last, int versus);

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

@@ -35,6 +35,7 @@ NodeCluster::NodeCluster(int h, int w, pf_Options *options) {
   this->root_nodes = this->lists.add_list();
   this->inner_plot = this->lists.add_list();
   this->inner_new = this->lists.add_list();
+  this->plot_sequence.reserve(1024);
 }
 
 NodeCluster::~NodeCluster() {
@@ -68,8 +69,8 @@ void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options optio
 }
 
 void NodeCluster::build_tangs_sequence() {
-  for (auto& line : vert_nodes) {
-    for (Node& node : line) {
+  for (int y = 0; y < (int)vert_nodes.size(); y++) {
+    for (Node& node : vert_nodes[y]) {
       node.precalc_tangs_sequences(*this);
     }
   }
@@ -94,8 +95,7 @@ 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) break;
-        int current_index = std::distance(up_nodes.begin(), it);
-        node.add_intersection(*it, current_index);
+        node.add_intersection(*it, it->abs_x_index);
         it->add_intersection(node, node.abs_x_index);
         ++it;
       }

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

@@ -20,7 +20,7 @@
 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, start_x, end_x);
+  this->hub_ = new Hub(height);
 }
 
 Cluster::~Cluster() {
@@ -63,7 +63,6 @@ Tile* Cluster::merge_tiles() {
       if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) continue;
       if (shape->outer_polyline->boundary()) {
         shape->outer_polyline->partition();
-        shape->outer_polyline->precalc();
       }
     }
   }
@@ -77,7 +76,7 @@ Tile* Cluster::merge_tiles() {
         continue;
       }
 
-      if (shape->outer_polyline->boundary() && !shape->outer_polyline->next_tile_eligible_shapes().empty()) {
+      if (shape->outer_polyline->any_ancients) {
         Cursor cursor(*this, shape);
         Sequence* new_outer = nullptr;
 

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

@@ -56,7 +56,6 @@ void Cursor::traverse_outer(Part* act_part,
     if (all_parts.empty() || last_part != act_part) {
       all_parts.push_back(act_part);
     }
-
     bool jumped_to_new_part = false;
     if (act_part->is(Part::EXCLUSIVE)) {
       if (act_part->size == 0) return;
@@ -82,36 +81,45 @@ void Cursor::traverse_outer(Part* act_part,
         }
         this->cluster.positions_pool.emplace_back(this->cluster.hub(), new_position->payload);
         outer_joined_polyline->add(&this->cluster.positions_pool.back());
-
-        for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
-          if (Part *part = shape->outer_polyline->find_first_part_by_position(new_position, act_part->versus())) {
-            const auto n = all_parts.size();
-            Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
-
-            if (last_last_part != part) {
-              if (n >= 2) {
-                bool all_seam = true;
-                for (std::size_t i = all_parts.size() - 2; i < all_parts.size(); ++i) {
-                  if (all_parts[i]->type != Part::SEAM) {
-                    all_seam = false;
-                    break;
-                  }
+        new_position->end_point()->tracked_outer = true;
+        int versus = act_part->versus();
+        auto& q_set = new_position->end_point()->queues();
+        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;
+        });
+
+        Part* part = nullptr;
+        if (it != q_set.end()) {
+          part = static_cast<Part*>(*it);
+        }
+        if (part) {
+          const auto n = all_parts.size();
+          Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
+          if (last_last_part != part) {
+            if (n >= 2) {
+              bool all_seam = true;
+              for (std::size_t i = all_parts.size() - 2; i < all_parts.size(); ++i) {
+                if (all_parts[i]->type != Part::SEAM) {
+                  all_seam = false;
+                  break;
                 }
-                if (all_seam) break;
-              }
-              if (shapes_sequence_lookup.insert(part->polyline()->shape).second) {
-                shapes_sequence.push_back(part->polyline()->shape);
               }
-              part->next_position(new_position);
-              part->dead_end = true;
-              act_part = part;
-              jumped_to_new_part = true;
-              break;
+              if (all_seam) break;
+            }
+            if (shapes_sequence_lookup.insert(part->polyline()->shape).second) {
+              shapes_sequence.push_back(part->polyline()->shape);
             }
+            part->next_position(new_position);
+            part->dead_end = true;
+            act_part = part;
+            jumped_to_new_part = true;
+            break;
           }
         }
-        if (jumped_to_new_part) break;
-        act_part->next_position(nullptr);
+        if (!jumped_to_new_part) {
+          act_part->next_position(nullptr);
+        }
       }
     }
     if (jumped_to_new_part) continue;
@@ -122,107 +130,11 @@ void Cursor::traverse_outer(Part* act_part,
 }
 
 std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
-  std::vector<InnerPolyline*> retme;
-  std::vector<Shape*> missing_shapes;
-
-  for (Tile *tile : this->cluster.tiles())
-  { for (Shape *shape : tile->shapes())
-    { if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) ||
-        shape->outer_polyline->is_on(Polyline::TRACKED_INNER) ||
-        !shape->outer_polyline->boundary() ||
-        std::find(shapes_sequence_.begin(), shapes_sequence_.end(), shape) != shapes_sequence_.end()) {
-        continue;
-      }
-      missing_shapes.push_back(shape);
-    }
-  }
-
-  if (missing_shapes.size() > 0) {
-    std::vector<Shape*> to_delay_shapes;
-    to_delay_shapes = connect_missings(this->shapes_sequence_, missing_shapes);
-    if (!to_delay_shapes.empty())
-    { connect_missings(to_delay_shapes, missing_shapes);
-      while (!to_delay_shapes.empty()) {
-        to_delay_shapes = connect_missings(this->shapes_sequence_, to_delay_shapes);
-      }
-    }
-  }
-
-  retme = collect_inner_sequences(outer_seq);
-  for (Shape* shape : shapes_sequence_) {
-    shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
-  }
-  return(retme);
-}
-
-std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes) {
-  std::vector<Shape*> delay_shapes;
-
-  for (Shape* shape : shapes_sequence)
-  { Polyline* polyline = shape->outer_polyline;
-    for (Shape* missing_shape : missing_shapes)
-    { Polyline* outer_polyline = missing_shape->outer_polyline;
-      if ( (polyline->mixed_tile_origin == false && outer_polyline->tile == polyline->tile) ||
-           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 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;
-          unique.reserve(sewn_sequence.size());
-          for (Point* p : sewn_sequence) {
-            if (!p) continue;
-            auto it = std::find_if(
-              unique.begin(), unique.end(),
-              [&](Point* up) {
-                  return up && *up == *p;
-              });
-            if (it == unique.end()) unique.push_back(p);
-          }
-          sewn_sequence.swap(unique);
-
-          if (sewn_sequence.size() <= 1) continue;
-
-          int first_x = sewn_sequence.front()->x;
-          bool different_x = false;
-          for (Point* p : sewn_sequence) {
-            if (p->x != first_x) {
-              different_x = true;
-              break;
-            }
-          }
-          if (different_x) {
-            orphan_inners_.push_back(outer_polyline->tile->shapes_pool->acquire_inner_polyline(sewn_sequence, shape, true));
-          }
-        }
-        polyline->mixed_tile_origin = true;
-        outer_polyline->clear();
-        outer_polyline->turn_on(Polyline::TRACKED_OUTER);
-        outer_polyline->turn_on(Polyline::TRACKED_INNER);
-        orphan_inners_.insert(
-          orphan_inners_.end(),
-          missing_shape->inner_polylines.begin(),
-          missing_shape->inner_polylines.end());
-      }
-    }
-  }
-
-  return(delay_shapes);
-}
-
-std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
   std::vector<InnerPolyline*> return_inner_polylines;
-
-  for (Shape* shape : shapes_sequence_)
-  { Polyline* polyline = shape->outer_polyline;
+  std::vector<Shape*> processing_queue = shapes_sequence_;
+  for (size_t i = 0; i < shapes_sequence_.size(); ++i)
+  { Shape* shape = shapes_sequence_[i];
+    Polyline* polyline = shape->outer_polyline;
     for (Part* part : polyline->parts())
     { if (part->innerable())
       { std::vector<Part*> all_parts;
@@ -232,7 +144,6 @@ std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq)
         };
         traverse_inner(part, all_parts, bounds);
         Sequence* retme_sequence = shape->outer_polyline->tile->shapes_pool->acquire_sequence();
-
         for (Part* part : all_parts)
         { part->touch();
           retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
@@ -242,7 +153,7 @@ std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq)
               position->payload->y <= bounds.max)) {
             return(false);
           }
-            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->queues_include(outer_seq)));
+            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->tracked_outer));
           });
         }
         if (retme_sequence->is_not_vertical()) {
@@ -270,27 +181,39 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     if (act_part->innerable()) {
       all_parts.push_back(act_part);
       bool jumped = false;
-      while (act_part = act_part->next) {
+      while (act_part = act_part->circular_next) {
         if (act_part->innerable()) {
             all_parts.push_back(act_part);
         } else {
-          for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
-            for (Part* dest_part : shape->outer_polyline->parts()) {
-              if (dest_part->trasmuted || dest_part->is(Part::EXCLUSIVE)) continue;
+          if (act_part->head)
+          { for (auto dest_part_p : static_cast<Position*>(act_part->head)->end_point()->queues()) {
+              Part* dest_part = static_cast<Part*>(dest_part_p);
+              if (dest_part->polyline()->tile == act_part->polyline()->tile) {
+                continue;
+              }
               int dest_part_versus = dest_part->versus();
               if (dest_part_versus != 0 && dest_part_versus == act_part->versus()) continue;
-              if (dest_part->intersect_part(act_part)) {
-                std::vector<EndPoint*> link_seq = dest_part->continuum_to(*act_part);
-                if (!link_seq.empty()) {
-                  Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
-                  for (EndPoint* pos : link_seq) {
-                    this->cluster.positions_pool.emplace_back(pos);
-                    ins_part->add(&this->cluster.positions_pool.back());
-                  }
-                  all_parts.push_back(ins_part);
+              std::vector<EndPoint*> link_seq = dest_part->continuum_to(*act_part);
+              if (!link_seq.empty()) {
+                Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
+                for (EndPoint* pos : link_seq) {
+                  this->cluster.positions_pool.emplace_back(pos);
+                  ins_part->add(&this->cluster.positions_pool.back());
                 }
-                shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
-                shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
+                all_parts.push_back(ins_part);
+              }
+              Shape* shape = dest_part->polyline()->shape;
+              if (!dest_part->polyline()->is_on(Polyline::TRACKED_OUTER))
+              { shapes_sequence_.push_back(shape);
+                orphan_inners_.insert(
+                  orphan_inners_.end(),
+                  shape->inner_polylines.begin(),
+                  shape->inner_polylines.end());
+              }
+              dest_part->polyline()->turn_on(Polyline::TRACKED_OUTER);
+              if (!dest_part->touched()) {
+                dest_part->touch();
+
                 act_part = dest_part->circular_next;
                 jumped = true;
                 break;
@@ -298,7 +221,6 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
             }
             if (jumped) break;
           }
-          if (jumped) break;
           if (act_part->is(Part::SEAM)) {
             all_parts.push_back(act_part);
           }
@@ -313,17 +235,3 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     else break;
   }
 }
-
-std::vector<std::vector<Point*>> Cursor::combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb)
-{ std::vector<std::vector<Point*>> rets;
-  size_t n = std::min(seqa.size(), seqb.size());
-  for (size_t i = 0; i < n; ++i) {
-    std::vector<Point*> last = std::move(seqa.back());
-    seqa.pop_back();
-    std::vector<Point*> first = std::move(seqb.front());
-    seqb.erase(seqb.begin());
-    first.insert(first.end(), last.begin(), last.end());
-    rets.push_back(std::move(first));
-  }
-  return rets;
-}

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

@@ -35,8 +35,6 @@ class Cursor {
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
                       Sequence* outer_joined_polyline);
-  std::vector<InnerPolyline*> collect_inner_sequences(Sequence* outer_seq);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
-  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*> shapes_sequence, std::vector<Shape*> missing_shapes);
 };

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

@@ -20,9 +20,11 @@ class EndPoint {
 
   void set_point(Point* p) { point_ = p; }
   Point* get_point() const { return point_; }
-  std::unordered_set<Queueable<Point>*>& queues() { return queues_; }
+  std::vector<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
+  bool tracked_outer = false;
+
  private:
   Point* point_;
-  std::unordered_set<Queueable<Point>*> queues_;
+  std::vector<Queueable<Point>*> queues_;
 };

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

@@ -10,8 +10,8 @@
 #include "Hub.h"
 #include <cstring>
 
-Hub::Hub(int height, int start_x, int end_x)
-    : width_(end_x - start_x), height_(height), start_x_(start_x)
+Hub::Hub(int height)
+    : height_(height)
 { size_t total_pixels = static_cast<size_t>(height);
   payloads_.resize(total_pixels);
   bitset_.resize((total_pixels + 63) / 64, 0);