contrek 1.1.2 → 1.1.4

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

@@ -106,8 +106,8 @@ module Contrek
 
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
-        all_parts << act_part if all_parts.last != act_part
-
+        last_part = all_parts.last
+        all_parts << act_part if last_part != act_part
         if act_part.is?(Part::EXCLUSIVE)
           return if act_part.size == 0
           while (position = act_part.next_position)
@@ -117,14 +117,14 @@ module Contrek
             outer_joined_polyline.add(position)
           end
         else
+          return if act_part.dead_end && all_parts.size > 1 && last_part.is?(Part::SEAM) && last_part.polyline == act_part.polyline
           while (new_position = act_part.iterator)
             return if outer_joined_polyline.size > 1 &&
               outer_joined_polyline.head.payload == new_position.payload &&
               act_part == all_parts.first
             outer_joined_polyline.add(Position.new(position: new_position.payload, hub: @cluster.hub))
-
             act_part.polyline.next_tile_eligible_shapes.each do |shape|
-              if (part = shape.outer_polyline.find_first_part_by_position(new_position))
+              if (part = shape.outer_polyline.find_first_part_by_position(new_position, act_part.versus))
                 if all_parts[-2] != part
                   if all_parts.size >= 2
                     map = all_parts[-2..].map(&:type).uniq
@@ -132,12 +132,12 @@ module Contrek
                   end
                   shapes_sequence.add(part.polyline.shape)
                   part.next_position(new_position)
+                  part.dead_end = true
                   traverse_outer(part, all_parts, shapes_sequence, outer_joined_polyline)
                   return
                 end
               end
             end
-            act_part.passes += 1
             act_part.next_position
           end
         end
@@ -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/concurrent/finder.rb

@@ -29,6 +29,7 @@ module Contrek
           @clusters = []
           @maximum_width = bitmap.w
           @number_of_tiles = options[:number_of_tiles] || (raise "number_of_tiles params is needed!")
+          @number_of_tiles = 1 if @number_of_tiles <= 0
 
           cw = @maximum_width.to_f / @number_of_tiles
           raise "One pixel tile width minimum!" if cw < 1.0
@@ -45,7 +46,7 @@ module Contrek
               finder = ClippedPolygonFinder.new(
                 bitmap: bitmap,
                 matcher: matcher,
-                options: {versus: current_versus, bounds: true},
+                options: {versus: current_versus, bounds: true, connectivity: @options[:connectivity]}.compact,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x]
               )

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

@@ -8,18 +8,19 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted, :delayed
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :delayed, :versus
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
         @next = nil
         @circular_next = nil
         @prev = nil
-        @passes = 0
+        @dead_end = false
         @touched = false
         @inverts = false
         @trasmuted = false
         @delayed = false
+        @versus = 0
       end
 
       def is?(type)
@@ -60,7 +61,7 @@ module Contrek
       end
 
       def inspect
-        "part #{polyline.parts.index(self)} (inv=#{@inverts} trm=#{@trasmuted} touched=#{@touched} passes=#{@passes}, #{size}x) of #{polyline.info} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
+        "part #{polyline.parts.index(self)} (versus=#{@versus} inv=#{@inverts} trm=#{@trasmuted} touched=#{@touched} dead_end =#{@dead_end}, #{size}x) of #{polyline.info} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
       end
 
       def innerable?
@@ -78,6 +79,14 @@ module Contrek
         map(&:end_point)
       end
 
+      def orient!
+        @versus = if size <= 1
+          0
+        else
+          (tail.payload[:y] - head.payload[:y]).positive? ? 1 : -1
+        end
+      end
+
       def self.remove_adjacent_pairs(array = nil)
         n = array.size
         (0...(n - 1)).each do |i|

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

@@ -14,6 +14,8 @@ 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)
       end
 
       def insert_after(part, new_part)
@@ -25,10 +27,10 @@ module Contrek
         part.next = part.circular_next = new_part
       end
 
-      def find_first_part_by_position(position)
+      def find_first_part_by_position(position, versus)
         @parts.find do |part|
           part.is?(Part::SEAM) &&
-            part.passes == 0 &&
+            part.versus == -versus &&
             position.end_point.queues.include?(part)
         end
       end
@@ -144,10 +146,10 @@ module Contrek
 
             count = 0
             inside.each do |position|
-              break unless position.end_point.queues.include?(inside_compare)
-              count += 1
+              inclusion = position.end_point.queues.include?(inside_compare)
+              count += 1 if inclusion
             end
-            if count == inside.size
+            if count == inside.size && count < inside_compare.size
               inside.type = Part::EXCLUSIVE
               inside.trasmuted = true
               break

data/lib/contrek/finder/node.rb

@@ -3,7 +3,8 @@ module Contrek
     class Node
       include Listable
 
-      attr_reader :min_x, :max_x, :y, :name, :tangs, :tangs_sequence, :tangs_count, :data_pointer
+      attr_reader :min_x, :max_x, :y, :name, :tangs_sequence, :tangs_count, :data_pointer,
+        :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
@@ -24,12 +25,11 @@ module Contrek
       OUTER = 0
       INNER = 1
 
-      def initialize(cluster, min_x, max_x, y, name)
+      def initialize(cluster, min_x, max_x, y, name, connectivity_offset = 0)
         @name = name
         @min_x = min_x
         @max_x = max_x
         @y = y
-        @tangs = {T_UP => [], T_DOWN => []}
         @tangs_sequence = nil
         @tangs_count = 0
         @track = 0
@@ -39,11 +39,23 @@ module Contrek
         @down_indexer = 0
         @outer_index = -1
         @inner_index = -1
-        cluster.add_node(self)
+        @upper_start = Float::INFINITY
+        @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 tangs?(node)
-        @min_x <= node.max_x && node.min_x <= @max_x
+      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)
@@ -62,15 +74,13 @@ module Contrek
           end
 
         when :inner
-
           if versus == :o
             (last_node_index == 0) ? last_node_index = tangs_sequence.size - 1 : last_node_index -= 1
           else
             (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)
@@ -79,14 +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]
-      end
 
-      def tangs_with_x?(x)
-        x.between?(@min_x, @max_x)
+        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
@@ -97,28 +121,33 @@ module Contrek
         (@track & OCOMPLETE) == OCOMPLETE
       end
 
-      def add_intersection(other_node)
+      def add_intersection(other_node, other_node_index)
         if other_node.y < y
-          @tangs[T_UP] << other_node
+          @upper_start = other_node_index if other_node_index < @upper_start
+          @upper_end = other_node_index if other_node_index > @upper_end
         else
-          @tangs[T_DOWN] << other_node
+          @lower_start = other_node_index if other_node_index < @lower_start
+          @lower_end = other_node_index if other_node_index > @lower_end
         end
       end
 
-      def precalc_tangs_sequences
-        @tangs_sequence = Array.new(tangs[T_UP].size + tangs[T_DOWN].size)
-        tangs = self.tangs[T_UP].sort_by(&:min_x)
-        n = -1
-        @up_indexer = -tangs[0].abs_x_index if tangs.size > 0
-        tangs.each do |t_node|
-          nd = 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[n += 1] = nd
+      def precalc_tangs_sequences(cluster:)
+        @tangs_sequence = []
+        @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|
+            @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
-        tangs = self.tangs[T_DOWN].sort_by(&:min_x).reverse
-        @down_indexer = (tangs.last.abs_x_index + self.tangs[T_DOWN].size + self.tangs[T_UP].size - 1) if tangs.size > 0
-        tangs.each do |t_node|
-          nd = 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[n += 1] = nd
+        if @lower_end >= 0
+          @lower_end.downto(@lower_start).each do |lower_pos|
+            @tangs_sequence << lower_pos
+          end
         end
         @tangs_count = tangs_sequence.size
       end

data/lib/contrek/finder/node_cluster.rb

@@ -1,7 +1,7 @@
 module Contrek
   module Finder
     class NodeCluster
-      attr_reader :root_nodes, :sequences, :polygons, :lists, :treemap, :vert_nodes
+      attr_reader :root_nodes, :sequences, :polygons, :lists, :treemap, :vert_nodes, :options
       VERSUS_INVERTER = {a: :o, o: :a}
 
       def initialize(h, options)
@@ -44,7 +44,7 @@ module Contrek
       def build_tangs_sequence
         @vert_nodes.each do |line|
           line.each do |node|
-            node.precalc_tangs_sequences
+            node.precalc_tangs_sequences(cluster: self)
           end
         end
       end
@@ -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
@@ -103,9 +100,15 @@ module Contrek
             # end
 
             next_node = if (first.track & Contrek::Finder::Node::OMAX) != 0
-              (inner_v == :a) ? first.tangs[Contrek::Finder::Node::T_UP].first : first.tangs[Contrek::Finder::Node::T_DOWN].first
+              if inner_v == :a
+                vert_nodes[first.y + Node::T_UP][first.upper_start]
+              else
+                vert_nodes[first.y + Node::T_DOWN][first.lower_start]
+              end
+            elsif inner_v == :a
+              vert_nodes[first.y + Node::T_DOWN][first.lower_end]
             else
-              (inner_v == :a) ? first.tangs[Contrek::Finder::Node::T_DOWN].last : first.tangs[Contrek::Finder::Node::T_UP].last
+              vert_nodes[first.y + Node::T_UP][first.upper_end]
             end
 
             if !next_node.nil?
@@ -192,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)
@@ -225,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
@@ -258,7 +261,7 @@ module Contrek
         plot_node(next_node, start_node, bounds, versus)
       end
 
-      def add_node(node)
+      def add_node(node, offset)
         @nodes += 1
         node.abs_x_index = @vert_nodes[node.y].size
 
@@ -273,17 +276,17 @@ module Contrek
             index = 0
             loop do
               up_node = up_nodes[index]
-              if up_node.max_x >= node.min_x
-                if up_node.min_x <= node.max_x
-                  node.add_intersection(up_node)
-                  up_node.add_intersection(node)
+              if (up_node.max_x + offset) >= node.min_x
+                if (up_node.min_x - offset) <= node.max_x
+                  node.add_intersection(up_node, index)
+                  up_node.add_intersection(node, node.abs_x_index)
                 end
                 return if (index += 1) == up_nodes_count
                 loop do
                   up_node = up_nodes[index]
-                  if up_node.min_x <= node.max_x
-                    node.add_intersection(up_node)
-                    up_node.add_intersection(node)
+                  if (up_node.min_x - offset) <= node.max_x
+                    node.add_intersection(up_node, index)
+                    up_node.add_intersection(node, node.abs_x_index)
                   else
                     return
                   end

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
@@ -91,6 +90,7 @@ module Contrek
 
       # image scan
       def scan
+        offset = (@node_cluster.options[:connectivity] == 8) ? 1 : 0
         last_color = nil
         matching = false
         min_x = start_x
@@ -103,16 +103,16 @@ module Contrek
             matching = true
             if x == (end_x - 1)
               max_x = x
-              Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+              Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color, offset)
               matching = false
             end
           elsif @matcher.unmatch?(color) && matching == true
             max_x = x - 1
-            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color, offset)
             matching = false
           elsif x == (end_x - 1) && matching == true
             max_x = x
-            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color)
+            Contrek::Finder::Node.new(@node_cluster, min_x, max_x, y, last_color, offset)
             matching = false
           end
         end

data/lib/contrek/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.4
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-02-09 00:00:00.000000000 Z
+date: 2026-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -135,12 +135,14 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- LICENSE-MIT.md
 - LICENSE.md
 - README.md
 - Rakefile
 - contrek.gemspec
 - contrek.png
 - ext/cpp_polygon_finder/PolygonFinder/CMakeLists.txt
+- ext/cpp_polygon_finder/PolygonFinder/LICENSE_AGPL.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
@@ -275,7 +277,6 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://github.com/runout77/contrek
-  source_code_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: 
@@ -293,7 +294,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
 summary: Fast PNG contour tracing and shape detection for Ruby