contrek 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58d88411970256b3edc37da05dd9304aaa4593b320e7d73db5966b69d403c4cf
-  data.tar.gz: 6a05687f7ffba4b22eb7ebf02abf2a622931bc3250968fa785fb13720036118e
+  metadata.gz: 0fff9996602ac84d2a5d96e840150e59cb457bc8050c53758efac88f170bef79
+  data.tar.gz: 40958fef1d22e2458beae7291cfdca85102eda4983bf01ef468c334ddce99ec8
 SHA512:
-  metadata.gz: 7150e06efce7580fdefd55725db0de52e2805b909e800679a0f99481c3e52333209d1b5ceb750c1fc63a28fa6aaaad7f7662d3baf3ebf377b29cfe4dacf6d19d
-  data.tar.gz: 988e85fd99234df2b3cd0e8bec0d8f68ba0f631111a3fda62e114e185dd1619589223266b5e3db71a2a5c478d2871f862209489df997a13a9da866b84718c609
+  metadata.gz: 7f8f1f1368c472fb9770a892874f54817a67745929a0d772c5a9cc3e387fcd868e5662ad67e341d6a53232b6be4eb028438545535adfb05be3d69c497c3918da
+  data.tar.gz: cc7991d57ce63d43c98165c1f3684d1f31d05993a6e4a20e40437d70d5b251a1de0032ca354f44d2bb8efbf30286423f6b2925e01da0f039c71661427f4d2716

data/CHANGELOG.md

@@ -122,3 +122,10 @@ All notable changes to this project will be documented in this file.
 
 ## [1.2.9] - 2026-06-13
 - **Streaming merger:** The streaming merger class extends VerticalMerger and adds a useful feature: the progressive extraction of contours into a disk buffer (SVG file). In this way, all extracted polygons that are no longer within the junction zone of the next stripe are removed from the system and streamed directly to disk. This incredibly reduces memory consumption, allowing the processing of very large files on machines with low memory availability, at the expense of increased processing times. An example of this technique is available in both C++ and Ruby in the repository.
+
+## [1.3.0] - 2026-06-17
+- **Streaming merger:** Improvements and bug fixing.
+- **CPP code:** All structures now own 'Point' instances by value instead of raw pointers. Removed now-redundant `clone()` method; results from `process_info()` are already self-contained since points are owned by value, so the defensive deep copy is no longer needed.
+
+## [1.3.1] - 2026-06-20
+- **Streaming merger:** The progressive streaming extraction mode has now reached new heights of efficiency on the C++ side. This mode allows the data source to be processed in contiguous blocks. All isolated polygons, as well as those extending into the bottom strips, are removed from the list and streamed directly to the SVG file. This drastically reduces RAM requirements. An extreme test on an 81920×81920 pixel image containing a massive number of polygons (20,000,000) was processed using roughly 40 strips of 2000 pixels each in less than 300 seconds, peaking at a RAM usage of just 13GB.

data/Gemfile.lock

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

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -461,20 +461,14 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
         ProcessResult *result = polygon_finder.process_info();
         if (result) {
           std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-          result_clones.push_back(result);
           vmerger.add_tile(*result, !(current_y_offset + stripe_height < total_height));
+          delete result;
         }
         stripe_count++;
       }
-
       ProcessResult *merged_result = vmerger.process_info();
       std::cout << "total found polygons " << merged_result->groups << std::endl;
       delete merged_result;
-
-      // frees memory
-      for (auto c : result_clones) {
-        delete c;
-      }
     } catch (const std::exception& e) {
       std::cerr << "\n[ERROR] Processing exception: " << e.what() << std::endl;
       if (shared_stream.is_open()) shared_stream.close();

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

@@ -34,5 +34,5 @@ class Cluster {
   static void list_to_string(std::vector<Point> list);
   PartPool parts_pool;
   std::deque<Position> positions_pool;
-  const Finder* finder() const { return finder_; };
+  const Finder* finder() const { return finder_; }
 };

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

@@ -61,11 +61,6 @@ void Cursor::traverse_outer(Part* act_part,
       if (act_part->size == 0) return;
 
       while (Position *position = act_part->next_position(nullptr)) {
-        if (outer_joined_polyline->size > 1 &&
-          outer_joined_polyline->head->payload == position->payload &&
-          act_part == all_parts.front()) {
-          return;
-        }
         outer_joined_polyline->add(position);
       }
     } else {

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

@@ -75,6 +75,36 @@ void Part::orient()
   }
 }
 
+void Part::try_transmutation() {
+  auto& head_queues = static_cast<Position*>(this->head)->end_point()->queues();
+  if (head_queues.size() == 1) {
+    return;
+  }
+
+  auto other_head_it = std::find_if(head_queues.begin(), head_queues.end(), [this](auto* queueable_ptr) {
+    Part* part = static_cast<Part*>(queueable_ptr);
+    return part != this && part->polyline()->tile == this->polyline()->tile;
+  });
+
+  if (other_head_it != head_queues.end()) {
+    Part* other_head_part = static_cast<Part*>(*other_head_it);
+    auto& tail_queues = static_cast<Position*>(this->tail)->end_point()->queues();
+    auto found_in_tail = std::find(tail_queues.begin(), tail_queues.end(), other_head_part);
+    if (found_in_tail != tail_queues.end()) {
+      if ( (other_head_part->tail->payload.y == tail->payload.y && other_head_part->head->payload.y == head->payload.y) ||
+           (other_head_part->tail->payload.y == head->payload.y && other_head_part->head->payload.y == tail->payload.y)) {
+        if (this->next == nullptr && other_head_part->prev == nullptr) {
+            this->mirror = true;
+        }
+      } else {
+          this->type = Part::EXCLUSIVE;
+          this->trasmuted = true;
+          other_head_part->transmutation_skip = true;
+      }
+    }
+  }
+}
+
 bool Part::within(Part* other) {
   const auto [self_min, self_max] = std::minmax(this->head->payload.y, this->tail->payload.y);
   const auto [other_min, other_max] = std::minmax(other->head->payload.y, other->tail->payload.y);

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

@@ -32,9 +32,11 @@ class Part : public Queueable<Point> {
   bool is(Types type);
   bool inverts = false;
   bool trasmuted = false;
+  bool transmutation_skip = false;
   bool dead_end = false;
   bool mirror = false;
   Part* next = nullptr;
+  Part* next_seam = nullptr;
   Part* prev = nullptr;
   Part* circular_next = nullptr;
   std::string toString() const { return "Part type = " + std::to_string(static_cast<uint32_t>(type)); }
@@ -51,6 +53,7 @@ class Part : public Queueable<Point> {
   std::vector<EndPoint*> continuum_to(const Part& other_part) const;
   bool within(Part* other);
   bool same_length(Part* other);
+  void try_transmutation();
 
  private:
   int versus_ = 0;

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

@@ -32,11 +32,23 @@ void Partitionable::add_part(Part* new_part)
   new_part->prev = last;
   new_part->circular_next = this->parts_.front();
 
-  if (new_part->is(Part::SEAM)) new_part->orient();
+  if (new_part->is(Part::SEAM)) {
+    if (!this->first_seam) {
+      this->first_seam = new_part;
+    }
+    if (this->last_seam) {
+      this->last_seam->next_seam = new_part;
+    }
+    this->last_seam = new_part;
+    new_part->orient();
+  }
 }
 
 void Partitionable::partition()
 { this->parts_.clear();
+  this->first_seam = nullptr;
+  this->last_seam = nullptr;
+
   Polyline *polyline = static_cast<Polyline*>(this);
   PartPool& pool = polyline->tile->cluster->parts_pool;
   Part *current_part = nullptr;
@@ -65,54 +77,42 @@ void Partitionable::partition()
   }
   this->add_part(current_part);
 
-  this->trasmute_parts();
+  this->transmute_parts();
 }
 
-void Partitionable::trasmute_parts()
+void Partitionable::transmute_transposed_part(Part* part) {
+  if (Part* current_seam = this->first_seam; current_seam != nullptr) {
+    while (current_seam != nullptr) {
+      if (current_seam != part) {
+        if (part->within(current_seam)) {
+          if (!part->same_length(current_seam)) {
+            part->type = Part::EXCLUSIVE;
+            part->trasmuted = true;
+            std::vector<Queueable<Point>*>& a = static_cast<Position*>(part->head)->end_point()->queues();
+            a.erase(std::remove(a.begin(), a.end(), part), a.end());
+            std::vector<Queueable<Point>*>& b = static_cast<Position*>(part->tail)->end_point()->queues();
+            b.erase(std::remove(b.begin(), b.end(), part), b.end());
+          }
+        }
+      }
+      current_seam = current_seam->next_seam;
+    }
+  }
+}
+
+void Partitionable::transmute_parts()
 { Polyline *polyline = static_cast<Polyline*>(this);
   bool transpose = polyline->tile->cluster->finder()->transpose();
-
-  for (Part* inside : parts_) {
-    if (!inside->is(Part::SEAM)) continue;
-    for (Part* inside_compare : parts_) {
-      if (inside == inside_compare || !inside_compare->is(Part::SEAM)) continue;
-
+  if (Part* current_seam = this->first_seam; current_seam != nullptr) {
+    while (current_seam != nullptr) {
       if (transpose) {
-        if (inside->within(inside_compare)) {
-          Part* target_part;
-          if (!inside->same_length(inside_compare)) {
-            target_part = inside;
-            target_part->type = Part::EXCLUSIVE;
-            target_part->trasmuted = true;
-            std::vector<Queueable<Point>*>& a = static_cast<Position*>(target_part->head)->end_point()->queues();
-            a.erase(std::remove(a.begin(), a.end(), target_part), a.end());
-            std::vector<Queueable<Point>*>& b = static_cast<Position*>(target_part->tail)->end_point()->queues();
-            b.erase(std::remove(b.begin(), b.end(), target_part), b.end());
-            break;
-          }
-        }
+        transmute_transposed_part(current_seam);
       } else {
-        int count = 0;
-        inside->each([&](QNode<Point>* pos) -> bool {
-          Position *position = static_cast<Position*>(pos);
-          if (position->end_point()->queues_include(inside_compare))
-          { count++;
-            return true;
-          }
-          return false;
-        });
-        if (count == inside->size) {
-          if (count < inside_compare->size) {
-            inside->type = Part::EXCLUSIVE;
-            inside->trasmuted = true;
-            break;
-          } else if ( count == inside_compare->size &&
-                      inside->next == nullptr &&
-                      inside_compare->prev == nullptr) {
-            inside->mirror = true;
-          }
+        if (!current_seam->transmutation_skip) {
+          current_seam->try_transmutation();
         }
       }
+      current_seam = current_seam->next_seam;
     }
   }
 }

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

@@ -21,8 +21,10 @@ class Partitionable {
 
  protected:
   std::vector<Part*> parts_;
-
+  Part* first_seam = nullptr;
+  Part* last_seam = nullptr;
  private:
   void add_part(Part* new_part);
-  void trasmute_parts();
+  void transmute_parts();
+  void transmute_transposed_part(Part* part);
 };

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

@@ -12,6 +12,7 @@
 #include <string>
 #include <unordered_set>
 #include <sstream>
+#include <utility>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Shape.h"

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

@@ -8,6 +8,7 @@
  */
 
 #include <vector>
+#include <utility>
 #include "Shape.h"
 #include "ShapePool.h"
 #include "Tile.h"

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

@@ -102,9 +102,6 @@ module Contrek
         if act_part.is?(Part::EXCLUSIVE)
           return if act_part.size == 0
           while (position = act_part.next_position)
-            return if outer_joined_polyline.size > 1 &&
-              outer_joined_polyline.head.payload == position.payload &&
-              act_part == all_parts.first
             outer_joined_polyline.add(position)
           end
         else

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

@@ -10,11 +10,13 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :versus, :mirror
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts,
+        :trasmuted, :versus, :mirror, :next_seam, :transmutation_skip
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
         @next = nil
+        @next_seam = nil
         @circular_next = nil
         @prev = nil
         @dead_end = false
@@ -23,6 +25,7 @@ module Contrek
         @trasmuted = false
         @versus = 0
         @mirror = false
+        @transmutation_skip = false
       end
 
       def is?(type)
@@ -80,6 +83,27 @@ module Contrek
         end
       end
 
+      def try_transmutation!
+        head_queues = head.end_point.queues
+        return if head_queues.size == 1
+        other_head_part = head_queues.find { |part| part.polyline.tile == polyline.tile && part != self }
+        if other_head_part
+          tail_queues = tail.end_point.queues
+          if tail_queues.find { |part| part == other_head_part }
+            if (other_head_part.tail.payload[:y] == tail.payload[:y] && other_head_part.head.payload[:y] == head.payload[:y]) ||
+                (other_head_part.tail.payload[:y] == head.payload[:y] && other_head_part.head.payload[:y] == tail.payload[:y])
+              if self.next.nil? && other_head_part.prev.nil?
+                self.mirror = true
+              end
+            else
+              self.type = Part::EXCLUSIVE
+              self.trasmuted = true
+              other_head_part.transmutation_skip = true
+            end
+          end
+        end
+      end
+
       def within?(other)
         self_min, self_max = [head.payload[:y], tail.payload[:y]].minmax
         other_min, other_max = [other.head.payload[:y], other.tail.payload[:y]].minmax

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

@@ -8,6 +8,8 @@ module Contrek
       def initialize(*args, **kwargs, &block)
         super
         @parts = []
+        @first_seam = nil
+        @last_seam = nil
       end
 
       def add_part(new_part)
@@ -16,8 +18,14 @@ module Contrek
         last.next = last.circular_next = new_part if last
         new_part.circular_next = @parts.first
         new_part.prev = last
-
-        new_part.orient! if new_part.is?(Part::SEAM)
+        if new_part.is?(Part::SEAM)
+          @first_seam ||= new_part
+          if !@last_seam.nil?
+            @last_seam.next_seam = new_part
+          end
+          @last_seam = new_part
+          new_part.orient!
+        end
       end
 
       def inspect_parts
@@ -27,6 +35,8 @@ module Contrek
       def partition!
         current_part = nil
         @parts = []
+        @first_seam = nil
+        @last_seam = nil
 
         @raw.each_with_index do |position, n|
           if @tile.tg_border?(position)
@@ -49,7 +59,7 @@ module Contrek
         end
         add_part(current_part)
 
-        trasmute_parts!
+        transmute_parts!
       end
 
       private
@@ -57,42 +67,37 @@ module Contrek
       # If there are SEAM parts and one is canceled out by another within the same polyline,
       # meaning that all its points are repeated in another, longer sequence,
       # then the shorter one is converted to EXCLUSIVE and marked as transmuted
-      def trasmute_parts!
+      def transmute_parts!
         transpose = tile.cluster.finder.transpose?
-
-        @parts.each do |inside|
-          next unless inside.is?(Part::SEAM)
-          @parts.each do |inside_compare|
-            next if inside == inside_compare
-            next unless inside_compare.is?(Part::SEAM)
-
+        if (current_seam = @first_seam)
+          loop do
             if transpose
-              if inside.within?(inside_compare)
-                if !inside.same_length?(inside_compare)
-                  inside.type = Part::EXCLUSIVE
-                  inside.trasmuted = true
-                  inside.head.end_point.queues.delete(inside)
-                  inside.tail.end_point.queues.delete(inside)
-                  break
-                end
-              end
-            else
-              count = 0
-              inside.each do |position|
-                inclusion = position.end_point.queues.include?(inside_compare)
-                count += 1 if inclusion
-              end
-              if count == inside.size
-                if count < inside_compare.size
-                  inside.type = Part::EXCLUSIVE
-                  inside.trasmuted = true
-                  break
-                end
-                if count == inside_compare.size && inside.next.nil? && inside_compare.prev.nil?
-                  inside.mirror = true
+              transmute_transposed_part(current_seam)
+            elsif !current_seam.transmutation_skip
+              current_seam.try_transmutation!
+            end
+            current_seam = current_seam.next_seam
+            break if current_seam.nil?
+          end
+        end
+      end
+
+      def transmute_transposed_part(part)
+        if (current_seam = @first_seam)
+          loop do
+            if current_seam != part
+              if part.within?(current_seam)
+                if !part.same_length?(current_seam)
+                  part.type = Part::EXCLUSIVE
+                  part.trasmuted = true
+                  part.head.end_point.queues.delete(part)
+                  part.tail.end_point.queues.delete(part)
+                  return
                 end
               end
             end
+            current_seam = current_seam.next_seam
+            break if current_seam.nil?
           end
         end
       end

data/lib/contrek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contrek
-  VERSION = "1.3.0"
+  VERSION = "1.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Emanuele Cesaroni
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-17 00:00:00.000000000 Z
+date: 2026-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -307,7 +307,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
@@ -323,7 +323,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: []