contrek 1.3.5 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea7475a8d469db6be267562a802b7b8f09480774e6d3085a35a428f569d2f113
-  data.tar.gz: 20370119576e765342797caad9778b7d808f9b6be154eca4e5a744f988d532f6
+  metadata.gz: 6e79871127e3d6aff04c8bd1e6ea9765d47542249a188b0cf151ce8a005ea29a
+  data.tar.gz: '055817b3638fcf582584e45e0ffef001305961321f8a05beb5998399b0be7bc6'
 SHA512:
-  metadata.gz: b09fddc2bc46bb644f3024de98aa2db5155856981aaf3ce3a5dfaf5a8ef5449f36ad4fb784654bb12368fc8d2b2c0741a492c1f70ec4e620b4282d28268d770e
-  data.tar.gz: 6240cd18e6145a3f47504decfab3d74decce51c0ddc91084d7ac7cf95e020cc7165bfca4d8d7831c760ca3ee3aaa63ae3b50fa1c75b5ed60ed13ae87544b9d36
+  metadata.gz: e3007307485a1ce6902f4f95b452b3ef2622fd2c59a0a27d8ee2564e0d8b512bdf8acc15ad5fac30b472b8d14263800324ac19ad74932eb220366860ad7ec60b
+  data.tar.gz: 38289075bb92eb56229f1206ff595a0ea65d6bcbbf271dcdc035d60ef8b1c7609cbae687367803ff3d2cb39eae9f8fe670fb893afdcff87df77d8c0ce7b1c928

data/CHANGELOG.md

@@ -138,3 +138,9 @@ All notable changes to this project will be documented in this file.
 
 ## [1.3.4] - 2026-07-19
 - Refactored core topology from a top-left point model to a 4-vertex pixel-cell model, natively eliminating diagonal ambiguities and rewriting part of the stripe-merging algorithm to ensure perfect geometric stitching on shared nodes. Removed Strict Bounds mode. Added a Douglas-Peucker and a custom raster-compression algorithm that shifts top/right pixel boundaries by 1px to ensure flawless surface rendering as bitmap image.
+
+## [1.3.6] - 2026-07-26
+- Removed optionparser.h and the legacy options argument mechanism, replacing them with the new OptionValue.h and Options.h
+- Added polygon compression to the progressive streaming pipeline (StreamingMerger).
+- Added strict validation in progressive streaming. Results passed to add_tile() are now validated to ensure they contain compatible settings (such as versus conventions and compression options).
+- Added unsafe_mode flag to streaming mergers. This allows bypassing compatibility checks when using custom or arbitrary input data.

data/Gemfile.lock

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

data/README.md

@@ -128,7 +128,7 @@ rgb_matcher = CPPRGBNotMatcher.new(png_bitmap.rgb_value_at(0, 0))
 polygonfinder = CPPPolygonFinder.new(png_bitmap,
   rgb_matcher,
   nil,
-  {versus: :a, compress: {visvalingam: {tolerance: 1.5}}})
+  {versus: :a, compress: {visvalingam: true, visvalingam_tolerance: 1.5}})
 result = polygonfinder.process_info
 # draws the polygons found
 Contrek::Bitmaps::Painting.direct_draw_polygons(result.points, png_image)
@@ -312,8 +312,11 @@ result.metadata
                "total"=>0.05208},
  :groups=>1,
  :named_sequence=>"AFEDCBA",
- :treemap=>[]}
+ :treemap=>[],
+ :options=>{versus: :a, compress: {visvalingam: true, visvalingam_tolerance: 1.5}}
+}
 ```
+The options are the original options passed by user.
 
 ## Treemap
 

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

@@ -8,17 +8,16 @@
  */
 
 #pragma once
-
 #include <string>
 #include <vector>
 #include <memory>
 #include <cstdint>
 #include <string_view>
-
 #include "Finder.h"
 #include "FastPngBitmap.h"
 #include "RGBNotMatcher.h"
 #include "RGBMatcher.h"
+#include "Options.h"
 
 namespace Contrek {
 
@@ -49,7 +48,7 @@ struct Config {
 struct TraceContext {
   std::unique_ptr<FastPngBitmap> bitmap;
   std::unique_ptr<Matcher> matcher;
-  std::vector<std::string> internal_args;
+  Options internal_args;
   std::unique_ptr<Finder> finder;
   std::unique_ptr<ProcessResult> result;
 
@@ -82,23 +81,20 @@ inline TraceContext trace(const std::string& image_path, const Config& cfg = Con
     ctx.matcher = std::make_unique<RGBMatcher>(color_to_match);
   }
 
-  ctx.internal_args = {"--versus=a"};
-
-  struct Mapping { bool flag; std::string_view arg; };
-  const Mapping mappings[] = {
-    {cfg.compress_unique,      "--compress_uniq"},
-    {cfg.compress_linear,      "--compress_linear"},
-    {cfg.compress_visvalingam, "--compress_visvalingam"},
-    {cfg.treemap,              "--treemap"}
+  ctx.internal_args = {
+    {"versus", Identifier{"a"}},
   };
-  for (const auto& m : mappings) {
-    if (m.flag) ctx.internal_args.emplace_back(m.arg);
-  }
-  ctx.internal_args.push_back("--number_of_tiles=" + std::to_string(cfg.tiles));
+  Options compression_opts;
+
+  if (cfg.compress_unique) compression_opts["uniq"] = true;
+  if (cfg.compress_linear) compression_opts["linear"] = true;
+  if (cfg.compress_visvalingam) compression_opts["visvalingam"] = true;
+  if (cfg.compress_unique || cfg.compress_linear || cfg.compress_visvalingam) ctx.internal_args["compression"] = compression_opts;
+  ctx.internal_args["number_of_tiles"] = cfg.tiles;
   if (cfg.connectivity_mode == Connectivity::OMNIDIRECTIONAL) {
-    ctx.internal_args.push_back("--connectivity=" + std::to_string(8));
+    ctx.internal_args["connectivity"] = 8;
   }
-  ctx.finder = std::make_unique<Finder>(cfg.threads, ctx.bitmap.get(), ctx.matcher.get(), &ctx.internal_args);
+  ctx.finder = std::make_unique<Finder>(cfg.threads, ctx.bitmap.get(), ctx.matcher.get(), ctx.internal_args);
   ctx.result = std::unique_ptr<ProcessResult>(ctx.finder->process_info());
 
   return ctx;

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

@@ -32,7 +32,7 @@
 #include "polygon/matchers/RGBMatcher.h"
 #include "polygon/matchers/RGBNotMatcher.h"
 #include "polygon/matchers/ValueNotMatcher.h"
-#include "polygon/finder/optionparser.h"
+#include "polygon/finder/Options.h"
 #include "polygon/finder/concurrent/Finder.h"
 #include "polygon/finder/concurrent/HorizontalMerger.h"
 #include "polygon/finder/concurrent/VerticalMerger.h"
@@ -53,14 +53,22 @@ void Tests::test_a()
       "000000DDDDDD0000"\
       "0000000000000000";
 
-  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--treemap"};
+  Options options = {
+    {"versus", Identifier{"a"}},
+    {"compress", Options{
+      {"uniq", true},
+      {"linear", true},
+    }},
+    {"treemap", true}
+  };
+
   ValueNotMatcher matcher('0');
   Bitmap b(chunk, 16);
-  PolygonFinder pl(&b, &matcher, nullptr, &arguments);
+  PolygonFinder pl(&b, &matcher, nullptr, options);
   ProcessResult *o = pl.process_info();
   // o->print_polygons();
-  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> outer_array{11, 1, 11, 2, 6, 2, 6, 6, 12, 6, 12, 1 };
+  std::vector<int> inner_array{8, 3, 10, 3, 10, 5, 8, 5, 8, 4};
   std::vector<int> array_compare;
 
   for (const auto& x : o->polygons)
@@ -90,10 +98,19 @@ void Tests::test_b()
       "  XX       XX   "\
       "  XXXXXXXXXXX   ";
 
-  std::vector<std::string> arguments = {"--versus=o", "--number_of_tiles=2", "--compress_uniq", "--compress_linear", "--treemap"};
+  Options options = {
+    {"versus", Identifier{"o"}},
+    {"number_of_tiles",2},
+    {"compress", Options{
+      {"uniq", true},
+      {"linear", true},
+    }},
+    {"treemap", true}
+  };
+
   ValueNotMatcher matcher(' ');
   Bitmap b(chunk, 16);
-  Finder concurrentFinder(2, &b, &matcher, &arguments);
+  Finder concurrentFinder(2, &b, &matcher, options);
   ProcessResult *pro = concurrentFinder.process_info();
   pro->print_polygons();
   delete pro;
@@ -152,14 +169,21 @@ 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 << "image reading time =" << 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;
+  std::cout << "color = " << color << std::endl;
   RGBNotMatcher not_matcher(color);
 
-  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq", "--treemap"};
-  PolygonFinder pl(&png_bitmap, &not_matcher, nullptr, &arguments);
+  Options options = {
+    {"versus", Identifier{"a"}},
+    {"compress", Options{
+      {"uniq", true},
+    }},
+    {"treemap", true}
+  };
+
+  PolygonFinder pl(&png_bitmap, &not_matcher, nullptr, options);
   ProcessResult *o = pl.process_info();
   o->print_info();
   delete o;
@@ -176,8 +200,14 @@ void Tests::test_e()
   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);
+  Options options = {
+    {"versus", Identifier{"a"}},
+    {"number_of_tiles",2},
+    {"compress", Options{
+      {"uniq", true},
+    }},
+  };
+  Finder pl(2, &png_bitmap, &not_matcher, options);
   ProcessResult *o = pl.process_info();
   o->print_info();
   std::cout << "polygons = " << o->groups << std::endl;
@@ -211,8 +241,14 @@ void Tests::test_g()
   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);
+  Options options = {
+    {"versus", Identifier{"a"}},
+    {"number_of_tiles",2},
+    {"compress", Options{
+      {"uniq", true},
+    }},
+  };
+  Finder pl(2, &raw_bitmap, &not_matcher, options);
   ProcessResult *o = pl.process_info();
   // o->print_info();
   // o->print_polygons();
@@ -231,10 +267,15 @@ void Tests::test_h()
               "00        " \
               "0000000000" \
               "0000000000";
-  std::vector<std::string> arguments = {"--versus=a", "--compress_uniq"};
+  Options options = {
+    {"versus", Identifier{"a"}},
+    {"compress", Options{
+      {"uniq", true},
+    }},
+  };
   ValueNotMatcher matcher(' ');
   Bitmap b_left(left, 10);
-  PolygonFinder pl_left(&b_left, &matcher, nullptr, &arguments);
+  PolygonFinder pl_left(&b_left, &matcher, nullptr, options);
   ProcessResult *left_result = pl_left.process_info();
 
   std::string right =
@@ -248,11 +289,11 @@ void Tests::test_h()
               "0000000000" \
               "0000000000";
   Bitmap b_right(right, 10);
-  PolygonFinder pl_right(&b_right, &matcher, nullptr, &arguments);
+  PolygonFinder pl_right(&b_right, &matcher, nullptr, options);
   ProcessResult *right_result = pl_right.process_info();
 
-  std::vector<std::string> merger_arguments = {};
-  HorizontalMerger hmerger(1, &arguments);
+  Options merger_options = {};
+  HorizontalMerger hmerger(1, merger_options);
   hmerger.add_tile(*left_result);
   hmerger.add_tile(*right_result);
   ProcessResult *merged_result = hmerger.process_info();
@@ -282,8 +323,8 @@ double get_peak_rss() {
 */
 void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool generate_svg = false, bool generate_png = false) {
     std::vector<ProcessResult*> result_clones;
-    std::vector<std::string> varguments = {};
-    VerticalMerger vmerger(0, &varguments);
+    Options options = {};
+    VerticalMerger vmerger(0, options);
 
     // opens image to stream
     FILE* fp = fopen(filepath.c_str(), "rb");
@@ -340,10 +381,10 @@ void stream_png_image(const std::string& filepath, uint32_t stripe_height, bool
         if (ret != 0 && ret != SPNG_EOI) break;
       }
       // stripe contour tracing
-      std::vector<std::string> finder_arguments = {
-        "--versus=a",
+      Options options = {
+        {"versus", Identifier{"a"}},
       };
-      PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
+      PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, options);
       ProcessResult *result = polygon_finder.process_info();
       if (result) {
         std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;
@@ -400,7 +441,9 @@ double get_current_rss_mb() {
 
 void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_height) {
     std::vector<ProcessResult*> result_clones;
-    std::vector<std::string> varguments = {"--bounds"};
+    Options voptions = {
+        {"bounds", true},
+      };
     // opens image to stream
     FILE* fp = fopen(filepath.c_str(), "rb");
     if (!fp) {
@@ -439,7 +482,7 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
     std::vector<char> buffer(4 * 1024 * 1024);  // Buffer (4MB)
     shared_stream.rdbuf()->pubsetbuf(buffer.data(), buffer.size());
 
-    SvgStreamingMerger vmerger(0, &varguments, &shared_stream, total_width, total_height);
+    SvgStreamingMerger vmerger(0, voptions, &shared_stream, total_width, total_height);
     // GeoJsonStreamingMerger vmerger(0, &varguments, &shared_stream, 4294901760);
     try {
       size_t row_size = static_cast<size_t>(total_width) * 4;
@@ -466,14 +509,16 @@ void stream_progressive_png_image(const std::string& filepath, uint32_t stripe_h
           if (ret != 0 && ret != SPNG_EOI) break;
         }
         // stripe contour tracing
-        std::vector<std::string> finder_arguments = {
-          "--versus=a",
-          "--bounds",
-          "--compress_uniq",
-          "--compress_linear"
+        Options options = {
+          {"versus", Identifier{"a"}},
+          {"bounds", true},
+          {"compress", Options{
+            {"uniq", true},
+            {"linear", true},
+          }},
         };
 
-        PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, &finder_arguments);
+        PolygonFinder polygon_finder(&stripe_bitmap, &not_matcher, nullptr, options);
         ProcessResult *result = polygon_finder.process_info();
         if (result) {
           std::cout << "stripe " << stripe_count << ": found polygons " << result->groups << std::endl;

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

@@ -9,118 +9,48 @@
 
 #include <iostream>
 #include <string>
-#include <vector>
+#include <algorithm>
 #include "PolygonFinder.h"
 #include "FinderUtils.h"
-#include "optionparser.h"
 
-void FinderUtils::sanitize_options(pf_Options& options, std::vector<std::string> *incoming_options) {
-  std::vector<char*> argv0;
-  for (const auto& arg : *incoming_options)
-  argv0.push_back(const_cast<char*>(arg.data()));
-  argv0.push_back(nullptr);
-  char** argv = &argv0[0];
-  int argc = argv0.size() -1;
+void FinderUtils::sanitize_options(pf_Options& options, const Options& incoming_options) {
+  const Identifier versus = incoming_options.get<Identifier>("versus", options.versus == Node::A ? "a" : "o");
+  options.versus = versus == "a" ? Node::A : Node::O;
+  options.number_of_tiles = std::max(1, static_cast<int>(incoming_options.get<std::int64_t>(
+    "number_of_tiles",
+    options.number_of_tiles)));
+  options.connectivity_offset = incoming_options.get<std::int64_t>(
+    "connectivity",
+    options.connectivity_offset == 1 ? 8 : 4) == 8;
+  options.treemap = incoming_options.get<bool>("treemap", options.treemap);
+  options.named_sequences = incoming_options.get<bool>(
+    "named_sequences",
+    options.named_sequences);
+  options.bounds = incoming_options.get<bool>("bounds", options.bounds);
+  options.unsafe_mode = incoming_options.get<bool>("unsafe_mode", options.unsafe_mode);
 
-  enum  optionIndex { COMPRESS_UNIQ, VERSUS, COMPRESS_VISVALINGAM, COMPRESS_LINEAR, NUMBER_OF_TILES,
-                      COMPRESS_VISVALINGAM_TOLERANCE, TREEMAP, NAMED_SEQUENCES, BOUNDS, CONNECTIVITY,
-                      COMPRESS_RASTER, COMPRESS_DOUGLAS_PEUCKER };
-  const option::Descriptor usage[] = {
-     //  {UNKNOWN, 0,"" , ""    ,option::Arg::None, 0},
-     {COMPRESS_VISVALINGAM, 0, "" , "compress_visvalingam", option::Arg::None, 0},
-     {COMPRESS_LINEAR, 0, "" , "compress_linear", option::Arg::None, 0},
-     {COMPRESS_VISVALINGAM_TOLERANCE, 0, "" , "compress_visvalingam_tolerance", option::Arg::Optional, 0},
-     {COMPRESS_UNIQ, 0, "", "compress_uniq", option::Arg::None, 0},
-     {COMPRESS_RASTER, 0, "", "compress_raster", option::Arg::None, 0},
-     {COMPRESS_DOUGLAS_PEUCKER, 0, "", "compress_douglas_peucker", option::Arg::None, 0},
-     {NUMBER_OF_TILES, 0, "", "number_of_tiles", option::Arg::Optional, 0},
-     {TREEMAP, 0, "", "treemap", option::Arg::None, 0},
-     {NAMED_SEQUENCES, 0, "", "named_sequences", option::Arg::None, 0},
-     {BOUNDS, 0, "", "bounds", option::Arg::None, 0},
-     {VERSUS, 0, "v", "versus", option::Arg::Optional, 0},
-     {CONNECTIVITY, 0, "c", "connectivity", option::Arg::Optional, 0},
-     {0, 0, 0, 0, 0, 0}
-  };
-
-  option::Stats  stats(usage, argc, argv);
-  option::Option ioptions[stats.options_max], buffer[stats.buffer_max];
-  option::Parser parse(usage, argc, argv, ioptions, buffer);
-
-  if (parse.error())  return;
-  // VERSUS
-  if (ioptions[VERSUS].count() > 0)
-  { for (option::Option* opt = ioptions[VERSUS]; opt; opt = opt->next())
-    { std::string opts = opt->arg;
-      options.versus = (opts.compare("a") == 0 ? Node::A : Node::O);
-      break;
-    }
-  }
-  // COMPRESS UNIQ
-  if (ioptions[COMPRESS_UNIQ].count() > 0)
-  { options.compress_uniq = true;
-  }
-  // NUMBER_OF_TILES
-  if (ioptions[NUMBER_OF_TILES].count() > 0)
-  { try {
-      options.number_of_tiles = std::stoi(ioptions[NUMBER_OF_TILES].arg);
-      if (options.number_of_tiles <= 0) options.number_of_tiles = 1;
+  if (const Options* compress = incoming_options.get_options("compress")) {
+    options.compress_uniq = compress->get<bool>("uniq", options.compress_uniq);
+    options.compress_linear = compress->get<bool>("linear", options.compress_linear);
+    options.compress_raster = compress->get<bool>("raster", options.compress_raster);
+    options.compress_douglas_peucker = compress->get<bool>("douglas_peucker", options.compress_douglas_peucker);
+    options.compress_visvalingam = compress->get<bool>("visvalingam", options.compress_visvalingam);
+    if (compress->contains("visvalingam_tolerance")) {
+      options.compress_visvalingam = true;
+      options.compress_visvalingam_tolerance = static_cast<float>(compress->get<double>(
+        "visvalingam_tolerance",
+        options.compress_visvalingam_tolerance));
     }
-    catch (const std::invalid_argument&) {
-      std::cerr << "Errore: --number_of_tiles requires a number\n";
-    }
-  }
-  // CONNECTIVITY
-  if (ioptions[CONNECTIVITY].count() > 0)
-  { try {
-      if (std::stoi(ioptions[CONNECTIVITY].arg) == 8) options.connectivity_offset = 1;
-    }
-    catch (const std::invalid_argument&) {
-      std::cerr << "Errore: --connectivity requires a number\n";
-    }
-  }
-  // TREEMAP
-  if (ioptions[TREEMAP].count() > 0)
-  { options.treemap = true;
   }
-  // NAMED_SEQUENCES
-  if (ioptions[NAMED_SEQUENCES].count() > 0)
-  { options.named_sequences = true;
-  }
-  // BOUNDS
-  if (ioptions[BOUNDS].count() > 0)
-  { options.bounds = true;
-  }
-  // COMPRESS LINEAR
-  if (ioptions[COMPRESS_LINEAR].count() > 0)
-  { options.compress_linear = true;
-  }
-  // COMPRESS UNIQ
-  if (ioptions[COMPRESS_VISVALINGAM].count() > 0)
-  { options.compress_visvalingam = true;
-  }
-  if (ioptions[COMPRESS_VISVALINGAM_TOLERANCE].count() > 0)
-  { options.compress_visvalingam = true;
-    for (option::Option* opt = ioptions[COMPRESS_VISVALINGAM_TOLERANCE]; opt; opt = opt->next())
-    { std::string opts = opt->arg;
-      options.compress_visvalingam_tolerance = strtof(opt->arg, 0);
-      break;
-    }
-  }
-  // COMPRESS RASTER
-  if (ioptions[COMPRESS_RASTER].count() > 0)
-  { options.compress_raster = true;
-  }
-  // COMPRESS DOUGLAS PEUCKER
-  if (ioptions[COMPRESS_DOUGLAS_PEUCKER].count() > 0)
-  { options.compress_douglas_peucker = true;
-  }
-  /* std::cout << "-----------" << std::endl;
+
+/*std::cout << "-----------" << std::endl;
   std::cout << "versus " << options.versus << std::endl;
   std::cout << "bounds " << options.bounds << std::endl;
   std::cout << "number_of_tiles " << options.number_of_tiles << std::endl;
   std::cout << "uniq " << options.compress_uniq << std::endl;
   std::cout << "linear " << options.compress_linear << std::endl;
+  std::cout << "treemap " << options.treemap << std::endl;
   std::cout << "visvalingam " << options.compress_visvalingam << std::endl;
-  std::cout << "visvalingam tolernace " << options.compress_visvalingam_tolerance << std::endl;
+  std::cout << "visvalingam tolerance " << options.compress_visvalingam_tolerance << std::endl;
   std::cout << "-----------" << std::endl; */
 }

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

@@ -10,8 +10,9 @@
 #pragma once
 #include <string>
 #include <vector>
+#include "Options.h"
 
 class FinderUtils {
  public:
-  static void sanitize_options(pf_Options& options, std::vector<std::string> *incoming_options);
+  static void sanitize_options(pf_Options& options, const Options& incoming_options);
 };

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

@@ -43,8 +43,7 @@ NodeCluster::~NodeCluster() {
 }
 
 void NodeCluster::compress_coords(std::list<Polygon>& polygons, pf_Options options) {
-  if (!(options.compress_linear || options.compress_uniq || options.compress_raster ||
-        options.compress_douglas_peucker || options.compress_visvalingam)) return;
+  if (!(options.any_compression())) return;
 
   auto compress_sequence = [&](std::vector<Point>& points_vec) {
     if (points_vec.empty()) return;

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

@@ -0,0 +1,91 @@
+/*
+ * OptionValue.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.
+ */
+
+#pragma once
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+
+class Options;
+
+struct Identifier {
+  std::string value;
+  Identifier() = default;
+  Identifier(const char* v) : value(v) {}
+  Identifier(std::string v) : value(std::move(v)) {}
+  bool operator==(const Identifier& other) const {
+    return value == other.value;
+  }
+  bool operator!=(const Identifier& other) const {
+    return value != other.value;
+  }
+};
+
+class OptionValue {
+ public:
+  using NestedOptions = std::shared_ptr<Options>;
+
+  using Value = std::variant<
+    std::monostate,
+    bool,
+    std::int64_t,
+    double,
+    std::string,
+    Identifier,
+    NestedOptions>;
+
+  OptionValue() = default;
+  OptionValue(bool value) : value_(value) {}
+  OptionValue(int value) : value_(static_cast<std::int64_t>(value)) {}
+  OptionValue(std::int64_t value) : value_(value) {}
+  OptionValue(double value) : value_(value) {}
+  OptionValue(const char* value) : value_(std::string(value)) {}
+  OptionValue(std::string value) : value_(std::move(value)) {}
+  OptionValue(Identifier value) : value_(std::move(value)) {}
+  OptionValue(const Options& value);
+  OptionValue(Options&& value);
+  bool is_bool() const { return std::holds_alternative<bool>(value_); }
+  bool is_integer() const { return std::holds_alternative<std::int64_t>(value_); }
+  bool is_double() const {return std::holds_alternative<double>(value_);}
+  bool is_string() const { return std::holds_alternative<std::string>(value_); }
+  bool is_options() const { return std::holds_alternative<NestedOptions>(value_); }
+  bool is_identifier() const { return std::holds_alternative<Identifier>(value_); }
+  bool as_bool() const { return std::get<bool>(value_); }
+  std::int64_t as_integer() const { return std::get<std::int64_t>(value_); }
+  double as_double() const { return std::get<double>(value_); }
+  const std::string& as_string() const { return std::get<std::string>(value_); }
+  std::string& as_string() { return std::get<std::string>(value_); }
+  const Options& as_options() const;
+  Options& as_options();
+  const Identifier& as_identifier() const { return std::get<Identifier>(value_); }
+  Identifier& as_identifier() { return std::get<Identifier>(value_);}
+
+  template <typename T>
+  bool is() const { return std::holds_alternative<T>(value_); }
+
+  template <typename T>
+  const T& as() const { return std::get<T>(value_); }
+
+  template <typename T>
+  T& as() { return std::get<T>(value_);}
+
+  template <typename T>
+  const T* get_if() const { return std::get_if<T>(&value_); }
+
+  template <typename T>
+  T* get_if() {return std::get_if<T>(&value_); }
+
+  const Value& value() const { return value_; }
+  Value& value() {return value_;}
+
+ private:
+  Value value_;
+};