contrek 1.1.8 → 1.2.0

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

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

@@ -29,15 +29,6 @@ Polyline::Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::op
   }
 }
 
-void Polyline::precalc() {
-  next_tile_eligible_shapes_.clear();  // useless if called once
-  for (Shape* s : tile->circular_next->boundary_shapes())
-  { if (!s->outer_polyline->is_on(Polyline::TRACKED_OUTER) && this->vert_intersect(*s->outer_polyline) )
-    { next_tile_eligible_shapes_.push_back(s);
-    }
-  }
-}
-
 bool Polyline::vert_intersect(Polyline& other) {
   return( !(this->max_y_ < other.min_y || other.max_y_ < this->min_y));
 }
@@ -51,10 +42,6 @@ bool Polyline::boundary() {
   return( tile->tg_border(Point{min_x, 0}) || tile->tg_border(Point{max_x, 0}));
 }
 
-void Polyline::reset_tracked_endpoints() {
-  tracked_endpoints.clear();
-}
-
 void Polyline::find_boundary() {
   if (raw_.empty()) return;
   min_x =  std::numeric_limits<int>::max();
@@ -72,43 +59,6 @@ void Polyline::find_boundary() {
   }
 }
 
-std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) const {
-  if (this->tracked_endpoints.empty()) {
-    for (int i = 0; i < parts_.size(); ++i) {
-      auto& part = parts_[i];
-      if (!part->is(Part::SEAM) && part->trasmuted) continue;
-      part->each([&](QNode<Point>* pos) -> bool {
-        Position *position = static_cast<Position*>(pos);
-        if (position->end_point() != nullptr)
-        { this->tracked_endpoints[position->end_point()] = i;
-        }
-        return true;
-      });
-    }
-  }
-
-  std::vector<std::pair<int, int>> matching_parts;
-  for (int j = 0; j < other->parts_.size(); ++j) {
-    auto& other_part = other->parts_[j];
-    if (!other_part->is(Part::SEAM) && other_part->trasmuted) {
-      continue;
-    }
-    other_part->each([&](QNode<Point>* pos) -> bool {
-      Position *position = static_cast<Position*>(pos);
-      auto it = this->tracked_endpoints.find(position->end_point());
-      if (it != this->tracked_endpoints.end()) {
-        int self_index = it->second;
-        matching_parts.push_back({self_index, j});
-        return false;
-      }
-      return true;
-    });
-  }
-
-  return matching_parts;
-}
-
-
 void Polyline::clear() {
   this->raw_.clear();
 }

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

@@ -29,8 +29,7 @@ class Polyline : public Partitionable {
   using Partitionable::Partitionable;
   Polyline(Tile* tile, const std::vector<Point*>& polygon, const std::optional<RectBounds>& bounds = std::nullopt);
   enum Flags : uint32_t {
-    TRACKED_OUTER = 1 << 0,
-    TRACKED_INNER = 1 << 1
+    TRACKED_OUTER = 1 << 0
   };
   void turn_on(Flags f) { flags_ |= f; }
   void turn_off(Flags f) { flags_ &= ~f; }
@@ -41,15 +40,12 @@ class Polyline : public Partitionable {
   Tile *tile = nullptr;
   Shape* shape = nullptr;
   std::vector<Point*> raw() const { return raw_; }
-  const std::list<Shape*>& next_tile_eligible_shapes() const { return next_tile_eligible_shapes_; }
   const std::vector<Part*>& parts() const { return parts_; }
-  std::vector<std::pair<int, int>> intersection(const Polyline* other) const;
   const int max_y() const { return max_y_; }
   void clear();
   bool is_empty();
   bool vert_intersect(Polyline& other);
-  void reset_tracked_endpoints();
-  bool mixed_tile_origin = false;
+  bool any_ancients = false;
   std::string info();
   bool vert_bounds_intersect(Bounds& vertical_bounds);
   bool within(std::vector<Point*>& points);
@@ -59,6 +55,4 @@ class Polyline : public Partitionable {
   int min_x, max_x, min_y, max_y_;
   void find_boundary();
   uint32_t flags_ = 0;
-  std::list<Shape*> next_tile_eligible_shapes_;
-  mutable std::unordered_map<const EndPoint*, int> tracked_endpoints;
 };

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

@@ -7,8 +7,11 @@
  * See the LICENSE file in this directory for the full license text.
  */
 #include <iostream>
+#include <algorithm>
 #include "Position.h"
 #include "Hub.h"
+#include "Part.h"
+#include "Polyline.h"
 
 Position::Position(Hub* hub, Point* point)
 : QNode<Point>(point)
@@ -30,9 +33,25 @@ Position::Position(EndPoint* end_point)
 }
 
 void Position::before_rem(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) this->end_point_->queues().erase(q);
+  /*if (this->end_point_ != nullptr)
+  { if (q->listable())
+    { auto& v = this->end_point_->queues();
+      v.erase(std::remove(v.begin(), v.end(), q), v.end());
+    }
+  }*/
 }
 
-void Position::after_add(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) this->end_point_->queues().insert(q);
+void Position::after_add(Queueable<Point>* q) {
+  if (this->end_point_ != nullptr && q->listable()) {
+    auto& q_vec = this->end_point_->queues();
+    auto it = std::find(q_vec.begin(), q_vec.end(), q);
+    if (it == q_vec.end()) {
+      q_vec.push_back(q);
+      if (q_vec.size() > 1) {
+        static_cast<Part*>(q)->polyline()->any_ancients = true;
+        Queueable<Point>* first_q = q_vec.front();
+        static_cast<Part*>(first_q)->polyline()->any_ancients = true;
+      }
+    }
+  }
 }

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

@@ -39,6 +39,7 @@ class Queueable {
   QNode<T>* _iterator {nullptr};
   bool _started = false;
   size_t size {0};
+  virtual bool listable() const { return false; }
   Queueable() = default;
   virtual ~Queueable() = default;
 
@@ -75,53 +76,6 @@ class Queueable {
     node->after_add(this);
   }
 
-  void reset() {
-    head = nullptr;
-    tail = nullptr;
-    _iterator = nullptr;
-    _started = false;
-    size = 0;
-  }
-
-  void singleton()
-  { if (head && head->next) {
-      head->next->prev = nullptr;
-      head->next = nullptr;
-    }
-    tail = nullptr;
-    size = 1;
-    _iterator = nullptr;
-    _started = false;
-  }
-
-  void replace(Queueable<T>& q) {
-    reset();
-    append(q);
-  }
-
-  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);
-    });
-  }
-
   void rewind() {
     _iterator = nullptr;
     _started = false;
@@ -198,14 +152,4 @@ class Queueable {
     if (!tail) return nullptr;
     return rem(tail);
   }
-
-  bool contains(const T& value) const {
-    QNode<T>* current = head;
-    while (current) {
-      if (current->payload == value)
-          return true;
-      current = current->next;
-    }
-    return false;
-  }
 };

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

@@ -104,18 +104,6 @@ std::string Tile::toString() {
   return s;
 }
 
-const std::list<Shape*>& Tile::boundary_shapes()
-{ if (!boundary_shapes_initialized_)
-  { for (Shape* s : shapes_)
-    { if (s->outer_polyline->boundary())
-      { boundary_shapes_.push_back(s);
-      }
-    }
-    boundary_shapes_initialized_ = true;
-  }
-  return boundary_shapes_;
-}
-
 std::list<Polygon> Tile::to_raw_polygons()
 { std::list<Polygon> retme;
   for (Shape* s : shapes_)

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

@@ -31,8 +31,6 @@ class Tile {
   int end_x_;
   std::string name_;
   std::list<Shape*> shapes_;
-  std::list<Shape*> boundary_shapes_;
-  bool boundary_shapes_initialized_ = false;
 
  public:
   Tile(Finder *finder, int start_x, int end_x, std::string name, const Benchmarks& b);
@@ -46,7 +44,6 @@ class Tile {
   std::string name() const { return name_; }
   const std::list<Shape*>& shapes() const { return shapes_; }
   std::list<Shape*>& shapes() { return shapes_; }
-  const std::list<Shape*>& boundary_shapes();
   bool whole();
   bool left();
   bool right();

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

@@ -12,6 +12,7 @@
 #include <vector>
 #include <algorithm>
 #include <utility>
+#include <unordered_set>
 #include "VerticalMerger.h"
 
 VerticalMerger::VerticalMerger(int number_of_threads, std::vector<std::string> *options)
@@ -35,14 +36,21 @@ ProcessResult* VerticalMerger::process_info() {
 
 void VerticalMerger::transpose(ProcessResult& result) {
   std::swap(result.width, result.height);
-
+  std::unordered_set<Point*> seen;
   for (auto& polygon : result.polygons) {
+    auto process_p = [&](Point* p) {
+      if (p) {
+        if (seen.insert(p).second) {
+          std::swap(p->x, p->y);
+        }
+      }
+    };
     for (Point* p : polygon.outer) {
-      if (p) std::swap(p->x, p->y);
+      process_p(p);
     }
     for (auto& sequence : polygon.inner) {
       for (Point* p : sequence) {
-        if (p) std::swap(p->x, p->y);
+        process_p(p);
       }
     }
     std::swap(polygon.bounds.min_x, polygon.bounds.min_y);

data/lib/contrek/finder/concurrent/cluster.rb

@@ -34,7 +34,6 @@ module Contrek
               next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) || shape.outer_polyline.width == 0
               if shape.outer_polyline.boundary?
                 shape.outer_polyline.partition!
-                shape.outer_polyline.precalc!
               end
             end
           end
@@ -44,7 +43,7 @@ module Contrek
           tile.shapes.each do |shape|
             next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) || shape.outer_polyline.width == 0
 
-            if shape.outer_polyline.boundary? && shape.outer_polyline.next_tile_eligible_shapes.any?
+            if shape.outer_polyline.any_ancients
               cursor = Cursor.new(cluster: self, shape: shape)
 
               new_outer = nil