contrek 1.2.0 → 1.2.2

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/Hub.cpp

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

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

@@ -15,10 +15,8 @@
 class EndPoint;
 class Hub {
  public:
-  explicit Hub(int height, int start_x, int end_x);
+  explicit Hub(int height);
   int spawn_end_point();
-  const int width() const { return width_; }
-  const int start_x() const { return start_x_; }
   inline EndPoint* get(int key) {
     if (!is_set(key)) return nullptr;
     int index = payloads_[key];
@@ -34,9 +32,7 @@ class Hub {
   }
 
  private:
-  int width_;
   int height_;
-  int start_x_;
   std::vector<int> payloads_;
   std::vector<EndPoint> endpoint_pool_;
   Hub(const Hub&) = delete;

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

@@ -6,6 +6,9 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
+#ifdef HAVE_TCMALLOC
+#include <gperftools/malloc_extension.h>
+#endif
 #include <iostream>
 #include <list>
 #include <vector>
@@ -286,6 +289,12 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
 
 extern "C"
 void Init_cpp_polygon_finder() {
+  #ifdef HAVE_TCMALLOC
+  MallocExtension::instance()->SetNumericProperty(
+    "tcmalloc.max_total_thread_cache_bytes",
+    1024 * 1024 * 1024);
+  #endif
+
   Data_Type<Bitmap> rb_cBitmap =
     define_class<Bitmap>("CPPBitMap")
     .define_constructor(Constructor<Bitmap, std::string, int>())

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:, start_x:, end_x:)
+        @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/hub.rb

@@ -2,7 +2,7 @@ module Contrek
   module Concurrent
     class Hub
       attr_reader :payloads
-      def initialize(height:, start_x:, end_x:)
+      def initialize(height:)
         # @payloads = Array.new(height)
         @payloads = {}
       end