contrek 1.2.9 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f506a5908c11f7ac1de118b4772ad9e85cd00746e4ee57b5d9c1600faea371e
-  data.tar.gz: 81c2807712361d51398962c9496bf3c833b21eb42d34907069c923cd62654f62
+  metadata.gz: 58d88411970256b3edc37da05dd9304aaa4593b320e7d73db5966b69d403c4cf
+  data.tar.gz: 6a05687f7ffba4b22eb7ebf02abf2a622931bc3250968fa785fb13720036118e
 SHA512:
-  metadata.gz: 76c41016ce95c124ed72beacd5c838bf5fe960483e3cf7b78848d53c3d997948f5de0c8ecacdb08d3c38b8faf7349ec79cef9546415773e5d5201019b04fe3b2
-  data.tar.gz: 1823196730b740221b2e75be9915706b5b96afd91349dd898eda70d1ccce69f569270e134663137523ea3860e5d49a419b59a083a6a11be027bf4e14a1a0e30b
+  metadata.gz: 7150e06efce7580fdefd55725db0de52e2805b909e800679a0f99481c3e52333209d1b5ceb750c1fc63a28fa6aaaad7f7662d3baf3ebf377b29cfe4dacf6d19d
+  data.tar.gz: 988e85fd99234df2b3cd0e8bec0d8f68ba0f631111a3fda62e114e185dd1619589223266b5e3db71a2a5c478d2871f862209489df997a13a9da866b84718c609

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.2.9)
+    contrek (1.3.0)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -60,16 +60,16 @@ void Tests::test_a()
   std::vector<int> array_compare;
 
   for (const auto& x : o->polygons)
-  { for (const Point* p : x.outer) {
-      array_compare.push_back(p->x);
-      array_compare.push_back(p->y);
+  { for (const Point& p : x.outer) {
+      array_compare.push_back(p.x);
+      array_compare.push_back(p.y);
     }
     if (outer_array != array_compare) throw std::runtime_error("Wrong OUTER results!");
     array_compare.clear();
     for (const auto& z : x.inner)
-    { for (const Point* y : z)
-      { array_compare.push_back(y->x);
-        array_compare.push_back(y->y);
+    { for (const Point& y : z)
+      { array_compare.push_back(y.x);
+        array_compare.push_back(y.y);
       }
     }
     if (inner_array != array_compare) throw std::runtime_error("Wrong INNER results!");
@@ -97,9 +97,9 @@ void Tests::test_b()
 
 void Tests::test_c()
 { Sequence sequence;
-  Point* p1 = new Point({1, 1});
-  Point* p2 = new Point({2, 2});
-  Point* p3 = new Point({3, 3});
+  Point p1{1, 1};
+  Point p2{2, 2};
+  Point p3{3, 3};
 
   Hub* hub = new Hub(4);
 
@@ -114,7 +114,7 @@ void Tests::test_c()
   if (sequence.size != 3) throw std::runtime_error("Wrong sequence size");
 
   // iterator() initially gives head
-  Point* head = sequence.head->payload;
+  const Point& head = sequence.head->payload;
   if (head != p1) throw std::runtime_error("Wrong head");
   if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
   if (sequence.iterator() != pos1) throw std::runtime_error("Wrong iterator to head");
@@ -135,10 +135,6 @@ void Tests::test_c()
   sequence.rewind();
   if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
 
-  delete p1;
-  delete p2;
-  delete p3;
-
   delete hub;
 
   delete pos1;
@@ -348,10 +344,8 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
       ProcessResult *result = polygon_finder.process_info();
       if (result) {
         std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-        ProcessResult* safe_result = result->clone();
-        result_clones.push_back(safe_result);
-        vmerger.add_tile(*safe_result);
-        delete result;
+        result_clones.push_back(result);
+        vmerger.add_tile(*result);
       }
       stripe_count++;
     }
@@ -467,10 +461,8 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
         ProcessResult *result = polygon_finder.process_info();
         if (result) {
           std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
-          ProcessResult* safe_result = result->clone();
-          result_clones.push_back(safe_result);
-          vmerger.add_tile(*safe_result, !(current_y_offset + stripe_height < total_height));
-          delete result;
+          result_clones.push_back(result);
+          vmerger.add_tile(*result, !(current_y_offset + stripe_height < total_height));
         }
         stripe_count++;
       }

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

@@ -100,33 +100,31 @@ Node* Node::my_next_outer(Node *last, int versus) {
   return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
-Point* Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
+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;
 
   int tg_index = this->tangs_sequence[enter_to_index];
-  Point* point;
   if (tg_index < 0) {
     Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      point = &node_up.end_point;
+      return node_up.end_point;
     } else {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      point = &node_up.start_point;
+      return node_up.start_point;
     }
   } else {
     Node& node_down = cluster->vert_nodes[y + T_DOWN][tg_index];
     if (mode == Node::A) {
       enter_to->track |= TURNER[tracking][OMIN - 1];
-      point = &node_down.start_point;
+      return node_down.start_point;
     } else {
       enter_to->track |= TURNER[tracking][OMAX - 1];
-      point = &node_down.end_point;
+      return node_down.end_point;
     }
   }
-  return point;
 }
 
 Node* Node::get_tangent_node_by_virtual_index(int virtual_index) {

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

@@ -61,6 +61,9 @@ struct Point {
   bool operator==(const Point& other) const {
     return x == other.x && y == other.y;
   }
+  bool operator!=(const Point& other) const {
+    return !(*this == other);
+  }
   Point(int x_, int y_) : x(x_), y(y_) {}
   Point() : x(0), y(0) {}
 };
@@ -96,7 +99,7 @@ class Node : public  Listable {
   NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
   SmallVec tangs_sequence;
-  Point* coords_entering_to(Node *enter_to, int mode, int tracking);
+  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);
   Node* get_tangent_node_by_virtual_index(int vitual_index);

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

@@ -18,7 +18,6 @@
 #include "NodeCluster.h"
 #include "Node.h"
 #include "RectBounds.h"
-#include "PointPool.h"
 #include "../reducers/UniqReducer.h"
 #include "../reducers/LinearReducer.h"
 #include "../reducers/VisvalingamReducer.h"
@@ -44,7 +43,7 @@ NodeCluster::~NodeCluster() {
 void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options options) {
   if (!(options.compress_linear || options.compress_uniq || options.compress_visvalingam)) return;
 
-  auto compress_sequence = [&](std::vector<Point*>& points_vec) {
+  auto compress_sequence = [&](std::vector<Point>& points_vec) {
     if (points_vec.empty()) return;
 
     if (options.compress_uniq) {
@@ -122,9 +121,9 @@ void NodeCluster::plot(int versus) {
         next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
 
       if (next_node != nullptr)
-      { Point* p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
+      { Point p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
+        poly.bounds.expand(p.x, p.y);
         poly.outer.push_back(p);
-        poly.bounds.expand(p->x, p->y);
       }
       if ((this->nodes > 0) && (next_node != nullptr))
       { plot_node(poly.outer, next_node, root_node, versus, poly.bounds);
@@ -137,7 +136,7 @@ void NodeCluster::plot(int versus) {
         int index_inner = 0;
         while (inner_plot->size() > 0)
         { this->plot_sequence.clear();
-          std::vector<Point*> inner_sequence;
+          std::vector<Point> inner_sequence;
           std::list<Node*>::iterator first_i;
           Node *first = nullptr;
 
@@ -243,7 +242,7 @@ std::pair<int, int> NodeCluster::test_in_hole_o(Node* node)
   return {-1, -1};
 }
 
-void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
+void NodeCluster::plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node) {
   Node *current_node = node;
   bool strict_bounds = this->options->strict_bounds;
   while (current_node != nullptr) {
@@ -279,8 +278,8 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
         }
       }
     } else if (strict_bounds) {
-        sequence_coords.push_back(this->points_pool.acquire((first_is_max ? last_node->max_x : last_node->min_x), current_node->y));
-        sequence_coords.push_back(this->points_pool.acquire((first_is_max ? next_node->min_x : next_node->max_x), current_node->y));
+        sequence_coords.push_back(Point{(first_is_max ? last_node->max_x : last_node->min_x), current_node->y});
+        sequence_coords.push_back(Point{(first_is_max ? next_node->min_x : next_node->max_x), current_node->y});
       }
 
     if (current_node->track_uncomplete()) {
@@ -293,7 +292,7 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
   }
 }
 
-void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds) {
+void NodeCluster::plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds) {
   Node *current_node = node;
   bool strict_bounds = this->options->strict_bounds;
 
@@ -315,23 +314,23 @@ void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, No
       plot = (n == next_node);
     }
     if (plot) {
-      Point* p = last_node->coords_entering_to(current_node, versus, Node::OUTER);
+      Point p = last_node->coords_entering_to(current_node, versus, Node::OUTER);
+      bounds.expand(p.x, p.y);
       sequence_coords.push_back(p);
-      bounds.expand(p->x, p->y);
       if (current_node != start_node) {
         inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         if (last_node->y == next_node->y) {
-          Point* p1 = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
+          Point p1 = next_node->coords_entering_to(current_node, versus_inverter[versus], Node::OUTER);
+          bounds.expand(p1.x, p1.y);
           sequence_coords.push_back(p1);
-          bounds.expand(p1->x, p1->y);
           inner_plot->contains(current_node) ? inner_plot->remove(current_node) : inner_plot->push_back(current_node);
         }
       }
     } else if (strict_bounds) {
         bool is_down = current_node->y > last_node->y;
         bool is_a = (versus == Node::A);
-        sequence_coords.push_back(this->points_pool.acquire((is_down == is_a ? last_node->min_x : last_node->max_x), current_node->y));
-        sequence_coords.push_back(this->points_pool.acquire((is_down == is_a ? next_node->max_x : next_node->min_x), current_node->y));
+        sequence_coords.push_back(Point{(is_down == is_a ? last_node->min_x : last_node->max_x), current_node->y});
+        sequence_coords.push_back(Point{(is_down == is_a ? next_node->max_x : next_node->min_x), current_node->y});
       }
 
     if (current_node == start_node) {

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

@@ -18,7 +18,6 @@
 #include "Lists.h"
 #include "RectBounds.h"
 #include "Polygon.h"
-#include "PointPool.h"
 
 class Node;
 struct Point;
@@ -26,8 +25,8 @@ struct pf_Options;
 
 class NodeCluster {
  private:
-  void plot_node(std::vector<Point*>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds);
-  void plot_inner_node(std::vector<Point*>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
+  void plot_node(std::vector<Point>& sequence_coords, Node *node, Node *start_node, int versus, RectBounds& bounds);
+  void plot_inner_node(std::vector<Point>& sequence_coords, Node *node, int versus, Node *stop_at, Node *start_node);
   std::vector<Node*> plot_sequence;
   List *inner_plot;
   List *inner_new;
@@ -35,7 +34,6 @@ class NodeCluster {
   int count = 0;
   int nodes;
   int width;
-  PointPool points_pool;
 
  public:
   pf_Options *options;

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

@@ -14,8 +14,8 @@
 #include "RectBounds.h"
 
 struct Polygon {
-  std::vector<Point*> outer;
-  std::list<std::vector<Point*>> inner;
+  std::vector<Point> outer;
+  std::list<std::vector<Point>> inner;
   RectBounds bounds;
   Polygon() : bounds(RectBounds::empty()) {}
 };

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

@@ -108,6 +108,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->width = this->source_bitmap->w();
   pr->height = this->source_bitmap->h();
   pr->has_bounds = this->node_cluster->options->bounds;
+  pr->versus = this->options.versus;
 
   if (this->node_cluster->options->named_sequences && typeid(*this->source_bitmap) == typeid(Bitmap))
   { std::string sequence;
@@ -133,25 +134,25 @@ void ProcessResult::draw_on_bitmap(RawBitmap& bitmap) const {
     // --- OUTER ---
     if (!poly.outer.empty()) {
       for (size_t i = 0; i < poly.outer.size() - 1; ++i) {
-        Point* p1 = poly.outer[i];
-        Point* p2 = poly.outer[i+1];
-        bitmap.draw_line(p1->x, p1->y, p2->x, p2->y, 255, 0, 0, 255);
+        const Point& p1 = poly.outer[i];
+        const Point& p2 = poly.outer[i+1];
+        bitmap.draw_line(p1.x, p1.y, p2.x, p2.y, 255, 0, 0, 255);
       }
-      Point* last = poly.outer.back();
-      Point* first = poly.outer.front();
-      bitmap.draw_line(last->x, last->y, first->x, first->y, 255, 0, 0, 255);
+      const Point& last = poly.outer.back();
+      const Point& first = poly.outer.front();
+      bitmap.draw_line(last.x, last.y, first.x, first.y, 255, 0, 0, 255);
     }
     // --- INNER ---
     for (const auto& sequence : poly.inner) {
       if (sequence.empty()) continue;
       for (size_t i = 0; i < sequence.size() - 1; ++i) {
-        Point* p1 = sequence[i];
-        Point* p2 = sequence[i+1];
-        bitmap.draw_line(p1->x, p1->y, p2->x, p2->y, 0, 128, 0, 255);
+        const Point& p1 = sequence[i];
+        const Point& p2 = sequence[i+1];
+        bitmap.draw_line(p1.x, p1.y, p2.x, p2.y, 0, 128, 0, 255);
       }
-      Point* last = sequence.back();
-      Point* first = sequence.front();
-      bitmap.draw_line(last->x, last->y, first->x, first->y, 0, 128, 0, 255);
+      const Point& last = sequence.back();
+      const Point& first = sequence.front();
+      bitmap.draw_line(last.x, last.y, first.x, first.y, 0, 128, 0, 255);
     }
   }
 }

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

@@ -61,12 +61,12 @@ struct pf_Options {
 struct ProcessResult {
   int groups;
   int width, height;
+  int versus;
   bool has_bounds = false;
   std::map<std::string, double> benchmarks;
   std::list<Polygon> polygons;
   std::string named_sequence;
   std::vector<std::pair<int, int>> treemap;
-  std::vector<Point> cloned_points_storage;
 
   void draw_on_bitmap(RawBitmap& canvas) const;
 
@@ -74,12 +74,12 @@ struct ProcessResult {
     int counter = 0;
     for (const auto& polygon : polygons) {
       std::cout << counter << " - " << "outer" << "\n";
-      for (const Point* p : polygon.outer) std::cout << p->toString();
+      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();
+        for (const Point& p : seq) std::cout << p.toString();
       }
       std::cout << "\n" << polygon.bounds.to_string() <<"\n";
       counter++;
@@ -95,61 +95,15 @@ struct ProcessResult {
 
   void translate(int x) {
     for (auto& polygon : polygons) {
-      for (Point* p : polygon.outer) p->x += x;
-      for (const auto& seq : polygon.inner) {
-        for (Point* p : seq) p->x += x;
+      for (Point& p : polygon.outer) p.x += x;
+      for (auto& seq : polygon.inner) {
+        for (Point& p : seq) p.x += x;
       }
       polygon.bounds.min_x += x;
       polygon.bounds.max_x += x;
     }
   }
 
-  ProcessResult* clone() const {
-    ProcessResult* new_res = new ProcessResult();
-    new_res->groups = this->groups;
-    new_res->width = this->width;
-    new_res->height = this->height;
-    new_res->benchmarks = this->benchmarks;
-    new_res->named_sequence = this->named_sequence;
-    new_res->treemap = this->treemap;
-
-    size_t estimated_points = 0;
-    for (const auto& poly : this->polygons) {
-      estimated_points += poly.outer.size();
-      for (const auto& seq : poly.inner) estimated_points += seq.size();
-    }
-    new_res->cloned_points_storage.reserve(estimated_points);
-
-    for (const auto& poly : this->polygons) {
-      Polygon new_poly;
-      new_poly.bounds = poly.bounds;
-      new_poly.outer.reserve(poly.outer.size());
-      // outer
-      for (const Point* p : poly.outer) {
-        if (p) {
-          new_res->cloned_points_storage.push_back(Point(p->x, p->y));
-          size_t idx = new_res->cloned_points_storage.size() - 1;
-          new_poly.outer.push_back(&new_res->cloned_points_storage[idx]);
-        }
-      }
-      // inner
-      for (const auto& seq : poly.inner) {
-        std::vector<Point*> new_seq;
-        new_seq.reserve(seq.size());
-        for (const Point* p : seq) {
-          if (p) {
-            new_res->cloned_points_storage.push_back(Point(p->x, p->y));
-            size_t idx = new_res->cloned_points_storage.size() - 1;
-            new_seq.push_back(&new_res->cloned_points_storage[idx]);
-          }
-        }
-        new_poly.inner.push_back(new_seq);
-      }
-      new_res->polygons.push_back(new_poly);
-    }
-    return new_res;
-  }
-
   void to_svg_stream(std::ostream& os) const {
     os << "<svg xmlns=\"http://www.w3.org/2000/svg\" "
        << "width=\"" << width << "\" height=\"" << height << "\">\n";
@@ -158,11 +112,10 @@ struct ProcessResult {
       if (!poly.outer.empty()) {
         os << "<polygon points=\"";
         bool first = true;
-        for (const Point* p : poly.outer) {
-          if (!p) continue;
+        for (const Point& p : poly.outer) {
           if (!first) os << " ";
           first = false;
-          os << p->x << "," << p->y;
+          os << p.x << "," << p.y;
         }
         os << "\" fill=\"none\" stroke=\"red\" stroke-width=\"1\"/>\n";
       }
@@ -171,11 +124,10 @@ struct ProcessResult {
         if (sequence.empty()) continue;
         os << "<polygon points=\"";
         bool first = true;
-        for (const Point* p : sequence) {
-          if (!p) continue;
+        for (const Point& p : sequence) {
           if (!first) os << " ";
           first = false;
-          os << p->x << "," << p->y;
+          os << p.x << "," << p.y;
         }
         os << "\" fill=\"none\" stroke=\"green\" stroke-width=\"1\"/>\n";
       }

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

@@ -18,7 +18,7 @@
 #include "../../CpuTimer.h"
 
 Cluster::Cluster(Finder *finder, int height, int start_x, int end_x)
-  : finder(finder)
+  : finder_(finder)
 { tiles_.reserve(2);  // only two (left|right)
   this->hub_ = new Hub(height);
 }
@@ -40,16 +40,16 @@ void Cluster::add(Tile* tile) {
   }
 }
 
-void Cluster::list_to_string(std::vector<Point*> list)
+void Cluster::list_to_string(std::vector<Point> list)
 { std::cout << "(" << &list << ") ";
-  for (Point* point : list) {
-    std::cout << point->toString();
+  for (const Point& point : list) {
+    std::cout << point.toString();
   }
   std::cout << std::endl;
 }
 
 Tile* Cluster::merge_tiles() {
-  bool treemap = this->finder->options().treemap;
+  bool treemap = this->finder_->options().treemap;
   double tot_inner = 0;
   double tot_outer = 0;
   CpuTimer timer;
@@ -141,7 +141,7 @@ Tile* Cluster::merge_tiles() {
   };
 
   Tile* tile = new Tile(
-    this->finder, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
+    this->finder_, tiles_.front()->start_x(), tiles_.back()->end_x(), tiles_.front()->name() + tiles_.back()->name(), b);
 
   tile->assign_shapes(new_shapes);
   for (Tile* old_tile : tiles_) {

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

@@ -18,7 +18,7 @@
 
 class Cluster {
  private:
-  Finder *finder;
+  Finder *finder_;
   std::vector<Tile*> tiles_;
   Hub *hub_ = nullptr;
   void assign_ancestry(Shape *shape, InnerPolyline* inner_polyline);
@@ -31,7 +31,8 @@ class Cluster {
   Tile* merge_tiles();
   const std::vector<Tile*> tiles() const { return tiles_; }
   Hub* hub() { return hub_; }
-  static void list_to_string(std::vector<Point*> list);
+  static void list_to_string(std::vector<Point> list);
   PartPool parts_pool;
   std::deque<Position> positions_pool;
+  const Finder* finder() const { return finder_; };
 };

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

@@ -29,7 +29,7 @@ Sequence* Cursor::join_outers()
                        this->shapes_sequence_,
                        outer_joined_polyline);
 
-  if (*outer_joined_polyline->head->payload == *outer_joined_polyline->tail->payload &&
+  if (outer_joined_polyline->head->payload == outer_joined_polyline->tail->payload &&
       this->cluster.tiles().front()->left() &&
       this->cluster.tiles().back()->right()) outer_joined_polyline->pop();
 
@@ -151,11 +151,11 @@ std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq, bool treema
           retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
           Position *position = static_cast<Position*>(pos);
           if (part->is(Part::ADDED) &&
-             !(position->payload->y >= bounds.min &&
-              position->payload->y <= bounds.max)) {
+             !(position->payload.y >= bounds.min &&
+              position->payload.y <= bounds.max)) {
             return(false);
           }
-            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->tracked_outer));
+            return(!(polyline->tile->tg_border(position->payload) && position->end_point()->tracked_outer));
           });
         }
         if (retme_sequence->is_not_vertical()) {
@@ -175,7 +175,7 @@ void Cursor::mark_children(std::vector<EndPoint*>& end_points, const Polyline* o
   for (size_t i = 0; i + 1 < end_points.size(); i += 2) {
     const auto& a = end_points[i];
     const auto& b = end_points[i + 1];
-    auto [y_min, y_max] = std::minmax(a->get_point()->y, b->get_point()->y);
+    auto [y_min, y_max] = std::minmax(a->get_point().y, b->get_point().y);
     for (int y = y_min + 1; y < y_max; ++y) {
       EndPoint* end_point = this->cluster.hub()->get(y);
       if (end_point) {
@@ -199,9 +199,9 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
       auto [min_it, max_it] = std::minmax_element(
         points.begin(),
         points.end(),
-        [](Point* a, Point* b) { return a->y < b->y; });
-      bounds.min = std::min(bounds.min, (*min_it)->y);
-      bounds.max = std::max(bounds.max, (*max_it)->y);
+        [](const Point& a, const Point& b) { return a.y < b.y; });
+      bounds.min = std::min(bounds.min, min_it->y);
+      bounds.max = std::max(bounds.max, max_it->y);
     }
     if (act_part->innerable()) {
       all_parts.push_back(act_part);

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

@@ -16,15 +16,15 @@ class Part;
 
 class EndPoint {
  public:
-  EndPoint() : point_(nullptr) {}
+  EndPoint() {}
 
-  void set_point(Point* p) { point_ = p; }
-  Point* get_point() const { return point_; }
+  void set_point(const Point& p) { point_ = p; }
+  const Point& get_point() const { return point_; }
   std::vector<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
   bool tracked_outer = false;
 
  private:
-  Point* point_;
+  Point point_;
   std::vector<Queueable<Point>*> queues_;
 };

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

@@ -56,4 +56,6 @@ class Finder : public Poolable {
   virtual ProcessResult* process_info();
   const pf_Options& options() const { return options_; }
   Queue<Tile*>& tiles() { return tiles_; }
+  virtual bool transpose() const { return false; }
+  int versus;
 };

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

@@ -11,7 +11,7 @@
 #include <vector>
 #include "InnerPolyline.h"
 
-InnerPolyline::InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape)
+InnerPolyline::InnerPolyline(std::vector<Point> raw_coordinates, Shape* shape)
   : raw_coordinates_(std::move(raw_coordinates)),
     shape_(shape) {}
 InnerPolyline::InnerPolyline(Sequence* sequence)
@@ -19,7 +19,7 @@ InnerPolyline::InnerPolyline(Sequence* sequence)
   this->raw_coordinates_ = sequence->to_vector();
 }
 
-std::vector<Point*>& InnerPolyline::raw() {
+std::vector<Point>& InnerPolyline::raw() {
   return this->raw_coordinates_;
 }
 
@@ -41,11 +41,11 @@ Shape* InnerPolyline::shape() {
 
 Bounds& InnerPolyline::raw_vertical_bounds() {
   if (!raw_coordinates_.empty()) {
-    int min_y = raw_coordinates_[0]->y;
-    int max_y = raw_coordinates_[0]->y;
+    int min_y = raw_coordinates_[0].y;
+    int max_y = raw_coordinates_[0].y;
     for (const auto& pos : raw_coordinates_) {
-      if (pos->y < min_y) min_y = pos->y;
-      if (pos->y > max_y) max_y = pos->y;
+      if (pos.y < min_y) min_y = pos.y;
+      if (pos.y > max_y) max_y = pos.y;
     }
     vertical_bounds_.min = min_y;
     vertical_bounds_.max = max_y;

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

@@ -14,15 +14,15 @@
 
 class InnerPolyline {
  public:
-  explicit InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape);
+  explicit InnerPolyline(std::vector<Point> raw_coordinates, Shape* shape);
   explicit InnerPolyline(Sequence* sequence);
-  std::vector<Point*>& raw();
+  std::vector<Point>& raw();
   Sequence* sequence() { return this->sequence_; }
   Bounds& vertical_bounds();
   Shape* shape();
   Shape* assigned_shape = nullptr;
  private:
-  std::vector<Point*> raw_coordinates_;
+  std::vector<Point> raw_coordinates_;
   Sequence* sequence_ = nullptr;
   Shape* shape_;
   Bounds& raw_vertical_bounds();