contrek 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fa95266798ecc7809dececd0fe6a0153ada90dbc5bbc9a22f418654ae6ab920
-  data.tar.gz: 064e8757c2be8ea55c6e2b688d0b614ad5080bf741bbeef90fa3a204cf6815f8
+  metadata.gz: 87e8665985a5c9b3818f5f405609c8bf0f9d81dfaa197054e0801acdc60dc56c
+  data.tar.gz: 450c56eda5bd65ab936fcd52b37e3f8edbc2ec0ac852aa0cc4c052ee6d81ab7e
 SHA512:
-  metadata.gz: 29b8d97fd331a3ee586729700c58070c0d3f849762c38265c59f6b7994d4a0fdc111f774b044835ae8dbc1de6905b0b2eabe92376549c08d16c9721aa5ee5ef1
-  data.tar.gz: 553b23d74c214bb78e33e2243fd7bd0b600abd8f953acb21554cf2ca59498312f95fda3d6daafa9a9df43a577a6daf8844c0410ab15042f28a6d3e2eee4fc26f
+  metadata.gz: e4cc2ea0d61819436e922eacdcad551658deceac1b5a907cea03d306de65fa2f71b96018acf6fcc6f88163775cabf0ba9b8d6ded3e9067dfcf3cc3e70d3e3e6d
+  data.tar.gz: ca933647465baca8a294176a1fbbc336bf1956c8eebab2cf48dd45ac4e55ba55ea84b00d38cbdd9ee0cf012b332684b8902c5e98a8cbaaafbfc846b374a12801

data/CHANGELOG.md

@@ -18,7 +18,7 @@ All notable changes to this project will be documented in this file.
 ### Added
 - Added C++ multithreading supports
 - Optimized old just present C++ code
-- Removed Png++ dependency in place of libspn
+- Removed Png++ dependency in place of libspng
 
 ## [1.0.7] - 2026-01-10
 ### Added
@@ -76,3 +76,7 @@ All notable changes to this project will be documented in this file.
 ## [1.1.8] - 2026-04-19
 ### Changed
 - Treemap now available on multiprocessing side too.
+
+## [1.1.9] - 2026-04-24
+### Changed
+- Improved the internal parts joining algorithm, which was imprecise in some circumstances.

data/Gemfile.lock

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

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

@@ -32,8 +32,6 @@ Node::Node(int min_x, int max_x, int y, NodeCluster* cluster, char name)
   this->track = 0;
   this->outer_index = -1;
   this->inner_index = -1;
-  this->inner_left_index = -1;
-  this->inner_right_index = -1;
 }
 
 bool Node::get_trackmax() {

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

@@ -280,7 +280,7 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
               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);
+                std::vector<EndPoint*> link_seq = dest_part->continuum_to(*act_part);
                 if (!link_seq.empty()) {
                   Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
                   for (EndPoint* pos : link_seq) {
@@ -314,33 +314,6 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
   }
 }
 
-template <typename T>
-std::vector<T*> difference_ptr(std::vector<T*>& a, std::vector<T*>& b)
-{ std::vector<T*> result;
-  for (T* item : a) {
-    auto it = std::find_if(
-      b.begin(), b.end(),
-      [&](T* other) {
-        return other == item;
-      });
-    if (it == b.end()) {
-      result.push_back(item);
-    }
-  }
-  return result;
-}
-
-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;
-}
-
 std::vector<std::vector<Point*>> Cursor::combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb)
 { std::vector<std::vector<Point*>> rets;
   size_t n = std::min(seqa.size(), seqb.size());

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

@@ -37,7 +37,6 @@ class Cursor {
                       Sequence* outer_joined_polyline);
   std::vector<InnerPolyline*> collect_inner_sequences(Sequence* outer_seq);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
-  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*> shapes_sequence, std::vector<Shape*> missing_shapes);
 };

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

@@ -74,29 +74,6 @@ 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((static_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;
-}
-
 void Part::orient()
 { if (this->size <= 1 || (this->size == 2 && this->inverts)) {
     this->versus_ = 0;
@@ -127,3 +104,41 @@ std::string Part::inspect() {
   ss << ")";
   return ss.str();
 }
+
+std::vector<EndPoint*> Part::continuum_to(const Part& other_part) const {
+  if (this->size <= 2 && this->inverts && other_part.size <= 2 && other_part.inverts) return {};
+
+  Point* target = other_part.head->payload;
+  QNode<Point>* cursor = this->tail;
+
+  while (cursor != nullptr) {
+    if (*cursor->payload == *target) {
+      QNode<Point>* s = cursor;
+      QNode<Point>* o = other_part.head;
+      bool match = true;
+      int count = 0;
+
+      while (s != nullptr && o != nullptr) {
+        if (!(*s->payload == *o->payload)) {
+          match = false;
+          break;
+        }
+        s = s->next;
+        o = o->next;
+        count++;
+      }
+      if (match && s == nullptr) {
+        std::vector<EndPoint*> res;
+        res.reserve(count);
+        s = cursor;
+        for (int i = 0; i < count; ++i) {
+          res.push_back(static_cast<Position*>(s)->end_point());
+          s = s->next;
+        }
+        return res;
+      }
+    }
+    cursor = cursor->prev;
+  }
+  return {};
+}

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

@@ -47,10 +47,9 @@ 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);
   void orient();
   std::string inspect();
+  std::vector<EndPoint*> continuum_to(const Part& other_part) const;
 
  private:
   int versus_ = 0;

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

@@ -195,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|
@@ -221,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/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/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

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.1.8"
+  VERSION = "1.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-04-19 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec