contrek 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60fae59ed14c24cedd7dadfdc33dea05188b1131ee6443b59591e5243cb4710b
-  data.tar.gz: b565f7a0e9713a9389329cf1cc44f9c2da36908d75c538af625afdb6e1d9d71a
+  metadata.gz: 2b2690fa75c9a6671f9c8ea91522d3adaf8600bfc0739dad4c8eb4a14b80d97e
+  data.tar.gz: 38db9719cc44356ec32d33031e877edda131a970ec0fb5e385f9c31e19699858
 SHA512:
-  metadata.gz: 86ece9b65041fae9aec64173f5e3bb719971852a6327953b78dc6567f94018db544cc8b7e062d57aad3a859f8142982406e1d9301716f2a49eaa8a05a586ddfc
-  data.tar.gz: 87a22df67016a3249a069cec0bee1746ddb92c1103f9a98e0a8e85b2240ae7d4be735123cfa72443432b30a91be333c4d195b384b194f5703a075b4832e07bd6
+  metadata.gz: 4827a05d797400b0245c8225274dc070870e83186d51da4b4f16bb8368359597967012b65cedbff39f808fa9d1eafad5e3012e144f10afb801d564a2ff916dca
+  data.tar.gz: 690435e9531d0c8c47c703e41c4719333b91edbe60232a5183c30e21a2822c06b827498b49afbda4785cff404e3abdaf776f0a0b4aec9c9b58a0a9fbf29c8844

data/CHANGELOG.md

@@ -52,4 +52,9 @@ All notable changes to this project will be documented in this file.
 ## [1.1.3] - 2026-02-21
 ### Changed
 - Added support for 8-way pixel connectivity (omnidirectional) in addition to the standard 4-way mode.
-- Optimized C++ and Ruby algorithms for initial spatial pixel tracking to improve performance. 
+- Optimized C++ and Ruby algorithms for initial spatial pixel tracking to improve performance.
+
+## [1.1.4] - 2026-02-28
+### Changed
+- Fixed an infinite loop bug in multithreading during inner sequence joining in Omnidirectional mode.
+- Optimized C++ and Ruby algorithms for initial spatial tangential sequence determination.

data/Gemfile.lock

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

data/README.md

@@ -112,7 +112,7 @@ 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 4 threads working on 4 tiles (total compute time about 1.53 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.2 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
@@ -126,11 +126,11 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{ compress: 13.0815,
-  init: 453.245,
-  inner: 27.0072,
-  outer: 66.9162,
-  total: 466.326
+{ compress: 26.37,
+  init: 354.339,
+  inner: 17.9427,
+  outer: 93.6252,
+  total: 380.709
 }
 
 ```
@@ -288,23 +288,24 @@ This process is applied recursively, merging bands until a single final band rem
 One of the most complex test you can find under the spec folder is named "scans poly 1200x800", scans this [image](spec/files/images/sample_1200x800.png) computing coordinates to draw polygons drawn in this [result](spec/files/stored_samples/sample_1200x800.png).
 On pure ruby implementation kept time
 ```ruby
-{ :scan=>801.494,
-  :build_tangs_sequence=>160.491,
-  :plot=>86.633,
+{ :scan=>775.435,
+  :build_tangs_sequence=>38.916,
+  :plot=>101.876,
   :compress=>0.002,
-  :total=>1048.62}
+  :total=>916.229
+}
 ```
 This the one for the native C++
 ```ruby
-{ scan: 7.1146329999999995,
-  build_tangs_sequence: 3.063812,
-  plot: 4.474851999999999,
-  compress: 0.0031999999999999997
-  total: 14.656496999999998
+{ scan: 5.077878999999999,
+  build_tangs_sequence: 0.697222999999999,
+  plot: 2.00479,
+  compress: 0.00071,
+  total: 7.780602
 }
 ```
 
-About 75x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
+About 130x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
 
 ## 🛠 C++ Standalone Library Usage
 

data/ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h

@@ -70,7 +70,7 @@ inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const
       if (m.flag) internal_args.emplace_back(m.arg);
   }
   internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
-  if(cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
+  if (cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
     internal_args.push_back("--connectivity=" + std::to_string(8));
   }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp

@@ -44,6 +44,8 @@ FastPngBitmap::FastPngBitmap(std::string filename) : Bitmap("", 0) {
         spng_ctx_free(ctx);
         this->png_error = error;
       }
+    } else {
+      throw std::runtime_error("Unable open file: " + filename);
     }
   }
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.cpp

@@ -17,9 +17,10 @@
 #include "Node.h"
 #include "NodeCluster.h"
 
-Node::Node(int min_x, int max_x, int y, char name)
+Node::Node(int min_x, int max_x, int y, NodeCluster* cluster, char name)
 : start_point(min_x, y),
-  end_point(max_x, y) {
+  end_point(max_x, y),
+  cluster(cluster) {
   this->name = name;
   this->min_x = min_x;
   this->max_x = max_x;
@@ -67,24 +68,14 @@ void Node::precalc_tangs_sequences(NodeCluster& cluster) {
   }
   // --- CLOCKWISE (UP) ---
   for (int upper_pos = this->upper_start; upper_pos <= this->upper_end; upper_pos++) {
-    Node& t_node = cluster.vert_nodes[y + T_UP][upper_pos];
-    tangs_sequence.emplace_back(NodeDescriptor{
-      &t_node,
-      Tangent{ &t_node.end_point, OMAX},
-      Tangent{ &t_node.start_point, OMIN}
-    });
+    tangs_sequence.push_back(-(upper_pos + 1));
   }
   if (this->lower_end >= 0) {
     this->down_indexer = (cluster.vert_nodes[y + T_DOWN][this->lower_start].abs_x_index + lower_size + upper_size - 1);
   }
   // --- COUNTER-CLOCKWISE (DOWN) ---
   for (int lower_pos = this->lower_end; lower_pos >= this->lower_start; lower_pos--) {
-    Node& t_node = cluster.vert_nodes[y + T_DOWN][lower_pos];
-    tangs_sequence.emplace_back(NodeDescriptor{
-      &t_node,
-      Tangent{&t_node.start_point, OMIN},
-      Tangent{&t_node.end_point, OMAX}
-    });
+    tangs_sequence.push_back(lower_pos);
   }
   this->tangs_count = this->tangs_sequence.size();
 }
@@ -95,7 +86,7 @@ Node* Node::my_next_inner(Node *last, int versus) {
   else            last_node_index = this->down_indexer - last->abs_x_index;
   if (versus == Node::O) last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
   else          last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
-  return((this->tangs_sequence)[last_node_index].node);
+  return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Node* Node::my_next_outer(Node *last, int versus) {
@@ -104,15 +95,42 @@ Node* Node::my_next_outer(Node *last, int versus) {
   else                   last_node_index = this->down_indexer - last->abs_x_index;
   if (versus == Node::O) last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
   else                   last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
-  return((this->tangs_sequence)[last_node_index].node);
+  return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Point* Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
   int enter_to_index;
   if (enter_to->y < this->y) enter_to_index = enter_to->abs_x_index + this->up_indexer;
   else                       enter_to_index = this->down_indexer - enter_to->abs_x_index;
-  NodeDescriptor ds = (this->tangs_sequence)[enter_to_index];
-  Tangent t = (mode == Node::O ? ds.o : ds.a);
-  enter_to->track |= TURNER[tracking][t.mode - 1];
-  return(t.point);
+
+  int tg_index = this->tangs_sequence[enter_to_index];
+  Point* point;
+  if (tg_index < 0) {
+    Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
+    if (mode == Node::A) {
+      enter_to->track |= TURNER[tracking][OMAX - 1];
+      point = &node_up.end_point;
+    } else {
+      enter_to->track |= TURNER[tracking][OMIN - 1];
+      point = &node_up.start_point;
+    }
+  } else {
+    Node& node_down = cluster->vert_nodes[y + T_DOWN][tg_index];
+    if (mode == Node::A) {
+      enter_to->track |= TURNER[tracking][OMIN - 1];
+      point = &node_down.start_point;
+    } else {
+      enter_to->track |= TURNER[tracking][OMAX - 1];
+      point = &node_down.end_point;
+    }
+  }
+  return point;
+}
+
+Node* Node::get_tangent_node_by_virtual_index(int virtual_index) {
+  if (virtual_index < 0) {
+    return &(this->cluster->vert_nodes[y + T_UP][-(virtual_index + 1)]);
+  } else {
+    return &(this->cluster->vert_nodes[y + T_DOWN][virtual_index]);
+  }
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.h

@@ -28,11 +28,6 @@ struct Point {
   }
   Point(int x_, int y_) : x(x_), y(y_) {}
 };
-struct Tangent {
-  Point   *point;
-  int   mode;
-};
-struct NodeDescriptor;
 
 class Node : public  Listable {
  public:
@@ -63,24 +58,20 @@ class Node : public  Listable {
   int lower_start = std::numeric_limits<int>::max();
   int lower_end   = -1;
   Point start_point, end_point;
+  NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
-  std::vector<NodeDescriptor> tangs_sequence;
+  std::vector<int> tangs_sequence;
   Point* coords_entering_to(Node *enter_to, int mode, int tracking);
   Node* my_next_outer(Node *last, int versus);
   Node* my_next_inner(Node *last, int versus);
+  Node* get_tangent_node_by_virtual_index(int vitual_index);
   bool track_uncomplete();
   bool track_complete();
   bool get_trackmax();
 
  public:
   int min_x, max_x;
-  Node(int min_x, int max_x, int y, char name);
+  Node(int min_x, int max_x, int y, NodeCluster* cluster, char name);
   void precalc_tangs_sequences(NodeCluster& cluster);
   bool processed = false;
 };
-
-struct NodeDescriptor {
-  Node  *node;
-  Tangent a;
-  Tangent o;
-};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.cpp

@@ -75,7 +75,7 @@ void NodeCluster::build_tangs_sequence() {
 }
 
 Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset) {
-  vert_nodes[y].emplace_back(min_x, max_x, y, name);
+  vert_nodes[y].emplace_back(min_x, max_x, y, this, name);
 
   Node& node = vert_nodes[y].back();
   node.abs_x_index = vert_nodes[y].size() - 1;
@@ -115,8 +115,11 @@ void NodeCluster::plot(int versus) {
     this->plot_sequence.push_back(root_node);
     Polygon poly;
 
-    if ((root_node)->tangs_sequence.size() > 0)  // front() on empty list is undefined
-    { versus == Node::A ? next_node = root_node->tangs_sequence.back().node : next_node = root_node->tangs_sequence.front().node;
+    if ((root_node)->tangs_sequence.size() > 0)  // front() or back() on empty list is undefined
+    { versus == Node::A ?
+        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.back()) :
+        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
+
       if (next_node != nullptr)
       { Point* p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
         poly.outer.push_back(p);
@@ -254,7 +257,11 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
 
     bool plot = true;
     if (next_node->y == last_node->y) {
-      Node *n = (versus == Node::A ? current_node->tangs_sequence.front().node : current_node->tangs_sequence.back().node);
+      Node *n;
+      int virtual_index = (versus == Node::A ?
+        current_node->tangs_sequence.front() :
+        current_node->tangs_sequence.back());
+      n = current_node->get_tangent_node_by_virtual_index(virtual_index);
       plot = (n == next_node);
     }
     if (plot) {
@@ -289,7 +296,10 @@ void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, No
 
     bool plot = true;
     if (next_node->y == last_node->y) {
-      Node *n = (versus == Node::A ? current_node->tangs_sequence.back().node : current_node->tangs_sequence.front().node);
+      int virtual_index = (versus == Node::A ?
+          current_node->tangs_sequence.back() :
+          current_node->tangs_sequence.front());
+      Node *n = current_node->get_tangent_node_by_virtual_index(virtual_index);
       plot = (n == next_node);
     }
     if (plot) {

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

@@ -242,7 +242,7 @@ std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
         for (Part* part : all_parts)
         { part->touch();
           retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
-          Position *position = dynamic_cast<Position*>(pos);
+          Position *position = static_cast<Position*>(pos);
           if (part->is(Part::ADDED) &&
              !(position->payload->y >= bounds.min &&
               position->payload->y <= bounds.max)) {
@@ -283,6 +283,8 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
           for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
             for (Part* dest_part : shape->outer_polyline->parts()) {
               if (dest_part->trasmuted || dest_part->is(Part::EXCLUSIVE)) continue;
+              int dest_part_versus = dest_part->versus();
+              if (dest_part_versus != 0 && dest_part_versus == act_part->versus()) continue;
               if (dest_part->intersect_part(act_part)) {
                 std::vector<EndPoint*> link_seq = duplicates_intersection(*dest_part, *act_part);
                 if (!link_seq.empty()) {

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

@@ -9,6 +9,7 @@
 
 #pragma once
 #include <vector>
+#include <unordered_set>
 #include "Part.h"
 
 class Part;
@@ -19,9 +20,9 @@ class EndPoint {
 
   void set_point(Point* p) { point_ = p; }
   Point* get_point() const { return point_; }
-  std::vector<Queueable<Point>*>& queues() { return queues_; }
+  std::unordered_set<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
  private:
   Point* point_;
-  std::vector<Queueable<Point>*> queues_;
+  std::unordered_set<Queueable<Point>*> queues_;
 };

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

@@ -64,7 +64,7 @@ void Part::touch()
 bool Part::intersect_part(Part* other_part)
 { bool intersect = false;
   other_part->each([&](QNode<Point>* pos) -> bool {
-    Position *position = dynamic_cast<Position*>(pos);
+    Position *position = static_cast<Position*>(pos);
     if (position->end_point()->queues_include(this))
     { intersect = true;
       return(false);
@@ -78,7 +78,7 @@ 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());
+    out.push_back((static_cast<Position*>(current))->end_point());
     current = current->next;
   }
   return out;

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

@@ -48,7 +48,7 @@ void Partitionable::insert_after(Part* part, Part* new_part) {
 
 void Partitionable::partition()
 { this->parts_.clear();
-  Polyline *polyline = dynamic_cast<Polyline*>(this);
+  Polyline *polyline = static_cast<Polyline*>(this);
   PartPool& pool = polyline->tile->cluster->parts_pool;
   Part *current_part = nullptr;
   int n = 0;
@@ -159,7 +159,7 @@ std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>>
   }
 
   std::vector<Part*> all_parts;
-  Polyline* polyline = dynamic_cast<Polyline*>(this);
+  Polyline* polyline = static_cast<Polyline*>(this);
   all_parts.reserve(before_parts.size() + after_parts.size());
   all_parts.insert(all_parts.end(), before_parts.begin(), before_parts.end());
   all_parts.insert(all_parts.end(), after_parts.begin(), after_parts.end());
@@ -208,9 +208,9 @@ void Partitionable::trasmute_parts()
       if (inside == inside_compare || !inside_compare->is(Part::SEAM) ) continue;
       int count = 0;
       inside->each([&](QNode<Point>* pos) -> bool {
-        Position *position = dynamic_cast<Position*>(pos);
+        Position *position = static_cast<Position*>(pos);
         if (position->end_point()->queues_include(inside_compare))
-        { count ++;
+        { count++;
           return true;
         }
         return false;

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

@@ -9,6 +9,7 @@
 
 #include <vector>
 #include <limits>
+#include <string>
 #include <unordered_set>
 #include <sstream>
 #include "Polyline.h"
@@ -77,7 +78,7 @@ std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) c
       auto& part = parts_[i];
       if (!part->is(Part::SEAM) && part->trasmuted) continue;
       part->each([&](QNode<Point>* pos) -> bool {
-        Position *position = dynamic_cast<Position*>(pos);
+        Position *position = static_cast<Position*>(pos);
         if (position->end_point() != nullptr)
         { this->tracked_endpoints[position->end_point()] = i;
         }
@@ -93,7 +94,7 @@ std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) c
       continue;
     }
     other_part->each([&](QNode<Point>* pos) -> bool {
-      Position *position = dynamic_cast<Position*>(pos);
+      Position *position = static_cast<Position*>(pos);
       auto it = this->tracked_endpoints.find(position->end_point());
       if (it != this->tracked_endpoints.end()) {
         int self_index = it->second;

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

@@ -30,12 +30,9 @@ Position::Position(EndPoint* end_point)
 }
 
 void Position::before_rem(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) {
-    auto& queues = this->end_point_->queues();
-    queues.erase(std::remove(queues.begin(), queues.end(), q), queues.end());
-  }
+  if (this->end_point_ != nullptr) this->end_point_->queues().erase(q);
 }
 
 void Position::after_add(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) this->end_point_->queues().push_back(q);
+  if (this->end_point_ != nullptr) this->end_point_->queues().insert(q);
 }

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

@@ -189,6 +189,8 @@ module Contrek
               act_part.polyline.next_tile_eligible_shapes.each do |shape|
                 shape.outer_polyline.parts.each do |dest_part|
                   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)

data/lib/contrek/finder/node.rb

@@ -4,7 +4,7 @@ module Contrek
       include Listable
 
       attr_reader :min_x, :max_x, :y, :name, :tangs_sequence, :tangs_count, :data_pointer,
-        :upper_start, :upper_end, :lower_start, :lower_end
+        :upper_start, :upper_end, :lower_start, :lower_end, :start_point, :end_point
       attr_accessor :track, :abs_x_index, :outer_index, :inner_index
 
       T_UP = -1
@@ -43,10 +43,21 @@ module Contrek
         @upper_end = -1
         @lower_start = Float::INFINITY
         @lower_end = -1
-
+        @start_point = {x: min_x, y: y}
+        @end_point = {x: max_x, y: y}
+        @cluster = cluster
         cluster.add_node(self, connectivity_offset)
       end
 
+      def get_tangent_node_by_virtual_index(virtual_index)
+        return nil if virtual_index.nil?
+        if virtual_index < 0
+          @cluster.vert_nodes[y + T_UP][-(virtual_index + 1)]
+        else
+          @cluster.vert_nodes[y + T_DOWN][virtual_index]
+        end
+      end
+
       def my_next(last, versus, mode)
         last_node_index = if last.y < y
           last.abs_x_index + @up_indexer
@@ -69,7 +80,7 @@ module Contrek
             (last_node_index == tangs_sequence.size - 1) ? last_node_index = 0 : last_node_index += 1
           end
         end
-        tangs_sequence.at(last_node_index)
+        get_tangent_node_by_virtual_index(@tangs_sequence.at(last_node_index))
       end
 
       def coords_entering_to(enter_to, enter_mode, tracking)
@@ -78,10 +89,28 @@ module Contrek
         else
           @down_indexer - enter_to.abs_x_index
         end
-        ds = tangs_sequence[enter_to_index]
-        coords_source = ds.send(enter_mode)
-        enter_to.track |= TURNER[tracking][coords_source[:m] - 1]
-        coords_source[:point]
+
+        tg_index = @tangs_sequence[enter_to_index]
+        if tg_index < 0
+          node_up = @cluster.vert_nodes[y + T_UP][-(tg_index + 1)]
+          if enter_mode == :a
+            enter_to.track |= TURNER[tracking][OMAX - 1]
+            point = node_up.end_point
+          else
+            enter_to.track |= TURNER[tracking][OMIN - 1]
+            point = node_up.start_point
+          end
+        else
+          node_down = @cluster.vert_nodes[y + T_DOWN][tg_index]
+          if enter_mode == :a
+            enter_to.track |= TURNER[tracking][OMIN - 1]
+            point = node_down.start_point
+          else
+            enter_to.track |= TURNER[tracking][OMAX - 1]
+            point = node_down.end_point
+          end
+        end
+        point
       end
 
       def track_uncomplete
@@ -107,29 +136,17 @@ module Contrek
         @up_indexer = -cluster.vert_nodes[@y + T_UP][@upper_start].abs_x_index if @upper_end >= 0
         if @upper_end >= 0
           (@upper_start..@upper_end).each do |upper_pos|
-            t_node = cluster.vert_nodes[@y + T_UP][upper_pos]
-            @tangs_sequence << Contrek::Finder::PolygonFinder::NodeDescriptor.new(
-              t_node,
-              {point: {x: t_node.max_x, y: t_node.y}, m: OMAX},
-              {point: {x: t_node.min_x, y: t_node.y}, m: OMIN}
-            )
+            @tangs_sequence << -(upper_pos + 1)
           end
         end
-
         if @lower_end >= 0
           lower_size = (@lower_end >= 0) ? (@lower_end - @lower_start + 1) : 0
           upper_size = (@upper_end >= 0) ? (@upper_end - @upper_start + 1) : 0
           @down_indexer = (cluster.vert_nodes[@y + T_DOWN][@lower_start].abs_x_index + lower_size + upper_size - 1)
         end
-
         if @lower_end >= 0
           @lower_end.downto(@lower_start).each do |lower_pos|
-            t_node = cluster.vert_nodes[@y + T_DOWN][lower_pos]
-            @tangs_sequence << Contrek::Finder::PolygonFinder::NodeDescriptor.new(
-              t_node,
-              {point: {x: t_node.min_x, y: t_node.y}, m: OMIN},
-              {point: {x: t_node.max_x, y: t_node.y}, m: OMAX}
-            )
+            @tangs_sequence << lower_pos
           end
         end
         @tangs_count = tangs_sequence.size

data/lib/contrek/finder/node_cluster.rb

@@ -62,21 +62,18 @@ module Contrek
           bounds = Bounds.empty
           # external polygon
           @plot_sequence << root_node
-          next_node_nd = if versus == :a
-            root_node.tangs_sequence.last
+
+          next_node = if versus == :a
+            root_node.get_tangent_node_by_virtual_index(root_node.tangs_sequence.last)
           else
-            root_node.tangs_sequence.first
+            root_node.get_tangent_node_by_virtual_index(root_node.tangs_sequence.first)
           end
-          #---------------
-          if !next_node_nd.nil?
-            next_node = next_node_nd.node
+          if !next_node.nil?
             coord = next_node.coords_entering_to(root_node, VERSUS_INVERTER[versus], Contrek::Finder::Node::OUTER)
             @sequence_coords << coord
             bounds.expand(x: coord[:x], y: coord[:y])
           end
-          #---------------
-
-          plot_node(next_node, root_node, bounds, versus) if @nodes > 0 && !next_node_nd.nil?
+          plot_node(next_node, root_node, bounds, versus) if @nodes > 0 && !next_node.nil?
 
           draw_sequence(bitmap, "X") unless bitmap.nil?
           @polygons << {outer: @sequence_coords, inner: [], bounds: (bounds.to_h if @options[:bounds])}.compact if @sequence_coords.size >= 2
@@ -198,13 +195,13 @@ module Contrek
         @root_nodes.delete(node)
         @inner_plot.delete(node)
         last_node = @plot_sequence.last
-        next_node_nd = node.my_next(last_node, versus, :inner)
-        next_node = next_node_nd.node
+        next_node = node.my_next(last_node, versus, :inner)
         @plot_sequence << node
 
         plot = true
         if next_node.y == last_node.y
-          plot = (node.tangs_sequence.send((versus == :a) ? :first : :last).node == next_node)
+          virtual_index = node.tangs_sequence.send((versus == :a) ? :first : :last)
+          plot = (node.get_tangent_node_by_virtual_index(virtual_index) == next_node)
         end
         if plot
           @sequence_coords << last_node.coords_entering_to(node, VERSUS_INVERTER[versus], Contrek::Finder::Node::INNER)
@@ -231,14 +228,14 @@ module Contrek
 
         node.outer_index = start_node.outer_index
         last_node = @plot_sequence.last
-        next_node_nd = node.my_next(last_node, versus, :outer)
-        next_node = next_node_nd.node
+        next_node = node.my_next(last_node, versus, :outer)
 
         @plot_sequence << node
 
         plot = true
         if next_node.y == last_node.y
-          plot = (node.tangs_sequence.send((versus == :a) ? :last : :first).node == next_node)
+          virtual_index = node.tangs_sequence.send((versus == :a) ? :last : :first)
+          plot = (node.get_tangent_node_by_virtual_index(virtual_index) == next_node)
         end
 
         # coord

data/lib/contrek/finder/polygon_finder.rb

@@ -3,7 +3,6 @@ require "benchmark"
 module Contrek
   module Finder
     class PolygonFinder
-      NodeDescriptor = Struct.new(:node, :a, :o)
       def initialize(bitmap, matcher, test_bitmap = nil, options = {})
         @options = {versus: :a}.merge(options)
         sanitize_options

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.1.3"
+  VERSION = "1.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Emanuele Cesaroni
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -279,7 +279,7 @@ metadata:
   homepage_uri: https://github.com/runout77/contrek
   documentation_uri: https://github.com/runout77/contrek#readme
   changelog_uri: https://github.com/runout77/contrek/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -295,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.22
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Fast PNG contour tracing and shape detection for Ruby
 test_files: []