contrek 1.1.8 → 1.2.0

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

@@ -39,74 +39,39 @@ module Contrek
       end
 
       def join_inners!(outer_seq)
-        # search for missing sequence to sew
-        missing_shapes = []
-        @cluster.tiles.each do |tile|
-          tile.shapes.each do |shape|
-            next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) ||
-              shape.outer_polyline.on?(Polyline::TRACKED_INNER) ||
-              !shape.outer_polyline.boundary? ||
-              @shapes_sequence.include?(shape)
-            missing_shapes << shape
-          end
-        end
-
-        if missing_shapes.any?
-          to_delay_shapes = connect_missings(@shapes_sequence, missing_shapes)
-          if to_delay_shapes.any?
-            connect_missings(to_delay_shapes, missing_shapes)
-            while to_delay_shapes.any?
-              to_delay_shapes = connect_missings(@shapes_sequence, to_delay_shapes)
-            end
-          end
-        end
-
-        retme = collect_inner_sequences(outer_seq)
+        return_inner_polylines = []
 
-        @shapes_sequence.each do |shape|
-          shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
-        end
-        retme
-      end
+        @processing_shapes = @shapes_sequence.to_a
 
-      private
+        @processing_shapes.each do |shape|
+          polyline = shape.outer_polyline
+          polyline.parts.each do |part|
+            if part.innerable?
+              all_parts = []
+              bounds = {min: polyline.max_y, max: 0}
+              traverse_inner(part, all_parts, bounds)
+              range_of_bounds = (bounds[:min]..bounds[:max])
 
-      def connect_missings(shapes_sequence, missing_shapes)
-        delay_shapes = []
+              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])
 
-        shapes_sequence.each do |shape|
-          polyline = shape.outer_polyline
-          missing_shapes.each do |missing_shape|
-            missing_outer_polyline = missing_shape.outer_polyline
-            next if (polyline.mixed_tile_origin == false && missing_outer_polyline.tile == polyline.tile) || # accepts only other side ones
-              missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
-              polyline == missing_outer_polyline ||
-              !polyline.vert_intersect?(missing_outer_polyline)
-
-            if (intersection = polyline.intersection(missing_outer_polyline)).any?
-              inject_sequences_left, inject_sequences_right = polyline.sew!(intersection, missing_outer_polyline)
-              if inject_sequences_left.nil?
-                delay_shapes << missing_shape
-                next
-              end
-              combine!(inject_sequences_right, inject_sequences_left).each do |sewn_sequence|
-                sewn_sequence.uniq!
-                if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # only areas
-                  @orphan_inners << InnerPolyline.new(shape: shape, raw_coordinates: sewn_sequence, recombined: true)
+                  !(polyline.tile.tg_border?(position.payload) && position.end_point.tracked_outer)
                 end
               end
-              missing_outer_polyline.clear!
-              polyline.mixed_tile_origin = true
-              missing_outer_polyline.turn_on(Polyline::TRACKED_OUTER)
-              missing_outer_polyline.turn_on(Polyline::TRACKED_INNER)
-              @orphan_inners += missing_shape.inner_polylines
+              if retme_sequence.is_not_vertical
+                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
+              end
             end
           end
         end
-
-        delay_shapes
+        return_inner_polylines
       end
 
+      private
+
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
         last_part = all_parts.last
@@ -126,13 +91,19 @@ module Contrek
               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, act_part.versus))
-                if all_parts[-2] != part
-                  if all_parts.size >= 2
-                    map = all_parts[-2..].map(&:type).uniq
-                    break if map.size == 1 && map.first == Part::SEAM
-                  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
+                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.add(part.polyline.shape)
                   part.next_position(new_position)
                   part.dead_end = true
@@ -149,36 +120,9 @@ module Contrek
         traverse_outer(act_part.circular_next, all_parts, shapes_sequence, outer_joined_polyline)
       end
 
-      def collect_inner_sequences(outer_seq)
-        return_inner_polylines = []
-        @shapes_sequence.each do |shape|
-          polyline = shape.outer_polyline
-          polyline.parts.each do |part|
-            if part.innerable?
-              all_parts = []
-              bounds = {min: polyline.max_y, max: 0}
-              traverse_inner(part, all_parts, bounds)
-              range_of_bounds = (bounds[:min]..bounds[:max])
-
-              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.queues.include?(outer_seq))
-                end
-              end
-              if retme_sequence.is_not_vertical
-                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
-              end
-            end
-          end
-        end
-        return_inner_polylines
-      end
-
       def traverse_inner(act_part, all_parts, bounds)
         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
@@ -186,27 +130,32 @@ module Contrek
         end
         if act_part.innerable?
           all_parts << act_part
-          while (act_part = act_part.next)
+          while (act_part = act_part.circular_next)
             if act_part.innerable?
               all_parts << act_part
             else
-              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)
+              if act_part.head
+                eligibles = act_part.head.end_point.queues.select { |p| p.polyline.tile != act_part.polyline.tile }
+                eligibles.each do |dest_part|
                   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)
-                    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
+                  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
-                    shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
-                    shape.outer_polyline.turn_on(Polyline::TRACKED_OUTER)
+                    all_parts << ins_part
+                  end
+                  shape = dest_part.polyline.shape
+                  if !dest_part.polyline.on?(Polyline::TRACKED_OUTER)
+                    @processing_shapes << shape
+                    @orphan_inners += shape.inner_polylines
+                  end
+                  dest_part.polyline.turn_on(Polyline::TRACKED_OUTER)
+                  if !dest_part.touched
+                    dest_part.touch!
                     traverse_inner(dest_part.circular_next, all_parts, bounds)
                     return
                   end
@@ -220,31 +169,6 @@ module Contrek
         end
       end
       # rubocop:enable Lint/NonLocalExitFromIterator
-
-      # The sequences should contain inverted parts, e.g., 4,5,6,6,5,4. These parts must be
-      # removed from the sequences, and the remaining elements are compared. Only the
-      # elements that appear once between the two sequences are kept. This represents
-      # a connection between parts inserted afterwards.
-      # TODO evaluate the adoption of remove_adjacent_pairs!
-      def duplicates_intersection(part_a, part_b)
-        a1 = part_a.inverts ? Part.remove_adjacent_pairs(part_a.to_endpoints) : part_a.to_endpoints
-        b1 = part_b.inverts ? Part.remove_adjacent_pairs(part_b.to_endpoints) : part_b.to_endpoints
-        (a1 - b1) + (b1 - a1)
-      end
-
-      # example
-      # a = [[A],[B,C]]
-      # b = [[D],[E,F]]
-      # res = [[D,B,C],[E,F,A]]
-      def combine!(seqa, seqb)
-        rets = []
-        [seqa.count, seqb.count].min.times do
-          last = seqa.pop
-          first = seqb.shift
-          rets << first + last
-        end
-        rets
-      end
     end
   end
 end

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

@@ -2,9 +2,11 @@ module Contrek
   module Concurrent
     class EndPoint
       attr_reader :queues, :position
+      attr_accessor :tracked_outer
       def initialize(position)
         @queues = []
         @position = position
+        @tracked_outer = false
       end
 
       def inspect

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

@@ -7,8 +7,8 @@ module Contrek
       EXCLUSIVE = 0
       ADDED = 2
 
-      attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :delayed, :versus
+      attr_reader :polyline, :touched
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :versus
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
@@ -19,7 +19,6 @@ module Contrek
         @touched = false
         @inverts = false
         @trasmuted = false
-        @delayed = false
         @versus = 0
       end
 
@@ -27,10 +26,6 @@ module Contrek
         @type == type
       end
 
-      def set_polyline(polyline)
-        @polyline = polyline
-      end
-
       def add_position(position)
         hub = is?(EXCLUSIVE) ? nil : polyline.tile.cluster.hub
         add(Position.new(position: position, hub: hub))
@@ -68,23 +63,6 @@ module Contrek
         (@touched == false) && is?(EXCLUSIVE)
       end
 
-      def intersect_part?(other_part)
-        intersect = false
-        other_part.each do |position|
-          if position.end_point.queues.include?(self)
-            intersect = true
-            false
-          else
-            true
-          end
-        end
-        intersect
-      end
-
-      def to_endpoints
-        map(&:end_point)
-      end
-
       def orient!
         @versus = if size <= 1 || (size == 2 && @inverts)
           0
@@ -93,16 +71,34 @@ module Contrek
         end
       end
 
-      def self.remove_adjacent_pairs(array = nil)
-        n = array.size
-        (0...(n - 1)).each do |i|
-          if array[i] == array[i + 1]
-            # Remove the pair and call recursively
-            new_array = array[0...i] + array[(i + 2)..]
-            return remove_adjacent_pairs(new_array)
+      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
-        array
+        []
       end
     end
   end

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

@@ -18,23 +18,6 @@ module Contrek
         new_part.orient! if new_part.is?(Part::SEAM)
       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, versus)
-        @parts.find do |part|
-          part.is?(Part::SEAM) &&
-            part.versus == -versus &&
-            position.end_point.queues.include?(part)
-        end
-      end
-
       def inspect_parts
         [" "] + ["#{self.class} parts=#{@parts.size}"] + @parts.map { |p| p.inspect } + [" "]
       end
@@ -67,70 +50,6 @@ module Contrek
         trasmute_parts!
       end
 
-      def sew!(intersection, other)
-        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]
-
-        # 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
-
-        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
-
-        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
-
-        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
-        insert_after(will_be_last, new_end_part)
-
-        reset_tracked_endpoints!
-
-        returning_data
-      end
-
       private
 
       # If there are SEAM parts and one is canceled out by another within the same polyline,

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

@@ -4,10 +4,9 @@ module Contrek
       prepend Partitionable
 
       TRACKED_OUTER = 1 << 0
-      TRACKED_INNER = 1 << 1
 
-      attr_reader :raw, :name, :min_y, :max_y, :next_tile_eligible_shapes
-      attr_accessor :shape, :tile, :mixed_tile_origin
+      attr_reader :raw, :name, :min_y, :max_y
+      attr_accessor :shape, :tile, :any_ancients
 
       def initialize(tile:, polygon:, shape: nil, bounds: nil)
         @tile = tile
@@ -15,7 +14,7 @@ module Contrek
         @raw = polygon
         @shape = shape
         @flags = 0
-        @mixed_tile_origin = false # becomes true when is sewn with polyline coming from other side tile
+        @any_ancients = false
 
         if bounds.nil?
           find_boundary
@@ -55,38 +54,6 @@ 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)
-        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?
         @raw.empty?
       end
@@ -104,17 +71,6 @@ module Contrek
         @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
-
       def vert_intersect?(other)
         !(@max_y < other.min_y || other.max_y < @min_y)
       end

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

@@ -20,11 +20,17 @@ module Contrek
       end
 
       def after_add(new_queue)
-        @end_point.queues << new_queue if @end_point
+        if @end_point && new_queue.instance_of?(Contrek::Concurrent::Part)
+          @end_point.queues << new_queue if !@end_point.queues.include?(new_queue)
+          if @end_point.queues.size > 1
+            new_queue.polyline.any_ancients = true
+            @end_point.queues.first.polyline.any_ancients = true
+          end
+        end
       end
 
       def before_rem(old_queue)
-        @end_point&.queues&.delete(old_queue)
+        # @end_point&.queues&.delete(old_queue) if old_queue.class == Contrek::Concurrent::Part
       end
 
       def inspect

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

@@ -10,16 +10,6 @@ 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
 
@@ -55,30 +45,6 @@ module Contrek
         node.after_add(self)
       end
 
-      def replace!(queueable)
-        reset!
-        append(queueable)
-      end
-
-      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 move_from(queueable, &block)
         queueable.rewind!
         while (node = queueable.iterator)
@@ -87,13 +53,6 @@ module Contrek
         end
       end
 
-      def reset!
-        @head = nil
-        @tail = nil
-        @size = 0
-        @iterator = 0
-      end
-
       # from yield: false => stop, true => continue
       def each(&block)
         last = nil
@@ -152,23 +111,6 @@ module Contrek
       def pop!
         rem(@tail)
       end
-
-      def remove_adjacent_pairs!
-        unless @tail.nil?
-          pointer = @tail
-          loop do
-            break if pointer == @head
-            if pointer.payload == pointer.prev&.payload
-              later = pointer.next
-              rem pointer.prev
-              rem pointer
-              pointer = later.nil? ? @tail : later
-              redo
-            end
-            break unless (pointer = pointer.prev)
-          end
-        end
-      end
     end
   end
 end

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

@@ -31,10 +31,6 @@ module Contrek
         assign_raw_polygons!(result[:polygons], result.metadata[:treemap])
       end
 
-      def boundary_shapes
-        @bbs ||= shapes.select { |s| s.outer_polyline.boundary? }
-      end
-
       def iterate
         @shapes.each do |shape|
           shape.outer_polyline.raw.each do |position|

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

@@ -28,13 +28,17 @@ module Contrek
       def transpose(result)
         result.metadata[:width], result.metadata[:height] = result.metadata[:height], result.metadata[:width]
         result.polygons.each do |polygon|
-          polygon[:outer].each { |p| p[:x], p[:y] = p[:y], p[:x] }
-          polygon[:inner].each do |sequence|
-            sequence.each { |p| p[:x], p[:y] = p[:y], p[:x] }
+          invert_point = ->(p) { {x: p[:y], y: p[:x]} }
+          polygon[:outer] = polygon[:outer].map(&invert_point)
+          polygon[:inner] = polygon[:inner].map do |sequence|
+            sequence.map(&invert_point)
           end
           if polygon.key?(:bounds)
-            polygon[:bounds][:min_x], polygon[:bounds][:min_y] = polygon[:bounds][:min_y], polygon[:bounds][:min_x]
-            polygon[:bounds][:max_x], polygon[:bounds][:max_y] = polygon[:bounds][:max_y], polygon[:bounds][:max_x]
+            b = polygon[:bounds]
+            polygon[:bounds] = {
+              min_x: b[:min_y], min_y: b[:min_x],
+              max_x: b[:max_y], max_y: b[:max_x]
+            }
           end
         end
         result

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.1.8"
+  VERSION = "1.2.0"
 end