contrek 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60fae59ed14c24cedd7dadfdc33dea05188b1131ee6443b59591e5243cb4710b
-  data.tar.gz: b565f7a0e9713a9389329cf1cc44f9c2da36908d75c538af625afdb6e1d9d71a
+  metadata.gz: 22d05e676f5c4a0f22f02ec2e915257bf1f5da224d468cb0e2f46fc397360242
+  data.tar.gz: '0997b63d2839cc3ba613884eff2e3a565d96502e4606db0bb72d2aee228e514d'
 SHA512:
-  metadata.gz: 86ece9b65041fae9aec64173f5e3bb719971852a6327953b78dc6567f94018db544cc8b7e062d57aad3a859f8142982406e1d9301716f2a49eaa8a05a586ddfc
-  data.tar.gz: 87a22df67016a3249a069cec0bee1746ddb92c1103f9a98e0a8e85b2240ae7d4be735123cfa72443432b30a91be333c4d195b384b194f5703a075b4832e07bd6
+  metadata.gz: 57bf5e08937ea8fb4cee39e383a8f760e3a36714643c583408af6d02c7fbb84515af8d3089c753319677b8d5223c7a6a07f505c4356e21cd10570abbec358210
+  data.tar.gz: 0ec4babf59251515b05857a459adfd7365b930feaf58b17ca2215ab4b534abe3ac41ae45e7643270ec8acba4c699fbcd311b12eb3ddab6789e5dd1b7275ad220

data/CHANGELOG.md

@@ -52,4 +52,14 @@ All notable changes to this project will be documented in this file.
 ## [1.1.3] - 2026-02-21
 ### Changed
 - Added support for 8-way pixel connectivity (omnidirectional) in addition to the standard 4-way mode.
-- Optimized C++ and Ruby algorithms for initial spatial pixel tracking to improve performance. 
+- Optimized C++ and Ruby algorithms for initial spatial pixel tracking to improve performance.
+
+## [1.1.4] - 2026-02-28
+### Changed
+- Fixed an infinite loop bug in multithreading during inner sequence joining in Omnidirectional mode.
+- Optimized C++ and Ruby algorithms for initial spatial tangential sequence determination.
+
+## [1.1.5] - 2026-03-08
+### Changed
+- **RawBitmap Integration (Ruby/C++):** Introduced a native buffer class for direct contour extraction, bypassing PNG encoding to significantly reduce latency and memory overhead.
+- **Tiled Polygon Merger:** Added a spatial merger for `Finder` outputs to stitch polygons from discrete sub-areas (requiring only a 1px overlap). This multi-phase workflow supports coordinate translation and eliminates monolithic buffer requirements, optimizing the peak memory footprint.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contrek (1.1.3)
+    contrek (1.1.5)
       chunky_png (~> 1.4)
       concurrent-ruby (~> 1.3.5)
       rice (= 4.5.0)

data/README.md

@@ -1,10 +1,10 @@
 # Contrek
-Contrek is a Ruby gem powered by a <u>standalone C++17 core library</u> for fast contour tracing and edge detection in PNG images. It employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
+Contrek is a Ruby gem powered by a <u>standalone C++17 core library</u> for fast contour tracing and edge detection in PNG images and raw memory streams. It employs a **topological approach** to extract polygonal contours, representing shapes as a connected graph of shared endpoints. This ensures perfect adjacency and structural integrity for shape analysis and raster-to-vector workflows, such as PNG to SVG conversion, managed via libspng (0.7.4) with multithreading support.
 
 
 ## About Contrek library
 
-Contrek (**con**tour **trek**king) simply scans your png bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.
+Contrek (**con**tour **trek**king) simply scans your png/raw bitmap and returns shape contour as close polygonal lines, both for the external and internal sides. It can compute the nesting level of the polygons found with a tree structure. It supports various levels and modes of compression and approximation of the found coordinates. It is capable of multithreaded processing, splitting the image into vertical strips and recombining the coordinates in pairs.
 
 In the following image all the non-white pixels have been examined and the result is the red polygon for the outer contour and the green one for the inner one
 ![alt text](contrek.png "Contour tracing")
@@ -86,6 +86,24 @@ You can also read base64 png images
 png_bitmap = CPPRemotePngBitMap.new("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+P+/HgAFhAJ/wlseKgAAAABJRU5ErkJggg==")
 ```
 
+You can process from a raw stream
+```ruby
+  raw_bitmap = CPPRawBitMap.new
+  # set 20 as width, 30 as height, 4 as bytes per pixel and clears the content (true)
+  raw_bitmap.define(20,30,4,true)
+  # draws a polygon
+  4.upto(5) do |y|
+    5.upto(8) do |x|
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0, 0);
+    end
+  end
+  not_matcher = CPPRGBNotMatcher.new(raw_bitmap.rgb_value_at(0, 0))
+  result = CPPPolygonFinder.new(raw_bitmap, not_matcher, nil,{compress: {uniq: true, linear: true}}).process_info
+  puts result.points.inspect
+  =>
+  [{:outer=>[{:x=>5, :y=>4}, {:x=>5, :y=>5}, {:x=>8, :y=>5}, {:x=>8, :y=>4}], :inner=>[]}]
+```
+
 Multithreaded contour processing is supported. However, on Ruby MRI (the standard Ruby implementation, at least up to 3.x), the Global Interpreter Lock (GIL) prevents more than one thread from executing Ruby code simultaneously. As a consequence, execution remains effectively serialized even on multicore systems, unless the gem is used under JRuby or TruffleRuby (not tested).
 
 ```ruby
@@ -112,7 +130,7 @@ Regarding multithreading:
 
 - The treemap option is currently ignored (multithreaded treemap support will be introduced in upcoming revisions).
 
-By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 1.53 secs with image load).
+By not declaring native option CPP Multithreading optimized code is used. In the above example a [105 MP image](spec/files/images/sample_10240x10240.png) is examined by 4 threads working on 4 tiles (total compute time about 1.2 secs with image load).
 
 ```ruby
 result = Contrek.contour!(
@@ -126,11 +144,11 @@ result = Contrek.contour!(
 )
 puts result.metadata[:benchmarks].inspect
 
-{ compress: 13.0815,
-  init: 453.245,
-  inner: 27.0072,
-  outer: 66.9162,
-  total: 466.326
+{ compress: 26.37,
+  init: 354.339,
+  inner: 17.9427,
+  outer: 93.6252,
+  total: 380.709
 }
 
 ```
@@ -288,23 +306,24 @@ This process is applied recursively, merging bands until a single final band rem
 One of the most complex test you can find under the spec folder is named "scans poly 1200x800", scans this [image](spec/files/images/sample_1200x800.png) computing coordinates to draw polygons drawn in this [result](spec/files/stored_samples/sample_1200x800.png).
 On pure ruby implementation kept time
 ```ruby
-{ :scan=>801.494,
-  :build_tangs_sequence=>160.491,
-  :plot=>86.633,
+{ :scan=>775.435,
+  :build_tangs_sequence=>38.916,
+  :plot=>101.876,
   :compress=>0.002,
-  :total=>1048.62}
+  :total=>916.229
+}
 ```
 This the one for the native C++
 ```ruby
-{ scan: 7.1146329999999995,
-  build_tangs_sequence: 3.063812,
-  plot: 4.474851999999999,
-  compress: 0.0031999999999999997
-  total: 14.656496999999998
+{ scan: 5.077878999999999,
+  build_tangs_sequence: 0.697222999999999,
+  plot: 2.00479,
+  compress: 0.00071,
+  total: 7.780602
 }
 ```
 
-About 75x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
+About 130x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro.
 
 ## 🛠 C++ Standalone Library Usage
 

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

@@ -21,7 +21,9 @@ void run_test() {
   // test_suite.test_c();
   // test_suite.test_d();
   // test_suite.test_e();
-  test_suite.test_f();
+  // test_suite.test_f();
+  // test_suite.test_g();
+  // test_suite.test_h();
   std::cout << "compute time =" << cpu_timer.stop() << std::endl;
 }
 

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

@@ -70,7 +70,7 @@ 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) {
+  if (cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
     internal_args.push_back("--connectivity=" + std::to_string(8));
   }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/Tests.cpp

@@ -18,6 +18,7 @@
 #include "polygon/finder/concurrent/ClippedPolygonFinder.h"
 #include "polygon/bitmaps/Bitmap.h"
 #include "polygon/bitmaps/FastPngBitmap.h"
+#include "polygon/bitmaps/RawBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "polygon/matchers/Matcher.h"
 #include "polygon/matchers/RGBMatcher.h"
@@ -25,6 +26,7 @@
 #include "polygon/matchers/ValueNotMatcher.h"
 #include "polygon/finder/optionparser.h"
 #include "polygon/finder/concurrent/Finder.h"
+#include "polygon/finder/concurrent/HorizontalMerger.h"
 #include "polygon/finder/concurrent/Sequence.h"
 #include "polygon/finder/concurrent/Position.h"
 #include "polygon/finder/Polygon.h"
@@ -141,7 +143,7 @@ void Tests::test_d()
   FastPngBitmap png_bitmap("../images/sample_10240x10240.png");
   // FastPngBitmap png_bitmap("images/labyrinth.png");
   std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
-  std::cout << "immagine =" << cpu_timer.stop() << std::endl;
+  std::cout << "image reading time =" << cpu_timer.stop() << std::endl;
 
   int color = png_bitmap.value_at(0, 0);
   std::cout << "color =" << color << std::endl;
@@ -169,7 +171,7 @@ void Tests::test_e()
   Finder pl(2, &png_bitmap, &not_matcher, &arguments);
   ProcessResult *o = pl.process_info();
   o->print_info();
-  std::cout << "polygons =" << o->groups << std::endl;
+  std::cout << "polygons = " << o->groups << std::endl;
   delete o;
 }
 
@@ -184,3 +186,70 @@ void Tests::test_f()
   std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
   std::cout << "load_error=" << bitmap.error() << std::endl;
 }
+
+void Tests::test_g()
+{ RawBitmap raw_bitmap;
+  raw_bitmap.define(50, 50, 4);
+
+  // draw a polygon start_x = 5, start_y = 4, end_x = 8, end_y = 5
+  for (int y : {4, 5}) {
+    for (int x = 5; x <= 8; ++x) {
+      raw_bitmap.draw_pixel(x, y, 1, 0, 0);
+    }
+  }
+
+  int color = raw_bitmap.rgb_value_at(0, 0);
+  std::cout << "color = " << color << std::endl;
+  RGBNotMatcher not_matcher(color);
+
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--number_of_tiles=2"};
+  Finder pl(2, &raw_bitmap, &not_matcher, &arguments);
+  ProcessResult *o = pl.process_info();
+  // o->print_info();
+  // o->print_polygons();
+  std::cout << "polygons = " << o->groups << std::endl;
+  delete o;
+}
+
+void Tests::test_h()
+{ std::string left =
+              "0000000000" \
+              "0000000000" \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "00        " \
+              "0000000000" \
+              "0000000000";
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  ValueNotMatcher matcher(' ');
+  Bitmap b_left(left, 10);
+  PolygonFinder pl_left(&b_left, &matcher, nullptr, &arguments);
+  ProcessResult *left_result = pl_left.process_info();
+
+  std::string right =
+              "0000000000" \
+              "0000000000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "      0000" \
+              "0000000000" \
+              "0000000000";
+  Bitmap b_right(right, 10);
+  PolygonFinder pl_right(&b_right, &matcher, nullptr, &arguments);
+  ProcessResult *right_result = pl_right.process_info();
+
+  std::vector<std::string> merger_arguments = {};
+  HorizontalMerger hmerger(1, &arguments);
+  hmerger.add_tile(*left_result);
+  hmerger.add_tile(*right_result);
+  ProcessResult *merged_result = hmerger.process_info();
+  merged_result->print_polygons();
+
+  delete merged_result;
+  delete left_result;
+  delete right_result;
+}

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

@@ -17,4 +17,6 @@ class Tests {
   virtual void test_d();
   virtual void test_e();
   virtual void test_f();
+  virtual void test_g();
+  virtual void test_h();
 };

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

@@ -20,72 +20,38 @@
 #include "FastPngBitmap.h"
 #include "spng.h"
 
-FastPngBitmap::FastPngBitmap(std::string filename) : Bitmap("", 0) {
-  if (filename.length() > 0)
-  { std::ifstream file(filename, std::ios::binary | std::ios::ate);
-    if (file.is_open())
-    { std::streamsize size = file.tellg();
+FastPngBitmap::FastPngBitmap(std::string filename) : RawBitmap() {
+  if (filename.length() > 0) {
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    if (file.is_open()) {
+      std::streamsize size = file.tellg();
       file.seekg(0, std::ios::beg);
       std::vector<unsigned char> file_buffer(size);
-      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size))
-      { this->png_error = -1;
+      if (!file.read(reinterpret_cast<char*>(file_buffer.data()), size)) {
+        this->png_error = -1;
       } else {
         spng_ctx *ctx = spng_ctx_new(0);
         spng_set_png_buffer(ctx, file_buffer.data(), file_buffer.size());
         struct spng_ihdr ihdr;
         spng_get_ihdr(ctx, &ihdr);
-        this->width = ihdr.width;
-        this->height = ihdr.height;
         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);
+        this->define(ihdr.width, ihdr.height, 4, false);
+        unsigned char* raw_ptr = this->image.get();
+        madvise(raw_ptr, out_size, MADV_HUGEPAGE);
+        int error = spng_decode_image(ctx, raw_ptr, out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
         spng_ctx_free(ctx);
         this->png_error = error;
       }
+    } else {
+      throw std::runtime_error("Unable to open file: " + filename);
     }
   }
 }
 
-bool FastPngBitmap::pixel_match(int x, int y, Matcher *matcher)
-{ int32_t index = ((y * width) + x) * 4;
-  unsigned int color;
-  unsigned char *red = &image[index];
-  std::memcpy(&color, red, 3);
-  if (typeid(*matcher) == typeid(RGBMatcher))  return((reinterpret_cast<RGBMatcher*>(matcher))->match(color));
-  if (typeid(*matcher) == typeid(RGBNotMatcher)) return((reinterpret_cast<RGBNotMatcher*>(matcher))->match(color));
-  return(false);
-}
-
-int FastPngBitmap::w() {
-  return this->width;
-}
-
-int FastPngBitmap::h() {
-  return this->height;
-}
-
 int FastPngBitmap::error() {
   return this->png_error;
 }
-char FastPngBitmap::value_at(int x, int y) {
-  return(0);
-}
-
-// source image format RGBA => returning uint ABGR
-unsigned int FastPngBitmap::rgb_value_at(int x, int y) {
-  uint32_t index = (uint32_t(y) * width + x) * 4;
-  return *reinterpret_cast<const uint32_t*>(&image[index]);
-}
-
-const unsigned char* FastPngBitmap::get_row_ptr(int y) const {
-  return image.data() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
-}
-
-int FastPngBitmap::get_bytes_per_pixel() const {
-  return 4;  // RGBA
-}
 
 void FastPngBitmap::loadFile(std::vector<unsigned char>& buffer, const std::string& filename)  // designed for loading files from hard disk in an std::vector
 { std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

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

@@ -11,29 +11,20 @@
 #include <vector>
 #include <cstddef>
 #include <string>
-#include "Bitmap.h"
+#include "RawBitmap.h"
 
 class RGBMatcher;
 
 static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-class FastPngBitmap : public Bitmap {
+class FastPngBitmap : public RawBitmap {
  public:
   explicit FastPngBitmap(std::string filename);
-  bool pixel_match(int x, int y, Matcher *matcher);
-  int h();
-  int w();
   virtual int error();
-  char value_at(int x, int y);
-  unsigned int rgb_value_at(int x, int y);
-  const unsigned char* get_row_ptr(int y) const;
-  int get_bytes_per_pixel() const;
 
  protected:
   std::vector<unsigned char> buffer;
   std::vector<unsigned char> base64_decode(std::string &encoded_string);
-  std::vector<unsigned char> image;
-  unsigned int width, height;
   int png_error;
   int decodePNG(std::vector<unsigned char>& out_image, unsigned long& image_width, unsigned long& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true);
 

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

@@ -0,0 +1,64 @@
+/*
+ * RawBitmap.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 <memory>
+#include "RawBitmap.h"
+
+RawBitmap::RawBitmap() : Bitmap("", 0),
+  width(0),
+  height(0) {
+}
+
+int RawBitmap::w() {
+  return this->width;
+}
+
+int RawBitmap::h() {
+  return this->height;
+}
+
+char RawBitmap::value_at(int x, int y) {
+  return(0);
+}
+
+const unsigned char* RawBitmap::get_row_ptr(int y) const {
+  return image.get() + (static_cast<size_t>(y) * static_cast<size_t>(width) * 4);
+}
+
+int RawBitmap::get_bytes_per_pixel() const {
+  return this->bpp;
+}
+
+// source image format RGBA => returning uint ABGR
+unsigned int RawBitmap::rgb_value_at(int x, int y) {
+  uint32_t index = (static_cast<uint32_t>(y) * width + x) * 4;
+  return *reinterpret_cast<const uint32_t*>(&image[index]);
+}
+
+void RawBitmap::draw_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
+  if (x >= width || y >= height) return;
+  unsigned char* p = &image[(static_cast<size_t>(y) * width + x) * bpp];
+  p[0] = r;
+  if (bpp > 1) p[1] = g;
+  if (bpp > 2) p[2] = b;
+  if (bpp > 3) p[3] = a;
+}
+
+uint32_t RawBitmap::define(uint width, uint height, int bytes_per_pixel, bool clear)
+{ this->width = width;
+  this->height = height;
+  this->bpp = bytes_per_pixel;
+  uint32_t dimension = (static_cast<uint32_t>(width) * static_cast<uint32_t>(height)) * bytes_per_pixel;
+  this->image = std::make_unique<unsigned char[]>(dimension);
+  if (clear) {
+    std::fill(image.get(), image.get() + dimension, 0);
+  }
+  return dimension;
+}
+

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/bitmaps/RawBitmap.h

@@ -0,0 +1,37 @@
+/*
+ * RawBitmap.h
+ *
+ * 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.
+ */
+
+#pragma once
+#include <vector>
+#include <memory>
+#include <cstddef>
+#include <string>
+#include "Bitmap.h"
+
+class RGBMatcher;
+
+class RawBitmap : public Bitmap {
+ public:
+  explicit RawBitmap();
+  int h();
+  int w();
+  char value_at(int x, int y);
+  unsigned int rgb_value_at(int x, int y);
+  const unsigned char* get_row_ptr(int y) const;
+  int get_bytes_per_pixel() const;
+  uint32_t define(uint width, uint height, int bytes_per_pixel, bool clear = false);
+  void draw_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255);
+
+ protected:
+  std::unique_ptr<unsigned char[]> image;
+  unsigned int width, height;
+
+ private:
+  int bpp;
+};

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

@@ -30,12 +30,10 @@ RemoteFastPngBitmap::RemoteFastPngBitmap(std::string *dataurl) : FastPngBitmap("
     struct spng_ihdr ihdr;
     int error = spng_get_ihdr(ctx, &ihdr);
     if (!error) {
-      this->width = ihdr.width;
-      this->height = ihdr.height;
       size_t out_size;  // RGBA8 dimension
       spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &out_size);
-      this->image.resize(out_size);
-      error = spng_decode_image(ctx, image.data(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
+      this->define(ihdr.width, ihdr.height, 4, false);
+      error = spng_decode_image(ctx, image.get(), out_size, SPNG_FMT_RGBA8, SPNG_DECODE_TRNS);
     }
     if (error != 0) {
       std::cout << "spng error: " << spng_strerror(error) << std::endl;

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

@@ -17,9 +17,10 @@
 #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, NodeCluster* cluster, char name)
 : start_point(min_x, y),
-  end_point(max_x, y) {
+  end_point(max_x, y),
+  cluster(cluster) {
   this->name = name;
   this->min_x = min_x;
   this->max_x = max_x;
@@ -67,24 +68,14 @@ void Node::precalc_tangs_sequences(NodeCluster& cluster) {
   }
   // --- 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}
-    });
+    tangs_sequence.push_back(-(upper_pos + 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);
   }
   // --- 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}
-    });
+    tangs_sequence.push_back(lower_pos);
   }
   this->tangs_count = this->tangs_sequence.size();
 }
@@ -95,7 +86,7 @@ Node* Node::my_next_inner(Node *last, int versus) {
   else            last_node_index = this->down_indexer - last->abs_x_index;
   if (versus == Node::O) last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
   else          last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
-  return((this->tangs_sequence)[last_node_index].node);
+  return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Node* Node::my_next_outer(Node *last, int versus) {
@@ -104,15 +95,42 @@ Node* Node::my_next_outer(Node *last, int versus) {
   else                   last_node_index = this->down_indexer - last->abs_x_index;
   if (versus == Node::O) last_node_index == this->tangs_sequence.size() - 1 ? last_node_index = 0 : last_node_index++;
   else                   last_node_index == 0 ? last_node_index = this->tangs_sequence.size() - 1 : last_node_index--;
-  return((this->tangs_sequence)[last_node_index].node);
+  return get_tangent_node_by_virtual_index(this->tangs_sequence[last_node_index]);
 }
 
 Point* Node::coords_entering_to(Node *enter_to, int mode, int tracking) {
   int enter_to_index;
   if (enter_to->y < this->y) enter_to_index = enter_to->abs_x_index + this->up_indexer;
   else                       enter_to_index = this->down_indexer - enter_to->abs_x_index;
-  NodeDescriptor ds = (this->tangs_sequence)[enter_to_index];
-  Tangent t = (mode == Node::O ? ds.o : ds.a);
-  enter_to->track |= TURNER[tracking][t.mode - 1];
-  return(t.point);
+
+  int tg_index = this->tangs_sequence[enter_to_index];
+  Point* point;
+  if (tg_index < 0) {
+    Node& node_up = cluster->vert_nodes[y + T_UP][-(tg_index + 1)];
+    if (mode == Node::A) {
+      enter_to->track |= TURNER[tracking][OMAX - 1];
+      point = &node_up.end_point;
+    } else {
+      enter_to->track |= TURNER[tracking][OMIN - 1];
+      point = &node_up.start_point;
+    }
+  } else {
+    Node& node_down = cluster->vert_nodes[y + T_DOWN][tg_index];
+    if (mode == Node::A) {
+      enter_to->track |= TURNER[tracking][OMIN - 1];
+      point = &node_down.start_point;
+    } else {
+      enter_to->track |= TURNER[tracking][OMAX - 1];
+      point = &node_down.end_point;
+    }
+  }
+  return point;
+}
+
+Node* Node::get_tangent_node_by_virtual_index(int virtual_index) {
+  if (virtual_index < 0) {
+    return &(this->cluster->vert_nodes[y + T_UP][-(virtual_index + 1)]);
+  } else {
+    return &(this->cluster->vert_nodes[y + T_DOWN][virtual_index]);
+  }
 }

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

@@ -28,11 +28,6 @@ struct Point {
   }
   Point(int x_, int y_) : x(x_), y(y_) {}
 };
-struct Tangent {
-  Point   *point;
-  int   mode;
-};
-struct NodeDescriptor;
 
 class Node : public  Listable {
  public:
@@ -63,24 +58,20 @@ class Node : public  Listable {
   int lower_start = std::numeric_limits<int>::max();
   int lower_end   = -1;
   Point start_point, end_point;
+  NodeCluster* cluster;
   void add_intersection(Node& other_node, int other_node_index);
-  std::vector<NodeDescriptor> tangs_sequence;
+  std::vector<int> tangs_sequence;
   Point* coords_entering_to(Node *enter_to, int mode, int tracking);
   Node* my_next_outer(Node *last, int versus);
   Node* my_next_inner(Node *last, int versus);
+  Node* get_tangent_node_by_virtual_index(int vitual_index);
   bool track_uncomplete();
   bool track_complete();
   bool get_trackmax();
 
  public:
   int min_x, max_x;
-  Node(int min_x, int max_x, int y, char name);
+  Node(int min_x, int max_x, int y, NodeCluster* cluster, char name);
   void precalc_tangs_sequences(NodeCluster& cluster);
   bool processed = false;
 };
-
-struct NodeDescriptor {
-  Node  *node;
-  Tangent a;
-  Tangent o;
-};