contrek 1.0.4 → 1.0.6

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

@@ -0,0 +1,40 @@
+/*
+ * Hub.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include <deque>
+#include "EndPoint.h"
+
+class EndPoint;
+class Hub {
+ public:
+  explicit Hub(int height, int width);
+  EndPoint* spawn_end_point();
+  const int width() const { return width_; }
+  inline EndPoint* get(int key) const {
+    if (!is_set(key)) return nullptr;
+    return payloads_[key];
+  }
+  inline void put(int key, EndPoint* payload) {
+    payloads_[key] = payload;
+    bitset_[key >> 6] |= (1ULL << (key & 63));
+  }
+  inline bool is_set(int key) const {
+    return (bitset_[key >> 6] & (1ULL << (key & 63)));
+  }
+
+ private:
+  int width_;
+  int height_;
+  std::vector<EndPoint*> payloads_;
+  std::deque<EndPoint> endpoint_pool_;
+  Hub(const Hub&) = delete;
+  Hub& operator=(const Hub&) = delete;
+  std::vector<uint64_t> bitset_;
+};

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

@@ -0,0 +1,70 @@
+/*
+ * Part.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Part.h"
+#include <iostream>
+#include "Polyline.h"
+#include "Tile.h"
+#include "Cluster.h"
+
+Part::Part(Types type, Polyline* polyline)
+: type(type),
+  polyline_(polyline) {
+}
+
+bool Part::is(Types type)
+{ return(this->type == type);
+}
+
+Position* Part::next_position(Position* force_position) {
+  if (force_position != nullptr)
+  { QNode<Point>* move_to_this = nullptr;
+    this->reverse_each([&](QNode<Point>* pos) -> bool {
+      if (*(pos->payload) == *(force_position->payload)) {
+        move_to_this = pos;
+        return false;
+      }
+      return true;
+    });
+    if (move_to_this) next_of(move_to_this);
+    return(force_position);
+  } else {
+    if (this->iterator() == nullptr) return(nullptr);
+    Position *position = static_cast<Position*>(this->iterator());
+    this->touched_ = true;
+    this->forward();
+    return(position);
+  }
+}
+
+void Part::add_position(Point* point) {
+  Cluster* c = this->polyline_->tile->cluster;
+  c->positions_pool.emplace_back(c->hub(), point);
+  this->add(&c->positions_pool.back());
+}
+
+bool Part::innerable()
+{  return(!this->touched_ && is(EXCLUSIVE));
+}
+
+void Part::touch()
+{  this->touched_ = true;
+}
+
+bool Part::intersect_part(Part* other_part)
+{ bool intersect = false;
+  other_part->each([&](QNode<Point>* pos) -> bool {
+    Position *position = dynamic_cast<Position*>(pos);
+    if (position->end_point()->queues_include(this))
+    { intersect = true;
+      return(false);
+    }
+    return(true);
+  });
+  return(intersect);
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Part.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <cstdint>
+#include <string>
+#include <deque>
+#include "Queueable.h"
+#include "Position.h"
+#include "../Node.h"
+
+class Polyline;
+class Position;
+class Part : public Queueable<Point> {
+ public:
+  enum Types : uint32_t {
+    SEAM = 1,
+    EXCLUSIVE = 0,
+    ADDED = 2
+  };
+  explicit Part(Types type, Polyline* polyline);
+  bool is(Types type);
+  bool inverts = false;
+  bool trasmuted = false;
+  Part* next = nullptr;
+  Part* prev = nullptr;
+  Part* circular_next = nullptr;
+  std::string toString() const { return "Part type = " + std::to_string(static_cast<uint32_t>(type)); }
+  Polyline* polyline() { return polyline_; }
+  Position* next_position(Position* force_position);
+  void add_position(Point* point);
+  int passes = 0;
+  Types type;
+  bool innerable();
+  const bool touched() const { return touched_; }
+  void touch();
+  bool intersect_part(Part* other_part);
+
+ private:
+  bool touched_ = false;
+  Polyline* polyline_;
+};

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

@@ -0,0 +1,24 @@
+/*
+ * PartPool.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "PartPool.h"
+#include "Part.h"
+#include "Polyline.h"
+
+Part* PartPool::acquire(uint32_t type, Polyline* poly) {
+  storage.emplace_back(static_cast<Part::Types>(type), poly);
+
+  Part* p = &storage.back();
+  p->next = nullptr;
+  p->prev = nullptr;
+  return p;
+}
+
+void PartPool::clear() {
+  storage.clear();
+}

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

@@ -0,0 +1,23 @@
+/*
+ * PartPool.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <deque>
+#include <cstdint>  // for uint32_t
+
+class Part;
+class Polyline;
+
+class PartPool {
+ private:
+  std::deque<Part> storage;
+
+ public:
+  Part* acquire(uint32_t type, Polyline* poly);
+  void clear();
+};

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

@@ -0,0 +1,182 @@
+/*
+ * Partitionable.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <vector>
+#include <utility>
+#include <iostream>
+#include "Partitionable.h"
+#include "Polyline.h"
+#include "Sequence.h"
+#include "Tile.h"
+#include "../Node.h"
+#include "PartPool.h"
+#include "Cluster.h"
+
+class Polyline;
+class Point;
+class Tile;
+
+void Partitionable::add_part(Part* new_part)
+{ Part* last = this->parts_.empty() ? nullptr : this->parts_.back();
+  this->parts_.push_back(new_part);
+  if (last) {
+    last->next = last->circular_next = new_part;
+  }
+  new_part->prev = last;
+  new_part->circular_next = this->parts_.front();
+}
+
+void Partitionable::partition()
+{ this->parts_.clear();
+  Polyline *polyline = dynamic_cast<Polyline*>(this);
+  PartPool& pool = polyline->tile->cluster->parts_pool;
+  Part *current_part = nullptr;
+  int n = 0;
+  Point* prev_position = nullptr;
+  for (Point* position : polyline->raw())
+  { if (polyline->tile->tg_border(*position))
+    { if (current_part == nullptr) {
+        current_part = pool.acquire(Part::SEAM, polyline);
+      } else if (!current_part->is(Part::SEAM)) {
+        this->add_part(current_part);
+        current_part = pool.acquire(Part::SEAM, polyline);
+      }
+    } else if (current_part == nullptr) {
+      current_part = pool.acquire(Part::EXCLUSIVE, polyline);
+    } else if (!current_part->is(Part::EXCLUSIVE)) {
+      this->add_part(current_part);
+      current_part = pool.acquire(Part::EXCLUSIVE, polyline);
+    }
+    if (n > 0 && *prev_position == *position) {
+      current_part->inverts = true;
+    }
+    current_part->add_position(position);
+    n++;
+    prev_position = position;
+  }
+  this->add_part(current_part);
+
+  this->trasmute_parts();
+}
+
+Part* Partitionable::find_first_part_by_position(Position* position) {
+  for (Part* part : this->parts_)
+  { if ( part->is(Part::SEAM) &&
+      part->passes == 0 &&
+      position->end_point()->queues_include(part)) return(part);
+  }
+  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::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);
+    }
+  }
+  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::vector<Part*> after_parts;
+  for (int i = 0; i < other_matching_part_indexes.front(); ++i) {
+    after_parts.push_back(other->parts_[i]);
+  }
+  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);
+    }
+  }
+
+  // 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<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);
+    }
+  }
+  return { left, right };
+}
+
+void Partitionable::trasmute_parts()
+{ std::vector<Part*> insides;
+  for (Part* p : parts_) {
+    if (p->is(Part::SEAM)) insides.push_back(p);
+  }
+  if (insides.size() < 2) return;
+
+  for (Part* inside : insides)
+  { for (Part* inside_compare : insides) {
+      if (inside == inside_compare || !inside_compare->is(Part::SEAM) ) continue;
+      bool all_match = true;
+      inside->each([&](QNode<Point>* pos) -> bool {
+        Position *position = dynamic_cast<Position*>(pos);
+        if (position->end_point()->queues_include(inside_compare))
+        { return true;
+        }
+        all_match = false;
+        return false;
+      });
+      if (all_match) {
+        inside->type = Part::EXCLUSIVE;
+        inside->trasmuted = true;
+        break;
+      }
+    }
+  }
+}
+

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

@@ -0,0 +1,30 @@
+/*
+ * Partitionable.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include <utility>
+#include "Part.h"
+
+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);
+
+ protected:
+  std::vector<Part*> parts_;
+
+ private:
+  void add_part(Part* new_part);
+  void trasmute_parts();
+};

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

@@ -0,0 +1,108 @@
+/*
+ * Polyline.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <vector>
+#include <limits>
+#include <unordered_set>
+#include "Polyline.h"
+#include "Tile.h"
+#include "Shape.h"
+
+Polyline::Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds)
+: raw_(polygon),
+  tile(tile)
+{ if (bounds.has_value()) {
+    min_x =  bounds->min_x;
+    max_x = bounds->max_x;
+    min_y =  bounds->min_y;
+    max_y_ = bounds->max_y;
+  } else {
+    this->find_boundary();  // TODO(ema): optimize when merging the bounds are the sum of the previouses
+  }
+}
+
+void Polyline::precalc() {
+  next_tile_eligible_shapes_.clear();  // useless if called once
+  for (Shape* s : tile->circular_next->boundary_shapes())
+  { if (!s->outer_polyline->is_on(Polyline::TRACKED_OUTER) && this->vert_intersect(*s->outer_polyline) )
+    { next_tile_eligible_shapes_.push_back(s);
+    }
+  }
+}
+
+bool Polyline::vert_intersect(Polyline& other) {
+  return( !(this->max_y_ < other.min_y || other.max_y_ < this->min_y));
+}
+
+int Polyline::width() {
+  if (raw_.empty()) return 0;
+  return(max_x - min_x);
+}
+
+bool Polyline::boundary() {
+  return( tile->tg_border(Point{min_x, 0}) || tile->tg_border(Point{max_x, 0}));
+}
+
+void Polyline::find_boundary() {
+  if (raw_.empty()) return;
+  min_x =  std::numeric_limits<int>::max();
+  max_x = -std::numeric_limits<int>::max();
+  min_y =  std::numeric_limits<int>::max();
+  max_y_ = -std::numeric_limits<int>::max();
+  for (Point* p : raw_) {
+    if (!p) continue;
+    int x = p->x;
+    int y = p->y;
+    if (x < min_x) min_x = x;
+    if (x > max_x) max_x = x;
+    if (y < min_y) min_y = y;
+    if (y > max_y_) max_y_ = y;
+  }
+}
+
+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<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);
+    }
+  }
+  return result;
+}
+
+void Polyline::clear() {
+  this->raw_.clear();
+}
+
+bool Polyline::is_empty() {
+  return raw_.empty();
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Polyline.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <list>
+#include <cstdint>
+#include <optional>
+#include <vector>
+#include "Partitionable.h"
+#include "../RectBounds.h"
+
+class Tile;
+class Shape;
+class Point;
+
+class Polyline : public Partitionable {
+ public:
+  using Partitionable::Partitionable;
+  Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds = std::nullopt);
+  enum Flags : uint32_t {
+    TRACKED_OUTER = 1 << 0,
+    TRACKED_INNER = 1 << 1
+  };
+  void turn_on(Flags f) { flags_ |= f; }
+  void turn_off(Flags f) { flags_ &= ~f; }
+  bool is_on(Flags f) const { return(flags_ & f); }
+  bool boundary();
+  void precalc();
+  int width();
+  Tile *tile = nullptr;
+  Shape* shape = nullptr;
+  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;
+  const int max_y() const { return max_y_; }
+  void clear();
+  bool is_empty();
+  bool vert_intersect(Polyline& other);
+
+ private:
+  std::vector<Point*> raw_;
+  int min_x, max_x, min_y, max_y_;
+  void find_boundary();
+  uint32_t flags_ = 0;
+  std::list<Shape*> next_tile_eligible_shapes_;
+};

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

@@ -0,0 +1,59 @@
+/*
+ * Poolable.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <utility>
+#include "Poolable.h"
+
+Poolable::Poolable(int number_of_threads) : stop(false) {
+  if (number_of_threads == -1) {
+    number_of_threads_ = static_cast<int>(std::thread::hardware_concurrency());
+  } else {
+    number_of_threads_ = number_of_threads;
+  }
+
+  for (int i = 0; i < number_of_threads_; ++i) {
+    workers.emplace_back([this] {
+      while (true) {
+        std::function<void()> task;
+        {
+          std::unique_lock<std::mutex> lock(this->queue_mutex);
+          this->condition.wait(lock, [this] {
+              return this->stop || !this->tasks.empty();
+          });
+
+          if (this->stop && this->tasks.empty()) return;
+
+          task = std::move(this->tasks.front());
+          this->tasks.pop();
+          active_tasks++;
+        }
+        task();
+        active_tasks--;
+        wait_cv.notify_all();
+      }
+    });
+  }
+}
+
+Poolable::~Poolable() {
+  {
+    std::unique_lock<std::mutex> lock(queue_mutex);
+    stop = true;
+  }
+  condition.notify_all();
+  for (std::thread &worker : workers) {
+      if (worker.joinable()) worker.join();
+  }
+}
+
+void Poolable::wait() {
+  std::unique_lock<std::mutex> lock(queue_mutex);
+  wait_cv.wait(lock, [this] {
+      return tasks.empty() && active_tasks == 0;
+  });
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Poolable.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include <thread>
+#include <queue>
+#include <functional>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+#include <utility>
+
+class Poolable {
+ public:
+  // 0 (synch), -1 (maximum availables), or N thread
+  explicit Poolable(int number_of_threads);
+  ~Poolable();
+
+  template<typename Payload, typename F>
+  void enqueue(Payload payload, F&& func) {
+    if (number_of_threads_ > 0) {
+      {
+        std::unique_lock<std::mutex> lock(queue_mutex);
+        tasks.emplace([payload = std::move(payload), fn = std::forward<F>(func)]() mutable {
+            fn(payload);
+        });
+      }
+      condition.notify_one();
+    } else {
+        func(payload);  // 0 thread
+    }
+  }
+  void wait();
+
+ private:
+  std::vector<std::thread> workers;
+  std::queue<std::function<void()>> tasks;
+
+  std::mutex queue_mutex;
+  std::condition_variable condition;
+  std::condition_variable wait_cv;
+
+  int number_of_threads_;
+  bool stop = false;
+  std::atomic<int> active_tasks{0};
+};