contrek 1.1.9 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87e8665985a5c9b3818f5f405609c8bf0f9d81dfaa197054e0801acdc60dc56c
-  data.tar.gz: 450c56eda5bd65ab936fcd52b37e3f8edbc2ec0ac852aa0cc4c052ee6d81ab7e
+  metadata.gz: b46d3ae57168cfeb52a0788b6e11af74a164c8e19b4414783f95ac96d1507ed2
+  data.tar.gz: e0637093c914f2426a74b4a47ebeac34152ae473de619fda2e164f22c5d03bc8
 SHA512:
-  metadata.gz: e4cc2ea0d61819436e922eacdcad551658deceac1b5a907cea03d306de65fa2f71b96018acf6fcc6f88163775cabf0ba9b8d6ded3e9067dfcf3cc3e70d3e3e6d
-  data.tar.gz: ca933647465baca8a294176a1fbbc336bf1956c8eebab2cf48dd45ac4e55ba55ea84b00d38cbdd9ee0cf012b332684b8902c5e98a8cbaaafbfc846b374a12801
+  metadata.gz: 472da77db1202e4cf38416e7c5dcfbd483a1f9b9fdb414afb3583a441c3ea180107741d1bc939270fb2aa46e54541712a0efc56f542abe9afd5f39d66e7c847a
+  data.tar.gz: 66ee95022392360b2cb9dbd9757d669a7f01cc95512ee4a74a288e7dc5c94657ebfc0ebe1107090b3e24df490462073f9ea3f2fd6cb57f7432214a809e486b0b

data/CHANGELOG.md

@@ -80,3 +80,7 @@ All notable changes to this project will be documented in this file.
 ## [1.1.9] - 2026-04-24
 ### Changed
 - Improved the internal parts joining algorithm, which was imprecise in some circumstances.
+
+## [1.2.0] - 2026-05-02
+### Changed
+- Further improvements have been applied to the internal parts joining algorithm using a new structural approach. This update is faster and resolves edge cases where inner parts were mistakenly classified as outer perimeters, ensuring precise contour hierarchy. The simplified logic has led to a significant reduction in codebase complexity and the removal of substantial redundant code.

data/Gemfile.lock

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

data/README.md

@@ -167,7 +167,7 @@ Regarding multithreading:
 
 - The algorithm splits the contour-detection workflow into multiple phases that can be executed in parallel. The initial contour extraction on each band and the subsequent merging of coordinates between adjacent bands—performed pairwise, recursively, and in a non-deterministic order—results in a final output that is not idempotent. Idempotence is guaranteed only when the exact same merging sequence is repeated.
 
-By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 1.2 secs with image load).
+By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 1.1 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
@@ -181,11 +181,11 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{ compress: 26.37,
-  init: 354.339,
-  inner: 17.9427,
-  outer: 93.6252,
-  total: 380.709
+{ compress: 23.83,
+  init: 313.179,
+  inner: 6.16,
+  outer: 78.791,
+  total: 337.013
 }
 
 ```
@@ -483,9 +483,12 @@ int main() {
 
 ## License
 
-This project is licensed under the terms of a dual-license.
+Contrek uses a dual-license model:
 
-See [LICENSE.md](LICENSE.md).
+- **Ruby gem and wrappers** — [MIT](lib/LICENSE-MIT.md). Free to use in any project, including commercial ones.
+- **C++17 core engine** (`ext/cpp_polygon_finder/PolygonFinder`) — [AGPLv3](ext/cpp_polygon_finder/PolygonFinder/LICENSE_AGPL.txt). If you use the core in a SaaS or closed-source product, you must either open your source or [contact the author](https://github.com/runout77) for a commercial license.
+
+See [LICENSE.md](LICENSE.md) for full details.
 
 ## Changelog
 

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

@@ -63,7 +63,6 @@ Tile* Cluster::merge_tiles() {
       if (shape->outer_polyline->is_on(Polyline::TRACKED_OUTER) || shape->outer_polyline->width() == 0) continue;
       if (shape->outer_polyline->boundary()) {
         shape->outer_polyline->partition();
-        shape->outer_polyline->precalc();
       }
     }
   }
@@ -77,7 +76,7 @@ Tile* Cluster::merge_tiles() {
         continue;
       }
 
-      if (shape->outer_polyline->boundary() && !shape->outer_polyline->next_tile_eligible_shapes().empty()) {
+      if (shape->outer_polyline->any_ancients) {
         Cursor cursor(*this, shape);
         Sequence* new_outer = nullptr;
 

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

@@ -56,7 +56,6 @@ void Cursor::traverse_outer(Part* act_part,
     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;
@@ -82,36 +81,45 @@ void Cursor::traverse_outer(Part* act_part,
         }
         this->cluster.positions_pool.emplace_back(this->cluster.hub(), new_position->payload);
         outer_joined_polyline->add(&this->cluster.positions_pool.back());
-
-        for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
-          if (Part *part = shape->outer_polyline->find_first_part_by_position(new_position, act_part->versus())) {
-            const auto n = all_parts.size();
-            Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
-
-            if (last_last_part != part) {
-              if (n >= 2) {
-                bool 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;
-                  }
+        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->versus() == -versus && p->polyline()->tile != act_part->polyline()->tile;
+        });
+
+        Part* part = nullptr;
+        if (it != q_set.end()) {
+          part = static_cast<Part*>(*it);
+        }
+        if (part) {
+          const auto n = all_parts.size();
+          Part *last_last_part = n >= 2 ? all_parts[n - 2] : nullptr;
+          if (last_last_part != part) {
+            if (n >= 2) {
+              bool 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) break;
-              }
-              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 (all_seam) break;
+            }
+            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 (jumped_to_new_part) break;
-        act_part->next_position(nullptr);
+        if (!jumped_to_new_part) {
+          act_part->next_position(nullptr);
+        }
       }
     }
     if (jumped_to_new_part) continue;
@@ -122,107 +130,11 @@ void Cursor::traverse_outer(Part* act_part,
 }
 
 std::vector<InnerPolyline*> Cursor::join_inners(Sequence* outer_seq) {
-  std::vector<InnerPolyline*> retme;
-  std::vector<Shape*> missing_shapes;
-
-  for (Tile *tile : this->cluster.tiles())
-  { for (Shape *shape : tile->shapes())
-    { 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()) {
-        continue;
-      }
-      missing_shapes.push_back(shape);
-    }
-  }
-
-  if (missing_shapes.size() > 0) {
-    std::vector<Shape*> to_delay_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);
-      }
-    }
-  }
-
-  retme = collect_inner_sequences(outer_seq);
-  for (Shape* shape : shapes_sequence_) {
-    shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
-  }
-  return(retme);
-}
-
-std::vector<Shape*> Cursor::connect_missings(std::vector<Shape*> shapes_sequence, std::vector<Shape*> missing_shapes) {
-  std::vector<Shape*> delay_shapes;
-
-  for (Shape* shape : shapes_sequence)
-  { Polyline* polyline = shape->outer_polyline;
-    for (Shape* missing_shape : missing_shapes)
-    { Polyline* outer_polyline = missing_shape->outer_polyline;
-      if ( (polyline->mixed_tile_origin == false && outer_polyline->tile == polyline->tile) ||
-           outer_polyline->is_on(Polyline::TRACKED_OUTER)  ||
-           !polyline->vert_intersect(*outer_polyline)) continue;
-      std::vector<std::pair<int, int>> intersection = polyline->intersection(outer_polyline);
-      if (intersection.size() > 0)
-      { auto result = polyline->sew(intersection, outer_polyline);
-        if (!result) {
-          delay_shapes.push_back(missing_shape);
-          continue;
-        }
-        auto& inject_sequences_left = result->first;
-        auto& inject_sequences_right = result->second;
-        auto combined = combine(inject_sequences_right, inject_sequences_left);
-        for (auto& sewn_sequence : combined) {
-          std::vector<Point*> unique;
-          unique.reserve(sewn_sequence.size());
-          for (Point* p : sewn_sequence) {
-            if (!p) continue;
-            auto it = std::find_if(
-              unique.begin(), unique.end(),
-              [&](Point* up) {
-                  return up && *up == *p;
-              });
-            if (it == unique.end()) unique.push_back(p);
-          }
-          sewn_sequence.swap(unique);
-
-          if (sewn_sequence.size() <= 1) continue;
-
-          int first_x = sewn_sequence.front()->x;
-          bool different_x = false;
-          for (Point* p : sewn_sequence) {
-            if (p->x != first_x) {
-              different_x = true;
-              break;
-            }
-          }
-          if (different_x) {
-            orphan_inners_.push_back(outer_polyline->tile->shapes_pool->acquire_inner_polyline(sewn_sequence, shape, true));
-          }
-        }
-        polyline->mixed_tile_origin = true;
-        outer_polyline->clear();
-        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());
-      }
-    }
-  }
-
-  return(delay_shapes);
-}
-
-std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
   std::vector<InnerPolyline*> return_inner_polylines;
-
-  for (Shape* shape : shapes_sequence_)
-  { Polyline* polyline = shape->outer_polyline;
+  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;
@@ -232,7 +144,6 @@ std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq)
         };
         traverse_inner(part, all_parts, bounds);
         Sequence* retme_sequence = shape->outer_polyline->tile->shapes_pool->acquire_sequence();
-
         for (Part* part : all_parts)
         { part->touch();
           retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
@@ -242,7 +153,7 @@ std::vector<InnerPolyline*> Cursor::collect_inner_sequences(Sequence* outer_seq)
               position->payload->y <= bounds.max)) {
             return(false);
           }
-            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->queues_include(outer_seq)));
+            return(!(polyline->tile->tg_border(*position->payload) && position->end_point()->tracked_outer));
           });
         }
         if (retme_sequence->is_not_vertical()) {
@@ -270,27 +181,39 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     if (act_part->innerable()) {
       all_parts.push_back(act_part);
       bool jumped = false;
-      while (act_part = act_part->next) {
+      while (act_part = act_part->circular_next) {
         if (act_part->innerable()) {
             all_parts.push_back(act_part);
         } else {
-          for (Shape *shape : act_part->polyline()->next_tile_eligible_shapes()) {
-            for (Part* dest_part : shape->outer_polyline->parts()) {
-              if (dest_part->trasmuted || dest_part->is(Part::EXCLUSIVE)) continue;
+          if (act_part->head)
+          { for (auto dest_part_p : static_cast<Position*>(act_part->head)->end_point()->queues()) {
+              Part* dest_part = static_cast<Part*>(dest_part_p);
+              if (dest_part->polyline()->tile == act_part->polyline()->tile) {
+                continue;
+              }
               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 = 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);
+              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());
                 }
-                shape->outer_polyline->turn_on(Polyline::TRACKED_OUTER);
-                shape->outer_polyline->turn_on(Polyline::TRACKED_INNER);
+                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);
+                orphan_inners_.insert(
+                  orphan_inners_.end(),
+                  shape->inner_polylines.begin(),
+                  shape->inner_polylines.end());
+              }
+              dest_part->polyline()->turn_on(Polyline::TRACKED_OUTER);
+              if (!dest_part->touched()) {
+                dest_part->touch();
+
                 act_part = dest_part->circular_next;
                 jumped = true;
                 break;
@@ -298,7 +221,6 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
             }
             if (jumped) break;
           }
-          if (jumped) break;
           if (act_part->is(Part::SEAM)) {
             all_parts.push_back(act_part);
           }
@@ -313,17 +235,3 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
     else break;
   }
 }
-
-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());
-  for (size_t i = 0; i < n; ++i) {
-    std::vector<Point*> last = std::move(seqa.back());
-    seqa.pop_back();
-    std::vector<Point*> first = std::move(seqb.front());
-    seqb.erase(seqb.begin());
-    first.insert(first.end(), last.begin(), last.end());
-    rets.push_back(std::move(first));
-  }
-  return rets;
-}

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

@@ -35,8 +35,6 @@ class Cursor {
                       std::vector<Part*>& all_parts,
                       std::vector<Shape*>& shapes_sequence,
                       Sequence* outer_joined_polyline);
-  std::vector<InnerPolyline*> collect_inner_sequences(Sequence* outer_seq);
   void traverse_inner(Part* act_part, std::vector<Part*> &all_parts, Bounds& bounds);
-  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/EndPoint.h

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

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

@@ -61,19 +61,6 @@ void Part::touch()
 {  this->touched_ = true;
 }
 
-bool Part::intersect_part(Part* other_part)
-{ bool intersect = false;
-  other_part->each([&](QNode<Point>* pos) -> bool {
-    Position *position = static_cast<Position*>(pos);
-    if (position->end_point()->queues_include(this))
-    { intersect = true;
-      return(false);
-    }
-    return(true);
-  });
-  return(intersect);
-}
-
 void Part::orient()
 { if (this->size <= 1 || (this->size == 2 && this->inverts)) {
     this->versus_ = 0;

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

@@ -28,10 +28,10 @@ class Part : public Queueable<Point> {
     ADDED = 2
   };
   explicit Part(Types type, Polyline* polyline);
+  bool listable() const override { return true; }
   bool is(Types type);
   bool inverts = false;
   bool trasmuted = false;
-  bool delayed = false;
   bool dead_end = false;
   Part* next = nullptr;
   Part* prev = nullptr;
@@ -45,8 +45,6 @@ class Part : public Queueable<Point> {
   const bool touched() const { return touched_; }
   const int versus() const { return versus_; }
   void touch();
-  bool intersect_part(Part* other_part);
-  void set_polyline(Polyline* polyline) { this->polyline_ = polyline; }
   void orient();
   std::string inspect();
   std::vector<EndPoint*> continuum_to(const Part& other_part) const;

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

@@ -35,17 +35,6 @@ void Partitionable::add_part(Part* new_part)
   if (new_part->is(Part::SEAM)) new_part->orient();
 }
 
-void Partitionable::insert_after(Part* part, Part* new_part) {
-  auto it = std::find(parts_.begin(), parts_.end(), part);
-  if (it != parts_.end()) parts_.insert(it + 1, new_part);
-  new_part->prev = part;
-  new_part->next = part->next;
-  new_part->circular_next = part->next;
-  if (part->next) part->next->prev = new_part;
-  part->next = new_part;
-  part->circular_next = new_part;
-}
-
 void Partitionable::partition()
 { this->parts_.clear();
   Polyline *polyline = static_cast<Polyline*>(this);
@@ -79,123 +68,6 @@ void Partitionable::partition()
   this->trasmute_parts();
 }
 
-Part* Partitionable::find_first_part_by_position(Position* position, int versus) {
-  for (Part* part : this->parts_)
-  { if ( part->is(Part::SEAM) &&
-      part->versus() == -(versus) &&
-      position->end_point()->queues_include(part)) return(part);
-  }
-  return(nullptr);
-}
-
-std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>> intersection, Polyline* other)
-{ std::vector<int> matching_part_indexes;
-  std::vector<int> other_matching_part_indexes;
-  matching_part_indexes.reserve(intersection.size());
-  other_matching_part_indexes.reserve(intersection.size());
-
-  // traspose
-  for (const auto& pair : intersection) {
-    matching_part_indexes.push_back(pair.first);
-    other_matching_part_indexes.push_back(pair.second);
-  }
-  std::sort(matching_part_indexes.begin(), matching_part_indexes.end());
-  std::sort(other_matching_part_indexes.begin(), other_matching_part_indexes.end());
-
-  auto start_it_before = other->parts_.begin() + other_matching_part_indexes.back() + 1;
-  auto end_it_before   = other->parts_.end();
-  std::vector<Part*> before_parts(start_it_before, end_it_before);
-  auto start_it_after = other->parts_.begin();
-  auto end_it_after   = other->parts_.begin() + other_matching_part_indexes.front();
-  std::vector<Part*> after_parts(start_it_after, end_it_after);
-
-  int start_idx = matching_part_indexes.front();
-  int end_idx  = matching_part_indexes.back();
-  Part* part_start = parts_[start_idx];
-  Part* part_end   = parts_[end_idx];
-
-  auto collect_sequences = [&](const std::vector<int>& indices, std::vector<Part*>& p_list)
-    -> std::vector<std::vector<Point*>> {
-    std::vector<std::vector<Point*>> result;
-    int last_n = -1;
-    if (indices.size() < 2) return result;
-    for (int n = indices.front() + 1; n < indices.back(); ++n) {
-      if (std::find(indices.begin(), indices.end(), n) == indices.end()) {
-        Part* part = p_list[n];
-        if (part->is(Part::SEAM) && part->size > 0 && !part->delayed) {
-          part->delayed = true;
-          result.clear();
-          result.push_back({nullptr});
-          return result;
-        }
-        if (last_n == (n - 1) && !result.empty()) {
-          std::vector<Point*> pts = part->to_vector();
-          result.back().insert(result.back().end(), pts.begin(), pts.end());
-        } else {
-          result.push_back(part->to_vector());
-        }
-        last_n = n;
-      }
-    }
-    return result;
-  };
-  auto left = collect_sequences(matching_part_indexes, this->parts_);
-  if (!left.empty() && !left[0].empty() && left[0][0] == nullptr) {
-    return std::nullopt;
-  }
-  auto right = collect_sequences(other_matching_part_indexes, other->parts_);
-  if (!right.empty() && !right[0].empty() && right[0][0] == nullptr) {
-    return std::nullopt;
-  }
-
-  if (part_start != part_end) {
-    for (int n = end_idx - 1; n > start_idx; --n) {
-      Part* delete_part = parts_[n];
-      // Topological detachment of pointers
-      if (delete_part->prev) delete_part->prev->next = delete_part->next;
-      if (delete_part->next) delete_part->next->prev = delete_part->prev;
-      parts_.erase(parts_.begin() + n);
-    }
-  }
-
-  std::vector<Part*> all_parts;
-  Polyline* polyline = static_cast<Polyline*>(this);
-  all_parts.reserve(before_parts.size() + after_parts.size());
-  all_parts.insert(all_parts.end(), before_parts.begin(), before_parts.end());
-  all_parts.insert(all_parts.end(), after_parts.begin(), after_parts.end());
-  Part* will_be_last = all_parts.empty() ? nullptr : all_parts.back();
-  for (auto it = all_parts.rbegin(); it != all_parts.rend(); ++it) {
-    Part* p = *it;
-    this->insert_after(part_start, p);
-    auto& op = other->parts_;
-    op.erase(std::remove(op.begin(), op.end(), p), op.end());
-    p->set_polyline(polyline);
-  }
-
-  part_start->type = Part::EXCLUSIVE;
-  PartPool& pool = polyline->tile->cluster->parts_pool;
-  Part* new_end_part = pool.acquire(Part::EXCLUSIVE, polyline);
-  new_end_part->add(part_end->tail);
-  part_start->singleton();
-
-  // deletes part_end
-  if (part_start != part_end) {
-    if (part_end->prev) part_end->prev->next = part_end->next;
-    if (part_end->next) part_end->next->prev = part_end->prev;
-    auto it = std::find(parts_.begin(), parts_.end(), part_end);
-    if (it != parts_.end()) {
-      parts_.erase(it);
-    }
-  }
-
-  Part* reference_part = (will_be_last != nullptr) ? will_be_last : part_start;
-  this->insert_after(reference_part, new_end_part);
-
-  polyline->reset_tracked_endpoints();
-
-  return std::make_pair(left, right);
-}
-
 void Partitionable::trasmute_parts()
 { std::vector<Part*> insides;
   for (Part* p : parts_) {

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

@@ -10,18 +10,13 @@
 #pragma once
 #include <vector>
 #include <utility>
-#include <optional>
 #include "Part.h"
 
-using SewReturnData = std::pair<std::vector<std::vector<Point*>>, std::vector<std::vector<Point*>>>;
-
 class Partitionable {
  public:
   explicit Partitionable() {}
   virtual ~Partitionable() = default;
   void partition();
-  Part* find_first_part_by_position(Position* position, int versus);
-  std::optional<SewReturnData> sew(std::vector<std::pair<int, int>> intersection, Polyline* other);
   const std::vector<Part*> parts() const { return parts_; }
 
  protected:
@@ -29,6 +24,5 @@ class Partitionable {
 
  private:
   void add_part(Part* new_part);
-  void insert_after(Part* part, Part* new_part);
   void trasmute_parts();
 };