contrek 1.0.4 → 1.0.6

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

@@ -0,0 +1,31 @@
+/*
+ * Position.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+#include <iostream>
+#include "Position.h"
+#include "Hub.h"
+
+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;
+  }
+}
+
+void Position::before_rem(Queueable<Point>* q)  {
+  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);
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Position.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include "Queueable.h"
+#include "../Node.h"
+#include "EndPoint.h"
+#include "Hub.h"
+
+class EndPoint;
+class Hub;
+class Position : public QNode<Point>{
+ public:
+  explicit Position(Hub* hub, Point* point);
+  const EndPoint* end_point() const { return end_point_; }
+  void before_rem(Queueable<Point>* q) override;
+  void after_add(Queueable<Point>* q) override;
+ private:
+  EndPoint* end_point_;
+};

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

@@ -0,0 +1,36 @@
+/*
+ * Queue.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <utility>
+
+template <typename T>
+class Queue {
+ public:
+  void queue_push(T value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    queue_.push(value);
+    cond_.notify_one();
+  }
+
+  T queue_pop() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cond_.wait(lock, [this]{ return !queue_.empty(); });
+    T value = queue_.front();
+    queue_.pop();
+    return value;
+  }
+
+ private:
+  std::queue<T> queue_;
+  std::mutex mutex_;
+  std::condition_variable cond_;
+};

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

@@ -0,0 +1,230 @@
+/*
+ * Queueable.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include <list>
+#include <functional>
+#include <stdexcept>
+#include <iostream>
+
+template <typename T>
+class Queueable;
+
+template <typename T>
+class QNode {
+ public:
+  T* payload;
+  QNode<T>* next  {nullptr};
+  QNode<T>* prev  {nullptr};
+  Queueable<T>* owner {nullptr};
+  explicit QNode(T* value) : payload(value) {}
+  virtual ~QNode() = default;
+  virtual void before_rem(Queueable<T>* q) {}
+  virtual void after_add(Queueable<T>* q) {}
+};
+
+
+template <typename T>
+class Queueable {
+ public:
+  QNode<T>* head {nullptr};
+  QNode<T>* tail {nullptr};
+  QNode<T>* _iterator {nullptr};
+  bool _started = false;
+  size_t size {0};
+  Queueable() = default;
+  virtual ~Queueable() = default;
+
+  QNode<T>* rem(QNode<T>* node) {
+    if (!node) return nullptr;
+    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;
+    if (node == head) head = node->next;
+    if (node == tail) tail = node->prev;
+    node->next = nullptr;
+    node->prev = nullptr;
+    node->owner = nullptr;
+    if (size > 0) size--;
+    return node;
+  }
+
+  void add(QNode<T>* node) {
+    if (!node) return;
+    if (node->owner)
+        node->owner->rem(node);
+    if (tail) {
+        tail->next = node;
+        node->prev = tail;
+    } else {
+        head = node;
+        node->prev = nullptr;
+    }
+    tail = node;
+    node->next = nullptr;
+    node->owner = this;
+    size++;
+    node->after_add(this);
+  }
+
+  void reset() {
+    head = nullptr;
+    tail = nullptr;
+    _iterator = nullptr;
+    size = 0;
+  }
+
+  void replace(Queueable<T>& q) {
+    reset();
+    append(q);
+  }
+
+  void append(Queueable<T>& q) {
+    if (q.size == 0) return;
+    QNode<T>* current = q.head;
+    while (current) {
+      current->before_rem(&q);
+      current->owner = this;
+      current = current->next;
+    }
+    if (tail) {
+      tail->next = q.head;
+      q.head->prev = tail;
+    } else {
+      head = q.head;
+    }
+    tail = q.tail;
+    size += q.size;
+    q.reset();
+    each([&](QNode<T>* n) -> bool {
+      n->after_add(this);
+      return(true);
+    });
+  }
+
+  void rewind() {
+    _iterator = nullptr;
+    _started = false;
+  }
+
+  QNode<T>* iterator() const {
+    if (!_started)  return head;
+    return _iterator;
+  }
+
+  void forward() {
+    if (!_started)
+    { _iterator = head ? head->next : nullptr;
+      _started = true;
+    } else if (_iterator) {
+      _iterator = _iterator->next;
+    }
+  }
+
+  void next_of(QNode<T>* node) {
+    if (!node)  throw std::runtime_error("nil node");
+    if (node->owner != this) throw std::runtime_error("wrong node");
+    _iterator = node->next;
+    _started = true;
+  }
+
+  template<typename Func>
+  void each(Func func) {
+    QNode<T>* current = head;
+    while (current) {
+      if (!func(current)) break;
+      current = current->next;
+    }
+  }
+
+  template<typename Func>
+  void reverse_each(Func func) {
+    QNode<T>* current = tail;
+    while (current) {
+      if (!func(current)) break;
+      current = current->prev;
+    }
+  }
+
+  template<typename Func>
+  void move_from(Queueable<T>& queueable, Func func) {
+    queueable.rewind();
+    while (QNode<T>* node = queueable.iterator())
+    { queueable.forward();
+      if (func(node)) add(node);
+    }
+  }
+
+  std::vector<T*> to_vector() const {
+    std::vector<T*> out;
+    QNode<T>* current = head;
+    while (current) {
+        out.push_back(current->payload);
+        current = current->next;
+    }
+    return out;
+  }
+
+  std::vector<T> map(std::function<T(QNode<T>*)> fn) {
+      std::vector<T> out;
+      each([&](QNode<T>* n){
+          out.push_back(fn(n));
+      });
+      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);
+  }
+
+  bool contains(const T& value) const {
+    QNode<T>* current = head;
+    while (current) {
+      if (current->payload == value)
+          return true;
+      current = current->next;
+    }
+    return false;
+  }
+
+  std::vector<T*> remove_adjacent_pairs(const std::vector<T*>& input = {}) const {
+    const std::vector<T*>& source = input.empty() ? to_vector() : input;
+    std::vector<T*> result;
+    result.reserve(source.size());
+
+    for (T* current : source) {
+      if (!result.empty() && *result.back() == *current) {
+          result.pop_back();  // "Annulla" la coppia invece di ricominciare
+      } else {
+          result.push_back(current);
+      }
+    }
+    return result;
+  }
+};

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

@@ -0,0 +1,35 @@
+/*
+ * Sequence.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <string>
+#include "Sequence.h"
+
+std::string Sequence::toString() {
+  std::string retme = "";
+  this->each([&](QNode<Point>* pos) -> bool {
+    retme += pos->payload->toString();
+    return true;
+  });
+  return(retme);
+}
+
+bool Sequence::is_not_vertical()
+{ if (this->size < 2) {
+    return false;
+  }
+  int x0 = head->payload->x;
+  this->rewind();
+
+  while (QNode<Point>* position = this->iterator())
+  { if (position->payload->x != x0) {
+      return true;
+    }
+    this->forward();
+  }
+  return false;
+}

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

@@ -0,0 +1,20 @@
+/*
+ * Sequence.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <string>
+#include "Queueable.h"
+#include "../Node.h"
+#include "Position.h"
+
+class Sequence : public Queueable<Point>{
+ public:
+  Sequence() {}
+  std::string toString();
+  bool is_not_vertical();
+};

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

@@ -0,0 +1,26 @@
+/*
+ * Shape.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <list>
+#include "Shape.h"
+#include "Polyline.h"
+
+Shape::Shape(Polyline* outer_polyline, const std::list<std::vector<Point*>>& inner_polylines)
+: outer_polyline(outer_polyline),
+  inner_polylines(inner_polylines) {
+}
+
+Shape::~Shape() {
+  if (outer_polyline) {
+    delete outer_polyline;
+  }
+}
+
+void Shape::clear_inner() {
+  inner_polylines.clear();
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Shape.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <list>
+#include <iostream>
+#include <vector>
+
+class Point;
+class Polyline;
+class Shape {
+ public:
+  Shape(Polyline* outer_polyline, const std::list<std::vector<Point*>>& inner_polylines);
+  virtual ~Shape();
+  Polyline* outer_polyline = nullptr;
+  std::list<std::vector<Point*>> inner_polylines;
+  void clear_inner();
+};

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

@@ -0,0 +1,105 @@
+/*
+ * Tile.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <string>
+#include <iostream>
+#include <list>
+#include <utility>
+#include "Tile.h"
+#include "Shape.h"
+#include "Polyline.h"
+
+class Shape;
+class Polyline;
+
+Tile::Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b)
+: finder(finder),
+  start_x_(start_x),
+  end_x_(end_x),
+  name_(name),
+  benchmarks(b) {
+}
+
+Tile::~Tile() {
+  for (Shape* shape : shapes_) {
+    delete shape;
+  }
+  shapes_.clear();
+}
+
+bool Tile::whole() {
+  return(start_x_ == 0 && end_x_ == finder->maximum_width());
+}
+
+bool Tile::left() {
+  return(start_x_ == 0);
+}
+
+bool Tile::right() {
+  return(end_x_ == finder->maximum_width());
+}
+
+void Tile::initial_process(ClippedPolygonFinder *finder) {
+  this->assign_raw_polygons(finder->get_cluster()->polygons);
+}
+
+void Tile::assign_raw_polygons(const std::list<Polygon>& raw_polylines) {
+  for (const auto& raw_polyline : raw_polylines)
+  { if (raw_polyline.bounds.width() > 0)
+    { Polyline* polyline = new Polyline(this, raw_polyline.outer, raw_polyline.bounds);
+      { Shape* shape = new Shape(polyline, raw_polyline.inner);
+        polyline->shape = shape;
+        this->shapes_.push_back(shape);
+      }
+    }
+  }
+}
+
+void Tile::assign_shapes(std::list<Shape*>& shapes) {
+  for (Shape *shape : shapes) {
+    shape->outer_polyline->tile = this;
+  }
+  this->shapes_ = shapes;
+}
+
+bool Tile::tg_border(const Point& coord) {
+  return( coord.x == (this->next == nullptr ? start_x_ : (end_x_ - 1)));
+}
+
+void Tile::info() {
+  std::cout << "TILE name=" << name_ << " start_x=" << start_x_ << " end_x=" << end_x_ << std::endl;
+}
+
+const std::list<Shape*>& Tile::boundary_shapes()
+{ if (!boundary_shapes_initialized_)
+  { for (Shape* s : shapes_)
+    { if (s->outer_polyline->boundary())
+      { boundary_shapes_.push_back(s);
+      }
+    }
+    boundary_shapes_initialized_ = true;
+  }
+  return boundary_shapes_;
+}
+
+std::list<Polygon> Tile::to_raw_polygons()
+{ std::list<Polygon> retme;
+  for (Shape* s : shapes_)
+  { if (s->outer_polyline && !s->outer_polyline->is_empty())
+    { Polygon poly;
+      poly.outer = s->outer_polyline->raw();
+      if (!s->inner_polylines.empty()) {
+        for (auto inner : s->inner_polylines) {
+          poly.inner.push_back(inner);
+        }
+      }
+      retme.push_back(std::move(poly));
+    }
+  }
+  return(retme);
+}

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

@@ -0,0 +1,56 @@
+/*
+ * Tile.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+#pragma once
+#include <string>
+#include <list>
+#include "Finder.h"
+#include "ClippedPolygonFinder.h"
+
+class Finder;
+class Cluster;
+class Shape;
+
+struct Benchmarks {
+  double outer;
+  double inner;
+};
+
+class Tile {
+ private:
+  Finder *finder;
+  int start_x_;
+  int end_x_;
+  std::string name_;
+  std::list<Shape*> shapes_;
+  std::list<Shape*> boundary_shapes_;
+  bool boundary_shapes_initialized_ = false;
+  void assign_raw_polygons(const std::list<Polygon>& raw_polylines);
+
+ public:
+  Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b);
+  virtual ~Tile();
+  Tile *prev = nullptr;
+  Tile *next = nullptr;
+  Tile* circular_next = nullptr;
+  Cluster *cluster = nullptr;
+  int start_x() const { return start_x_; }
+  int end_x() const { return end_x_; }
+  std::string name() const { return name_; }
+  const std::list<Shape*>& shapes() const { return shapes_; }
+  std::list<Shape*>& shapes() { return shapes_; }
+  const std::list<Shape*>& boundary_shapes();
+  bool whole();
+  bool left();
+  bool right();
+  void initial_process(ClippedPolygonFinder *finder);
+  void info();
+  bool tg_border(const Point& coord);
+  void assign_shapes(std::list<Shape*>& shapes);
+  std::list<Polygon> to_raw_polygons();
+  Benchmarks benchmarks;
+};

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.cpp

@@ -8,16 +8,16 @@
 
 #include "Matcher.h"
 #include <iostream>
-Matcher::Matcher(char value) {
+Matcher::Matcher(unsigned int value) {
   this->value = value;
 }
 
 Matcher::~Matcher() {
 }
 
-bool Matcher::match(char value) {
+bool Matcher::match(unsigned int value) {
   return(this->value == value);
 }
-bool Matcher::unmatch(char value) {
+bool Matcher::unmatch(unsigned int value) {
   return(!match(value));
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.h

@@ -6,18 +6,15 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_MATCHERS_MATCHER_H_
-#define POLYGON_MATCHERS_MATCHER_H_
+#pragma once
 
 class Matcher {
  protected:
-  char value;
+  unsigned int value;
 
  public:
-  Matcher(char value);
-  virtual bool match(char value);
-  virtual bool unmatch(char value);
+  explicit Matcher(unsigned int value);
+  virtual bool match(unsigned int value);
+  virtual bool unmatch(unsigned int value);
   virtual ~Matcher();
 };
-
-#endif /* POLYGON_MATCHERS_MATCHER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/RGBMatcher.h

@@ -6,18 +6,14 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_MATCHERS_RGBMATCHER_H_
-#define POLYGON_MATCHERS_RGBMATCHER_H_
-
+#pragma once
 #include "Matcher.h"
 
 class RGBMatcher : public Matcher {
  public:
-  RGBMatcher(unsigned int rgb_value);
+  explicit RGBMatcher(unsigned int rgb_value);
   virtual ~RGBMatcher();
-  bool match(unsigned int value);
+  bool match(unsigned int value) override;
  private:
   unsigned int rgb_value;
 };
-
-#endif /* POLYGON_MATCHERS_RGBMATCHER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/RGBNotMatcher.cpp

@@ -8,13 +8,13 @@
 
 #include "RGBNotMatcher.h"
 #include <iostream>
-RGBNotMatcher::RGBNotMatcher(int rgb_value) : Matcher(0L) {
+RGBNotMatcher::RGBNotMatcher(unsigned int rgb_value) : Matcher(0L) {
   this->rgb_value = rgb_value;
 }
 
 RGBNotMatcher::~RGBNotMatcher() {
 }
 
-bool RGBNotMatcher::match(int value) {
+bool RGBNotMatcher::match(unsigned int value) {
   return(this->rgb_value != value);
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/RGBNotMatcher.h

@@ -6,18 +6,14 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_MATCHERS_RGBNOTMATCHER_H_
-#define POLYGON_MATCHERS_RGBNOTMATCHER_H_
-
+#pragma once
 #include "Matcher.h"
 
 class RGBNotMatcher : public Matcher {
  public:
-  RGBNotMatcher(int rgb_value);
+  explicit RGBNotMatcher(unsigned int rgb_value);
   virtual ~RGBNotMatcher();
-  bool match(int value);
+  bool match(unsigned int value) override;
  private:
-  int rgb_value;
+  unsigned int rgb_value;
 };
-
-#endif /* POLYGON_MATCHERS_RGBMATCHER_H_ */