contrek 1.1.7 → 1.1.9

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

@@ -14,12 +14,15 @@
 #include "Cluster.h"
 #include "Hub.h"
 #include "PartPool.h"
+#include "InnerPolyline.h"
 
 class Cluster {
  private:
   Finder *finder;
   std::vector<Tile*> tiles_;
   Hub *hub_ = nullptr;
+  void assign_ancestry(Shape *shape, std::vector<InnerPolyline*>& inner_polylines);
+
  public:
   Cluster(Finder *finder, int height, int start_x, int end_x);
   virtual ~Cluster();

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

@@ -12,34 +12,28 @@
 #include <unordered_set>
 #include "Cursor.h"
 #include "Polyline.h"
+#include "InnerPolyline.h"
 
 Cursor::Cursor(Cluster& cluster, Shape* shape)
 : cluster(cluster), shape(shape) {
 }
 
-Cursor::~Cursor() {
-  for (Sequence* sequence : this->allocated_sequences) {
-    delete sequence;
-  }
-}
-
 Sequence* Cursor::join_outers()
 { Polyline* outer_polyline = shape->outer_polyline;
-  this->shapes_sequence.push_back(this->shape);
+  this->shapes_sequence_.push_back(this->shape);
   this->shapes_sequence_lookup.insert(this->shape);
-  Sequence* outer_joined_polyline = new Sequence();
-  this->allocated_sequences.push_back(outer_joined_polyline);
+  Sequence* outer_joined_polyline = outer_polyline->tile->shapes_pool->acquire_sequence();
   std::vector<Part*> all_parts;
   this->traverse_outer(outer_polyline->parts().front(),
                        all_parts,
-                       this->shapes_sequence,
+                       this->shapes_sequence_,
                        outer_joined_polyline);
 
   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();
 
-  for (Shape* shape : shapes_sequence) {
+  for (Shape* shape : shapes_sequence_) {
     shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
     if (shape == outer_polyline->shape) {
       continue;
@@ -127,8 +121,8 @@ void Cursor::traverse_outer(Part* act_part,
   }
 }
 
-std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
-  std::vector<Sequence*> retme;
+std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
+  std::vector<InnerPolyline*> retme;
   std::vector<Shape*> missing_shapes;
 
   for (Tile *tile : this->cluster.tiles())
@@ -136,7 +130,7 @@ std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
     { if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) ||
         shape->outer_polyline->is_on(Polyline::TRACKED_INNER) ||
         !shape->outer_polyline->boundary() ||
-        std::find(shapes_sequence.begin(), shapes_sequence.end(), shape) != shapes_sequence.end()) {
+        std::find(shapes_sequence_.begin(), shapes_sequence_.end(), shape) != shapes_sequence_.end()) {
         continue;
       }
       missing_shapes.push_back(shape);
@@ -145,17 +139,17 @@ std::vector<Sequence*> Cursor::join_inners(Sequence* outer_seq) {
 
   if (missing_shapes.size() > 0) {
     std::vector<Shape*> to_delay_shapes;
-    to_delay_shapes = connect_missings(this->shapes_sequence, missing_shapes);
+    to_delay_shapes = connect_missings(this->shapes_sequence_, missing_shapes);
     if (!to_delay_shapes.empty())
     { connect_missings(to_delay_shapes, missing_shapes);
       while (!to_delay_shapes.empty()) {
-        to_delay_shapes = connect_missings(this->shapes_sequence, to_delay_shapes);
+        to_delay_shapes = connect_missings(this->shapes_sequence_, to_delay_shapes);
       }
     }
   }
 
   retme = collect_inner_sequences(outer_seq);
-  for (Shape* shape : shapes_sequence) {
+  for (Shape* shape : shapes_sequence_) {
     shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
   }
   return(retme);
@@ -206,7 +200,7 @@ std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence
             }
           }
           if (different_x) {
-            orphan_inners_.push_back(sewn_sequence);
+            orphan_inners_.push_back(outer_polyline->tile->shapes_pool->acquire_inner_polyline(sewn_sequence, shape, true));
           }
         }
         polyline->mixed_tile_origin = true;
@@ -214,9 +208,9 @@ std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence
         outer_polyline->turn_on(Polyline::TRACKED_OUTER);
         outer_polyline->turn_on(Polyline::TRACKED_INNER);
         orphan_inners_.insert(
-        orphan_inners_.end(),
-        missing_shape->inner_polylines.begin(),
-        missing_shape->inner_polylines.end());
+          orphan_inners_.end(),
+          missing_shape->inner_polylines.begin(),
+          missing_shape->inner_polylines.end());
       }
     }
   }
@@ -224,10 +218,10 @@ std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence
   return(delay_shapes);
 }
 
-std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
-  std::vector<Sequence*> return_sequences;
+std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
+  std::vector<InnerPolyline*> return_inner_polylines;
 
-  for (Shape* shape : shapes_sequence)
+  for (Shape* shape : shapes_sequence_)
   { Polyline* polyline = shape->outer_polyline;
     for (Part* part : polyline->parts())
     { if (part->innerable())
@@ -237,7 +231,7 @@ std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
           .max = 0
         };
         traverse_inner(part, all_parts, bounds);
-        Sequence* retme_sequence = new Sequence();
+        Sequence* retme_sequence = shape->outer_polyline->tile->shapes_pool->acquire_sequence();
 
         for (Part* part : all_parts)
         { part->touch();
@@ -251,13 +245,13 @@ std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
             return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->queues_include(outer_seq)));
           });
         }
-        if (retme_sequence->is_not_vertical()) return_sequences.push_back(retme_sequence);
-        else                                   delete retme_sequence;
+        if (retme_sequence->is_not_vertical()) {
+          return_inner_polylines.push_back(polyline->tile->shapes_pool->acquire_inner_polyline(retme_sequence));
+        }
       }
     }
   }
-
-  return(return_sequences);
+  return(return_inner_polylines);
 }
 
 void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bounds& bounds) {
@@ -286,7 +280,7 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
               int dest_part_versus = dest_part->versus();
               if (dest_part_versus != 0 && dest_part_versus == act_part->versus()) continue;
               if (dest_part->intersect_part(act_part)) {
-                std::vector<EndPoint*> link_seq = duplicates_intersection(*dest_part, *act_part);
+                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) {
@@ -320,33 +314,6 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
   }
 }
 
-template <typename T>
-std::vector<T*> difference_ptr(std::vector<T*>& a, std::vector<T*>& b)
-{ std::vector<T*> result;
-  for (T* item : a) {
-    auto it = std::find_if(
-      b.begin(), b.end(),
-      [&](T* other) {
-        return other == item;
-      });
-    if (it == b.end()) {
-      result.push_back(item);
-    }
-  }
-  return result;
-}
-
-std::vector<EndPoint*> Cursor::duplicates_intersection(Part& part_a, Part& part_b) {
-  auto a1 = part_a.to_endpoints();
-  auto b1 = part_b.to_endpoints();
-  if (part_a.inverts) a1 = Part::remove_adjacent_pairs(a1);
-  if (part_b.inverts) b1 = Part::remove_adjacent_pairs(b1);
-  std::vector<EndPoint*> result = difference_ptr(a1, b1);
-  std::vector<EndPoint*> temp = difference_ptr(b1, a1);
-  result.insert(result.end(), temp.begin(), temp.end());
-  return result;
-}
-
 std::vector<std::vector<Point*>> Cursor::combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb)
 { std::vector<std::vector<Point*>> rets;
   size_t n = std::min(seqa.size(), seqb.size());

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

@@ -11,38 +11,32 @@
 #include <list>
 #include <vector>
 #include <unordered_set>
+#include "../Primitives.h"
 #include "Sequence.h"
 #include "Cluster.h"
 #include "Shape.h"
 #include "Part.h"
 
-struct Bounds {
-  int min;
-  int max;
-};
-
 class Cursor {
  public:
   Cursor(Cluster& cluster, Shape* shape);
-  virtual ~Cursor();
   Sequence* join_outers();
-  std::vector<Sequence*> join_inners(Sequence* outer_seq);
-  std::list<std::vector<Point*>> orphan_inners() { return orphan_inners_; }
+  std::vector<InnerPolyline*> join_inners(Sequence* outer_seq);
+  std::list<InnerPolyline*> orphan_inners() { return orphan_inners_; }
+  const std::vector<Shape*>& shapes_sequence() const { return shapes_sequence_; }
 
  private:
   Cluster& cluster;
   Shape* shape;
-  std::vector<Sequence*> allocated_sequences;
-  std::vector<Shape*> shapes_sequence;
+  std::vector<Shape*> shapes_sequence_;
   std::unordered_set<Shape*> shapes_sequence_lookup;
-  std::list<std::vector<Point*>> orphan_inners_;
+  std::list<InnerPolyline*> orphan_inners_;
   void traverse_outer(Part* act_part,
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
                       Sequence* outer_joined_polyline);
-  std::vector<Sequence*> collect_inner_sequences(Sequence* outer_seq);
+  std::vector<InnerPolyline*> collect_inner_sequences(Sequence* outer_seq);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
-  std::vector<EndPoint*> duplicates_intersection(Part& part_a, Part& part_b);
   std::vector<std::vector<Point*>> combine(std::vector<std::vector<Point*>>& seqa, std::vector<std::vector<Point*>>& seqb);
   std::vector<Shape*> connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes);
 };

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

@@ -30,19 +30,20 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
   maximum_width_(bitmap->w()),
   height(bitmap->h())
 { cpu_timer.start();
-  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+  if (options != nullptr) FinderUtils::sanitize_options(this->options_, options);
 
-  double cw = static_cast<double>(this->maximum_width_) / this->options.number_of_tiles;
+  double cw = static_cast<double>(this->maximum_width_) / this->options_.number_of_tiles;
   if (cw < 1.0) {
     throw std::runtime_error("One pixel tile width minimum!");
   }
   int x = 0;
-  for (int tile_index = 0; tile_index < this->options.number_of_tiles; tile_index++)
+  for (int tile_index = 0; tile_index < this->options_.number_of_tiles; tile_index++)
   { int tile_end_x = static_cast<int>(cw * (tile_index + 1));
     TilePayload p { tile_index, x, tile_end_x };
     enqueue(p, [this](const TilePayload& payload) {
-      std::vector<std::string> base_arguments = {"--bounds", "--versus=" + this->options.get_alpha_versus()};
-      if (this->options.connectivity_offset == 1) base_arguments.push_back("--connectivity=8");
+      std::vector<std::string> base_arguments = {"--bounds", "--versus=" + this->options_.get_alpha_versus()};
+      if (this->options_.connectivity_offset == 1) base_arguments.push_back("--connectivity=8");
+      if (this->options_.treemap) base_arguments.push_back("--treemap");
       CpuTimer t;
       t.start();
       auto* finder = new ClippedPolygonFinder(
@@ -70,7 +71,7 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
 
 Finder::Finder(int number_of_threads, std::vector<std::string> *options)
 : Poolable(number_of_threads), bitmap(nullptr), matcher(nullptr), input_options(*options), maximum_width_(0) {
-  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+  if (options != nullptr) FinderUtils::sanitize_options(this->options_, options);
   reports["init"] = 0;
 }
 
@@ -145,15 +146,17 @@ ProcessResult* Finder::process_info() {
   pr->groups = pr->polygons.size();
   pr->width = this->maximum_width_;
   pr->height = this->height;
-  FakeCluster fake_cluster(pr->polygons, this->options);
+  FakeCluster fake_cluster(pr->polygons, this->options_);
   cpu_timer.start();
-  fake_cluster.compress_coords(pr->polygons, this->options);
+  fake_cluster.compress_coords(pr->polygons, this->options_);
   reports["compress"] = cpu_timer.stop();
   reports["total"] = reports["compress"] + reports["init"];
   reports["outer"] = this->whole_tile->benchmarks.outer;
   reports["inner"] = this->whole_tile->benchmarks.inner;
+  if (this->options_.treemap) {
+    pr->treemap = this->whole_tile->compute_treemap();
+  }
   pr->benchmarks = this->reports;
-  // TODO(ema): pr->treemap
   // TODO(ema): pr->named_sequence
   return(pr);
 }

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

@@ -33,7 +33,7 @@ class Finder : public Poolable {
  private:
   Bitmap *bitmap;
   Matcher *matcher;
-  pf_Options options;
+  pf_Options options_;
   std::vector<std::string> input_options;
   Tile* whole_tile = nullptr;
   std::queue<ClippedPolygonFinder*> finders;
@@ -54,4 +54,5 @@ class Finder : public Poolable {
   virtual ~Finder();
   int maximum_width() const { return maximum_width_; }
   virtual ProcessResult* process_info();
+  const pf_Options& options() const { return options_; }
 };

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

@@ -0,0 +1,55 @@
+/*
+ * InnerPolyline.cpp
+ *
+ * Copyright (c) 2025-2026 Emanuele Cesaroni
+ *
+ * Licensed under the GNU Affero General Public License v3 (AGPLv3).
+ * See the LICENSE file in this directory for the full license text.
+ */
+
+#include <utility>
+#include <vector>
+#include "InnerPolyline.h"
+
+InnerPolyline::InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape, bool recombined)
+  : raw_coordinates_(std::move(raw_coordinates)),
+    recombined_(recombined),
+    shape_(shape) {}
+InnerPolyline::InnerPolyline(Sequence* sequence)
+  : sequence_(sequence) {
+  this->raw_coordinates_ = sequence->to_vector();
+}
+
+std::vector<Point*>& InnerPolyline::raw() {
+  return this->raw_coordinates_;
+}
+
+Bounds& InnerPolyline::vertical_bounds() {
+  if (sequence_ != nullptr) {
+    return(sequence_->vertical_bounds);
+  } else {
+    return(this->raw_vertical_bounds());
+  }
+}
+
+Shape* InnerPolyline::shape() {
+  if (sequence_ != nullptr) {
+    return(sequence_->shape);
+  } else {
+    return(this->shape_ ? this->shape_ : this->assigned_shape);
+  }
+}
+
+Bounds& InnerPolyline::raw_vertical_bounds() {
+  if (!raw_coordinates_.empty()) {
+    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;
+    }
+    vertical_bounds_.min = min_y;
+    vertical_bounds_.max = max_y;
+  }
+  return(vertical_bounds_);
+}

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

@@ -0,0 +1,32 @@
+/*
+ * InnerPolyline.h
+ *
+ * Copyright (c) 2025-2026 Emanuele Cesaroni
+ *
+ * Licensed under the GNU Affero General Public License v3 (AGPLv3).
+ * See the LICENSE file in this directory for the full license text.
+ */
+
+#pragma once
+#include <vector>
+#include <optional>
+#include "Sequence.h"
+
+class InnerPolyline {
+ public:
+  explicit InnerPolyline(std::vector<Point*> raw_coordinates, Shape* shape, bool recombined = false);
+  explicit InnerPolyline(Sequence* sequence);
+  std::vector<Point*>& raw();
+  Sequence* sequence() { return this->sequence_; }
+  Bounds& vertical_bounds();
+  bool recombined() { return this->recombined_; }
+  Shape* shape();
+  Shape* assigned_shape = nullptr;
+ private:
+  bool recombined_ = false;
+  std::vector<Point*> raw_coordinates_;
+  Sequence* sequence_ = nullptr;
+  Shape* shape_;
+  Bounds& raw_vertical_bounds();
+  Bounds vertical_bounds_;
+};

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

@@ -22,7 +22,7 @@ void Merger::add_tile(ProcessResult& result)
   }
   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);
+  tile->assign_raw_polygons(result.polygons, result.treemap);
   tiles.queue_push(tile);
 
   this->maximum_width_ = end_x;

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

@@ -74,29 +74,6 @@ bool Part::intersect_part(Part* other_part)
   return(intersect);
 }
 
-std::vector<EndPoint*> Part::to_endpoints() {
-  std::vector<EndPoint*> out;
-  QNode<Point>* current = head;
-  while (current) {
-    out.push_back((static_cast<Position*>(current))->end_point());
-    current = current->next;
-  }
-  return out;
-}
-
-std::vector<EndPoint*> Part::remove_adjacent_pairs(const std::vector<EndPoint*>& input = {}) {
-  std::vector<EndPoint*> result;
-  result.reserve(input.size());
-  for (EndPoint* current : input) {
-    if (!result.empty() && result.back() == current) {
-      result.pop_back();
-    } else {
-      result.push_back(current);
-    }
-  }
-  return result;
-}
-
 void Part::orient()
 { if (this->size <= 1 || (this->size == 2 && this->inverts)) {
     this->versus_ = 0;
@@ -127,3 +104,41 @@ 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 {};
+
+  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

@@ -47,10 +47,9 @@ class Part : public Queueable<Point> {
   void touch();
   bool intersect_part(Part* other_part);
   void set_polyline(Polyline* polyline) { this->polyline_ = polyline; }
-  std::vector<EndPoint*> to_endpoints();
-  static std::vector<EndPoint*> remove_adjacent_pairs(const std::vector<EndPoint*>& input);
   void orient();
   std::string inspect();
+  std::vector<EndPoint*> continuum_to(const Part& other_part) const;
 
  private:
   int versus_ = 0;

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

@@ -128,3 +128,24 @@ std::string Polyline::info() {
   ss << "b" << this->tile->name() << " S" << part_index;
   return ss.str();
 }
+
+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) {
+  size_t n = points.size();
+  if (n < 3) return false;
+  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)) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}

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

@@ -16,7 +16,9 @@
 #include <unordered_map>
 #include <string>
 #include "Partitionable.h"
+#include "Sequence.h"
 #include "../RectBounds.h"
+#include "../Primitives.h"
 
 class Tile;
 class Shape;
@@ -49,6 +51,8 @@ class Polyline : public Partitionable {
   void reset_tracked_endpoints();
   bool mixed_tile_origin = false;
   std::string info();
+  bool vert_bounds_intersect(Bounds& vertical_bounds);
+  bool within(std::vector<Point*>& points);
 
  private:
   std::vector<Point*> raw_;

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

@@ -177,6 +177,7 @@ class Queueable {
 
   std::vector<T*> to_vector() const {
     std::vector<T*> out;
+    out.reserve(this->size);
     QNode<T>* current = head;
     while (current) {
         out.push_back(current->payload);

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

@@ -34,3 +34,17 @@ bool Sequence::is_not_vertical()
   }
   return false;
 }
+
+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;
+    for (const auto& pos : cache) {
+      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

@@ -9,13 +9,27 @@
 
 #pragma once
 #include <string>
+#include <vector>
 #include "Queueable.h"
 #include "../Node.h"
 #include "Position.h"
+#include "../Primitives.h"
 
+class Shape;
 class Sequence : public Queueable<Point>{
  public:
   Sequence() {}
   std::string toString();
   bool is_not_vertical();
+  Shape* shape = nullptr;
+  Bounds vertical_bounds;
+  void compute_vertical_bounds();
+  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/Shape.cpp

@@ -8,20 +8,29 @@
  */
 
 #include <list>
+#include <vector>
 #include "Shape.h"
 #include "Polyline.h"
 
-Shape::Shape(Polyline* outer_polyline, const std::list<std::vector<Point*>>& inner_polylines)
+Shape::Shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines)
 : outer_polyline(outer_polyline),
   inner_polylines(inner_polylines) {
-}
-
-Shape::~Shape() {
-  if (outer_polyline) {
-    delete outer_polyline;
+  for (InnerPolyline* ip : inner_polylines) {
+    ip->assigned_shape = this;
   }
 }
 
 void Shape::clear_inner() {
   inner_polylines.clear();
 }
+
+void Shape::set_parent_shape(Shape* shape) {
+  if (this->parent_shape_ != nullptr)
+  { auto& v = this->parent_shape_->children_shapes;
+    v.erase(std::remove(v.begin(), v.end(), this), v.end());
+  }
+  this->parent_shape_ = shape;
+  if (shape != nullptr)
+  { shape->children_shapes.push_back(this);
+  }
+}

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

@@ -11,14 +11,22 @@
 #include <list>
 #include <iostream>
 #include <vector>
+#include "InnerPolyline.h"
 
 class Point;
 class Polyline;
 class Shape {
  public:
-  Shape(Polyline* outer_polyline, const std::list<std::vector<Point*>>& inner_polylines);
-  virtual ~Shape();
+  Shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   Polyline* outer_polyline = nullptr;
-  std::list<std::vector<Point*>> inner_polylines;
+  std::vector<InnerPolyline*> inner_polylines;
+  Shape* merged_to_shape = nullptr;
+  InnerPolyline* parent_inner_polyline = nullptr;
+  std::vector<Shape*> children_shapes;
   void clear_inner();
+  bool reassociation_skip = false;
+  Shape* parent_shape() { return parent_shape_; }
+  void set_parent_shape(Shape*);
+ private:
+  Shape* parent_shape_ = nullptr;
 };