contrek 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e7576fef74116c62a018f66a13d9e29d215f7b505637b40bcb16631250fed0d
-  data.tar.gz: 7ba2f39e97a44eaddd13361b4dc5a8f8cb1790a93dab327c1794d61e0ffc45a0
+  metadata.gz: 07f6097c256b6d44373aa941b969b12dd68630e168c72b29d1ae478bb5f48186
+  data.tar.gz: 7ec31b1ef4413e679e31a123f367d0a86ed332160455c8024ea185ca67c27020
 SHA512:
-  metadata.gz: 748e4750b607bc2a9e9e916fc0a00a96db530e94658822d1d6eb97508fa9e302e5def958a63e621a2f97be1396bb0acad4971aea936cbca700c1ea93ac5acdaf
-  data.tar.gz: 804a329359ea6648e4bcbf4babdb8af53a12205851d669b562fa37d5aa69a49f8b6988a143f2783c85b2681432f65ff52b82db8f207718bd29b16c46882f518d
+  metadata.gz: c03213b7499e5741bf3c90044251a5ba6fc606905f3c72ff93462a62ffc116ebae7ce211fb2a201862d874ae865df048e45cf85beed094bc60967d2b4dd6fc34
+  data.tar.gz: ae891e55d9d9ef5503f654d79c7187713579c6fa1c699736d446d6b19497ddb9d30723a26e98a77261481f364466b7d891962e9937433a65e6e341f240129faa

data/CHANGELOG.md

@@ -83,4 +83,19 @@ 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.
+
+## [1.2.3] - 2026-05-23
+### Changed
+### Changed
+* **SVG Conversion:** Added utility methods to convert point coordinates directly into SVG paths.
+* **Contrek API & RAII Architecture:** Refactored the Contrek API to utilize an RAII (Resource Acquisition Is Initialization) pattern, safely wrapping both the trace engine and the processing results within a unified context lifecycle shell.
+* **ProcessResult Memory Management:** Updated `ProcessResult` to properly manage resource deallocation during cloning operations, ensuring deep-copied or moved internal points are automatically and safely freed when the context scope ends.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.2.0)
+    contrek (1.2.3)
       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

@@ -158,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!(

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/src/ContrekApi.h

@@ -13,6 +13,7 @@
 #include <vector>
 #include <memory>
 #include <cstdint>
+#include <string_view>
 
 #include "Finder.h"
 #include "FastPngBitmap.h"
@@ -43,21 +44,44 @@ struct Config {
   Connectivity connectivity_mode = Connectivity::ORTHOGONAL;
 };
 
-inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const Config& cfg = Config()) {
-  auto bitmap = std::make_unique<FastPngBitmap>(image_path);
+struct TraceContext {
+  std::unique_ptr<FastPngBitmap> bitmap;
+  std::unique_ptr<Matcher> matcher;
+  std::vector<std::string> internal_args;
+  std::unique_ptr<Finder> finder;
+  std::unique_ptr<ProcessResult> result;
+
+  // this allows result direct access
+  const ProcessResult* operator->() const { return result.get(); }
+  ProcessResult* operator->() { return result.get(); }
+  const ProcessResult& operator*() const { return *result; }
+  ProcessResult& operator*() { return *result; }
+
+  // context can be moved not copied
+  TraceContext() = default;
+  TraceContext(const TraceContext&) = delete;
+  TraceContext& operator=(const TraceContext&) = delete;
+  TraceContext(TraceContext&&) = default;
+  TraceContext& operator=(TraceContext&&) = default;
+};
+
+inline TraceContext trace(const std::string& image_path, const Config& cfg = Config()) {
+  TraceContext ctx;
+
+  ctx.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;
+                             ? ctx.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);
+    ctx.matcher = std::make_unique<RGBNotMatcher>(color_to_match);
   } else {
-    matcher = std::make_unique<RGBMatcher>(color_to_match);
+    ctx.matcher = std::make_unique<RGBMatcher>(color_to_match);
   }
 
-  std::vector<std::string> internal_args = {"--versus=a"};
+  ctx.internal_args = {"--versus=a"};
+
   struct Mapping { bool flag; std::string_view arg; };
   const Mapping mappings[] = {
     {cfg.compress_unique,      "--compress_uniq"},
@@ -65,18 +89,17 @@ inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const
     {cfg.compress_visvalingam, "--compress_visvalingam"},
     {cfg.treemap,              "--treemap"}
   };
-
-  for (auto& m : mappings) {
-      if (m.flag) internal_args.emplace_back(m.arg);
+  for (const auto& m : mappings) {
+    if (m.flag) ctx.internal_args.emplace_back(m.arg);
   }
-  internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
+  ctx.internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
   if (cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
-    internal_args.push_back("--connectivity=" + std::to_string(8));
+    ctx.internal_args.push_back("--connectivity=" + std::to_string(8));
   }
+  ctx.finder = std::make_unique<Finder>(cfg.threads, ctx.bitmap.get(), ctx.matcher.get(), &ctx.internal_args);
+  ctx.result = std::unique_ptr<ProcessResult>(ctx.finder->process_info());
 
-  Finder finder(cfg.threads, bitmap.get(), matcher.get(), &internal_args);
-
-  return std::unique_ptr<ProcessResult>(finder.process_info());
+  return ctx;
 }
 
 }  // namespace Contrek

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

@@ -342,17 +342,18 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height) {
 
     std::cout << "Merging polygons ..." << std::endl;
     ProcessResult *merged_result = vmerger.process_info();
-    std::cout << "Founds total polygons: " << merged_result->groups << std::endl;
 
     if (merged_result) {
-      RawBitmap full_bitmap;
+      std::cout << "Founds total polygons: " << merged_result->groups << std::endl;
+      /*RawBitmap full_bitmap;
       full_bitmap.define(total_width, total_height, 4, true);
       full_bitmap.fill(255, 255, 255);
       merged_result->draw_on_bitmap(full_bitmap);
       std::cout << "Saving whole png ..." << std::endl;
       if (full_bitmap.save_to_png("whole.png")) {
         std::cout << "Png saved!" << std::endl;
-      }
+      }*/
+      merged_result->save_svg("whole.svg");
     }
     delete merged_result;
     // frees memory

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

@@ -14,7 +14,12 @@
 #include <string>
 #include <map>
 #include <iostream>
+#include <memory>
 #include <utility>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+#include <limits>
 #include "../bitmaps/Bitmap.h"
 #include "NodeCluster.h"
 #include "Node.h"
@@ -58,6 +63,8 @@ struct ProcessResult {
   std::list<Polygon> polygons;
   std::string named_sequence;
   std::vector<std::pair<int, int>> treemap;
+  std::vector<std::unique_ptr<Point>> cloned_points_storage;
+
   void draw_on_bitmap(RawBitmap& canvas) const;
 
   void print_polygons() {
@@ -103,14 +110,22 @@ struct ProcessResult {
     new_res->named_sequence = this->named_sequence;
     new_res->treemap = this->treemap;
 
+    size_t estimated_points = 0;
+    for (const auto& poly : this->polygons) {
+      estimated_points += poly.outer.size();
+      for (const auto& seq : poly.inner) estimated_points += seq.size();
+    }
+    new_res->cloned_points_storage.reserve(estimated_points);
+
     for (const auto& poly : this->polygons) {
       Polygon new_poly;
-      // Bounds
+      // bounds
       new_poly.bounds = poly.bounds;
       // outer
       for (const Point* p : poly.outer) {
         if (p) {
-          new_poly.outer.push_back(new Point(p->x, p->y));
+          new_res->cloned_points_storage.push_back(std::make_unique<Point>(p->x, p->y));
+          new_poly.outer.push_back(new_res->cloned_points_storage.back().get());
         }
       }
       // inner
@@ -118,7 +133,8 @@ struct ProcessResult {
         std::vector<Point*> new_seq;
         for (const Point* p : seq) {
           if (p) {
-            new_seq.push_back(new Point(p->x, p->y));
+            new_res->cloned_points_storage.push_back(std::make_unique<Point>(p->x, p->y));
+            new_seq.push_back(new_res->cloned_points_storage.back().get());
           }
         }
         new_poly.inner.push_back(new_seq);
@@ -127,6 +143,61 @@ struct ProcessResult {
     }
     return new_res;
   }
+
+  std::string to_svg() const {
+    std::vector<std::string> lines;
+    lines.push_back(
+      "<svg xmlns=\"http://www.w3.org/2000/svg\" "
+      "width=\"" + std::to_string(width) +
+      "\" height=\"" + std::to_string(height) + "\">");
+    for (const auto& poly : polygons) {
+      { // outer
+        std::ostringstream pts;
+        bool first = true;
+        for (const Point* p : poly.outer) {
+          if (!p) continue;
+          if (!first)
+              pts << " ";
+          first = false;
+          pts << p->x << "," << p->y;
+        }
+        lines.push_back(
+          "<polygon points=\"" + pts.str() +
+          "\" fill=\"none\" stroke=\"red\" stroke-width=\"1\"/>");
+      }
+      // inner
+      for (const auto& sequence : poly.inner) {
+        if (sequence.empty()) continue;
+        std::ostringstream pts;
+        bool first = true;
+        for (const Point* p : sequence) {
+          if (!p) continue;
+          if (!first) pts << " ";
+          first = false;
+          pts << p->x << "," << p->y;
+        }
+        lines.push_back(
+          "<polygon points=\"" + pts.str() +
+          "\" fill=\"none\" stroke=\"green\" stroke-width=\"1\"/>");
+      }
+    }
+    lines.push_back("</svg>");
+    std::ostringstream result;
+    for (size_t i = 0; i < lines.size(); ++i) {
+      result << lines[i];
+      if (i + 1 < lines.size()) result << "\n";
+    }
+    return result.str();
+  }
+
+  void save_svg(const std::string& filename) const {
+    std::ofstream file(filename);
+    if (!file.is_open()) {
+      throw std::runtime_error("Unable to open SVG file: " + filename);
+    }
+    file << to_svg();
+    file.close();
+  }
 };
 
 class PolygonFinder {

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

@@ -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);