contrek 1.1.9 → 1.2.0

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

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

@@ -39,74 +39,39 @@ module Contrek
       end
 
       def join_inners!(outer_seq)
-        # search for missing sequence to sew
-        missing_shapes = []
-        @cluster.tiles.each do |tile|
-          tile.shapes.each do |shape|
-            next if shape.outer_polyline.on?(Polyline::TRACKED_OUTER) ||
-              shape.outer_polyline.on?(Polyline::TRACKED_INNER) ||
-              !shape.outer_polyline.boundary? ||
-              @shapes_sequence.include?(shape)
-            missing_shapes << shape
-          end
-        end
-
-        if missing_shapes.any?
-          to_delay_shapes = connect_missings(@shapes_sequence, missing_shapes)
-          if to_delay_shapes.any?
-            connect_missings(to_delay_shapes, missing_shapes)
-            while to_delay_shapes.any?
-              to_delay_shapes = connect_missings(@shapes_sequence, to_delay_shapes)
-            end
-          end
-        end
-
-        retme = collect_inner_sequences(outer_seq)
+        return_inner_polylines = []
 
-        @shapes_sequence.each do |shape|
-          shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
-        end
-        retme
-      end
+        @processing_shapes = @shapes_sequence.to_a
 
-      private
+        @processing_shapes.each do |shape|
+          polyline = shape.outer_polyline
+          polyline.parts.each do |part|
+            if part.innerable?
+              all_parts = []
+              bounds = {min: polyline.max_y, max: 0}
+              traverse_inner(part, all_parts, bounds)
+              range_of_bounds = (bounds[:min]..bounds[:max])
 
-      def connect_missings(shapes_sequence, missing_shapes)
-        delay_shapes = []
+              retme_sequence = Sequence.new
+              all_parts.each do |part|
+                part.touch!
+                retme_sequence.move_from(part) do |position|
+                  next false if part.is?(Part::ADDED) && !(range_of_bounds === position.payload[:y])
 
-        shapes_sequence.each do |shape|
-          polyline = shape.outer_polyline
-          missing_shapes.each do |missing_shape|
-            missing_outer_polyline = missing_shape.outer_polyline
-            next if (polyline.mixed_tile_origin == false && missing_outer_polyline.tile == polyline.tile) || # accepts only other side ones
-              missing_outer_polyline.on?(Polyline::TRACKED_OUTER) ||
-              polyline == missing_outer_polyline ||
-              !polyline.vert_intersect?(missing_outer_polyline)
-
-            if (intersection = polyline.intersection(missing_outer_polyline)).any?
-              inject_sequences_left, inject_sequences_right = polyline.sew!(intersection, missing_outer_polyline)
-              if inject_sequences_left.nil?
-                delay_shapes << missing_shape
-                next
-              end
-              combine!(inject_sequences_right, inject_sequences_left).each do |sewn_sequence|
-                sewn_sequence.uniq!
-                if sewn_sequence.size > 1 && sewn_sequence.map { |c| c[:x] }.uniq.size > 1 # only areas
-                  @orphan_inners << InnerPolyline.new(shape: shape, raw_coordinates: sewn_sequence, recombined: true)
+                  !(polyline.tile.tg_border?(position.payload) && position.end_point.tracked_outer)
                 end
               end
-              missing_outer_polyline.clear!
-              polyline.mixed_tile_origin = true
-              missing_outer_polyline.turn_on(Polyline::TRACKED_OUTER)
-              missing_outer_polyline.turn_on(Polyline::TRACKED_INNER)
-              @orphan_inners += missing_shape.inner_polylines
+              if retme_sequence.is_not_vertical
+                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
+              end
             end
           end
         end
-
-        delay_shapes
+        return_inner_polylines
       end
 
+      private
+
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
         last_part = all_parts.last
@@ -126,13 +91,19 @@ module Contrek
               outer_joined_polyline.head.payload == new_position.payload &&
               act_part == all_parts.first
             outer_joined_polyline.add(Position.new(position: new_position.payload, hub: @cluster.hub))
-            act_part.polyline.next_tile_eligible_shapes.each do |shape|
-              if (part = shape.outer_polyline.find_first_part_by_position(new_position, act_part.versus))
-                if all_parts[-2] != part
-                  if all_parts.size >= 2
-                    map = all_parts[-2..].map(&:type).uniq
-                    break if map.size == 1 && map.first == Part::SEAM
-                  end
+            new_position.end_point.tracked_outer = true
+            versus = act_part.versus
+            part = new_position.end_point.queues.find do |p|
+              p.versus == -versus && p.polyline.tile != act_part.polyline.tile
+            end
+            if part
+              if all_parts[-2] != part
+                cont = true
+                if all_parts.size >= 2
+                  map = all_parts[-2..].map(&:type).uniq
+                  cont = false if map.size == 1 && map.first == Part::SEAM
+                end
+                if cont
                   shapes_sequence.add(part.polyline.shape)
                   part.next_position(new_position)
                   part.dead_end = true
@@ -149,36 +120,9 @@ module Contrek
         traverse_outer(act_part.circular_next, all_parts, shapes_sequence, outer_joined_polyline)
       end
 
-      def collect_inner_sequences(outer_seq)
-        return_inner_polylines = []
-        @shapes_sequence.each do |shape|
-          polyline = shape.outer_polyline
-          polyline.parts.each do |part|
-            if part.innerable?
-              all_parts = []
-              bounds = {min: polyline.max_y, max: 0}
-              traverse_inner(part, all_parts, bounds)
-              range_of_bounds = (bounds[:min]..bounds[:max])
-
-              retme_sequence = Sequence.new
-              all_parts.each do |part|
-                part.touch!
-                retme_sequence.move_from(part) do |position|
-                  next false if part.is?(Part::ADDED) && !(range_of_bounds === position.payload[:y])
-                  !(polyline.tile.tg_border?(position.payload) && position.end_point.queues.include?(outer_seq))
-                end
-              end
-              if retme_sequence.is_not_vertical
-                return_inner_polylines << InnerPolyline.new(sequence: retme_sequence)
-              end
-            end
-          end
-        end
-        return_inner_polylines
-      end
-
       def traverse_inner(act_part, all_parts, bounds)
         return if act_part == all_parts.first
+
         if act_part.size > 0
           min_y, max_y = act_part.to_a.minmax_by { |p| p[:y] }
           bounds[:min] = [bounds[:min], min_y[:y]].min
@@ -186,26 +130,32 @@ module Contrek
         end
         if act_part.innerable?
           all_parts << act_part
-          while (act_part = act_part.next)
+          while (act_part = act_part.circular_next)
             if act_part.innerable?
               all_parts << act_part
             else
-              act_part.polyline.next_tile_eligible_shapes.each do |shape|
-                shape.outer_polyline.parts.each do |dest_part|
-                  next if dest_part.trasmuted || dest_part.is?(Part::EXCLUSIVE)
+              if act_part.head
+                eligibles = act_part.head.end_point.queues.select { |p| p.polyline.tile != act_part.polyline.tile }
+                eligibles.each do |dest_part|
                   dest_part_versus = dest_part.versus
                   next if dest_part_versus != 0 && dest_part_versus == act_part.versus
-                  if dest_part.intersect_part?(act_part)
-                    link_seq = dest_part.continuum_to?(act_part)
-                    if link_seq.any?
-                      ins_part = Part.new(Part::ADDED, act_part.polyline)
-                      link_seq.each do |pos|
-                        ins_part.add(Position.new(position: nil, hub: nil, known_endpoint: pos))
-                      end
-                      all_parts << ins_part
+
+                  link_seq = dest_part.continuum_to?(act_part)
+                  if link_seq.any?
+                    ins_part = Part.new(Part::ADDED, act_part.polyline)
+                    link_seq.each do |pos|
+                      ins_part.add(Position.new(position: nil, hub: nil, known_endpoint: pos))
                     end
-                    shape.outer_polyline.turn_on(Polyline::TRACKED_INNER)
-                    shape.outer_polyline.turn_on(Polyline::TRACKED_OUTER)
+                    all_parts << ins_part
+                  end
+                  shape = dest_part.polyline.shape
+                  if !dest_part.polyline.on?(Polyline::TRACKED_OUTER)
+                    @processing_shapes << shape
+                    @orphan_inners += shape.inner_polylines
+                  end
+                  dest_part.polyline.turn_on(Polyline::TRACKED_OUTER)
+                  if !dest_part.touched
+                    dest_part.touch!
                     traverse_inner(dest_part.circular_next, all_parts, bounds)
                     return
                   end
@@ -219,20 +169,6 @@ module Contrek
         end
       end
       # rubocop:enable Lint/NonLocalExitFromIterator
-
-      # example
-      # a = [[A],[B,C]]
-      # b = [[D],[E,F]]
-      # res = [[D,B,C],[E,F,A]]
-      def combine!(seqa, seqb)
-        rets = []
-        [seqa.count, seqb.count].min.times do
-          last = seqa.pop
-          first = seqb.shift
-          rets << first + last
-        end
-        rets
-      end
     end
   end
 end

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

@@ -2,9 +2,11 @@ module Contrek
   module Concurrent
     class EndPoint
       attr_reader :queues, :position
+      attr_accessor :tracked_outer
       def initialize(position)
         @queues = []
         @position = position
+        @tracked_outer = false
       end
 
       def inspect

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

@@ -7,8 +7,8 @@ module Contrek
       EXCLUSIVE = 0
       ADDED = 2
 
-      attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :delayed, :versus
+      attr_reader :polyline, :touched
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :versus
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
@@ -19,7 +19,6 @@ module Contrek
         @touched = false
         @inverts = false
         @trasmuted = false
-        @delayed = false
         @versus = 0
       end
 
@@ -27,10 +26,6 @@ module Contrek
         @type == type
       end
 
-      def set_polyline(polyline)
-        @polyline = polyline
-      end
-
       def add_position(position)
         hub = is?(EXCLUSIVE) ? nil : polyline.tile.cluster.hub
         add(Position.new(position: position, hub: hub))
@@ -68,19 +63,6 @@ module Contrek
         (@touched == false) && is?(EXCLUSIVE)
       end
 
-      def intersect_part?(other_part)
-        intersect = false
-        other_part.each do |position|
-          if position.end_point.queues.include?(self)
-            intersect = true
-            false
-          else
-            true
-          end
-        end
-        intersect
-      end
-
       def orient!
         @versus = if size <= 1 || (size == 2 && @inverts)
           0