contrek 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e7576fef74116c62a018f66a13d9e29d215f7b505637b40bcb16631250fed0d
-  data.tar.gz: 7ba2f39e97a44eaddd13361b4dc5a8f8cb1790a93dab327c1794d61e0ffc45a0
+  metadata.gz: 0d4e8a9a3c94ae345edb0ecbb6087020141ad20cd2661e2b58578323a721f66e
+  data.tar.gz: ec99c9629d41d589e90ff39d8305c7e0355743b3f51caeb1e0a9da4702007fde
 SHA512:
-  metadata.gz: 748e4750b607bc2a9e9e916fc0a00a96db530e94658822d1d6eb97508fa9e302e5def958a63e621a2f97be1396bb0acad4971aea936cbca700c1ea93ac5acdaf
-  data.tar.gz: 804a329359ea6648e4bcbf4babdb8af53a12205851d669b562fa37d5aa69a49f8b6988a143f2783c85b2681432f65ff52b82db8f207718bd29b16c46882f518d
+  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

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

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

@@ -129,7 +129,7 @@ void Cursor::traverse_outer(Part* act_part,
   }
 }
 
-std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
+std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treemap) {
   std::vector<InnerPolyline*> return_inner_polylines;
   std::vector<Shape*> processing_queue = shapes_sequence_;
   for (size_t i = 0; i < shapes_sequence_.size(); ++i)
@@ -138,11 +138,12 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
     for (Part* part : polyline->parts())
     { if (part->innerable())
       { std::vector<Part*> all_parts;
+        std::vector<EndPoint*> tracked_end_points;
         Bounds bounds{
           .min = polyline->max_y(),
           .max = 0
         };
-        traverse_inner(part, all_parts, bounds);
+        traverse_inner(part, all_parts, bounds, tracked_end_points);
         Sequence* retme_sequence = shape->outer_polyline->tile->shapes_pool->acquire_sequence();
         for (Part* part : all_parts)
         { part->touch();
@@ -157,7 +158,11 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
           });
         }
         if (retme_sequence->is_not_vertical()) {
-          return_inner_polylines.push_back(polyline->tile->shapes_pool->acquire_inner_polyline(retme_sequence));
+          InnerPolyline* inner_polyline = polyline->tile->shapes_pool->acquire_inner_polyline(retme_sequence);
+          return_inner_polylines.push_back(inner_polyline);
+          if (treemap) {
+            mark_children(tracked_end_points, polyline, inner_polyline);
+          }
         }
       }
     }
@@ -165,7 +170,26 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
   return(return_inner_polylines);
 }
 
-void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bounds& bounds) {
+void Cursor::mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline) {
+  for (size_t i = 0; i + 1 < end_points.size(); i += 2) {
+    const auto& a = end_points[i];
+    const auto& b = end_points[i + 1];
+    auto [y_min, y_max] = std::minmax(a->get_point()->y, b->get_point()->y);
+    for (int y = y_min + 1; y < y_max; ++y) {
+      EndPoint* end_point = this->cluster.hub()->get(y);
+      if (end_point) {
+        for (auto part_p : end_point->queues())
+        { Part* part = static_cast<Part*>(part_p);
+          if (part->polyline() != outer_polyline) {
+            part->polyline()->inside_inner_polyline = inner_polyline;
+          }
+        }
+      }
+    }
+  }
+}
+
+void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bounds& bounds, std::vector<EndPoint*>& tracked_end_points) {
   PartPool& pool = act_part->polyline()->tile->cluster->parts_pool;
   while (act_part != nullptr) {
     if (!all_parts.empty() && act_part == all_parts.front()) return;
@@ -186,13 +210,17 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
             all_parts.push_back(act_part);
         } else {
           if (act_part->head)
-          { for (auto dest_part_p : static_cast<Position*>(act_part->head)->end_point()->queues()) {
+          { EndPoint* current_end_point = static_cast<Position*>(act_part->head)->end_point();
+            for (auto dest_part_p : current_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;
+
+              tracked_end_points.push_back(current_end_point);
+
               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());

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

@@ -21,7 +21,7 @@ class Cursor {
  public:
   Cursor(Cluster& cluster, Shape* shape);
   Sequence* join_outers();
-  std::vector<InnerPolyline*> join_inners(Sequence* outer_seq);
+  std::vector<InnerPolyline*> join_inners(Sequence* outer_seq, bool treemap);
   std::list<InnerPolyline*> orphan_inners() { return orphan_inners_; }
   const std::vector<Shape*>& shapes_sequence() const { return shapes_sequence_; }
 
@@ -35,6 +35,7 @@ class Cursor {
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
                       Sequence* outer_joined_polyline);
-  void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
+  void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds, std::vector<EndPoint*>& tracked_end_points);
   std::vector<Shape*> connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes);
+  void mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline);
 };

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

@@ -11,9 +11,8 @@
 #include <vector>
 #include "InnerPolyline.h"
 
-InnerPolyline::InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape, bool recombined)
+InnerPolyline::InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape)
   : raw_coordinates_(std::move(raw_coordinates)),
-    recombined_(recombined),
     shape_(shape) {}
 InnerPolyline::InnerPolyline(Sequence* sequence)
   : sequence_(sequence) {

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

@@ -14,16 +14,14 @@
 
 class InnerPolyline {
  public:
-  explicit InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape, bool recombined = false);
+  explicit InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape);
   explicit InnerPolyline(Sequence* sequence);
   std::vector<Point*>& raw();
   Sequence* sequence() { return this->sequence_; }
   Bounds& vertical_bounds();
-  bool recombined() { return this->recombined_; }
   Shape* shape();
   Shape* assigned_shape = nullptr;
  private:
-  bool recombined_ = false;
   std::vector<Point*> raw_coordinates_;
   Sequence* sequence_ = nullptr;
   Shape* shape_;

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

@@ -22,15 +22,12 @@ Polyline::Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::op
 { if (bounds.has_value()) {
     min_x =  bounds->min_x;
     max_x = bounds->max_x;
-    min_y =  bounds->min_y;
+    min_y_ =  bounds->min_y;
     max_y_ = bounds->max_y;
   } else {
     this->find_boundary();  // TODO(ema): optimize when merging the bounds are the sum of the previouses
   }
-}
-
-bool Polyline::vert_intersect(Polyline& other) {
-  return( !(this->max_y_ < other.min_y || other.max_y_ < this->min_y));
+  this->name = tile->shapes().size();
 }
 
 int Polyline::width() {
@@ -46,7 +43,7 @@ void Polyline::find_boundary() {
   if (raw_.empty()) return;
   min_x =  std::numeric_limits<int>::max();
   max_x = -std::numeric_limits<int>::max();
-  min_y =  std::numeric_limits<int>::max();
+  min_y_ =  std::numeric_limits<int>::max();
   max_y_ = -std::numeric_limits<int>::max();
   for (Point* p : raw_) {
     if (!p) continue;
@@ -54,7 +51,7 @@ void Polyline::find_boundary() {
     int y = p->y;
     if (x < min_x) min_x = x;
     if (x > max_x) max_x = x;
-    if (y < min_y) min_y = y;
+    if (y < min_y_) min_y_ = y;
     if (y > max_y_) max_y_ = y;
   }
 }
@@ -67,20 +64,8 @@ bool Polyline::is_empty() {
   return raw_.empty();
 }
 
-std::string Polyline::info() {
-  Shape* shape = this->shape;
-  size_t part_index = 0;
-  auto it = std::find(this->tile->shapes().begin(), this->tile->shapes().end(), shape);
-  if (it != this->tile->shapes().end()) {
-    part_index = std::distance(this->tile->shapes().begin(), it);
-  }
-  std::stringstream ss;
-  ss << "b" << this->tile->name() << " S" << part_index;
-  return ss.str();
-}
-
 bool Polyline::vert_bounds_intersect(Bounds& vertical_bounds)
-{ return !(this->max_y_ < vertical_bounds.min || vertical_bounds.max < this->min_y);
+{ return !(this->max_y_ < vertical_bounds.min || vertical_bounds.max < this->min_y_);
 }
 
 bool Polyline::within(std::vector<Point*>& points) {
@@ -99,3 +84,14 @@ bool Polyline::within(std::vector<Point*>& points) {
   }
   return inside;
 }
+
+std::string Polyline::named() {
+  if (this->named_.empty()) {
+    std::stringstream ss;
+    ss << "t" << this->tile->name() << "s" << this->name;
+    if (this->boundary()) ss << "B";
+    return ss.str();
+  } else {
+    return this->named_;
+  }
+}

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

@@ -23,6 +23,7 @@
 class Tile;
 class Shape;
 class Point;
+class InnerPolyline;
 
 class Polyline : public Partitionable {
  public:
@@ -42,17 +43,21 @@ class Polyline : public Partitionable {
   std::vector<Point*> raw() const { return raw_; }
   const std::vector<Part*>& parts() const { return parts_; }
   const int max_y() const { return max_y_; }
+  const int min_y() const { return min_y_; }
   void clear();
   bool is_empty();
-  bool vert_intersect(Polyline& other);
   bool any_ancients = false;
-  std::string info();
   bool vert_bounds_intersect(Bounds& vertical_bounds);
   bool within(std::vector<Point*>& points);
+  InnerPolyline* inside_inner_polyline = nullptr;
+  std::string named();
+  void set_named(std::string force_named) { this->named_ = force_named; }
 
  private:
   std::vector<Point*> raw_;
-  int min_x, max_x, min_y, max_y_;
+  int min_x, max_x, min_y_, max_y_;
   void find_boundary();
   uint32_t flags_ = 0;
+  std::string named_;
+  int name;
 };

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

@@ -9,6 +9,7 @@
 
 #include <list>
 #include <vector>
+#include <string>
 #include "Shape.h"
 #include "Polyline.h"
 
@@ -34,3 +35,7 @@ void Shape::set_parent_shape(Shape* shape) {
   { shape->children_shapes.push_back(this);
   }
 }
+
+std::string Shape::name() {
+  return(this->outer_polyline->named());
+}

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

@@ -11,6 +11,7 @@
 #include <list>
 #include <iostream>
 #include <vector>
+#include <string>
 #include "InnerPolyline.h"
 
 class Point;
@@ -24,9 +25,10 @@ class Shape {
   InnerPolyline* parent_inner_polyline = nullptr;
   std::vector<Shape*> children_shapes;
   void clear_inner();
-  bool reassociation_skip = false;
+  bool fixed = false;
   Shape* parent_shape() { return parent_shape_; }
   void set_parent_shape(Shape*);
+  std::string name();
  private:
   Shape* parent_shape_ = nullptr;
 };

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

@@ -17,8 +17,8 @@ Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<Inne
   return shape;
 }
 
-InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point*> coords, Shape* shape, bool rec) {
-  inner_polylines_storage.emplace_back(coords, shape, rec);
+InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point*> coords, Shape* shape) {
+  inner_polylines_storage.emplace_back(coords, shape);
   InnerPolyline* ip = &inner_polylines_storage.back();
   return ip;
 }

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

@@ -27,7 +27,7 @@ class ShapePool {
 
  public:
   Shape* acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
-  InnerPolyline* acquire_inner_polyline(std::vector<Point*> coords, Shape* s, bool rec);
+  InnerPolyline* acquire_inner_polyline(std::vector<Point*> coords, Shape* s);
   InnerPolyline* acquire_inner_polyline(Sequence* seq);
   Sequence* acquire_sequence();
   Polyline* acquire_polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds);

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

@@ -61,7 +61,7 @@ void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const st
     { Polyline* polyline = this->shapes_pool->acquire_polyline(this, raw_polyline.outer, raw_polyline.bounds);
       std::vector<InnerPolyline*> inner_polylines_list;
       for (auto& raw_points : raw_polyline.inner) {
-        inner_polylines_list.push_back(this->shapes_pool->acquire_inner_polyline(raw_points, nullptr, false));
+        inner_polylines_list.push_back(this->shapes_pool->acquire_inner_polyline(raw_points, nullptr));
       }
       Shape* shape = this->shapes_pool->acquire_shape(polyline, inner_polylines_list);
       polyline->shape = shape;
@@ -75,6 +75,7 @@ void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const st
           if (it != shapes_map.end()) {
             Shape* parent = it->second;
             shape->set_parent_shape(parent);
+            shape->fixed = true;
             shape->parent_inner_polyline = parent->inner_polylines[treemap_entry.second];
           }
         }
@@ -84,7 +85,7 @@ void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const st
   }
 }
 
-void Tile::assign_shapes(std::list<Shape*>& shapes) {
+void Tile::assign_shapes(std::vector<Shape*>& shapes) {
   for (Shape *shape : shapes) {
     shape->outer_polyline->tile = this;
   }
@@ -135,7 +136,8 @@ std::vector<std::pair<int, int>> Tile::compute_treemap()
   for (auto* shape : this->shapes_) {
     if (shape->outer_polyline->is_empty()) continue;
     if (shape->parent_shape() != nullptr) {
-      int p_idx = shapes_map[shape->parent_shape()];
+      auto p_it = shapes_map.find(shape->parent_shape());
+      int p_idx = (p_it != shapes_map.end()) ? p_it->second : -1;
       const auto& inners = shape->parent_shape()->inner_polylines;
       auto it = std::find(inners.begin(), inners.end(), shape->parent_inner_polyline);
       int inner_idx = static_cast<int>(std::distance(inners.begin(), it));

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

@@ -30,7 +30,7 @@ class Tile {
   int start_x_;
   int end_x_;
   std::string name_;
-  std::list<Shape*> shapes_;
+  std::vector<Shape*> shapes_;
 
  public:
   Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b);
@@ -42,15 +42,15 @@ class Tile {
   int start_x() const { return start_x_; }
   int end_x() const { return end_x_; }
   std::string name() const { return name_; }
-  const std::list<Shape*>& shapes() const { return shapes_; }
-  std::list<Shape*>& shapes() { return shapes_; }
+  const std::vector<Shape*>& shapes() const { return shapes_; }
+  std::vector<Shape*>& shapes() { return shapes_; }
   bool whole();
   bool left();
   bool right();
   void initial_process(ClippedPolygonFinder *finder);
   void info();
   bool tg_border(const Point& coord);
-  void assign_shapes(std::list<Shape*>& shapes);
+  void assign_shapes(std::vector<Shape*>& shapes);
   void assign_raw_polygons(const std::list<Polygon>& raw_polylines, const std::vector<std::pair<int, int>>& treemap);
   std::list<Polygon> to_raw_polygons();
   std::vector<std::pair<int, int>> compute_treemap();

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -291,9 +291,8 @@ extern "C"
 void Init_cpp_polygon_finder() {
   #ifdef HAVE_TCMALLOC
   MallocExtension::instance()->SetNumericProperty(
-      "tcmalloc.max_total_thread_cache_bytes",
-      1024 * 1024 * 1024
-  );
+    "tcmalloc.max_total_thread_cache_bytes",
+    1024 * 1024 * 1024);
   #endif
 
   Data_Type<Bitmap> rb_cBitmap =

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

@@ -6,7 +6,7 @@ module Contrek
       def initialize(finder:, height:, start_x:, end_x:)
         @finder = finder
         @tiles = []
-        @hub = Hub.new(height: )
+        @hub = Hub.new(height:)
       end
 
       def add(tile)
@@ -28,6 +28,7 @@ module Contrek
 
         new_shapes = []
         all_new_inner_polylines = []
+
         tot_outer += Benchmark.measure do
           @tiles.each do |tile|
             tile.shapes.each do |shape|
@@ -54,13 +55,12 @@ module Contrek
               new_inners = shape.inner_polylines
               new_inner_polylines = []
               tot_inner += Benchmark.measure do
-                new_inner_polylines = cursor.join_inners!(new_outer)
+                new_inner_polylines = cursor.join_inners!(new_outer, treemap)
                 new_inners += new_inner_polylines
                 if treemap
-                  new_inner_polylines.each { |p| p.sequence.compute_vertical_bounds! }
-                  all_new_inner_polylines += new_inner_polylines
-                  cursor.orphan_inners.each do |orphan_inner|
-                    all_new_inner_polylines << orphan_inner if orphan_inner.recombined
+                  new_inner_polylines.each do |inner_polyline|
+                    inner_polyline.sequence.compute_vertical_bounds!
+                    all_new_inner_polylines += new_inner_polylines
                   end
                 end
                 new_inners += cursor.orphan_inners
@@ -70,7 +70,6 @@ module Contrek
               inserting_new_shape = Shape.init_by(polyline, new_inners)
               new_shapes << inserting_new_shape
               polyline.shape = inserting_new_shape
-              inserting_new_shape.set_parent_shape(shape.parent_shape)
 
               new_inner_polylines.each { |inner_polyline| inner_polyline.sequence.shape = inserting_new_shape }
 
@@ -78,23 +77,20 @@ module Contrek
                 cursor.shapes_sequence.each do |merged_shape|
                   merged_shape.merged_to_shape = inserting_new_shape
                 end
-                assign_ancestry(inserting_new_shape, all_new_inner_polylines)
+                if shape.outer_polyline.inside_inner_polyline
+                  assign_ancestry(inserting_new_shape, shape.outer_polyline.inside_inner_polyline)
+                end
               end
             else
-              if treemap && !shape.reassociation_skip && shape.parent_shape.nil?
-                assign_ancestry(shape, all_new_inner_polylines)
+              if treemap
+                if shape.fixed
+                  shape.set_parent_shape(shape.parent_shape.merged_to_shape) if shape.parent_shape.merged_to_shape
+                else
+                  is_children(shape, all_new_inner_polylines)
+                end
               end
-              new_shapes << shape
-            end
-          end
-        end
 
-        if treemap
-          @tiles.each do |tile|
-            tile.shapes.each do |shape|
-              if (merged_to_shape = shape.parent_shape&.merged_to_shape)
-                shape.set_parent_shape(merged_to_shape)
-              end
+              new_shapes << shape
             end
           end
         end
@@ -116,16 +112,21 @@ module Contrek
 
       private
 
-      def assign_ancestry(shape, inner_polylines)
+      def assign_ancestry(shape, inner_polyline)
+        shape.set_parent_shape(inner_polyline.sequence.shape)
+        shape.parent_inner_polyline = inner_polyline
+        shape.fixed = true
+      end
+
+      def is_children(shape, inner_polylines)
         inner_polylines.each do |inner_polyline|
-          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
-              shape.children_shapes.each do |children_shape|
-                children_shape.reassociation_skip = true
-              end
-            end
+          bounds = inner_polyline.vertical_bounds
+          min_y = bounds[:min]
+          max_y = bounds[:max]
+          next if shape.outer_polyline.get_bounds[:max_y] < min_y ||
+            shape.outer_polyline.get_bounds[:min_y] > max_y
+          if shape.outer_polyline.within?(inner_polyline.raw)
+            assign_ancestry(shape, inner_polyline)
           end
         end
       end

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

@@ -4,7 +4,7 @@ module Contrek
       attr_reader :orphan_inners, :shapes_sequence
 
       def initialize(cluster:, shape:)
-        @shapes_sequence = Set.new([shape])
+        @shapes_sequence = [shape]
         @cluster = cluster
         @outer_polyline = shape.outer_polyline
         @orphan_inners = []
@@ -38,18 +38,19 @@ module Contrek
         outer_joined_polyline
       end
 
-      def join_inners!(outer_seq)
+      def join_inners!(outer_seq, treemap)
         return_inner_polylines = []
+        shape_index = 0
 
-        @processing_shapes = @shapes_sequence.to_a
-
-        @processing_shapes.each do |shape|
+        while shape_index < @shapes_sequence.size
+          shape = @shapes_sequence[shape_index]
           polyline = shape.outer_polyline
           polyline.parts.each do |part|
             if part.innerable?
               all_parts = []
+              tracked_end_points = []
               bounds = {min: polyline.max_y, max: 0}
-              traverse_inner(part, all_parts, bounds)
+              traverse_inner(part, all_parts, bounds, tracked_end_points)
               range_of_bounds = (bounds[:min]..bounds[:max])
 
               retme_sequence = Sequence.new
@@ -62,16 +63,36 @@ module Contrek
                 end
               end
               if retme_sequence.is_not_vertical
-                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
+                inner_polyline = InnerPolyline.new(sequence: retme_sequence)
+                return_inner_polylines << inner_polyline
+                mark_children(tracked_end_points, polyline, inner_polyline) if treemap
               end
             end
           end
+          shape_index += 1
         end
         return_inner_polylines
       end
 
       private
 
+      # finds each part (and relative polyline) inscribed between two end_points and sets the
+      # founded inner_polyline which be later used to define in which parent hole is placed.
+      def mark_children(end_points, outer_polyline, inner_polyline)
+        end_points.each_slice(2) do |a, b|
+          range = [a.position[:y], b.position[:y]].sort
+          (range[0] + 1).upto(range[1] - 1) do |y|
+            if (end_point = @cluster.hub.payloads[y])
+              end_point.queues.each do |part|
+                if part.polyline != outer_polyline
+                  part.polyline.inside_inner_polyline = inner_polyline
+                end
+              end
+            end
+          end
+        end
+      end
+
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
         last_part = all_parts.last
@@ -104,7 +125,7 @@ module Contrek
                   cont = false if map.size == 1 && map.first == Part::SEAM
                 end
                 if cont
-                  shapes_sequence.add(part.polyline.shape)
+                  shapes_sequence << part.polyline.shape if !shapes_sequence.include?(part.polyline.shape)
                   part.next_position(new_position)
                   part.dead_end = true
                   traverse_outer(part, all_parts, shapes_sequence, outer_joined_polyline)
@@ -120,7 +141,7 @@ module Contrek
         traverse_outer(act_part.circular_next, all_parts, shapes_sequence, outer_joined_polyline)
       end
 
-      def traverse_inner(act_part, all_parts, bounds)
+      def traverse_inner(act_part, all_parts, bounds, tracked_end_points)
         return if act_part == all_parts.first
 
         if act_part.size > 0
@@ -140,6 +161,8 @@ module Contrek
                   dest_part_versus = dest_part.versus
                   next if dest_part_versus != 0 && dest_part_versus == act_part.versus
 
+                  tracked_end_points << act_part.head.end_point
+
                   link_seq = dest_part.continuum_to?(act_part)
                   if link_seq.any?
                     ins_part = Part.new(Part::ADDED, act_part.polyline)
@@ -150,13 +173,13 @@ module Contrek
                   end
                   shape = dest_part.polyline.shape
                   if !dest_part.polyline.on?(Polyline::TRACKED_OUTER)
-                    @processing_shapes << shape
+                    @shapes_sequence << shape
                     @orphan_inners += shape.inner_polylines
                   end
                   dest_part.polyline.turn_on(Polyline::TRACKED_OUTER)
                   if !dest_part.touched
                     dest_part.touch!
-                    traverse_inner(dest_part.circular_next, all_parts, bounds)
+                    traverse_inner(dest_part.circular_next, all_parts, bounds, tracked_end_points)
                     return
                   end
                 end
@@ -165,7 +188,7 @@ module Contrek
             end
           end
         elsif act_part.next
-          traverse_inner(act_part.next, all_parts, bounds)
+          traverse_inner(act_part.next, all_parts, bounds, tracked_end_points)
         end
       end
       # rubocop:enable Lint/NonLocalExitFromIterator

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

@@ -1,12 +1,11 @@
 module Contrek
   module Concurrent
     class InnerPolyline
-      attr_reader :sequence, :recombined
+      attr_reader :sequence
 
-      def initialize(shape: nil, raw_coordinates: [], sequence: nil, recombined: false)
+      def initialize(shape: nil, raw_coordinates: [], sequence: nil)
         @raw = raw_coordinates if raw_coordinates
         @sequence = sequence if sequence
-        @recombined = recombined
         @shape = shape
       end
 

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

@@ -6,15 +6,17 @@ module Contrek
       TRACKED_OUTER = 1 << 0
 
       attr_reader :raw, :name, :min_y, :max_y
-      attr_accessor :shape, :tile, :any_ancients
+      attr_accessor :shape, :tile, :any_ancients, :inside_inner_polyline
 
-      def initialize(tile:, polygon:, shape: nil, bounds: nil)
+      def initialize(tile:, polygon:, shape: nil, bounds: nil, force_named: nil)
         @tile = tile
         @name = tile.shapes.count
+        @named = force_named
         @raw = polygon
         @shape = shape
         @flags = 0
         @any_ancients = false
+        @inside_inner_polyline = nil
 
         if bounds.nil?
           find_boundary
@@ -31,17 +33,13 @@ module Contrek
       end
 
       def named
-        "[b#{@tile.name} S#{@name} #{"B" if boundary?}]"
+        @named || "t#{@tile.name}s#{@name}#{"B" if boundary?}"
       end
 
       def numpy_raw
         raw.flat_map { |p| [p[:x], p[:y]] }
       end
 
-      def info
-        "w#{@tile.name} S#{@name}"
-      end
-
       def turn_on(flag)
         @flags |= flag
       end

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

@@ -1,8 +1,8 @@
 module Contrek
   module Concurrent
     class Shape
-      attr_accessor :outer_polyline, :inner_polylines, :merged_to_shape, :parent_inner_polyline,
-        :reassociation_skip
+      attr_accessor :outer_polyline, :inner_polylines, :merged_to_shape,
+        :parent_inner_polyline, :fixed
       attr_reader :parent_shape, :children_shapes
 
       def initialize
@@ -10,7 +10,7 @@ module Contrek
         @merged_to_shape = nil
         @parent_inner_polyline = nil
         @children_shapes = []
-        @reassociation_skip = false
+        @fixed = false
       end
 
       def self.init_by(set_outer_polyline, set_inner_polylines)
@@ -24,6 +24,10 @@ module Contrek
         @inner_polylines.clear
       end
 
+      def name
+        outer_polyline.named
+      end
+
       def set_parent_shape(shape)
         @parent_shape&.children_shapes&.delete(self)
         @parent_shape = shape

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

@@ -61,15 +61,15 @@ module Contrek
       end
 
       def compute_treemap
-        @shapes_map = {}
+        shapes_map = {}
         shape_index = 0
 
-        @shapes.map do |shape|
+        shapes.map do |shape|
           next if shape.outer_polyline.empty?
-          @shapes_map[shape] = shape_index
+          shapes_map[shape] = shape_index
           shape_index += 1
           if shape.parent_shape
-            [@shapes_map[shape.parent_shape], shape.parent_shape.inner_polylines.index(shape.parent_inner_polyline)]
+            [shapes_map[shape.parent_shape], shape.parent_shape.inner_polylines.index(shape.parent_inner_polyline)]
           else
             [-1, -1]
           end
@@ -104,6 +104,7 @@ module Contrek
             if treemap_entry != [-1, -1]
               parent = shapes_map[treemap_entry.first]
               shape.set_parent_shape(parent)
+              shape.fixed = true
               shape.parent_inner_polyline = parent.inner_polylines[treemap_entry.last]
             end
           end

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-09 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -136,6 +136,7 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.md
+- PERFORMANCE.md
 - README.md
 - Rakefile
 - contrek.gemspec
@@ -143,10 +144,6 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt
 - ext/cpp_polygon_finder/PolygonFinder/LICENSE_AGPL.txt
 - ext/cpp_polygon_finder/PolygonFinder/clean.sh
-- ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp
-- ext/cpp_polygon_finder/PolygonFinder/images/graphs_1024x1024.png
-- ext/cpp_polygon_finder/PolygonFinder/images/labyrinth.png
-- ext/cpp_polygon_finder/PolygonFinder/images/sample_10240x10240.png
 - ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h
 - ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/Tests.h

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

@@ -1,56 +0,0 @@
-/*
- * example.cpp
- *
- * Copyright (c) 2025-2026 Emanuele Cesaroni
- *
- * Licensed under the GNU Affero General Public License v3 (AGPLv3).
- * See the LICENSE file in this directory for the full license text.
- */
-
-#include <iostream>
-#include <gperftools/malloc_extension.h>
-#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();
-  // test_suite.test_g();
-  // test_suite.test_h();
-  // test_suite.test_i();
-  std::cout << "compute time =" << cpu_timer.stop() << std::endl;
-}
-
-int main() {
-  MallocExtension::instance()->SetNumericProperty(
-      "tcmalloc.max_total_thread_cache_bytes",
-      1024 * 1024 * 1024
-  );
-
-  Contrek::Config cfg;
-  cfg.threads = 4;
-  cfg.tiles = 4;
-  cfg.compress_unique = true;
-  // cfg.treemap = true;
-  // cfg.connectivity_mode = Contrek::Connectivity::OMNIDIRECTIONAL;
-
-  CpuTimer cpu_timer;
-  cpu_timer.start();
-  std::cout << "--- Start Native Benchmark ---" << std::endl;
-  // auto result = Contrek::trace("../images/graphs_1024x1024.png", cfg);
-  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;
-}