contrek 1.1.6 → 1.1.8

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

@@ -11,14 +11,22 @@
 #include <list>
 #include <iostream>
 #include <vector>
+#include "InnerPolyline.h"
 
 class Point;
 class Polyline;
 class Shape {
  public:
-  Shape(Polyline* outer_polyline, const std::list<std::vector<Point*>>& inner_polylines);
-  virtual ~Shape();
+  Shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   Polyline* outer_polyline = nullptr;
-  std::list<std::vector<Point*>> inner_polylines;
+  std::vector<InnerPolyline*> inner_polylines;
+  Shape* merged_to_shape = nullptr;
+  InnerPolyline* parent_inner_polyline = nullptr;
+  std::vector<Shape*> children_shapes;
   void clear_inner();
+  bool reassociation_skip = false;
+  Shape* parent_shape() { return parent_shape_; }
+  void set_parent_shape(Shape*);
+ private:
+  Shape* parent_shape_ = nullptr;
 };

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

@@ -0,0 +1,42 @@
+/*
+ * ShapePool.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 <vector>
+#include "Shape.h"
+#include "ShapePool.h"
+
+Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines) {
+  shapes_storage.emplace_back(outer_polyline, inner_polylines);
+  Shape* shape = &shapes_storage.back();
+  return shape;
+}
+
+InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point*> coords, Shape* shape, bool rec) {
+  inner_polylines_storage.emplace_back(coords, shape, rec);
+  InnerPolyline* ip = &inner_polylines_storage.back();
+  return ip;
+}
+
+InnerPolyline* ShapePool::acquire_inner_polyline(Sequence* seq) {
+  inner_polylines_storage.emplace_back(seq);
+  InnerPolyline* ip = &inner_polylines_storage.back();
+  return ip;
+}
+
+Sequence* ShapePool::acquire_sequence() {
+  sequences_storage.emplace_back();
+  Sequence* s = &sequences_storage.back();
+  return s;
+}
+
+Polyline* ShapePool::acquire_polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
+  polylines_storage.emplace_back(tile, polygon, bounds);
+  Polyline* p = &polylines_storage.back();
+  return p;
+}

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

@@ -0,0 +1,34 @@
+/*
+ * ShapePool.h
+ *
+ * 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.
+ */
+
+#pragma once
+#include <deque>
+#include <vector>
+#include "Shape.h"
+#include "../RectBounds.h"
+#include "Polyline.h"
+
+class Shape;
+class Tile;
+class Polyline;
+class InnerPolyline;
+class ShapePool {
+ private:
+  std::deque<Shape> shapes_storage;
+  std::deque<InnerPolyline> inner_polylines_storage;
+  std::deque<Sequence> sequences_storage;
+  std::deque<Polyline> polylines_storage;
+
+ 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(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

@@ -11,6 +11,8 @@
 #include <iostream>
 #include <list>
 #include <utility>
+#include <vector>
+#include <unordered_map>
 #include "Tile.h"
 #include "Shape.h"
 #include "Polyline.h"
@@ -24,13 +26,15 @@ Tile::Tile(Finder *finder, int start_x, int end_x, std::string name, const Bench
   end_x_(end_x),
   name_(name),
   benchmarks(b) {
+  this->shapes_pool = new ShapePool();
+  this->shapes_pools.push_back(this->shapes_pool);
 }
 
 Tile::~Tile() {
-  for (Shape* shape : shapes_) {
-    delete shape;
-  }
   shapes_.clear();
+  for (ShapePool* pool : this->shapes_pools) {
+    delete pool;
+  }
 }
 
 bool Tile::whole() {
@@ -46,18 +50,37 @@ bool Tile::right() {
 }
 
 void Tile::initial_process(ClippedPolygonFinder *finder) {
-  this->assign_raw_polygons(finder->get_cluster()->polygons);
+  this->assign_raw_polygons(finder->get_cluster()->polygons, finder->get_cluster()->treemap);
 }
 
-void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines) {
+void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines, const std::vector<std::pair<int, int>>& treemap) {
+  std::unordered_map<int, Shape*> shapes_map;
+  int polyline_index = 0;
   for (const auto& raw_polyline : raw_polylines)
   { if (raw_polyline.bounds.width() > 0)
-    { Polyline* polyline = new Polyline(this, raw_polyline.outer, raw_polyline.bounds);
-      { Shape* shape = new Shape(polyline, raw_polyline.inner);
-        polyline->shape = shape;
-        this->shapes_.push_back(shape);
+    { 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));
+      }
+      Shape* shape = this->shapes_pool->acquire_shape(polyline, inner_polylines_list);
+      polyline->shape = shape;
+      this->shapes_.push_back(shape);
+
+      if (treemap.size() > 0)
+      { auto treemap_entry = treemap[polyline_index];
+        shapes_map[polyline_index] = shape;
+        if (treemap_entry.first != -1 && treemap_entry.second != -1) {
+          auto it = shapes_map.find(treemap_entry.first);
+          if (it != shapes_map.end()) {
+            Shape* parent = it->second;
+            shape->set_parent_shape(parent);
+            shape->parent_inner_polyline = parent->inner_polylines[treemap_entry.second];
+          }
+        }
       }
     }
+    polyline_index++;
   }
 }
 
@@ -73,7 +96,12 @@ bool Tile::tg_border(const Point& coord) {
 }
 
 void Tile::info() {
-  std::cout << "TILE name=" << name_ << " start_x=" << start_x_ << " end_x=" << end_x_ << std::endl;
+  std::cout << this->toString() << std::endl;
+}
+
+std::string Tile::toString() {
+  std::string s = "TILE name=" + name_ + " start_x=" + std::to_string(start_x_) + " end_x=" + std::to_string(end_x_);
+  return s;
 }
 
 const std::list<Shape*>& Tile::boundary_shapes()
@@ -96,7 +124,7 @@ std::list<Polygon> Tile::to_raw_polygons()
       poly.outer = s->outer_polyline->raw();
       if (!s->inner_polylines.empty()) {
         for (auto inner : s->inner_polylines) {
-          poly.inner.push_back(inner);
+          poly.inner.push_back(inner->raw());
         }
       }
       retme.push_back(std::move(poly));
@@ -104,3 +132,36 @@ std::list<Polygon> Tile::to_raw_polygons()
   }
   return(retme);
 }
+
+std::vector<std::pair<int, int>> Tile::compute_treemap()
+{ std::unordered_map<Shape*, int> shapes_map;
+  int current_index = 0;
+
+  for (auto* shape : this->shapes_) {
+    if (shape->outer_polyline->is_empty()) continue;
+    shapes_map[shape] = current_index++;
+  }
+  std::vector<std::pair<int, int>> treemap;
+  treemap.reserve(shapes_map.size());
+
+  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()];
+      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));
+      treemap.push_back({p_idx, inner_idx});
+    } else {
+      treemap.push_back({-1, -1});
+    }
+  }
+  return treemap;
+}
+
+void Tile::adopt(Tile* other) {
+  for (ShapePool* pool : other->shapes_pools) {
+    this->shapes_pools.push_back(pool);
+  }
+  other->shapes_pools.clear();
+}

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

@@ -6,11 +6,14 @@
  * Licensed under the GNU Affero General Public License v3 (AGPLv3).
  * See the LICENSE file in this directory for the full license text.
  */
+
 #pragma once
 #include <string>
 #include <list>
+#include <vector>
 #include "Finder.h"
 #include "ClippedPolygonFinder.h"
+#include "ShapePool.h"
 
 class Finder;
 class Cluster;
@@ -51,7 +54,12 @@ class Tile {
   void info();
   bool tg_border(const Point& coord);
   void assign_shapes(std::list<Shape*>& shapes);
-  void assign_raw_polygons(const std::list<Polygon>& raw_polylines);
+  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();
+  std::string toString();
   Benchmarks benchmarks;
+  std::vector<ShapePool*> shapes_pools;
+  ShapePool* shapes_pool;
+  void adopt(Tile* other);
 };

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -63,6 +63,8 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/Tile.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/Polyline.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Polyline.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/InnerPolyline.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/InnerPolyline.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/Partitionable.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Partitionable.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/Shape.h"
@@ -91,6 +93,8 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.cpp"
 extern "C" {
   #include "PolygonFinder/src/polygon/bitmaps/spng.h"
 }

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

@@ -22,10 +22,12 @@ module Contrek
       # outer sequences and both the old and new inner ones. Shapes that are not in the contact area are directly
       # reassigned unchanged to the new shape.
       def merge_tiles!
+        treemap = @finder.options[:treemap]
         tot_inner = 0
         tot_outer = 0
 
         new_shapes = []
+        all_new_inner_polylines = []
         tot_outer += Benchmark.measure do
           @tiles.each do |tile|
             tile.shapes.each do |shape|
@@ -43,30 +45,61 @@ module Contrek
             next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) || shape.outer_polyline.width == 0
 
             if shape.outer_polyline.boundary? && shape.outer_polyline.next_tile_eligible_shapes.any?
-              new_outer = nil
-              new_inners = shape.inner_polylines
               cursor = Cursor.new(cluster: self, shape: shape)
 
+              new_outer = nil
               tot_outer += Benchmark.measure do
                 new_outer = cursor.join_outers!
               end.real
+
+              new_inners = shape.inner_polylines
+              new_inner_polylines = []
               tot_inner += Benchmark.measure do
-                new_inner_sequences = cursor.join_inners!(new_outer)
-                new_inners += new_inner_sequences.map { |s| s.to_a } if new_inner_sequences.any?
+                new_inner_polylines = cursor.join_inners!(new_outer)
+                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
+                  end
+                end
                 new_inners += cursor.orphan_inners
               end.real
 
-              new_shapes << Shape.new.tap do |shape|
-                polyline = Polyline.new(tile: tile, polygon: new_outer.to_a)
-                shape.outer_polyline = polyline
-                polyline.shape = shape
-                shape.inner_polylines = new_inners
+              polyline = Polyline.new(tile: tile, polygon: new_outer.to_a)
+              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 }
+
+              if treemap
+                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)
               end
             else
+              if treemap && !shape.reassociation_skip && shape.parent_shape.nil?
+                assign_ancestry(shape, all_new_inner_polylines)
+              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
+            end
+          end
+        end
+
         past_tot_outer = @tiles.first.benchmarks[:outer] + @tiles.last.benchmarks[:outer]
         past_tot_inner = @tiles.first.benchmarks[:inner] + @tiles.last.benchmarks[:inner]
 
@@ -81,6 +114,22 @@ module Contrek
         tile.assign_shapes!(new_shapes)
         tile
       end
+
+      private
+
+      def assign_ancestry(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
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,7 +1,8 @@
 module Contrek
   module Concurrent
     class Cursor
-      attr_reader :orphan_inners
+      attr_reader :orphan_inners, :shapes_sequence
+
       def initialize(cluster:, shape:)
         @shapes_sequence = Set.new([shape])
         @cluster = cluster
@@ -90,7 +91,9 @@ module Contrek
               end
               combine!(inject_sequences_right, inject_sequences_left).each do |sewn_sequence|
                 sewn_sequence.uniq!
-                @orphan_inners << sewn_sequence if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # segmenti non sono ammessi, solo aree
+                if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # only areas
+                  @orphan_inners << InnerPolyline.new(shape: shape, raw_coordinates: sewn_sequence, recombined: true)
+                end
               end
               missing_outer_polyline.clear!
               polyline.mixed_tile_origin = true
@@ -147,7 +150,7 @@ module Contrek
       end
 
       def collect_inner_sequences(outer_seq)
-        return_sequences = []
+        return_inner_polylines = []
         @shapes_sequence.each do |shape|
           polyline = shape.outer_polyline
           polyline.parts.each do |part|
@@ -165,16 +168,17 @@ module Contrek
                   !(polyline.tile.tg_border?(position.payload) && position.end_point.queues.include?(outer_seq))
                 end
               end
-              return_sequences << retme_sequence if retme_sequence.is_not_vertical
+              if retme_sequence.is_not_vertical
+                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
+              end
             end
           end
         end
-        return_sequences
+        return_inner_polylines
       end
 
       def traverse_inner(act_part, all_parts, bounds)
         return if act_part == all_parts.first
-
         if act_part.size > 0
           min_y, max_y = act_part.to_a.minmax_by { |p| p[:y] }
           bounds[:min] = [bounds[:min], min_y[:y]].min

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

@@ -3,7 +3,7 @@ module Contrek
     class Finder
       prepend Poolable
 
-      attr_reader :maximum_width
+      attr_reader :maximum_width, :options
 
       # Supported options
       # - number_of_threads: number of threads that can be used by the process. If set to 0, it works in
@@ -47,7 +47,12 @@ module Contrek
               finder = ClippedPolygonFinder.new(
                 bitmap: bitmap,
                 matcher: matcher,
-                options: {versus: current_versus, bounds: true, connectivity: @options[:connectivity]}.compact,
+                options: {
+                  versus: current_versus,
+                  bounds: true,
+                  treemap: @options[:treemap],
+                  connectivity: @options[:connectivity]
+                }.compact,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x]
               )
@@ -88,6 +93,7 @@ module Contrek
           width: @maximum_width,
           height: @height
         }
+        metadata[:treemap] = @whole_tile.compute_treemap if options[:treemap]
         Contrek::Finder::Result.new(raw_polygons, metadata)
       end
 

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

@@ -0,0 +1,49 @@
+module Contrek
+  module Concurrent
+    class InnerPolyline
+      attr_reader :sequence, :recombined
+
+      def initialize(shape: nil, raw_coordinates: [], sequence: nil, recombined: false)
+        @raw = raw_coordinates if raw_coordinates
+        @sequence = sequence if sequence
+        @recombined = recombined
+        @shape = shape
+      end
+
+      def raw
+        @sequence ? @sequence.to_a : @raw
+      end
+
+      def vertical_bounds
+        if @sequence
+          @sequence.vertical_bounds
+        else
+          raw_vertical_bounds
+        end
+      end
+
+      def shape
+        if @sequence
+          @sequence.shape
+        else
+          @shape
+        end
+      end
+
+      private
+
+      def raw_vertical_bounds
+        @vertical_bounds ||= begin
+          min_y = Float::INFINITY
+          max_y = 0
+          @raw.each do |pos|
+            y = pos[:y]
+            min_y = y if y < min_y
+            max_y = y if y > max_y
+          end
+          {min: min_y, max: max_y}
+        end
+      end
+    end
+  end
+end

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

@@ -119,6 +119,33 @@ module Contrek
         !(@max_y < other.min_y || other.max_y < @min_y)
       end
 
+      def vert_bounds_intersect?(vertical_bounds)
+        !(@max_y < vertical_bounds[:min] || vertical_bounds[:max] < @min_y)
+      end
+
+      # verifies if enclosed in the given sequence (raycasting technique)
+      def within?(raw_coords)
+        is_within = false
+        self_y = raw.first[:y]
+        self_x = raw.first[:x]
+        last_node = raw_coords.last
+        return false if last_node.nil?
+        lx = last_node[:x]
+        ly = last_node[:y]
+        raw_coords.each do |pos|
+          cx = pos[:x]
+          cy = pos[:y]
+          if (cy > self_y) != (ly > self_y)
+            intersect_x = lx + (self_y - ly).to_f * (cx - lx) / (cy - ly)
+            if self_x < intersect_x
+              is_within = !is_within
+            end
+          end
+          lx, ly = cx, cy
+        end
+        is_within
+      end
+
       def get_bounds
         {min_x: @min_x,
          max_x: @max_x,
@@ -126,6 +153,25 @@ module Contrek
          max_y: @max_y}
       end
 
+      def self.is_within?(test_seq, container_seq)
+        target = test_seq.first
+        return false unless target
+        tx, ty = target[:x], target[:y]
+        inside = false
+        j = container_seq.length - 1
+        container_seq.each_with_index do |p_i, i|
+          p_j = container_seq[j]
+          if (p_i[:y] > ty) != (p_j[:y] > ty)
+            intersect_x = (p_j[:x] - p_i[:x]) * (ty - p_i[:y]).to_f / (p_j[:y] - p_i[:y]) + p_i[:x]
+            if tx < intersect_x
+              inside = !inside
+            end
+          end
+          j = i
+        end
+        inside
+      end
+
       private
 
       def find_boundary

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

@@ -1,8 +1,13 @@
 module Contrek
   module Concurrent
     class Sequence
+      attr_accessor :vertical_bounds, :shape
       prepend Queueable
 
+      def initialize
+        @vertical_bounds = nil
+      end
+
       def is_not_vertical
         return false if size < 2
         x0 = head.payload[:x]
@@ -13,6 +18,22 @@ module Contrek
         end
         false
       end
+
+      def compute_vertical_bounds!
+        return if size == 0
+        min_y = Float::INFINITY
+        max_y = 0
+        get_vector_cache.each do |pos|
+          y = pos[:y]
+          min_y = y if y < min_y
+          max_y = y if y > max_y
+        end
+        @vertical_bounds = {min: min_y, max: max_y}
+      end
+
+      def get_vector_cache
+        @vector_cache ||= to_a
+      end
     end
   end
 end

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

@@ -1,10 +1,37 @@
 module Contrek
   module Concurrent
     class Shape
-      attr_accessor :outer_polyline, :inner_polylines
+      attr_accessor :outer_polyline, :inner_polylines, :merged_to_shape, :parent_inner_polyline,
+        :reassociation_skip
+      attr_reader :parent_shape, :children_shapes
+
+      def initialize
+        @parent_shape = nil
+        @merged_to_shape = nil
+        @parent_inner_polyline = nil
+        @children_shapes = []
+        @reassociation_skip = false
+      end
+
+      def self.init_by(set_outer_polyline, set_inner_polylines)
+        s = Shape.new
+        s.outer_polyline = set_outer_polyline
+        s.inner_polylines = set_inner_polylines
+        s
+      end
 
       def clear_inner!
-        @inner_polylines = []
+        @inner_polylines.clear
+      end
+
+      def set_parent_shape(shape)
+        @parent_shape&.children_shapes&.delete(self)
+        @parent_shape = shape
+        shape.children_shapes << self if shape
+      end
+
+      def info
+        "Shape (outer_polyline = #{outer_polyline.named}, children count = #{@children_shapes.size}"
       end
     end
   end