contrek 1.3.5 → 1.3.6

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

@@ -0,0 +1,123 @@
+/*
+ * Options.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 "OptionValue.h"
+#include <initializer_list>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <sstream>
+
+
+class Options {
+ public:
+  using Map = std::map<std::string, OptionValue>;
+  using value_type = Map::value_type;
+  using iterator = Map::iterator;
+  using const_iterator = Map::const_iterator;
+
+  Options() = default;
+
+  Options(std::initializer_list<value_type> values) : values_(values) {}
+
+  OptionValue& operator[](const std::string& key) { return values_[key]; }
+  OptionValue& operator[](std::string&& key) { return values_[std::move(key)]; }
+  OptionValue& at(const std::string& key) { return values_.at(key); }
+  const OptionValue& at(const std::string& key) const { return values_.at(key); }
+  iterator find(const std::string& key) { return values_.find(key); }
+  const_iterator find(const std::string& key) const { return values_.find(key); }
+  iterator begin() { return values_.begin(); }
+  const_iterator begin() const { return values_.begin(); }
+  const_iterator cbegin() const { return values_.cbegin(); }
+  iterator end() { return values_.end(); }
+  const_iterator end() const { return values_.end(); }
+  const_iterator cend() const { return values_.cend(); }
+  bool contains(const std::string& key) const { return values_.find(key) != values_.end();}
+  bool empty() const {return values_.empty();}
+  std::size_t size() const {return values_.size();}
+  void clear() { values_.clear();}
+  std::size_t erase(const std::string& key) { return values_.erase(key);}
+
+
+  std::string to_string(int indent = 0) const {
+    std::ostringstream out;
+    std::string pad(indent, ' ');
+    out << "{";
+    bool first = true;
+    for (const auto& [key, value] : values_) {
+      if (!first) {
+        out << ",";
+      }
+      out << "\n" << pad << "  " << key << ": ";
+      if (value.is_bool()) {
+        out << (value.as_bool() ? "true" : "false");
+      } else if (value.is_integer()) {
+        out << value.as_integer();
+      } else if (value.is_double()) {
+        out << value.as_double();
+      } else if (value.is_string()) {
+        out << "\"" << value.as_string() << "\"";
+      } else if (value.is_identifier()) {
+        out << ":" << value.as_identifier().value;
+      } else if (value.is_options()) {
+        out << value.as_options().to_string(indent + 2);
+      } else {
+        out << "nil";
+      }
+      first = false;
+    }
+    if (!values_.empty()) {
+      out << "\n" << pad;
+    }
+    out << "}";
+    return out.str();
+  }
+
+  template <typename T>
+  T get(const std::string& key, T default_value) const {
+    const auto it = values_.find(key);
+    if (it == values_.end()) {
+      return default_value;
+    }
+    const T* value = it->second.get_if<T>();
+    return value != nullptr ? *value : default_value;
+  }
+
+  const Options* get_options(const std::string& key) const {
+    const auto it = values_.find(key);
+    if (it == values_.end()) {
+      return nullptr;
+    }
+    if (!it->second.is_options()) {
+      return nullptr;
+    }
+    return &it->second.as_options();
+  }
+
+  const Map& values() const {
+    return values_;
+  }
+
+ private:
+  Map values_;
+};
+
+inline OptionValue::OptionValue(const Options& value) : value_(std::make_shared<Options>(value)) {}
+inline OptionValue::OptionValue(Options&& value) : value_(std::make_shared<Options>(std::move(value))) {}
+
+inline const Options& OptionValue::as_options() const {
+  const auto& options = std::get<NestedOptions>(value_);
+  if (!options) {
+    throw std::runtime_error("OptionValue contains null Options");
+  }
+  return *options;
+}

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

@@ -22,7 +22,6 @@
 #include "../matchers/Matcher.h"
 #include "../matchers/RGBMatcher.h"
 #include "../matchers/RGBNotMatcher.h"
-#include "optionparser.h"
 #include "NodeCluster.h"
 #include "Node.h"
 #include "FinderUtils.h"
@@ -30,15 +29,16 @@
 PolygonFinder::PolygonFinder(Bitmap *bitmap,
                              Matcher *matcher,
                              Bitmap *,
-                             std::vector<std::string> *options,
+                             const Options& options,
                              int start_x,
                              int end_x)
     : start_x(start_x),
       end_x(end_x == -1 ? bitmap->w() : end_x),
+      incoming_options_(options),
       source_bitmap(bitmap),
       matcher(matcher)
 { this->rgb_matcher = dynamic_cast<RGBMatcher*>(matcher);
-  if (options != nullptr) FinderUtils::sanitize_options(this->options, options);
+  FinderUtils::sanitize_options(this->options, options);
 
   this->node_cluster = new NodeCluster(source_bitmap->h(), source_bitmap->w(), &this->options);
 
@@ -109,6 +109,7 @@ ProcessResult* PolygonFinder::process_info() {
   pr->height = this->source_bitmap->h();
   pr->has_bounds = this->node_cluster->options->bounds;
   pr->versus = this->options.versus;
+  pr->options = this->incoming_options_;
 
   if (this->node_cluster->options->named_sequences && typeid(*this->source_bitmap) == typeid(Bitmap))
   { std::string sequence;

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

@@ -27,6 +27,7 @@
 #include "Node.h"
 #include "Polygon.h"
 #include "Node.h"
+#include "Options.h"
 #include "../CpuTimer.h"
 
 class Bitmap;
@@ -50,6 +51,7 @@ struct pf_Options {
   bool compress_raster = false;
   bool compress_douglas_peucker = false;
   bool named_sequences = false;
+  bool unsafe_mode = false;
   bool bounds = false;
   int connectivity_offset = 0;
   float compress_visvalingam_tolerance = 10.0;
@@ -57,6 +59,9 @@ struct pf_Options {
   std::string get_alpha_versus() {
     return(versus == Node::A ? "a" : "o");
   }
+  bool any_compression() const {
+    return(compress_linear || compress_uniq || compress_raster || compress_douglas_peucker || compress_visvalingam);
+  }
 };
 
 struct ProcessResult {
@@ -68,21 +73,23 @@ struct ProcessResult {
   std::list<Polygon> polygons;
   std::string named_sequence;
   std::vector<std::pair<int, int>> treemap;
+  Options options;
 
   void draw_on_bitmap(RawBitmap& canvas) const;
 
   void print_polygons() {
     int counter = 0;
     for (const auto& polygon : polygons) {
-      std::cout << counter << " - " << "outer" << "\n";
+      std::cout << "Polygon " << counter << std::endl;
+      std::cout << "outer=";
       for (const Point& p : polygon.outer) std::cout << p.toString();
-      bool first = true;
+      std::cout << std::endl;
       for (const auto& seq : polygon.inner) {
-        if (!first) std::cout << "\n";
-        first = false;
+        std::cout << "inner=";
         for (const Point& p : seq) std::cout << p.toString();
+        std::cout << std::endl;
       }
-      std::cout << "\n" << polygon.bounds.to_string() <<"\n";
+      std::cout << polygon.bounds.to_string() << std::endl;
       counter++;
     }
   }
@@ -150,6 +157,7 @@ class PolygonFinder {
  protected:
   int start_x;
   int end_x;
+  Options incoming_options_;
 
  private:
   Bitmap *source_bitmap;
@@ -262,7 +270,7 @@ class PolygonFinder {
   PolygonFinder(Bitmap *bitmap,
                 Matcher *matcher,
                 Bitmap *test_bitmap,
-                std::vector<std::string> *options = nullptr,
+                const Options& options,
                 int start_x = 0,
                 int end_x = -1);
   ProcessResult* process_info();

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

@@ -10,6 +10,6 @@
 #include <vector>
 #include "ClippedPolygonFinder.h"
 
-ClippedPolygonFinder::ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bitmap_start_x, int bitmap_end_x, std::vector<std::string> *options)
+ClippedPolygonFinder::ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bitmap_start_x, int bitmap_end_x, const Options& options)
 : PolygonFinder(bitmap, matcher, nullptr, options, bitmap_start_x, bitmap_end_x) {
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/ClippedPolygonFinder.h

@@ -11,8 +11,9 @@
 #include <string>
 #include <vector>
 #include "../PolygonFinder.h"
+#include "../Options.h"
 
 class ClippedPolygonFinder : public PolygonFinder {
  public:
-  ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bm_start_x, int bm_end_x, std::vector<std::string>* options = nullptr);
+  ClippedPolygonFinder(Bitmap *bitmap, Matcher *matcher, int bm_start_x, int bm_end_x, const Options& options);
 };

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

@@ -14,7 +14,6 @@
 #include "../../bitmaps/Bitmap.h"
 #include "../../matchers/Matcher.h"
 #include "../../matchers/RGBMatcher.h"
-#include "../optionparser.h"
 #include "../FinderUtils.h"
 #include "ClippedPolygonFinder.h"
 #include "Tile.h"
@@ -22,15 +21,15 @@
 #include "Cluster.h"
 #include "FakeCluster.h"
 
-Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vector<std::string> *options)
+Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Options& options)
 : Poolable(number_of_threads),
   bitmap(bitmap),
   matcher(matcher),
-  input_options(*options),
+  input_options(options),
   maximum_width_(bitmap->w()),
   height(bitmap->h())
 { cpu_timer.start();
-  if (options != nullptr) FinderUtils::sanitize_options(this->options_, options);
+  FinderUtils::sanitize_options(this->options_, options);
 
   double cw = static_cast<double>(this->maximum_width_) / this->options_.number_of_tiles;
   if (cw < 1.0) {
@@ -41,9 +40,17 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
   { int tile_end_x = static_cast<int>(cw * (tile_index + 1));
     TilePayload p { tile_index, x, tile_end_x };
     enqueue(p, [this](const TilePayload& payload) {
-      std::vector<std::string> base_arguments = {"--bounds", "--versus=" + this->options_.get_alpha_versus()};
-      if (this->options_.connectivity_offset == 1) base_arguments.push_back("--connectivity=8");
-      if (this->options_.treemap) base_arguments.push_back("--treemap");
+      Options base_arguments = {
+        {"bounds", true},
+        {"versus", Identifier{this->options_.get_alpha_versus()}},
+      };
+      if (this->options_.connectivity_offset == 1) {
+        base_arguments["connectivity"] = 8;
+      }
+      if (this->options_.treemap) {
+        base_arguments["treemap"] = true;
+      }
+
       CpuTimer t;
       t.start();
       auto* finder = new ClippedPolygonFinder(
@@ -51,7 +58,7 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
         this->matcher,
         payload.tile_start_x,
         payload.tile_end_x,
-        &base_arguments);
+        base_arguments);
       {
         std::lock_guard<std::mutex> lock(finders_mutex);
         finders.push(finder);
@@ -69,9 +76,9 @@ Finder::Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vec
   reports["init"] = cpu_timer.stop();
 }
 
-Finder::Finder(int number_of_threads, std::vector<std::string> *options)
-: Poolable(number_of_threads), bitmap(nullptr), matcher(nullptr), input_options(*options), maximum_width_(0) {
-  if (options != nullptr) FinderUtils::sanitize_options(this->options_, options);
+Finder::Finder(int number_of_threads, const Options& options)
+: Poolable(number_of_threads), bitmap(nullptr), matcher(nullptr), input_options(options), maximum_width_(0) {
+  FinderUtils::sanitize_options(this->options_, options);
   reports["init"] = 0;
 }
 
@@ -140,6 +147,7 @@ ProcessResult* Finder::process_info() {
   pr->height = this->height;
   pr->has_bounds = this->options_.bounds;
   pr->versus = this->options_.versus;
+  pr->options = this->input_options;
   FakeCluster fake_cluster(pr->polygons, this->options_);
   cpu_timer.start();
   fake_cluster.compress_coords(pr->polygons, this->options_);

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

@@ -15,6 +15,7 @@
 #include <vector>
 #include "Poolable.h"
 #include "../PolygonFinder.h"
+#include "../Options.h"
 #include "Queue.h"
 #include "Tile.h"
 
@@ -34,7 +35,7 @@ class Finder : public Poolable {
   Bitmap *bitmap;
   Matcher *matcher;
   pf_Options options_;
-  std::vector<std::string> input_options;
+  Options input_options;
   std::queue<ClippedPolygonFinder*> finders;
   std::mutex finders_mutex;
   std::map<std::string, double> reports;
@@ -49,13 +50,13 @@ class Finder : public Poolable {
 
  public:
   using Poolable::Poolable;
-  Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, std::vector<std::string> *options);
-  Finder(int number_of_threads, std::vector<std::string> *options);
+  Finder(int number_of_threads, Bitmap *bitmap, Matcher *matcher, const Options& options);
+  Finder(int number_of_threads, const Options& options);
   virtual ~Finder();
   int maximum_width() const { return maximum_width_; }
   virtual ProcessResult* process_info();
   const pf_Options& options() const { return options_; }
   Queue<Tile*>& tiles() { return tiles_; }
   virtual bool transpose() const { return false; }
-  int versus;
+  int versus = -1;
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/GeoJsonStreamingMerger.h

@@ -36,13 +36,13 @@ class GeoJsonStreamingMerger : public StreamingMerger {
 
  public:
   GeoJsonStreamingMerger(int number_of_threads,
-                         std::vector<std::string>* options,
+                         const Options& options,
                          std::ofstream* stream_to,
                          unsigned int pixel_value)
       : StreamingMerger(number_of_threads, options, stream_to),
         target_value(pixel_value) {}
 
-  void stream_raw_polygon(const Shape* shape) override {
+  void stream_raw_polygon(const Polygon& polygon) override {
     if (!stream) return;
     if (!is_first_feature) {
       *stream << ",";
@@ -51,7 +51,7 @@ class GeoJsonStreamingMerger : public StreamingMerger {
 
     *stream << "{\"type\":\"Feature\",\"properties\":{\"PixelVal\":" << target_value
             << "},\"geometry\":{\"type\":\"Polygon\",\"coordinates\":[[";
-    const std::vector<Point>& points = shape->outer_polyline->raw();
+    const std::vector<Point>& points = polygon.outer;
     const size_t points_size = points.size();
     if (points_size > 0) {
       for (size_t i = 0; i < points_size; ++i) {
@@ -63,8 +63,7 @@ class GeoJsonStreamingMerger : public StreamingMerger {
       *stream << "]]";
     }
 
-    for (const auto& inner_polyline : shape->inner_polylines) {
-      const std::vector<Point>& inner_points = inner_polyline->raw();
+    for (const std::vector<Point>& inner_points : polygon.inner) {
       const size_t inner_size = inner_points.size();
       if (inner_size > 0) {
         *stream << ",[";

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

@@ -12,7 +12,7 @@
 #include <vector>
 #include "HorizontalMerger.h"
 
-HorizontalMerger::HorizontalMerger(int number_of_threads, std::vector<std::string> *options)
+HorizontalMerger::HorizontalMerger(int number_of_threads, const Options& options)
 : Merger(number_of_threads, options) {
 }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.h

@@ -14,6 +14,6 @@
 
 class HorizontalMerger : public Merger {
  public:
-  HorizontalMerger(int number_of_threads, std::vector<std::string> *options);
+  HorizontalMerger(int number_of_threads, const Options& options);
   void add_tile(ProcessResult& result) override;
 };

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

@@ -12,15 +12,41 @@
 #include <vector>
 #include "Merger.h"
 
-Merger::Merger(int number_of_threads, std::vector<std::string> *options)
+Merger::Merger(int number_of_threads, const Options& options)
 : Finder(number_of_threads, options) {
+  if (!this->safe()) {
+    std::cerr << "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. "
+              << "Incompatible result options might lead to unexpected vector geometry.\n";
+  }
+}
+
+bool Merger::safe() {
+  return(!this->options().unsafe_mode);
 }
 
 void Merger::add_tile(ProcessResult& result)
 { if (this->height == 0) {
     this->height = result.height;
+  } else {
+    if (result.height != this->height && safe()) {
+      throw std::invalid_argument("All results must have the same height");
+    }
   }
-  this->versus = result.versus;
+  if (this->versus == -1) {
+    this->versus = result.versus;
+  } else {
+    if (this->versus != result.versus && safe()) {
+      throw std::invalid_argument("All results must have the same versus option");
+    }
+  }
+  if (const Options* compress = result.options.get_options("compress")) {
+    if (this->safe()) {
+      if (compress->contains("visvalingam") || compress->contains("raster") || compress->contains("douglas_peucker"))
+      { throw std::invalid_argument("Result with not supported postprocessing compression mode");
+      }
+    }
+  }
+
   int end_x = this->current_x + result.width;
   Tile* tile = new Tile(this, this->current_x, end_x, std::to_string(tiles_.size()), Benchmarks {0, 0});
   tile->assign_raw_polygons(result.polygons, result.treemap);

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Merger.h

@@ -11,12 +11,14 @@
 #include <string>
 #include <vector>
 #include "Finder.h"
+#include "../Options.h"
 
 class Merger : public Finder {
  public:
-  Merger(int number_of_threads, std::vector<std::string> *options);
+  Merger(int number_of_threads, const Options& options);
   virtual void add_tile(ProcessResult& result);
   ProcessResult* process_info() override;
+  bool safe();
 
  protected:
   void translate(ProcessResult& result, int offset);

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

@@ -45,3 +45,15 @@ void Shape::set_parent_shape(Shape* shape) {
 std::string Shape::name() {
   return(this->outer_polyline->named());
 }
+
+Polygon Shape::to_raw_polygon(bool bounds) {
+  Polygon poly;
+  poly.outer = this->outer_polyline->raw();
+  if (bounds) {
+    this->outer_polyline->fill_bounds(poly.bounds);
+  }
+  for (auto inner : this->inner_polylines) {
+    poly.inner.push_back(inner->raw());
+  }
+  return(poly);
+}

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Shape.h

@@ -13,6 +13,7 @@
 #include <vector>
 #include <string>
 #include "InnerPolyline.h"
+#include "../Polygon.h"
 
 class Point;
 class Polyline;
@@ -31,6 +32,7 @@ class Shape {
   void set_parent_shape(Shape*);
   std::string name();
   void detach_from_pool();
+  Polygon to_raw_polygon(bool bounds = false);
  private:
   Shape* parent_shape_ = nullptr;
   ShapePool* shape_pool_ = nullptr;

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

@@ -8,13 +8,16 @@
  */
 
 #include "StreamingMerger.h"
+#include "FakeCluster.h"
 #include <sstream>
 #include <algorithm>
 #include <vector>
 #include <string>
+#include <utility>
+#include <list>
 
 StreamingMerger::StreamingMerger(int number_of_threads,
-                                 std::vector<std::string>* options,
+                                 const Options& options,
                                  std::ofstream* stream_to)
   : VerticalMerger(number_of_threads, options), stream(stream_to) {
   if (!stream) {
@@ -45,7 +48,15 @@ void StreamingMerger::stream_polygons(Tile* tile, bool flush) {
       std::remove_if(tile->shapes().begin(), tile->shapes().end(), [this, flush, tile_end_x](Shape* shape) {
         if (flush || shape->outer_polyline->max_x() < (tile_end_x - 1)) {
           this->moved++;
-          this->stream_raw_polygon(shape);
+          Polygon polygon = shape->to_raw_polygon();
+          if (this->options().any_compression()) {
+            std::list<Polygon> polygons;
+            polygons.push_back(polygon);
+            FakeCluster fake_cluster(polygons, this->options());
+            fake_cluster.compress_coords(polygons, this->options());
+            polygon = std::move(polygons.front());
+          }
+          this->stream_raw_polygon(polygon);
           shape->detach_from_pool();
           return true;
         }
@@ -59,20 +70,19 @@ void StreamingMerger::stream_polygons(Tile* tile, bool flush) {
   }
 }
 
-void StreamingMerger::stream_raw_polygon(const Shape* shape) {
+void StreamingMerger::stream_raw_polygon(const Polygon& polygon) {
   std::ostringstream outer_oss;
 
   this->write_outer_polygon_start();
-  const std::vector<Point>& points = shape->outer_polyline->raw();
+  const std::vector<Point>& points = polygon.outer;
   for (size_t i = 0; i < points.size(); ++i) {
     *stream << points[i].y << "," << points[i].x;
     if (i < points.size() - 1) *stream << " ";
   }
   this->write_outer_polygon_end();
 
-  for (const auto& inner_polyline : shape->inner_polylines) {
+  for (const std::vector<Point>& inner_points : polygon.inner) {
     this->write_inner_polygon_start();
-    const std::vector<Point>& inner_points = inner_polyline->raw();
     for (size_t i = 0; i < inner_points.size(); ++i) {
       *stream << inner_points[i].y << "," << inner_points[i].x;
       if (i < inner_points.size() - 1) *stream << " ";

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/StreamingMerger.h

@@ -21,7 +21,7 @@ class StreamingMerger : public VerticalMerger {
   int moved = 0;
 
   void stream_polygons(Tile* tile, bool flush = false);
-  virtual void stream_raw_polygon(const Shape* shape);
+  virtual void stream_raw_polygon(const Polygon& polygon);
   virtual void write_header() = 0;
   virtual void write_footer() = 0;
   virtual void write_outer_polygon_start() = 0;
@@ -33,7 +33,7 @@ class StreamingMerger : public VerticalMerger {
 
  public:
   StreamingMerger(int number_of_threads,
-                  std::vector<std::string>* options,
+                  const Options& options,
                   std::ofstream* stream_to);
   void add_tile(ProcessResult& result, bool flush = false);
   ProcessResult* process_info() override;

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/SvgStreamingMerger.h

@@ -43,7 +43,7 @@ class SvgStreamingMerger : public StreamingMerger {
 
  public:
   SvgStreamingMerger(int number_of_threads,
-                     std::vector<std::string>* options,
+                     const Options& options,
                      std::ofstream* stream_to,
                      int total_width, int total_height)
     : StreamingMerger(number_of_threads, options, stream_to),

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

@@ -110,19 +110,7 @@ std::list<Polygon> Tile::to_raw_polygons()
 { std::list<Polygon> retme;
   bool bounds = this->finder->options().bounds;
   for (Shape* s : shapes_)
-  { if (s->outer_polyline && !s->outer_polyline->is_empty())
-    { Polygon poly;
-      poly.outer = s->outer_polyline->raw();
-      if (bounds) {
-        s->outer_polyline->fill_bounds(poly.bounds);
-      }
-      if (!s->inner_polylines.empty()) {
-        for (auto inner : s->inner_polylines) {
-          poly.inner.push_back(inner->raw());
-        }
-      }
-      retme.push_back(std::move(poly));
-    }
+  { retme.push_back(std::move(s->to_raw_polygon(bounds)));
   }
   return(retme);
 }

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

@@ -14,7 +14,7 @@
 #include <utility>
 #include "VerticalMerger.h"
 
-VerticalMerger::VerticalMerger(int number_of_threads, std::vector<std::string> *options)
+VerticalMerger::VerticalMerger(int number_of_threads, const Options& options)
 : Merger(number_of_threads, options) {
 }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h

@@ -14,7 +14,7 @@
 
 class VerticalMerger : public Merger {
  public:
-  VerticalMerger(int number_of_threads, std::vector<std::string> *options);
+  VerticalMerger(int number_of_threads, const Options& options);
   void add_tile(ProcessResult& result) override;
   ProcessResult* process_info() override;
   bool transpose() const override { return true; };