contrek 1.0.6 → 1.0.8

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,41 @@ 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);
+        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,11 +11,10 @@
 
 Position::Position(Hub* hub, Point* point)
 : QNode<Point>(point)
-{ int key = point->y * hub->width() + point->x;
+{ int key = point->y * hub->width() + (point->x - hub->start_x());
   EndPoint* existing_ep = hub->get(key);
   if (existing_ep == nullptr)
-  { end_point_ = hub->spawn_end_point();
-    hub->put(key, end_point_);
+  { end_point_ = hub->put(key, hub->spawn_end_point());
   } else {
     end_point_ = existing_ep;
   }

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

@@ -79,9 +79,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 +142,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 +193,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 +215,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);
       }