contrek 1.2.9 → 1.3.1

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();

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

@@ -20,6 +20,7 @@ void Merger::add_tile(ProcessResult& result)
 { if (this->height == 0) {
     this->height = result.height;
   }
+  this->versus = result.versus;
   int end_x = this->current_x + result.width;
   Tile* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), Benchmarks {0, 0});
   tile->assign_raw_polygons(result.polygons, result.treemap);
@@ -36,9 +37,9 @@ ProcessResult* Merger::process_info() {
 
 void Merger::translate(ProcessResult& result, int offset) {
   for (auto& polygon : result.polygons) {
-    for (Point* p : polygon.outer) p->x += offset;
-    for (const auto& seq : polygon.inner) {
-      for (Point* p : seq) p->x += offset;
+    for (Point& p : polygon.outer) p.x += offset;
+    for (auto& seq : polygon.inner) {
+      for (Point& p : seq) p.x += offset;
     }
     polygon.bounds.min_x += offset;
     polygon.bounds.max_x += offset;

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

@@ -29,7 +29,7 @@ Position* Part::next_position(Position* force_position) {
   if (force_position != nullptr)
   { QNode<Point>* move_to_this = nullptr;
     this->reverse_each([&](QNode<Point>* pos) -> bool {
-      if (*(pos->payload) == *(force_position->payload)) {
+      if (pos->payload == force_position->payload) {
         move_to_this = pos;
         return false;
       }
@@ -46,7 +46,7 @@ Position* Part::next_position(Position* force_position) {
   }
 }
 
-void Part::add_position(Point* point) {
+void Part::add_position(const Point& point) {
   Cluster* c = this->polyline_->tile->cluster;
   Hub* hub = is(EXCLUSIVE) ? nullptr : c->hub();
   c->positions_pool.emplace_back(hub, point);
@@ -65,7 +65,7 @@ void Part::orient()
 { if (this->size <= 1 || (this->size == 2 && this->inverts)) {
     this->versus_ = 0;
   } else {
-    int diff = this->tail->payload->y - this->head->payload->y;
+    int diff = this->tail->payload.y - this->head->payload.y;
     if (diff == 0) {
       this->mirror = true;
       this->versus_ = 0;
@@ -75,6 +75,56 @@ 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";
+  }
+}
+
 std::string Part::inspect() {
   size_t part_index = 0;
   auto it = std::find(this->polyline()->parts().begin(), this->polyline()->parts().end(), this);
@@ -89,10 +139,10 @@ std::string Part::inspect() {
   << " trm=" << this->trasmuted
   << " touched=" << this->touched_
   << " dead_end=" << this->dead_end
-  << ", " << this->size << "x) of " << this->polyline()->tile->name()
-  << " (" << std::to_string(static_cast<uint32_t>(type)) << ") (";
+  << ", " << this->size << "x) of " << this->polyline()->tile->name() << " " << this->polyline()->named()
+  << " (" << typeToString(type) << ") (";
   this->each([&](QNode<Point>* pos) -> bool {
-    ss << pos->payload->toString();
+    ss << pos->payload.toString();
     return true;
   });
   ss << ")";
@@ -102,18 +152,18 @@ std::string Part::inspect() {
 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 {};
 
-  Point* target = other_part.head->payload;
+  const Point& target = other_part.head->payload;
   QNode<Point>* cursor = this->tail;
 
   while (cursor != nullptr) {
-    if (*cursor->payload == *target) {
+    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)) {
+        if (!(s->payload == o->payload)) {
           match = false;
           break;
         }

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

@@ -32,15 +32,17 @@ class Part : public Queueable<Point> {
   bool is(Types type);
   bool inverts = false;
   bool trasmuted = false;
+  bool transmutation_skip = false;
   bool dead_end = false;
   bool mirror = false;
   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_; }
   Position* next_position(Position* force_position);
-  void add_position(Point* point);
+  void add_position(const Point& point);
   Types type;
   bool innerable();
   const bool touched() const { return touched_; }
@@ -49,6 +51,9 @@ class Part : public Queueable<Point> {
   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/Partitionable.cpp

@@ -32,18 +32,30 @@ void Partitionable::add_part(Part* new_part)
   new_part->prev = last;
   new_part->circular_next = this->parts_.front();
 
-  if (new_part->is(Part::SEAM)) new_part->orient();
+  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;
-  Point* prev_position = nullptr;
-  for (Point* position : polyline->raw())
-  { if (polyline->tile->tg_border(*position))
+  const Point* prev_position = nullptr;
+  for (const Point& position : polyline->raw())
+  { if (polyline->tile->tg_border(position))
     { if (current_part == nullptr) {
         current_part = pool.acquire(Part::SEAM, polyline);
       } else if (!current_part->is(Part::SEAM)) {
@@ -56,48 +68,51 @@ void Partitionable::partition()
       this->add_part(current_part);
       current_part = pool.acquire(Part::EXCLUSIVE, polyline);
     }
-    if (n > 0 && *prev_position == *position) {
+    if (n > 0 && *prev_position == position) {
       current_part->inverts = true;
     }
     current_part->add_position(position);
     n++;
-    prev_position = position;
+    prev_position = &position;
   }
   this->add_part(current_part);
 
-  this->trasmute_parts();
+  this->transmute_parts();
 }
 
-void Partitionable::trasmute_parts()
-{ std::vector<Part*> insides;
-  for (Part* p : parts_) {
-    if (p->is(Part::SEAM)) insides.push_back(p);
+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;
+    }
   }
-  if (insides.size() < 2) return;
+}
 
-  for (Part* inside : insides)
-  { for (Part* inside_compare : insides) {
-      if (inside == inside_compare || !inside_compare->is(Part::SEAM) ) continue;
-      int count = 0;
-      inside->each([&](QNode<Point>* pos) -> bool {
-        Position *position = static_cast<Position*>(pos);
-        if (position->end_point()->queues_include(inside_compare))
-        { count++;
-          return true;
-        }
-        return false;
-      });
-      if (count == inside->size) {
-        if (count < inside_compare->size) {
-          inside->type = Part::EXCLUSIVE;
-          inside->trasmuted = true;
-          break;
-        } else if ( count == inside_compare->size &&
-                    inside->next == nullptr &&
-                    inside_compare->prev == nullptr) {
-          inside->mirror = true;
+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,8 +21,10 @@ class Partitionable {
 
  protected:
   std::vector<Part*> parts_;
-
+  Part* first_seam = nullptr;
+  Part* last_seam = nullptr;
  private:
   void add_part(Part* new_part);
-  void trasmute_parts();
+  void transmute_parts();
+  void transmute_transposed_part(Part* part);
 };

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

@@ -12,12 +12,13 @@
 #include <string>
 #include <unordered_set>
 #include <sstream>
+#include <utility>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Shape.h"
 
-Polyline::Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds)
-: raw_(polygon),
+Polyline::Polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds)
+: raw_(std::move(polygon)),
   tile(tile)
 { if (bounds.has_value()) {
     min_x =  bounds->min_x;
@@ -45,10 +46,9 @@ void Polyline::find_boundary() {
   max_x_ = -std::numeric_limits<int>::max();
   min_y_ =  std::numeric_limits<int>::max();
   max_y_ = -std::numeric_limits<int>::max();
-  for (Point* p : raw_) {
-    if (!p) continue;
-    int x = p->x;
-    int y = p->y;
+  for (const Point& p : raw_) {
+    int x = p.x;
+    int y = p.y;
     if (x < min_x) min_x = x;
     if (x > max_x_) max_x_ = x;
     if (y < min_y_) min_y_ = y;
@@ -68,17 +68,17 @@ bool Polyline::vert_bounds_intersect(Bounds& vertical_bounds)
 { return !(this->max_y_ < vertical_bounds.min || vertical_bounds.max < this->min_y_);
 }
 
-bool Polyline::within(std::vector<Point*>& points) {
+bool Polyline::within(std::vector<Point>& points) {
   size_t n = points.size();
   if (n < 3) return false;
-  const int tx = this->raw_[0]->x;
-  const int ty = this->raw_[0]->y;
+  const int tx = this->raw_[0].x;
+  const int ty = this->raw_[0].y;
   bool inside = false;
   for (size_t i = 0, j = n - 1; i < n; j = i++) {
-    const Point* pi = points[i];
-    const Point* pj = points[j];
-    if (((pi->y > ty) != (pj->y > ty)) &&
-        (tx < (pj->x - pi->x) * (ty - pi->y) / (pj->y - pi->y) + pi->x)) {
+    const Point& pi = points[i];
+    const Point& pj = points[j];
+    if (((pi.y > ty) != (pj.y > ty)) &&
+        (tx < (pj.x - pi.x) * (ty - pi.y) / (pj.y - pi.y) + pi.x)) {
       inside = !inside;
     }
   }

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

@@ -28,7 +28,7 @@ class InnerPolyline;
 class Polyline : public Partitionable {
  public:
   using Partitionable::Partitionable;
-  Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds = std::nullopt);
+  Polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt);
   enum Flags : uint32_t {
     TRACKED_OUTER = 1 << 0
   };
@@ -40,7 +40,7 @@ class Polyline : public Partitionable {
   int width();
   Tile *tile = nullptr;
   Shape* shape = nullptr;
-  const std::vector<Point*>& raw() const { return raw_; }
+  const std::vector<Point>& raw() const { return raw_; }
   const std::vector<Part*>& parts() const { return parts_; }
   const int max_y() const { return max_y_; }
   const int min_y() const { return min_y_; }
@@ -49,14 +49,14 @@ class Polyline : public Partitionable {
   bool is_empty();
   bool any_ancients = false;
   bool vert_bounds_intersect(Bounds& vertical_bounds);
-  bool within(std::vector<Point*>& points);
+  bool within(std::vector<Point>& points);
   InnerPolyline* inside_inner_polyline = nullptr;
   std::string named();
   void set_named(std::string force_named) { this->named_ = force_named; }
   void fill_bounds(RectBounds& target_bounds) const;
 
  private:
-  std::vector<Point*> raw_;
+  std::vector<Point> raw_;
   int min_x, max_x_, min_y_, max_y_;
   void find_boundary();
   uint32_t flags_ = 0;

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

@@ -13,10 +13,10 @@
 #include "Part.h"
 #include "Polyline.h"
 
-Position::Position(Hub* hub, Point* point)
+Position::Position(Hub* hub, const Point& point)
 : QNode<Point>(point)
 { if (hub != nullptr) {
-    int key = point->y;
+    int key = point.y;
     EndPoint* existing_ep = hub->get(key);
     if (existing_ep == nullptr)
     { end_point_ = hub->put(key, hub->spawn_end_point());

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

@@ -17,7 +17,7 @@ class EndPoint;
 class Hub;
 class Position : public QNode<Point>{
  public:
-  explicit Position(Hub* hub, Point* point);
+  explicit Position(Hub* hub, const Point& point);
   explicit Position(EndPoint* end_point);
   EndPoint* end_point() { return end_point_; }
   void before_rem(Queueable<Point>* q) override;

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

@@ -20,11 +20,11 @@ class Queueable;
 template <typename T>
 class QNode {
  public:
-  T* payload;
+  T payload;
   QNode<T>* next  {nullptr};
   QNode<T>* prev  {nullptr};
   Queueable<T>* owner {nullptr};
-  explicit QNode(T* value) : payload(value) {}
+  explicit QNode(const T& value) : payload(value) {}
   virtual ~QNode() = default;
   virtual void before_rem(Queueable<T>* q) {}
   virtual void after_add(Queueable<T>* q) {}
@@ -129,8 +129,8 @@ class Queueable {
     }
   }
 
-  std::vector<T*> to_vector() const {
-    std::vector<T*> out;
+  std::vector<T> to_vector() const {
+    std::vector<T> out;
     out.reserve(this->size);
     QNode<T>* current = head;
     while (current) {

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

@@ -13,7 +13,7 @@
 std::string Sequence::toString() {
   std::string retme = "";
   this->each([&](QNode<Point>* pos) -> bool {
-    retme += pos->payload->toString();
+    retme += pos->payload.toString();
     return true;
   });
   return(retme);
@@ -23,11 +23,11 @@ bool Sequence::is_not_vertical()
 { if (this->size < 2) {
     return false;
   }
-  int x0 = head->payload->x;
+  int x0 = head->payload.x;
   this->rewind();
 
   while (QNode<Point>* position = this->iterator())
-  { if (position->payload->x != x0) {
+  { if (position->payload.x != x0) {
       return true;
     }
     this->forward();
@@ -38,11 +38,11 @@ bool Sequence::is_not_vertical()
 void Sequence::compute_vertical_bounds()
 { const auto& cache = get_vector_cache();
   if (!cache.empty()) {
-    int min_y = cache[0]->y;
-    int max_y = cache[0]->y;
+    int min_y = cache[0].y;
+    int max_y = cache[0].y;
     for (const auto& pos : cache) {
-      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/Sequence.h

@@ -24,12 +24,12 @@ class Sequence : public Queueable<Point>{
   Shape* shape = nullptr;
   Bounds vertical_bounds;
   void compute_vertical_bounds();
-  const std::vector<Point*>& get_vector_cache() {
+  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;
+  std::vector<Point> vector_cache;
 };

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

@@ -12,10 +12,12 @@
 #include <string>
 #include "Shape.h"
 #include "Polyline.h"
+#include "ShapePool.h"
 
-Shape::Shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines)
+Shape::Shape(ShapePool* shape_pool, Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines)
 : outer_polyline(outer_polyline),
-  inner_polylines(inner_polylines) {
+  inner_polylines(inner_polylines),
+  shape_pool_(shape_pool) {
   for (InnerPolyline* ip : inner_polylines) {
     ip->assigned_shape = this;
   }
@@ -25,6 +27,10 @@ void Shape::clear_inner() {
   inner_polylines.clear();
 }
 
+void Shape::detach_from_pool() {
+  shape_pool_->detach_shape();
+}
+
 void Shape::set_parent_shape(Shape* shape) {
   if (this->parent_shape_ != nullptr)
   { auto& v = this->parent_shape_->children_shapes;

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

@@ -16,9 +16,10 @@
 
 class Point;
 class Polyline;
+class ShapePool;
 class Shape {
  public:
-  Shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
+  Shape(ShapePool* shape_pool, Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   Polyline* outer_polyline = nullptr;
   std::vector<InnerPolyline*> inner_polylines;
   Shape* merged_to_shape = nullptr;
@@ -29,6 +30,8 @@ class Shape {
   Shape* parent_shape() { return parent_shape_; }
   void set_parent_shape(Shape*);
   std::string name();
+  void detach_from_pool();
  private:
   Shape* parent_shape_ = nullptr;
+  ShapePool* shape_pool_ = nullptr;
 };

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

@@ -8,17 +8,32 @@
  */
 
 #include <vector>
+#include <utility>
 #include "Shape.h"
 #include "ShapePool.h"
+#include "Tile.h"
 
 Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines) {
-  shapes_storage.emplace_back(outer_polyline, inner_polylines);
+  shapes_storage.emplace_back(this, outer_polyline, inner_polylines);
   Shape* shape = &shapes_storage.back();
+  this->shapes_count++;
   return shape;
 }
 
-InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point*> coords, Shape* shape) {
-  inner_polylines_storage.emplace_back(coords, shape);
+void ShapePool::set_owner(Tile* tile) {
+  this->owner_tile_ = tile;
+}
+
+void ShapePool::detach_shape() {
+  this->shapes_count--;
+  if (this->shapes_count == 0) {
+    this->owner_tile_->unregister_pool(this);
+    delete this;
+  }
+}
+
+InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point> coords, Shape* shape) {
+  inner_polylines_storage.emplace_back(std::move(coords), shape);
   InnerPolyline* ip = &inner_polylines_storage.back();
   return ip;
 }
@@ -35,8 +50,8 @@ Sequence* ShapePool::acquire_sequence() {
   return s;
 }
 
-Polyline* ShapePool::acquire_polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
-  polylines_storage.emplace_back(tile, polygon, bounds);
+Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
+  polylines_storage.emplace_back(tile, std::move(polygon), bounds);
   Polyline* p = &polylines_storage.back();
   return p;
 }

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

@@ -20,6 +20,8 @@ class Polyline;
 class InnerPolyline;
 class ShapePool {
  private:
+  int shapes_count = 0;
+  Tile* owner_tile_ = nullptr;
   std::deque<Shape> shapes_storage;
   std::deque<InnerPolyline> inner_polylines_storage;
   std::deque<Sequence> sequences_storage;
@@ -27,8 +29,10 @@ class ShapePool {
 
  public:
   Shape* acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
-  InnerPolyline* acquire_inner_polyline(std::vector<Point*> coords, Shape* s);
+  InnerPolyline* acquire_inner_polyline(std::vector<Point> coords, Shape* s);
   InnerPolyline* acquire_inner_polyline(Sequence* seq);
   Sequence* acquire_sequence();
-  Polyline* acquire_polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds);
+  Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds);
+  void set_owner(Tile* tile);
+  void detach_shape();
 };