contrek 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a9bb4f4ff327f04f6877b024c533c8d6d7b6f0ecfc7ad0ae51e6ad05a84438c
-  data.tar.gz: 9bf8394de257d8a3832400936992d5f848e015d10e389ce986347668d4f53b23
+  metadata.gz: d0d1a364ff39a11f632f5f57d99970448173727e8f5a42e84e1b334521c1e1d1
+  data.tar.gz: 24a52785c8735e9fce60931a1ffc1bd974aa5a50a6fb755229cd25dd5263cab3
 SHA512:
-  metadata.gz: c9640a27737904a3ab5eb4b4f1357262ba05dac579c743ba653ef9be0ed73a90648adc5af0d3c5ff9629f04aa12ca27b5f7e703855805488690d604dd7a82572
-  data.tar.gz: 656e58e008e3a6b912f5b99ed1b90dbe9b673dab08815177d14ec5d3de3a9380359b70d259517bdd2278b5f327db86bb448293d72555534205751e04a49378b1
+  metadata.gz: e321b716a5c16d6c75f24bc6bcdebc302a6ea9785009bad93905321ebc7a97ef29048fb1c6e4e0557611ec9d096dee874bd1ff37f66ad2763c4dacd7176b0ce4
+  data.tar.gz: 38608a89ed8ee0c43a985bf8057d07b860acd524d2e8c0022651e5ec3fdcc8f13e3d515e309d436ad261203e00a58b901dd6cf141bfbeeb93520f7937ccdb4b8

data/CHANGELOG.md

@@ -18,4 +18,8 @@ All notable changes to this project will be documented in this file.
 ### Added
 - Added C++ multithreading supports
 - Optimized old just present C++ code
-- Removed Png++ dependency in place of libspn 
+- Removed Png++ dependency in place of libspn
+
+## [1.0.7] - 2026-01-10
+### Added
+- Optimized C++/Ruby data transfer: Implemented NumPy-compatible binary serialization for coordinate outputs. This reduces serialization overhead and significantly increases data throughput between the C++ core and the Ruby interface.

data/Gemfile.lock

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

data/README.md

@@ -1,5 +1,5 @@
 # Contrek
-Contrek is a Ruby library (C++ powered) to trace png bitmap areas polygonal contours. Manages png images usign libspng (version 0.7.4) library. May work multithreading.
+Contrek is a Ruby gem with a C++ core for fast contour tracing and edge detection in PNG images. It extracts polygonal contours from bitmap shapes, enabling image processing, shape analysis, and raster-to-vector workflows such as PNG to SVG conversion. Manages png images usign libspng (version 0.7.4) library. May work multithreading.
 
 ## 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.
@@ -34,9 +34,10 @@ result = Contrek.contour!(
   }
 )
 ```
-The result reports information about the execution times (microseconds), the polygons found, their coordinates and the nesting tree.
+The resulting metadata information contains the execution times (microseconds), the count of polygons found and the nesting tree map. You can access polygons coordinates too (see later).
+
 ```ruby
-{:benchmarks=>{"build_tangs_sequence"=>0.129, "compress"=>0.037, "plot"=>0.198, "scan"=>0.114, "total"=>0.478}, :groups=>2, :named_sequence=>"", :polygons=>[...], :treemap=>[]}
+{:benchmarks=>{"build_tangs_sequence"=>0.129, "compress"=>0.037, "plot"=>0.198, "scan"=>0.114, "total"=>0.478}, :groups=>2, :named_sequence=>"", :treemap=>[]}
 
 ```
 
@@ -63,7 +64,7 @@ polygonfinder = CPPPolygonFinder.new(png_bitmap,
   {versus: :a, compress: {visvalingam: {tolerance: 1.5}}})
 result = polygonfinder.process_info
 # draws the polygons found
-Contrek::Bitmaps::Painting.direct_draw_polygons(result[:polygons], png_image)
+Contrek::Bitmaps::Painting.direct_draw_polygons(result.points, png_image)
 png_image.save('result.png') # => inspect the image to feedback the result
 ```
 
@@ -98,7 +99,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 2 thread working on 2 tiles (total compute time about 2 secs).
+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 2 threads working on 2 tiles (total compute time about 2 secs).
 
 ```ruby
 result = Contrek.contour!(
@@ -110,7 +111,7 @@ result = Contrek.contour!(
     finder: {number_of_tiles: 2, compress: {uniq: true}}
   }
 )
-puts result[:benchmarks].inspect
+puts result.metadata[:benchmarks].inspect
 
 {"compress"=>14.596786999999999,
   "init"=>2078.745861,
@@ -118,6 +119,97 @@ puts result[:benchmarks].inspect
   "outer"=>118.94489599999999,
   "total"=>2093.342648}
 ```
+
+## Result
+
+The result structure contains polygon coordinates and a set of metadata. Polygon coordinates can be accessed via:
+
+```ruby
+result.polygons
+
+[{:outer=>[11, 2, 11, 5, 6, 5, 6, 2],
+  :inner=>[[10, 3, 7, 3, 7, 4, 10, 4]]}]
+```
+
+For native classes (C/C++), coordinates are represented as an interleaved NumPy array (`ndarray`) in the form:
+
+```
+[x0, y0, x1, y1, ...]
+```
+
+A ruby side helper method could converts this data structure into point-based representations:
+
+```ruby
+result.points
+
+[{:outer=>[{:x=>11, :y=>2}, {:x=>11, :y=>5}, {:x=>6, :y=>5}, {:x=>6, :y=>2}],
+  :inner=>[[{:x=>10, :y=>3}, {:x=>7, :y=>3}, {:x=>7, :y=>4}, {:x=>10, :y=>4}]]}]
+```
+
+- `outer` represents a single polygonal sequence  
+- `inner` is represented as an array of polygonal sequences (holes)
+
+For pure Ruby implementations (`{ native: false }`), coordinates are always expressed as points.  
+In this case, both `polygons` and `points` return the same data, represented as hashes with `x` and `y` keys.
+
+## Metadata
+
+Metadata associated with the result can be accessed via:
+
+```ruby
+result.metadata
+
+{:benchmarks=>{"build_tangs_sequence"=>0.00577,
+               "compress"=>0.01239,
+               "plot"=>0.01919,
+               "scan"=>0.01473,
+               "total"=>0.05208},
+ :groups=>1,
+ :named_sequence=>"AFEDCBA",
+ :treemap=>[]}
+```
+
+## Treemap
+
+The treemap is a data structure that represents the containment hierarchy of polygons. For each polygon, it defines the parent polygon in which it is contained and its relative position among siblings. This structure allows reconstruction of the inclusion tree and determination of nesting relationships between geometries. Consider the above image
+
+```ruby
+ "AAAAAAAAAAAAAAAAAAAAAA" \
+ "A                    A" \
+ "A BBBBBBBBBBBBBBBBBB A" \
+ "A BBBBBBBBBBBBBBBBBB A" \
+ "A BBB    BBBBB   BBB A" \
+ "A BBB CC BBBBB D BBB A" \
+ "A BBB    BBBBB   BBB A" \
+ "A BBBBBBBBBBBBBBBBBB A" \
+ "A BBBBBBBBBBBBBBBBBB A" \
+ "A                    A" \
+ "AAAAAAAAAAAAAAAAAAAAAA"
+```
+
+```ruby
+result.metadata[:treemap]
+
+[[-1, -1],  # A
+ [0, 0],    # B
+ [1, 0],    # C
+ [1, 1]]    # D
+```
+
+There are four polygons (`A`, `B`, `C`, and `D`).  
+The order matches the one provided in `result.polygons`.
+
+Each entry has the structure:
+
+```
+[parent_index, position]
+```
+
+- Polygon **A** (index `0`) has no parent and is represented as `[-1, -1]`
+- Polygon **B** is contained in **A** and is its first child → `[0, 0]`
+- Polygon **C** is contained in **B** and is its first child → `[1, 0]`
+- Polygon **D** is also contained in **B** and is its second child → `[1, 1]`
+
 ## Multithreaded approach
 
 The multithreaded contour-tracing implementation operates as follows:
@@ -178,6 +270,10 @@ This project is licensed under the terms of the MIT license.
 
 See [LICENSE.md](LICENSE.md).
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a complete list of changes.
+
 ## History
 The algorithm was originally developed by me in 2018 when I was commissioned to create a Rails web application whose main objective was to census buildings from GoogleMAPS; the end user had to be able to select their home building by clicking its roof on the map which had to be identified as a clickable polygon. The solution was to configure GoogleMAPS to render buildings of a well-defined color (red), and at each refresh of the same to transform the div into an image (html2canvas) then process it server side returning the polygons to be superimposed again on the map. This required very fast polygons determination. Searching for a library for tracing the contours I was not able to find anything better except OpenCV which however seemed to me a very heavy dependency. So I decided to write my algorithm directly in the context of the ROR application. Once perfected, it was already usable but a bit slow in the higher image resolutions. So I decided to write the counterpart in C++, which came out much faster and which I then used as an extension on Ruby by means of Rice.
 

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

@@ -124,6 +124,7 @@ Finder::~Finder() {
 ProcessResult* Finder::process_info() {
   ProcessResult *pr = new ProcessResult();
   pr->polygons = std::move(this->whole_tile->to_raw_polygons());
+  pr->groups = pr->polygons.size();
   FakeCluster fake_cluster(pr->polygons, this->options);
   cpu_timer.start();
   fake_cluster.compress_coords(pr->polygons, this->options);

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -8,11 +8,11 @@
 
 #include <iostream>
 #include <list>
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
 #include <vector>
 #include <map>
 #include <string>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 #include "PolygonFinder/src/polygon/finder/PolygonFinder.h"
 #include "PolygonFinder/src/polygon/finder/PolygonFinder.cpp"
@@ -86,142 +86,133 @@ extern "C" {
   #include "PolygonFinder/src/polygon/bitmaps/spng.h"
 }
 
-using namespace Rice;
-
-namespace Rice::detail
-{ template<>
-  class To_Ruby<std::vector<Point*>>
-  { public:
-      VALUE convert(const std::vector<Point*>& x)
-      { Rice::Array arr;
-        for (Point* p : x)
-          arr.push(p);
-        return arr;
-      }
-  };
-
-  template<>
-  class To_Ruby<std::list<std::vector<Point*>>>
-  { public:
-      VALUE convert(const std::list<std::vector<Point*>>& x)
-      { Rice::Array arr;
-        for (const std::vector<Point*>& vec : x)
-        { arr.push(vec);
-        }
-        return arr;
-      }
-  };
+class RubyResult {
+ public:
+  Rice::Array polygons;
+  Rice::Hash metadata;
+};
 
-  template<>
-  class To_Ruby<Point*>
-  { public:
-      VALUE convert(Point* const & x)
-      {  Rice::Hash h = Rice::Hash();
-         h[Symbol("x")] = x->x;
-         h[Symbol("y")] = x->y;
-         return(h);
-      }
-  };
+using namespace Rice;
 
-  template<>
-  class To_Ruby<std::map<std::string, double>*>
-  { public:
-      VALUE convert(std::map<std::string, double>* const & x)
-      { Rice::Hash return_me = Rice::Hash();
-        std::map<std::string, double>::iterator it;
-        for ( it = x->begin(); it != x->end(); it++ )
-        {  return_me[String(it->first)] = it->second;
-        }
-        return return_me;
-      }
-  };
+namespace Rice::detail {
 
-  template<>
-  class From_Ruby<std::vector<std::string>*>
-  { public:
-    Convertible is_convertible(VALUE value)
-    { switch (rb_type(value))
-      { case RUBY_T_HASH:
-          return Convertible::Cast;
+template<>
+class From_Ruby<std::vector<std::string>*>
+{ public:
+  Convertible is_convertible(VALUE value)
+  { switch (rb_type(value))
+    { case RUBY_T_HASH:
+        return Convertible::Cast;
+        break;
+      default:
+        return Convertible::None;
+    }
+  }
+  std::vector<std::string>* convert(VALUE value)
+  { std::vector<std::string> *arguments = new std::vector<std::string>();
+    if (rb_type(value) == RUBY_T_NIL) return(arguments);
+    Rice::Hash hash = (Rice::Hash) value;
+    for (Rice::Hash::iterator it = hash.begin(); it != hash.end(); ++it) {
+      Rice::String keyString = it->key.to_s();
+      Rice::Object value = it->value;
+      switch (value.rb_type()) {
+        case T_STRING:
+          arguments->push_back("--" + keyString.str()+"="+((Rice::String) value).str());
           break;
-        default:
-          return Convertible::None;
-      }
+        case T_SYMBOL:
+          arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
+          break;
+        case T_FLOAT:
+          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
+          break;
+        case T_FIXNUM:
+          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
+          break;
+        case T_TRUE:
+          arguments->push_back("--" + keyString.str()+"=true");
+          break;
+        case T_FALSE:
+          arguments->push_back("--" + keyString.str()+"=false");
+          break;
+        case T_HASH:
+          std::vector<std::string>* iv = From_Ruby<std::vector<std::string>*>::convert(value);
+          for (std::vector<std::string>::iterator it_iv = iv->begin() ; it_iv != iv->end(); ++it_iv)
+          { (*it_iv).replace(0, 2, "_");
+            arguments->push_back("--" + keyString.str() + *it_iv);
+          }
+          break;
+       }
     }
-    std::vector<std::string>* convert(VALUE value)
-    { std::vector<std::string> *arguments = new std::vector<std::string>();
-      if (rb_type(value) == RUBY_T_NIL) return(arguments);
-      Rice::Hash hash = (Rice::Hash) value;
-      for (Rice::Hash::iterator it = hash.begin(); it != hash.end(); ++it) {
-        Rice::String keyString = it->key.to_s();
-        Rice::Object value = it->value;
-        switch (value.rb_type()) {
-          case T_STRING:
-            arguments->push_back("--" + keyString.str()+"="+((Rice::String) value).str());
-            break;
-          case T_SYMBOL:
-            arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
-            break;
-          case T_FLOAT:
-            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
-            break;
-          case T_FIXNUM:
-            arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
-            break;
-          case T_TRUE:
-            arguments->push_back("--" + keyString.str()+"=true");
-            break;
-          case T_FALSE:
-            arguments->push_back("--" + keyString.str()+"=false");
-            break;
-          case T_HASH:
-            std::vector<std::string>* iv = From_Ruby<std::vector<std::string>*>::convert(value);
-            for (std::vector<std::string>::iterator it_iv = iv->begin() ; it_iv != iv->end(); ++it_iv)
-            { (*it_iv).replace(0, 2, "_");
-              arguments->push_back("--" + keyString.str() + *it_iv);
-            }
-            break;
-         }
-      }
-      return arguments;
+    return arguments;
+  }
+};
+
+template<>
+class To_Ruby<ProcessResult*>
+{public:
+  VALUE convert(ProcessResult* const & pr)
+  { if (!pr) {
+      return Qnil;
     }
-  };
+    RubyResult* rr = new RubyResult();
+    Rice::Data_Object<RubyResult> rb_result(rr);
 
-  template<>
-  struct Type<ProcessResult>
-  { static bool verify()
-    { return true;
+    Rice::Hash return_me = Rice::Hash();
+    Rice::Hash benchmarks_rb;
+    for (auto const& [name, value] : pr->benchmarks) {
+      benchmarks_rb[Rice::String(name)] = value;
     }
-  };
+    return_me[Symbol("benchmarks")] = benchmarks_rb;
+    return_me[Symbol("groups")] = pr->groups;
+    return_me[Symbol("named_sequence")] = pr->named_sequence;
 
-  template<>
-  class To_Ruby<ProcessResult*>
-  { public:
-    VALUE convert(ProcessResult* const & pr)
-    { Rice::Hash return_me = Rice::Hash();
-      return_me[Symbol("benchmarks")] = &pr->benchmarks;
-      return_me[Symbol("groups")] = pr->groups;
-      return_me[Symbol("named_sequence")] = pr->named_sequence;
-      Rice::Array out;
-      for (Polygon& x : pr->polygons)
-      { Rice::Hash h = Rice::Hash();
-        h[Symbol("outer")] = x.outer;
-        h[Symbol("inner")] = x.inner;
-        out.push(h);
+    Rice::Array out;
+    for (Polygon& x : pr->polygons)
+    { Rice::Hash poly_hash = Rice::Hash();
+      // OUTER: std::vector<Point*>
+      Rice::Array outer_flat;
+      for (Point* p : x.outer) {
+        outer_flat.push(p->x);
+        outer_flat.push(p->y);
       }
-      return_me[Symbol("polygons")] = out;
-      Rice::Array tmapout;
-      for (const auto& tm : pr->treemap) {
-        Rice::Array tmentry;
-        tmentry.push(tm.first);   // outer
-        tmentry.push(tm.second);  // inner
-        tmapout.push(tmentry);
+      poly_hash[Symbol("outer")] = outer_flat;
+      // INNER: std::list<std::vector<Point*>>
+      Rice::Array inner_collection;
+      for (const std::vector<Point*>& sequence : x.inner) {
+        Rice::Array sequence_flat;
+        for (Point* p : sequence) {
+          sequence_flat.push(p->x);
+          sequence_flat.push(p->y);
+        }
+        inner_collection.push(sequence_flat);
       }
-      return_me[Symbol("treemap")] = tmapout;
-      delete pr;
-      return(return_me);
+      poly_hash[Symbol("inner")] = inner_collection;
+      out.push(poly_hash);
+    }
+    rr->polygons = out;
+
+    // Treemap
+    Rice::Array tmapout;
+    for (const auto& tm : pr->treemap) {
+      Rice::Array tmentry;
+      tmentry.push(tm.first);
+      tmentry.push(tm.second);
+      tmapout.push(tmentry);
     }
-  };
+    return_me[Symbol("treemap")] = tmapout;
+    rr->metadata = return_me;
+
+    // Protects objects 'out' e 'return_me' linking them to the ruby instance preventing GC
+    // garbage collector to free them before the instance itself.
+    Rice::Object ruby_obj = rb_result;
+    ruby_obj.iv_set("@polygons_storage", out);
+    ruby_obj.iv_set("@metadata_storage", return_me);
+
+    delete pr;
+    return rb_result.value();
+  }
+};
+
 }  // namespace Rice::detail
 
 extern "C"
@@ -281,12 +272,18 @@ void Init_cpp_polygon_finder() {
 
   Data_Type<PolygonFinder> rb_cPolygonFinder =
     define_class<PolygonFinder>("CPPPolygonFinder")
-    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, std::vector<std::string>*>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = nullptr)
+    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, std::vector<std::string>*>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
     .define_method("get_shapelines", &PolygonFinder::get_shapelines)
-    .define_method("process_info", &PolygonFinder::process_info);
+    .define_method("process_info", &PolygonFinder::process_info, Rice::Arg("yield_gvl") = true);
 
   Data_Type<Finder> rb_cFinder =
     define_class<Finder>("CPPFinder")
-    .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = nullptr)
-    .define_method("process_info", &Finder::process_info);
+    .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
+    .define_method("process_info", &Finder::process_info, Rice::Arg("yield_gvl") = true);
+
+  Data_Type<RubyResult> rb_cResult =
+    define_class_under<RubyResult>(rb_cFinder, "Result")
+    .define_constructor(Constructor<RubyResult>())
+    .define_method("polygons", [](RubyResult& rr) { return rr.polygons; })
+    .define_method("metadata", [](RubyResult& rr) { return rr.metadata; });
 }

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

@@ -74,14 +74,17 @@ module Contrek
           end
         end.real
 
-        {polygons: raw_polygons,
-         benchmarks: {
-           total: ((@initialize_time + compress_time) * 1000).round(3),
-           init: (@initialize_time * 1000).round(3),
-           outer: (@whole_tile.benchmarks[:outer] * 1000).round(3),
-           inner: (@whole_tile.benchmarks[:inner] * 1000).round(3),
-           compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
-         }.compact}
+        metadata = {
+          groups: raw_polygons.size,
+          benchmarks: {
+            total: ((@initialize_time + compress_time) * 1000).round(3),
+            init: (@initialize_time * 1000).round(3),
+            outer: (@whole_tile.benchmarks[:outer] * 1000).round(3),
+            inner: (@whole_tile.benchmarks[:inner] * 1000).round(3),
+            compress: ((compress_time * 1000).round(3) if @options.has_key?(:compress))
+          }.compact
+        }
+        Contrek::Finder::Result.new(raw_polygons, metadata)
       end
 
       private

data/lib/contrek/finder/polygon_finder.rb

@@ -43,12 +43,14 @@ module Contrek
 
       # infos
       def process_info
-        {named_sequence: @node_cluster.sequences.map { |list| list.map(&:name).join }.join("-"),
-         groups: @node_cluster.sequences.size,
-         groups_names: @node_cluster.root_nodes.map(&:name).join,
-         polygons: @node_cluster.polygons,
-         benchmarks: format_benchmarks,
-         treemap: (@node_cluster.treemap if @options.has_key?(:treemap))}
+        metadata = {
+          named_sequence: @node_cluster.sequences.map { |list| list.map(&:name).join }.join("-"),
+          groups: @node_cluster.sequences.size,
+          groups_names: @node_cluster.root_nodes.map(&:name).join,
+          benchmarks: format_benchmarks,
+          treemap: (@node_cluster.treemap if @options.has_key?(:treemap))
+        }
+        Result.new(@node_cluster.polygons, metadata)
       end
 
       def get_shapelines

data/lib/contrek/finder/result.rb

@@ -0,0 +1,13 @@
+module Contrek
+  module Finder
+    Result = Struct.new(:polygons, :metadata_hash) do
+      def points
+        polygons
+      end
+
+      def metadata
+        metadata_hash
+      end
+    end
+  end
+end

data/lib/contrek/results/cpp_result.rb

@@ -0,0 +1,21 @@
+module Contrek
+  module Results
+    class CPPFinder::Result
+      def points
+        raw_list = polygons.to_a
+        @to_points ||= raw_list.map do |polygon|
+          {outer: self.class.to_points(polygon[:outer]),
+           inner: polygon[:inner].map { |s| self.class.to_points(s) }}
+        end
+      end
+
+      def total_time
+        metadata[:benchmarks].values.sum
+      end
+
+      def self.to_points(flat_polygon)
+        flat_polygon.each_slice(2).map { |x, y| {x: x, y: y} }
+      end
+    end
+  end
+end

data/lib/contrek/version.rb

@@ -1,3 +1,3 @@
 module Contrek
-  VERSION = "1.0.6"
+  VERSION = "1.0.7"
 end

data/lib/contrek.rb

@@ -15,6 +15,7 @@ require "contrek/finder/node"
 require "contrek/finder/node_cluster"
 require "contrek/finder/concurrent/fake_cluster"
 require "contrek/finder/polygon_finder"
+require "contrek/finder/result"
 require "contrek/finder/concurrent/clipped_polygon_finder"
 require "contrek/finder/concurrent/hub"
 require "contrek/finder/concurrent/end_point"
@@ -41,6 +42,7 @@ require "contrek/reducers/uniq_reducer"
 require "contrek/reducers/visvalingam_reducer"
 require "cpp_polygon_finder"
 require "contrek/cpp/cpp_concurrent_finder"
+require "contrek/results/cpp_result"
 
 module Contrek
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-06 00:00:00.000000000 Z
+date: 2026-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -256,6 +256,7 @@ files:
 - lib/contrek/finder/node.rb
 - lib/contrek/finder/node_cluster.rb
 - lib/contrek/finder/polygon_finder.rb
+- lib/contrek/finder/result.rb
 - lib/contrek/map/mercator_projection.rb
 - lib/contrek/matchers/matcher.rb
 - lib/contrek/matchers/matcher_hsb.rb
@@ -264,6 +265,7 @@ files:
 - lib/contrek/reducers/reducer.rb
 - lib/contrek/reducers/uniq_reducer.rb
 - lib/contrek/reducers/visvalingam_reducer.rb
+- lib/contrek/results/cpp_result.rb
 - lib/contrek/version.rb
 homepage: https://github.com/runout77/contrek
 licenses: