contrek 1.1.2 → 1.1.3

data/ext/cpp_polygon_finder/PolygonFinder/examples/example.cpp

@@ -1,10 +1,11 @@
-//============================================================================
-// Name        : example.cpp
-// Author      : Emanuele Cesaroni
-// Version     :
-// Copyright   : 2025 Emanuele Cesaroni
-// Description :
-//============================================================================
+/*
+ * example.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 <iostream>
 #include "ContrekApi.h"
@@ -29,6 +30,7 @@ int main() {
   cfg.threads = 4;
   cfg.tiles = 4;
   cfg.compress_unique = true;
+  cfg.connectivity_mode = Contrek::Connectivity::OMNIDIRECTIONAL;
 
   CpuTimer cpu_timer;
   cpu_timer.start();

data/ext/cpp_polygon_finder/PolygonFinder/src/ContrekApi.h

@@ -26,6 +26,11 @@ enum class MatchMode {
   EXACT_COLOR   // Tracks border of what exactly matchs target color
 };
 
+enum class Connectivity {
+  ORTHOGONAL = 4,        // up, down, left, right 4 directions
+  OMNIDIRECTIONAL = 8    // 8 directions
+};
+
 struct Config {
   int threads = 4;
   int tiles = 2;
@@ -35,6 +40,7 @@ struct Config {
   bool treemap = false;
   int32_t target_color = -1;
   MatchMode mode = MatchMode::NOT_COLOR;
+  Connectivity connectivity_mode = Connectivity::ORTHOGONAL;
 };
 
 inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const Config& cfg = Config()) {
@@ -64,6 +70,9 @@ inline std::unique_ptr<ProcessResult> trace(const std::string& image_path, const
       if (m.flag) internal_args.emplace_back(m.arg);
   }
   internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
+  if(cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
+    internal_args.push_back("--connectivity=" + std::to_string(8));
+  }
 
   Finder finder(cfg.threads, bitmap.get(), matcher.get(), &internal_args);
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/FastPngBitmap.cpp

@@ -7,6 +7,7 @@
  * See the LICENSE file in this directory for the full license text.
  */
 
+#include <sys/mman.h>
 #include <iostream>
 #include <vector>
 #include <fstream>
@@ -38,6 +39,7 @@ FastPngBitmap::FastPngBitmap(std::string filename) : Bitmap("", 0) {
         size_t out_size;
         spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
         this->image.resize(out_size);
+        madvise(this->image.data(), out_size, MADV_HUGEPAGE);
         int error = spng_decode_image(ctx, image.data(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
         spng_ctx_free(ctx);
         this->png_error = error;

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

@@ -22,7 +22,7 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
   char** argv = &argv0[0];
   int argc = argv0.size() -1;
 
-  enum  optionIndex { COMPRESS_UNIQ, VERSUS, COMPRESS_VISVALINGAM, COMPRESS_LINEAR, NUMBER_OF_TILES, COMPRESS_VISVALINGAM_TOLERANCE, TREEMAP, NAMED_SEQUENCES, BOUNDS};
+  enum  optionIndex { COMPRESS_UNIQ, VERSUS, COMPRESS_VISVALINGAM, COMPRESS_LINEAR, NUMBER_OF_TILES, COMPRESS_VISVALINGAM_TOLERANCE, TREEMAP, NAMED_SEQUENCES, BOUNDS, CONNECTIVITY};
   const option::Descriptor usage[] = {
      //  {UNKNOWN, 0,"" , ""    ,option::Arg::None, 0},
      {COMPRESS_VISVALINGAM, 0, "" , "compress_visvalingam", option::Arg::None, 0},
@@ -34,6 +34,7 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
      {NAMED_SEQUENCES, 0, "", "named_sequences", option::Arg::None, 0},
      {BOUNDS, 0, "", "bounds", option::Arg::None, 0},
      {VERSUS, 0, "v", "versus", option::Arg::Optional, 0},
+     {CONNECTIVITY, 0, "c", "connectivity", option::Arg::Optional, 0},
      {0, 0, 0, 0, 0, 0}
   };
 
@@ -58,9 +59,19 @@ void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string>
   if (ioptions[NUMBER_OF_TILES].count() > 0)
   { try {
       options.number_of_tiles = std::stoi(ioptions[NUMBER_OF_TILES].arg);
+      if (options.number_of_tiles <= 0) options.number_of_tiles = 1;
     }
     catch (const std::invalid_argument&) {
-      std::cerr << "Errore: --number_of_tiles richiede un numero (non una lettera)\n";
+      std::cerr << "Errore: --number_of_tiles requires a number\n";
+    }
+  }
+  // CONNECTIVITY
+  if (ioptions[CONNECTIVITY].count() > 0)
+  { try {
+      if (std::stoi(ioptions[CONNECTIVITY].arg) == 8) options.connectivity_offset = 1;
+    }
+    catch (const std::invalid_argument&) {
+      std::cerr << "Errore: --connectivity requires a number\n";
     }
   }
   // TREEMAP

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

@@ -10,109 +10,101 @@
 #include "List.h"
 #include <iostream>
 
-class Listable;
+List::List(int id) : start(nullptr), end(nullptr), isize(0), idd(id) {}
 
-List::List(int id) {
-  this->start = nullptr;
-  this->end = nullptr;
-  this->isize = 0;
-  this->idd = id;
-}
-
-Listable *List::first() {
-  return(this->start);
-}
-Listable *List::last() {
-  return(this->end);
-}
+Listable *List::first() { return this->start; }
+Listable *List::last() { return this->end; }
+int List::get_id() { return this->idd; }
+int List::size() { return this->isize; }
 
 bool List::contains(Listable *entry) {
-  return(entry->data_pointer[this->idd].inside);
-}
-int List::get_id() {
-  return(this->idd);
+  return entry->data_pointer[this->idd].inside;
 }
 
-void List::grab(List *source_list) {
-  if (source_list->size() == 0) return;
-  int source_list_idd = source_list->get_id();
-  Listable *source_list_start_entry = source_list->first();
-
-  Listable *act = source_list->last();
-  while (true)
-  { if ((act = act->data_pointer[source_list_idd].prev) == nullptr) break;
-  }
-  Listable *source_entry = source_list->first();
-  while (true)
-  { source_entry->data_pointer[this->idd] = source_entry->data_pointer[source_list_idd];
-    Listable *next_entry = source_entry->data_pointer[source_list_idd].next;
-    source_entry->data_pointer[source_list_idd].inside = false;
-    source_entry->data_pointer[source_list_idd].next = nullptr;
-    source_entry->data_pointer[source_list_idd].prev = nullptr;
-    if (next_entry == nullptr) break;
-    source_entry = next_entry;
-  }
-  source_list_start_entry->data_pointer[this->idd].prev = this->end;
-  if (this->end != nullptr) this->end->data_pointer[this->idd].next = source_list_start_entry;
-  this->end = source_list->last();
-  if (this->start == nullptr) this->start = source_list->first();
-  this->isize += source_list->size();
-  source_list->reset();
-}
-
-void List::reset()  {
+void List::reset() {
   this->end = nullptr;
   this->start = nullptr;
   this->isize = 0;
 }
 
-Listable *List::shift() {
-  if (this->isize == 0) return(nullptr);
-  Listable *retme = this->start;
-  Listable *next_of_retme = retme->data_pointer[this->idd].next;
-  this->start = next_of_retme;
-  if (retme == this->end) this->end = nullptr;
-  if (next_of_retme != nullptr) next_of_retme->data_pointer[this->idd].prev = nullptr;
-  this->isize--;
-  retme->data_pointer[this->idd].next = nullptr;
-  retme->data_pointer[this->idd].prev = nullptr;
-  retme->data_pointer[this->idd].inside = false;
-  return (retme);
-}
-
 void List::push_back(Listable *entry) {
-  if (entry->data_pointer[this->idd].inside) return;
-  if (this->isize > 0)
-  { this->end->data_pointer[this->idd].next = entry;
-    entry->data_pointer[this->idd].prev = this->end;
+  auto& meta = entry->data_pointer[this->idd];
+  if (meta.inside) return;
+
+  if (this->isize > 0) {
+    this->end->data_pointer[this->idd].next = entry;
+    meta.prev = this->end;
   } else {
     this->start = entry;
+    meta.prev = nullptr;
   }
+
+  meta.next = nullptr;
   this->end = entry;
-  entry->data_pointer[this->idd].inside = true;
+  meta.inside = true;
   this->isize++;
 }
-int List::size() {
-  return(this->isize);
-}
 
 void List::remove(Listable *entry) {
-  if (this->isize == 0) return;
-  if (entry->data_pointer[this->idd].inside == false) return;
-  Listable *next_of_entry = entry->data_pointer[this->idd].next;
-  Listable *prev_of_entry = entry->data_pointer[this->idd].prev;
+  auto& meta = entry->data_pointer[this->idd];
+  if (this->isize == 0 || !meta.inside) return;
+
+  Listable *nxt = meta.next;
+  Listable *prv = meta.prev;
+
+  if (entry == this->start) this->start = nxt;
+  if (entry == this->end)   this->end = prv;
+
+  if (nxt) nxt->data_pointer[this->idd].prev = prv;
+  if (prv) prv->data_pointer[this->idd].next = nxt;
+
+  meta.next = nullptr;
+  meta.prev = nullptr;
+  meta.inside = false;
+  this->isize--;
+}
+
+Listable *List::shift() {
+  if (this->isize == 0) return nullptr;
+  Listable *retme = this->start;
+  auto& meta = retme->data_pointer[this->idd];
+
+  this->start = meta.next;
+  if (retme == this->end) this->end = nullptr;
+  if (this->start) this->start->data_pointer[this->idd].prev = nullptr;
+
+  this->isize--;
+  meta.next = nullptr;
+  meta.prev = nullptr;
+  meta.inside = false;
+  return retme;
+}
+
+void List::grab(List *source_list) {
+  if (source_list->isize == 0) return;
 
-  if (entry == this->start)
-  { this->start = next_of_entry;
+  int src_idd = source_list->idd;
+  Listable *current = source_list->start;
+
+  while (current) {
+    auto& src_meta = current->data_pointer[src_idd];
+    auto& dst_meta = current->data_pointer[this->idd];
+    dst_meta = src_meta;
+    src_meta.inside = false;
+    src_meta.next = nullptr;
+    src_meta.prev = nullptr;
+    current = dst_meta.next;
   }
-  if (entry == this->end)
-  { this->end = prev_of_entry;
+
+  if (this->isize > 0) {
+    this->end->data_pointer[this->idd].next = source_list->start;
+    source_list->start->data_pointer[this->idd].prev = this->end;
+    this->end = source_list->end;
+  } else {
+    this->start = source_list->start;
+    this->end = source_list->end;
   }
 
-  if (next_of_entry != nullptr)  next_of_entry->data_pointer[this->idd].prev = prev_of_entry;
-  if (prev_of_entry != nullptr)  prev_of_entry->data_pointer[this->idd].next = next_of_entry;
-  entry->data_pointer[this->idd].next = nullptr;
-  entry->data_pointer[this->idd].prev = nullptr;
-  this->isize--;
-  entry->data_pointer[this->idd].inside = false;
+  this->isize += source_list->isize;
+  source_list->reset();
 }

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

@@ -8,13 +8,21 @@
  */
 
 #pragma once
+#include <array>
+
+// Forward declaration
+class Listable;
+
+// Definizione completa di Link (necessaria per std::array)
+struct Link {
+  Listable* next = nullptr;
+  Listable* prev = nullptr;
+  bool inside = false;
+};
 
-#include <vector>
-#include "Lists.h"
-struct Link;
 class Listable {
  public:
-  std::vector<Link> data_pointer;
+  std::array<Link, 3> data_pointer;
 };
 
 class List {

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

@@ -25,13 +25,3 @@ List *Lists::add_list() {
   lists.push_back(list);
   return(list);
 }
-
-std::vector<Link> Lists::get_data_pointer() {
-  std::vector<Link> data(this->lists.size());
-  for (auto& dt : data) {
-    dt.inside = false;
-    dt.next = nullptr;
-    dt.prev = nullptr;
-  }
-  return data;
-}

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

@@ -11,19 +11,12 @@
 #include <list>
 #include <vector>
 #include "List.h"
-class List;
-class Listable;
-struct Link {
-  Listable *next, *prev;
-  bool inside;
-};
 
 class Lists {
  public:
   Lists() {}
   virtual ~Lists();
   List *add_list();
-  std::vector<Link> get_data_pointer();
  private:
   std::list<List*> lists;
 };

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

@@ -11,11 +11,15 @@
 #include <string>
 #include <iostream>
 #include <algorithm>
+#include <limits>
 #include <vector>
 #include <list>
 #include "Node.h"
+#include "NodeCluster.h"
 
-Node::Node(int min_x, int max_x, int y, char name) {
+Node::Node(int min_x, int max_x, int y, char name)
+: start_point(min_x, y),
+  end_point(max_x, y) {
   this->name = name;
   this->min_x = min_x;
   this->max_x = max_x;
@@ -32,64 +36,59 @@ Node::Node(int min_x, int max_x, int y, char name) {
 bool Node::get_trackmax() {
   return((this->track & OMAX) != 0);
 }
+
 bool Node::track_complete() {
   return((this->track & OCOMPLETE) == OCOMPLETE);
 }
+
 bool Node::track_uncomplete() {
   return((this->track & OCOMPLETE) != OCOMPLETE);
 }
 
-bool Node::tangs_with(Node *node) {
-  return(this->min_x <= node->max_x && node->min_x <= this->max_x);
-}
-
-void Node::add_intersection(Node *other_node) {
-  if (other_node->y < this->y) tangs[T_UP].push_back(other_node);
-  else                         tangs[T_DOWN].push_back(other_node);
+void Node::add_intersection(Node& other_node, int other_node_index) {
+  if (other_node.y < this->y) {
+    upper_start = std::min(upper_start, other_node_index);
+    upper_end = std::max(upper_end, other_node_index);
+  } else {
+    lower_start = std::min(lower_start, other_node_index);
+    lower_end = std::max(lower_end, other_node_index);
+  }
 }
 
-void Node::precalc_tangs_sequences(std::vector<Point>& points) {
+void Node::precalc_tangs_sequences(NodeCluster& cluster) {
   this->tangs_sequence.clear();
-  this->tangs_sequence.reserve(tangs[T_UP].size() + tangs[T_DOWN].size());
-  std::vector<Node*> up_copy = tangs[T_UP];
-  std::vector<Node*> down_copy = tangs[T_DOWN];
 
-  // --- CLOCKWISE (UP) ---
-  std::sort(up_copy.begin(), up_copy.end(), sort_min_x);
-  if (!up_copy.empty()) {
-    this->up_indexer = -up_copy.front()->abs_x_index;
+  int lower_size = this->lower_end >= 0 ? (this->lower_end - this->lower_start + 1) : 0;
+  int upper_size = this->upper_end >= 0 ? (this->upper_end - this->upper_start + 1) : 0;
+  this->tangs_sequence.reserve(lower_size + upper_size);
+
+  if (this->upper_end >= 0) {
+    this->up_indexer = -cluster.vert_nodes[y + T_UP][this->upper_start].abs_x_index;
   }
-  for (Node* t_node : up_copy) {
-    tangs_sequence.push_back(NodeDescriptor{
-      t_node,
-      Tangent{ &points.emplace_back(t_node->max_x, t_node->y), OMAX},
-      Tangent{ &points.emplace_back(t_node->min_x, t_node->y), OMIN}
+  // --- CLOCKWISE (UP) ---
+  for (int upper_pos = this->upper_start; upper_pos <= this->upper_end; upper_pos++) {
+    Node& t_node = cluster.vert_nodes[y + T_UP][upper_pos];
+    tangs_sequence.emplace_back(NodeDescriptor{
+      &t_node,
+      Tangent{ &t_node.end_point, OMAX},
+      Tangent{ &t_node.start_point, OMIN}
     });
   }
-
-  // --- COUNTER-CLOCKWISE (DOWN) ---
-  std::sort(down_copy.begin(), down_copy.end(), sort_max_x);
-  std::reverse(down_copy.begin(), down_copy.end());
-  if (!down_copy.empty()) {
-    this->down_indexer = (down_copy.back()->abs_x_index +
-                         tangs[T_UP].size() + tangs[T_DOWN].size() - 1);
+  if (this->lower_end >= 0) {
+    this->down_indexer = (cluster.vert_nodes[y + T_DOWN][this->lower_start].abs_x_index + lower_size + upper_size - 1);
   }
-  for (Node* t_node : down_copy) {
-    tangs_sequence.push_back(NodeDescriptor{
-      t_node,
-      Tangent{&points.emplace_back(t_node->min_x, t_node->y), OMIN},
-      Tangent{&points.emplace_back(t_node->max_x, t_node->y), OMAX}
+  // --- COUNTER-CLOCKWISE (DOWN) ---
+  for (int lower_pos = this->lower_end; lower_pos >= this->lower_start; lower_pos--) {
+    Node& t_node = cluster.vert_nodes[y + T_DOWN][lower_pos];
+    tangs_sequence.emplace_back(NodeDescriptor{
+      &t_node,
+      Tangent{&t_node.start_point, OMIN},
+      Tangent{&t_node.end_point, OMAX}
     });
   }
   this->tangs_count = this->tangs_sequence.size();
 }
 
-bool Node::sort_min_x(Node *a, Node *b) {
-  return(a->min_x <= b->min_x);
-}
-bool Node::sort_max_x(Node *a, Node *b) {
-  return(a->max_x <= b->max_x);
-}
 Node* Node::my_next_inner(Node *last, int versus) {
   unsigned int last_node_index;
   if (last->y < this->y)       last_node_index = last->abs_x_index + this->up_indexer;
@@ -98,6 +97,7 @@ Node* Node::my_next_inner(Node *last, int versus) {
   else          last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
   return((this->tangs_sequence)[last_node_index].node);
 }
+
 Node* Node::my_next_outer(Node *last, int versus) {
   unsigned int last_node_index;
   if (last->y < this->y) last_node_index = last->abs_x_index + this->up_indexer;

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

@@ -11,6 +11,8 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <limits>
+#include <algorithm>
 #include <map>
 #include "List.h"
 
@@ -32,10 +34,9 @@ struct Tangent {
 };
 struct NodeDescriptor;
 
-
 class Node : public  Listable {
  public:
-  static const int T_UP = 0;
+  static const int T_UP = -1;
   static const int T_DOWN = 1;
   static const int O = 0;
   static const int A = 1;
@@ -50,7 +51,6 @@ class Node : public  Listable {
   static const int OUTER = 0;
   static const int INNER = 1;
 
-  std::vector<Node*> tangs[2];
   int y;
   int abs_x_index;
   int up_indexer, down_indexer;
@@ -58,8 +58,12 @@ class Node : public  Listable {
   char name;
   int track;
   int outer_index, inner_index;
-  bool tangs_with(Node *node);
-  void add_intersection(Node *other_node);
+  int upper_start = std::numeric_limits<int>::max();
+  int upper_end   = -1;
+  int lower_start = std::numeric_limits<int>::max();
+  int lower_end   = -1;
+  Point start_point, end_point;
+  void add_intersection(Node& other_node, int other_node_index);
   std::vector<NodeDescriptor> tangs_sequence;
   Point* coords_entering_to(Node *enter_to, int mode, int tracking);
   Node* my_next_outer(Node *last, int versus);
@@ -68,14 +72,10 @@ class Node : public  Listable {
   bool track_complete();
   bool get_trackmax();
 
- private:
-  static bool sort_min_x(Node *a, Node *b);
-  static bool sort_max_x(Node *a, Node *b);
-
  public:
   int min_x, max_x;
   Node(int min_x, int max_x, int y, char name);
-  void precalc_tangs_sequences(std::vector<Point>& points);
+  void precalc_tangs_sequences(NodeCluster& cluster);
   bool processed = false;
 };
 

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) {
+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, 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;
       }
     }
@@ -159,13 +155,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)
@@ -309,21 +312,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()));
-}