contrek 1.3.3 → 1.3.4

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

@@ -6,6 +6,7 @@
  * Licensed under the GNU Affero General Public License v3 (AGPLv3).
  * See the LICENSE file in this directory for the full license text.
  */
+
 #include <algorithm>
 #include <vector>
 #include <utility>
@@ -18,8 +19,8 @@ Cursor::Cursor(Cluster& cluster, Shape* shape)
 : cluster(cluster), shape(shape) {
 }
 
-Sequence Cursor::join_outers()
-{ Polyline* outer_polyline = shape->outer_polyline;
+Sequence Cursor::join_outers() {
+  Polyline* outer_polyline = shape->outer_polyline;
   this->shapes_sequence_.push_back(this->shape);
   this->shapes_sequence_lookup.insert(this->shape);
   Sequence outer_joined_polyline;
@@ -47,42 +48,67 @@ Sequence Cursor::join_outers()
   return(outer_joined_polyline);
 }
 
-void Cursor::traverse_outer(Part* act_part,
+std::vector<InnerPolyline*> Cursor::join_inners(bool treemap) {
+  std::vector<InnerPolyline*> return_inner_polylines;
+  std::vector<Shape*> processing_queue = shapes_sequence_;
+
+  for (size_t i = 0; i < shapes_sequence_.size(); ++i)
+  { Shape* shape = shapes_sequence_[i];
+    Polyline* polyline = shape->outer_polyline;
+    for (Part* part : polyline->parts())
+    { if (part->innerable())
+      { std::vector<Part*> all_parts;
+        std::vector<EndPoint*> tracked_end_points;
+        traverse_inner(part, all_parts, tracked_end_points);
+        Sequence retme_sequence;
+        for (Part* part : all_parts)
+        { part->touch();
+          retme_sequence.append(*part);
+        }
+        InnerPolyline* inner_polyline = polyline->tile->shapes_pool->acquire_inner_polyline(&retme_sequence);
+        return_inner_polylines.push_back(inner_polyline);
+        if (treemap) {
+          mark_children(tracked_end_points, polyline, inner_polyline);
+        }
+      }
+    }
+  }
+  return(return_inner_polylines);
+}
+
+void Cursor::traverse_outer(Part* start_part,
                             std::vector<Part*>& all_parts,
                             std::vector<Shape*>& shapes_sequence,
                             Sequence& outer_joined_polyline) {
+  Part* act_part = start_part;
+
   while (act_part != nullptr) {
     Part* last_part = (!all_parts.empty()) ? all_parts.back() : nullptr;
     if (all_parts.empty() || last_part != act_part) {
       all_parts.push_back(act_part);
     }
     bool jumped_to_new_part = false;
+
     if (act_part->is(Part::EXCLUSIVE)) {
       if (act_part->size == 0) return;
-
       while (Position *position = act_part->next_position(nullptr)) {
         outer_joined_polyline.add(position);
       }
     } else {
-      if (act_part->dead_end &&
-         all_parts.size() > 1 &&
-         last_part->is(Part::SEAM) &&
-         last_part->polyline() == act_part->polyline()) return;
       while (Position *new_position = static_cast<Position*>(act_part->iterator())) {
         if (outer_joined_polyline.size > 1 &&
-          outer_joined_polyline.head->payload == new_position->payload &&
-          act_part == all_parts.front()) {
+            outer_joined_polyline.head->payload == new_position->payload &&
+            act_part == all_parts.front()) {
           return;
         }
-        this->cluster.positions_pool.emplace_back(this->cluster.hub(), new_position->payload);
-        outer_joined_polyline.add(&this->cluster.positions_pool.back());
         new_position->end_point()->tracked_outer = true;
         int versus = act_part->versus();
         auto& q_set = new_position->end_point()->queues();
         auto it = std::find_if(q_set.begin(), q_set.end(), [&](Queueable<Point>* q) {
           Part* p = static_cast<Part*>(q);
-          return (p->mirror || act_part->mirror || p->versus() == -versus) && p->polyline()->tile != act_part->polyline()->tile;
+          return (p->versus() == -versus) && p->polyline()->tile != act_part->polyline()->tile;
         });
+
         Part* part = nullptr;
         if (it != q_set.end()) {
           part = static_cast<Part*>(*it);
@@ -91,31 +117,16 @@ void Cursor::traverse_outer(Part* act_part,
           const auto n = all_parts.size();
           Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
           if (last_last_part != part) {
-            bool all_seam = false;
-            if (n >= 2) {
-              all_seam = true;
-              for (std::size_t i = all_parts.size() - 2; i < all_parts.size(); ++i) {
-                if (all_parts[i]->type != Part::SEAM) {
-                  all_seam = false;
-                  break;
-                }
-              }
-            }
-            if (!all_seam) {
-              if (shapes_sequence_lookup.insert(part->polyline()->shape).second) {
-                shapes_sequence.push_back(part->polyline()->shape);
-              }
-              part->next_position(new_position);
-              part->dead_end = true;
-              act_part = part;
-              jumped_to_new_part = true;
-              break;
+            if (shapes_sequence_lookup.insert(part->polyline()->shape).second) {
+              shapes_sequence.push_back(part->polyline()->shape);
             }
+            part->next_position(new_position);
+            act_part = part;
+            jumped_to_new_part = true;
+            break;
           }
         }
-        if (!jumped_to_new_part) {
-          act_part->next_position(nullptr);
-        }
+        act_part->next_position(nullptr);
       }
     }
     if (jumped_to_new_part) continue;
@@ -125,79 +136,9 @@ void Cursor::traverse_outer(Part* act_part,
   }
 }
 
-std::vector<InnerPolyline*> Cursor::join_inners(bool treemap) {
-  std::vector<InnerPolyline*> return_inner_polylines;
-  std::vector<Shape*> processing_queue = shapes_sequence_;
-  for (size_t i = 0; i < shapes_sequence_.size(); ++i)
-  { Shape* shape = shapes_sequence_[i];
-    Polyline* polyline = shape->outer_polyline;
-    for (Part* part : polyline->parts())
-    { if (part->innerable())
-      { std::vector<Part*> all_parts;
-        std::vector<EndPoint*> tracked_end_points;
-        Bounds bounds{
-          .min = polyline->max_y(),
-          .max = 0
-        };
-        traverse_inner(part, all_parts, bounds, tracked_end_points);
-        Sequence retme_sequence;
-        for (Part* part : all_parts)
-        { part->touch();
-          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)) {
-            return(false);
-          }
-            return(!(polyline->tile->tg_border(position->payload) && position->end_point()->tracked_outer));
-          });
-        }
-        if (retme_sequence.is_not_vertical()) {
-          InnerPolyline* inner_polyline = polyline->tile->shapes_pool->acquire_inner_polyline(&retme_sequence);
-          return_inner_polylines.push_back(inner_polyline);
-          if (treemap) {
-            mark_children(tracked_end_points, polyline, inner_polyline);
-          }
-        }
-      }
-    }
-  }
-  return(return_inner_polylines);
-}
-
-void Cursor::mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline) {
-  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);
-    for (int y = y_min + 1; y < y_max; ++y) {
-      EndPoint* end_point = this->cluster.hub()->get(y);
-      if (end_point) {
-        for (auto part_p : end_point->queues())
-        { Part* part = static_cast<Part*>(part_p);
-          if (part->polyline() != outer_polyline) {
-            part->polyline()->inside_inner_polyline = inner_polyline;
-          }
-        }
-      }
-    }
-  }
-}
-
-void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bounds& bounds, std::vector<EndPoint*>& tracked_end_points) {
-  PartPool& pool = act_part->polyline()->tile->cluster->parts_pool;
+void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, std::vector<EndPoint*>& tracked_end_points) {
   while (act_part != nullptr) {
     if (!all_parts.empty() && act_part == all_parts.front()) return;
-    if (act_part->size > 0) {
-      auto points = act_part->to_vector();
-      auto [min_it, max_it] = std::minmax_element(
-        points.begin(),
-        points.end(),
-        [](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);
       bool jumped = false;
@@ -216,16 +157,6 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
               if (dest_part_versus != 0 && dest_part_versus == act_part->versus()) continue;
 
               tracked_end_points.push_back(current_end_point);
-
-              std::vector<EndPoint*> link_seq = dest_part->continuum_to(*act_part);
-              if (!link_seq.empty()) {
-                Part* ins_part = pool.acquire(Part::ADDED, act_part->polyline());
-                for (EndPoint* pos : link_seq) {
-                  this->cluster.positions_pool.emplace_back(pos);
-                  ins_part->add(&this->cluster.positions_pool.back());
-                }
-                all_parts.push_back(ins_part);
-              }
               Shape* shape = dest_part->polyline()->shape;
               if (!dest_part->polyline()->is_on(Polyline::TRACKED_OUTER))
               { shapes_sequence_.push_back(shape);
@@ -260,3 +191,22 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     else break;
   }
 }
+
+void Cursor::mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline) {
+  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);
+    for (int y = y_min + 1; y < y_max; ++y) {
+      EndPoint* end_point = this->cluster.hub()->get(y);
+      if (end_point) {
+        for (auto part_p : end_point->queues())
+        { Part* part = static_cast<Part*>(part_p);
+          if (part->polyline() != outer_polyline) {
+            part->polyline()->inside_inner_polyline = inner_polyline;
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -35,7 +35,7 @@ class Cursor {
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
                       Sequence& outer_joined_polyline);
-  void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds, std::vector<EndPoint*>& tracked_end_points);
+  void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, std::vector<EndPoint*>& tracked_end_points);
   std::vector<Shape*> connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes);
   void mark_children(std::vector<EndPoint*>& end_points, const Polyline* outer_polyline, InnerPolyline* inner_polyline);
 };

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

@@ -139,6 +139,7 @@ ProcessResult* Finder::process_info() {
   pr->width = this->maximum_width_;
   pr->height = this->height;
   pr->has_bounds = this->options_.bounds;
+  pr->versus = this->options_.versus;
   FakeCluster fake_cluster(pr->polygons, this->options_);
   cpu_timer.start();
   fake_cluster.compress_coords(pr->polygons, this->options_);

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

@@ -29,8 +29,8 @@ Position* Part::next_position(Position* force_position) {
   if (force_position != nullptr)
   { QNode<Point>* move_to_this = nullptr;
     this->reverse_each([&](QNode<Point>* pos) -> bool {
+      move_to_this = pos;
       if (pos->payload == force_position->payload) {
-        move_to_this = pos;
         return false;
       }
       return true;
@@ -62,12 +62,11 @@ void Part::touch()
 }
 
 void Part::orient()
-{ if (this->size <= 1 || (this->size == 2 && this->inverts)) {
+{ if (this->size <= 1) {
     this->versus_ = 0;
   } else {
     int diff = this->tail->payload.y - this->head->payload.y;
     if (diff == 0) {
-      this->mirror = true;
       this->versus_ = 0;
     } else {
       this->versus_ = diff > 0 ? 1 : -1;
@@ -75,52 +74,10 @@ void Part::orient()
   }
 }
 
-void Part::try_transmutation() {
-  auto& head_queues = static_cast<Position*>(this->head)->end_point()->queues();
-  if (head_queues.size() == 1) {
-    return;
-  }
-
-  auto other_head_it = std::find_if(head_queues.begin(), head_queues.end(), [this](auto* queueable_ptr) {
-    Part* part = static_cast<Part*>(queueable_ptr);
-    return part != this && part->polyline()->tile == this->polyline()->tile;
-  });
-
-  if (other_head_it != head_queues.end()) {
-    Part* other_head_part = static_cast<Part*>(*other_head_it);
-    auto& tail_queues = static_cast<Position*>(this->tail)->end_point()->queues();
-    auto found_in_tail = std::find(tail_queues.begin(), tail_queues.end(), other_head_part);
-    if (found_in_tail != tail_queues.end()) {
-      if ( (other_head_part->tail->payload.y == tail->payload.y && other_head_part->head->payload.y == head->payload.y) ||
-           (other_head_part->tail->payload.y == head->payload.y && other_head_part->head->payload.y == tail->payload.y)) {
-        if (this->next == nullptr && other_head_part->prev == nullptr) {
-            this->mirror = true;
-        }
-      } else {
-          this->type = Part::EXCLUSIVE;
-          this->trasmuted = true;
-          other_head_part->transmutation_skip = true;
-      }
-    }
-  }
-}
-
-bool Part::within(Part* other) {
-  const auto [self_min, self_max] = std::minmax(this->head->payload.y, this->tail->payload.y);
-  const auto [other_min, other_max] = std::minmax(other->head->payload.y, other->tail->payload.y);
-  return (self_min >= other_min) && (self_max <= other_max);
-}
-
-bool Part::same_length(Part* other) {
-  return( std::abs(this->head->payload.y - this->tail->payload.y) ==
-          std::abs(other->head->payload.y - other->tail->payload.y));
-}
-
 constexpr std::string_view typeToString(Part::Types t) noexcept {
   switch (t) {
     case Part::SEAM:      return "SEAM";
     case Part::EXCLUSIVE: return "EXCLUSIVE";
-    case Part::ADDED:     return "ADDED";
     default:        return "UNKNOWN";
   }
 }
@@ -134,11 +91,7 @@ std::string Part::inspect() {
   std::stringstream ss;
   ss << "part " << part_index
   << " (versus=" << this->versus_
-  << " mirror=" << this->mirror
-  << " inv=" << this->inverts
-  << " trm=" << this->trasmuted
   << " touched=" << this->touched_
-  << " dead_end=" << this->dead_end
   << ", " << this->size << "x) of " << this->polyline()->tile->name() << " " << this->polyline()->named()
   << " (" << typeToString(type) << ") (";
   this->each([&](QNode<Point>* pos) -> bool {
@@ -148,41 +101,3 @@ std::string Part::inspect() {
   ss << ")";
   return ss.str();
 }
-
-std::vector<EndPoint*> Part::continuum_to(const Part& other_part) const {
-  if (this->size <= 2 && this->inverts && other_part.size <= 2 && other_part.inverts) return {};
-
-  const Point& target = other_part.head->payload;
-  QNode<Point>* cursor = this->tail;
-
-  while (cursor != nullptr) {
-    if (cursor->payload == target) {
-      QNode<Point>* s = cursor;
-      QNode<Point>* o = other_part.head;
-      bool match = true;
-      int count = 0;
-
-      while (s != nullptr && o != nullptr) {
-        if (!(s->payload == o->payload)) {
-          match = false;
-          break;
-        }
-        s = s->next;
-        o = o->next;
-        count++;
-      }
-      if (match && s == nullptr) {
-        std::vector<EndPoint*> res;
-        res.reserve(count);
-        s = cursor;
-        for (int i = 0; i < count; ++i) {
-          res.push_back(static_cast<Position*>(s)->end_point());
-          s = s->next;
-        }
-        return res;
-      }
-    }
-    cursor = cursor->prev;
-  }
-  return {};
-}

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

@@ -24,25 +24,17 @@ class Part : public Queueable<Point> {
  public:
   enum Types : uint32_t {
     SEAM = 1,
-    EXCLUSIVE = 0,
-    ADDED = 2
+    EXCLUSIVE = 0
   };
   explicit Part(Types type, Polyline* polyline);
   bool listable() const override { return true; }
   bool is(Types type);
-  bool inverts = false;
-  bool trasmuted = false;
-  bool transmutation_skip = false;
-  bool dead_end = false;
-  bool mirror = false;
 
  private:
   bool touched_ = false;
 
  public:
   Part* next = nullptr;
-  Part* next_seam = nullptr;
-  Part* prev = nullptr;
   Part* circular_next = nullptr;
   std::string toString() const { return "Part type = " + std::to_string(static_cast<uint32_t>(type)); }
   Polyline* polyline() { return polyline_; }
@@ -55,10 +47,6 @@ class Part : public Queueable<Point> {
   void touch();
   void orient();
   std::string inspect();
-  std::vector<EndPoint*> continuum_to(const Part& other_part) const;
-  bool within(Part* other);
-  bool same_length(Part* other);
-  void try_transmutation();
 
  private:
   int versus_ = 0;

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

@@ -16,7 +16,6 @@ Part* PartPool::acquire(uint32_t type, Polyline* poly) {
 
   Part* p = &storage.back();
   p->next = nullptr;
-  p->prev = nullptr;
   return p;
 }
 

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

@@ -29,31 +29,19 @@ void Partitionable::add_part(Part* new_part)
   if (last) {
     last->next = last->circular_next = new_part;
   }
-  new_part->prev = last;
   new_part->circular_next = this->parts_.front();
 
   if (new_part->is(Part::SEAM)) {
-    if (!this->first_seam) {
-      this->first_seam = new_part;
-    }
-    if (this->last_seam) {
-      this->last_seam->next_seam = new_part;
-    }
-    this->last_seam = new_part;
     new_part->orient();
   }
 }
 
 void Partitionable::partition()
 { this->parts_.clear();
-  this->first_seam = nullptr;
-  this->last_seam = nullptr;
-
   Polyline *polyline = static_cast<Polyline*>(this);
   PartPool& pool = polyline->tile->cluster->parts_pool;
   Part *current_part = nullptr;
-  int n = 0;
-  const Point* prev_position = nullptr;
+
   for (const Point& position : polyline->raw())
   { if (polyline->tile->tg_border(position))
     { if (current_part == nullptr) {
@@ -68,51 +56,7 @@ void Partitionable::partition()
       this->add_part(current_part);
       current_part = pool.acquire(Part::EXCLUSIVE, polyline);
     }
-    if (n > 0 && *prev_position == position) {
-      current_part->inverts = true;
-    }
     current_part->add_position(position);
-    n++;
-    prev_position = &position;
   }
   this->add_part(current_part);
-
-  this->transmute_parts();
-}
-
-void Partitionable::transmute_transposed_part(Part* part) {
-  if (Part* current_seam = this->first_seam; current_seam != nullptr) {
-    while (current_seam != nullptr) {
-      if (current_seam != part) {
-        if (part->within(current_seam)) {
-          if (!part->same_length(current_seam)) {
-            part->type = Part::EXCLUSIVE;
-            part->trasmuted = true;
-            std::vector<Queueable<Point>*>& a = static_cast<Position*>(part->head)->end_point()->queues();
-            a.erase(std::remove(a.begin(), a.end(), part), a.end());
-            std::vector<Queueable<Point>*>& b = static_cast<Position*>(part->tail)->end_point()->queues();
-            b.erase(std::remove(b.begin(), b.end(), part), b.end());
-          }
-        }
-      }
-      current_seam = current_seam->next_seam;
-    }
-  }
-}
-
-void Partitionable::transmute_parts()
-{ Polyline *polyline = static_cast<Polyline*>(this);
-  bool transpose = polyline->tile->cluster->finder()->transpose();
-  if (Part* current_seam = this->first_seam; current_seam != nullptr) {
-    while (current_seam != nullptr) {
-      if (transpose) {
-        transmute_transposed_part(current_seam);
-      } else {
-        if (!current_seam->transmutation_skip) {
-          current_seam->try_transmutation();
-        }
-      }
-      current_seam = current_seam->next_seam;
-    }
-  }
 }

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

@@ -21,10 +21,7 @@ class Partitionable {
 
  protected:
   std::vector<Part*> parts_;
-  Part* first_seam = nullptr;
-  Part* last_seam = nullptr;
+
  private:
   void add_part(Part* new_part);
-  void transmute_parts();
-  void transmute_transposed_part(Part* part);
 };

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

@@ -120,15 +120,6 @@ class Queueable {
     }
   }
 
-  template<typename Func>
-  void move_from(Queueable<T>& queueable, Func func) {
-    queueable.rewind();
-    while (QNode<T>* node = queueable.iterator())
-    { queueable.forward();
-      if (func(node)) add(node);
-    }
-  }
-
   std::vector<T> to_vector() const {
     std::vector<T> out;
     out.reserve(this->size);
@@ -140,16 +131,39 @@ class Queueable {
     return out;
   }
 
-  std::vector<T> map(std::function<T(QNode<T>*)> fn) {
-      std::vector<T> out;
-      each([&](QNode<T>* n){
-          out.push_back(fn(n));
-      });
-      return out;
-  }
-
   QNode<T>* pop() {
     if (!tail) return nullptr;
     return rem(tail);
   }
+
+  void reset() {
+    head = nullptr;
+    tail = nullptr;
+    _iterator = nullptr;
+    _started = false;
+    size = 0;
+  }
+
+  void append(Queueable<T>& q) {
+    if (q.size == 0) return;
+    QNode<T>* current = q.head;
+    while (current) {
+      current->before_rem(&q);
+      current->owner = this;
+      current = current->next;
+    }
+    if (tail) {
+      tail->next = q.head;
+      q.head->prev = tail;
+    } else {
+      head = q.head;
+    }
+    tail = q.tail;
+    size += q.size;
+    q.reset();
+    each([&](QNode<T>* n) -> bool {
+      n->after_add(this);
+      return(true);
+    });
+  }
 };

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

@@ -18,19 +18,3 @@ std::string Sequence::toString() {
   });
   return(retme);
 }
-
-bool Sequence::is_not_vertical()
-{ if (this->size < 2) {
-    return false;
-  }
-  int x0 = head->payload.x;
-  this->rewind();
-
-  while (QNode<Point>* position = this->iterator())
-  { if (position->payload.x != x0) {
-      return true;
-    }
-    this->forward();
-  }
-  return false;
-}

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

@@ -20,14 +20,5 @@ class Sequence : public Queueable<Point>{
  public:
   Sequence() {}
   std::string toString();
-  bool is_not_vertical();
   Shape* shape = nullptr;
-  const std::vector<Point>& get_vector_cache() {
-    if (vector_cache.empty() && this->size > 0) {
-      vector_cache = this->to_vector();
-    }
-    return vector_cache;
-  }
- private:
-  std::vector<Point> vector_cache;
 };

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

@@ -94,7 +94,7 @@ void Tile::assign_shapes(std::vector<Shape*>& shapes) {
 }
 
 bool Tile::tg_border(const Point& coord) {
-  return( coord.x == (this->next == nullptr ? start_x_ : (end_x_ - 1)));
+  return( coord.x == (this->next == nullptr ? start_x_ : (end_x_)));
 }
 
 void Tile::info() {