contrek 1.0.9 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15c162c3876502f8e8710ce261825dfe7fa66e1b600db084763e02ef70876a37
-  data.tar.gz: 32203f85040726d71ac519aac811d4078474c85dcd7c7b08227f1cea7e3b485f
+  metadata.gz: 1a5b664225e4cd276127b4d2861bb74382dc178cbdfd23ab36afd169c46eaca0
+  data.tar.gz: '06601846595b647920216a6035fc00885972416222114a8f306b0f3219cafaa5'
 SHA512:
-  metadata.gz: c9f8d2a44f087f96cfeacc8df8dec0973bf301f770ae45e82e6bf7d01902546c280c0446ee9c281c850a8e7c8965309e20d1a723ec269e60a99d386c288af0e7
-  data.tar.gz: 4d2c5c834fca24731866d0a56cc64d4aeac12437fac11b78389c38f7fbed9e637c785eb2a3357fb5c90a5fc257b2d010fe36cac2f84db3888f2b311276c42895
+  metadata.gz: baf09342bd36fb5c0f73d6fa9a679fd7eae42a26ba419832964da24cbd27ff8a58d5725d82a87cf0458351d2c8acc3ed6d18690f31d91b69f77c7de91c891ea4
+  data.tar.gz: 19b61c4937cf4c944de9312114e8be41dfd2b524d1cb9ff34449e567d007870b318d71b0c4f90dda5257ae9e66c949ac58b0e209ddc5c18887f23fb7df65af68

data/CHANGELOG.md

@@ -34,3 +34,9 @@ All notable changes to this project will be documented in this file.
 ### Added
 - **CMake Integration**: The library is now fully modularized via CMake, enabling seamless integration as a dependency in external C++ projects.
 - Multithreading Algorithm Optimization.
+
+## [1.1.0] - 2026-02-08
+### Changes
+- Resolved connectivity issues between internal zones and the outer boundary.
+- Refined the internal parts stitching algorithm (sew method) for better performance.
+- Miscellaneous optimizations and improvements.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.0.9)
+    contrek (1.1.0)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -99,25 +99,25 @@ Regarding multithreading:
 
 - The treemap option is currently ignored (multithreaded treemap support will be introduced in upcoming revisions).
 
-By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 2 threads working on 2 tiles (total compute time about 1.66 secs with image load).
+By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 1.53 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
   png_file_path: "./spec/files/images/sample_10240x10240.png",
   options: {
-    number_of_threads: 2,
+    number_of_threads: 4,
     class: "value_not_matcher",
     color: {r: 255, g: 255, b: 255, a: 255},
-    finder: {number_of_tiles: 2, compress: {uniq: true}}
+    finder: {number_of_tiles: 4, compress: {uniq: true}}
   }
 )
 puts result.metadata[:benchmarks].inspect
 
-{ "compress"=>13.423765,
-  "init"=>612.654121,
-  "inner"=>14.8930669,
-  "outer"=>33.0693249,
-  "total"=>626.0778879
+{ compress: 13.0815,
+  init: 453.245,
+  inner: 27.0072,
+  outer: 66.9162,
+  total: 466.326
 }
 
 ```

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

@@ -26,8 +26,8 @@ void run_test() {
 
 int main() {
   Contrek::Config cfg;
-  cfg.threads = 2;
-  cfg.tiles = 2;
+  cfg.threads = 4;
+  cfg.tiles = 4;
   cfg.compress_unique = true;
 
   CpuTimer cpu_timer;

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

@@ -24,39 +24,23 @@ Cursor::~Cursor() {
 
 Sequence* Cursor::join_outers()
 { Polyline* outer_polyline = shape->outer_polyline;
-  this->polylines_sequence.push_back(outer_polyline);
+  this->shapes_sequence.push_back(this->shape);
+  this->shapes_sequence_lookup.insert(this->shape);
   Sequence* outer_joined_polyline = new Sequence();
   this->allocated_sequences.push_back(outer_joined_polyline);
-  int counter = 0;
   std::vector<Part*> all_parts;
-  std::vector<Shape*> shapes;
-  shapes.push_back(this->shape);
   this->traverse_outer(outer_polyline->parts().front(),
                        all_parts,
-                       this->polylines_sequence,
-                       shapes,
-                       outer_joined_polyline, counter);
+                       this->shapes_sequence,
+                       outer_joined_polyline);
 
   if (*outer_joined_polyline->head->payload == *outer_joined_polyline->tail->payload &&
       this->cluster.tiles().front()->left() &&
       this->cluster.tiles().back()->right()) outer_joined_polyline->pop();
 
-  // TODO(ema): optimize
-  std::unordered_set<Polyline*> seen;
-  std::vector<Polyline*> result;
-  for (Polyline* x : polylines_sequence) {
-      if (seen.insert(x).second) {
-          result.push_back(x);
-      }
-  }
-  polylines_sequence = result;
-
-  for (Polyline* polyline : polylines_sequence) {
-    polyline->turn_on(Polyline::TRACKED_OUTER);
-  }
-
-  for (Shape *shape : shapes)
-  { if (shape == outer_polyline->shape) {
+  for (Shape* shape : shapes_sequence) {
+    shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
+    if (shape == outer_polyline->shape) {
       continue;
     }
     orphan_inners_.insert(
@@ -70,22 +54,13 @@ Sequence* Cursor::join_outers()
 
 void Cursor::traverse_outer(Part* act_part,
                             std::vector<Part*>& all_parts,
-                            std::vector<Polyline*>& polylines,
-                            std::vector<Shape*>& shapes,
-                            Sequence* outer_joined_polyline,
-                            int& counter) {
+                            std::vector<Shape*>& shapes_sequence,
+                            Sequence* outer_joined_polyline) {
   while (act_part != nullptr) {
-    counter += 1;
-
     if (all_parts.empty() || all_parts.back() != act_part) {
       all_parts.push_back(act_part);
     }
 
-    Shape* target_shape = act_part->polyline()->shape;
-    if (std::find(shapes.begin(), shapes.end(), target_shape) == shapes.end()) {
-      shapes.push_back(target_shape);
-    }
-
     bool jumped_to_new_part = false;
     if (act_part->is(Part::EXCLUSIVE)) {
       if (act_part->size == 0) return;
@@ -123,7 +98,9 @@ void Cursor::traverse_outer(Part* act_part,
                 }
                 if (all_seam) break;
               }
-              polylines.push_back(part->polyline()->shape->outer_polyline);
+              if (shapes_sequence_lookup.insert(part->polyline()->shape).second) {
+                shapes_sequence.push_back(part->polyline()->shape);
+              }
               part->next_position(new_position);
               act_part = part;
               jumped_to_new_part = true;
@@ -152,33 +129,40 @@ std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
     { if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) ||
         shape->outer_polyline->is_on(Polyline::TRACKED_INNER) ||
         !shape->outer_polyline->boundary() ||
-        std::find(polylines_sequence.begin(), polylines_sequence.end(), shape->outer_polyline) != polylines_sequence.end()) {
+        std::find(shapes_sequence.begin(), shapes_sequence.end(), shape) != shapes_sequence.end()) {
         continue;
       }
       missing_shapes.push_back(shape);
     }
   }
 
-  std::vector<Shape*> to_delay;
-  to_delay = connect_missings(missing_shapes);
-  while (!to_delay.empty()) {
-    to_delay = connect_missings(to_delay);
+  if (missing_shapes.size() > 0) {
+    std::vector<Shape*> to_delay_shapes;
+    to_delay_shapes = connect_missings(this->shapes_sequence, missing_shapes);
+    if (!to_delay_shapes.empty())
+    { connect_missings(to_delay_shapes, missing_shapes);
+      while (!to_delay_shapes.empty()) {
+        to_delay_shapes = connect_missings(this->shapes_sequence, to_delay_shapes);
+      }
+    }
   }
 
   retme = collect_inner_sequences(outer_seq);
-  for (Polyline* polyline : polylines_sequence) {
-    polyline->turn_on(Polyline::TRACKED_INNER);
+  for (Shape* shape : shapes_sequence) {
+    shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
   }
   return(retme);
 }
 
-std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> missing_shapes) {
+std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes) {
   std::vector<Shape*> delay_shapes;
 
-  for (Polyline *polyline : polylines_sequence)
-  { for (Shape *missing_shape : missing_shapes)
+  for (Shape* shape : shapes_sequence)
+  { Polyline* polyline = shape->outer_polyline;
+    for (Shape* missing_shape : missing_shapes)
     { Polyline* outer_polyline = missing_shape->outer_polyline;
-      if ( outer_polyline->is_on(Polyline::TRACKED_OUTER)  ||
+      if ( (polyline->mixed_tile_origin == false && outer_polyline->tile == polyline->tile) ||
+           outer_polyline->is_on(Polyline::TRACKED_OUTER)  ||
            !polyline->vert_intersect(*outer_polyline)) continue;
       std::vector<std::pair<int, int>> intersection = polyline->intersection(outer_polyline);
       if (intersection.size() > 0)
@@ -218,6 +202,7 @@ std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> missing_shapes)
             orphan_inners_.push_back(sewn_sequence);
           }
         }
+        polyline->mixed_tile_origin = true;
         outer_polyline->clear();
         outer_polyline->turn_on(Polyline::TRACKED_OUTER);
         outer_polyline->turn_on(Polyline::TRACKED_INNER);
@@ -235,8 +220,9 @@ std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> missing_shapes)
 std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
   std::vector<Sequence*> return_sequences;
 
-  for (Polyline* polyline : polylines_sequence)
-  { for (Part* part : polyline->parts())
+  for (Shape* shape : shapes_sequence)
+  { Polyline* polyline = shape->outer_polyline;
+    for (Part* part : polyline->parts())
     { if (part->innerable())
       { std::vector<Part*> all_parts;
         Bounds bounds{
@@ -291,15 +277,17 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
             for (Part* dest_part : shape->outer_polyline->parts()) {
               if (dest_part->trasmuted || dest_part->is(Part::EXCLUSIVE)) continue;
               if (dest_part->intersect_part(act_part)) {
-                std::vector<Point*> link_seq = duplicates_intersection(*dest_part, *act_part);
+                std::vector<EndPoint*> link_seq = duplicates_intersection(*dest_part, *act_part);
                 if (!link_seq.empty()) {
                   Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
-                  for (Point* pos : link_seq) {
-                    this->cluster.positions_pool.emplace_back(this->cluster.hub(), pos);
+                  for (EndPoint* pos : link_seq) {
+                    this->cluster.positions_pool.emplace_back(pos);
                     ins_part->add(&this->cluster.positions_pool.back());
                   }
                   all_parts.push_back(ins_part);
                 }
+                shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
+                shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
                 act_part = dest_part->circular_next;
                 jumped = true;
                 break;
@@ -324,14 +312,13 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
 }
 
 template <typename T>
-std::vector<T*> difference_ptr(const std::vector<T*>& a, const std::vector<T*>& b)
+std::vector<T*> difference_ptr(std::vector<T*>& a, std::vector<T*>& b)
 { std::vector<T*> result;
   for (T* item : a) {
-    if (!item) continue;
     auto it = std::find_if(
       b.begin(), b.end(),
       [&](T* other) {
-          return other && *other == *item;
+        return other == item;
       });
     if (it == b.end()) {
       result.push_back(item);
@@ -340,11 +327,13 @@ std::vector<T*> difference_ptr(const std::vector<T*>& a, const std::vector<T*>&
   return result;
 }
 
-std::vector<Point*> Cursor::duplicates_intersection(const Part& part_a, const Part& part_b) {
-  std::vector<Point*> a1 = part_a.inverts ? part_a.remove_adjacent_pairs(part_a.to_vector()) : part_a.to_vector();
-  std::vector<Point*> b1 = part_b.inverts ? part_b.remove_adjacent_pairs(part_b.to_vector()) : part_b.to_vector();
-  std::vector<Point*> result = difference_ptr(a1, b1);
-  std::vector<Point*> temp = difference_ptr(b1, a1);
+std::vector<EndPoint*> Cursor::duplicates_intersection(Part& part_a, Part& part_b) {
+  auto a1 = part_a.to_endpoints();
+  auto b1 = part_b.to_endpoints();
+  if (part_a.inverts) a1 = Part::remove_adjacent_pairs(a1);
+  if (part_b.inverts) b1 = Part::remove_adjacent_pairs(b1);
+  std::vector<EndPoint*> result = difference_ptr(a1, b1);
+  std::vector<EndPoint*> temp = difference_ptr(b1, a1);
   result.insert(result.end(), temp.begin(), temp.end());
   return result;
 }

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

@@ -9,6 +9,7 @@
 #pragma once
 #include <list>
 #include <vector>
+#include <unordered_set>
 #include "Sequence.h"
 #include "Cluster.h"
 #include "Shape.h"
@@ -31,17 +32,16 @@ class Cursor {
   Cluster& cluster;
   Shape* shape;
   std::vector<Sequence*> allocated_sequences;
-  std::vector<Polyline*> polylines_sequence;
+  std::vector<Shape*> shapes_sequence;
+  std::unordered_set<Shape*> shapes_sequence_lookup;
   std::list<std::vector<Point*>> orphan_inners_;
   void traverse_outer(Part* act_part,
                       std::vector<Part*>& all_parts,
-                      std::vector<Polyline*>& polylines,
-                      std::vector<Shape*>& shapes,
-                      Sequence* outer_joined_polyline,
-                      int& counter);
+                      std::vector<Shape*>& shapes_sequence,
+                      Sequence* outer_joined_polyline);
   std::vector<Sequence*> collect_inner_sequences(Sequence* outer_seq);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
-  std::vector<Point*> duplicates_intersection(const Part& part_a, const Part& part_b);
+  std::vector<EndPoint*> duplicates_intersection(Part& part_a, Part& part_b);
   std::vector<std::vector<Point*>> combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb);
-  std::vector<Shape*> connect_missings(std::vector<Shape*> missing_shapes);
+  std::vector<Shape*> connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes);
 };

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

@@ -14,9 +14,13 @@ class Part;
 
 class EndPoint {
  public:
-  EndPoint() {}
+  EndPoint() : point_(nullptr) {}
+
+  void set_point(Point* p) { point_ = p; }
+  Point* get_point() const { return point_; }
   std::vector<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
  private:
+  Point* point_;
   std::vector<Queueable<Point>*> queues_;
 };

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

@@ -8,6 +8,7 @@
 
 #include "Part.h"
 #include <iostream>
+#include <vector>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Cluster.h"
@@ -69,3 +70,26 @@ bool Part::intersect_part(Part* other_part)
   });
   return(intersect);
 }
+
+std::vector<EndPoint*> Part::to_endpoints() {
+  std::vector<EndPoint*> out;
+  QNode<Point>* current = head;
+  while (current) {
+    out.push_back((dynamic_cast<Position*>(current))->end_point());
+    current = current->next;
+  }
+  return out;
+}
+
+std::vector<EndPoint*> Part::remove_adjacent_pairs(const std::vector<EndPoint*>& input = {}) {
+  std::vector<EndPoint*> result;
+  result.reserve(input.size());
+  for (EndPoint* current : input) {
+    if (!result.empty() && result.back() == current) {
+      result.pop_back();
+    } else {
+      result.push_back(current);
+    }
+  }
+  return result;
+}

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

@@ -10,12 +10,15 @@
 #include <cstdint>
 #include <string>
 #include <deque>
+#include <vector>
 #include "Queueable.h"
 #include "Position.h"
+#include "EndPoint.h"
 #include "../Node.h"
 
 class Polyline;
 class Position;
+class EndPoint;
 class Part : public Queueable<Point> {
  public:
   enum Types : uint32_t {
@@ -42,6 +45,8 @@ class Part : public Queueable<Point> {
   void touch();
   bool intersect_part(Part* other_part);
   void set_polyline(Polyline* polyline) { this->polyline_ = polyline; }
+  std::vector<EndPoint*> to_endpoints();
+  static std::vector<EndPoint*> remove_adjacent_pairs(const std::vector<EndPoint*>& input);
 
  private:
   bool touched_ = false;

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

@@ -45,6 +45,7 @@ class Polyline : public Partitionable {
   bool is_empty();
   bool vert_intersect(Polyline& other);
   void reset_tracked_endpoints();
+  bool mixed_tile_origin = false;
 
  private:
   std::vector<Point*> raw_;

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

@@ -16,12 +16,18 @@ Position::Position(Hub* hub, Point* point)
     EndPoint* existing_ep = hub->get(key);
     if (existing_ep == nullptr)
     { end_point_ = hub->put(key, hub->spawn_end_point());
+      end_point_->set_point(point);
     } else {
       end_point_ = existing_ep;
     }
   }
 }
 
+Position::Position(EndPoint* end_point)
+  : QNode<Point>(end_point->get_point())
+{  this->end_point_ = end_point;
+}
+
 void Position::before_rem(Queueable<Point>* q)  {
   if (this->end_point_ != nullptr) {
     auto& queues = this->end_point_->queues();

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

@@ -17,7 +17,8 @@ class Hub;
 class Position : public QNode<Point>{
  public:
   explicit Position(Hub* hub, Point* point);
-  const EndPoint* end_point() const { return end_point_; }
+  explicit Position(EndPoint* end_point);
+  EndPoint* end_point() { return end_point_; }
   void before_rem(Queueable<Point>* q) override;
   void after_add(Queueable<Point>* q) override;
  private:

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

@@ -206,19 +206,4 @@ class Queueable {
     }
     return false;
   }
-
-  std::vector<T*> remove_adjacent_pairs(const std::vector<T*>& input = {}) const {
-    const std::vector<T*>& source = input.empty() ? to_vector() : input;
-    std::vector<T*> result;
-    result.reserve(source.size());
-
-    for (T* current : source) {
-      if (!result.empty() && *result.back() == *current) {
-          result.pop_back();
-      } else {
-          result.push_back(current);
-      }
-    }
-    return result;
-  }
 };

data/lib/contrek/bitmaps/custom_bitmap.rb

@@ -1,8 +1,8 @@
 module Contrek
   module Bitmaps
     class CustomBitmap < PngBitmap
-      def initialize(w:, h:)
-        @image = ChunkyPNG::Image.new(w, h, ChunkyPNG::Color::TRANSPARENT)
+      def initialize(w:, h:, color: ChunkyPNG::Color::TRANSPARENT)
+        @image = ChunkyPNG::Image.new(w, h, color)
       end
     end
   end

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

@@ -3,11 +3,10 @@ module Contrek
     class Cursor
       attr_reader :orphan_inners
       def initialize(cluster:, shape:)
-        @polylines_sequence = []
+        @shapes_sequence = Set.new([shape])
         @cluster = cluster
         @outer_polyline = shape.outer_polyline
         @orphan_inners = []
-        @shapes = [shape]
       end
 
       def inspect
@@ -15,26 +14,22 @@ module Contrek
       end
 
       # Given the initial polyline, draw its outer boundary, possibly extending into
-      # adjacent polylines, and then connect them. At the end, @polylines_sequence
+      # adjacent polylines, and then connect them. At the end, @shapes_sequence
       # contains the merged polylines. Returns a new resulting polyline.
       def join_outers!
         seq_log = []
-        @polylines_sequence << @outer_polyline
 
         outer_joined_polyline = Sequence.new
-
         traverse_outer(@outer_polyline.parts.first,
           seq_log,
-          @polylines_sequence,
-          @shapes,
+          @shapes_sequence,
           outer_joined_polyline)
         outer_joined_polyline.pop! if outer_joined_polyline.head.payload == outer_joined_polyline.tail.payload &&
           @cluster.tiles.first.left? && @cluster.tiles.last.right?
 
-        @polylines_sequence.uniq!
-
-        @polylines_sequence.each { |c| c.turn_on(Polyline::TRACKED_OUTER) }
-        (@shapes - [@outer_polyline.shape]).each do |shape|
+        @shapes_sequence.each do |shape|
+          shape.outer_polyline.turn_on(Polyline::TRACKED_OUTER)
+          next if shape == @outer_polyline.shape
           @orphan_inners += shape.inner_polylines
           shape.clear_inner!
         end
@@ -50,32 +45,41 @@ module Contrek
             next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) ||
               shape.outer_polyline.on?(Polyline::TRACKED_INNER) ||
               !shape.outer_polyline.boundary? ||
-              @polylines_sequence.include?(shape.outer_polyline)
+              @shapes_sequence.include?(shape)
             missing_shapes << shape
           end
         end
-        to_delay = connect_missings(missing_shapes)
-        while to_delay.any?
-          to_delay = connect_missings(to_delay)
+
+        if missing_shapes.any?
+          to_delay_shapes = connect_missings(@shapes_sequence, missing_shapes)
+          if to_delay_shapes.any?
+            connect_missings(to_delay_shapes, missing_shapes)
+            while to_delay_shapes.any?
+              to_delay_shapes = connect_missings(@shapes_sequence, to_delay_shapes)
+            end
+          end
         end
 
         retme = collect_inner_sequences(outer_seq)
 
-        @polylines_sequence.each do |polyline|
-          polyline.turn_on(Polyline::TRACKED_INNER)
+        @shapes_sequence.each do |shape|
+          shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
         end
         retme
       end
 
       private
 
-      def connect_missings(missing_shapes)
+      def connect_missings(shapes_sequence, missing_shapes)
         delay_shapes = []
 
-        @polylines_sequence.each do |polyline|
+        shapes_sequence.each do |shape|
+          polyline = shape.outer_polyline
           missing_shapes.each do |missing_shape|
             missing_outer_polyline = missing_shape.outer_polyline
-            next if missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
+            next if (polyline.mixed_tile_origin == false && missing_outer_polyline.tile == polyline.tile) || # accepts only other side ones
+              missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
+              polyline == missing_outer_polyline ||
               !polyline.vert_intersect?(missing_outer_polyline)
 
             if (intersection = polyline.intersection(missing_outer_polyline)).any?
@@ -89,6 +93,7 @@ module Contrek
                 @orphan_inners << sewn_sequence if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # segmenti non sono ammessi, solo aree
               end
               missing_outer_polyline.clear!
+              polyline.mixed_tile_origin = true
               missing_outer_polyline.turn_on(Polyline::TRACKED_OUTER)
               missing_outer_polyline.turn_on(Polyline::TRACKED_INNER)
               @orphan_inners += missing_shape.inner_polylines
@@ -100,9 +105,9 @@ module Contrek
       end
 
       # rubocop:disable Lint/NonLocalExitFromIterator
-      def traverse_outer(act_part, all_parts, polylines, shapes, outer_joined_polyline)
+      def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
         all_parts << act_part if all_parts.last != act_part
-        shapes << act_part.polyline.shape if !shapes.include?(act_part.polyline.shape)
+
         if act_part.is?(Part::EXCLUSIVE)
           return if act_part.size == 0
           while (position = act_part.next_position)
@@ -125,9 +130,9 @@ module Contrek
                     map = all_parts[-2..].map(&:type).uniq
                     break if map.size == 1 && map.first == Part::SEAM
                   end
-                  polylines << part.polyline.shape.outer_polyline
+                  shapes_sequence.add(part.polyline.shape)
                   part.next_position(new_position)
-                  traverse_outer(part, all_parts, polylines, shapes, outer_joined_polyline)
+                  traverse_outer(part, all_parts, shapes_sequence, outer_joined_polyline)
                   return
                 end
               end
@@ -138,12 +143,13 @@ module Contrek
         end
         next_part = act_part.circular_next
         next_part.rewind!
-        traverse_outer(act_part.circular_next, all_parts, polylines, shapes, outer_joined_polyline)
+        traverse_outer(act_part.circular_next, all_parts, shapes_sequence, outer_joined_polyline)
       end
 
       def collect_inner_sequences(outer_seq)
         return_sequences = []
-        @polylines_sequence.each do |polyline|
+        @shapes_sequence.each do |shape|
+          polyline = shape.outer_polyline
           polyline.parts.each do |part|
             if part.innerable?
               all_parts = []
@@ -154,9 +160,9 @@ module Contrek
               retme_sequence = Sequence.new
               all_parts.each do |part|
                 part.touch!
-                retme_sequence.move_from(part) do |pos|
-                  next false if part.is?(Part::ADDED) && !(range_of_bounds === pos.payload[:y])
-                  !(polyline.tile.tg_border?(pos.payload) && pos.end_point.queues.include?(outer_seq))
+                retme_sequence.move_from(part) do |position|
+                  next false if part.is?(Part::ADDED) && !(range_of_bounds === position.payload[:y])
+                  !(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
@@ -189,10 +195,12 @@ module Contrek
                     if link_seq.any?
                       ins_part = Part.new(Part::ADDED, act_part.polyline)
                       link_seq.each do |pos|
-                        ins_part.add(Position.new(position: pos, hub: @cluster.hub))
+                        ins_part.add(Position.new(position: nil, hub: nil, known_endpoint: pos))
                       end
                       all_parts << ins_part
                     end
+                    shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
+                    shape.outer_polyline.turn_on(Polyline::TRACKED_OUTER)
                     traverse_inner(dest_part.circular_next, all_parts, bounds)
                     return
                   end
@@ -213,9 +221,8 @@ module Contrek
       # 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_a.remove_adjacent_pairs : part_a.to_a
-        b1 = part_b.inverts ? part_b.remove_adjacent_pairs : part_b.to_a
-
+        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
 

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

@@ -1,9 +1,10 @@
 module Contrek
   module Concurrent
     class EndPoint
-      attr_reader :queues
-      def initialize
+      attr_reader :queues, :position
+      def initialize(position)
         @queues = []
+        @position = position
       end
 
       def inspect

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

@@ -73,6 +73,22 @@ module Contrek
         end
         false
       end
+
+      def to_endpoints
+        map(&:end_point)
+      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)
+          end
+        end
+        array
+      end
     end
   end
 end

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

@@ -7,7 +7,7 @@ module Contrek
       TRACKED_INNER = 1 << 1
 
       attr_reader :raw, :name, :min_y, :max_y, :next_tile_eligible_shapes
-      attr_accessor :shape, :tile
+      attr_accessor :shape, :tile, :mixed_tile_origin
 
       def initialize(tile:, polygon:, shape: nil, bounds: nil)
         @tile = tile
@@ -15,6 +15,7 @@ module Contrek
         @raw = polygon
         @shape = shape
         @flags = 0
+        @mixed_tile_origin = false # becomes true when is sewn with polyline coming from other side tile
 
         if bounds.nil?
           find_boundary

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

@@ -5,9 +5,14 @@ module Contrek
 
       attr_reader :end_point
 
-      def initialize(hub:, position:)
-        @end_point = hub.payloads[position[:y]] ||= EndPoint.new if hub
-        @position = position
+      def initialize(hub:, position:, known_endpoint: nil)
+        if !known_endpoint.nil?
+          @end_point = known_endpoint
+          @position = @end_point.position
+        else
+          @end_point = hub.payloads[position[:y]] ||= EndPoint.new(position) if hub
+          @position = position
+        end
       end
 
       def payload
@@ -21,6 +26,10 @@ module Contrek
       def before_rem(old_queue)
         @end_point&.queues&.delete(old_queue)
       end
+
+      def inspect
+        "#{self.class} (#{payload})"
+      end
     end
   end
 end

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

@@ -153,19 +153,6 @@ module Contrek
         rem(@tail)
       end
 
-      def remove_adjacent_pairs(array = nil)
-        array = to_a if 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)
-          end
-        end
-        array
-      end
-
       def remove_adjacent_pairs!
         unless @tail.nil?
           pointer = @tail
@@ -182,15 +169,6 @@ module Contrek
           end
         end
       end
-
-      #       def index(node)
-      #         index = 0
-      #         each do |loop_node|
-      #           return index if node == loop_node
-      #           index += 1
-      #         end
-      #         -1
-      #       end
     end
   end
 end

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.0.9"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.0
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-31 00:00:00.000000000 Z
+date: 2026-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec