contrek 1.3.5 → 1.3.6

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -10,6 +10,7 @@
 #include <gperftools/malloc_extension.h>
 #endif
 #include <iostream>
+#include <cstdint>
 #include <list>
 #include <vector>
 #include <map>
@@ -61,6 +62,7 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/Poolable.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/Poolable.cpp"
 #include "PolygonFinder/src/polygon/finder/FinderUtils.h"
+#include "PolygonFinder/src/polygon/finder/Options.h"
 #include "PolygonFinder/src/polygon/finder/FinderUtils.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/ClippedPolygonFinder.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/ClippedPolygonFinder.cpp"
@@ -119,56 +121,94 @@ using namespace Rice;
 namespace Rice::detail {
 
 template<>
-class From_Ruby<std::vector<std::string>*>
+class From_Ruby<Options>
 { public:
   Convertible is_convertible(VALUE value)
   { switch (rb_type(value))
     { case RUBY_T_HASH:
+      case RUBY_T_NIL:
         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);
+  Options convert(VALUE value)
+  { Options options;
+    if (rb_type(value) == RUBY_T_NIL) return(options);
     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());
+          options[keyString.str()] = ((Rice::String) value).str();
           break;
         case T_SYMBOL:
-          arguments->push_back("--" + keyString.str()+"="+((Rice::Symbol) value).str());
+          options[keyString.str()] = ::Identifier(((Rice::Symbol) value).str());
           break;
         case T_FLOAT:
-          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2DBL(value.value())));
+          options[keyString.str()] = NUM2DBL(value.value());
           break;
         case T_FIXNUM:
-          arguments->push_back("--" + keyString.str()+"="+std::to_string(NUM2INT(value.value())));
+        case T_BIGNUM:
+          options[keyString.str()] = static_cast<std::int64_t>(NUM2LL(value.value()));
           break;
         case T_TRUE:
-          arguments->push_back("--" + keyString.str()+"=true");
+          options[keyString.str()] = true;
           break;
         case T_FALSE:
-          arguments->push_back("--" + keyString.str()+"=false");
+          options[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);
-          }
+          options[keyString.str()] = From_Ruby<Options>().convert(value.value());
+          break;
+        case T_NIL:
+          options[keyString.str()] = OptionValue();
+          break;
+        default:
+          rb_raise(rb_eTypeError,
+                   "Unsupported option value type for '%s': %s",
+                   keyString.str().c_str(),
+                   rb_obj_classname(value.value()));
           break;
        }
     }
-    return arguments;
+    return options;
   }
 };
 
+Rice::Object option_value_to_ruby(const OptionValue& option_value);
+Rice::Hash options_to_ruby(const Options& options) {
+  Rice::Hash hash;
+  for (const auto& [key, value] : options.values()) {
+    hash[Rice::Symbol(key)] = option_value_to_ruby(value);
+  }
+  return hash;
+}
+
+Rice::Object option_value_to_ruby(const OptionValue& option_value) {
+  if (option_value.is_bool()) {
+    return Rice::Object(option_value.as_bool() ? Qtrue : Qfalse);
+  }
+  if (option_value.is_integer()) {
+    return Rice::Object(LL2NUM(option_value.as_integer()));
+  }
+  if (option_value.is_double()) {
+    return Rice::Object(DBL2NUM(option_value.as_double()));
+  }
+  if (option_value.is_string()) {
+    return Rice::String(option_value.as_string());
+  }
+  if (option_value.is_identifier()) {
+    return Rice::Symbol(option_value.as_identifier().value);
+  }
+  if (option_value.is_options()) {
+    return options_to_ruby(option_value.as_options());
+  }
+  return Rice::Object(Qnil);
+}
+
 template<>
 class To_Ruby<ProcessResult*>
 {public:
@@ -191,6 +231,7 @@ class To_Ruby<ProcessResult*>
     return_me[Symbol("width")] = pr->width;
     return_me[Symbol("height")] = pr->height;
     return_me[Symbol("versus")] = Symbol(pr->versus == Node::O ? "o" : "a");
+    return_me[Symbol("options")] = options_to_ruby(pr->options);
 
     Rice::Array out;
     for (Polygon& x : pr->polygons)
@@ -257,6 +298,7 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
   pr.width = detail::From_Ruby<int>().convert(metadata[Symbol("width")].value());
   pr.height = detail::From_Ruby<int>().convert(metadata[Symbol("height")].value());
   pr.versus = metadata[Symbol("versus")] == Symbol("o") ? Node::O : Node::A;
+  pr.options = detail::From_Ruby<Options>().convert(metadata[Symbol("options")].value());
 
   Rice::Array rb_polygons = rb_result.iv_get("@polygons_storage");
   for (size_t i = 0; i < rb_polygons.size(); ++i) {
@@ -316,7 +358,7 @@ struct OfstreamWrapper {
 
 SvgStreamingMerger* create_svg_streaming_merger(Object self,
                                          int number_of_threads,
-                                         std::vector<std::string>* options,
+                                         Options options,
                                          Object stream_obj,
                                          int total_width,
                                          int total_height) {
@@ -326,11 +368,11 @@ SvgStreamingMerger* create_svg_streaming_merger(Object self,
 
 GeoJsonStreamingMerger* create_geo_json_streaming_merger(Object self,
                                          int number_of_threads,
-                                         std::vector<std::string>* options,
+                                         Options options,
                                          Object stream_obj,
                                          int pixel_val) {
   OfstreamWrapper* wrapper = Rice::detail::From_Ruby<OfstreamWrapper*>().convert(stream_obj.value());
-  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream(),pixel_val);
+  return new GeoJsonStreamingMerger(number_of_threads, options, &wrapper->get_stream(), pixel_val);
 }
 
 OfstreamWrapper* create_ofstream(Object self, std::string path) {
@@ -409,18 +451,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, Rice::Arg("yield_gvl") = true)
+    .define_constructor(Constructor<PolygonFinder, Bitmap*, Matcher*, Bitmap*, Options>(), Arg("bitmap"), Arg("matcher"), Arg("test_bitmap") = nullptr, Arg("options") = Rice::Hash(), Rice::Arg("yield_gvl") = true)
     .define_method("get_shapelines", &PolygonFinder::get_shapelines)
     .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, Rice::Arg("yield_gvl") = true)
+    .define_constructor(Constructor<Finder, int, Bitmap*, Matcher*, Options>(), Arg("number_of_threads"), Arg("bitmap"), Arg("matcher"), Arg("options") = Rice::Hash(), Rice::Arg("yield_gvl") = true)
     .define_method("process_info", &Finder::process_info, Rice::Arg("yield_gvl") = true);
 
   Data_Type<Merger> rb_cMerger =
     define_class<Merger, Finder>("CPPMerger")
-    .define_constructor(Constructor<Merger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Rice::Arg("yield_gvl") = true)
+    .define_constructor(Constructor<Merger, int, Options>(), Arg("number_of_threads"), Arg("options") = Rice::Hash(), Rice::Arg("yield_gvl") = true)
     .define_method("add_tile", [](Merger& self, Object rb_result) {
       ProcessResult pr = Rice::detail::ruby_result_to_process_result(rb_result);
       self.add_tile(pr);
@@ -429,11 +471,11 @@ void Init_cpp_polygon_finder() {
 
   Data_Type<HorizontalMerger> rb_cHorizontalMerger =
     define_class<HorizontalMerger, Merger>("CPPHorizontalMerger")
-    .define_constructor(Constructor<HorizontalMerger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Arg("yield_gvl") = true);
+    .define_constructor(Constructor<HorizontalMerger, int, Options>(), Arg("number_of_threads"), Arg("options") = Rice::Hash(), Arg("yield_gvl") = true);
 
   Data_Type<VerticalMerger> rb_cVerticalMerger =
     define_class<VerticalMerger, Merger>("CPPVerticalMerger")
-    .define_constructor(Constructor<VerticalMerger, int, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, Arg("yield_gvl") = true)
+    .define_constructor(Constructor<VerticalMerger, int, Options>(), Arg("number_of_threads"), Arg("options") = Rice::Hash(), Arg("yield_gvl") = true)
     .define_method("add_tile", [](VerticalMerger& self, Object rb_result) {
       ProcessResult pr = Rice::detail::ruby_result_to_process_result(rb_result);
       self.add_tile(pr);

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

@@ -76,7 +76,6 @@ module Contrek
 
       def process_info
         raw_polygons = @whole_tile.to_raw_polygons
-
         compress_time = Benchmark.measure do
           if @options.has_key?(:compress)
             FakeCluster.new(raw_polygons, @options).compress_coords
@@ -94,7 +93,8 @@ module Contrek
           }.compact,
           width: @maximum_width,
           height: @height,
-          versus: options[:versus]
+          versus: options[:versus],
+          options: options
         }
         metadata[:treemap] = @whole_tile.compute_treemap if options[:treemap]
         Contrek::Finder::Result.new(raw_polygons, metadata)

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

@@ -17,16 +17,16 @@ module Contrek
         @stream.write("]}")
       end
 
-      def stream_raw_polygon(shape)
+      def stream_raw_polygon(polygon)
         if @first_feature
           @first_feature = false
         else
           @stream.write(",")
         end
-        outer_ring = shape.outer_polyline.raw.map { |p| [p[:y], p[:x]] }
+        outer_ring = polygon[:outer].map { |p| [p[:y], p[:x]] }
         outer_ring << outer_ring.first if outer_ring.first != outer_ring.last
         polygon_coordinates = [outer_ring]
-        shape.inner_polylines.map(&:raw).each do |sequence|
+        polygon[:inner].each do |sequence|
           inner_ring = sequence.map { |p| [p[:y], p[:x]] }
           inner_ring << inner_ring.first if inner_ring.first != inner_ring.last
           polygon_coordinates << inner_ring

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

@@ -11,12 +11,24 @@ module Contrek
         @current_x = 0
         @tiles = Queue.new
         @whole_tile = nil
-        @options = options
+        @user_options = options
+        @options = {unsafe_mode: false}.merge(@user_options)
+        unless safe?
+          warn "[Contrek WARNING] Processing tile with 'unsafe_mode: true'. Incompatible result options might lead to unexpected vector geometry."
+        end
       end
 
       def add_tile(result)
         @height ||= result.metadata[:height]
+        raise ArgumentError, "All results must have the same height" if @height != result.metadata[:height] && safe?
         @options[:versus] ||= result.metadata[:versus]
+        raise ArgumentError, "All results must have the same versus option" if @options[:versus] != result.metadata[:versus] && safe?
+        if safe? && result.metadata[:options].key?(:compress)
+          if (result.metadata[:options][:compress].keys - [:uniq, :linear]).any?
+            raise ArgumentError, "Result with not supported postprocessing compression mode"
+          end
+        end
+
         end_x = @current_x + result.metadata[:width]
 
         tile = Tile.new(
@@ -32,6 +44,10 @@ module Contrek
         @current_x = end_x - 1
       end
 
+      def safe?
+        !@options[:unsafe_mode]
+      end
+
       def process_info
         process_tiles!(nil, height: @height)
         super

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

@@ -39,6 +39,12 @@ module Contrek
       def info
         "Shape (outer_polyline = #{outer_polyline.named}, children count = #{@children_shapes.size}"
       end
+
+      def to_raw_polygon(bounds: false)
+        {bounds: (outer_polyline.get_bounds if bounds),
+         outer: outer_polyline.raw,
+         inner: inner_polylines.map(&:raw)}.compact
+      end
     end
   end
 end

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

@@ -34,7 +34,11 @@ module Contrek
           bounds = shape.outer_polyline.get_bounds
           if flush || bounds[:max_x] < tile.end_x - 1
             @moved += 1
-            stream_raw_polygon(shape)
+            polygon = shape.to_raw_polygon
+            if @options.has_key?(:compress)
+              FakeCluster.new([polygon], @options).compress_coords
+            end
+            stream_raw_polygon(polygon)
             false
           else
             true
@@ -44,10 +48,10 @@ module Contrek
         ensure_footer if flush
       end
 
-      def stream_raw_polygon(shape)
-        outer_pts = shape.outer_polyline.raw.map { |p| "#{p[:y]},#{p[:x]}" }.join(" ")
+      def stream_raw_polygon(polygon)
+        outer_pts = polygon[:outer].map { |p| "#{p[:y]},#{p[:x]}" }.join(" ")
         write_outer_polygon(outer_pts)
-        shape.inner_polylines.map(&:raw).each do |sequence|
+        polygon[:inner].each do |sequence|
           inner_pts = sequence.map { |p| "#{p[:y]},#{p[:x]}" }.join(" ")
           write_inner_polygon(inner_pts)
         end

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

@@ -54,13 +54,8 @@ module Contrek
       end
 
       def to_raw_polygons
-        @shapes.filter_map do |shape|
-          unless shape.outer_polyline.empty?
-            {bounds: (shape.outer_polyline.get_bounds if @finder.options[:bounds]),
-             outer: shape.outer_polyline.raw,
-             inner: shape.inner_polylines.map(&:raw)}.compact
-          end
-        end
+        bounds = @finder.options[:bounds]
+        @shapes.map { |s| s.to_raw_polygon(bounds:) }
       end
 
       def compute_treemap

data/lib/contrek/finder/node_cluster.rb

@@ -33,7 +33,7 @@ module Contrek
           Contrek::Reducers::UniqReducer.new(points: seq).reduce! if @options[:compress].has_key?(:uniq)
           Contrek::Reducers::LinearReducer.new(points: seq, options: @options[:compress][:linear]).reduce! if @options[:compress].has_key?(:linear)
           Contrek::Reducers::RasterReducer.new(points: seq, options: @options).reduce! if @options[:compress].has_key?(:raster)
-          Contrek::Reducers::VisvalingamReducer.new(points: seq, options: @options[:compress][:visvalingam]).reduce! if @options[:compress].has_key?(:visvalingam)
+          Contrek::Reducers::VisvalingamReducer.new(points: seq, options: @options[:compress]).reduce! if @options[:compress].has_key?(:visvalingam)
           Contrek::Reducers::DouglasPeuckerReducer.new(points: seq).reduce! if @options[:compress].has_key?(:douglas_peucker)
         end
       end

data/lib/contrek/finder/polygon_finder.rb

@@ -6,6 +6,7 @@ module Contrek
   module Finder
     class PolygonFinder
       def initialize(bitmap, matcher, test_bitmap = nil, options = {})
+        @ori_options = options
         @options = {versus: :a}.merge(options)
         sanitize_options
         @source_bitmap = bitmap
@@ -52,6 +53,7 @@ module Contrek
           width: @source_bitmap.w,
           height: @source_bitmap.h,
           treemap: (@node_cluster.treemap if @options.has_key?(:treemap)),
+          options: @ori_options,
           versus: @options[:versus]
         }
         Result.new(@node_cluster.polygons, metadata)

data/lib/contrek/reducers/visvalingam_reducer.rb

@@ -8,7 +8,8 @@ module Contrek
     class VisvalingamReducer < Reducer
       def initialize(points: list_of_points, options: {})
         @pts = points
-        @tolerance = options[:tolerance] * options[:tolerance]
+        given_tolerance = options[:visvalingam_tolerance] || 10.0
+        @tolerance = given_tolerance * given_tolerance
       end
 
       def reduce!

data/lib/contrek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Contrek
-  VERSION = "1.3.5"
+  VERSION = "1.3.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contrek
 version: !ruby/object:Gem::Version
-  version: 1.3.5
+  version: 1.3.6
 platform: ruby
 authors:
 - Emanuele Cesaroni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-07-19 00:00:00.000000000 Z
+date: 2026-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -183,6 +183,8 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Node.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/NodeCluster.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/OptionValue.h
+- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Options.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/PointPool.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/PointPool.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/Polygon.h
@@ -239,7 +241,6 @@ files:
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/Tile.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h
-- ext/cpp_polygon_finder/PolygonFinder/src/polygon/finder/optionparser.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.cpp
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/Matcher.h
 - ext/cpp_polygon_finder/PolygonFinder/src/polygon/matchers/RGBMatcher.cpp