contrek 1.3.1 → 1.3.3

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

@@ -11,36 +11,18 @@
 #include <vector>
 #include "InnerPolyline.h"
 
-InnerPolyline::InnerPolyline(std::vector<Point> raw_coordinates, Shape* shape)
-  : raw_coordinates_(std::move(raw_coordinates)),
-    shape_(shape) {}
-InnerPolyline::InnerPolyline(Sequence* sequence)
-  : sequence_(sequence) {
+InnerPolyline::InnerPolyline(ShapePool* shape_pool, std::vector<Point> raw_coordinates, Shape* shape)
+  : shape(shape),
+    shape_pool(shape_pool),
+    raw_coordinates_(std::move(raw_coordinates)) {}
+InnerPolyline::InnerPolyline(ShapePool* shape_pool, Sequence* sequence)
+  : shape_pool(shape_pool) {
   this->raw_coordinates_ = sequence->to_vector();
+  this->shape = sequence->shape;
 }
 
-std::vector<Point>& InnerPolyline::raw() {
-  return this->raw_coordinates_;
-}
-
-Bounds& InnerPolyline::vertical_bounds() {
-  if (sequence_ != nullptr) {
-    return(sequence_->vertical_bounds);
-  } else {
-    return(this->raw_vertical_bounds());
-  }
-}
-
-Shape* InnerPolyline::shape() {
-  if (sequence_ != nullptr) {
-    return(sequence_->shape);
-  } else {
-    return(this->shape_ ? this->shape_ : this->assigned_shape);
-  }
-}
-
-Bounds& InnerPolyline::raw_vertical_bounds() {
-  if (!raw_coordinates_.empty()) {
+void InnerPolyline::compute_vertical_bounds()
+{ if (!raw_coordinates_.empty()) {
     int min_y = raw_coordinates_[0].y;
     int max_y = raw_coordinates_[0].y;
     for (const auto& pos : raw_coordinates_) {
@@ -50,5 +32,4 @@ Bounds& InnerPolyline::raw_vertical_bounds() {
     vertical_bounds_.min = min_y;
     vertical_bounds_.max = max_y;
   }
-  return(vertical_bounds_);
 }

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

@@ -12,19 +12,18 @@
 #include <optional>
 #include "Sequence.h"
 
+class ShapePool;
 class InnerPolyline {
  public:
-  explicit InnerPolyline(std::vector<Point> raw_coordinates, Shape* shape);
-  explicit InnerPolyline(Sequence* sequence);
-  std::vector<Point>& raw();
-  Sequence* sequence() { return this->sequence_; }
-  Bounds& vertical_bounds();
-  Shape* shape();
-  Shape* assigned_shape = nullptr;
+  explicit InnerPolyline(ShapePool* shape_pool, std::vector<Point> raw_coordinates, Shape* shape);
+  explicit InnerPolyline(ShapePool* shape_pool, Sequence* sequence);
+  std::vector<Point>& raw() { return this->raw_coordinates_; }
+  Bounds& vertical_bounds() { return this->vertical_bounds_; }
+  Shape* shape = nullptr;
+  ShapePool* shape_pool = nullptr;
+  void compute_vertical_bounds();
+
  private:
   std::vector<Point> raw_coordinates_;
-  Sequence* sequence_ = nullptr;
-  Shape* shape_;
-  Bounds& raw_vertical_bounds();
-  Bounds vertical_bounds_;
+  Bounds vertical_bounds_{0, 0};
 };

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

@@ -35,6 +35,11 @@ class Part : public Queueable<Point> {
   bool transmutation_skip = false;
   bool dead_end = false;
   bool mirror = false;
+
+ private:
+  bool touched_ = false;
+
+ public:
   Part* next = nullptr;
   Part* next_seam = nullptr;
   Part* prev = nullptr;
@@ -45,8 +50,8 @@ class Part : public Queueable<Point> {
   void add_position(const Point& point);
   Types type;
   bool innerable();
-  const bool touched() const { return touched_; }
-  const int versus() const { return versus_; }
+  bool touched() const { return touched_; }
+  int versus() const { return versus_; }
   void touch();
   void orient();
   std::string inspect();
@@ -57,6 +62,5 @@ class Part : public Queueable<Point> {
 
  private:
   int versus_ = 0;
-  bool touched_ = false;
   Polyline* polyline_;
 };

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

@@ -17,9 +17,10 @@
 #include "Tile.h"
 #include "Shape.h"
 
-Polyline::Polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds)
-: raw_(std::move(polygon)),
-  tile(tile)
+Polyline::Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds)
+: tile(tile),
+  shape_pool(shape_pool),
+  raw_(std::move(polygon))
 { if (bounds.has_value()) {
     min_x =  bounds->min_x;
     max_x_ = bounds->max_x;

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

@@ -22,13 +22,14 @@
 
 class Tile;
 class Shape;
+class ShapePool;
 class Point;
 class InnerPolyline;
 
 class Polyline : public Partitionable {
  public:
   using Partitionable::Partitionable;
-  Polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt);
+  Polyline(ShapePool* shape_pool, Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt);
   enum Flags : uint32_t {
     TRACKED_OUTER = 1 << 0
   };
@@ -39,12 +40,13 @@ class Polyline : public Partitionable {
   void precalc();
   int width();
   Tile *tile = nullptr;
+  ShapePool* shape_pool = nullptr;
   Shape* shape = nullptr;
   const std::vector<Point>& raw() const { return raw_; }
   const std::vector<Part*>& parts() const { return parts_; }
-  const int max_y() const { return max_y_; }
-  const int min_y() const { return min_y_; }
-  const int max_x() const { return max_x_; }
+  int max_y() const { return max_y_; }
+  int min_y() const { return min_y_; }
+  int max_x() const { return max_x_; }
   void clear();
   bool is_empty();
   bool any_ancients = false;
@@ -60,6 +62,6 @@ class Polyline : public Partitionable {
   int min_x, max_x_, min_y_, max_y_;
   void find_boundary();
   uint32_t flags_ = 0;
-  std::string named_;
   int name;
+  std::string named_;
 };

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

@@ -32,7 +32,7 @@ Position::Position(EndPoint* end_point)
 {  this->end_point_ = end_point;
 }
 
-void Position::before_rem(Queueable<Point>* q)  {
+void Position::before_rem(Queueable<Point>*)  {
   /*if (this->end_point_ != nullptr)
   { if (q->listable())
     { auto& v = this->end_point_->queues();

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

@@ -26,8 +26,8 @@ class QNode {
   Queueable<T>* owner {nullptr};
   explicit QNode(const T& value) : payload(value) {}
   virtual ~QNode() = default;
-  virtual void before_rem(Queueable<T>* q) {}
-  virtual void after_add(Queueable<T>* q) {}
+  virtual void before_rem(Queueable<T>*) {}
+  virtual void after_add(Queueable<T>*) {}
 };
 
 

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

@@ -34,17 +34,3 @@ bool Sequence::is_not_vertical()
   }
   return false;
 }
-
-void Sequence::compute_vertical_bounds()
-{ const auto& cache = get_vector_cache();
-  if (!cache.empty()) {
-    int min_y = cache[0].y;
-    int max_y = cache[0].y;
-    for (const auto& pos : cache) {
-      if (pos.y < min_y) min_y = pos.y;
-      if (pos.y > max_y) max_y = pos.y;
-    }
-    vertical_bounds.min = min_y;
-    vertical_bounds.max = max_y;
-  }
-}

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

@@ -22,8 +22,6 @@ class Sequence : public Queueable<Point>{
   std::string toString();
   bool is_not_vertical();
   Shape* shape = nullptr;
-  Bounds vertical_bounds;
-  void compute_vertical_bounds();
   const std::vector<Point>& get_vector_cache() {
     if (vector_cache.empty() && this->size > 0) {
       vector_cache = this->to_vector();

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

@@ -17,17 +17,17 @@
 Shape::Shape(ShapePool* shape_pool, Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines)
 : outer_polyline(outer_polyline),
   inner_polylines(inner_polylines),
-  shape_pool_(shape_pool) {
-  for (InnerPolyline* ip : inner_polylines) {
-    ip->assigned_shape = this;
-  }
-}
+  shape_pool_(shape_pool) {}
 
 void Shape::clear_inner() {
   inner_polylines.clear();
 }
 
 void Shape::detach_from_pool() {
+  this->outer_polyline->shape_pool->detach_polyline();
+  for (InnerPolyline* inner_polyline : this->inner_polylines) {
+    inner_polyline->shape_pool->detach_inner_polyline();
+  }
   shape_pool_->detach_shape();
 }
 

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

@@ -9,49 +9,54 @@
 
 #include <vector>
 #include <utility>
+#include <iostream>
 #include "Shape.h"
 #include "ShapePool.h"
 #include "Tile.h"
 
 Shape* ShapePool::acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines) {
-  shapes_storage.emplace_back(this, outer_polyline, inner_polylines);
-  Shape* shape = &shapes_storage.back();
-  this->shapes_count++;
+  Shape* shape = this->shapes.acquire(this, outer_polyline, inner_polylines);
   return shape;
 }
 
+Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
+  return this->polylines.acquire(this, tile, std::move(polygon), bounds);
+}
+
+InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point> coords, Shape* shape) {
+  return this->inner_polylines.acquire(this, std::move(coords), shape);
+}
+
+InnerPolyline* ShapePool::acquire_inner_polyline(Sequence* seq) {
+  return this->inner_polylines.acquire(this, seq);
+}
+
 void ShapePool::set_owner(Tile* tile) {
   this->owner_tile_ = tile;
 }
 
 void ShapePool::detach_shape() {
-  this->shapes_count--;
-  if (this->shapes_count == 0) {
-    this->owner_tile_->unregister_pool(this);
-    delete this;
-  }
+  this->shapes.decrement();
+  this->check_destruction();
 }
 
-InnerPolyline* ShapePool::acquire_inner_polyline(std::vector<Point> coords, Shape* shape) {
-  inner_polylines_storage.emplace_back(std::move(coords), shape);
-  InnerPolyline* ip = &inner_polylines_storage.back();
-  return ip;
+void ShapePool::detach_polyline() {
+  this->polylines.decrement();
+  this->check_destruction();
 }
 
-InnerPolyline* ShapePool::acquire_inner_polyline(Sequence* seq) {
-  inner_polylines_storage.emplace_back(seq);
-  InnerPolyline* ip = &inner_polylines_storage.back();
-  return ip;
+void ShapePool::detach_inner_polyline() {
+  this->inner_polylines.decrement();
+  this->check_destruction();
 }
 
-Sequence* ShapePool::acquire_sequence() {
-  sequences_storage.emplace_back();
-  Sequence* s = &sequences_storage.back();
-  return s;
-}
-
-Polyline* ShapePool::acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds = std::nullopt) {
-  polylines_storage.emplace_back(tile, std::move(polygon), bounds);
-  Polyline* p = &polylines_storage.back();
-  return p;
+void ShapePool::check_destruction() {
+  if (this->shapes.is_released() &&
+      this->polylines.is_released() &&
+      this->inner_polylines.is_released()) {
+    if (this->owner_tile_) {
+      this->owner_tile_->unregister_pool(this);
+    }
+    delete this;
+  }
 }

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

@@ -13,6 +13,7 @@
 #include "Shape.h"
 #include "../RectBounds.h"
 #include "Polyline.h"
+#include "SubPool.h"
 
 class Shape;
 class Tile;
@@ -20,19 +21,18 @@ class Polyline;
 class InnerPolyline;
 class ShapePool {
  private:
-  int shapes_count = 0;
   Tile* owner_tile_ = nullptr;
-  std::deque<Shape> shapes_storage;
-  std::deque<InnerPolyline> inner_polylines_storage;
-  std::deque<Sequence> sequences_storage;
-  std::deque<Polyline> polylines_storage;
-
+  SubPool<Shape> shapes{this};
+  SubPool<Polyline> polylines{this};
+  SubPool<InnerPolyline> inner_polylines{this};
  public:
   Shape* acquire_shape(Polyline* outer_polyline, const std::vector<InnerPolyline*>& inner_polylines);
   InnerPolyline* acquire_inner_polyline(std::vector<Point> coords, Shape* s);
   InnerPolyline* acquire_inner_polyline(Sequence* seq);
-  Sequence* acquire_sequence();
   Polyline* acquire_polyline(Tile* tile, std::vector<Point> polygon, const std::optional<RectBounds>& bounds);
   void set_owner(Tile* tile);
   void detach_shape();
+  void detach_polyline();
+  void detach_inner_polyline();
+  void check_destruction();
 };

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

@@ -15,15 +15,11 @@
 
 StreamingMerger::StreamingMerger(int number_of_threads,
                                  std::vector<std::string>* options,
-                                 std::ofstream* stream_to,
-                                 int total_width, int total_height)
-  : VerticalMerger(number_of_threads, options), stream(stream_to), total_width(total_width), total_height(total_height) {
+                                 std::ofstream* stream_to)
+  : VerticalMerger(number_of_threads, options), stream(stream_to) {
   if (!stream) {
     throw std::invalid_argument("Streaming requires a valid destination output. stream_to cannot be null.");
   }
-  if (total_width <= 0 || total_height <= 0) {
-    throw std::invalid_argument("Streaming requires valid canvas dimensions (width and height must be > 0).");
-  }
 }
 
 void StreamingMerger::add_tile(ProcessResult& result, bool flush)
@@ -38,7 +34,7 @@ void StreamingMerger::add_tile(ProcessResult& result, bool flush)
 
 ProcessResult* StreamingMerger::process_info() {
   ProcessResult *pr = VerticalMerger::process_info();
-  pr->groups =  this->moved;
+  pr->groups = this->moved;
   return(pr);
 }
 
@@ -65,53 +61,34 @@ void StreamingMerger::stream_polygons(Tile* tile, bool flush) {
 
 void StreamingMerger::stream_raw_polygon(const Shape* shape) {
   std::ostringstream outer_oss;
+
+  this->write_outer_polygon_start();
   const std::vector<Point>& points = shape->outer_polyline->raw();
   for (size_t i = 0; i < points.size(); ++i) {
-    outer_oss << points[i].y << "," << points[i].x;
-    if (i < points.size() - 1) outer_oss << " ";
+    *stream << points[i].y << "," << points[i].x;
+    if (i < points.size() - 1) *stream << " ";
   }
-  *stream << svg_outer_polygon_string(outer_oss.str());
+  this->write_outer_polygon_end();
 
   for (const auto& inner_polyline : shape->inner_polylines) {
-    std::ostringstream inner_oss;
+    this->write_inner_polygon_start();
     const std::vector<Point>& inner_points = inner_polyline->raw();
     for (size_t i = 0; i < inner_points.size(); ++i) {
-      inner_oss << inner_points[i].y << "," << inner_points[i].x;
-      if (i < inner_points.size() - 1) inner_oss << " ";
+      *stream << inner_points[i].y << "," << inner_points[i].x;
+      if (i < inner_points.size() - 1) *stream << " ";
     }
-    *stream << svg_inner_polygon_string(inner_oss.str());
+    this->write_inner_polygon_end();
   }
 }
 
 void StreamingMerger::ensure_header() {
   if (stream && stream->tellp() == 0) {
-    *stream << svg_header_string();
+    this->write_header();
   }
 }
 
 void StreamingMerger::ensure_footer() {
   if (stream) {
-    *stream << svg_footer_string();
+    this->write_footer();
   }
 }
-
-std::string StreamingMerger::svg_css() {
-  return ".out{fill:none;stroke:red;stroke-width:1;}.in{fill:none;stroke:green;stroke-width:1;}.out:hover{stroke:yellow;}";
-}
-
-std::string StreamingMerger::svg_header_string() {
-  return "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + std::to_string(total_width) +
-         "\" height=\"" + std::to_string(total_height) + "\"><style>" + svg_css() + "</style>";
-}
-
-std::string StreamingMerger::svg_footer_string() {
-  return "</svg>";
-}
-
-std::string StreamingMerger::svg_outer_polygon_string(std::string_view points) {
-  return "<polygon points=\"" + std::string(points) + "\" class=\"out\"/>";
-}
-
-std::string StreamingMerger::svg_inner_polygon_string(std::string_view points) {
-  return "<polygon points=\"" + std::string(points) + "\" class=\"in\"/>";
-}

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

@@ -16,26 +16,25 @@
 #include <vector>
 
 class StreamingMerger : public VerticalMerger {
- private:
+ protected:
   std::ofstream* stream;
-  int total_width;
-  int total_height;
   int moved = 0;
+
+  void stream_polygons(Tile* tile, bool flush = false);
+  virtual void stream_raw_polygon(const Shape* shape);
+  virtual void write_header() = 0;
+  virtual void write_footer() = 0;
+  virtual void write_outer_polygon_start() = 0;
+  virtual void write_outer_polygon_end() = 0;
+  virtual void write_inner_polygon_start() = 0;
+  virtual void write_inner_polygon_end() = 0;
   void ensure_header();
   void ensure_footer();
-  void stream_polygons(Tile* tile, bool flush = false);
-  void stream_raw_polygon(const Shape* shape);
-  virtual std::string svg_css();
-  virtual std::string svg_header_string();
-  virtual std::string svg_footer_string();
-  virtual std::string svg_outer_polygon_string(std::string_view points);
-  virtual std::string svg_inner_polygon_string(std::string_view points);
 
  public:
   StreamingMerger(int number_of_threads,
                   std::vector<std::string>* options,
-                  std::ofstream* stream_to,
-                  int total_width, int total_height);
+                  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/SubPool.h

@@ -0,0 +1,47 @@
+/*
+ * SubPool.h
+ *
+ * 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 <deque>
+#include <memory>
+#include <utility>
+
+class ShapePool;
+
+template <typename T>
+class SubPool {
+ private:
+  std::unique_ptr<std::deque<T>> storage_;
+  uint32_t active_count_ = 0;
+  ShapePool* macro_pool_ = nullptr;
+
+ public:
+  explicit SubPool(ShapePool* macro_pool) : macro_pool_(macro_pool) {
+    storage_ = std::make_unique<std::deque<T>>();
+  }
+
+  template <typename... Args>
+  T* acquire(Args&&... args) {
+    storage_->emplace_back(std::forward<Args>(args)...);
+    T* ptr = &storage_->back();
+    active_count_++;
+    return ptr;
+  }
+
+  void decrement() {
+    active_count_--;
+    if (active_count_ == 0 && storage_ != nullptr) {
+      storage_.reset();
+    }
+  }
+
+  bool is_released() const {
+    return storage_ == nullptr;
+  }
+};

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

@@ -0,0 +1,56 @@
+/*
+ * SvgStreamingMerger.h
+ *
+ * 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 <string>
+#include <vector>
+#include "StreamingMerger.h"
+
+class SvgStreamingMerger : public StreamingMerger {
+ private:
+  int total_width;
+  int total_height;
+  std::string svg_css() {
+      return ".out{fill:none;stroke:red;stroke-width:1;}.in{fill:none;stroke:green;stroke-width:1;}.out:hover{stroke:yellow;}";
+  }
+
+ protected:
+  void write_header() override {
+    *stream << "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" << total_width
+            << "\" height=\"" << total_height << "\"><style>" << svg_css() << "</style>";
+  }
+  void write_footer() override {
+    *stream << "</svg>";
+  }
+  void write_outer_polygon_start() override {
+    *stream << "<polygon points=\"";
+  }
+  void write_outer_polygon_end() override {
+    *stream << "\" class=\"out\"/>";
+  }
+  void write_inner_polygon_start() override {
+    *stream << "<polygon points=\"";
+  }
+  void write_inner_polygon_end() override {
+    *stream << "\" class=\"in\"/>";
+  }
+
+ public:
+  SvgStreamingMerger(int number_of_threads,
+                     std::vector<std::string>* options,
+                     std::ofstream* stream_to,
+                     int total_width, int total_height)
+    : StreamingMerger(number_of_threads, options, stream_to),
+      total_width(total_width),
+      total_height(total_height) {
+    if (total_width <= 0 || total_height <= 0) {
+      throw std::invalid_argument("SVG Streaming requires valid canvas dimensions (width and height must be > 0).");
+    }
+  }
+};

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -96,6 +96,8 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/StreamingMerger.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/StreamingMerger.cpp"
+#include "PolygonFinder/src/polygon/finder/concurrent/SvgStreamingMerger.h"
+#include "PolygonFinder/src/polygon/finder/concurrent/GeoJsonStreamingMerger.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.cpp"
 extern "C" {
@@ -308,14 +310,23 @@ struct OfstreamWrapper {
   std::ofstream& get_stream() { return stream; }
 };
 
-StreamingMerger* create_streaming_merger(Object self,
+SvgStreamingMerger* create_svg_streaming_merger(Object self,
                                          int number_of_threads,
                                          std::vector<std::string>* options,
                                          Object stream_obj,
                                          int total_width,
                                          int total_height) {
   OfstreamWrapper* wrapper = Rice::detail::From_Ruby<OfstreamWrapper*>().convert(stream_obj.value());
-  return new StreamingMerger(number_of_threads, options, &wrapper->get_stream(), total_width, total_height);
+  return new SvgStreamingMerger(number_of_threads, options, &wrapper->get_stream(), total_width, total_height);
+}
+
+GeoJsonStreamingMerger* create_geo_json_streaming_merger(Object self,
+                                         int number_of_threads,
+                                         std::vector<std::string>* 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);
 }
 
 OfstreamWrapper* create_ofstream(Object self, std::string path) {
@@ -436,7 +447,11 @@ void Init_cpp_polygon_finder() {
       ProcessResult pr = Rice::detail::ruby_result_to_process_result(rb_result);
       self.add_tile(pr, flush);
     });
-    rb_cstreaming_merger.define_singleton_method("new", &create_streaming_merger);
+
+  Data_Type<SvgStreamingMerger> rb_csvgstreaming_merger = define_class<SvgStreamingMerger, StreamingMerger>("CPPSvgStreamingMerger");
+  rb_csvgstreaming_merger.define_singleton_method("new", &create_svg_streaming_merger);
+  Data_Type<GeoJsonStreamingMerger> rb_cgeojsonstreaming_merger = define_class<GeoJsonStreamingMerger, StreamingMerger>("CPPGeoJsonStreamingMerger");
+  rb_cgeojsonstreaming_merger.define_singleton_method("new", &create_geo_json_streaming_merger);
 
   Module mContrek = define_module("Contrek");
   Module mCpp = define_module_under(mContrek, "Cpp");

data/lib/contrek/cpp/cpp_geo_json_concurrent_streaming_merger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Cpp
+    class CPPGeoJsonConcurrentStreamingMerger < CPPGeoJsonStreamingMerger
+      def self.new(stream_to:, number_of_threads: 0, options: nil, pixel_val: 0)
+        super(number_of_threads, options, stream_to, pixel_val)
+      end
+    end
+  end
+end

data/lib/contrek/cpp/{cpp_concurrent_streaming_merger.rb → cpp_svg_concurrent_streaming_merger.rb}

@@ -2,7 +2,7 @@
 
 module Contrek
   module Cpp
-    class CPPConcurrentStreamingMerger < CPPStreamingMerger
+    class CPPSvgConcurrentStreamingMerger < CPPSvgStreamingMerger
       def self.new(stream_to:, total_width:, total_height:, number_of_threads: 0, options: nil)
         super(number_of_threads, options, stream_to, total_width, total_height)
       end