contrek 1.0.0

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

@@ -0,0 +1,325 @@
+/*
+ * NodeCluster.cpp
+ *
+ *  Created on: 26 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "NodeCluster.h"
+#include "Node.h"
+#include "../reducers/UniqReducer.h"
+#include "../reducers/LinearReducer.h"
+#include "../reducers/VisvalingamReducer.h"
+#include <iostream>
+#include <list>
+#include <algorithm>
+#include <map>
+#include <string>
+#include <vector>
+
+NodeCluster::NodeCluster(int h, pf_Options *options) {
+  this->vert_nodes = new std::vector<Node*>[h];
+  versus_inverter[Node::O] = Node::A;
+  versus_inverter[Node::A] = Node::O;
+  this->options = options;
+  this->height = h;
+  this->nodes = 0;
+  this->plot_sequence = nullptr;
+  this->sequence_coords = nullptr;
+  this->sequences = new std::list<std::list<Node*>*>();
+
+  this->root_nodes = this->lists.add_list();
+  this->inner_plot = this->lists.add_list();
+  this->inner_new = this->lists.add_list();
+}
+
+NodeCluster::~NodeCluster() {
+}
+
+void NodeCluster::compress_coords(pf_Options options) {
+  if (options.compress_linear || options.compress_uniq || options.compress_visvalingam)
+  { std::list<std::list<Point*>*> sequences;
+    for (std::list<std::map<std::string, std::list<std::list<Point*>*>>>::iterator x = this->polygons.begin(); x != this->polygons.end(); ++x)
+    { for (std::list<std::list<Point*>*>::iterator y = (*x)["outer"].begin(); y != (*x)["outer"].end(); ++y)
+      { sequences.push_back(*y);
+      }
+      for (std::list<std::list<Point*>*>::iterator y = (*x)["inner"].begin(); y != (*x)["inner"].end(); ++y)
+      { sequences.push_back(*y);
+      }
+    }
+    if (options.compress_uniq)
+    { for (std::list<std::list<Point*>*>::iterator it = sequences.begin(); it != sequences.end(); ++it)
+      { UniqReducer reducer(*it);
+        reducer.reduce();
+      }
+    }
+    if (options.compress_linear)
+    { for (std::list<std::list<Point*>*>::iterator it = sequences.begin(); it != sequences.end(); ++it)
+      { LinearReducer reducer(*it);
+        reducer.reduce();
+      }
+    }
+    if (options.compress_visvalingam)
+    { for (std::list<std::list<Point*>*>::iterator it = sequences.begin(); it != sequences.end(); ++it)
+      { VisvalingamReducer reducer(*it, options.compress_visvalingam_tolerance);
+        reducer.reduce();
+      }
+    }
+  }
+}
+
+
+void NodeCluster::build_tangs_sequence() {
+  for (int line = 0; line < this->height; line++)
+  { for (std::vector<Node*>::iterator node = vert_nodes[line].begin(); node != vert_nodes[line].end(); ++node)
+    { (*node)->precalc_tangs_sequences();
+    }
+  }
+}
+
+void NodeCluster::add_node(Node *node) {
+  this->nodes++;
+  node->data_pointer = this->lists.get_data_pointer();
+  node->abs_x_index = vert_nodes[node->y].size();
+  vert_nodes[node->y].push_back(node);
+  root_nodes->push_back(node);
+
+  if (node->y > 0)
+  { std::vector<Node*> *up_nodes = &vert_nodes[node->y - 1];
+    int up_nodes_count = up_nodes->size();
+    Node *up_node;
+    if (up_nodes_count > 0)
+    { int index = 0;
+      do
+      { up_node = (*up_nodes)[index];
+          if (up_node->max_x >= node->min_x)
+          { if (up_node->min_x <= node->max_x)
+            { node->add_intersection(up_node);
+              (up_node)->add_intersection(node);
+            }
+          if (++index == up_nodes_count) return;
+          do
+          { up_node = (*up_nodes)[index];
+            if (up_node->min_x <= node->max_x)
+            {   node->add_intersection(up_node);
+              (up_node)->add_intersection(node);
+            }
+            else  return;
+          }while (++index != up_nodes_count);
+          return;
+          }
+      }while(++index != up_nodes_count);
+    }
+  }
+}
+
+std::list<Point*>* NodeCluster::get_coords() {
+  return(this->sequence_coords);
+}
+
+void NodeCluster::plot(int versus) {
+  int inner_v = versus_inverter[versus];
+  int index_order = 0;
+  Node *next_node;
+
+  while (root_nodes->size() > 0)
+  { Node *root_node = (Node*) root_nodes->shift();
+    root_node->outer_index = index_order;
+    this->plot_sequence = new std::list<Node*>();
+    this->sequence_coords = new std::list<Point*>();
+
+    plot_sequence->push_back(root_node);
+
+    if ((root_node)->tangs_sequence->size() > 0)  // front() on empty list is undefined
+    { versus == Node::A ? next_node = root_node->tangs_sequence->back()->node : next_node = root_node->tangs_sequence->front()->node;
+      if (next_node != nullptr)
+      { sequence_coords->push_back(next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER));
+      }
+      if ((this->nodes > 0) && (next_node != nullptr))
+      { plot_node(next_node, root_node, versus);
+      }
+      this->sequences->push_back(plot_sequence);
+      std::list<std::list<Point*>*> outer_container, inner_container;
+      outer_container.push_back(sequence_coords);
+      std::list<Point*> pl_inner;
+      std::map<std::string, std::list<std::list<Point*>*>> poly;
+      poly["outer"] = outer_container;
+      poly["inner"] = inner_container;
+      if (sequence_coords->size() > 2) this->polygons.push_back(poly);
+
+      int index_inner = 0;
+      while (inner_plot->size() > 0)
+      { this->plot_sequence = new std::list<Node*>();
+        this->sequence_coords = new std::list<Point*>();
+        std::list<Node*>::iterator first_i;
+        Node *first = nullptr;
+
+        Listable *act = inner_plot->first();
+        do
+        { if (((Node*)act)->tangs_count <= 2)
+          { first = (Node*) act;
+            break;
+          }
+        }while((act = act->data_pointer[inner_plot->get_id()].next) != nullptr);
+
+        if (first == nullptr) first = (Node*) inner_plot->first();
+
+        plot_sequence->push_back(first);
+        inner_plot->remove(first);
+        root_nodes->remove(first);
+
+        first->inner_index = index_inner;
+
+        Node *next_node;
+        if (first->get_trackmax())
+        { if (inner_v == Node::A)  next_node = first->tangs[Node::T_UP].front();
+          else                     next_node = first->tangs[Node::T_DOWN].front();
+        } else {
+          if (inner_v == Node::A)  next_node = first->tangs[Node::T_DOWN].back();
+          else                     next_node = first->tangs[Node::T_UP].back();
+        }
+
+        if (next_node != nullptr)
+        { sequence_coords->push_back(next_node->coords_entering_to(first, inner_v, Node::INNER));
+          plot_inner_node(next_node, inner_v, first, root_node);
+        }
+
+        this->polygons.back()["inner"].push_back(sequence_coords);
+        this->inner_plot->grab(this->inner_new);
+        index_inner++;
+      }
+    } else {
+      this->sequences->push_back(plot_sequence);
+    }
+    // tree
+    if (this->options->treemap)
+    { this->treemap.push_back(versus == Node::A ? this->test_in_hole_a(root_node) : this->test_in_hole_o(root_node));
+    }
+    index_order++;
+  }
+}
+
+int *NodeCluster::test_in_hole_a(Node *node)
+{ if (node->outer_index > 0)
+  { int start_left = node->abs_x_index - 1;
+    do
+    { Node *prev = this->vert_nodes[node->y][start_left];
+      int cindex = prev->outer_index;
+      if ((cindex < node->outer_index) && ((prev->track & Node::IMAX) != 0))
+      { unsigned int start_right = node->abs_x_index;
+        unsigned int line_size = this->vert_nodes[node->y].size();
+        while (++start_right != line_size)
+        { Node *tnext = this->vert_nodes[node->y][start_right];
+          if (tnext->outer_index == cindex)
+          { if ((tnext->track & Node::IMIN) != 0)  return(new int[2] {cindex, prev->inner_index});
+            else                                   return(new int[2] {-1, -1});
+          }
+        }
+      }
+    }while(--start_left >= 0);
+  }
+  return(new int[2] {-1, -1});
+}
+
+int *NodeCluster::test_in_hole_o(Node *node)
+{ unsigned int line_size = this->vert_nodes[node->y].size();
+  if ((node->outer_index) > 0 && (vert_nodes[node->y].back() != node))
+  { unsigned int start_left = node->abs_x_index + 1;
+    do
+    { Node *prev = this->vert_nodes[node->y][start_left];
+      int cindex = prev->outer_index;
+      if ((cindex < node->outer_index) && ((prev->track & Node::IMIN) != 0))
+      { int start_right = node->abs_x_index;
+        while (--start_right >= 0)
+        { Node *tnext = this->vert_nodes[node->y][start_right];
+          if (tnext->outer_index == cindex)
+          { if ((tnext->track & Node::IMAX) != 0)  return(new int[2] {cindex, prev->inner_index});
+            else                                   return(new int[2] {-1, -1});
+          }
+        }
+      }
+    }while(++start_left != line_size);
+  }
+  return(new int[2] {-1, -1});
+}
+
+void NodeCluster::plot_inner_node(Node *node, int versus, Node *stop_at, Node *start_node) {
+  node->outer_index = start_node->outer_index;
+  node->inner_index = stop_at->inner_index;
+  root_nodes->remove(node);
+  inner_plot->remove(node);
+
+  Node *last_node = plot_sequence->back();
+  Node *next_node = node->my_next_inner(last_node, versus);
+
+  plot_sequence->push_back(node);
+
+  bool plot = true;
+  if (next_node -> y == last_node -> y)
+  { Node *n = (versus == Node::A ? node->tangs_sequence->front()->node : node->tangs_sequence->back()->node);
+    plot = (n == next_node);
+  }
+  if (plot)
+  { sequence_coords->push_back(last_node->coords_entering_to(node, versus_inverter[versus], Node::INNER));
+    if (node != start_node)
+    { if (last_node->y == next_node->y)
+      { sequence_coords->push_back(next_node->coords_entering_to(node, versus, Node::INNER));
+      }
+    }
+  }
+  if (node->track_uncomplete())
+  { this->inner_new->push_back(node);
+  } else {
+    inner_new->remove(node);
+  }
+  if (next_node == stop_at) return;
+  plot_inner_node(next_node, versus, stop_at, start_node);
+}
+
+void NodeCluster::plot_node(Node *node, Node *start_node, int versus) {
+  root_nodes->remove(node);
+  node->outer_index = start_node->outer_index;
+  Node *last_node = plot_sequence->back();
+  Node *next_node = node->my_next_outer(last_node, versus);
+
+  plot_sequence->push_back(node);
+  bool plot = true;
+  if (next_node -> y == last_node -> y)
+  { Node *n = (versus == Node::A ? node->tangs_sequence->back()->node : node->tangs_sequence->front()->node);
+    plot = (n == next_node);
+  }
+
+  if (plot)
+  { sequence_coords->push_back(last_node->coords_entering_to(node, versus, Node::OUTER));
+    if (node != start_node)
+    { inner_plot->contains(node) ? inner_plot->remove(node) : inner_plot->push_back(node);
+      if (last_node->y == next_node->y)
+      { sequence_coords->push_back(next_node->coords_entering_to(node, versus_inverter[versus], Node::OUTER));
+        inner_plot->contains(node) ? inner_plot->remove(node) : inner_plot->push_back(node);
+      }
+    }
+  }
+  if (node == start_node)
+  { if (node->track_complete()) return;
+  }
+  plot_node(next_node, start_node, versus);
+}
+
+void NodeCluster::list_track(Node *node, std::list<Node*> *list) {
+  std::list<Node*>::iterator i = std::find(list->begin(), list->end(), node);
+  if (i == list->end())  list->push_back(node);
+  else                   list_delete(node, list);
+}
+
+void NodeCluster::list_delete(Node *node, std::list<Node*> *list) {
+  std::list<Node*>::iterator i;
+  while ((i = std::find(list->begin(), list->end(), node)) !=  list->end())
+  {  list->erase(i);
+  }
+}
+
+bool NodeCluster::list_present(Node *node, std::list<Node*> *list) {
+  std::list<Node*>::iterator i = std::find(list->begin(), list->end(), node);
+  return(!(i == list->end()));
+}

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

@@ -0,0 +1,59 @@
+/*
+ * NodeCluster.h
+ *
+ *  Created on: 26 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_FINDER_NODECLUSTER_H_
+#define POLYGON_FINDER_NODECLUSTER_H_
+#include <list>
+#include <vector>
+#include <map>
+#include <string>
+#include "PolygonFinder.h"
+#include "Lists.h"
+
+class Node;
+struct Point;
+struct pf_Options;
+
+class NodeCluster {
+ private:
+  void plot_node(Node *node, Node *start_node, int versus);
+  void plot_inner_node(Node *node, int versus, Node *stop_at, Node *start_node);
+  std::list<Node*> *plot_sequence;
+  List *inner_plot;
+  std::list<Point*> *sequence_coords;
+  List *inner_new;
+  int versus_inverter[2];
+  int count = 0;
+  int nodes;
+  pf_Options *options;
+
+ public:
+  std::list<int*> treemap;
+  int *test_in_hole_a(Node *node);
+  int *test_in_hole_o(Node *node);
+  std::vector<Node*> *vert_nodes;
+  void list_track(Node *node, std::list<Node*> *list);
+  void list_delete(Node *node, std::list<Node*> *list);
+  bool list_present(Node *node, std::list<Node*> *list);
+  void compress_coords(pf_Options options);
+  List *root_nodes;
+  int height;
+  std::list<std::map<std::string, std::list<std::list<Point*>*>>> polygons;
+  NodeCluster(int h, pf_Options *options);
+  virtual ~NodeCluster();
+  void add_node(Node *node);
+  void calc_root_nodes();
+  void build_tangs_sequence();
+  void plot(int versus);
+  Lists lists;
+  std::list<Node*>::iterator exam(std::list<Node*>::iterator inode, Node *node, Node *father, Node *root_node);
+  std::list<Point*>* get_coords();
+  std::list<std::list<Node*>*> *sequences;
+};
+
+#endif /* POLYGON_FINDER_NODECLUSTER_H_ */

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

@@ -0,0 +1,206 @@
+/*
+ * PolygonFinder.cpp
+ *
+ *  Created on: 24 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+
+#include <iostream>
+#include <list>
+#include <map>
+#include <ctime>
+#include <typeinfo>
+#include <string>
+#include <ctime>
+#include <vector>
+#include "PolygonFinder.h"
+#include "../bitmaps/Bitmap.h"
+#include "../matchers/Matcher.h"
+#include "../matchers/RGBMatcher.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);
+
+  //= SCAN ==============//
+  start_timer();
+  scan();
+  reports["scan"] = end_timer();
+  //=====================//
+
+  //= BUILD_TANGS_SEQUENCE ===//
+  start_timer();
+  node_cluster->build_tangs_sequence();
+  reports["build_tangs_sequence"] = end_timer();
+  //=====================//
+
+  //= PLOT ===//
+  start_timer();
+  node_cluster->plot(this->options.versus);
+  reports["plot"] = end_timer();
+  //=====================//
+
+  //= COMPRESS_COORDS ===//
+  start_timer();
+  node_cluster->compress_coords(this->options);
+  reports["compress"] = end_timer();
+  //=====================//
+  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});
+      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;
+}
+
+PolygonFinder::~PolygonFinder() {
+}
+
+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;
+                  }
+                }
+      }
+    }
+  }
+}
+
+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->treemap = this->node_cluster->treemap;
+
+  if (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;
+      }
+      if (n != 0) sequence += '-';
+      sequence += seq;
+    }
+    pr->named_sequence = sequence;
+  }
+  else pr->named_sequence = "";
+  return(pr);
+}

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

@@ -0,0 +1,69 @@
+/*
+ * PolygonFinder.h
+ *
+ *  Created on: 24 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGONFINDER_H_
+#define POLYGONFINDER_H_
+
+#include <list>
+#include <vector>
+#include "Node.h"
+#include <ctime>
+#include <string>
+#include <map>
+
+class Bitmap;
+class Matcher;
+class RGBMatcher;
+class NodeCluster;
+class Node;
+struct Point;
+
+struct ShapeLine {
+  int start_x, end_x, y;
+};
+
+struct pf_Options {
+  int versus = Node::A;
+  bool treemap = false;
+  bool compress_uniq = false;
+  bool compress_linear = false;
+  bool compress_visvalingam = false;
+  float compress_visvalingam_tolerance = 10.0;
+};
+struct ProcessResult {
+  int groups;
+  std::map<std::string, double> benchmarks;
+  std::list<std::map<std::string, std::list<std::list<Point*>*>>> polygons;
+  std::string named_sequence;
+  std::list<int*> treemap;
+};
+
+class PolygonFinder {
+ private:
+  Bitmap *source_bitmap;
+  Matcher *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);
+
+ public:
+  PolygonFinder(Bitmap *bitmap, Matcher *matcher, Bitmap *test_bitmap, std::vector<std::string> *options = nullptr);
+  ProcessResult* process_info();
+  std::list<ShapeLine*> *get_shapelines();
+  virtual ~PolygonFinder();
+};
+
+
+
+
+#endif /* POLYGONFINDER_H_ */