contrek 1.0.0

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

@@ -0,0 +1,120 @@
+/*
+ * List.cpp
+ *
+ *  Created on: 08 gen 2019
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "List.h"
+#include <iostream>
+
+class Listable;
+
+List::List(int id) {
+  this->start = nullptr;
+  this->end = nullptr;
+  this->isize = 0;
+  this->idd = id;
+}
+
+List::~List() {
+}
+
+Listable *List::first() {
+  return(this->start);
+}
+Listable *List::last() {
+  return(this->end);
+}
+
+bool List::contains(Listable *entry) {
+  return(entry->data_pointer[this->idd].inside);
+}
+int List::get_id() {
+  return(this->idd);
+}
+
+void List::grab(List *source_list) {
+  if (source_list->size() == 0) return;
+  int source_list_idd = source_list->get_id();
+  Listable *source_list_start_entry = source_list->first();
+
+  Listable *act = source_list->last();
+  while (true)
+  { if ((act = act->data_pointer[source_list_idd].prev) == nullptr) break;
+  }
+  Listable *source_entry = source_list->first();
+  while (true)
+  { source_entry->data_pointer[this->idd] = source_entry->data_pointer[source_list_idd];
+    Listable *next_entry = source_entry->data_pointer[source_list_idd].next;
+    source_entry->data_pointer[source_list_idd].inside = false;
+    source_entry->data_pointer[source_list_idd].next = nullptr;
+    source_entry->data_pointer[source_list_idd].prev = nullptr;
+    if (next_entry == nullptr) break;
+    source_entry = next_entry;
+  }
+  source_list_start_entry->data_pointer[this->idd].prev = this->end;
+  if (this->end != nullptr) this->end->data_pointer[this->idd].next = source_list_start_entry;
+  this->end = source_list->last();
+  if (this->start == nullptr) this->start = source_list->first();
+  this->isize += source_list->size();
+  source_list->reset();
+}
+
+void List::reset()  {
+  this->end = nullptr;
+  this->start = nullptr;
+  this->isize = 0;
+}
+
+Listable *List::shift() {
+  if (this->isize == 0) return(nullptr);
+  Listable *retme = this->start;
+  Listable *next_of_retme = retme->data_pointer[this->idd].next;
+  this->start = next_of_retme;
+  if (retme == this->end) this->end = nullptr;
+  if (next_of_retme != nullptr) next_of_retme->data_pointer[this->idd].prev = nullptr;
+  this->isize--;
+  retme->data_pointer[this->idd].next = nullptr;
+  retme->data_pointer[this->idd].prev = nullptr;
+  retme->data_pointer[this->idd].inside = false;
+  return (retme);
+}
+
+void List::push_back(Listable *entry) {
+  if (entry->data_pointer[this->idd].inside) return;
+  if (this->isize > 0)
+  { this->end->data_pointer[this->idd].next = entry;
+    entry->data_pointer[this->idd].prev = this->end;
+  } else {
+    this->start = entry;
+  }
+  this->end = entry;
+  entry->data_pointer[this->idd].inside = true;
+  this->isize++;
+}
+int List::size() {
+  return(this->isize);
+}
+
+void List::remove(Listable *entry) {
+  if (this->isize == 0) return;
+  if (entry->data_pointer[this->idd].inside == false) return;
+  Listable *next_of_entry = entry->data_pointer[this->idd].next;
+  Listable *prev_of_entry = entry->data_pointer[this->idd].prev;
+
+  if (entry == this->start)
+  { this->start = next_of_entry;
+  }
+  if (entry == this->end)
+  { this->end = prev_of_entry;
+  }
+
+  if (next_of_entry != nullptr)  next_of_entry->data_pointer[this->idd].prev = prev_of_entry;
+  if (prev_of_entry != nullptr)  prev_of_entry->data_pointer[this->idd].next = next_of_entry;
+  entry->data_pointer[this->idd].next = nullptr;
+  entry->data_pointer[this->idd].prev = nullptr;
+  this->isize--;
+  entry->data_pointer[this->idd].inside = false;
+}

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

@@ -0,0 +1,40 @@
+/*
+ * List.h
+ *
+ *  Created on: 08 gen 2019
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_FINDER_LIST_H_
+#define POLYGON_FINDER_LIST_H_
+
+#include "Lists.h"
+struct Link;
+class Listable {
+ public:
+  Link *data_pointer;
+};
+
+class List {
+ public:
+  List(int id);
+  virtual ~List();
+  void push_back(Listable *entry);
+  void remove(Listable *entry);
+  void grab(List *source_list);
+  int size();
+  Listable *first();
+  Listable *last();
+  Listable *shift();
+  void reset();
+  bool contains(Listable *entry);
+  int get_id();
+ private:
+  Listable  *start;
+  Listable  *end;
+  int   isize;
+  int   idd;
+};
+
+#endif /* POLYGON_FINDER_LIST_H_ */

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

@@ -0,0 +1,36 @@
+/*
+ * Lists.cpp
+ *
+ *  Created on: 08 gen 2019
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Lists.h"
+#include "List.h"
+#include <list>
+struct Link;
+class List;
+Lists::Lists() {
+  this->lists = new std::list<List*>();
+}
+
+Lists::~Lists() {
+}
+
+List *Lists::add_list() {
+  List *list = new List(this->lists->size());
+  lists->push_back(list);
+  return(list);
+}
+
+Link *Lists::get_data_pointer() {
+  Link *data_pointer = new Link[this->lists->size()];
+  Link *dt = data_pointer;
+  for (unsigned int i = 0; i < this->lists->size(); ++i, dt++)
+  { dt->inside = false;
+    dt->next = nullptr;
+    dt->prev = nullptr;
+  }
+  return(data_pointer);
+}

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

@@ -0,0 +1,30 @@
+/*
+ * Lists.h
+ *
+ *  Created on: 08 gen 2019
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_FINDER_LISTS_H_
+#define POLYGON_FINDER_LISTS_H_
+#include <list>
+#include "List.h"
+class List;
+class Listable;
+struct Link {
+  Listable *next, *prev;
+  bool inside;
+};
+
+class Lists {
+ public:
+  Lists();
+  virtual ~Lists();
+  List *add_list();
+  Link *get_data_pointer();
+ private:
+  std::list<List*> *lists;
+};
+
+#endif /* POLYGON_FINDER_LISTS_H_ */

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

@@ -0,0 +1,111 @@
+/*
+ * Node.cpp
+ *
+ *  Created on: 26 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Node.h"
+#include <string>
+#include <string.h>
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <list>
+
+Node::Node(int min_x, int max_x, int y, char name) {
+  this->name = name;
+  this->min_x = min_x;
+  this->max_x = max_x;
+  this->y = y;
+  this->tangs_count = 0;
+  this->abs_x_index = 0;
+  this->down_indexer = 0;
+  this->up_indexer = 0;
+  this->track = 0;
+  this->outer_index = -1;
+  this->inner_index = -1;
+}
+
+Node::~Node() {
+}
+
+bool Node::get_trackmax() {
+  return((this->track & OMAX) != 0);
+}
+bool Node::track_complete() {
+  return((this->track & OCOMPLETE) == OCOMPLETE);
+}
+bool Node::track_uncomplete() {
+  return((this->track & OCOMPLETE) != OCOMPLETE);
+}
+
+bool Node::tangs_with(Node *node) {
+  return(this->min_x <= node->max_x && node->min_x <= this->max_x);
+}
+void Node::add_intersection(Node *other_node) {
+  if (other_node->y < this->y)
+  { tangs[T_UP].push_back(other_node);
+  } else {
+    tangs[T_DOWN].push_back(other_node);
+  }
+}
+
+void Node::precalc_tangs_sequences() {
+  this->tangs_sequence = new std::vector<NodeDescriptor*>(tangs[T_UP].size() + tangs[T_DOWN].size());
+
+  std::list<Node*> tangs_seq;
+  int n = 0;
+  // clockwise
+  tangs_seq = tangs[T_UP];
+  tangs_seq.sort(sort_min_x);
+  if (tangs_seq.size() > 0) this->up_indexer = -tangs_seq.front()->abs_x_index;
+  for (std::list<Node*>::iterator t_node = tangs_seq.begin(); t_node != tangs_seq.end(); ++t_node)
+  { (*this->tangs_sequence)[n++] = new NodeDescriptor({ *t_node,
+        new Tangent({new Point({(*t_node)->max_x, (*t_node)->y}), OMAX}),
+        new Tangent({new Point({(*t_node)->min_x, (*t_node)->y}), OMIN})});
+  }
+  tangs_seq = tangs[T_DOWN];
+  tangs_seq.sort(sort_max_x);
+  tangs_seq.reverse();
+  if (tangs_seq.size() > 0) this->down_indexer = (tangs_seq.back()->abs_x_index + tangs[T_UP].size() + tangs[T_DOWN].size() - 1);
+  for (std::list<Node*>::iterator t_node = tangs_seq.begin(); t_node != tangs_seq.end(); ++t_node)
+  { (*this->tangs_sequence)[n++] = new NodeDescriptor({ *t_node,
+        new Tangent({new Point({(*t_node)->min_x, (*t_node)->y}), OMIN}),
+        new Tangent({new Point({(*t_node)->max_x, (*t_node)->y}), OMAX})});
+  }
+  this->tangs_count = this->tangs_sequence->size();
+}
+bool Node::sort_min_x(Node *a, Node *b) {
+  return(a->min_x <= b->min_x);
+}
+bool Node::sort_max_x(Node *a, Node *b) {
+  return(a->max_x <= b->max_x);
+}
+Node* Node::my_next_inner(Node *last, int versus) {
+  unsigned int last_node_index;
+  if (last->y < this->y)       last_node_index = last->abs_x_index + this->up_indexer;
+  else            last_node_index = this->down_indexer - last->abs_x_index;
+  if (versus == Node::O) last_node_index == 0 ? last_node_index = this->tangs_sequence->size() - 1 : last_node_index--;
+  else          last_node_index == this->tangs_sequence->size() - 1 ? last_node_index = 0 : last_node_index++;
+  return((*this->tangs_sequence)[last_node_index]->node);
+}
+Node* Node::my_next_outer(Node *last, int versus) {
+  unsigned int last_node_index;
+  if (last->y < this->y) last_node_index = last->abs_x_index + this->up_indexer;
+  else                   last_node_index = this->down_indexer - last->abs_x_index;
+  if (versus == Node::O) last_node_index == this->tangs_sequence->size() - 1 ? last_node_index = 0 : last_node_index++;
+  else                   last_node_index == 0 ? last_node_index = this->tangs_sequence->size() - 1 : last_node_index--;
+  return((*this->tangs_sequence)[last_node_index]->node);
+}
+
+Point* Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
+  int enter_to_index;
+  if (enter_to->y < this->y) enter_to_index = enter_to->abs_x_index + this->up_indexer;
+  else                       enter_to_index = this->down_indexer - enter_to->abs_x_index;
+  NodeDescriptor *ds = (*this->tangs_sequence)[enter_to_index];
+  Tangent *t = (mode == Node::O ? ds->o : ds->a);
+  enter_to->track |= TURNER[tracking][t->mode - 1];
+  return(t->point);
+}

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

@@ -0,0 +1,80 @@
+/*
+ * Node.h
+ *
+ *  Created on: 26 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_FINDER_NODE_H_
+#define POLYGON_FINDER_NODE_H_
+#include <string>
+#include <vector>
+#include <list>
+#include <map>
+#include "List.h"
+
+struct Point {
+  int x;
+  int y;
+};
+struct Tangent {
+  Point   *point;
+  int   mode;
+};
+struct NodeDescriptor;
+
+
+class Node : public  Listable {
+ public:
+  static const int T_UP = 0;
+  static const int T_DOWN = 1;
+  static const int O = 0;
+  static const int A = 1;
+  static const int OMAX = 1 << 0;
+  static const int OMIN = 1 << 1;
+  static const int IMAX = 1 << 2;
+  static const int IMIN = 1 << 3;
+  static const int OCOMPLETE = OMIN | OMAX;
+  static const int TURN_MAX = IMAX | OMAX;
+  static const int TURN_MIN = IMIN | OMIN;
+  const int TURNER[2][2] = {{OMAX, OMIN}, {TURN_MAX, TURN_MIN}};
+  static const int OUTER = 0;
+  static const int INNER = 1;
+
+  std::list<Node*> tangs[2];
+  int y;
+  int abs_x_index;
+  int up_indexer, down_indexer;
+  int tangs_count;
+  char name;
+  int track;
+  int outer_index, inner_index;
+  bool tangs_with(Node *node);
+  void add_intersection(Node *other_node);
+  std::vector<NodeDescriptor*> *tangs_sequence;
+  Point* coords_entering_to(Node *enter_to, int mode, int tracking);
+  Node* my_next_outer(Node *last, int versus);
+  Node* my_next_inner(Node *last, int versus);
+  bool track_uncomplete();
+  bool track_complete();
+  bool get_trackmax();
+
+ private:
+  static bool sort_min_x(Node *a, Node *b);
+  static bool sort_max_x(Node *a, Node *b);
+
+ public:
+  int min_x, max_x;
+  Node(int min_x, int max_x, int y, char name);
+  virtual ~Node();
+  void precalc_tangs_sequences();
+};
+
+struct NodeDescriptor {
+  Node  *node;
+  Tangent *a;
+  Tangent *o;
+};
+
+#endif /* POLYGON_FINDER_NODE_H_ */