contrek 1.0.4 → 1.0.6

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

@@ -6,198 +6,113 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-
 #include <iostream>
 #include <list>
 #include <map>
 #include <ctime>
 #include <typeinfo>
 #include <string>
-#include <ctime>
 #include <vector>
+#include <utility>
 #include "PolygonFinder.h"
 #include "../bitmaps/Bitmap.h"
 #include "../matchers/Matcher.h"
 #include "../matchers/RGBMatcher.h"
+#include "../matchers/RGBNotMatcher.h"
 #include "optionparser.h"
 #include "NodeCluster.h"
 #include "Node.h"
-
-PolygonFinder::PolygonFinder(Bitmap *bitmap, Matcher *matcher, Bitmap *test_bitmap, std::vector<std::string> *options) {
-  source_bitmap = bitmap;
-  this->matcher = matcher;
-  if (options != nullptr) sanitize_options(options);
-  this->node_cluster = new NodeCluster(source_bitmap->h(), &this->options);
+#include "FinderUtils.h"
+
+PolygonFinder::PolygonFinder(Bitmap *bitmap,
+                             Matcher *matcher,
+                             Bitmap *test_bitmap,
+                             std::vector<std::string> *options,
+                             int start_x,
+                             int end_x)
+    : source_bitmap(bitmap),
+      matcher(matcher),
+      start_x(start_x),
+      end_x(end_x == -1 ? bitmap->w() : end_x)
+{ this->rgb_matcher = dynamic_cast<RGBMatcher*>(matcher);
+  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+  this->node_cluster = new NodeCluster(source_bitmap->h(), source_bitmap->w(), &this->options);
 
   //= SCAN ==============//
-  start_timer();
+  cpu_timer.start();
   scan();
-  reports["scan"] = end_timer();
+  reports["scan"] = cpu_timer.stop();
   //=====================//
 
   //= BUILD_TANGS_SEQUENCE ===//
-  start_timer();
+  cpu_timer.start();
   node_cluster->build_tangs_sequence();
-  reports["build_tangs_sequence"] = end_timer();
+  reports["build_tangs_sequence"] = cpu_timer.stop();
   //=====================//
 
   //= PLOT ===//
-  start_timer();
+  cpu_timer.start();
   node_cluster->plot(this->options.versus);
-  reports["plot"] = end_timer();
+  reports["plot"] = cpu_timer.stop();
   //=====================//
 
   //= COMPRESS_COORDS ===//
-  start_timer();
-  node_cluster->compress_coords(this->options);
-  reports["compress"] = end_timer();
+  cpu_timer.start();
+  node_cluster->compress_coords(this->node_cluster->polygons, this->options);
+  reports["compress"] = cpu_timer.stop();
   //=====================//
   reports["total"] = reports["scan"] + reports["build_tangs_sequence"] + reports["plot"] + reports["compress"];
 }
 
 std::list<ShapeLine*> *PolygonFinder::get_shapelines() {
   std::list<ShapeLine*> *sll = new std::list<ShapeLine*>();
-  for (int line = 0; line < this->node_cluster->height; line++)
-  { for (std::vector<Node*>::iterator node = this->node_cluster->vert_nodes[line].begin(); node != this->node_cluster->vert_nodes[line].end(); ++node)
-    { ShapeLine *sl = new ShapeLine({(*node)->min_x, (*node)->max_x, (*node)->y});
+  for (int line = 0; line < this->node_cluster->height; line++) {
+    for (Node& node : this->node_cluster->vert_nodes[line]) {
+      ShapeLine *sl = new ShapeLine({node.min_x, node.max_x, node.y});
       sll->push_back(sl);
     }
   }
-  return(sll);
-}
-
-void PolygonFinder::sanitize_options(std::vector<std::string> *incoming_options)
-{ std::vector<char*> argv0;
-  for (const auto& arg : *incoming_options)
-  argv0.push_back((char*)arg.data());
-  argv0.push_back(nullptr);
-  char** argv = &argv0[0];
-  int argc = argv0.size() -1;
-
-  enum  optionIndex { COMPRESS_UNIQ, VERSUS, COMPRESS_VISVALINGAM, COMPRESS_LINEAR, COMPRESS_VISVALINGAM_TOLERANCE, TREEMAP};
-  const option::Descriptor usage[] = {
-     //  {UNKNOWN, 0,"" , ""    ,option::Arg::None, 0},
-     {COMPRESS_VISVALINGAM, 0, "" , "compress_visvalingam", option::Arg::None, 0},
-     {COMPRESS_LINEAR, 0, "" , "compress_linear", option::Arg::None, 0},
-     {COMPRESS_VISVALINGAM_TOLERANCE, 0, "" , "compress_visvalingam_tolerance", option::Arg::Optional, 0},
-     {COMPRESS_UNIQ, 0, "", "compress_uniq", option::Arg::None, 0},
-     {TREEMAP, 0, "", "treemap", option::Arg::None, 0},
-     {VERSUS, 0, "v", "versus", option::Arg::Optional, 0},
-     {0, 0, 0, 0, 0, 0}
-  };
-
-  option::Stats  stats(usage, argc, argv);
-  option::Option ioptions[stats.options_max], buffer[stats.buffer_max];
-  option::Parser parse(usage, argc, argv, ioptions, buffer);
-
-  if (parse.error())  return;
-  // VERSUS
-  if (ioptions[VERSUS].count() > 0)
-  { for (option::Option* opt = ioptions[VERSUS]; opt; opt = opt->next())
-    { std::string opts = opt->arg;
-      this->options.versus = (opts.compare("a") == 0 ? Node::A : Node::O);
-      break;
-    }
-  }
-  // COMPRESS UNIQ
-  if (ioptions[COMPRESS_UNIQ].count() > 0)
-  { this->options.compress_uniq = true;
-  }
-  // TREEMAP
-  if (ioptions[TREEMAP].count() > 0)
-  { this->options.treemap = true;
-  }
-  // COMPRESS LINEAR
-  if (ioptions[COMPRESS_LINEAR].count() > 0)
-  { this->options.compress_linear = true;
-  }
-  // COMPRESS UNIQ
-  if (ioptions[COMPRESS_VISVALINGAM].count() > 0)
-  { this->options.compress_visvalingam = true;
-  }
-  if (ioptions[COMPRESS_VISVALINGAM_TOLERANCE].count() > 0)
-  { this->options.compress_visvalingam = true;
-    for (option::Option* opt = ioptions[COMPRESS_VISVALINGAM_TOLERANCE]; opt; opt = opt->next())
-    { std::string opts = opt->arg;
-      this->options.compress_visvalingam_tolerance = strtof(opt->arg, 0);
-      break;
-    }
-  }
-  /*std::cout << "-----------" << std::endl;
-  std::cout << "versus" << this->options.versus << std::endl;
-  std::cout << "uniq" << this->options.compress_uniq << std::endl;
-  std::cout << "linear" << this->options.compress_linear << std::endl;
-  std::cout << "visvalingam" << this->options.compress_visvalingam << std::endl;
-  std::cout << this->options.compress_visvalingam_tolerance << std::endl;
-  std::cout << "-----------" << std::endl;*/
-}
-
-void PolygonFinder::start_timer() {
-  timer_start = std::clock();
-}
-
-double PolygonFinder::end_timer() {
-  std::clock_t c_end = std::clock();
-  return 1000.0 * (c_end - timer_start) / CLOCKS_PER_SEC;
+  return sll;
 }
 
 PolygonFinder::~PolygonFinder() {
+  delete this->node_cluster;
 }
 
 void PolygonFinder::scan() {
-  char last_color = 0, color = 0;
-  int min_x = 0;
-  int max_x = 0;
-  bool match;
-  bool matching = false;
-
-  for (int y = 0; y < this->source_bitmap->h(); y++)
-  { for (int x = 0; x < this->source_bitmap->w(); x++)
-    { color = this->source_bitmap->value_at(x, y);
-      match = this->source_bitmap->pixel_match(x, y, this->matcher);
-      if (match && matching == false)
-      { min_x = x;
-        last_color = color;
-        matching = true;
-        if (x == (this->source_bitmap->w() - 1) )
-        { max_x = x;
-          this->node_cluster->add_node(new Node(min_x, max_x, y, last_color));
-          matching = false;
-        }
-      } else {
-        if (!match && matching == true)
-        { max_x = x - 1;
-          this->node_cluster->add_node(new Node(min_x, max_x, y, last_color));
-          matching = false;
-        } else {
-                  if (x == (this->source_bitmap->w()-1) && matching == true)
-                  { max_x = x;
-                    this->node_cluster->add_node(new Node(min_x, max_x, y, last_color));
-                    matching = false;
-                  }
-                }
-      }
+    int bpp = this->source_bitmap->get_bytes_per_pixel();
+
+    RGBMatcher* rgb_m = dynamic_cast<RGBMatcher*>(this->matcher);
+
+    if (bpp == 1) {
+      auto fetcher = [](const unsigned char* p) { return static_cast<unsigned int>(p[0]); };
+      if (rgb_m) run_loop(rgb_m, fetcher);
+      else       run_loop(this->matcher, fetcher);
+    } else {
+      auto fetcher = [](const unsigned char* p) { return p[0] | (p[1] << 8) | (p[2] << 16); };
+      if (rgb_m) run_loop(rgb_m, fetcher);
+      else       run_loop(this->matcher, fetcher);
     }
-  }
 }
 
 ProcessResult* PolygonFinder::process_info() {
   ProcessResult *pr = new ProcessResult();
-  pr->groups = this->node_cluster->sequences->size();
-  pr->polygons = this->node_cluster->polygons;
-  pr->benchmarks = this->reports;
+  pr->groups = this->node_cluster->sequences.size();
+  pr->polygons = std::move(this->node_cluster->polygons);
+  pr->benchmarks = std::move(this->reports);
   pr->treemap = this->node_cluster->treemap;
 
-  if (typeid(*this->source_bitmap) == typeid(Bitmap))
+  if (this->node_cluster->options->named_sequences && typeid(*this->source_bitmap) == typeid(Bitmap))
   { std::string sequence;
     int n = 0;
-    for (std::list<std::list<Node*>*>::iterator list = this->node_cluster->sequences->begin(); list != this->node_cluster->sequences->end(); ++list, n++)
-    { std::string seq;
-      for (std::list<Node*>::iterator node = (*list)->begin(); node != (*list)->end(); ++node)
-      { seq += (*node)->name;
+    for (const auto& seq_list : this->node_cluster->sequences) {
+      std::string seq;
+      for (Node* node : seq_list) {
+        seq += node->name;
       }
       if (n != 0) sequence += '-';
       sequence += seq;
+      n++;
     }
     pr->named_sequence = sequence;
   }

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

@@ -6,15 +6,20 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGONFINDER_H_
-#define POLYGONFINDER_H_
-
+#pragma once
 #include <list>
 #include <vector>
-#include "Node.h"
 #include <ctime>
 #include <string>
 #include <map>
+#include <iostream>
+#include <utility>
+#include "../bitmaps/Bitmap.h"
+#include "NodeCluster.h"
+#include "Node.h"
+#include "Polygon.h"
+#include "Node.h"
+#include "../CpuTimer.h"
 
 class Bitmap;
 class Matcher;
@@ -33,37 +38,101 @@ struct pf_Options {
   bool compress_uniq = false;
   bool compress_linear = false;
   bool compress_visvalingam = false;
+  bool named_sequences = false;
+  bool bounds = false;
   float compress_visvalingam_tolerance = 10.0;
+  int number_of_tiles = 1;
+  std::string get_alpha_versus() {
+    return(versus == Node::A ? "a" : "o");
+  }
 };
 struct ProcessResult {
   int groups;
   std::map<std::string, double> benchmarks;
-  std::list<std::map<std::string, std::list<std::list<Point*>*>>> polygons;
+  std::list<Polygon> polygons;
   std::string named_sequence;
-  std::list<int*> treemap;
+  std::vector<std::pair<int, int>> treemap;
+
+  void print_polygons() {
+    int counter = 0;
+    for (const auto& polygon : polygons) {
+      std::cout << counter << " - " << "outer" << "\n";
+      for (const Point* p : polygon.outer) std::cout << p->toString();
+      bool first = true;
+      for (const auto& seq : polygon.inner) {
+        if (!first) std::cout << "\n";
+        first = false;
+        for (const Point* p : seq) std::cout << p->toString();
+      }
+      std::cout << "\n";
+      counter++;
+    }
+  }
+
+  void print_info() {
+    for (const auto& [key, value] : benchmarks) {
+      std::cout << key << ": " << value << ", ";
+    }
+    std::cout << std::endl;
+  }
 };
 
 class PolygonFinder {
+ protected:
+  int start_x;
+  int end_x;
+
  private:
   Bitmap *source_bitmap;
   Matcher *matcher;
+  RGBMatcher* rgb_matcher;
   NodeCluster *node_cluster;
   pf_Options options;
   std::map<std::string, double> reports;
-  void start_timer();
-  double end_timer();
   void scan();
-  std::clock_t timer_start, timer_end;
-  void sanitize_options(std::vector<std::string> *incoming_options);
+  CpuTimer cpu_timer;
+
+  template <typename M, typename F>
+  void run_loop(M* specific_matcher, F&& fetch_color) {
+    int img_h = this->source_bitmap->h();
+    int bpp = this->source_bitmap->get_bytes_per_pixel();
+    for (int y = 0; y < img_h; y++) {
+      const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
+      const unsigned char* p = row_ptr + (this->start_x * bpp);
+      int min_x = 0;
+      bool matching = false;
+      unsigned char last_red_value = 0;
+      for (int x = this->start_x; x < this->end_x; x++) {
+        unsigned int color = fetch_color(p);
+        unsigned char current_val = p[0];
+        p += bpp;
+        if (specific_matcher->match(color)) {
+          if (!matching) {
+            min_x = x;
+            last_red_value = current_val;
+            matching = true;
+          }
+          if (x == this->end_x - 1) {
+            this->node_cluster->add_node(min_x, x, y, last_red_value);
+            matching = false;
+          }
+        } else if (matching) {
+          this->node_cluster->add_node(min_x, x - 1, y, last_red_value);
+          matching = false;
+        }
+      }
+    }
+  }
 
  public:
-  PolygonFinder(Bitmap *bitmap, Matcher *matcher, Bitmap *test_bitmap, std::vector<std::string> *options = nullptr);
+  PolygonFinder(Bitmap *bitmap,
+                Matcher *matcher,
+                Bitmap *test_bitmap,
+                std::vector<std::string> *options = nullptr,
+                int start_x = 0,
+                int end_x = -1);
   ProcessResult* process_info();
   std::list<ShapeLine*> *get_shapelines();
   virtual ~PolygonFinder();
+  const NodeCluster* get_cluster() const { return this->node_cluster; }
 };
-
-
-
-
-#endif /* POLYGONFINDER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/RectBounds.h

@@ -0,0 +1,39 @@
+/*
+ * RectBounds.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <limits>
+#include <algorithm>
+
+struct RectBounds {
+  int min_x = std::numeric_limits<int>::max();
+  int max_x = std::numeric_limits<int>::min();
+  int min_y = std::numeric_limits<int>::max();
+  int max_y = std::numeric_limits<int>::min();
+
+  static RectBounds empty() {
+    return RectBounds{};
+  }
+
+  inline RectBounds& expand(int x, int 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;
+    return *this;
+  }
+
+  inline bool is_empty() const {
+    return min_x == std::numeric_limits<int>::max();
+  }
+
+  inline int width() const {
+    if (is_empty()) return 0;
+    return(max_x - min_x);
+  }
+};

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

@@ -0,0 +1,14 @@
+/*
+ * ClippedPolygonFinder.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+#include <string>
+#include <vector>
+#include "ClippedPolygonFinder.h"
+
+ClippedPolygonFinder::ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bitmap_start_x, int bitmap_end_x, std::vector<std::string> *options)
+: PolygonFinder(bitmap, matcher, nullptr, options, bitmap_start_x, bitmap_end_x) {
+}

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

@@ -0,0 +1,17 @@
+/*
+ * ClippedPolygonFinder.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <string>
+#include <vector>
+#include "../PolygonFinder.h"
+
+class ClippedPolygonFinder : public PolygonFinder {
+ public:
+  ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bm_start_x, int bm_end_x, std::vector<std::string> *options = nullptr);
+};

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

@@ -0,0 +1,117 @@
+/*
+ * Cluster.cpp
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <vector>
+#include <list>
+#include <iostream>
+#include "Cluster.h"
+#include "Shape.h"
+#include "Polyline.h"
+#include "Sequence.h"
+#include "Cursor.h"
+#include "../../CpuTimer.h"
+
+Cluster::Cluster(Finder *finder, int height, int width)
+  : finder(finder)
+{ tiles_.reserve(2);  // only two (left|right)
+  this->hub_ = new Hub(height, width);
+}
+
+Cluster::~Cluster() {
+  for (Tile* tile : tiles_) {
+    delete tile;
+  }
+  delete this->hub_;
+}
+
+void Cluster::add(Tile* tile) {
+  Tile* last_tile = tiles_.empty() ? nullptr : tiles_.back();
+  tiles_.push_back(tile);
+  tile->cluster = this;
+  if (last_tile) {
+    last_tile->next = last_tile->circular_next = tile;
+    tile->prev = tile->circular_next = last_tile;
+  }
+}
+
+void Cluster::list_to_string(std::vector<Point*> list)
+{ std::cout << "(" << &list << ") ";
+  for (Point* point : list) {
+    std::cout << point->toString();
+  }
+  std::cout << std::endl;
+}
+
+Tile* Cluster::merge_tiles() {
+  double tot_inner = 0;
+  double tot_outer = 0;
+  CpuTimer timer;
+  std::list<Shape*> shapes;
+
+  timer.start();
+  for (Tile* tile : tiles_) {
+    for (Shape *shape : tile->shapes()) {
+      if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) continue;
+      if (shape->outer_polyline->boundary())
+      { shape->outer_polyline->partition();
+        shape->outer_polyline->precalc();
+      }
+    }
+  }
+  tot_outer += timer.stop();
+
+  for (Tile* tile : tiles_) {
+    std::list<Shape*>& src = tile->shapes();
+    for (auto it = src.begin(); it != src.end(); )
+    { Shape* shape = *it;
+      if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0)
+      { it++;
+        continue;
+      }
+
+      if (shape->outer_polyline->boundary() && !shape->outer_polyline->next_tile_eligible_shapes().empty()) {
+        Sequence* new_outer = nullptr;
+        std::list<std::vector<Point*>> new_inners = shape->inner_polylines;
+        Cursor cursor(*this, shape);
+        timer.start();
+        new_outer = cursor.join_outers();
+        tot_outer += timer.stop();
+
+        timer.start();
+        std::vector<Sequence*> new_inner_sequences = cursor.join_inners(new_outer);
+        tot_inner += timer.stop();
+
+        for (Sequence* s : new_inner_sequences) {
+          new_inners.push_back(s->to_vector());
+          delete s;
+        }
+        for (auto s : cursor.orphan_inners()) {
+          new_inners.push_back(s);
+        }
+        Polyline* polyline = new Polyline(tile, new_outer->to_vector());
+        Shape* shape = new Shape(polyline, new_inners);
+        shapes.push_back(shape);
+        polyline->shape = shape;
+        it++;
+      } else {
+        shapes.push_back(shape);
+        it = src.erase(it);
+      }
+    }
+  }
+  double past_tot_outer = tiles_.front()->benchmarks.outer + tiles_.back()->benchmarks.outer;
+  double past_tot_inner = tiles_.front()->benchmarks.inner + tiles_.back()->benchmarks.inner;
+  Benchmarks b{
+    tot_outer + past_tot_outer,
+    tot_inner + past_tot_inner
+  };
+  Tile* tile = new Tile(this->finder, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
+  tile->assign_shapes(shapes);
+  return(tile);
+}
+

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

@@ -0,0 +1,32 @@
+/*
+ * Cluster.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <vector>
+#include <deque>
+#include "Finder.h"
+#include "Cluster.h"
+#include "Hub.h"
+#include "PartPool.h"
+
+class Cluster {
+ private:
+  Finder *finder;
+  std::vector<Tile*> tiles_;
+  Hub *hub_ = nullptr;
+ public:
+  Cluster(Finder *finder, int height, int width);
+  virtual ~Cluster();
+  void add(Tile* tile);
+  Tile* merge_tiles();
+  const std::vector<Tile*> tiles() const { return tiles_; }
+  Hub* hub() { return hub_; }
+  static void list_to_string(std::vector<Point*> list);
+  PartPool parts_pool;
+  std::deque<Position> positions_pool;
+};