contrek 1.1.9 → 1.2.0

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

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.9"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 1.2.0
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 2026-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -135,7 +135,6 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
-- LICENSE-MIT.md
 - LICENSE.md
 - README.md
 - Rakefile
@@ -242,6 +241,7 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.h
 - ext/cpp_polygon_finder/cpp_polygon_finder.cpp
 - ext/cpp_polygon_finder/extconf.rb
+- lib/LICENSE-MIT.md
 - lib/contrek.rb
 - lib/contrek/bitmaps/bitmap.rb
 - lib/contrek/bitmaps/chunky_bitmap.rb