contrek 1.0.0

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

@@ -0,0 +1,23 @@
+/*
+ * Matcher.cpp
+ *
+ *  Created on: 25 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Matcher.h"
+#include <iostream>
+Matcher::Matcher(char value) {
+  this->value = value;
+}
+
+Matcher::~Matcher() {
+}
+
+bool Matcher::match(char value) {
+  return(this->value == value);
+}
+bool Matcher::unmatch(char value) {
+  return(!match(value));
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Matcher.h
+ *
+ *  Created on: 25 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_MATCHERS_MATCHER_H_
+#define POLYGON_MATCHERS_MATCHER_H_
+
+class Matcher {
+ protected:
+  char value;
+
+ public:
+  Matcher(char value);
+  virtual bool match(char value);
+  virtual bool unmatch(char value);
+  virtual ~Matcher();
+};
+
+#endif /* POLYGON_MATCHERS_MATCHER_H_ */

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

@@ -0,0 +1,20 @@
+/*
+ * RGBMatcher.cpp
+ *
+ *  Created on: 05 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "RGBMatcher.h"
+#include <iostream>
+RGBMatcher::RGBMatcher(unsigned int rgb_value) : Matcher(0L) {
+  this->rgb_value = rgb_value;
+}
+
+RGBMatcher::~RGBMatcher() {
+}
+
+bool RGBMatcher::match(unsigned int value) {
+  return(this->rgb_value == value);
+}

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

@@ -0,0 +1,23 @@
+/*
+ * RGBMatcher.h
+ *
+ *  Created on: 05 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_MATCHERS_RGBMATCHER_H_
+#define POLYGON_MATCHERS_RGBMATCHER_H_
+
+#include "Matcher.h"
+
+class RGBMatcher : public Matcher {
+ public:
+  RGBMatcher(unsigned int rgb_value);
+  virtual ~RGBMatcher();
+  bool match(unsigned int value);
+ private:
+  unsigned int rgb_value;
+};
+
+#endif /* POLYGON_MATCHERS_RGBMATCHER_H_ */

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

@@ -0,0 +1,20 @@
+/*
+ * RGBMatcher.cpp
+ *
+ *  Created on: 05 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "RGBNotMatcher.h"
+#include <iostream>
+RGBNotMatcher::RGBNotMatcher(int rgb_value) : Matcher(0L) {
+  this->rgb_value = rgb_value;
+}
+
+RGBNotMatcher::~RGBNotMatcher() {
+}
+
+bool RGBNotMatcher::match(int value) {
+  return(this->rgb_value != value);
+}

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

@@ -0,0 +1,23 @@
+/*
+ * RGBMatcher.h
+ *
+ *  Created on: 05 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_MATCHERS_RGBNOTMATCHER_H_
+#define POLYGON_MATCHERS_RGBNOTMATCHER_H_
+
+#include "Matcher.h"
+
+class RGBNotMatcher : public Matcher {
+ public:
+  RGBNotMatcher(int rgb_value);
+  virtual ~RGBNotMatcher();
+  bool match(int value);
+ private:
+  int rgb_value;
+};
+
+#endif /* POLYGON_MATCHERS_RGBMATCHER_H_ */

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

@@ -0,0 +1,20 @@
+/*
+ * ValueNotMatcher.cpp
+ *
+ *  Created on: 27 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "ValueNotMatcher.h"
+#include <iostream>
+
+ValueNotMatcher::ValueNotMatcher(char value) : Matcher(value) {
+}
+
+ValueNotMatcher::~ValueNotMatcher() {
+}
+
+bool ValueNotMatcher::match(char value) {
+  return(this->value != value);
+}

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

@@ -0,0 +1,21 @@
+/*
+ * ValueNotMatcher.h
+ *
+ *  Created on: 27 nov 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_MATCHERS_VALUENOTMATCHER_H_
+#define POLYGON_MATCHERS_VALUENOTMATCHER_H_
+
+#include "Matcher.h"
+
+class ValueNotMatcher : public Matcher {
+ public:
+  ValueNotMatcher(char value);
+  virtual ~ValueNotMatcher();
+  bool match(char value);
+};
+
+#endif /* POLYGON_MATCHERS_VALUENOTMATCHER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.cpp

@@ -0,0 +1,40 @@
+/*
+ * LinearReducer.cpp
+ *
+ *  Created on: 19 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <iterator>
+#include <list>
+#include "LinearReducer.h"
+#include "Reducer.h"
+
+LinearReducer::LinearReducer(std::list<Point*> *list_of_points) : Reducer(list_of_points) {
+}
+
+LinearReducer::~LinearReducer() {
+}
+
+void LinearReducer::reduce() {
+  std::list<Point*>::iterator start_p = this->points->begin();
+  std::list<Point*>::iterator end_p = std::next(start_p, 1);
+
+  int *dir = seq_dir(*start_p, *end_p);
+
+  for (std::list<Point*>::iterator point = std::next(end_p, 1); point != this->points->end(); ++point)
+  { int *act_seq = seq_dir(*end_p, *point);
+    if (act_seq[0] == dir[0] && act_seq[1] == dir[1])
+    { point = this->points->erase(end_p);
+      end_p = point;
+    } else {
+      dir = act_seq;
+      end_p = point;
+    }
+  }
+}
+
+int *LinearReducer::seq_dir(Point *a, Point *b)
+{ return(new int[2] {b->x - a->x, b->y - a->y});
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.h

@@ -0,0 +1,23 @@
+/*
+ * LinearReducer.h
+ *
+ *  Created on: 19 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_REDUCERS_LINEARREDUCER_H_
+#define POLYGON_REDUCERS_LINEARREDUCER_H_
+
+#include "Reducer.h"
+
+class LinearReducer : public Reducer {
+ public:
+  LinearReducer(std::list<Point*> *list_of_points);
+  virtual ~LinearReducer();
+  void reduce();
+ private:
+  int *seq_dir(Point *a, Point *b);
+};
+
+#endif /* POLYGON_REDUCERS_LINEARREDUCER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.cpp

@@ -0,0 +1,19 @@
+/*
+ * Reducer.cpp
+ *
+ *  Created on: 16 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "Reducer.h"
+
+Reducer::Reducer(std::list<Point*> *list_of_points) {
+  this->points = list_of_points;
+}
+
+Reducer::~Reducer() {
+}
+
+void Reducer::reduce() {
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.h

@@ -0,0 +1,25 @@
+/*
+ * Reducer.h
+ *
+ *  Created on: 16 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_REDUCERS_REDUCER_H_
+#define POLYGON_REDUCERS_REDUCER_H_
+
+#include <list>
+#include "../finder/Node.h"
+
+struct Point;
+class Reducer {
+ public:
+  Reducer(std::list<Point*> *list_of_points);
+  virtual ~Reducer();
+  virtual void reduce();
+ protected:
+  std::list<Point*> *points;
+};
+
+#endif /* POLYGON_REDUCERS_REDUCER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.cpp

@@ -0,0 +1,30 @@
+/*
+ * UniqReducer.cpp
+ *
+ *  Created on: 19 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include "UniqReducer.h"
+#include "Reducer.h"
+#include "algorithm"
+#include "list"
+#include "iterator"
+#include "iostream"
+
+UniqReducer::UniqReducer(std::list<Point*> *list_of_points) : Reducer(list_of_points) {
+}
+
+UniqReducer::~UniqReducer() {
+}
+
+struct is_near {
+  bool operator() (Point *first, Point *second)
+  { return (first->x == second->x && first->y == second->y); }
+};
+
+void UniqReducer::reduce() {
+  this->points->unique(is_near());
+}
+

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.h

@@ -0,0 +1,21 @@
+/*
+ * UniqReducer.h
+ *
+ *  Created on: 19 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_REDUCERS_UNIQREDUCER_H_
+#define POLYGON_REDUCERS_UNIQREDUCER_H_
+
+#include "Reducer.h"
+
+class UniqReducer : public Reducer {
+ public:
+  UniqReducer(std::list<Point*> *list_of_points);
+  virtual ~UniqReducer();
+  void reduce();
+};
+
+#endif /* POLYGON_REDUCERS_UNIQREDUCER_H_ */

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.cpp

@@ -0,0 +1,50 @@
+/*
+ * VisvalingamReducer.cpp
+ *
+ *  Created on: 20 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#include <iostream>
+#include <list>
+#include "VisvalingamReducer.h"
+#include "Reducer.h"
+
+VisvalingamReducer::VisvalingamReducer(std::list<Point*> *list_of_points, float tolerance) : Reducer(list_of_points) {
+  this->tolerance = tolerance * tolerance;
+}
+
+VisvalingamReducer::~VisvalingamReducer() {
+}
+
+void VisvalingamReducer::reduce() {
+  std::list<Point*> *new_points = this->simplify();
+  this->points->assign(new_points->begin(), new_points->end());
+}
+std::list<Point*> *VisvalingamReducer::simplify() {
+  Vertex *vwLine = VisvalingamReducer::Vertex::buildLine(this->points);
+  float minArea = this->tolerance;
+  for (;;) {
+    minArea = this->simplifyVertex(vwLine);
+    if (minArea >= this->tolerance) break;
+  }
+  std::list<Point*> *simp = vwLine->getCoordinates();
+  return(simp);
+}
+float VisvalingamReducer::simplifyVertex(VisvalingamReducer::Vertex *vwLine) {
+  VisvalingamReducer::Vertex *curr = vwLine;
+  float minArea = curr->getArea();
+  VisvalingamReducer::Vertex *minVertex = nullptr;
+  while (curr != nullptr) {
+    float area = curr->getArea();
+    if (area < minArea) {
+      minArea = area;
+      minVertex = curr;
+    }
+    curr = curr->get_next();
+  }
+  if (minVertex != nullptr  && minArea < this->tolerance) minVertex->remove();
+  if (!vwLine->isLiving())    return -1;
+  return(minArea);
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.h

@@ -0,0 +1,121 @@
+/*
+ * VisvalingamReducer.h
+ *
+ *  Created on: 20 dic 2018
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#ifndef POLYGON_REDUCERS_VISVALINGAMREDUCER_H_
+#define POLYGON_REDUCERS_VISVALINGAMREDUCER_H_
+
+#include <cmath>
+#include <limits>
+#include <list>
+#include "Reducer.h"
+#include "../finder/Node.h"
+
+struct Point;
+
+class VisvalingamReducer : public Reducer {
+ public:
+  VisvalingamReducer(std::list<Point*> *list_of_points, float tolerance);
+  virtual ~VisvalingamReducer();
+  void reduce();
+  std::list<Point*> *simplify();
+  class Triangle {
+   public:
+    static int area(Point *a, Point *b, Point *c) {
+      return( std::abs(  ((c->x - a->x) * (b->y - a->y) - (b->x - a->x) * (c->y - a->y)) / 2));
+    }
+  };
+    class Vertex {
+      const float MAX_AREA = std::numeric_limits<float>::max();
+      Vertex(Point *pt) {
+        this->pt = pt;
+        this->prev = nullptr;
+        this->next = nullptr;
+        this->area = MAX_AREA;
+        this->isLive = true;
+      }
+
+     public:
+      Point *pt;
+      void setNext(Vertex *nextp) {
+        this->next = nextp;
+      }
+      void setPrec(Vertex *prev) {
+        this->prev = prev;
+      }
+      void updateArea() {
+        if (this->prev == nullptr || this->next == nullptr)
+        { this->area = MAX_AREA;
+          return;
+        }
+        this->area = Triangle::area(this->prev->pt, this->pt, this->next->pt);
+      }
+      float getArea()
+      { return(this->area);
+      }
+      Vertex *get_next() {
+        return(this->next);
+      }
+      bool isLiving()
+      { return(this->isLive);
+      }
+      static Vertex *buildLine(std::list<Point*> *pts) {
+        Vertex *first = nullptr;
+        Vertex *prev = nullptr;
+        int i = 0;
+        for (std::list<Point*>::iterator it = pts->begin(); it != pts->end(); ++it, i++)
+        { Vertex *v = new Vertex(*it);
+          if (first == nullptr) first = v;
+          v->setPrec(prev);
+          if (prev != nullptr)
+          { prev->setNext(v);
+            prev->updateArea();
+          }
+          prev = v;
+        }
+        return(first);
+      }
+      Vertex* remove() {
+        Vertex *tmpPrev = this->prev;
+        Vertex *tmpNext = this->next;
+        Vertex *result = nullptr;
+        if (this->prev != nullptr)
+        { this->prev->setNext(tmpNext);
+          this->prev->updateArea();
+          result = prev;
+        }
+        if (this->next != nullptr)
+        { this->next->setPrec(tmpPrev);
+          this->next->updateArea();
+          if (result == nullptr) result = this->next;
+        }
+        this->isLive = false;
+        return(result);
+      }
+      std::list<Point*> *getCoordinates() {
+        std::list<Point*> *coords = new std::list<Point*>();
+        Vertex *curr = this;
+        for (;;)
+        { coords->push_back(curr->pt);
+          curr = curr->get_next();
+          if (curr == nullptr) break;
+        }
+        return(coords);
+      }
+
+     private:
+      Vertex *next, *prev;
+      double area = MAX_AREA;
+      bool isLive = true;
+    };
+
+ private:
+  float simplifyVertex(VisvalingamReducer::Vertex *vwLine);
+  float tolerance;
+};
+
+#endif /* POLYGON_REDUCERS_VISVALINGAMREDUCER_H_ */