contrek 1.0.2 → 1.0.4

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

@@ -0,0 +1,119 @@
+module Contrek
+  module Concurrent
+    class Finder
+      prepend Poolable
+
+      attr_reader :maximum_width
+
+      # Supported options
+      # - number_of_threads: number of threads that can be used by the process. If set to 0, it works in
+      #   single-thread mode.
+      #   The process can take advantage of multiprocessing when computing the initial contours of the
+      #   tiles into which the image is divided, and during the subsequent merging of tiles into pairs.
+      #   Each merge is performed by any available thread as soon as two adjacent tiles have been computed.
+      #   If set to nil, the process will use the maximum number of cpu available cores.
+      # - bitmap: PngBitmap containing the image.
+      # - matcher: specific Matcher used for pixel identification.
+      # - options: options include:
+      #            - number_of_tiles: number of tiles into which the image is initially divided.
+      #              It cannot exceed the image width, so the system works with tiles at least one pixel wide.
+      #              Given the technique on which the process is based, using excessively narrow tiles is
+      #              discouraged.
+
+      def initialize(bitmap:, matcher:, options: {}, &block)
+        @initialize_time = Benchmark.measure do
+          @block = block
+          @tiles = Queue.new
+          @bitmap = bitmap
+          @options = options
+          @clusters = []
+          @maximum_width = bitmap.w
+          @number_of_tiles = options[:number_of_tiles] || (raise "number_of_tiles params is needed!")
+
+          cw = @maximum_width.to_f / @number_of_tiles
+          raise "One pixel tile width minimum!" if cw < 1.0
+          x = 0
+          current_versus = options[:versus]
+          raise "Define versus!" if current_versus.nil?
+
+          @number_of_tiles.times do |tile_index|
+            tile_end_x = (cw * (tile_index + 1)).to_i
+
+            enqueue!(tile_index: tile_index,
+              tile_start_x: x,
+              tile_end_x: tile_end_x) do |payload|
+              finder = ClippedPolygonFinder.new(
+                bitmap: bitmap,
+                matcher: matcher,
+                options: {versus: current_versus},
+                start_x: payload[:tile_start_x],
+                end_x: payload[:tile_end_x]
+              )
+              tile = Tile.new(
+                finder: self,
+                start_x: payload[:tile_start_x],
+                end_x: payload[:tile_end_x],
+                name: payload[:tile_index].to_s
+              )
+              tile.initial_process!(finder)
+              @tiles << tile
+            end
+
+            x = tile_end_x - 1
+          end
+          @tile = process_tiles!(bitmap)
+        end.real
+      end
+
+      def process_info(bitmap = nil)
+        raw_polygons = @tile.to_raw_polygons
+
+        compress_time = Benchmark.measure do
+          if @options.has_key?(:compress)
+            FakeCluster.new(raw_polygons, @options).compress_coords
+          end
+        end.real
+
+        {polygons: raw_polygons,
+         benchmarks: {
+           total: ((@initialize_time + compress_time) * 1000).round(3),
+           init: (@initialize_time * 1000).round(3),
+           outer: (@tile.benchmarks[:outer] * 1000).round(3),
+           inner: (@tile.benchmarks[:inner] * 1000).round(3),
+           compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
+         }.compact}
+      end
+
+      private
+
+      def process_tiles!(bitmap)
+        arriving_tiles = []
+        loop do
+          tile = @tiles.pop
+          return tile if tile.whole?
+
+          if (twin_tile = arriving_tiles.find { |b| (b.start_x == (tile.end_x - 1)) || ((b.end_x - 1) == tile.start_x) })
+            cluster = Cluster.new(finder: self, height: bitmap.h, width: bitmap.w)
+            if twin_tile.start_x == (tile.end_x - 1)
+              cluster.add(tile)
+              cluster.add(twin_tile)
+            else
+              cluster.add(twin_tile)
+              cluster.add(tile)
+            end
+            enqueue!(cluster: cluster) do |payload|
+              merged_tile = payload[:cluster].merge_tiles!
+              @tiles << merged_tile
+              # usefull external access to each merged_tile
+              @block&.call(merged_tile, bitmap)
+            end
+            arriving_tiles.delete(twin_tile)
+            next
+          end
+          arriving_tiles << tile
+        end
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Contrek
+  module Concurrent
+    class Hub
+      attr_reader :payloads, :width
+      def initialize(height:, width:)
+        @width = width
+        # @payloads = Array.new(width * height)
+        @payloads = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Contrek
+  module Concurrent
+    module Listable
+      attr_accessor :prev, :next, :owner
+      def initialize(*args, **kwargs, &block)
+        super
+        @next = nil
+        @prev = nil
+        @owner = nil
+      end
+
+      def payload
+        raise NoMethodError
+      end
+
+      def after_add(new_queue)
+      end
+
+      def before_rem(old_queue)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Contrek
+  module Concurrent
+    class Part
+      prepend Queueable
+
+      SEAM = 1
+      EXCLUSIVE = 0
+      ADDED = 2
+
+      attr_reader :polyline, :index, :touched
+      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted
+      def initialize(type, polyline)
+        @type = type
+        @polyline = polyline
+        @next = nil
+        @circular_next = nil
+        @prev = nil
+        @passes = 0
+        @touched = false
+        @inverts = false
+        @trasmuted = false
+      end
+
+      def is?(type)
+        @type == type
+      end
+
+      def add_position(position, n)
+        add(Position.new(position: position, hub: polyline.tile.cluster.hub))
+      end
+
+      def next_position(force_position = nil)
+        if force_position
+          move_to_this = reverse_each { |pos| break pos if pos.payload == force_position }
+          next_of!(move_to_this)
+          force_position
+        else
+          return nil if iterator.nil?
+          position = iterator
+          @touched = true
+          forward!
+          position
+        end
+      end
+
+      def touch!
+        @touched = true
+      end
+
+      def name
+        {Part::EXCLUSIVE => "EXCLUSIVE",
+         Part::SEAM => "SEAM",
+         Part::ADDED => "ADDED"}[type]
+      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})"
+      end
+
+      def innerable?
+        (@touched == false) && is?(EXCLUSIVE)
+      end
+
+      def intersect_part?(other_part)
+        other_part.each do |position|
+          return true if position.end_point.queues.include?(self)
+        end
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module Contrek
+  module Concurrent
+    module Partitionable
+      attr_reader :parts
+
+      def initialize(*args, **kwargs, &block)
+        super
+        @parts = []
+      end
+
+      def add_part(new_part)
+        last = @parts.last
+        @parts << new_part
+        last.next = last.circular_next = new_part if last
+        new_part.circular_next = @parts.first
+        new_part.prev = last
+      end
+
+      def find_first_part_by_position(position)
+        @parts.find do |part|
+          part.is?(Part::SEAM) &&
+            part.passes == 0 &&
+            position.end_point.queues.include?(part)
+        end
+      end
+
+      def inspect_parts
+        [" "] + ["#{self.class} parts=#{@parts.size}"] + @parts.map { |p| p.inspect } + [" "]
+      end
+
+      def partition!
+        current_part = nil
+        @parts = []
+
+        @raw.each_with_index do |position, n|
+          if @tile.tg_border?(position)
+            if current_part.nil?
+              current_part = Part.new(Part::SEAM, self)
+            elsif !current_part.is?(Part::SEAM)
+              add_part(current_part)
+              current_part = Part.new(Part::SEAM, self)
+            end
+          elsif current_part.nil?
+            current_part = Part.new(Part::EXCLUSIVE, self)
+          elsif !current_part.is?(Part::EXCLUSIVE)
+            add_part(current_part)
+            current_part = Part.new(Part::EXCLUSIVE, self)
+          end
+          if n > 0 && @raw[n - 1] == position
+            current_part.inverts = true
+          end
+          current_part.add_position(position, n)
+        end
+        add_part(current_part)
+
+        trasmute_parts!
+      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
+        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 = []
+        (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?
+        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
+        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?
+        end
+        [left, right]
+      end
+
+      private
+
+      # 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!
+        insides = @parts.select { |p| p.is?(Part::SEAM) }
+        return if insides.size < 2
+
+        insides.each do |inside|
+          (insides - [inside]).each do |inside_compare|
+            next unless inside_compare.is?(Part::SEAM)
+
+            count = 0
+            inside.each do |position|
+              break unless position.end_point.queues.include?(inside_compare)
+              count += 1
+            end
+            if count == inside.size
+              inside.type = Part::EXCLUSIVE
+              inside.trasmuted = true
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Contrek
+  module Concurrent
+    class Polyline
+      prepend Partitionable
+
+      TRACKED_OUTER = 1 << 0
+      TRACKED_INNER = 1 << 1
+      Bounds = Struct.new(:min_x, :max_x, :min_y, :max_y)
+
+      attr_reader :raw, :name, :min_y, :max_y, :next_tile_eligible_shapes
+      attr_accessor :shape, :tile
+
+      def initialize(tile:, polygon:, shape: nil)
+        @tile = tile
+        @name = tile.shapes.count
+        @raw = polygon
+        @shape = shape
+        @flags = 0
+        find_boundary
+      end
+
+      def inspect
+        "#{self.class}[b#{@tile.name} S#{@name} #{"B" if boundary?}] (#{raw.count} => #{raw.inspect})"
+      end
+
+      def info
+        "w#{@tile.name} S#{@name}"
+      end
+
+      def turn_on(flag)
+        @flags |= flag
+      end
+
+      def turn_off(flag)
+        @flags &= ~flag
+      end
+
+      def on?(flag)
+        (@flags & flag) != 0
+      end
+
+      def intersection(other)
+        (@raw.compact & other.raw.compact)
+      end
+
+      def empty?
+        @raw.empty?
+      end
+
+      def boundary?
+        @tile.tg_border?({x: @min_x}) || @tile.tg_border?({x: @max_x})
+      end
+
+      def clear!
+        @raw = []
+      end
+
+      def vert_intersect?(other)
+        !(@max_y < other.min_y || other.max_y < @min_y)
+      end
+
+      def width
+        return 0 if empty?
+        @max_x - @min_x
+      end
+
+      # Pre-detects, for the current polyline, adjacent ones in the neighboring tile
+      # that vertically intersect.
+      def precalc!
+        @next_tile_eligible_shapes = @tile
+          .circular_next.boundary_shapes
+          .select { |s|
+          !s.outer_polyline.on?(Polyline::TRACKED_OUTER) &&
+            vert_intersect?(s.outer_polyline)
+        }
+      end
+
+      private
+
+      def find_boundary
+        return if @raw.empty?
+
+        bounds = @raw.compact.each_with_object(Bounds.new(Float::INFINITY, -Float::INFINITY, Float::INFINITY, -Float::INFINITY)) do |c, b|
+          x, y = c[:x], c[:y]
+          b.min_x = x if x < b.min_x
+          b.max_x = x if x > b.max_x
+          b.min_y = y if y < b.min_y
+          b.max_y = y if y > b.max_y
+        end
+
+        @min_x, @max_x, @min_y, @max_y = bounds.values
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "concurrent-ruby"
+
+module Contrek
+  module Concurrent
+    module Poolable
+      attr_reader :number_of_threads
+      def initialize(number_of_threads: 0, **kwargs)
+        @number_of_threads = number_of_threads || ::Concurrent.physical_processor_count
+        if @number_of_threads > 0
+          @threads = ::Concurrent::Array.new
+          @semaphore = ::Concurrent::Semaphore.new(@number_of_threads)
+        end
+        super(**kwargs)
+      end
+
+      def wait!
+        @threads.each(&:join)
+      end
+
+      def enqueue!(**payload, &block)
+        if @number_of_threads > 0
+          @threads << Thread.new do
+            @semaphore.acquire
+            begin
+              block.call(payload)
+            ensure
+              @semaphore.release
+            end
+          end
+        else
+          block.call(payload)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Contrek
+  module Concurrent
+    class Position
+      include Listable
+
+      attr_reader :end_point
+
+      def initialize(hub:, position:)
+        key = position[:y] * hub.width + position[:x]
+        @end_point = hub.payloads[key] ||= EndPoint.new
+        @position = position
+      end
+
+      def payload
+        @position
+      end
+
+      def after_add(new_queue)
+        @end_point.queues << new_queue
+      end
+
+      def before_rem(old_queue)
+        @end_point.queues.delete(old_queue)
+      end
+    end
+  end
+end