contrek 1.2.8 → 1.3.0

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";
       }
@@ -207,330 +159,103 @@ class PolygonFinder {
   std::map<std::string, double> reports;
   void scan();
   CpuTimer cpu_timer;
-/*
+
   template <typename M, typename F>
   void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
     int img_h = this->source_bitmap->h();
     int bpp = this->source_bitmap->get_bytes_per_pixel();
+
     for (int y = 0; y < img_h; y++) {
       const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
       const unsigned char* p = row_ptr + (this->start_x * bpp);
+
       int min_x = 0;
       bool matching = false;
       unsigned char last_red_value = 0;
-      for (int x = this->start_x; x < this->end_x; x++) {
-        unsigned int color = fetch_color(p);
-        unsigned char current_val = p[0];
-        p += bpp;
-        if (specific_matcher->match(color)) {
-          if (!matching) {
-            min_x = x;
-            last_red_value = current_val;
-            matching = true;
-          }
-          if (x == this->end_x - 1) {
-            this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-            matching = false;
-          }
-        } else if (matching) {
-          this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-          matching = false;
-        }
-      }
-    }
-  }*/
-
-template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
-
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // 1. Unico accesso alla RAM per pixel: leggiamo i 4 byte completi
-                unsigned int c0 = fetch_color(p);
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned int c3 = fetch_color(p + 12);
-
-                // 2. Estrazione a costo zero dai registri della CPU (Operazione bitwise, NO RAM)
-                // Se fetch_color ritorna il mascheramento standard, il primo byte si prende con il cast o lo shift
-                unsigned char v0 = static_cast<unsigned char>(c0); 
-                unsigned char v1 = static_cast<unsigned char>(c1);
-                unsigned char v2 = static_cast<unsigned char>(c2);
-                unsigned char v3 = static_cast<unsigned char>(c3);
 
-                p += 16; 
+      int x = this->start_x;
 
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
+      if (bpp == 4) {
+        for (; x <= this->end_x - 4; x += 4) {
+          // read 4 pixels (16 bytes)
+          unsigned int c0 = fetch_color(p);
+          unsigned int c1 = fetch_color(p + 4);
+          unsigned int c2 = fetch_color(p + 8);
+          unsigned int c3 = fetch_color(p + 12);
 
-                // [Resto della logica dei pixel 0, 1, 2, 3 invariata...]
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
+          // extracts value (used as debugging segment label)
+          unsigned char v0 = static_cast<unsigned char>(c0);
+          unsigned char v1 = static_cast<unsigned char>(c1);
+          unsigned char v2 = static_cast<unsigned char>(c2);
+          unsigned char v3 = static_cast<unsigned char>(c3);
 
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
+          p += 16;
 
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
+          bool m0 = specific_matcher->match(c0);
+          bool m1 = specific_matcher->match(c1);
+          bool m2 = specific_matcher->match(c2);
+          bool m3 = specific_matcher->match(c3);
 
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
+          if (m0) {
+            if (!matching) {
+              min_x = x; last_red_value = v0; matching = true;
             }
-        }
-
-        // --- CLEANUP SCALARE ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            // Applichiamo la stessa ottimizzazione anche qui
-            unsigned char current_val = static_cast<unsigned char>(color);
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
-            }
-        }
-
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
-        }
-    }
-}
-
- /*template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
-
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        // --- IL TUO SWEET SPOT: UNROLLING A 4 VIE RIFINITO ---
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // Leggiamo in sequenza stretta per ottimizzare i register e la cache L1
-                unsigned int c0 = fetch_color(p);
-                unsigned char v0 = p[0];
-                
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned char v1 = p[4];
-                
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned char v2 = p[8];
-                
-                unsigned int c3 = fetch_color(p + 12);
-                unsigned char v3 = p[12];
-
-                p += 16; // Spostato qui: avanza di 4 pixel RGBA precisi
-
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
-
-                // Pixel 0
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 1
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 2
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
+            matching = false;
+          }
 
-                // Pixel 3
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
+          if (m1) {
+            if (!matching) {
+              min_x = x + 1; last_red_value = v1; matching = true;
             }
-        }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
+            matching = false;
+          }
 
-        // --- CLEANUP SCALARE PER I RIMANENTI ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            unsigned char current_val = p[0];
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
+          if (m2) {
+            if (!matching) {
+              min_x = x + 2; last_red_value = v2; matching = true;
             }
-        }
-
-        // --- CHIUSURA DI SICUREZZA FINE RIGA ---
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
-        }
-    }
-}*/
-
-
-
-/*
-
-  #include <cstdint>
-
-template <typename M, typename F>
-void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
-    int img_h = this->source_bitmap->h();
-    int bpp = this->source_bitmap->get_bytes_per_pixel();
-
-    for (int y = 0; y < img_h; y++) {
-        const unsigned char* row_ptr = this->source_bitmap->get_row_ptr(y);
-        const unsigned char* p = row_ptr + (this->start_x * bpp);
-        
-        int min_x = 0;
-        bool matching = false;
-        unsigned char last_red_value = 0;
-        
-        int x = this->start_x;
-
-        // --- LINEA 1: UNROLLING A 4 VIE (SIMD FRIENDLY, NO DEPENDENCY) ---
-        if (bpp == 4) {
-            for (; x <= this->end_x - 4; x += 4) {
-                // Carichiamo 4 pixel in variabili separate (zero dipendenze tra loro)
-                unsigned int c0 = fetch_color(p);
-                unsigned int c1 = fetch_color(p + 4);
-                unsigned int c2 = fetch_color(p + 8);
-                unsigned int c3 = fetch_color(p + 12);
-
-                unsigned char v0 = p[0];
-                unsigned char v1 = p[4];
-                unsigned char v2 = p[8];
-                unsigned char v3 = p[12];
-
-                p += 16; // Avanza di 4 pixel (4 * 4 byte)
-
-                // Eseguiamo il match in parallelo. Il compilatore trasforma questo in istruzioni vettoriali
-                bool m0 = specific_matcher->match(c0);
-                bool m1 = specific_matcher->match(c1);
-                bool m2 = specific_matcher->match(c2);
-                bool m3 = specific_matcher->match(c3);
-
-                // Pixel 0
-                if (m0) {
-                    if (!matching) { min_x = x; last_red_value = v0; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 1
-                if (m1) {
-                    if (!matching) { min_x = x + 1; last_red_value = v1; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
-                    matching = false;
-                }
-
-                // Pixel 2
-                if (m2) {
-                    if (!matching) { min_x = x + 2; last_red_value = v2; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
-                    matching = false;
-                }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x + 1, y, last_red_value, offset);
+            matching = false;
+          }
 
-                // Pixel 3
-                if (m3) {
-                    if (!matching) { min_x = x + 3; last_red_value = v3; matching = true; }
-                } else if (matching) {
-                    this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
-                    matching = false;
-                }
+          if (m3) {
+            if (!matching) {
+              min_x = x + 3; last_red_value = v3; matching = true;
             }
+          } else if (matching) {
+            this->node_cluster->add_node(min_x, x + 2, y, last_red_value, offset);
+            matching = false;
+          }
         }
+      }
 
-        // --- LINEA 2: SCALAR CLEANUP ---
-        for (; x < this->end_x; x++) {
-            unsigned int color = fetch_color(p);
-            unsigned char current_val = p[0];
-            p += bpp;
-            
-            if (specific_matcher->match(color)) {
-                if (!matching) {
-                    min_x = x;
-                    last_red_value = current_val;
-                    matching = true;
-                }
-            } else if (matching) {
-                this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
-                matching = false;
-            }
+      // remaining pixels (width not a multiple of 4)
+      for (; x < this->end_x; x++) {
+        unsigned int color = fetch_color(p);
+        unsigned char current_val = static_cast<unsigned char>(color);
+        p += bpp;
+        if (specific_matcher->match(color)) {
+          if (!matching) {
+            min_x = x;
+            last_red_value = current_val;
+            matching = true;
+          }
+        } else if (matching) {
+          this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
+          matching = false;
         }
+      }
 
-        // --- CHIUSURA DI SICUREZZA ---
-        if (matching) {
-            this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
-        }
+      if (matching) {
+        this->node_cluster->add_node(min_x, this->end_x - 1, y, last_red_value, offset);
+      }
     }
-}*/
+  }
 
  public:
   PolygonFinder(Bitmap *bitmap,

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

@@ -35,7 +35,6 @@ class Finder : public Poolable {
   Matcher *matcher;
   pf_Options options_;
   std::vector<std::string> input_options;
-  Tile* whole_tile = nullptr;
   std::queue<ClippedPolygonFinder*> finders;
   std::mutex finders_mutex;
   std::map<std::string, double> reports;
@@ -45,6 +44,7 @@ class Finder : public Poolable {
   Queue<Tile*> tiles_;
   int maximum_width_;
   int height = 0;
+  Tile* whole_tile = nullptr;
   void process_tiles();
 
  public:
@@ -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;
 };