contrek 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b46d3ae57168cfeb52a0788b6e11af74a164c8e19b4414783f95ac96d1507ed2
-  data.tar.gz: e0637093c914f2426a74b4a47ebeac34152ae473de619fda2e164f22c5d03bc8
+  metadata.gz: 0d4e8a9a3c94ae345edb0ecbb6087020141ad20cd2661e2b58578323a721f66e
+  data.tar.gz: ec99c9629d41d589e90ff39d8305c7e0355743b3f51caeb1e0a9da4702007fde
 SHA512:
-  metadata.gz: 472da77db1202e4cf38416e7c5dcfbd483a1f9b9fdb414afb3583a441c3ea180107741d1bc939270fb2aa46e54541712a0efc56f542abe9afd5f39d66e7c847a
-  data.tar.gz: 66ee95022392360b2cb9dbd9757d669a7f01cc95512ee4a74a288e7dc5c94657ebfc0ebe1107090b3e24df490462073f9ea3f2fd6cb57f7432214a809e486b0b
+  metadata.gz: 9180029576fc846f3cbc8adcd68e5f68374b49fb734db8352e9ced637a447cfad93beb37cb5206084b411f4cb5cc26de9a1ac075b09f8ce1b39bb6e33fadd018
+  data.tar.gz: 163a00611440eb83d538b4dcd3f3c36745350c1d34e657fcdae069dd8c8020f36eec005264bd581e2024fca772e7f53dc0f856d35eca4717b741b0bcbaa91e5a

data/CHANGELOG.md

@@ -83,4 +83,12 @@ All notable changes to this project will be documented in this file.
 
 ## [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.
+- 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.
+
+## [1.2.1] - 2026-05-09
+### Changed
+- Some c++ optimizations.
+
+## [1.2.2] - 2026-05-20
+### Changed
+- The treemap determination algorithm has been heavily optimized. Calls to the geometric routine that checks whether a newly generated inner polyline encloses other already-existing ones have been reduced to the minimum. Polylines adjacent to the shared overlap stripe are now excluded from these checks, as they are already identified during the initial polygon detection phase. The geometric approach remains unavoidable in this context and is still a performance bottleneck. It will certainly be the subject of future optimizations.

data/Gemfile.lock

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

data/PERFORMANCE.md

@@ -0,0 +1,177 @@
+# ⚡ Contrek Performance Tuning
+
+This document describes optional dependencies and configuration tips to get the best performance out of Contrek on large images.
+
+All optimizations are **optional** — Contrek works correctly without any of them. However, on high-resolution images (10k×10k and above), the combined effect is significant.
+
+---
+
+## Benchmark Reference
+
+> System: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro
+> Image: 20480×20480 pixels — 8 threads / 8 tiles
+>
+> **Note:** Benchmarks were measured inside a VMware virtual machine.
+
+| Configuration | Time |
+|---|---|
+| Baseline (no tuning) | 5316 ms |
+| **Fully tuned** | **2938.05 ms** |
+
+---
+
+## 1. zlib-ng — Faster PNG Decoding
+
+**Impact: ~57% reduction in PNG decode time**
+
+Contrek uses [libspng](https://libspng.org/) for PNG decoding, which internally relies on zlib for decompression. [zlib-ng](https://github.com/zlib-ng/zlib-ng) is a high-performance, drop-in replacement for zlib that uses modern CPU instructions (AVX2, SSE4) to significantly accelerate deflate decompression.
+
+If zlib-ng is not installed, standard zlib is used automatically — no errors, just slower PNG decoding.
+
+### Installation
+
+**Ubuntu / Debian** — not available in standard repos, build from source:
+
+```bash
+git clone https://github.com/zlib-ng/zlib-ng.git
+cd zlib-ng && mkdir build && cd build
+cmake .. -DZLIB_COMPAT=ON -DCMAKE_BUILD_TYPE=Release
+make -j$(nproc)
+sudo make install
+sudo ldconfig
+```
+
+> ⚠️ The `-DZLIB_COMPAT=ON` flag is mandatory. Without it, zlib-ng uses a different ABI and CMake's `find_package(ZLIB)` won't detect it.
+
+**macOS:**
+```bash
+brew install zlib-ng
+```
+
+**Arch Linux:**
+```bash
+sudo pacman -S zlib-ng
+```
+
+After installation, rebuild Contrek — CMake will automatically detect zlib-ng in `/usr/local` and use it instead of system zlib.
+
+---
+
+## 2. tcmalloc — Faster Memory Allocation
+
+**Impact: significant reduction in allocator contention under multithreaded load**
+
+Contrek creates and destroys large numbers of small objects during processing. Under multithreaded workloads, the standard glibc allocator serializes many of these operations, causing thread contention. [tcmalloc](https://github.com/google/tcmalloc) (Thread-Caching Malloc) is Google's high-performance allocator that maintains per-thread caches, dramatically reducing lock contention.
+
+### Installation
+
+**Ubuntu / Debian:**
+```bash
+sudo apt-get install libgoogle-perftools-dev
+```
+
+**macOS:**
+```bash
+brew install gperftools
+```
+
+CMake will detect tcmalloc automatically. You will see this confirmation during the build:
+```
+-- Contrek: tcmalloc found in /usr/lib/x86_64-linux-gnu/libtcmalloc.so
+```
+
+### Tuning tcmalloc cache size
+
+For large images with many threads, increasing the per-thread cache size reduces requests to the central allocator. Add this at the very beginning of your `main()`:
+
+```cpp
+#include <gperftools/malloc_extension.h>
+
+int main() {
+    MallocExtension::instance()->SetNumericProperty(
+        "tcmalloc.max_total_thread_cache_bytes",
+        1024 * 1024 * 1024  // 1GB total thread cache
+    );
+    // ...
+}
+```
+
+The default is 32MB total. On systems with 16GB+ RAM, 1GB is a safe value that virtually eliminates allocator contention.
+
+---
+
+## 3. Thread and Tile Configuration
+
+**Impact: up to ~35% reduction in processing time on multi-core systems**
+
+Contrek splits the image into vertical tiles processed in parallel. The optimal configuration depends on your hardware.
+
+### General rule
+
+Set both `threads` and `tiles` to the number of **physical cores** on your machine.
+
+```cpp
+Contrek::Config cfg;
+cfg.threads = 8;  // match your physical core count
+cfg.tiles   = 8;  // same as threads for best results
+```
+
+```ruby
+result = Contrek.contour!(
+  png_file_path: "image.png",
+  options: {
+    number_of_threads: 8,
+    finder: { number_of_tiles: 8 }
+  }
+)
+```
+
+### Why threads == tiles?
+
+- **Fewer tiles than threads**: some cores sit idle waiting for others to finish
+- **More tiles than threads**: merge overhead increases without adding parallelism  
+- **threads == tiles**: optimal balance between parallel scan and merge cost
+
+Consider this depends your system. Probably is better not to saturate all cores leaving one ot two to the system and the others to Contrek. So on 8 cpu core 6 thread/tiles at maximum.
+
+---
+
+## 4. Combining All Optimizations
+
+Install zlib-ng and tcmalloc, then configure:
+
+```ruby
+# Ruby
+result = Contrek.contour!(
+  png_file_path: "large_image.png",
+  options: {
+    number_of_threads: 8,   # match your core count (or 1-2 less)
+    class: "value_not_matcher",
+    color: { r: 255, g: 255, b: 255, a: 255 },
+    finder: {
+      number_of_tiles: 8,   # same as threads
+      compress: { uniq: true }
+    }
+  }
+)
+```
+
+```cpp
+// C++ standalone
+#include <gperftools/malloc_extension.h>
+#include "ContrekApi.h"
+
+int main() {
+    MallocExtension::instance()->SetNumericProperty(
+        "tcmalloc.max_total_thread_cache_bytes",
+        1024 * 1024 * 1024
+    );
+
+    Contrek::Config cfg;
+    cfg.threads = 8;
+    cfg.tiles   = 8;
+
+    auto result = Contrek::trace("large_image.png", cfg);
+    std::cout << "Time: " << result->total_time << " ms" << std::endl;
+}
+```

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
 
@@ -143,7 +158,8 @@ You can process from a raw stream
   [{:outer=>[{:x=>5, :y=>4}, {:x=>5, :y=>5}, {:x=>8, :y=>5}, {:x=>8, :y=>4}], :inner=>[]}]
 ```
 
-Multithreaded contour processing is supported. However, on Ruby MRI (the standard Ruby implementation, at least up to 3.x), the Global Interpreter Lock (GIL) prevents more than one thread from executing Ruby code simultaneously. As a consequence, execution remains effectively serialized even on multicore systems, unless the gem is used under JRuby or TruffleRuby (not tested).
+Multithreaded contour processing is supported by both the native C++ and pure Ruby implementations. When using the C++ engine (default), multithreading works as expected and fully utilizes all available cores.
+When running the pure Ruby implementation, however, the Global Interpreter Lock (GIL) in Ruby MRI (the standard Ruby interpreter, up to at least version 3.x) prevents true parallel execution — threads are serialized even on multicore systems. Switching to JRuby or TruffleRuby would bypass this limitation, though these runtimes have not been tested with Contrek.
 
 ```ruby
 result = Contrek.contour!(
@@ -167,7 +183,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.1 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!(
@@ -232,9 +248,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 +428,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.

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/contrek.gemspec

@@ -11,7 +11,11 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/runout77/contrek"
   s.licenses = ["MIT", "AGPL-3.0-only"]
   s.files = Dir.chdir(File.expand_path("..", __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(docs|pkg|spec)/}) }
+    `git ls-files -z`.split("\x0").reject do |f| 
+      f.match(%r{^(docs|pkg|spec)/}) || 
+      f.include?("PolygonFinder/images/") || 
+      f.include?("PolygonFinder/examples/")
+    end
   end
   s.metadata = {
     "homepage_uri" => "https://github.com/runout77/contrek",

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/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() {
@@ -54,7 +54,7 @@ Tile* Cluster::merge_tiles() {
   double tot_outer = 0;
   CpuTimer timer;
 
-  std::list<Shape*> new_shapes;
+  std::vector<Shape*> new_shapes;
   std::vector<InnerPolyline*> all_new_inner_polylines;
 
   timer.start();
@@ -69,7 +69,7 @@ Tile* Cluster::merge_tiles() {
   tot_outer += timer.stop();
 
   for (Tile* tile : tiles_) {
-    std::list<Shape*>& src = tile->shapes();
+    std::vector<Shape*>& src = tile->shapes();
 
     for (Shape* shape : src) {
       if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) {
@@ -86,7 +86,7 @@ Tile* Cluster::merge_tiles() {
 
         timer.start();
         std::vector<InnerPolyline*> new_inners = shape->inner_polylines;
-        std::vector<InnerPolyline*> new_inner_polylines = cursor.join_inners(new_outer);
+        std::vector<InnerPolyline*> new_inner_polylines = cursor.join_inners(new_outer, treemap);
         tot_inner += timer.stop();
 
         for (InnerPolyline* inner_polyline : new_inner_polylines) {
@@ -94,59 +94,44 @@ Tile* Cluster::merge_tiles() {
           if (treemap) {
             inner_polyline->sequence()->compute_vertical_bounds();
             all_new_inner_polylines.push_back(inner_polyline);
-            for (const auto orphan_inner : cursor.orphan_inners()) {
-              if (orphan_inner->recombined()) {
-                all_new_inner_polylines.push_back(orphan_inner);
-              }
-            }
           }
         }
-
         for (auto s : cursor.orphan_inners()) {
           new_inners.push_back(s);
         }
-
         Polyline* polyline = tile->shapes_pool->acquire_polyline(tile, new_outer->to_vector(), std::nullopt);
         Shape* inserting_new_shape = tile->shapes_pool->acquire_shape(polyline, new_inners);
-
         new_shapes.push_back(inserting_new_shape);
         polyline->shape = inserting_new_shape;
-        inserting_new_shape->set_parent_shape(shape->parent_shape());
 
         for (InnerPolyline* inner_polyline : new_inner_polylines) {
           inner_polyline->sequence()->shape = inserting_new_shape;
         }
-
         if (treemap) {
           for (const auto merged_shape : cursor.shapes_sequence()) {
             merged_shape->merged_to_shape = inserting_new_shape;
           }
-          this->assign_ancestry(inserting_new_shape, all_new_inner_polylines);
+          InnerPolyline* inside_inner_polyline = shape->outer_polyline->inside_inner_polyline;
+          if (inside_inner_polyline) {
+            assign_ancestry(inserting_new_shape, inside_inner_polyline);
+          }
         }
-
       } else {
-        if (treemap && !shape->reassociation_skip && shape->parent_shape() == nullptr) {
-          this->assign_ancestry(shape, all_new_inner_polylines);
+        if (treemap) {
+          if (shape->fixed) {
+            Shape* ms = shape->parent_shape()->merged_to_shape;
+            if (ms) {
+              shape->set_parent_shape(ms);
+            }
+          } else {
+            is_children(shape, all_new_inner_polylines);
+          }
         }
         new_shapes.push_back(shape);
       }
     }
   }
 
-  if (treemap) {
-    for (Tile* tile : tiles_) {
-      for (Shape* shape : tile->shapes()) {
-        Shape* parent = shape->parent_shape();
-        while (parent && parent->merged_to_shape != nullptr) {
-          parent = parent->merged_to_shape;
-        }
-        if (parent != shape->parent_shape()) {
-          shape->set_parent_shape(parent);
-        }
-      }
-    }
-  }
-
   double past_tot_outer = tiles_.front()->benchmarks.outer + tiles_.back()->benchmarks.outer;
   double past_tot_inner = tiles_.front()->benchmarks.inner + tiles_.back()->benchmarks.inner;
 
@@ -165,16 +150,22 @@ Tile* Cluster::merge_tiles() {
   return tile;
 }
 
-void Cluster::assign_ancestry(Shape *shape, std::vector<InnerPolyline*>& inner_polylines)
-{ for (auto* inner_polyline : inner_polylines) {
-    if (shape->outer_polyline->vert_bounds_intersect(inner_polyline->vertical_bounds())) {
-      if (shape->outer_polyline->within(inner_polyline->raw())) {
-        shape->set_parent_shape(inner_polyline->shape());
-        shape->parent_inner_polyline = inner_polyline;
-        for (auto* children_shape : shape->children_shapes) {
-          children_shape->reassociation_skip = true;
-        }
-      }
+void Cluster::assign_ancestry(Shape *shape, InnerPolyline* inner_polyline)
+{ shape->set_parent_shape(inner_polyline->sequence()->shape);
+  shape->parent_inner_polyline = inner_polyline;
+  shape->fixed = true;
+}
+
+void Cluster::is_children(Shape* shape, std::vector<InnerPolyline*> inner_polylines) {
+  int shape_max_y = shape->outer_polyline->max_y();
+  int shape_min_y = shape->outer_polyline->min_y();
+  for (InnerPolyline* inner_polyline : inner_polylines) {
+    Bounds bounds = inner_polyline->vertical_bounds();
+    int min_y = bounds.min;
+    int max_y = bounds.max;
+    if (shape_max_y < min_y || shape_min_y > max_y ) continue;
+    if (shape->outer_polyline->within(inner_polyline->raw())) {
+      assign_ancestry(shape, inner_polyline);
     }
   }
 }

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

@@ -21,7 +21,8 @@ class Cluster {
   Finder *finder;
   std::vector<Tile*> tiles_;
   Hub *hub_ = nullptr;
-  void assign_ancestry(Shape *shape, std::vector<InnerPolyline*>& inner_polylines);
+  void assign_ancestry(Shape *shape, InnerPolyline* inner_polyline);
+  void is_children(Shape* shape, std::vector<InnerPolyline*> inner_polylines);
 
  public:
   Cluster(Finder *finder, int height, int start_x, int end_x);