contrek 1.1.2 → 1.1.4

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.cpp

@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 #include <utility>
+#include <deque>
 #include "NodeCluster.h"
 #include "Node.h"
 #include "RectBounds.h"
@@ -30,15 +31,9 @@ NodeCluster::NodeCluster(int h, int w, pf_Options *options) {
   this->nodes = 0;
 
   this->vert_nodes.resize(h);
-  for (int i = 0; i < h; ++i) {
-    this->vert_nodes[i].reserve(w/2);
-  }
-
   this->root_nodes = this->lists.add_list();
   this->inner_plot = this->lists.add_list();
   this->inner_new = this->lists.add_list();
-
-  this->points.reserve(w * h);
 }
 
 NodeCluster::~NodeCluster() {
@@ -74,32 +69,33 @@ void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options optio
 void NodeCluster::build_tangs_sequence() {
   for (auto& line : vert_nodes) {
     for (Node& node : line) {
-      node.precalc_tangs_sequences(this->points);
+      node.precalc_tangs_sequences(*this);
     }
   }
 }
 
-Node* NodeCluster::add_node(int min_x, int max_x, int y, char name) {
-  vert_nodes[y].emplace_back(min_x, max_x, y, name);
+Node* NodeCluster::add_node(int min_x, int max_x, int y, char name, int offset) {
+  vert_nodes[y].emplace_back(min_x, max_x, y, this, name);
 
   Node& node = vert_nodes[y].back();
-  node.data_pointer = this->lists.get_data_pointer();
   node.abs_x_index = vert_nodes[y].size() - 1;
   this->nodes++;
 
   root_nodes->push_back(&node);
 
   if (y > 0) {
-    std::vector<Node>& up_nodes = vert_nodes[y - 1];
+    std::deque<Node>& up_nodes = vert_nodes[y - 1];
     if (!up_nodes.empty()) {
       auto it = std::lower_bound(up_nodes.begin(), up_nodes.end(), node.min_x,
-        [](const Node& a, int val) {
-            return a.max_x < val;
+        [&](const Node& a, int val) {
+          return ((a.max_x + offset) < val);
         });
+
       while (it != up_nodes.end()) {
-        if (it->min_x > node.max_x) break;
-        node.add_intersection(&(*it));
-        it->add_intersection(&node);
+        if ((it->min_x - offset) > node.max_x) break;
+        int current_index = std::distance(up_nodes.begin(), it);
+        node.add_intersection(*it, current_index);
+        it->add_intersection(node, node.abs_x_index);
         ++it;
       }
     }
@@ -119,8 +115,11 @@ void NodeCluster::plot(int versus) {
     this->plot_sequence.push_back(root_node);
     Polygon poly;
 
-    if ((root_node)->tangs_sequence.size() > 0)  // front() on empty list is undefined
-    { versus == Node::A ? next_node = root_node->tangs_sequence.back().node : next_node = root_node->tangs_sequence.front().node;
+    if ((root_node)->tangs_sequence.size() > 0)  // front() or back() on empty list is undefined
+    { versus == Node::A ?
+        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.back()) :
+        next_node = root_node->get_tangent_node_by_virtual_index(root_node->tangs_sequence.front());
+
       if (next_node != nullptr)
       { Point* p = next_node->coords_entering_to(root_node, versus_inverter[versus], Node::OUTER);
         poly.outer.push_back(p);
@@ -159,13 +158,20 @@ void NodeCluster::plot(int versus) {
 
         first->inner_index = index_inner;
 
-        Node *next_node;
-        if (first->get_trackmax())
-        { if (inner_v == Node::A)  next_node = first->tangs[Node::T_UP].front();
-          else                     next_node = first->tangs[Node::T_DOWN].front();
+        Node* next_node = nullptr;
+
+        if (first->get_trackmax()) {
+          if (inner_v == Node::A) {
+            if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_start];
+          } else {
+            if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_start];
+          }
         } else {
-          if (inner_v == Node::A)  next_node = first->tangs[Node::T_DOWN].back();
-          else                     next_node = first->tangs[Node::T_UP].back();
+          if (inner_v == Node::A) {
+            if (first->lower_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_DOWN][first->lower_end];
+          } else {
+            if (first->upper_end >= 0) next_node = &this->vert_nodes[first->y + Node::T_UP][first->upper_end];
+          }
         }
 
         if (next_node != nullptr)
@@ -251,7 +257,11 @@ void NodeCluster::plot_inner_node(std::vector<Point*>& sequence_coords, Node *no
 
     bool plot = true;
     if (next_node->y == last_node->y) {
-      Node *n = (versus == Node::A ? current_node->tangs_sequence.front().node : current_node->tangs_sequence.back().node);
+      Node *n;
+      int virtual_index = (versus == Node::A ?
+        current_node->tangs_sequence.front() :
+        current_node->tangs_sequence.back());
+      n = current_node->get_tangent_node_by_virtual_index(virtual_index);
       plot = (n == next_node);
     }
     if (plot) {
@@ -286,7 +296,10 @@ void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, No
 
     bool plot = true;
     if (next_node->y == last_node->y) {
-      Node *n = (versus == Node::A ? current_node->tangs_sequence.back().node : current_node->tangs_sequence.front().node);
+      int virtual_index = (versus == Node::A ?
+          current_node->tangs_sequence.back() :
+          current_node->tangs_sequence.front());
+      Node *n = current_node->get_tangent_node_by_virtual_index(virtual_index);
       plot = (n == next_node);
     }
     if (plot) {
@@ -309,21 +322,3 @@ void NodeCluster::plot_node(std::vector<Point*>& sequence_coords, Node *node, No
     current_node = next_node;
   }
 }
-
-void NodeCluster::list_track(Node *node, std::list<Node*> *list) {
-  std::list<Node*>::iterator i = std::find(list->begin(), list->end(), node);
-  if (i == list->end())  list->push_back(node);
-  else                   list_delete(node, list);
-}
-
-void NodeCluster::list_delete(Node *node, std::list<Node*> *list) {
-  std::list<Node*>::iterator i;
-  while ((i = std::find(list->begin(), list->end(), node)) !=  list->end())
-  {  list->erase(i);
-  }
-}
-
-bool NodeCluster::list_present(Node *node, std::list<Node*> *list) {
-  std::list<Node*>::iterator i = std::find(list->begin(), list->end(), node);
-  return(!(i == list->end()));
-}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.h

@@ -10,6 +10,7 @@
 #pragma once
 #include <list>
 #include <vector>
+#include <deque>
 #include <map>
 #include <string>
 #include <utility>
@@ -32,24 +33,21 @@ class NodeCluster {
   int versus_inverter[2];
   int count = 0;
   int nodes;
-  std::vector<Point> points;
+  int width;
 
  public:
   pf_Options *options;
   std::vector<std::pair<int, int>> treemap;  // [a,b] a = index of parent outer, b = index of inner of parent outer
   std::pair<int, int> test_in_hole_a(Node* node);
   std::pair<int, int> test_in_hole_o(Node* node);
-  std::vector<std::vector<Node>> vert_nodes;
-  void list_track(Node *node, std::list<Node*> *list);
-  void list_delete(Node *node, std::list<Node*> *list);
-  bool list_present(Node *node, std::list<Node*> *list);
+  std::vector<std::deque<Node>> vert_nodes;
   void compress_coords(std::list<Polygon>& polygons, pf_Options options);
   List *root_nodes;
-  int height, width;
+  int height;
   std::list<Polygon> polygons;
   NodeCluster(int h, int w, pf_Options *options);
   virtual ~NodeCluster();
-  Node* add_node(int min_x, int max_x, int y, char name);
+  Node* add_node(int min_x, int max_x, int y, char name, int offset);
   void calc_root_nodes();
   void build_tangs_sequence();
   void plot(int versus);

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

@@ -37,6 +37,7 @@ PolygonFinder::PolygonFinder(Bitmap *bitmap,
       end_x(end_x == -1 ? bitmap->w() : end_x)
 { this->rgb_matcher = dynamic_cast<RGBMatcher*>(matcher);
   if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+
   this->node_cluster = new NodeCluster(source_bitmap->h(), source_bitmap->w(), &this->options);
 
   //= SCAN ==============//
@@ -82,17 +83,18 @@ PolygonFinder::~PolygonFinder() {
 
 void PolygonFinder::scan() {
     int bpp = this->source_bitmap->get_bytes_per_pixel();
+    int offset = options.connectivity_offset;
 
     RGBMatcher* rgb_m = dynamic_cast<RGBMatcher*>(this->matcher);
 
     if (bpp == 1) {
       auto fetcher = [](const unsigned char* p) { return static_cast<unsigned int>(p[0]); };
-      if (rgb_m) run_loop(rgb_m, fetcher);
-      else       run_loop(this->matcher, fetcher);
+      if (rgb_m) run_loop(rgb_m, fetcher, offset);
+      else       run_loop(this->matcher, fetcher, offset);
     } else {
       auto fetcher = [](const unsigned char* p) { return *reinterpret_cast<const uint32_t*>(p); };
-      if (rgb_m) run_loop(rgb_m, fetcher);
-      else       run_loop(this->matcher, fetcher);
+      if (rgb_m) run_loop(rgb_m, fetcher, offset);
+      else       run_loop(this->matcher, fetcher, offset);
     }
 }
 

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

@@ -41,6 +41,7 @@ struct pf_Options {
   bool compress_visvalingam = false;
   bool named_sequences = false;
   bool bounds = false;
+  int connectivity_offset = 0;
   float compress_visvalingam_tolerance = 10.0;
   int number_of_tiles = 1;
   std::string get_alpha_versus() {
@@ -94,7 +95,7 @@ class PolygonFinder {
   CpuTimer cpu_timer;
 
   template <typename M, typename F>
-  void run_loop(M* specific_matcher, F&& fetch_color) {
+  void run_loop(M* specific_matcher, F&& fetch_color, int offset) {
     int img_h = this->source_bitmap->h();
     int bpp = this->source_bitmap->get_bytes_per_pixel();
     for (int y = 0; y < img_h; y++) {
@@ -114,11 +115,11 @@ class PolygonFinder {
             matching = true;
           }
           if (x == this->end_x - 1) {
-            this->node_cluster->add_node(min_x, x, y, last_red_value);
+            this->node_cluster->add_node(min_x, x, y, last_red_value, offset);
             matching = false;
           }
         } else if (matching) {
-          this->node_cluster->add_node(min_x, x - 1, y, last_red_value);
+          this->node_cluster->add_node(min_x, x - 1, y, last_red_value, offset);
           matching = false;
         }
       }

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

@@ -58,7 +58,8 @@ void Cursor::traverse_outer(Part* act_part,
                             std::vector<Shape*>& shapes_sequence,
                             Sequence* outer_joined_polyline) {
   while (act_part != nullptr) {
-    if (all_parts.empty() || all_parts.back() != act_part) {
+    Part* last_part = (!all_parts.empty()) ? all_parts.back() : nullptr;
+    if (all_parts.empty() || last_part != act_part) {
       all_parts.push_back(act_part);
     }
 
@@ -75,6 +76,10 @@ void Cursor::traverse_outer(Part* act_part,
         outer_joined_polyline->add(position);
       }
     } else {
+      if (act_part->dead_end &&
+         all_parts.size() > 1 &&
+         last_part->is(Part::SEAM) &&
+         last_part->polyline() == act_part->polyline()) return;
       while (Position *new_position = static_cast<Position*>(act_part->iterator())) {
         if (outer_joined_polyline->size > 1 &&
           outer_joined_polyline->head->payload == new_position->payload &&
@@ -83,8 +88,9 @@ 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)) {
+          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;
 
@@ -103,6 +109,7 @@ void Cursor::traverse_outer(Part* act_part,
                 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;
@@ -110,7 +117,6 @@ void Cursor::traverse_outer(Part* act_part,
           }
         }
         if (jumped_to_new_part) break;
-        act_part->passes += 1;
         act_part->next_position(nullptr);
       }
     }
@@ -236,7 +242,7 @@ std::vector<Sequence*> Cursor::collect_inner_sequences(Sequence* outer_seq) {
         for (Part* part : all_parts)
         { part->touch();
           retme_sequence->move_from(*part, [&](QNode<Point>* pos) -> bool {
-          Position *position = dynamic_cast<Position*>(pos);
+          Position *position = static_cast<Position*>(pos);
           if (part->is(Part::ADDED) &&
              !(position->payload->y >= bounds.min &&
               position->payload->y <= bounds.max)) {
@@ -277,6 +283,8 @@ void Cursor::traverse_inner(Part* act_part, std::vector<Part*>& all_parts, Bound
           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;
+              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);
                 if (!link_seq.empty()) {

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

@@ -9,6 +9,7 @@
 
 #pragma once
 #include <vector>
+#include <unordered_set>
 #include "Part.h"
 
 class Part;
@@ -19,9 +20,9 @@ class EndPoint {
 
   void set_point(Point* p) { point_ = p; }
   Point* get_point() const { return point_; }
-  std::vector<Queueable<Point>*>& queues() { return queues_; }
+  std::unordered_set<Queueable<Point>*>& queues() { return queues_; }
   bool queues_include(Queueable<Point>* q) const;
  private:
   Point* point_;
-  std::vector<Queueable<Point>*> queues_;
+  std::unordered_set<Queueable<Point>*> queues_;
 };

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

@@ -41,6 +41,7 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
     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");
       CpuTimer t;
       t.start();
       auto* finder = new ClippedPolygonFinder(

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

@@ -10,6 +10,8 @@
 #include "Part.h"
 #include <iostream>
 #include <vector>
+#include <string>
+#include <sstream>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Cluster.h"
@@ -62,7 +64,7 @@ void Part::touch()
 bool Part::intersect_part(Part* other_part)
 { bool intersect = false;
   other_part->each([&](QNode<Point>* pos) -> bool {
-    Position *position = dynamic_cast<Position*>(pos);
+    Position *position = static_cast<Position*>(pos);
     if (position->end_point()->queues_include(this))
     { intersect = true;
       return(false);
@@ -76,7 +78,7 @@ std::vector<EndPoint*> Part::to_endpoints() {
   std::vector<EndPoint*> out;
   QNode<Point>* current = head;
   while (current) {
-    out.push_back((dynamic_cast<Position*>(current))->end_point());
+    out.push_back((static_cast<Position*>(current))->end_point());
     current = current->next;
   }
   return out;
@@ -94,3 +96,34 @@ std::vector<EndPoint*> Part::remove_adjacent_pairs(const std::vector<EndPoint*>&
   }
   return result;
 }
+
+void Part::orient()
+{ if (this->size <= 1) {
+    this->versus_ = 0;
+  } else {
+    this->versus_ = (this->tail->payload->y - this->head->payload->y) > 0 ? 1 : -1;
+  }
+}
+
+std::string Part::inspect() {
+  size_t part_index = 0;
+  auto it = std::find(this->polyline()->parts().begin(), this->polyline()->parts().end(), this);
+  if (it != this->polyline()->parts().end()) {
+    part_index = std::distance(this->polyline()->parts().begin(), it);
+  }
+  std::stringstream ss;
+  ss << "part " << part_index
+  << " (versus=" << this->versus_
+  << " inv=" << this->inverts
+  << " 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->each([&](QNode<Point>* pos) -> bool {
+    ss << pos->payload->toString();
+    return true;
+  });
+  ss << ")";
+  return ss.str();
+}

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

@@ -32,6 +32,7 @@ class Part : public Queueable<Point> {
   bool inverts = false;
   bool trasmuted = false;
   bool delayed = false;
+  bool dead_end = false;
   Part* next = nullptr;
   Part* prev = nullptr;
   Part* circular_next = nullptr;
@@ -39,17 +40,20 @@ class Part : public Queueable<Point> {
   Polyline* polyline() { return polyline_; }
   Position* next_position(Position* force_position);
   void add_position(Point* point);
-  int passes = 0;
   Types type;
   bool innerable();
   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; }
   std::vector<EndPoint*> to_endpoints();
   static std::vector<EndPoint*> remove_adjacent_pairs(const std::vector<EndPoint*>& input);
+  void orient();
+  std::string inspect();
 
  private:
+  int versus_ = 0;
   bool touched_ = false;
   Polyline* polyline_;
 };

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

@@ -31,6 +31,8 @@ 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();
 }
 
 void Partitionable::insert_after(Part* part, Part* new_part) {
@@ -46,7 +48,7 @@ void Partitionable::insert_after(Part* part, Part* new_part) {
 
 void Partitionable::partition()
 { this->parts_.clear();
-  Polyline *polyline = dynamic_cast<Polyline*>(this);
+  Polyline *polyline = static_cast<Polyline*>(this);
   PartPool& pool = polyline->tile->cluster->parts_pool;
   Part *current_part = nullptr;
   int n = 0;
@@ -77,10 +79,10 @@ void Partitionable::partition()
   this->trasmute_parts();
 }
 
-Part* Partitionable::find_first_part_by_position(Position* position) {
+Part* Partitionable::find_first_part_by_position(Position* position, int versus) {
   for (Part* part : this->parts_)
   { if ( part->is(Part::SEAM) &&
-      part->passes == 0 &&
+      part->versus() == -(versus) &&
       position->end_point()->queues_include(part)) return(part);
   }
   return(nullptr);
@@ -157,7 +159,7 @@ std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>>
   }
 
   std::vector<Part*> all_parts;
-  Polyline* polyline = dynamic_cast<Polyline*>(this);
+  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());
@@ -194,7 +196,6 @@ std::optional<SewReturnData> Partitionable::sew(std::vector<std::pair<int, int>>
   return std::make_pair(left, right);
 }
 
-
 void Partitionable::trasmute_parts()
 { std::vector<Part*> insides;
   for (Part* p : parts_) {
@@ -205,16 +206,16 @@ void Partitionable::trasmute_parts()
   for (Part* inside : insides)
   { for (Part* inside_compare : insides) {
       if (inside == inside_compare || !inside_compare->is(Part::SEAM) ) continue;
-      bool all_match = true;
+      int count = 0;
       inside->each([&](QNode<Point>* pos) -> bool {
-        Position *position = dynamic_cast<Position*>(pos);
+        Position *position = static_cast<Position*>(pos);
         if (position->end_point()->queues_include(inside_compare))
-        { return true;
+        { count++;
+          return true;
         }
-        all_match = false;
         return false;
       });
-      if (all_match) {
+      if (count == inside->size && count < inside_compare->size) {
         inside->type = Part::EXCLUSIVE;
         inside->trasmuted = true;
         break;
@@ -222,4 +223,3 @@ void Partitionable::trasmute_parts()
     }
   }
 }
-

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

@@ -20,8 +20,9 @@ class Partitionable {
   explicit Partitionable() {}
   virtual ~Partitionable() = default;
   void partition();
-  Part* find_first_part_by_position(Position* position);
+  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:
   std::vector<Part*> parts_;

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

@@ -9,7 +9,9 @@
 
 #include <vector>
 #include <limits>
+#include <string>
 #include <unordered_set>
+#include <sstream>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Shape.h"
@@ -76,7 +78,7 @@ std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) c
       auto& part = parts_[i];
       if (!part->is(Part::SEAM) && part->trasmuted) continue;
       part->each([&](QNode<Point>* pos) -> bool {
-        Position *position = dynamic_cast<Position*>(pos);
+        Position *position = static_cast<Position*>(pos);
         if (position->end_point() != nullptr)
         { this->tracked_endpoints[position->end_point()] = i;
         }
@@ -92,7 +94,7 @@ std::vector<std::pair<int, int>> Polyline::intersection(const Polyline* other) c
       continue;
     }
     other_part->each([&](QNode<Point>* pos) -> bool {
-      Position *position = dynamic_cast<Position*>(pos);
+      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;
@@ -114,3 +116,15 @@ void Polyline::clear() {
 bool Polyline::is_empty() {
   return raw_.empty();
 }
+
+std::string Polyline::info() {
+  Shape* shape = this->shape;
+  size_t part_index = 0;
+  auto it = std::find(this->tile->shapes().begin(), this->tile->shapes().end(), shape);
+  if (it != this->tile->shapes().end()) {
+    part_index = std::distance(this->tile->shapes().begin(), it);
+  }
+  std::stringstream ss;
+  ss << "b" << this->tile->name() << " S" << part_index;
+  return ss.str();
+}

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

@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 #include <unordered_map>
+#include <string>
 #include "Partitionable.h"
 #include "../RectBounds.h"
 
@@ -47,6 +48,7 @@ class Polyline : public Partitionable {
   bool vert_intersect(Polyline& other);
   void reset_tracked_endpoints();
   bool mixed_tile_origin = false;
+  std::string info();
 
  private:
   std::vector<Point*> raw_;

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

@@ -30,12 +30,9 @@ Position::Position(EndPoint* end_point)
 }
 
 void Position::before_rem(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) {
-    auto& queues = this->end_point_->queues();
-    queues.erase(std::remove(queues.begin(), queues.end(), q), queues.end());
-  }
+  if (this->end_point_ != nullptr) this->end_point_->queues().erase(q);
 }
 
 void Position::after_add(Queueable<Point>* q)  {
-  if (this->end_point_ != nullptr) this->end_point_->queues().push_back(q);
+  if (this->end_point_ != nullptr) this->end_point_->queues().insert(q);
 }

data/ext/cpp_polygon_finder/extconf.rb

@@ -1,9 +1,19 @@
 require "mkmf-rice"
 
+has_tcmalloc = find_library("tcmalloc", "malloc")
+
 # rubocop:disable Style/GlobalVars
 
-$CXXFLAGS << " -std=c++17 -pthread -march=native -DNDEBUG -Ofast -flto -g -fno-omit-frame-pointer"
-$CFLAGS << " -std=c99 -pthread -march=native -DNDEBUG -Ofast -flto -g -fno-omit-frame-pointer"
+$CXXFLAGS << " -std=c++17 -pthread -march=native -DNDEBUG -Ofast -flto"
+$CFLAGS << " -std=c11 -pthread -march=native -DNDEBUG -Ofast -flto"
+
+if has_tcmalloc
+  $LDFLAGS << " -Wl,--no-as-needed -ltcmalloc"
+  puts "tcmalloc linked to gem."
+else
+  puts "tcmalloc not found; standard malloc will be used."
+end
+
 $LDFLAGS << " -lz -lstdc++ -flto -pthread"
 
 $objs = [

data/lib/contrek/bitmaps/painting.rb

@@ -28,6 +28,7 @@ module Contrek
           png_image.draw_line(poly[:outer][0][:x], poly[:outer][0][:y], poly[:outer][-1][:x], poly[:outer][-1][:y], color)
           color = ChunkyPNG::Color("green @ 1.0")
           poly[:inner].each do |sequence|
+            next if sequence.empty?
             sequence.each_cons(2) do |coords|
               png_image.draw_line(coords[0][:x], coords[0][:y], coords[1][:x], coords[1][:y], color)
             end