contrek 1.0.5 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a9cdb68500b2dccfccad5f75c9c6bebddd7040f2bf59ad54cea0c0c0abd5eed
-  data.tar.gz: '08c914172eaff80d4b81283878d16dd569cd0b3fd4cb8d402a40aec4cf88e5d3'
+  metadata.gz: d0d1a364ff39a11f632f5f57d99970448173727e8f5a42e84e1b334521c1e1d1
+  data.tar.gz: 24a52785c8735e9fce60931a1ffc1bd974aa5a50a6fb755229cd25dd5263cab3
 SHA512:
-  metadata.gz: 4bf1697f9de6d1b8c2e12affe0493b86070772c80b16f657b24b880b89ebb81663ff718b9069e0959de061bfe132a3e844d88c0310dd5cb3700fab97166fdf0c
-  data.tar.gz: 4fd630772cc40e16cd233615ac4b6057c638b8fd2ff5d395df7d5c758247320f04f6115cb1f63cb512d275090d5b3d55b9fc9c756358ba2ffbbbe54007d13de7
+  metadata.gz: e321b716a5c16d6c75f24bc6bcdebc302a6ea9785009bad93905321ebc7a97ef29048fb1c6e4e0557611ec9d096dee874bd1ff37f66ad2763c4dacd7176b0ce4
+  data.tar.gz: 38608a89ed8ee0c43a985bf8057d07b860acd524d2e8c0022651e5ec3fdcc8f13e3d515e309d436ad261203e00a58b901dd6cf141bfbeeb93520f7937ccdb4b8

data/.gitignore

@@ -3,9 +3,10 @@
 # rspec failure tracking
 .rspec_status
 
-/ext/cpp_polygon_finder/PolygonFinder/Debug/*
-/ext/cpp_polygon_finder/.metadata/
-/ext/cpp_polygon_finder/RemoteSystemsTempFiles/
+/ext/cpp_polygon_finder/PolygonFinder/build/
+/ext/cpp_polygon_finder/PolygonFinder/contrek
+/ext/cpp_polygon_finder/PolygonFinder/build/*.o
+/ext/cpp_polygon_finder/PolygonFinder/build/*.d
 /ext/cpp_polygon_finder/Makefile
 /ext/cpp_polygon_finder/cpp_polygon_finder.o
 /ext/cpp_polygon_finder/cpp_polygon_finder.so

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.1] - 2025-05-18
+### Added
+- The project is made available as a Ruby gem
+
+## [1.0.3] - 2025-11-15
+### Changed
+- Minor changes
+
+## [1.0.5] - 2025-11-16
+### Added
+- Added ruby side multithreading supports
+
+## [1.0.6] - 2026-01-06
+### Added
+- Added C++ multithreading supports
+- Optimized old just present C++ code
+- 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,8 +1,8 @@
 # Contrek
-Contrek is a Ruby library (C++ powered) to trace png bitmap areas polygonal contours. Manages png images usign png++ and picoPNG (version 20101224) libraries and 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 (currently only on the Ruby side), splitting the image into vertical strips and recombining the coordinates in pairs.
+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.
 
 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")
@@ -19,21 +19,7 @@ And then execute:
 
     bundle install
 
-This will install the gem and compile the native extensions. If you get
-`fatal error: png++/png.hpp: No such file or directory`
-
-means that you have to install png++ on your system which Contrek C++ code depends on; visit http://download.savannah.nongnu.org/releases/pngpp/
-Grab the lattest file (here 0.2.9) 
-Go to download directory. Extract to /usr/src with 
-
-    sudo tar -zxf png++-0.2.9.tar.gz -C /usr/src
-Change directory to
-
-    cd /usr/src/png++-0.2.9/
-Do make and make install
-
-    make
-    make install
+This will install the gem and compile the native extensions.
 
 ## Usage
 In this example we are asking to examine any pixel that does not have the red color.
@@ -48,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=>[]}
 
 ```
 
@@ -77,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
 ```
 
@@ -88,8 +75,6 @@ png_bitmap = CPPRemotePngBitMap.new("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcS
 
 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).
 
-The actual multithreaded implementation effort is therefore focused on the native C++ component, which is currently under development and is expected to provide substantially higher performance.
-
 ```ruby
 result = Contrek.contour!(
   png_file_path: "./spec/files/images/rectangle_8x8.png",
@@ -114,6 +99,116 @@ 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 threads working on 2 tiles (total compute time about 2 secs).
+
+```ruby
+result = Contrek.contour!(
+  png_file_path: "./spec/files/images/sample_10240x10240.png",
+  options: {
+    number_of_threads: 2,
+    class: "value_not_matcher",
+    color: {r: 255, g: 255, b: 255, a: 255},
+    finder: {number_of_tiles: 2, compress: {uniq: true}}
+  }
+)
+puts result.metadata[:benchmarks].inspect
+
+{"compress"=>14.596786999999999,
+  "init"=>2078.745861,
+  "inner"=>1183.143734,
+  "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
 
@@ -151,22 +246,23 @@ 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=>1063.146,
-  :build_tangs_sequence=>287.114,
-  :plot=>79.329,
-  :compress=>0.001,
-  :total=>1429.59}
+{ :scan=>801.494,
+  :build_tangs_sequence=>160.491,
+  :plot=>86.633,
+  :compress=>0.002,
+  :total=>1048.62}
 ```
 This the one for the native C++
 ```ruby
-{ :scan=>43.521,
-  :build_tangs_sequence=>44.105,
-  :plot=>35.718,
-  :compress=>0.001,
-  :total=>123.34500000000001}
+{ scan: 7.1146329999999995,
+  build_tangs_sequence: 3.063812,
+  plot: 4.474851999999999,
+  compress: 0.0031999999999999997
+  total: 14.656496999999998
+}
 ```
 
-About 10 x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99). 
+About 75x faster. Times are in microseconds; system: AMD Ryzen 7 3700X 8-Core Processor (BogoMIPS: 7199,99) on Ubuntu distro. 
 
 ## License
 
@@ -174,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/Rakefile

@@ -3,8 +3,11 @@ require "rake"
 desc "compiles c++ extension"
 task :compile do |t|
   Dir.chdir("ext/cpp_polygon_finder") do
+    Dir.glob("**/*.o").each { |f| File.delete(f) }
+    File.delete("Makefile") if File.exist?("Makefile")
     system "ruby", "extconf.rb"
     system "make", "-B"
+    Dir.glob("**/*.o").each { |f| File.delete(f) }
     system "cp cpp_polygon_finder.so ./../../lib"
   end
 end

data/contrek.gemspec

@@ -4,8 +4,8 @@ require "contrek/version"
 Gem::Specification.new do |s|
   s.name = "contrek"
   s.version = Contrek::VERSION
-  s.summary = "Png image shapes contour finder"
-  s.description = "Contrek is a Ruby library (C++ powered) to trace png bitmap areas polygonal contours."
+  s.summary = "Fast PNG contour tracing and shape detection for Ruby"
+  s.description = "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."
   s.authors = ["Emanuele Cesaroni"]
   s.email = "cesaroni.emanuele77@gmail.com"
   s.homepage = "https://github.com/runout77/contrek"
@@ -14,7 +14,10 @@ Gem::Specification.new do |s|
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(pkg|spec)/}) }
   end
   s.metadata = {
-    "homepage_uri" => "https://github.com/runout77/contrek"
+    "homepage_uri" => "https://github.com/runout77/contrek",
+    "source_code_uri" => "https://github.com/runout77/contrek",
+    "documentation_uri" => "https://github.com/runout77/contrek#readme",
+    "changelog_uri" => "https://github.com/runout77/contrek/blob/main/CHANGELOG.md"
   }
 
   s.add_development_dependency "rspec", "~> 3.12"

data/ext/cpp_polygon_finder/PolygonFinder/Makefile

@@ -0,0 +1,44 @@
+CXX = g++
+CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g \
+           -fno-omit-frame-pointer -fsanitize=address,undefined \
+           -O0
+LDFLAGS = -lpng -pthread -lz -fsanitize=address,undefined
+
+# valgrinf or perf setup
+#CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -fno-omit-frame-pointer -march=native -DNDEBUG -O3
+#LDFLAGS = -lpng -pthread -lz
+
+# best performances
+CXXFLAGS = -Wall -Wextra -std=c++17 -Isrc -MMD -MP -pthread -g -march=native -DNDEBUG -Ofast -flto
+LDFLAGS = -lpng -pthread -lz -flto=auto
+
+SRC = $(shell find src -name '*.cpp')
+C_SRC = $(shell find src -name 'spng.c')
+
+OBJ = $(patsubst src/%.cpp, build/%.o, $(SRC))
+OBJ += $(patsubst src/%.c, build/%.o, $(C_SRC))
+
+DEPS = $(OBJ:.o=.d)
+
+EXEC = contrek
+
+all: $(EXEC)
+
+$(EXEC): $(OBJ)
+	$(CXX) $(CXXFLAGS) $(OBJ) -o $@ -Wl,--no-as-needed $(LDFLAGS)
+
+build/%.o: src/%.cpp
+	@mkdir -p $(dir $@)
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+build/%.o: src/%.c
+	@mkdir -p $(dir $@)
+	$(CC) -O3 -march=native -fPIC -c $< -o $@
+
+-include $(DEPS)
+
+clean:
+	rm -rf build $(EXEC)
+
+run: all
+	./$(EXEC)

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

@@ -6,14 +6,13 @@
 // Description :
 //============================================================================
 
-#include <iostream>
 #include <string.h>
+#include <iostream>
 #include <list>
 #include <map>
 #include <string>
 #include "polygon/finder/PolygonFinder.h"
 #include "polygon/bitmaps/Bitmap.h"
-#include "polygon/bitmaps/PngBitmap.h"
 #include "polygon/bitmaps/FastPngBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "polygon/matchers/Matcher.h"
@@ -22,12 +21,21 @@
 #include "polygon/matchers/ValueNotMatcher.h"
 #include "polygon/finder/optionparser.h"
 #include "Tests.h"
-using namespace std;
+#include "polygon/CpuTimer.h"
 
 int main() {
-  Tests *test_suite = new Tests;
-  test_suite->test_a();
+  CpuTimer cpu_timer;
+  Tests test_suite;
+  cpu_timer.start();
+
+  // test_suite.test_a();
+  // test_suite.test_b();
+  // test_suite.test_c();
+  // test_suite.test_d();
+  test_suite.test_e();
+  std::cout << "compute time =" << cpu_timer.stop() << std::endl;
 
+/*
   FastPngBitmap png_bitmap("images/labyrinth.png");
   std::cout << "image_w=" << png_bitmap.w() << " image_h=" << png_bitmap.h() << std::endl;
   std::cout << "load_error=" << png_bitmap.error() << std::endl;
@@ -37,5 +45,6 @@ int main() {
   RemoteFastPngBitmap bitmap(&data_url);
   std::cout << "image_w=" << bitmap.w() << " image_h=" << bitmap.h() << std::endl;
   std::cout << "load_error=" << bitmap.error() << std::endl;
+*/
   return 0;
 }

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

@@ -7,15 +7,15 @@
  */
 
 #include "Tests.h"
-#include <iostream>
 #include <string.h>
+#include <iostream>
 #include <list>
 #include <map>
 #include <vector>
 #include <string>
 #include "polygon/finder/PolygonFinder.h"
+#include "polygon/finder/concurrent/ClippedPolygonFinder.h"
 #include "polygon/bitmaps/Bitmap.h"
-#include "polygon/bitmaps/PngBitmap.h"
 #include "polygon/bitmaps/FastPngBitmap.h"
 #include "polygon/bitmaps/RemoteFastPngBitmap.h"
 #include "polygon/matchers/Matcher.h"
@@ -23,7 +23,10 @@
 #include "polygon/matchers/RGBNotMatcher.h"
 #include "polygon/matchers/ValueNotMatcher.h"
 #include "polygon/finder/optionparser.h"
-using namespace std;
+#include "polygon/finder/concurrent/Finder.h"
+#include "polygon/finder/concurrent/Sequence.h"
+#include "polygon/finder/concurrent/Position.h"
+#include "polygon/finder/Polygon.h"
 
 Tests::Tests() {
 }
@@ -32,7 +35,7 @@ Tests::~Tests() {
 }
 
 void Tests::test_a()
-{ string chunk =
+{ std::string chunk =
       "0000000000000000"\
       "00000000000B0000"\
       "000000AAAAAA0000"\
@@ -49,21 +52,139 @@ void Tests::test_a()
   std::vector<int> outer_array{11, 1, 6, 2, 6, 3, 6, 4, 6, 5, 11, 5, 11, 4, 11, 3, 11, 2, 11, 1};
   std::vector<int> inner_array{7, 3, 10, 3, 10, 4, 7, 4};
   std::vector<int> array_compare;
-  for (std::list<std::map<std::string, std::list<std::list<Point*>*>>>::iterator x = o->polygons.begin(); x != o->polygons.end(); ++x)
-  { for (std::list<Point*>::iterator y = (*x)["outer"].front()->begin(); y != (*x)["outer"].front()->end(); ++y)
-    {  array_compare.push_back((*y)->x);
-       array_compare.push_back((*y)->y);
+
+  for (const auto& x : o->polygons)
+  { for (const Point* p : x.outer) {
+      array_compare.push_back(p->x);
+      array_compare.push_back(p->y);
     }
-    if (outer_array != array_compare) throw;
+    if (outer_array != array_compare) throw std::runtime_error("Wrong OUTER results!");
     array_compare.clear();
-
-    for (std::list<std::list<Point*>*>::iterator z = (*x)["inner"].begin(); z != (*x)["inner"].end(); ++z)
-    { for (std::list<Point*>::iterator y = (*z)->begin(); y != (*z)->end(); ++y)
-      { array_compare.push_back((*y)->x);
-        array_compare.push_back((*y)->y);
+    for (const auto& z : x.inner)
+    { for (const Point* y : z)
+      { array_compare.push_back(y->x);
+        array_compare.push_back(y->y);
       }
     }
-    if (inner_array != array_compare) throw;
+    if (inner_array != array_compare) throw std::runtime_error("Wrong INNER results!");
   }
+  delete o;
+}
+
+void Tests::test_b()
+{ std::string chunk =
+//    "0123456789012345"
+      "  XXXXXXXXXXX   "\
+      "  XX       XX   "\
+      "  XX       XX   "\
+      "  XX       XX   "\
+      "  XXXXXXXXXXX   ";
+//        "0123456789012345"
+  /*chunk = "  XXXXXXXXXXX   "\
+          "  XX   XX  XX   "\
+          "  XX   XX  XX   "\
+          "  XX   XX  XX   "\
+          "  XXXXXXXXXXX   ";*/
+
+  std::vector<std::string> arguments = {"--versus=o", "--number_of_tiles=2", "--compress_uniq", "--compress_linear", "--treemap"};
+  ValueNotMatcher matcher(' ');
+  Bitmap b(chunk, 16);
+
+  /*ClippedPolygonFinder pl(&b, &matcher, 0, 16, &arguments);
+  ProcessResult *pr = pl.process_info();
+  pr->print_polygons();
+  delete pr;*/
+
+  Finder concurrentFinder(2, &b, &matcher, &arguments);
+  ProcessResult *pro = concurrentFinder.process_info();
+  pro->print_polygons();
+  delete pro;
+}
+
+void Tests::test_c()
+{ Sequence sequence;
+  Point* p1 = new Point({1, 1});
+  Point* p2 = new Point({2, 2});
+  Point* p3 = new Point({3, 3});
+
+  Hub* hub = new Hub(4, 4);  // coordinate 0 -> 3 sia x che y, matrice di 4 * 4
+
+  Position* pos1 = new Position(hub, p1);
+  Position* pos2 = new Position(hub, p2);
+  Position* pos3 = new Position(hub, p3);
+
+  if (sequence.size != 0) throw std::runtime_error("Wrong initial sequence size");
+  sequence.add(pos1);
+  sequence.add(pos2);
+  sequence.add(pos3);
+  if (sequence.size != 3) throw std::runtime_error("Wrong sequence size");
+
+  // iterator() initially gives head
+  Point* head = sequence.head->payload;
+  if (head != p1) throw std::runtime_error("Wrong head");
+  if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
+  if (sequence.iterator() != pos1) throw std::runtime_error("Wrong iterator to head");
+  // forward!
+  sequence.forward();
+  if (sequence.iterator()->payload != p2) throw std::runtime_error("Wrong iterator to position 2");
+  if (sequence.iterator() != pos2) throw std::runtime_error("Wrong iterator to position 2");
+  // forward!
+  sequence.forward();
+  if (sequence.iterator()->payload != p3) throw std::runtime_error("Wrong iterator to position 3");
+  if (sequence.iterator() != pos3) throw std::runtime_error("Wrong iterator to position 3");
+
+  // forward returns nullptr when no more items are present
+  sequence.forward();
+  if (sequence.iterator() != nullptr) throw std::runtime_error("Wrong iterator to end of list");
+
+  // rewind
+  sequence.rewind();
+  if (sequence.iterator()->payload != p1) throw std::runtime_error("Wrong iterator to head");
+
+  delete p1;
+  delete p2;
+  delete p3;
+
+  delete hub;
+
+  delete pos1;
+  delete pos2;
+  delete pos3;
 }
 
+void Tests::test_d()
+{ CpuTimer cpu_timer;
+  cpu_timer.start();
+  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;
+
+  int color = png_bitmap.value_at(0, 0);
+  std::cout << "color =" << color << std::endl;
+  RGBNotMatcher not_matcher(color);
+
+  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  PolygonFinder pl(&png_bitmap, &not_matcher, nullptr, &arguments);
+  ProcessResult *o = pl.process_info();
+  o->print_info();
+  delete o;
+}
+
+void Tests::test_e()
+{ CpuTimer cpu_timer;
+  cpu_timer.start();
+  FastPngBitmap png_bitmap("images/sample_10240x10240.png");
+  // FastPngBitmap png_bitmap("images/sample_1024x1024.png");
+  std::cout << "immagine =" << cpu_timer.stop() << std::endl;
+
+  int color = png_bitmap.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, &png_bitmap, &not_matcher, &arguments);
+  ProcessResult *o = pl.process_info();
+  o->print_info();
+  delete o;
+}

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

@@ -6,14 +6,15 @@
  *      Copyright 2025 Emanuele Cesaroni
  */
 
-#ifndef TESTS_H_
-#define TESTS_H_
+#pragma once
 
 class Tests {
  public:
   Tests();
   virtual ~Tests();
   virtual void test_a();
+  virtual void test_b();
+  virtual void test_c();
+  virtual void test_d();
+  virtual void test_e();
 };
-
-#endif /* TESTS_H_ */

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

@@ -0,0 +1,44 @@
+/*
+ * CpuTimer.h
+ *
+ *  Created on: 23 nov 2025
+ *      Author: ema
+ *      Copyright 2025 Emanuele Cesaroni
+ */
+
+#pragma once
+#include <chrono>
+
+class CpuTimer {
+  using Clock = std::chrono::steady_clock;
+  std::chrono::time_point<Clock> _start;
+  bool _running = false;
+
+ public:
+  void start() {
+    _start = Clock::now();
+    _running = true;
+  }
+
+  double stop() {
+    if (!_running) return 0.0;
+    auto duration = elapsed_ms();
+    _running = false;
+    return duration;
+  }
+
+  double elapsed_ms() const {
+    if (!_running) return 0.0;
+    auto end = Clock::now();
+    std::chrono::duration<double, std::milli> diff = end - _start;
+    return diff.count();
+  }
+
+  void reset() {
+    _running = false;
+  }
+
+  bool is_running() const {
+    return _running;
+  }
+};