contrek 1.1.2 → 1.1.3

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

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"
@@ -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) {
@@ -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);
@@ -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);
         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

@@ -10,6 +10,7 @@
 #include <vector>
 #include <limits>
 #include <unordered_set>
+#include <sstream>
 #include "Polyline.h"
 #include "Tile.h"
 #include "Shape.h"
@@ -114,3 +115,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/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

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

@@ -106,8 +106,8 @@ module Contrek
 
       # rubocop:disable Lint/NonLocalExitFromIterator
       def traverse_outer(act_part, all_parts, shapes_sequence, outer_joined_polyline)
-        all_parts << act_part if all_parts.last != act_part
-
+        last_part = all_parts.last
+        all_parts << act_part if last_part != act_part
         if act_part.is?(Part::EXCLUSIVE)
           return if act_part.size == 0
           while (position = act_part.next_position)
@@ -117,14 +117,14 @@ module Contrek
             outer_joined_polyline.add(position)
           end
         else
+          return if act_part.dead_end && all_parts.size > 1 && last_part.is?(Part::SEAM) && last_part.polyline == act_part.polyline
           while (new_position = act_part.iterator)
             return if outer_joined_polyline.size > 1 &&
               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))
+              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
@@ -132,12 +132,12 @@ module Contrek
                   end
                   shapes_sequence.add(part.polyline.shape)
                   part.next_position(new_position)
+                  part.dead_end = true
                   traverse_outer(part, all_parts, shapes_sequence, outer_joined_polyline)
                   return
                 end
               end
             end
-            act_part.passes += 1
             act_part.next_position
           end
         end

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

@@ -29,6 +29,7 @@ module Contrek
           @clusters = []
           @maximum_width = bitmap.w
           @number_of_tiles = options[:number_of_tiles] || (raise "number_of_tiles params is needed!")
+          @number_of_tiles = 1 if @number_of_tiles <= 0
 
           cw = @maximum_width.to_f / @number_of_tiles
           raise "One pixel tile width minimum!" if cw < 1.0
@@ -45,7 +46,7 @@ module Contrek
               finder = ClippedPolygonFinder.new(
                 bitmap: bitmap,
                 matcher: matcher,
-                options: {versus: current_versus, bounds: true},
+                options: {versus: current_versus, bounds: true, connectivity: @options[:connectivity]}.compact,
                 start_x: payload[:tile_start_x],
                 end_x: payload[:tile_end_x]
               )

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

@@ -8,18 +8,19 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :index, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :passes, :inverts, :trasmuted, :delayed
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :delayed, :versus
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
         @next = nil
         @circular_next = nil
         @prev = nil
-        @passes = 0
+        @dead_end = false
         @touched = false
         @inverts = false
         @trasmuted = false
         @delayed = false
+        @versus = 0
       end
 
       def is?(type)
@@ -60,7 +61,7 @@ module Contrek
       end
 
       def inspect
-        "part #{polyline.parts.index(self)} (inv=#{@inverts} trm=#{@trasmuted} touched=#{@touched} passes=#{@passes}, #{size}x) of #{polyline.info} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
+        "part #{polyline.parts.index(self)} (versus=#{@versus} inv=#{@inverts} trm=#{@trasmuted} touched=#{@touched} dead_end =#{@dead_end}, #{size}x) of #{polyline.info} (#{name}) (#{to_a.map { |e| "[#{e[:x]},#{e[:y]}]" }.join})"
       end
 
       def innerable?
@@ -78,6 +79,14 @@ module Contrek
         map(&:end_point)
       end
 
+      def orient!
+        @versus = if size <= 1
+          0
+        else
+          (tail.payload[:y] - head.payload[:y]).positive? ? 1 : -1
+        end
+      end
+
       def self.remove_adjacent_pairs(array = nil)
         n = array.size
         (0...(n - 1)).each do |i|

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

@@ -14,6 +14,8 @@ module Contrek
         last.next = last.circular_next = new_part if last
         new_part.circular_next = @parts.first
         new_part.prev = last
+
+        new_part.orient! if new_part.is?(Part::SEAM)
       end
 
       def insert_after(part, new_part)
@@ -25,10 +27,10 @@ module Contrek
         part.next = part.circular_next = new_part
       end
 
-      def find_first_part_by_position(position)
+      def find_first_part_by_position(position, versus)
         @parts.find do |part|
           part.is?(Part::SEAM) &&
-            part.passes == 0 &&
+            part.versus == -versus &&
             position.end_point.queues.include?(part)
         end
       end
@@ -144,10 +146,10 @@ module Contrek
 
             count = 0
             inside.each do |position|
-              break unless position.end_point.queues.include?(inside_compare)
-              count += 1
+              inclusion = position.end_point.queues.include?(inside_compare)
+              count += 1 if inclusion
             end
-            if count == inside.size
+            if count == inside.size && count < inside_compare.size
               inside.type = Part::EXCLUSIVE
               inside.trasmuted = true
               break

data/lib/contrek/finder/node.rb

@@ -3,7 +3,8 @@ module Contrek
     class Node
       include Listable
 
-      attr_reader :min_x, :max_x, :y, :name, :tangs, :tangs_sequence, :tangs_count, :data_pointer
+      attr_reader :min_x, :max_x, :y, :name, :tangs_sequence, :tangs_count, :data_pointer,
+        :upper_start, :upper_end, :lower_start, :lower_end
       attr_accessor :track, :abs_x_index, :outer_index, :inner_index
 
       T_UP = -1
@@ -24,12 +25,11 @@ module Contrek
       OUTER = 0
       INNER = 1
 
-      def initialize(cluster, min_x, max_x, y, name)
+      def initialize(cluster, min_x, max_x, y, name, connectivity_offset = 0)
         @name = name
         @min_x = min_x
         @max_x = max_x
         @y = y
-        @tangs = {T_UP => [], T_DOWN => []}
         @tangs_sequence = nil
         @tangs_count = 0
         @track = 0
@@ -39,11 +39,12 @@ module Contrek
         @down_indexer = 0
         @outer_index = -1
         @inner_index = -1
-        cluster.add_node(self)
-      end
+        @upper_start = Float::INFINITY
+        @upper_end = -1
+        @lower_start = Float::INFINITY
+        @lower_end = -1
 
-      def tangs?(node)
-        @min_x <= node.max_x && node.min_x <= @max_x
+        cluster.add_node(self, connectivity_offset)
       end
 
       def my_next(last, versus, mode)
@@ -62,13 +63,11 @@ module Contrek
           end
 
         when :inner
-
           if versus == :o
             (last_node_index == 0) ? last_node_index = tangs_sequence.size - 1 : last_node_index -= 1
           else
             (last_node_index == tangs_sequence.size - 1) ? last_node_index = 0 : last_node_index += 1
           end
-
         end
         tangs_sequence.at(last_node_index)
       end
@@ -85,10 +84,6 @@ module Contrek
         coords_source[:point]
       end
 
-      def tangs_with_x?(x)
-        x.between?(@min_x, @max_x)
-      end
-
       def track_uncomplete
         (@track & OCOMPLETE) != OCOMPLETE
       end
@@ -97,28 +92,45 @@ module Contrek
         (@track & OCOMPLETE) == OCOMPLETE
       end
 
-      def add_intersection(other_node)
+      def add_intersection(other_node, other_node_index)
         if other_node.y < y
-          @tangs[T_UP] << other_node
+          @upper_start = other_node_index if other_node_index < @upper_start
+          @upper_end = other_node_index if other_node_index > @upper_end
         else
-          @tangs[T_DOWN] << other_node
+          @lower_start = other_node_index if other_node_index < @lower_start
+          @lower_end = other_node_index if other_node_index > @lower_end
         end
       end
 
-      def precalc_tangs_sequences
-        @tangs_sequence = Array.new(tangs[T_UP].size + tangs[T_DOWN].size)
-        tangs = self.tangs[T_UP].sort_by(&:min_x)
-        n = -1
-        @up_indexer = -tangs[0].abs_x_index if tangs.size > 0
-        tangs.each do |t_node|
-          nd = Contrek::Finder::PolygonFinder::NodeDescriptor.new(t_node, {point: {x: t_node.max_x, y: t_node.y}, m: OMAX}, {point: {x: t_node.min_x, y: t_node.y}, m: OMIN})
-          tangs_sequence[n += 1] = nd
+      def precalc_tangs_sequences(cluster:)
+        @tangs_sequence = []
+        @up_indexer = -cluster.vert_nodes[@y + T_UP][@upper_start].abs_x_index if @upper_end >= 0
+        if @upper_end >= 0
+          (@upper_start..@upper_end).each do |upper_pos|
+            t_node = cluster.vert_nodes[@y + T_UP][upper_pos]
+            @tangs_sequence << Contrek::Finder::PolygonFinder::NodeDescriptor.new(
+              t_node,
+              {point: {x: t_node.max_x, y: t_node.y}, m: OMAX},
+              {point: {x: t_node.min_x, y: t_node.y}, m: OMIN}
+            )
+          end
+        end
+
+        if @lower_end >= 0
+          lower_size = (@lower_end >= 0) ? (@lower_end - @lower_start + 1) : 0
+          upper_size = (@upper_end >= 0) ? (@upper_end - @upper_start + 1) : 0
+          @down_indexer = (cluster.vert_nodes[@y + T_DOWN][@lower_start].abs_x_index + lower_size + upper_size - 1)
         end
-        tangs = self.tangs[T_DOWN].sort_by(&:min_x).reverse
-        @down_indexer = (tangs.last.abs_x_index + self.tangs[T_DOWN].size + self.tangs[T_UP].size - 1) if tangs.size > 0
-        tangs.each do |t_node|
-          nd = Contrek::Finder::PolygonFinder::NodeDescriptor.new(t_node, {point: {x: t_node.min_x, y: t_node.y}, m: OMIN}, {point: {x: t_node.max_x, y: t_node.y}, m: OMAX})
-          tangs_sequence[n += 1] = nd
+
+        if @lower_end >= 0
+          @lower_end.downto(@lower_start).each do |lower_pos|
+            t_node = cluster.vert_nodes[@y + T_DOWN][lower_pos]
+            @tangs_sequence << Contrek::Finder::PolygonFinder::NodeDescriptor.new(
+              t_node,
+              {point: {x: t_node.min_x, y: t_node.y}, m: OMIN},
+              {point: {x: t_node.max_x, y: t_node.y}, m: OMAX}
+            )
+          end
         end
         @tangs_count = tangs_sequence.size
       end