contrek 1.1.7 → 1.1.9

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
@@ -191,9 +195,8 @@ module Contrek
                   next if dest_part.trasmuted || dest_part.is?(Part::EXCLUSIVE)
                   dest_part_versus = dest_part.versus
                   next if dest_part_versus != 0 && dest_part_versus == act_part.versus
-
                   if dest_part.intersect_part?(act_part)
-                    link_seq = duplicates_intersection(dest_part, act_part)
+                    link_seq = dest_part.continuum_to?(act_part)
                     if link_seq.any?
                       ins_part = Part.new(Part::ADDED, act_part.polyline)
                       link_seq.each do |pos|
@@ -217,17 +220,6 @@ module Contrek
       end
       # rubocop:enable Lint/NonLocalExitFromIterator
 
-      # The sequences should contain inverted parts, e.g., 4,5,6,6,5,4. These parts must be
-      # removed from the sequences, and the remaining elements are compared. Only the
-      # elements that appear once between the two sequences are kept. This represents
-      # a connection between parts inserted afterwards.
-      # TODO evaluate the adoption of remove_adjacent_pairs!
-      def duplicates_intersection(part_a, part_b)
-        a1 = part_a.inverts ? Part.remove_adjacent_pairs(part_a.to_endpoints) : part_a.to_endpoints
-        b1 = part_b.inverts ? Part.remove_adjacent_pairs(part_b.to_endpoints) : part_b.to_endpoints
-        (a1 - b1) + (b1 - a1)
-      end
-
       # example
       # a = [[A],[B,C]]
       # b = [[D],[E,F]]

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/part.rb

@@ -81,10 +81,6 @@ module Contrek
         intersect
       end
 
-      def to_endpoints
-        map(&:end_point)
-      end
-
       def orient!
         @versus = if size <= 1 || (size == 2 && @inverts)
           0
@@ -93,16 +89,34 @@ module Contrek
         end
       end
 
-      def self.remove_adjacent_pairs(array = nil)
-        n = array.size
-        (0...(n - 1)).each do |i|
-          if array[i] == array[i + 1]
-            # Remove the pair and call recursively
-            new_array = array[0...i] + array[(i + 2)..]
-            return remove_adjacent_pairs(new_array)
+      def continuum_to?(other)
+        return [] if size <= 2 && inverts && other.size <= 2 && other.inverts
+        return [] if other.head.nil?
+
+        target = other.head.payload
+        cursor = tail
+        while cursor
+          if cursor.payload == target
+            s = cursor
+            o = other.head
+            match = true
+            nodes = []
+            while s && o
+              if s.payload != o.payload
+                match = false
+                break
+              end
+              nodes << s.end_point
+              s = s.next
+              o = o.next
+            end
+            if match && s.nil?
+              return nodes
+            end
           end
+          cursor = cursor.prev
         end
-        array
+        []
       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/queueable.rb

@@ -152,23 +152,6 @@ module Contrek
       def pop!
         rem(@tail)
       end
-
-      def remove_adjacent_pairs!
-        unless @tail.nil?
-          pointer = @tail
-          loop do
-            break if pointer == @head
-            if pointer.payload == pointer.prev&.payload
-              later = pointer.next
-              rem pointer.prev
-              rem pointer
-              pointer = later.nil? ? @tail : later
-              redo
-            end
-            break unless (pointer = pointer.prev)
-          end
-        end
-      end
     end
   end
 end