contrek 1.0.7 → 1.0.9

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

@@ -8,7 +8,7 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted
+      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted, :delayed
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
@@ -19,14 +19,20 @@ module Contrek
         @touched = false
         @inverts = false
         @trasmuted = false
+        @delayed = false
       end
 
       def is?(type)
         @type == type
       end
 
+      def set_polyline(polyline)
+        @polyline = polyline
+      end
+
       def add_position(position)
-        add(Position.new(position: position, hub: polyline.tile.cluster.hub))
+        hub = is?(EXCLUSIVE) ? nil : polyline.tile.cluster.hub
+        add(Position.new(position: position, hub: hub))
       end
 
       def next_position(force_position = nil)

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

@@ -16,6 +16,15 @@ module Contrek
         new_part.prev = last
       end
 
+      def insert_after(part, new_part)
+        part_index = @parts.index(part)
+        @parts.insert(part_index + 1, new_part)
+        new_part.prev = part
+        new_part.next = new_part.circular_next = part.next
+        part.next.prev = new_part if part.next
+        part.next = part.circular_next = new_part
+      end
+
       def find_first_part_by_position(position)
         @parts.find do |part|
           part.is?(Part::SEAM) &&
@@ -57,48 +66,67 @@ module Contrek
       end
 
       def sew!(intersection, other)
-        matching_part_indexes = []
-        parts.each_with_index do |part, index|
-          next if part.trasmuted
-          matching_part_indexes << index if part.intersection_with_array?(intersection)
-        end
-        other_matching_part_indexes = []
-        other.parts.each_with_index do |part, index|
-          next if part.trasmuted
-          other_matching_part_indexes << index if part.intersection_with_array?(intersection)
-        end
-        # other_matching_part_indexes and matching_part_indexes always contain at least one element
+        matching_part_indexes, other_matching_part_indexes = intersection.transpose.map(&:sort)
+        # other_matching_part_indexes and matching_part_indexes always must contain at least one element
         before_parts = other.parts[other_matching_part_indexes.last + 1..]
         after_parts = other_matching_part_indexes.first.zero? ? [] : other.parts[0..other_matching_part_indexes.first - 1]
         part_start = parts[matching_part_indexes.first]
         part_end = parts[matching_part_indexes.last]
 
-        # They are inverted since they traverse in opposite directions
-        sequence = Sequence.new
-        sequence.add part_start.head
-        before_parts.each { |part| sequence.append(part) }
-        after_parts.each { |part| sequence.append(part) }
-        sequence.add part_end.tail if part_end.tail # nil when part_start == part_end
-
-        part_start.replace!(sequence)
-        part_start.type = Part::EXCLUSIVE
-        part_end.reset! if part_start != part_end
+        # left and right side reduces will be combined and later converted into orphan inners sequences
+        returning_data = [[matching_part_indexes, parts], [other_matching_part_indexes, other.parts]].map do |matching_part_indexes, parts|
+          lastn = 0
+          result = []
+          (matching_part_indexes.first + 1).upto(matching_part_indexes.last - 1) do |n|
+            if matching_part_indexes.index(n).nil?
+              part = parts[n]
+              if part.is?(Part::SEAM) && part.size > 0 && !part.delayed # fallback, delays the shape
+                part.delayed = true
+                return nil
+              end
+              if (lastn == (n - 1)) && result.any?
+                result.last.concat part.to_a
+              else
+                result << part.to_a
+              end
+              lastn = n
+            end
+          end
+          result
+        end
 
-        left = []
-        (matching_part_indexes.first + 1).upto(matching_part_indexes.last - 1) do |n|
-          left << parts[n].to_a if matching_part_indexes.index(n).nil?
+        if part_start != part_end
+          (matching_part_indexes.last - 1).downto(matching_part_indexes.first + 1) do |n|
+            delete_part = parts[n]
+            delete_part.prev.next = delete_part.next if delete_part.prev
+            delete_part.next.prev = delete_part.prev if delete_part.next
+            parts.delete_at(n)
+          end
         end
-        (matching_part_indexes.last - 1).downto(matching_part_indexes.first + 1) do |n|
-          delete_part = parts[n]
-          delete_part.prev.next = delete_part.next if delete_part.prev
-          delete_part.next.prev = delete_part.prev if delete_part.next
-          parts.delete_at(n)
+
+        all_parts = before_parts + after_parts
+        will_be_last = all_parts.last
+        all_parts.reverse_each do |part|
+          insert_after(part_start, part)
+          other.parts.delete(part)
+          part.set_polyline(self)
         end
-        right = []
-        (other_matching_part_indexes.first + 1).upto(other_matching_part_indexes.last - 1) do |n|
-          right << other.parts[n].to_a if other_matching_part_indexes.index(n).nil?
+
+        part_start.type = Part::EXCLUSIVE
+        new_end_part = Part.new(Part::EXCLUSIVE, self)
+        new_end_part.add(part_end.tail)
+        part_start.singleton! # reduce part to its head only
+
+        if part_start != part_end
+          part_end.prev.next = part_end.next if part_end.prev
+          part_end.next.prev = part_end.prev if part_end.next
+          parts.delete(part_end)
         end
-        [left, right]
+        insert_after(will_be_last, new_end_part)
+
+        reset_tracked_endpoints!
+
+        returning_data
       end
 
       private

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

@@ -27,7 +27,15 @@ module Contrek
       end
 
       def inspect
-        "#{self.class}[b#{@tile.name} S#{@name} #{"B" if boundary?}] (#{raw.count} => #{raw.inspect})"
+        "#{self.class}#{named} (#{raw.count} => #{raw.inspect})"
+      end
+
+      def named
+        "[b#{@tile.name} S#{@name} #{"B" if boundary?}]"
+      end
+
+      def numpy_raw
+        raw.flat_map { |p| [p[:x], p[:y]] }
       end
 
       def info
@@ -46,8 +54,36 @@ module Contrek
         (@flags & flag) != 0
       end
 
+      def reset_tracked_endpoints!
+        @tracked_endpoints = nil
+      end
+
+      # returns for every position of intersection an array composed by the indexes of parts (self,other) involved
+      # es [[1,3],[2,6],...]. The first time the sequence for self is computed is stored.
       def intersection(other)
-        @raw & other.raw
+        if @tracked_endpoints.nil?
+          @tracked_endpoints = {} # memoize found sequence
+          parts.each_with_index do |part, part_index|
+            next if !part.is?(Part::SEAM) && part.trasmuted
+            part.each do |pos|
+              next if pos.end_point.nil?
+              @tracked_endpoints[pos.end_point.object_id] = part_index
+            end
+          end
+        end
+        matching_parts = []
+        other.parts.each_with_index do |part, part_index|
+          next if !part.is?(Part::SEAM) && part.trasmuted
+          part.each do |pos|
+            if (self_index = @tracked_endpoints[pos.end_point.object_id])
+              matching_parts << [self_index, part_index]
+              false
+            else
+              true
+            end
+          end
+        end
+        matching_parts
       end
 
       def empty?
@@ -82,6 +118,13 @@ module Contrek
         !(@max_y < other.min_y || other.max_y < @min_y)
       end
 
+      def get_bounds
+        {min_x: @min_x,
+         max_x: @max_x,
+         min_y: @min_y,
+         max_y: @max_y}
+      end
+
       private
 
       def find_boundary

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

@@ -6,8 +6,7 @@ module Contrek
       attr_reader :end_point
 
       def initialize(hub:, position:)
-        key = position[:y] * hub.width + position[:x]
-        @end_point = hub.payloads[key] ||= EndPoint.new
+        @end_point = hub.payloads[position[:y]] ||= EndPoint.new if hub
         @position = position
       end
 
@@ -16,11 +15,11 @@ module Contrek
       end
 
       def after_add(new_queue)
-        @end_point.queues << new_queue
+        @end_point.queues << new_queue if @end_point
       end
 
       def before_rem(old_queue)
-        @end_point.queues.delete(old_queue)
+        @end_point&.queues&.delete(old_queue)
       end
     end
   end

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

@@ -10,6 +10,16 @@ module Contrek
         @size = 0
       end
 
+      def singleton!
+        if @head&.next
+          @head.next.prev = nil
+          @head.next = nil
+        end
+        @tail = nil
+        @size = 1
+        @iterator = 0
+      end
+
       def rem(node)
         Raise "Not my node" if node.owner != self
 
@@ -84,12 +94,13 @@ module Contrek
         @iterator = 0
       end
 
+      # from yield: false => stop, true => continue
       def each(&block)
         last = nil
         unless @head.nil?
           pointer = @head
           loop do
-            yield(pointer)
+            break unless yield(pointer)
             last = pointer
             break unless (pointer = pointer.next)
           end
@@ -142,25 +153,6 @@ module Contrek
         rem(@tail)
       end
 
-      def intersection_with(queueable)
-        int = []
-        each do |node|
-          int += queueable.map do |e|
-            break [e.payload] if e.payload == node.payload
-          end.compact
-        end
-        int
-      end
-
-      def intersection_with_array?(array)
-        each { |node| return true if array.index(node.payload) }
-        false
-      end
-
-      def intersect_with?(queueable)
-        intersection_with(queueable).any?
-      end
-
       def remove_adjacent_pairs(array = nil)
         array = to_a if array.nil?
         n = array.size

data/lib/contrek/version.rb

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

data/lib/contrek.rb

@@ -5,6 +5,7 @@ require "contrek/bitmaps/chunky_bitmap"
 require "contrek/bitmaps/png_bitmap"
 require "contrek/bitmaps/custom_bitmap"
 require "contrek/bitmaps/rgb_color"
+require "contrek/bitmaps/rgb_cpp_color"
 require "contrek/finder/bounds"
 require "contrek/bitmaps/sample_generator"
 require "contrek/finder/list"
@@ -54,10 +55,10 @@ module Contrek
     private
 
     def compute_cpp(png_file_path, options)
-      color = Bitmaps::RgbColor.new(**options[:color])
+      color = Bitmaps::RgbCppColor.new(**options[:color])
       png_bitmap = CPPPngBitMap.new(png_file_path)
       rgb_matcher_klass = (options[:class] == "value_not_matcher") ? CPPRGBNotMatcher : CPPRGBMatcher
-      rgb_matcher = rgb_matcher_klass.new(color.to_rgb_raw)
+      rgb_matcher = rgb_matcher_klass.new(color.raw)
       if options.key?(:number_of_threads) || options[:finder]&.key?(:number_of_tiles)
         Contrek::Cpp::CPPConcurrentFinder.new(
           number_of_threads: options.dig(:number_of_threads) || 0,
@@ -74,7 +75,7 @@ module Contrek
     end
 
     def compute_ruby_pure(png_file_path, options)
-      color = Bitmaps::RgbColor.new(**options[:color])
+      color = Bitmaps::RgbCppColor.new(**options[:color])
       png_bitmap = Bitmaps::PngBitmap.new(png_file_path)
       rgb_matcher = const_get("Contrek::Matchers::" + camelize("value_not_matcher")).new(color.raw)
       if options.key?(:number_of_threads) || options[:finder]&.key?(:number_of_tiles)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.9
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-10 00:00:00.000000000 Z
+date: 2026-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -140,10 +140,11 @@ files:
 - Rakefile
 - contrek.gemspec
 - contrek.png
-- ext/cpp_polygon_finder/PolygonFinder/Makefile
+- ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt
+- ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp
 - ext/cpp_polygon_finder/PolygonFinder/images/labyrinth.png
 - ext/cpp_polygon_finder/PolygonFinder/images/sample_10240x10240.png
-- ext/cpp_polygon_finder/PolygonFinder/src/Main.cpp
+- ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h
 - ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/Tests.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/CpuTimer.h
@@ -229,6 +230,7 @@ files:
 - lib/contrek/bitmaps/painting.rb
 - lib/contrek/bitmaps/png_bitmap.rb
 - lib/contrek/bitmaps/rgb_color.rb
+- lib/contrek/bitmaps/rgb_cpp_color.rb
 - lib/contrek/bitmaps/sample_generator.rb
 - lib/contrek/cpp/cpp_concurrent_finder.rb
 - lib/contrek/finder/bounds.rb

data/ext/cpp_polygon_finder/PolygonFinder/Makefile

@@ -1,44 +0,0 @@
-CXX = g++
-CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g \
-           -fno-omit-frame-pointer -fsanitize=address,undefined \
-           -O0
-LDFLAGS = -lpng -pthread -lz -fsanitize=address,undefined
-
-# valgrinf or perf setup
-#CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -fno-omit-frame-pointer -march=native -DNDEBUG -O3
-#LDFLAGS = -lpng -pthread -lz
-
-# best performances
-CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -march=native -DNDEBUG -Ofast -flto
-LDFLAGS = -lpng -pthread -lz -flto=auto
-
-SRC = $(shell find src -name '*.cpp')
-C_SRC = $(shell find src -name 'spng.c')
-
-OBJ = $(patsubst src/%.cpp, build/%.o, $(SRC))
-OBJ += $(patsubst src/%.c, build/%.o, $(C_SRC))
-
-DEPS = $(OBJ:.o=.d)
-
-EXEC = contrek
-
-all: $(EXEC)
-
-$(EXEC): $(OBJ)
-	$(CXX) $(CXXFLAGS) $(OBJ) -o $@ -Wl,--no-as-needed $(LDFLAGS)
-
-build/%.o: src/%.cpp
-	@mkdir -p $(dir $@)
-	$(CXX) $(CXXFLAGS) -c $< -o $@
-
-build/%.o: src/%.c
-	@mkdir -p $(dir $@)
-	$(CC) -O3 -march=native -fPIC -c $< -o $@
-
--include $(DEPS)
-
-clean:
-	rm -rf build $(EXEC)
-
-run: all
-	./$(EXEC)

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

@@ -1,50 +0,0 @@
-//============================================================================
-// Name        : PolygonFinder.cpp
-// Author      : Emanuele Cesaroni
-// Version     :
-// Copyright   : 2025 Emanuele Cesaroni
-// Description :
-//============================================================================
-
-#include <string.h>
-#include <iostream>
-#include <list>
-#include <map>
-#include <string>
-#include "polygon/finder/PolygonFinder.h"
-#include "polygon/bitmaps/Bitmap.h"
-#include "polygon/bitmaps/FastPngBitmap.h"
-#include "polygon/bitmaps/RemoteFastPngBitmap.h"
-#include "polygon/matchers/Matcher.h"
-#include "polygon/matchers/RGBMatcher.h"
-#include "polygon/matchers/RGBNotMatcher.h"
-#include "polygon/matchers/ValueNotMatcher.h"
-#include "polygon/finder/optionparser.h"
-#include "Tests.h"
-#include "polygon/CpuTimer.h"
-
-int main() {
-  CpuTimer cpu_timer;
-  Tests test_suite;
-  cpu_timer.start();
-
-  // test_suite.test_a();
-  // test_suite.test_b();
-  // test_suite.test_c();
-  // test_suite.test_d();
-  test_suite.test_e();
-  std::cout << "compute time =" << cpu_timer.stop() << std::endl;
-
-/*
-  FastPngBitmap png_bitmap("images/labyrinth.png");
-  std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
-  std::cout << "load_error=" << png_bitmap.error() << std::endl;
-
-  std::string data_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+P+/HgAFhAJ/wlseKgAAAABJRU5ErkJggg==";
-  data_url.erase(0, 22);
-  RemoteFastPngBitmap bitmap(&data_url);
-  std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
-  std::cout << "load_error=" << bitmap.error() << std::endl;
-*/
-  return 0;
-}