contrek 1.3.3 → 1.3.4

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

@@ -51,24 +51,15 @@ module Contrek
             if part.innerable?
               all_parts = []
               tracked_end_points = []
-              bounds = {min: polyline.max_y, max: 0}
-              traverse_inner(part, all_parts, bounds, tracked_end_points)
-              range_of_bounds = (bounds[:min]..bounds[:max])
-
+              traverse_inner(part, all_parts, tracked_end_points)
               retme_sequence = Sequence.new
               all_parts.each do |part|
                 part.touch!
-                retme_sequence.move_from(part) do |position|
-                  next false if part.is?(Part::ADDED) && !(range_of_bounds === position.payload[:y])
-
-                  !(polyline.tile.tg_border?(position.payload) && position.end_point.tracked_outer)
-                end
-              end
-              if retme_sequence.is_not_vertical
-                inner_polyline = InnerPolyline.new(sequence: retme_sequence)
-                return_inner_polylines << inner_polyline
-                mark_children(tracked_end_points, polyline, inner_polyline) if treemap
+                retme_sequence.append(part)
               end
+              inner_polyline = InnerPolyline.new(sequence: retme_sequence)
+              return_inner_polylines << inner_polyline
+              mark_children(tracked_end_points, polyline, inner_polyline) if treemap
             end
           end
           shape_index += 1
@@ -78,76 +69,55 @@ module Contrek
 
       private
 
-      # finds each part (and relative polyline) inscribed between two end_points and sets the
-      # founded inner_polyline which be later used to define in which parent hole is placed.
-      def mark_children(end_points, outer_polyline, inner_polyline)
-        end_points.each_slice(2) do |a, b|
-          range = [a.position[:y], b.position[:y]].sort
-          (range[0] + 1).upto(range[1] - 1) do |y|
-            if (end_point = @cluster.hub.payloads[y])
-              end_point.queues.each do |part|
-                if part.polyline != outer_polyline
-                  part.polyline.inside_inner_polyline = inner_polyline
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # rubocop:disable Lint/NonLocalExitFromIterator
-      def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
-        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)
-            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))
-            new_position.end_point.tracked_outer = true
-            versus = act_part.versus
-            part = new_position.end_point.queues.find do |p|
-              (p.mirror || act_part.mirror || p.versus == -versus) && p.polyline.tile != act_part.polyline.tile
+      def traverse_outer(start_part, all_parts, shapes_sequence, outer_joined_polyline)
+        act_part = start_part
+
+        while act_part
+          last_part = all_parts.last
+          all_parts << act_part if last_part != act_part
+          jumped_to_new_part = false
+          if act_part.is?(Part::EXCLUSIVE)
+            return if act_part.size == 0
+            while (position = act_part.next_position)
+              outer_joined_polyline.add(position)
             end
-            if part
-              if all_parts[-2] != part
-                cont = true
-                if all_parts.size >= 2
-                  map = all_parts[-2..].map(&:type).uniq
-                  cont = false if map.size == 1 && map.first == Part::SEAM
-                end
-                if cont
-                  shapes_sequence << part.polyline.shape if !shapes_sequence.include?(part.polyline.shape)
+          else
+            while (new_position = act_part.iterator)
+              if outer_joined_polyline.size > 1 &&
+                  outer_joined_polyline.head.payload == new_position.payload &&
+                  act_part == all_parts.first
+                return
+              end
+              new_position.end_point.tracked_outer = true
+              versus = act_part.versus
+              part = new_position.end_point.queues.find do |p|
+                (p.versus == -versus) && p.polyline.tile != act_part.polyline.tile
+              end
+              if part
+                if all_parts[-2] != part
+                  if !shapes_sequence.include?(part.polyline.shape)
+                    shapes_sequence << part.polyline.shape
+                  end
                   part.next_position(new_position)
-                  part.dead_end = true
-                  traverse_outer(part, all_parts, shapes_sequence, outer_joined_polyline)
-                  return
+                  act_part = part
+                  jumped_to_new_part = true
+                  break
                 end
               end
+              act_part.next_position
             end
-            act_part.next_position
           end
+          next if jumped_to_new_part
+          next_part = act_part.circular_next
+          next_part.rewind!
+          act_part = next_part
         end
-        next_part = act_part.circular_next
-        next_part.rewind!
-        traverse_outer(act_part.circular_next, all_parts, shapes_sequence, outer_joined_polyline)
       end
 
-      def traverse_inner(act_part, all_parts, bounds, tracked_end_points)
+      # rubocop:disable Lint/NonLocalExitFromIterator
+      def traverse_inner(act_part, all_parts, tracked_end_points)
         return if act_part == all_parts.first
 
-        if act_part.size > 0
-          min_y, max_y = act_part.to_a.minmax_by { |p| p[:y] }
-          bounds[:min] = [bounds[:min], min_y[:y]].min
-          bounds[:max] = [bounds[:max], max_y[:y]].max
-        end
         if act_part.innerable?
           all_parts << act_part
           while (act_part = act_part.circular_next)
@@ -161,15 +131,6 @@ module Contrek
                   next if dest_part_versus != 0 && dest_part_versus == act_part.versus
 
                   tracked_end_points << act_part.head.end_point
-
-                  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|
-                      ins_part.add(Position.new(position: nil, hub: nil, known_endpoint: pos))
-                    end
-                    all_parts << ins_part
-                  end
                   shape = dest_part.polyline.shape
                   if !dest_part.polyline.on?(Polyline::TRACKED_OUTER)
                     @shapes_sequence << shape
@@ -179,7 +140,7 @@ module Contrek
                   dest_part.polyline.turn_on(Polyline::TRACKED_OUTER)
                   if !dest_part.touched
                     dest_part.touch!
-                    traverse_inner(dest_part.circular_next, all_parts, bounds, tracked_end_points)
+                    traverse_inner(dest_part.circular_next, all_parts, tracked_end_points)
                     return
                   end
                 end
@@ -188,10 +149,27 @@ module Contrek
             end
           end
         elsif act_part.next
-          traverse_inner(act_part.next, all_parts, bounds, tracked_end_points)
+          traverse_inner(act_part.next, all_parts, tracked_end_points)
         end
       end
       # rubocop:enable Lint/NonLocalExitFromIterator
+
+      # finds each part (and relative polyline) inscribed between two end_points and sets the
+      # founded inner_polyline which be later used to define in which parent hole is placed.
+      def mark_children(end_points, outer_polyline, inner_polyline)
+        end_points.each_slice(2) do |a, b|
+          range = [a.position[:y], b.position[:y]].sort
+          (range[0] + 1).upto(range[1] - 1) do |y|
+            if (end_point = @cluster.hub.payloads[y])
+              end_point.queues.each do |part|
+                if part.polyline != outer_polyline
+                  part.polyline.inside_inner_polyline = inner_polyline
+                end
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

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

@@ -93,7 +93,8 @@ module Contrek
             compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
           }.compact,
           width: @maximum_width,
-          height: @height
+          height: @height,
+          versus: options[:versus]
         }
         metadata[:treemap] = @whole_tile.compute_treemap if options[:treemap]
         Contrek::Finder::Result.new(raw_polygons, metadata)

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

@@ -7,25 +7,16 @@ module Contrek
 
       SEAM = 1
       EXCLUSIVE = 0
-      ADDED = 2
 
       attr_reader :polyline, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts,
-        :trasmuted, :versus, :mirror, :next_seam, :transmutation_skip
+      attr_accessor :next, :circular_next, :type, :versus
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
         @next = nil
-        @next_seam = nil
         @circular_next = nil
-        @prev = nil
-        @dead_end = false
         @touched = false
-        @inverts = false
-        @trasmuted = false
         @versus = 0
-        @mirror = false
-        @transmutation_skip = false
       end
 
       def is?(type)
@@ -57,12 +48,11 @@ module Contrek
 
       def name
         {Part::EXCLUSIVE => "EXCLUSIVE",
-         Part::SEAM => "SEAM",
-         Part::ADDED => "ADDED"}[type]
+         Part::SEAM => "SEAM"}[type]
       end
 
       def inspect
-        "part #{polyline.parts.index(self)} (mir=#{@mirror} versus=#{@versus} inv=#{@inverts} trm=#{@trasmuted} touched=#{@touched} dead_end =#{@dead_end}, #{size}x) of #{polyline.named} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
+        "part #{polyline.parts.index(self)} (versus=#{@versus} touched=#{@touched}, #{size}x) of #{polyline.named} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
       end
 
       def innerable?
@@ -70,80 +60,17 @@ module Contrek
       end
 
       def orient!
-        @versus = if size <= 1 || (size == 2 && @inverts)
+        @versus = if size <= 1
           0
         else
           diff = tail.payload[:y] - head.payload[:y]
           if diff == 0
-            @mirror = true
             0
           else
             diff.positive? ? 1 : -1
           end
         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
-        self_min >= other_min && self_max <= other_max
-      end
-
-      def same_length?(other)
-        (head.payload[:y] - tail.payload[:y]).abs ==
-          (other.head.payload[:y] - other.tail.payload[:y]).abs
-      end
-
-      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
-        []
-      end
     end
   end
 end

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

@@ -8,8 +8,6 @@ module Contrek
       def initialize(*args, **kwargs, &block)
         super
         @parts = []
-        @first_seam = nil
-        @last_seam = nil
       end
 
       def add_part(new_part)
@@ -17,15 +15,7 @@ module Contrek
         @parts << new_part
         last.next = last.circular_next = new_part if last
         new_part.circular_next = @parts.first
-        new_part.prev = last
-        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
+        new_part.orient! if new_part.is?(Part::SEAM)
       end
 
       def inspect_parts
@@ -35,8 +25,6 @@ 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)
@@ -52,54 +40,9 @@ module Contrek
             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)
         end
         add_part(current_part)
-
-        transmute_parts!
-      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 transmute_parts!
-        transpose = tile.cluster.finder.transpose?
-        if (current_seam = @first_seam)
-          loop do
-            if transpose
-              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
     end
   end

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

@@ -47,12 +47,30 @@ module Contrek
         node.after_add(self)
       end
 
-      def move_from(queueable, &block)
-        queueable.rewind!
-        while (node = queueable.iterator)
-          queueable.forward!
-          add(node) if yield(node)
+      def append(queueable)
+        return if queueable.size.zero?
+        queueable.each do |node|
+          node.before_rem(queueable)
+          node.owner = self
         end
+        if @tail
+          @tail.next = queueable.head
+          queueable.head.prev = @tail
+        else
+          @head = queueable.head
+        end
+        @tail = queueable.tail
+        @size += queueable.size
+        queueable.reset!
+
+        each { |node| node.after_add(self) }
+      end
+
+      def reset!
+        @head = nil
+        @tail = nil
+        @size = 0
+        @iterator = 0
       end
 
       # from yield: false => stop, true => continue

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

@@ -5,21 +5,6 @@ module Contrek
     class Sequence
       attr_accessor :shape
       prepend Queueable
-
-      def is_not_vertical
-        return false if size < 2
-        x0 = head.payload[:x]
-        rewind!
-        while (position = iterator)
-          return true if position.payload[:x] != x0
-          forward!
-        end
-        false
-      end
-
-      def get_vector_cache
-        @vector_cache ||= to_a
-      end
     end
   end
 end

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

@@ -84,7 +84,7 @@ module Contrek
       end
 
       def tg_border?(coord)
-        coord[:x] == (@next.nil? ? @start_x : (@end_x - 1))
+        coord[:x] == (@next.nil? ? @start_x : (@end_x))
       end
 
       def inspect

data/lib/contrek/finder/node.rb

@@ -6,7 +6,7 @@ module Contrek
       include Listable
 
       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
+        :upper_start, :upper_end, :lower_start, :lower_end
       attr_accessor :track, :abs_x_index, :outer_index, :inner_index, :inner_left_index, :inner_right_index
 
       T_UP = -1
@@ -30,7 +30,7 @@ module Contrek
       def initialize(cluster, min_x, max_x, y, name, connectivity_offset = 0)
         @name = name
         @min_x = min_x
-        @max_x = max_x
+        @max_x = max_x + 1
         @y = y
         @tangs_sequence = nil
         @tangs_count = 0
@@ -47,12 +47,14 @@ module Contrek
         @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 inspect
+        "#<#{self.class} id:#{@id} name:\"#{@name}\">"
+      end
+
       def get_tangent_node_by_virtual_index(virtual_index)
         return nil if virtual_index.nil?
         if virtual_index < 0
@@ -62,6 +64,22 @@ module Contrek
         end
       end
 
+      def nw_point
+        {x: min_x, y: y}
+      end
+
+      def ne_point
+        {x: max_x, y: y}
+      end
+
+      def se_point
+        {x: max_x, y: y + 1}
+      end
+
+      def sw_point
+        {x: min_x, y: y + 1}
+      end
+
       def my_next(last, versus, mode)
         last_node_index = if last.y < y
           last.abs_x_index + @up_indexer
@@ -99,19 +117,19 @@ module Contrek
           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
+            point = node_up.se_point
           else
             enter_to.track |= TURNER[tracking][OMIN - 1]
-            point = node_up.start_point
+            point = node_up.sw_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
+            point = node_down.nw_point
           else
             enter_to.track |= TURNER[tracking][OMAX - 1]
-            point = node_down.end_point
+            point = node_down.ne_point
           end
         end
         point