contrek 1.0.4 → 1.0.6

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

@@ -0,0 +1,344 @@
+/*
+ * Cursor.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+#include <algorithm>
+#include <vector>
+#include <utility>
+#include <unordered_set>
+#include "Cursor.h"
+#include "Polyline.h"
+
+Cursor::Cursor(Cluster& cluster, Shape* shape)
+: cluster(cluster), shape(shape) {
+}
+
+Cursor::~Cursor() {
+  for (Sequence* sequence : this->allocated_sequences) {
+    delete sequence;
+  }
+}
+
+Sequence* Cursor::join_outers()
+{ Polyline* outer_polyline = shape->outer_polyline;
+  this->polylines_sequence.push_back(outer_polyline);
+  Sequence* outer_joined_polyline = new Sequence();
+  this->allocated_sequences.push_back(outer_joined_polyline);
+  int counter = 0;
+  std::vector<Part*> all_parts;
+  std::vector<Shape*> shapes;
+  shapes.push_back(this->shape);
+  this->traverse_outer(outer_polyline->parts().front(),
+                       all_parts,
+                       this->polylines_sequence,
+                       shapes,
+                       outer_joined_polyline, counter);
+
+  if (*outer_joined_polyline->head->payload == *outer_joined_polyline->tail->payload &&
+      this->cluster.tiles().front()->left() &&
+      this->cluster.tiles().back()->right()) outer_joined_polyline->pop();
+
+  // TODO(ema): optimize
+  std::unordered_set<Polyline*> seen;
+  std::vector<Polyline*> result;
+  for (Polyline* x : polylines_sequence) {
+      if (seen.insert(x).second) {
+          result.push_back(x);
+      }
+  }
+  polylines_sequence = result;
+
+  for (Polyline* polyline : polylines_sequence) {
+    polyline->turn_on(Polyline::TRACKED_OUTER);
+  }
+
+  for (Shape *shape : shapes)
+  { if (shape == outer_polyline->shape) {
+      continue;
+    }
+    orphan_inners_.insert(
+        orphan_inners_.end(),
+        shape->inner_polylines.begin(),
+        shape->inner_polylines.end());
+    shape->clear_inner();
+  }
+  return(outer_joined_polyline);
+}
+
+void Cursor::traverse_outer(Part* act_part,
+                            std::vector<Part*>& all_parts,
+                            std::vector<Polyline*>& polylines,
+                            std::vector<Shape*>& shapes,
+                            Sequence* outer_joined_polyline,
+                            int& counter) {
+  while (act_part != nullptr) {
+    counter += 1;
+
+    if (all_parts.empty() || all_parts.back() != act_part) {
+      all_parts.push_back(act_part);
+    }
+
+    Shape* target_shape = act_part->polyline()->shape;
+    if (std::find(shapes.begin(), shapes.end(), target_shape) == shapes.end()) {
+      shapes.push_back(target_shape);
+    }
+
+    bool jumped_to_new_part = false;
+    if (act_part->is(Part::EXCLUSIVE)) {
+      if (act_part->size == 0) return;
+
+      while (Position *position = act_part->next_position(nullptr)) {
+        if (outer_joined_polyline->size > 1 &&
+          outer_joined_polyline->head->payload == position->payload &&
+          act_part == all_parts.front()) {
+          return;
+        }
+        outer_joined_polyline->add(position);
+      }
+    } else {
+      while (Position *new_position = static_cast<Position*>(act_part->iterator())) {
+        if (outer_joined_polyline->size > 1 &&
+          outer_joined_polyline->head->payload == new_position->payload &&
+          act_part == all_parts.front()) {
+          return;
+        }
+        this->cluster.positions_pool.emplace_back(this->cluster.hub(), new_position->payload);
+        outer_joined_polyline->add(&this->cluster.positions_pool.back());
+        for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
+          if (Part *part = shape->outer_polyline->find_first_part_by_position(new_position)) {
+            const auto n = all_parts.size();
+            Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
+
+            if (last_last_part != part) {
+              if (n >= 2) {
+                bool all_seam = true;
+                for (std::size_t i = all_parts.size() - 2; i < all_parts.size(); ++i) {
+                  if (all_parts[i]->type != Part::SEAM) {
+                    all_seam = false;
+                    break;
+                  }
+                }
+                if (all_seam) break;
+              }
+              polylines.push_back(part->polyline()->shape->outer_polyline);
+              part->next_position(new_position);
+              act_part = part;
+              jumped_to_new_part = true;
+              break;
+            }
+          }
+        }
+        if (jumped_to_new_part) break;
+        act_part->passes += 1;
+        act_part->next_position(nullptr);
+      }
+    }
+    if (jumped_to_new_part) continue;
+    Part* next_part = act_part->circular_next;
+    next_part->rewind();
+    act_part = next_part;
+  }
+}
+
+std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
+  std::vector<Sequence*> retme;
+  std::vector<Shape*> missing_shapes;
+
+  for (Tile *tile : this->cluster.tiles())
+  { for (Shape *shape : tile->shapes())
+    { if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) ||
+        shape->outer_polyline->is_on(Polyline::TRACKED_INNER) ||
+        !shape->outer_polyline->boundary() ||
+        std::find(polylines_sequence.begin(), polylines_sequence.end(), shape->outer_polyline) != polylines_sequence.end()) {
+        continue;
+      }
+      missing_shapes.push_back(shape);
+    }
+  }
+
+  for (Polyline *polyline : polylines_sequence)
+  { for (Shape *missing_shape : missing_shapes)
+    { Polyline* outer_polyline = missing_shape->outer_polyline;
+      if (!polyline->vert_intersect(*outer_polyline)) continue;
+      std::vector<Point*> intersection = polyline->intersection(outer_polyline);
+      if (intersection.size() > 0)
+      { auto [inject_sequences_left, inject_sequences_right] = polyline->sew(intersection, outer_polyline);
+        auto combined = combine(inject_sequences_right, inject_sequences_left);
+        for (auto& sewn_sequence : combined) {
+          std::vector<Point*> unique;
+          unique.reserve(sewn_sequence.size());
+          for (Point* p : sewn_sequence) {
+            if (!p) continue;
+            auto it = std::find_if(
+              unique.begin(), unique.end(),
+              [&](Point* up) {
+                  return up && *up == *p;
+              });
+            if (it == unique.end()) unique.push_back(p);
+          }
+          sewn_sequence.swap(unique);
+
+          if (sewn_sequence.size() <= 1) continue;
+
+          int first_x = sewn_sequence.front()->x;
+          bool different_x = false;
+          for (Point* p : sewn_sequence) {
+            if (p->x != first_x) {
+              different_x = true;
+              break;
+            }
+          }
+          if (different_x) {
+            orphan_inners_.push_back(sewn_sequence);
+          }
+        }
+        outer_polyline->clear();
+        outer_polyline->turn_on(Polyline::TRACKED_OUTER);
+        outer_polyline->turn_on(Polyline::TRACKED_INNER);
+        orphan_inners_.insert(
+        orphan_inners_.end(),
+        missing_shape->inner_polylines.begin(),
+        missing_shape->inner_polylines.end());
+      }
+    }
+  }
+  retme = collect_inner_sequences(outer_seq);
+  for (Polyline* polyline : polylines_sequence) {
+    polyline->turn_on(Polyline::TRACKED_INNER);
+  }
+  return(retme);
+}
+
+std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
+  std::vector<Sequence*> return_sequences;
+
+  for (Polyline* polyline : polylines_sequence)
+  { for (Part* part : polyline->parts())
+    { if (part->innerable())
+      { std::vector<Part*> all_parts;
+        Bounds bounds{
+          .min = polyline->max_y(),
+          .max = 0
+        };
+        traverse_inner(part, all_parts, bounds);
+        Sequence* retme_sequence = new Sequence();
+
+        for (Part* part : all_parts)
+        { part->touch();
+          retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
+          Position *position = dynamic_cast<Position*>(pos);
+          if (part->is(Part::ADDED) &&
+             !(position->payload->y >= bounds.min &&
+              position->payload->y <= bounds.max)) {
+            return(false);
+          }
+            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->queues_include(outer_seq)));
+          });
+        }
+        if (retme_sequence->is_not_vertical()) return_sequences.push_back(retme_sequence);
+        else                                   delete retme_sequence;
+      }
+    }
+  }
+
+  return(return_sequences);
+}
+
+void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bounds& bounds) {
+  PartPool& pool = act_part->polyline()->tile->cluster->parts_pool;
+  while (act_part != nullptr) {
+    if (!all_parts.empty() && act_part == all_parts.front()) return;
+    if (act_part->size > 0) {
+      auto points = act_part->to_vector();
+      auto [min_it, max_it] = std::minmax_element(
+        points.begin(),
+        points.end(),
+        [](Point* a, Point* b) { return a->y < b->y; });
+      bounds.min = std::min(bounds.min, (*min_it)->y);
+      bounds.max = std::max(bounds.max, (*max_it)->y);
+    }
+    if (act_part->innerable()) {
+      all_parts.push_back(act_part);
+      bool jumped = false;
+      while (act_part = act_part->next) {
+        if (act_part->innerable()) {
+            all_parts.push_back(act_part);
+        } else {
+          for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
+            for (Part* dest_part : shape->outer_polyline->parts()) {
+              if (dest_part->trasmuted) continue;
+              if (dest_part->intersect_part(act_part)) {
+                std::vector<Point*> link_seq = duplicates_intersection(*dest_part, *act_part);
+                if (!link_seq.empty()) {
+                  Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
+                  for (Point* pos : link_seq) {
+                    this->cluster.positions_pool.emplace_back(this->cluster.hub(), pos);
+                    ins_part->add(&this->cluster.positions_pool.back());
+                  }
+                  all_parts.push_back(ins_part);
+                }
+                act_part = dest_part->circular_next;
+                jumped = true;
+                break;
+              }
+            }
+            if (jumped) break;
+          }
+          if (jumped) break;
+          if (act_part->is(Part::SEAM)) {
+            all_parts.push_back(act_part);
+          }
+        }
+      }
+      if (jumped) continue;
+      break;
+    } else if (act_part->next) {
+      act_part = act_part->next;
+      continue;
+    }
+    else break;
+  }
+}
+
+template <typename T>
+std::vector<T*> difference_ptr(const std::vector<T*>& a, const std::vector<T*>& b)
+{ std::vector<T*> result;
+  for (T* item : a) {
+    if (!item) continue;
+    auto it = std::find_if(
+      b.begin(), b.end(),
+      [&](T* other) {
+          return other && *other == *item;
+      });
+    if (it == b.end()) {
+      result.push_back(item);
+    }
+  }
+  return result;
+}
+
+std::vector<Point*> Cursor::duplicates_intersection(const Part& part_a, const Part& part_b) {
+  std::vector<Point*> a1 = part_a.inverts ? part_a.remove_adjacent_pairs(part_a.to_vector()) : part_a.to_vector();
+  std::vector<Point*> b1 = part_b.inverts ? part_b.remove_adjacent_pairs(part_b.to_vector()) : part_b.to_vector();
+  std::vector<Point*> result = difference_ptr(a1, b1);
+  std::vector<Point*> temp = difference_ptr(b1, a1);
+  result.insert(result.end(), temp.begin(), temp.end());
+  return result;
+}
+
+std::vector<std::vector<Point*>> Cursor::combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb)
+{ std::vector<std::vector<Point*>> rets;
+  size_t n = std::min(seqa.size(), seqb.size());
+  for (size_t i = 0; i < n; ++i) {
+    std::vector<Point*> last = std::move(seqa.back());
+    seqa.pop_back();
+    std::vector<Point*> first = std::move(seqb.front());
+    seqb.erase(seqb.begin());
+    first.insert(first.end(), last.begin(), last.end());
+    rets.push_back(std::move(first));
+  }
+  return rets;
+}

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

@@ -0,0 +1,46 @@
+/*
+ * Cursor.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <list>
+#include <vector>
+#include "Sequence.h"
+#include "Cluster.h"
+#include "Shape.h"
+#include "Part.h"
+
+struct Bounds {
+  int min;
+  int max;
+};
+
+class Cursor {
+ public:
+  Cursor(Cluster& cluster, Shape* shape);
+  virtual ~Cursor();
+  Sequence* join_outers();
+  std::vector<Sequence*> join_inners(Sequence* outer_seq);
+  std::list<std::vector<Point*>> orphan_inners() { return orphan_inners_; }
+
+ private:
+  Cluster& cluster;
+  Shape* shape;
+  std::vector<Sequence*> allocated_sequences;
+  std::vector<Polyline*> polylines_sequence;
+  std::list<std::vector<Point*>> orphan_inners_;
+  void traverse_outer(Part* act_part,
+                      std::vector<Part*>& all_parts,
+                      std::vector<Polyline*>& polylines,
+                      std::vector<Shape*>& shapes,
+                      Sequence* outer_joined_polyline,
+                      int& counter);
+  std::vector<Sequence*> collect_inner_sequences(Sequence* outer_seq);
+  void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
+  std::vector<Point*> duplicates_intersection(const Part& part_a, const Part& part_b);
+  std::vector<std::vector<Point*>> combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb);
+};

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

@@ -0,0 +1,14 @@
+/*
+ * EndPoint.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "EndPoint.h"
+#include <iostream>
+
+bool EndPoint::queues_include(Queueable<Point>* q) const {
+  return (std::find(queues_.begin(), queues_.end(), q) != queues_.end());
+}

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

@@ -0,0 +1,22 @@
+/*
+ * EndPoint.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include "Part.h"
+
+class Part;
+
+class EndPoint {
+ public:
+  EndPoint() {}
+  std::vector<Queueable<Point>*>& queues() { return queues_; }
+  bool queues_include(Queueable<Point>* q) const;
+ private:
+  std::vector<Queueable<Point>*> queues_;
+};

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

@@ -0,0 +1,13 @@
+/*
+ * FakeCluster.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "FakeCluster.h"
+
+FakeCluster::FakeCluster(std::list<Polygon>& polygons, pf_Options options)
+: NodeCluster(0, 0, &options), polygons(polygons) {
+}

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

@@ -0,0 +1,17 @@
+/*
+ * FakeCluster.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <list>
+#include "../NodeCluster.h"
+
+class FakeCluster : public NodeCluster {
+ public:
+  std::list<Polygon>& polygons;
+  FakeCluster(std::list<Polygon>& polygons, pf_Options options);
+};

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

@@ -0,0 +1,138 @@
+/*
+ * Finder.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <utility>
+#include <vector>
+#include <string>
+#include "Finder.h"
+#include "../../bitmaps/Bitmap.h"
+#include "../../matchers/Matcher.h"
+#include "../../matchers/RGBMatcher.h"
+#include "../optionparser.h"
+#include "../FinderUtils.h"
+#include "ClippedPolygonFinder.h"
+#include "Tile.h"
+#include "Queue.h"
+#include "Cluster.h"
+#include "FakeCluster.h"
+
+Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vector<std::string> *options)
+: Poolable(number_of_threads),
+  bitmap(bitmap),
+  matcher(matcher),
+  input_options(*options),
+  maximum_width_(bitmap->w())
+{ cpu_timer.start();
+  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+
+  double cw = static_cast<double>(this->maximum_width_) / this->options.number_of_tiles;
+  if (cw < 1.0) {
+    throw std::runtime_error("One pixel tile width minimum!");
+  }
+  int x = 0;
+  for (int tile_index = 0; tile_index < this->options.number_of_tiles; tile_index++)
+  { int tile_end_x = static_cast<int>(cw * (tile_index + 1));
+    TilePayload p { tile_index, x, tile_end_x };
+    enqueue(p, [this](const TilePayload& payload) {
+      std::vector<std::string> base_arguments = {"--bounds", "--versus=" + this->options.get_alpha_versus()};
+      CpuTimer t;
+      t.start();
+      auto* finder = new ClippedPolygonFinder(
+        this->bitmap,
+        this->matcher,
+        payload.tile_start_x,
+        payload.tile_end_x,
+        &base_arguments);
+      {
+        std::lock_guard<std::mutex> lock(finders_mutex);
+        finders.push(finder);
+      }
+
+      Tile* tile = new Tile(this, payload.tile_start_x, payload.tile_end_x,
+                            std::to_string(payload.tile_index), Benchmarks {0, 0});
+      tile->initial_process(finder);
+      tiles.queue_push(tile);
+    });
+
+    x = tile_end_x - 1;
+  }
+  this->process_tiles();
+  reports["init"] = cpu_timer.stop();
+}
+
+
+void Finder::process_tiles() {
+  std::vector<Tile*> arriving_tiles;
+
+  while (true) {
+    Tile* tile = tiles.queue_pop();
+
+    if (tile->whole()) {
+      this->whole_tile = tile;
+      break;
+    }
+
+    auto it = std::find_if(
+      arriving_tiles.begin(),
+      arriving_tiles.end(),
+      [&](Tile* t) {
+        return (t->start_x() == (tile->end_x() - 1)) || ((t->end_x() - 1) == tile->start_x());
+      });
+
+    if (it != arriving_tiles.end()) {
+      Tile* twin_tile = *it;
+      Cluster *cluster = new Cluster(this, this->bitmap->h(), this->bitmap->w());
+      if (twin_tile->start_x() == (tile->end_x() - 1)) {
+        cluster->add(tile);
+        cluster->add(twin_tile);
+      } else {
+        cluster->add(twin_tile);
+        cluster->add(tile);
+      }
+      arriving_tiles.erase(it);
+      enqueue(cluster, [this](Cluster* c) {
+        Tile* merged_tile = c->merge_tiles();
+        tiles.queue_push(merged_tile);
+        delete c;
+      });
+    } else {
+      arriving_tiles.push_back(tile);
+    }
+  }
+}
+
+Finder::~Finder() {
+  if (this->whole_tile) {
+    delete this->whole_tile;  // last tile to be deleted (not owned by a cluster)
+  }
+
+  while (!finders.empty()) {
+    ClippedPolygonFinder* finder = nullptr;
+    { std::lock_guard<std::mutex> lock(finders_mutex);
+      finder = finders.front();
+      finders.pop();
+    }
+    delete finder;
+  }
+}
+
+ProcessResult* Finder::process_info() {
+  ProcessResult *pr = new ProcessResult();
+  pr->polygons = std::move(this->whole_tile->to_raw_polygons());
+  FakeCluster fake_cluster(pr->polygons, this->options);
+  cpu_timer.start();
+  fake_cluster.compress_coords(pr->polygons, this->options);
+  reports["compress"] = cpu_timer.stop();
+  reports["total"] = reports["compress"] + reports["init"];
+  reports["outer"] = this->whole_tile->benchmarks.outer;
+  reports["inner"] = this->whole_tile->benchmarks.inner;
+  pr->benchmarks = this->reports;
+  // TODO(ema): pr->treemap
+  // TODO(ema): pr->named_sequence
+  return(pr);
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Finder.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <queue>
+#include <mutex>
+#include <string>
+#include <map>
+#include <vector>
+#include "Poolable.h"
+#include "../PolygonFinder.h"
+#include "Queue.h"
+#include "Tile.h"
+
+struct TilePayload {
+  int tile_index;
+  int tile_start_x;
+  int tile_end_x;
+};
+
+class Bitmap;
+class Matcher;
+class Tile;
+class ClippedPolygonFinder;
+
+class Finder : public Poolable {
+ private:
+  Bitmap *bitmap;
+  Matcher *matcher;
+  pf_Options options;
+  std::vector<std::string> input_options;
+  int maximum_width_;
+  Queue<Tile*> tiles;
+  Tile* whole_tile = nullptr;
+  void process_tiles();
+  std::queue<ClippedPolygonFinder*> finders;
+  std::mutex finders_mutex;
+  std::map<std::string, double> reports;
+  CpuTimer cpu_timer;
+
+ public:
+  using Poolable::Poolable;
+  Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vector<std::string> *options);
+  virtual ~Finder();
+  int maximum_width() const { return maximum_width_; }
+  ProcessResult* process_info();
+};

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

@@ -0,0 +1,23 @@
+/*
+ * Hub.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Hub.h"
+#include <cstring>
+
+Hub::Hub(int height, int width)
+    : width_(width), height_(height)
+{ size_t total_pixels = static_cast<size_t>(width) * height;
+  payloads_.resize(total_pixels);
+  bitset_.resize((total_pixels + 63) / 64, 0);
+  std::memset(bitset_.data(), 0, bitset_.size() * sizeof(uint64_t));
+}
+
+EndPoint* Hub::spawn_end_point() {
+  endpoint_pool_.emplace_back();
+  return &endpoint_pool_.back();
+}