contrek 1.0.6 → 1.0.8

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -8,11 +8,11 @@
 
 #include <iostream>
 #include <list>
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
 #include <vector>
 #include <map>
 #include <string>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 #include "PolygonFinder/src/polygon/finder/PolygonFinder.h"
 #include "PolygonFinder/src/polygon/finder/PolygonFinder.cpp"
@@ -86,142 +86,133 @@ extern "C" {
   #include "PolygonFinder/src/polygon/bitmaps/spng.h"
 }
 
-using namespace Rice;
-
-namespace Rice::detail
-{ template<>
-  class To_Ruby<std::vector<Point*>>
-  { public:
-      VALUE convert(const std::vector<Point*>& x)
-      { Rice::Array arr;
-        for (Point* p : x)
-          arr.push(p);
-        return arr;
-      }
-  };
-
-  template<>
-  class To_Ruby<std::list<std::vector<Point*>>>
-  { public:
-      VALUE convert(const std::list<std::vector<Point*>>& x)
-      { Rice::Array arr;
-        for (const std::vector<Point*>& vec : x)
-        { arr.push(vec);
-        }
-        return arr;
-      }
-  };
+class RubyResult {
+ public:
+  Rice::Array polygons;
+  Rice::Hash metadata;
+};
 
-  template<>
-  class To_Ruby<Point*>
-  { public:
-      VALUE convert(Point* const & x)
-      {  Rice::Hash h = Rice::Hash();
-         h[Symbol("x")] = x->x;
-         h[Symbol("y")] = x->y;
-         return(h);
-      }
-  };
+using namespace Rice;
 
-  template<>
-  class To_Ruby<std::map<std::string, double>*>
-  { public:
-      VALUE convert(std::map<std::string, double>* const & x)
-      { Rice::Hash return_me = Rice::Hash();
-        std::map<std::string, double>::iterator it;
-        for ( it = x->begin(); it != x->end(); it++ )
-        {  return_me[String(it->first)] = it->second;
-        }
-        return return_me;
-      }
-  };
+namespace Rice::detail {
 
-  template<>
-  class From_Ruby<std::vector<std::string>*>
-  { public:
-    Convertible is_convertible(VALUE value)
-    { switch (rb_type(value))
-      { case RUBY_T_HASH:
-          return Convertible::Cast;
+template<>
+class From_Ruby<std::vector<std::string>*>
+{ public:
+  Convertible is_convertible(VALUE value)
+  { switch (rb_type(value))
+    { case RUBY_T_HASH:
+        return Convertible::Cast;
+        break;
+      default:
+        return Convertible::None;
+    }
+  }
+  std::vector<std::string>* convert(VALUE value)
+  { std::vector<std::string> *arguments = new std::vector<std::string>();
+    if (rb_type(value) == RUBY_T_NIL) return(arguments);
+    Rice::Hash hash = (Rice::Hash) value;
+    for (Rice::Hash::iterator it = hash.begin(); it != hash.end(); ++it) {
+      Rice::String keyString = it->key.to_s();
+      Rice::Object value = it->value;
+      switch (value.rb_type()) {
+        case T_STRING:
+          arguments->push_back("--" + keyString.str()+"="+((Rice::String) value).str());
           break;
-        default:
-          return Convertible::None;
-      }
+        case T_SYMBOL:
+          arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
+          break;
+        case T_FLOAT:
+          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
+          break;
+        case T_FIXNUM:
+          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
+          break;
+        case T_TRUE:
+          arguments->push_back("--" + keyString.str()+"=true");
+          break;
+        case T_FALSE:
+          arguments->push_back("--" + keyString.str()+"=false");
+          break;
+        case T_HASH:
+          std::vector<std::string>* iv = From_Ruby<std::vector<std::string>*>::convert(value);
+          for (std::vector<std::string>::iterator it_iv = iv->begin() ; it_iv != iv->end(); ++it_iv)
+          { (*it_iv).replace(0, 2, "_");
+            arguments->push_back("--" + keyString.str() + *it_iv);
+          }
+          break;
+       }
     }
-    std::vector<std::string>* convert(VALUE value)
-    { std::vector<std::string> *arguments = new std::vector<std::string>();
-      if (rb_type(value) == RUBY_T_NIL) return(arguments);
-      Rice::Hash hash = (Rice::Hash) value;
-      for (Rice::Hash::iterator it = hash.begin(); it != hash.end(); ++it) {
-        Rice::String keyString = it->key.to_s();
-        Rice::Object value = it->value;
-        switch (value.rb_type()) {
-          case T_STRING:
-            arguments->push_back("--" + keyString.str()+"="+((Rice::String) value).str());
-            break;
-          case T_SYMBOL:
-            arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
-            break;
-          case T_FLOAT:
-            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
-            break;
-          case T_FIXNUM:
-            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
-            break;
-          case T_TRUE:
-            arguments->push_back("--" + keyString.str()+"=true");
-            break;
-          case T_FALSE:
-            arguments->push_back("--" + keyString.str()+"=false");
-            break;
-          case T_HASH:
-            std::vector<std::string>* iv = From_Ruby<std::vector<std::string>*>::convert(value);
-            for (std::vector<std::string>::iterator it_iv = iv->begin() ; it_iv != iv->end(); ++it_iv)
-            { (*it_iv).replace(0, 2, "_");
-              arguments->push_back("--" + keyString.str() + *it_iv);
-            }
-            break;
-         }
-      }
-      return arguments;
+    return arguments;
+  }
+};
+
+template<>
+class To_Ruby<ProcessResult*>
+{public:
+  VALUE convert(ProcessResult* const & pr)
+  { if (!pr) {
+      return Qnil;
     }
-  };
+    RubyResult* rr = new RubyResult();
+    Rice::Data_Object<RubyResult> rb_result(rr);
 
-  template<>
-  struct Type<ProcessResult>
-  { static bool verify()
-    { return true;
+    Rice::Hash return_me = Rice::Hash();
+    Rice::Hash benchmarks_rb;
+    for (auto const& [name, value] : pr->benchmarks) {
+      benchmarks_rb[Rice::String(name)] = value;
     }
-  };
+    return_me[Symbol("benchmarks")] = benchmarks_rb;
+    return_me[Symbol("groups")] = pr->groups;
+    return_me[Symbol("named_sequence")] = pr->named_sequence;
 
-  template<>
-  class To_Ruby<ProcessResult*>
-  { public:
-    VALUE convert(ProcessResult* const & pr)
-    { Rice::Hash return_me = Rice::Hash();
-      return_me[Symbol("benchmarks")] = &pr->benchmarks;
-      return_me[Symbol("groups")] = pr->groups;
-      return_me[Symbol("named_sequence")] = pr->named_sequence;
-      Rice::Array out;
-      for (Polygon& x : pr->polygons)
-      { Rice::Hash h = Rice::Hash();
-        h[Symbol("outer")] = x.outer;
-        h[Symbol("inner")] = x.inner;
-        out.push(h);
+    Rice::Array out;
+    for (Polygon& x : pr->polygons)
+    { Rice::Hash poly_hash = Rice::Hash();
+      // OUTER: std::vector<Point*>
+      Rice::Array outer_flat;
+      for (Point* p : x.outer) {
+        outer_flat.push(p->x);
+        outer_flat.push(p->y);
       }
-      return_me[Symbol("polygons")] = out;
-      Rice::Array tmapout;
-      for (const auto& tm : pr->treemap) {
-        Rice::Array tmentry;
-        tmentry.push(tm.first);   // outer
-        tmentry.push(tm.second);  // inner
-        tmapout.push(tmentry);
+      poly_hash[Symbol("outer")] = outer_flat;
+      // INNER: std::list<std::vector<Point*>>
+      Rice::Array inner_collection;
+      for (const std::vector<Point*>& sequence : x.inner) {
+        Rice::Array sequence_flat;
+        for (Point* p : sequence) {
+          sequence_flat.push(p->x);
+          sequence_flat.push(p->y);
+        }
+        inner_collection.push(sequence_flat);
       }
-      return_me[Symbol("treemap")] = tmapout;
-      delete pr;
-      return(return_me);
+      poly_hash[Symbol("inner")] = inner_collection;
+      out.push(poly_hash);
+    }
+    rr->polygons = out;
+
+    // Treemap
+    Rice::Array tmapout;
+    for (const auto& tm : pr->treemap) {
+      Rice::Array tmentry;
+      tmentry.push(tm.first);
+      tmentry.push(tm.second);
+      tmapout.push(tmentry);
     }
-  };
+    return_me[Symbol("treemap")] = tmapout;
+    rr->metadata = return_me;
+
+    // Protects objects 'out' e 'return_me' linking them to the ruby instance preventing GC
+    // garbage collector to free them before the instance itself.
+    Rice::Object ruby_obj = rb_result;
+    ruby_obj.iv_set("@polygons_storage", out);
+    ruby_obj.iv_set("@metadata_storage", return_me);
+
+    delete pr;
+    return rb_result.value();
+  }
+};
+
 }  // namespace Rice::detail
 
 extern "C"
@@ -276,17 +267,23 @@ void Init_cpp_polygon_finder() {
 
   Data_Type<RGBNotMatcher> rb_cRGBNotMatcher =
     define_class<RGBNotMatcher, Matcher>("CPPRGBNotMatcher")
-    .define_constructor(Constructor<RGBNotMatcher, int>())
+    .define_constructor(Constructor<RGBNotMatcher, unsigned int>())
     .define_method("match", &RGBNotMatcher::match);
 
   Data_Type<PolygonFinder> rb_cPolygonFinder =
     define_class<PolygonFinder>("CPPPolygonFinder")
-    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, std::vector<std::string>*>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = nullptr)
+    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, std::vector<std::string>*>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
     .define_method("get_shapelines", &PolygonFinder::get_shapelines)
-    .define_method("process_info", &PolygonFinder::process_info);
+    .define_method("process_info", &PolygonFinder::process_info, Rice::Arg("yield_gvl") = true);
 
   Data_Type<Finder> rb_cFinder =
     define_class<Finder>("CPPFinder")
-    .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = nullptr)
-    .define_method("process_info", &Finder::process_info);
+    .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
+    .define_method("process_info", &Finder::process_info, Rice::Arg("yield_gvl") = true);
+
+  Data_Type<RubyResult> rb_cResult =
+    define_class_under<RubyResult>(rb_cFinder, "Result")
+    .define_constructor(Constructor<RubyResult>())
+    .define_method("polygons", [](RubyResult& rr) { return rr.polygons; })
+    .define_method("metadata", [](RubyResult& rr) { return rr.metadata; });
 }

data/lib/contrek/bitmaps/rgb_color.rb

@@ -3,23 +3,8 @@ module Contrek
     class RgbColor
       attr_reader :raw
       def initialize(r:, g:, b:, a: 255)
-        @r = r
-        @g = g
-        @b = b
-        @a = a
         @raw = (r << 24) + (g << 16) + (b << 8) + a
       end
-
-      def to_rgb_raw
-        @raw >> 8
-      end
-
-      def self.reverse_raw(raw)
-        [:a, :b, :g, :r].each_with_object({}) do |c, h|
-          h[c] = raw & 0xFF
-          raw >>= 8
-        end
-      end
     end
   end
 end

data/lib/contrek/bitmaps/rgb_cpp_color.rb

@@ -0,0 +1,10 @@
+module Contrek
+  module Bitmaps
+    class RgbCppColor
+      attr_reader :raw
+      def initialize(r:, g:, b:, a: 255)
+        @raw = (a << 24) | (b << 16) | (g << 8) | r
+      end
+    end
+  end
+end

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

@@ -3,10 +3,10 @@ module Contrek
     class Cluster
       attr_reader :tiles, :hub
 
-      def initialize(finder:, height:, width:)
+      def initialize(finder:, height:, start_x:, end_x:)
         @finder = finder
         @tiles = []
-        @hub = Hub.new(height:, width:)
+        @hub = Hub.new(start_x:, end_x:)
       end
 
       def add(tile)

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

@@ -54,34 +54,51 @@ module Contrek
             missing_shapes << shape
           end
         end
+        to_delay = connect_missings(missing_shapes)
+        while to_delay.any?
+          to_delay = connect_missings(to_delay)
+        end
+
+        retme = collect_inner_sequences(outer_seq)
+
+        @polylines_sequence.each do |polyline|
+          polyline.turn_on(Polyline::TRACKED_INNER)
+        end
+        retme
+      end
+
+      private
+
+      def connect_missings(missing_shapes)
+        delay_shapes = []
+
         @polylines_sequence.each do |polyline|
           missing_shapes.each do |missing_shape|
-            outer_polyline = missing_shape.outer_polyline
-            next unless polyline.vert_intersect?(outer_polyline)
-            if (intersection = polyline.intersection(outer_polyline)).any?
-              inject_sequences_left, inject_sequences_right = polyline.sew!(intersection, outer_polyline)
+            missing_outer_polyline = missing_shape.outer_polyline
+            next if missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
+              !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!
                 @orphan_inners << sewn_sequence if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # segmenti non sono ammessi, solo aree
               end
-              outer_polyline.clear!
-              outer_polyline.turn_on(Polyline::TRACKED_OUTER)
-              outer_polyline.turn_on(Polyline::TRACKED_INNER)
+              missing_outer_polyline.clear!
+              missing_outer_polyline.turn_on(Polyline::TRACKED_OUTER)
+              missing_outer_polyline.turn_on(Polyline::TRACKED_INNER)
               @orphan_inners += missing_shape.inner_polylines
             end
           end
         end
 
-        retme = collect_inner_sequences(outer_seq)
-
-        @polylines_sequence.each do |polyline|
-          polyline.turn_on(Polyline::TRACKED_INNER)
-        end
-        retme
+        delay_shapes
       end
 
-      private
-
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, polylines, shapes, outer_joined_polyline)
         all_parts << act_part if all_parts.last != act_part

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

@@ -74,14 +74,17 @@ module Contrek
           end
         end.real
 
-        {polygons: raw_polygons,
-         benchmarks: {
-           total: ((@initialize_time + compress_time) * 1000).round(3),
-           init: (@initialize_time * 1000).round(3),
-           outer: (@whole_tile.benchmarks[:outer] * 1000).round(3),
-           inner: (@whole_tile.benchmarks[:inner] * 1000).round(3),
-           compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
-         }.compact}
+        metadata = {
+          groups: raw_polygons.size,
+          benchmarks: {
+            total: ((@initialize_time + compress_time) * 1000).round(3),
+            init: (@initialize_time * 1000).round(3),
+            outer: (@whole_tile.benchmarks[:outer] * 1000).round(3),
+            inner: (@whole_tile.benchmarks[:inner] * 1000).round(3),
+            compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
+          }.compact
+        }
+        Contrek::Finder::Result.new(raw_polygons, metadata)
       end
 
       private
@@ -95,7 +98,18 @@ module Contrek
             return
           end
           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)
+              start_x = tile.start_x
+              end_x = twin_tile.end_x
+            else
+              start_x = twin_tile.start_x
+              end_x = tile.end_x
+            end
+
+            # puts "start = #{start_x} end = #{end_x}"
+
+            cluster = Cluster.new(finder: self, height: bitmap.h, start_x:, end_x:)
             if twin_tile.start_x == (tile.end_x - 1)
               cluster.add(tile)
               cluster.add(twin_tile)

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

@@ -2,8 +2,8 @@ module Contrek
   module Concurrent
     class Hub
       attr_reader :payloads, :width
-      def initialize(height:, width:)
-        @width = width
+      def initialize(start_x:, end_x:)
+        @width = end_x - start_x
         # @payloads = Array.new(width * height)
         @payloads = {}
       end

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

@@ -8,7 +8,7 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted
+      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted, :delayed
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
@@ -19,12 +19,17 @@ module Contrek
         @touched = false
         @inverts = false
         @trasmuted = false
+        @delayed = false
       end
 
       def is?(type)
         @type == type
       end
 
+      def set_polyline(polyline)
+        @polyline = polyline
+      end
+
       def add_position(position)
         add(Position.new(position: position, hub: polyline.tile.cluster.hub))
       end

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

@@ -16,6 +16,15 @@ module Contrek
         new_part.prev = last
       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)
         @parts.find do |part|
           part.is?(Part::SEAM) &&
@@ -57,48 +66,67 @@ module Contrek
       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
+        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]
 
-        # 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 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
 
-        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?
+        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
-        (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)
+
+        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
-        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?
+
+        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
-        [left, right]
+        insert_after(will_be_last, new_end_part)
+
+        reset_tracked_endpoints!
+
+        returning_data
       end
 
       private