contrek 1.0.5 → 1.0.7

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

@@ -9,12 +9,12 @@
 #include "ValueNotMatcher.h"
 #include <iostream>
 
-ValueNotMatcher::ValueNotMatcher(char value) : Matcher(value) {
+ValueNotMatcher::ValueNotMatcher(unsigned int value) : Matcher(value) {
 }
 
 ValueNotMatcher::~ValueNotMatcher() {
 }
 
-bool ValueNotMatcher::match(char value) {
+bool ValueNotMatcher::match(unsigned int value) {
   return(this->value != value);
 }

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

@@ -6,16 +6,12 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_MATCHERS_VALUENOTMATCHER_H_
-#define POLYGON_MATCHERS_VALUENOTMATCHER_H_
-
+#pragma once
 #include "Matcher.h"
 
 class ValueNotMatcher : public Matcher {
  public:
-  ValueNotMatcher(char value);
+  explicit ValueNotMatcher(unsigned int value);
   virtual ~ValueNotMatcher();
-  bool match(char value);
+  bool match(unsigned int value);
 };
-
-#endif /* POLYGON_MATCHERS_VALUENOTMATCHER_H_ */

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

@@ -8,33 +8,41 @@
 
 #include <iterator>
 #include <list>
+#include <iostream>
+#include <algorithm>
 #include "LinearReducer.h"
 #include "Reducer.h"
 
-LinearReducer::LinearReducer(std::list<Point*> *list_of_points) : Reducer(list_of_points) {
-}
-
-LinearReducer::~LinearReducer() {
+LinearReducer::LinearReducer(std::vector<Point*> &list_of_points)
+: Reducer(list_of_points) {
 }
 
 void LinearReducer::reduce() {
-  std::list<Point*>::iterator start_p = this->points->begin();
-  std::list<Point*>::iterator end_p = std::next(start_p, 1);
+  if (points.size() < 2) return;
 
-  int *dir = seq_dir(*start_p, *end_p);
+  Point* start_p = points[0];
+  Point* end_p = points[1];
+  auto 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;
+  for (size_t i = 2; i < points.size(); ++i) {
+    Point* point = points[i];
+    auto act_seq = seq_dir(end_p, point);
+    if (act_seq == dir) {
+      auto it = std::find_if(points.begin(), points.end(), [&](Point* p) {  // TODO(ema): optimize...
+        return p->x == end_p->x && p->y == end_p->y;
+      });
+      if (it != points.end()) {
+        size_t removed_idx = std::distance(points.begin(), it);
+        points.erase(it);
+        if (removed_idx <= i) i--;
+      }
     } else {
       dir = act_seq;
-      end_p = point;
     }
+    end_p = point;
   }
 }
 
-int *LinearReducer::seq_dir(Point *a, Point *b)
-{ return(new int[2] {b->x - a->x, b->y - a->y});
+std::array<int, 2> LinearReducer::seq_dir(Point *a, Point *b)
+{ return { b->x - a->x, b->y - a->y };
 }

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

@@ -6,18 +6,16 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_REDUCERS_LINEARREDUCER_H_
-#define POLYGON_REDUCERS_LINEARREDUCER_H_
-
+#pragma once
+#include <vector>
+#include <array>
 #include "Reducer.h"
 
 class LinearReducer : public Reducer {
  public:
-  LinearReducer(std::list<Point*> *list_of_points);
-  virtual ~LinearReducer();
+  explicit LinearReducer(std::vector<Point*>& list_of_points);
   void reduce();
+
  private:
-  int *seq_dir(Point *a, Point *b);
+  std::array<int, 2> seq_dir(Point *a, Point *b);
 };
-
-#endif /* POLYGON_REDUCERS_LINEARREDUCER_H_ */

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

@@ -8,11 +8,8 @@
 
 #include "Reducer.h"
 
-Reducer::Reducer(std::list<Point*> *list_of_points) {
-  this->points = list_of_points;
-}
-
-Reducer::~Reducer() {
+Reducer::Reducer(std::vector<Point*>& list_of_points)
+: points(list_of_points) {
 }
 
 void Reducer::reduce() {

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

@@ -6,20 +6,16 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_REDUCERS_REDUCER_H_
-#define POLYGON_REDUCERS_REDUCER_H_
-
+#pragma once
 #include <list>
+#include <vector>
 #include "../finder/Node.h"
 
 struct Point;
 class Reducer {
  public:
-  Reducer(std::list<Point*> *list_of_points);
-  virtual ~Reducer();
+  explicit Reducer(std::vector<Point*>& list_of_points);
   virtual void reduce();
  protected:
-  std::list<Point*> *points;
+  std::vector<Point*> &points;
 };
-
-#endif /* POLYGON_REDUCERS_REDUCER_H_ */

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

@@ -6,25 +6,22 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
+#include <vector>
+#include <algorithm>
+#include <iostream>
 #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() {
+UniqReducer::UniqReducer(std::vector<Point*>& list_of_points) : Reducer(list_of_points) {
 }
 
 struct is_near {
-  bool operator() (Point *first, Point *second)
-  { return (first->x == second->x && first->y == second->y); }
+  bool operator() (Point* first, Point* second) const {
+    return first->x == second->x && first->y == second->y;
+  }
 };
 
 void UniqReducer::reduce() {
-  this->points->unique(is_near());
+  auto last = std::unique(points.begin(), points.end(), is_near());
+  points.erase(last, points.end());
 }
-

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

@@ -6,16 +6,12 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_REDUCERS_UNIQREDUCER_H_
-#define POLYGON_REDUCERS_UNIQREDUCER_H_
-
+#pragma once
+#include <vector>
 #include "Reducer.h"
 
 class UniqReducer : public Reducer {
  public:
-  UniqReducer(std::list<Point*> *list_of_points);
-  virtual ~UniqReducer();
+  explicit UniqReducer(std::vector<Point*>& list_of_points);
   void reduce();
 };
-
-#endif /* POLYGON_REDUCERS_UNIQREDUCER_H_ */

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

@@ -6,45 +6,44 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#include <iostream>
-#include <list>
+#include <vector>
 #include "VisvalingamReducer.h"
-#include "Reducer.h"
 
-VisvalingamReducer::VisvalingamReducer(std::list<Point*> *list_of_points, float tolerance) : Reducer(list_of_points) {
+VisvalingamReducer::VisvalingamReducer(std::vector<Point*>& list_of_points, float tolerance)
+  : Reducer(list_of_points) {
   this->tolerance = tolerance * tolerance;
 }
 
-VisvalingamReducer::~VisvalingamReducer() {
-}
+VisvalingamReducer::~VisvalingamReducer() {}
 
 void VisvalingamReducer::reduce() {
-  std::list<Point*> *new_points = this->simplify();
-  this->points->assign(new_points->begin(), new_points->end());
+  std::vector<Point*> new_points = this->simplify();
+  points.assign(new_points.begin(), new_points.end());
 }
-std::list<Point*> *VisvalingamReducer::simplify() {
-  Vertex *vwLine = VisvalingamReducer::Vertex::buildLine(this->points);
+
+std::vector<Point*> VisvalingamReducer::simplify() {
+  Vertex* vwLine = Vertex::buildLine(points);
   float minArea = this->tolerance;
   for (;;) {
-    minArea = this->simplifyVertex(vwLine);
-    if (minArea >= this->tolerance) break;
+      minArea = simplifyVertex(vwLine);
+      if (minArea >= this->tolerance) break;
   }
-  std::list<Point*> *simp = vwLine->getCoordinates();
-  return(simp);
+  return Vertex::getCoordinates(vwLine);
 }
-float VisvalingamReducer::simplifyVertex(VisvalingamReducer::Vertex *vwLine) {
-  VisvalingamReducer::Vertex *curr = vwLine;
+
+float VisvalingamReducer::simplifyVertex(Vertex* vwLine) {
+  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();
+  Vertex* minVertex = nullptr;
+  while (curr) {
+      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);
+  if (minVertex && minArea < this->tolerance) minVertex->remove();
+  if (!vwLine->isLiving()) return -1;
+  return minArea;
 }

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

@@ -6,116 +6,105 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef POLYGON_REDUCERS_VISVALINGAMREDUCER_H_
-#define POLYGON_REDUCERS_VISVALINGAMREDUCER_H_
-
+#pragma once
+#include <vector>
 #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);
+  VisvalingamReducer(std::vector<Point*>& list_of_points, float tolerance);
   virtual ~VisvalingamReducer();
   void reduce();
-  std::list<Point*> *simplify();
+  std::vector<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));
+    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);
+  class Vertex {
+    const float MAX_AREA = std::numeric_limits<float>::max();
+    explicit 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 (!prev || !next)
+      { this->area = MAX_AREA;
+        return;
       }
-      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);
+      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::vector<Point*>& pts) {
+      Vertex* first = nullptr;
+      Vertex* prev = nullptr;
+      for (Point* p : pts) {
+        Vertex* v = new Vertex(p);
+        if (!first) first = v;
+        v->setPrec(prev);
+        if (prev) {
+            prev->setNext(v);
             prev->updateArea();
-          }
-          prev = v;
         }
-        return(first);
+        prev = v;
       }
-      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);
+      return first;
+    }
+
+    Vertex* remove() {
+      Vertex* tmpPrev = this->prev;
+      Vertex* tmpNext = this->next;
+      Vertex* result = nullptr;
+      if (tmpPrev) {
+        tmpPrev->setNext(tmpNext);
+        tmpPrev->updateArea();
+        result = tmpPrev;
       }
-      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);
+      if (tmpNext) {
+        tmpNext->setPrec(tmpPrev);
+        tmpNext->updateArea();
+        if (!result) result = tmpNext;
       }
+      this->isLive = false;
+      return result;
+    }
+
+    static std::vector<Point*> getCoordinates(Vertex* head) {
+      std::vector<Point*> coords;
+      Vertex* curr = head;
+      while (curr) {
+        coords.push_back(curr->pt);
+        curr = curr->get_next();
+      }
+      return coords;
+    }
 
-     private:
-      Vertex *next, *prev;
-      double area = MAX_AREA;
-      bool isLive = true;
-    };
+   private:
+    Vertex* next;
+    Vertex* prev;
+    float area;
+    bool isLive;
+  };
 
  private:
-  float simplifyVertex(VisvalingamReducer::Vertex *vwLine);
+  float simplifyVertex(Vertex* vwLine);
   float tolerance;
 };
-
-#endif /* POLYGON_REDUCERS_VISVALINGAMREDUCER_H_ */