contrek 1.0.7 → 1.0.9

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Partitionable.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 #include <utility>
 #include <iostream>
+#include <algorithm>
 #include "Partitionable.h"
 #include "Polyline.h"
 #include "Sequence.h"
@@ -31,6 +32,17 @@ void Partitionable::add_part(Part* new_part)
   new_part->circular_next = this->parts_.front();
 }
 
+void Partitionable::insert_after(Part* part, Part* new_part) {
+  auto it = std::find(parts_.begin(), parts_.end(), part);
+  if (it != parts_.end()) parts_.insert(it + 1, new_part);
+  new_part->prev = part;
+  new_part->next = part->next;
+  new_part->circular_next = part->next;
+  if (part->next) part->next->prev = new_part;
+  part->next = new_part;
+  part->circular_next = new_part;
+}
+
 void Partitionable::partition()
 { this->parts_.clear();
   Polyline *polyline = dynamic_cast<Polyline*>(this);
@@ -73,85 +85,115 @@ Part* Partitionable::find_first_part_by_position(Position* position) {
   return(nullptr);
 }
 
-std::pair<
-std::vector<std::vector<Point*>>,
-    std::vector<std::vector<Point*>>
->
-Partitionable::sew(std::vector<Point*> intersection, Polyline* other)
-{   std::vector<int> matching_part_indexes;
-  for (int i = 0; i < static_cast<int>(parts_.size()); ++i) {
-    Part* part = parts_[i];
-    if (!part || part->trasmuted) continue;
-    if (part->intersection_with_array(intersection)) {
-      matching_part_indexes.push_back(i);
-    }
-  }
+std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>> intersection, Polyline* other)
+{ std::vector<int> matching_part_indexes;
   std::vector<int> other_matching_part_indexes;
-  for (int i = 0; i < static_cast<int>(other->parts_.size()); ++i) {
-    Part* part = other->parts_[i];
-    if (!part || part->trasmuted) continue;
-    if (part->intersection_with_array(intersection)) {
-        other_matching_part_indexes.push_back(i);
-    }
+  matching_part_indexes.reserve(intersection.size());
+  other_matching_part_indexes.reserve(intersection.size());
+
+  // traspose
+  for (const auto& pair : intersection) {
+    matching_part_indexes.push_back(pair.first);
+    other_matching_part_indexes.push_back(pair.second);
   }
-  std::vector<Part*> before_parts;
-  for (int i = other_matching_part_indexes.back() + 1;
-       i < static_cast<int>(other->parts_.size()); ++i)
-  { before_parts.push_back(other->parts_[i]);
+  std::sort(matching_part_indexes.begin(), matching_part_indexes.end());
+  std::sort(other_matching_part_indexes.begin(), other_matching_part_indexes.end());
+
+  auto start_it_before = other->parts_.begin() + other_matching_part_indexes.back() + 1;
+  auto end_it_before   = other->parts_.end();
+  std::vector<Part*> before_parts(start_it_before, end_it_before);
+  auto start_it_after = other->parts_.begin();
+  auto end_it_after   = other->parts_.begin() + other_matching_part_indexes.front();
+  std::vector<Part*> after_parts(start_it_after, end_it_after);
+
+  int start_idx = matching_part_indexes.front();
+  int end_idx  = matching_part_indexes.back();
+  Part* part_start = parts_[start_idx];
+  Part* part_end   = parts_[end_idx];
+
+  auto collect_sequences = [&](const std::vector<int>& indices, std::vector<Part*>& p_list)
+    -> std::vector<std::vector<Point*>> {
+    std::vector<std::vector<Point*>> result;
+    int last_n = -1;
+    if (indices.size() < 2) return result;
+    for (int n = indices.front() + 1; n < indices.back(); ++n) {
+      if (std::find(indices.begin(), indices.end(), n) == indices.end()) {
+        Part* part = p_list[n];
+        if (part->is(Part::SEAM) && part->size > 0 && !part->delayed) {
+          part->delayed = true;
+          result.clear();
+          result.push_back({nullptr});
+          return result;
+        }
+        if (last_n == (n - 1) && !result.empty()) {
+          std::vector<Point*> pts = part->to_vector();
+          result.back().insert(result.back().end(), pts.begin(), pts.end());
+        } else {
+          result.push_back(part->to_vector());
+        }
+        last_n = n;
+      }
+    }
+    return result;
+  };
+  auto left = collect_sequences(matching_part_indexes, this->parts_);
+  if (!left.empty() && !left[0].empty() && left[0][0] == nullptr) {
+    return std::nullopt;
   }
-  std::vector<Part*> after_parts;
-  for (int i = 0; i < other_matching_part_indexes.front(); ++i) {
-    after_parts.push_back(other->parts_[i]);
+  auto right = collect_sequences(other_matching_part_indexes, other->parts_);
+  if (!right.empty() && !right[0].empty() && right[0][0] == nullptr) {
+    return std::nullopt;
   }
-  Part* part_start = parts_[matching_part_indexes.front()];
-  Part* part_end   = parts_[matching_part_indexes.back()];
-  // They are inverted since they traverse in opposite directions
-  Sequence sequence;
-  sequence.add(part_start->head);
-  for (Part* p : before_parts) sequence.append(*p);
-  for (Part* p : after_parts) sequence.append(*p);
-  if (part_end->tail) sequence.add(part_end->tail);
-  part_start->replace(sequence);
-  part_start->type = Part::EXCLUSIVE;
-  if (part_start != part_end) part_end->reset();
-
-  std::vector<std::vector<Point*>> left;
-
-  for (int n = matching_part_indexes.front() + 1;
-       n <= matching_part_indexes.back() - 1;
-       ++n)
-  { if (std::find(matching_part_indexes.begin(),
-                  matching_part_indexes.end(),
-                  n) == matching_part_indexes.end())
-    { auto pts = parts_[n]->to_vector();
-      left.push_back(pts);
+
+  if (part_start != part_end) {
+    for (int n = end_idx - 1; n > start_idx; --n) {
+      Part* delete_part = parts_[n];
+      // Topological detachment of pointers
+      if (delete_part->prev) delete_part->prev->next = delete_part->next;
+      if (delete_part->next) delete_part->next->prev = delete_part->prev;
+      parts_.erase(parts_.begin() + n);
     }
   }
 
-  // delete parts in reverse order
-  for (int n = matching_part_indexes.back() - 1;
-       n >= matching_part_indexes.front() + 1;
-       --n)
-  { Part* delete_part = parts_[n];
-    if (delete_part->prev) delete_part->prev->next = delete_part->next;
-    if (delete_part->next) delete_part->next->prev = delete_part->prev;
-    parts_.erase(parts_.begin() + n);
+  std::vector<Part*> all_parts;
+  Polyline* polyline = dynamic_cast<Polyline*>(this);
+  all_parts.reserve(before_parts.size() + after_parts.size());
+  all_parts.insert(all_parts.end(), before_parts.begin(), before_parts.end());
+  all_parts.insert(all_parts.end(), after_parts.begin(), after_parts.end());
+  Part* will_be_last = all_parts.empty() ? nullptr : all_parts.back();
+  for (auto it = all_parts.rbegin(); it != all_parts.rend(); ++it) {
+    Part* p = *it;
+    this->insert_after(part_start, p);
+    auto& op = other->parts_;
+    op.erase(std::remove(op.begin(), op.end(), p), op.end());
+    p->set_polyline(polyline);
   }
 
-  std::vector<std::vector<Point*>> right;
-  for (int n = other_matching_part_indexes.front() + 1;
-       n <= other_matching_part_indexes.back() - 1;
-       ++n)
-  { if (std::find(other_matching_part_indexes.begin(),
-                  other_matching_part_indexes.end(),
-                  n) == other_matching_part_indexes.end())
-    { auto pts = other->parts_[n]->to_vector();
-      right.push_back(pts);
+  part_start->type = Part::EXCLUSIVE;
+  PartPool& pool = polyline->tile->cluster->parts_pool;
+  Part* new_end_part = pool.acquire(Part::EXCLUSIVE, polyline);
+  new_end_part->add(part_end->tail);
+  part_start->singleton();
+
+  // deletes part_end
+  if (part_start != part_end) {
+    if (part_end->prev) part_end->prev->next = part_end->next;
+    if (part_end->next) part_end->next->prev = part_end->prev;
+    auto it = std::find(parts_.begin(), parts_.end(), part_end);
+    if (it != parts_.end()) {
+      parts_.erase(it);
     }
   }
-  return { left, right };
+
+  Part* reference_part = (will_be_last != nullptr) ? will_be_last : part_start;
+  this->insert_after(reference_part, new_end_part);
+
+  polyline->reset_tracked_endpoints();
+
+  return std::make_pair(left, right);
 }
 
+
 void Partitionable::trasmute_parts()
 { std::vector<Part*> insides;
   for (Part* p : parts_) {

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Partitionable.h

@@ -9,22 +9,24 @@
 #pragma once
 #include <vector>
 #include <utility>
+#include <optional>
 #include "Part.h"
 
+using SewReturnData = std::pair<std::vector<std::vector<Point*>>, std::vector<std::vector<Point*>>>;
+
 class Partitionable {
  public:
   explicit Partitionable() {}
   virtual ~Partitionable() = default;
   void partition();
   Part* find_first_part_by_position(Position* position);
-  std::pair<
-    std::vector<std::vector<Point*>>,
-    std::vector<std::vector<Point*>>> sew(std::vector<Point*> intersection, Polyline* other);
+  std::optional<SewReturnData> sew(std::vector<std::pair<int, int>> intersection, Polyline* other);
 
  protected:
   std::vector<Part*> parts_;
 
  private:
   void add_part(Part* new_part);
+  void insert_after(Part* part, Part* new_part);
   void trasmute_parts();
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Polyline.cpp

@@ -48,6 +48,10 @@ bool Polyline::boundary() {
   return( tile->tg_border(Point{min_x, 0}) || tile->tg_border(Point{max_x, 0}));
 }
 
+void Polyline::reset_tracked_endpoints() {
+  tracked_endpoints.clear();
+}
+
 void Polyline::find_boundary() {
   if (raw_.empty()) return;
   min_x =  std::numeric_limits<int>::max();
@@ -65,40 +69,43 @@ void Polyline::find_boundary() {
   }
 }
 
-struct PointHash {
-  size_t operator()(const Point* p) const {
-    if (!p) return 0;
-    std::hash<double> hasher;
-    size_t h1 = hasher(p->x);
-    size_t h2 = hasher(p->y);
-    return h1 ^ (h2 << 1);
-  }
-};
-
-struct PointEqual {
-  bool operator()(const Point* p1, const Point* p2) const {
-    if (!p1 || !p2) return p1 == p2;
-    return *p1 == *p2;
+std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) const {
+  if (this->tracked_endpoints.empty()) {
+    for (int i = 0; i < parts_.size(); ++i) {
+      auto& part = parts_[i];
+      if (!part->is(Part::SEAM) && part->trasmuted) continue;
+      part->each([&](QNode<Point>* pos) -> bool {
+        Position *position = dynamic_cast<Position*>(pos);
+        if (position->end_point() != nullptr)
+        { this->tracked_endpoints[position->end_point()] = i;
+        }
+        return true;
+      });
+    }
   }
-};
 
-std::vector<Point*> Polyline::intersection(const Polyline* other) const {
-  std::vector<Point*> result;
-  if (!other) return result;
-  std::unordered_set<Point*, PointHash, PointEqual> other_set;
-  other_set.reserve(other->raw().size());
-  for (Point* p : other->raw()) {
-    if (p) other_set.insert(p);
-  }
-  for (Point* p : raw_) {
-    if (!p) continue;
-    if (other_set.count(p)) {
-      result.push_back(p);
+  std::vector<std::pair<int, int>> matching_parts;
+  for (int j = 0; j < other->parts_.size(); ++j) {
+    auto& other_part = other->parts_[j];
+    if (!other_part->is(Part::SEAM) && other_part->trasmuted) {
+      continue;
     }
+    other_part->each([&](QNode<Point>* pos) -> bool {
+      Position *position = dynamic_cast<Position*>(pos);
+      auto it = this->tracked_endpoints.find(position->end_point());
+      if (it != this->tracked_endpoints.end()) {
+        int self_index = it->second;
+        matching_parts.push_back({self_index, j});
+        return false;
+      }
+      return true;
+    });
   }
-  return result;
+
+  return matching_parts;
 }
 
+
 void Polyline::clear() {
   this->raw_.clear();
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Polyline.h

@@ -10,7 +10,9 @@
 #include <list>
 #include <cstdint>
 #include <optional>
+#include <utility>
 #include <vector>
+#include <unordered_map>
 #include "Partitionable.h"
 #include "../RectBounds.h"
 
@@ -37,11 +39,12 @@ class Polyline : public Partitionable {
   std::vector<Point*> raw() const { return raw_; }
   const std::list<Shape*>& next_tile_eligible_shapes() const { return next_tile_eligible_shapes_; }
   const std::vector<Part*>& parts() const { return parts_; }
-  std::vector<Point*> intersection(const Polyline* other) const;
+  std::vector<std::pair<int, int>> intersection(const Polyline* other) const;
   const int max_y() const { return max_y_; }
   void clear();
   bool is_empty();
   bool vert_intersect(Polyline& other);
+  void reset_tracked_endpoints();
 
  private:
   std::vector<Point*> raw_;
@@ -49,4 +52,5 @@ class Polyline : public Partitionable {
   void find_boundary();
   uint32_t flags_ = 0;
   std::list<Shape*> next_tile_eligible_shapes_;
+  mutable std::unordered_map<const EndPoint*, int> tracked_endpoints;
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Position.cpp

@@ -11,21 +11,24 @@
 
 Position::Position(Hub* hub, Point* point)
 : QNode<Point>(point)
-{ int key = point->y * hub->width() + point->x;
-  EndPoint* existing_ep = hub->get(key);
-  if (existing_ep == nullptr)
-  { end_point_ = hub->spawn_end_point();
-    hub->put(key, end_point_);
-  } else {
-    end_point_ = existing_ep;
+{ if (hub != nullptr) {
+    int key = point->y;
+    EndPoint* existing_ep = hub->get(key);
+    if (existing_ep == nullptr)
+    { end_point_ = hub->put(key, hub->spawn_end_point());
+    } else {
+      end_point_ = existing_ep;
+    }
   }
 }
 
 void Position::before_rem(Queueable<Point>* q)  {
-  auto& queues = this->end_point_->queues();
-  queues.erase(std::remove(queues.begin(), queues.end(), q), queues.end());
+  if (this->end_point_ != nullptr) {
+    auto& queues = this->end_point_->queues();
+    queues.erase(std::remove(queues.begin(), queues.end(), q), queues.end());
+  }
 }
 
 void Position::after_add(Queueable<Point>* q)  {
-  this->end_point_->queues().push_back(q);
+  if (this->end_point_ != nullptr) this->end_point_->queues().push_back(q);
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Position.h

@@ -21,5 +21,5 @@ class Position : public QNode<Point>{
   void before_rem(Queueable<Point>* q) override;
   void after_add(Queueable<Point>* q) override;
  private:
-  EndPoint* end_point_;
+  EndPoint* end_point_ = nullptr;
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Queueable.h

@@ -43,8 +43,7 @@ class Queueable {
 
   QNode<T>* rem(QNode<T>* node) {
     if (!node) return nullptr;
-    if (node->owner != this)
-        throw std::runtime_error("Not my node");
+    // if (node->owner != this) throw std::runtime_error("Not my node");
     node->before_rem(this);
     if (node->prev) node->prev->next = node->next;
     if (node->next) node->next->prev = node->prev;
@@ -79,9 +78,21 @@ class Queueable {
     head = nullptr;
     tail = nullptr;
     _iterator = nullptr;
+    _started = false;
     size = 0;
   }
 
+  void singleton()
+  { if (head && head->next) {
+      head->next->prev = nullptr;
+      head->next = nullptr;
+    }
+    tail = nullptr;
+    size = 1;
+    _iterator = nullptr;
+    _started = false;
+  }
+
   void replace(Queueable<T>& q) {
     reset();
     append(q);
@@ -130,8 +141,8 @@ class Queueable {
   }
 
   void next_of(QNode<T>* node) {
-    if (!node)  throw std::runtime_error("nil node");
-    if (node->owner != this) throw std::runtime_error("wrong node");
+    // if (!node)  throw std::runtime_error("nil node");
+    // if (node->owner != this) throw std::runtime_error("wrong node");
     _iterator = node->next;
     _started = true;
   }
@@ -181,23 +192,6 @@ class Queueable {
       return out;
   }
 
-  bool intersection_with_array(const std::vector<T*>& array) {
-    if (array.empty() || size == 0) return false;
-
-    QNode<T>* current = head;
-    while (current) {
-      if (current->payload) {
-        for (T* item : array) {
-          if (item && *item == *(current->payload)) {
-            return true;
-          }
-        }
-      }
-      current = current->next;
-    }
-    return false;
-  }
-
   QNode<T>* pop() {
     if (!tail) return nullptr;
     return rem(tail);
@@ -220,7 +214,7 @@ class Queueable {
 
     for (T* current : source) {
       if (!result.empty() && *result.back() == *current) {
-          result.pop_back();  // "Annulla" la coppia invece di ricominciare
+          result.pop_back();
       } else {
           result.push_back(current);
       }

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -267,7 +267,7 @@ 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 =

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(height:, 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
@@ -165,7 +182,8 @@ module Contrek
             else
               act_part.polyline.next_tile_eligible_shapes.each do |shape|
                 shape.outer_polyline.parts.each do |dest_part|
-                  next if dest_part.trasmuted
+                  next if dest_part.trasmuted || dest_part.is?(Part::EXCLUSIVE)
+
                   if dest_part.intersect_part?(act_part)
                     link_seq = duplicates_intersection(dest_part, act_part)
                     if link_seq.any?

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

@@ -98,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

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