contrek 1.2.8 → 1.3.0

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

@@ -0,0 +1,117 @@
+/*
+ * StreamingMerger.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.
+ */
+
+#include "StreamingMerger.h"
+#include <sstream>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+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) {
+  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)
+{ VerticalMerger::add_tile(result);
+  if (tiles_.size() == 2) {
+    this->process_tiles();
+    this->tiles_.queue_push(this->whole_tile);
+    this->stream_polygons(this->whole_tile, flush);
+    this->whole_tile->shapes().shrink_to_fit();
+  }
+}
+
+ProcessResult* StreamingMerger::process_info() {
+  ProcessResult *pr = VerticalMerger::process_info();
+  pr->groups =  this->moved;
+  return(pr);
+}
+
+void StreamingMerger::stream_polygons(Tile* tile, bool flush) {
+  ensure_header();
+  if (int tile_end_x = tile->end_x(); true) {
+    tile->shapes().erase(
+      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);
+          shape->detach_from_pool();
+          return true;
+        }
+        return false;
+      }),
+      tile->shapes().end());
+  }
+  stream->flush();
+  if (flush) {
+    ensure_footer();
+  }
+}
+
+void StreamingMerger::stream_raw_polygon(const Shape* shape) {
+  std::ostringstream outer_oss;
+  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 << svg_outer_polygon_string(outer_oss.str());
+
+  for (const auto& inner_polyline : shape->inner_polylines) {
+    std::ostringstream inner_oss;
+    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 << svg_inner_polygon_string(inner_oss.str());
+  }
+}
+
+void StreamingMerger::ensure_header() {
+  if (stream && stream->tellp() == 0) {
+    *stream << svg_header_string();
+  }
+}
+
+void StreamingMerger::ensure_footer() {
+  if (stream) {
+    *stream << svg_footer_string();
+  }
+}
+
+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

@@ -0,0 +1,41 @@
+/*
+ * StreamingMerger.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 "VerticalMerger.h"
+#include <fstream>
+#include <string>
+#include <string_view>
+#include <stdexcept>
+#include <vector>
+
+class StreamingMerger : public VerticalMerger {
+ private:
+  std::ofstream* stream;
+  int total_width;
+  int total_height;
+  int moved = 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);
+  void add_tile(ProcessResult& result, bool flush = false);
+  ProcessResult* process_info() override;
+};

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

@@ -27,6 +27,7 @@ Tile::Tile(Finder *finder, int start_x, int end_x, std::string name, const Bench
   name_(name),
   benchmarks(b) {
   this->shapes_pool = new ShapePool();
+  this->shapes_pool->set_owner(this);
   this->shapes_pools.push_back(this->shapes_pool);
 }
 
@@ -156,6 +157,14 @@ std::vector<std::pair<int, int>> Tile::compute_treemap()
 void Tile::adopt(Tile* other) {
   for (ShapePool* pool : other->shapes_pools) {
     this->shapes_pools.push_back(pool);
+    pool->set_owner(this);
   }
   other->shapes_pools.clear();
 }
+
+void Tile::unregister_pool(ShapePool* shape_pool) {
+  auto it = std::find(this->shapes_pools.begin(), this->shapes_pools.end(), shape_pool);
+  if (it != this->shapes_pools.end()) {
+    this->shapes_pools.erase(it);
+  }
+}

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

@@ -59,4 +59,5 @@ class Tile {
   std::vector<ShapePool*> shapes_pools;
   ShapePool* shapes_pool;
   void adopt(Tile* other);
+  void unregister_pool(ShapePool* shape_pool);
 };

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

@@ -12,7 +12,6 @@
 #include <vector>
 #include <algorithm>
 #include <utility>
-#include <unordered_set>
 #include "VerticalMerger.h"
 
 VerticalMerger::VerticalMerger(int number_of_threads, std::vector<std::string> *options)
@@ -36,21 +35,13 @@ ProcessResult* VerticalMerger::process_info() {
 
 void VerticalMerger::transpose(ProcessResult& result) {
   std::swap(result.width, result.height);
-  std::unordered_set<Point*> seen;
   for (auto& polygon : result.polygons) {
-    auto process_p = [&](Point* p) {
-      if (p) {
-        if (seen.insert(p).second) {
-          std::swap(p->x, p->y);
-        }
-      }
-    };
-    for (Point* p : polygon.outer) {
-      process_p(p);
+    for (Point& p : polygon.outer) {
+      std::swap(p.x, p.y);
     }
     for (auto& sequence : polygon.inner) {
-      for (Point* p : sequence) {
-        process_p(p);
+      for (Point& p : sequence) {
+        std::swap(p.x, p.y);
       }
     }
     std::swap(polygon.bounds.min_x, polygon.bounds.min_y);

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

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

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.cpp

@@ -14,23 +14,23 @@
 #include "LinearReducer.h"
 #include "Reducer.h"
 
-LinearReducer::LinearReducer(std::vector<Point*> &list_of_points)
+LinearReducer::LinearReducer(std::vector<Point>& list_of_points)
 : Reducer(list_of_points) {
 }
 
 void LinearReducer::reduce() {
   if (points.size() < 2) return;
 
-  Point* start_p = points[0];
-  Point* end_p = points[1];
+  Point start_p = points[0];
+  Point end_p = points[1];
   auto dir = seq_dir(start_p, end_p);
 
   for (size_t i = 2; i < points.size(); ++i) {
-    Point* point = points[i];
+    Point point = points[i];
     auto act_seq = seq_dir(end_p, point);
     if (act_seq == dir) {
-      auto it = std::find_if(points.begin(), points.end(), [&](Point* p) {  // TODO(ema): optimize...
-        return p->x == end_p->x && p->y == end_p->y;
+      auto it = std::find_if(points.begin(), points.end(), [&](const Point& p) {  // TODO(ema): optimize...
+        return p.x == end_p.x && p.y == end_p.y;
       });
       if (it != points.end()) {
         size_t removed_idx = std::distance(points.begin(), it);
@@ -44,6 +44,6 @@ void LinearReducer::reduce() {
   }
 }
 
-std::array<int, 2> LinearReducer::seq_dir(Point *a, Point *b)
-{ return { b->x - a->x, b->y - a->y };
+std::array<int, 2> LinearReducer::seq_dir(const Point& a, const Point& b)
+{ return { b.x - a.x, b.y - a.y };
 }

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/LinearReducer.h

@@ -14,9 +14,9 @@
 
 class LinearReducer : public Reducer {
  public:
-  explicit LinearReducer(std::vector<Point*>& list_of_points);
+  explicit LinearReducer(std::vector<Point>& list_of_points);
   void reduce();
 
  private:
-  std::array<int, 2> seq_dir(Point *a, Point *b);
+  std::array<int, 2> seq_dir(const Point& a, const Point& b);
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.cpp

@@ -9,7 +9,7 @@
 
 #include "Reducer.h"
 
-Reducer::Reducer(std::vector<Point*>& list_of_points)
+Reducer::Reducer(std::vector<Point>& list_of_points)
 : points(list_of_points) {
 }
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/Reducer.h

@@ -15,8 +15,8 @@
 struct Point;
 class Reducer {
  public:
-  explicit Reducer(std::vector<Point*>& list_of_points);
+  explicit Reducer(std::vector<Point>& list_of_points);
   virtual void reduce();
  protected:
-  std::vector<Point*> &points;
+  std::vector<Point> &points;
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.cpp

@@ -13,12 +13,12 @@
 #include "UniqReducer.h"
 #include "Reducer.h"
 
-UniqReducer::UniqReducer(std::vector<Point*>& list_of_points) : Reducer(list_of_points) {
+UniqReducer::UniqReducer(std::vector<Point>& list_of_points) : Reducer(list_of_points) {
 }
 
 struct is_near {
-  bool operator() (Point* first, Point* second) const {
-    return first->x == second->x && first->y == second->y;
+  bool operator() (const Point& first, const Point& second) const {
+    return first.x == second.x && first.y == second.y;
   }
 };
 

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/UniqReducer.h

@@ -13,6 +13,6 @@
 
 class UniqReducer : public Reducer {
  public:
-  explicit UniqReducer(std::vector<Point*>& list_of_points);
+  explicit UniqReducer(std::vector<Point>& list_of_points);
   void reduce();
 };

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.cpp

@@ -10,7 +10,7 @@
 #include <vector>
 #include "VisvalingamReducer.h"
 
-VisvalingamReducer::VisvalingamReducer(std::vector<Point*>& list_of_points, float tolerance)
+VisvalingamReducer::VisvalingamReducer(std::vector<Point>& list_of_points, float tolerance)
   : Reducer(list_of_points) {
   this->tolerance = tolerance * tolerance;
 }
@@ -18,11 +18,11 @@ VisvalingamReducer::VisvalingamReducer(std::vector<Point*>& list_of_points, floa
 VisvalingamReducer::~VisvalingamReducer() {}
 
 void VisvalingamReducer::reduce() {
-  std::vector<Point*> new_points = this->simplify();
+  std::vector<Point> new_points = this->simplify();
   points.assign(new_points.begin(), new_points.end());
 }
 
-std::vector<Point*> VisvalingamReducer::simplify() {
+std::vector<Point> VisvalingamReducer::simplify() {
   Vertex* vwLine = Vertex::buildLine(points);
   float minArea = this->tolerance;
   for (;;) {

data/ext/cpp_polygon_finder/PolygonFinder/src/polygon/reducers/VisvalingamReducer.h

@@ -17,21 +17,21 @@ struct Point;
 
 class VisvalingamReducer : public Reducer {
  public:
-  VisvalingamReducer(std::vector<Point*>& list_of_points, float tolerance);
+  VisvalingamReducer(std::vector<Point>& list_of_points, float tolerance);
   virtual ~VisvalingamReducer();
   void reduce();
-  std::vector<Point*> simplify();
+  std::vector<Point> simplify();
 
   class Triangle {
    public:
-    static int area(Point* a, Point* b, Point* c) {
-      return std::abs(((c->x - a->x) * (b->y - a->y) - (b->x - a->x) * (c->y - a->y)) / 2);
+    static int area(const Point& a, const Point& b, const Point& c) {
+      return std::abs(((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2);
     }
   };
 
   class Vertex {
     const float MAX_AREA = std::numeric_limits<float>::max();
-    explicit Vertex(Point* pt) {
+    explicit Vertex(const Point& pt) {
       this->pt = pt;
       this->prev = nullptr;
       this->next = nullptr;
@@ -40,7 +40,7 @@ class VisvalingamReducer : public Reducer {
     }
 
    public:
-    Point* pt;
+    Point pt;
     void setNext(Vertex* nextp) { this->next = nextp; }
     void setPrec(Vertex* prev) { this->prev = prev; }
     void updateArea() {
@@ -54,10 +54,10 @@ class VisvalingamReducer : public Reducer {
     Vertex* get_next() { return this->next; }
     bool isLiving() { return this->isLive; }
 
-    static Vertex* buildLine(std::vector<Point*>& pts) {
+    static Vertex* buildLine(std::vector<Point>& pts) {
       Vertex* first = nullptr;
       Vertex* prev = nullptr;
-      for (Point* p : pts) {
+      for (const Point& p : pts) {
         Vertex* v = new Vertex(p);
         if (!first) first = v;
         v->setPrec(prev);
@@ -88,8 +88,8 @@ class VisvalingamReducer : public Reducer {
       return result;
     }
 
-    static std::vector<Point*> getCoordinates(Vertex* head) {
-      std::vector<Point*> coords;
+    static std::vector<Point> getCoordinates(Vertex* head) {
+      std::vector<Point> coords;
       Vertex* curr = head;
       while (curr) {
         coords.push_back(curr->pt);

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -27,8 +27,6 @@
 #include "PolygonFinder/src/polygon/finder/List.h"
 #include "PolygonFinder/src/polygon/finder/Lists.cpp"
 #include "PolygonFinder/src/polygon/finder/Lists.h"
-#include "PolygonFinder/src/polygon/finder/PointPool.h"
-#include "PolygonFinder/src/polygon/finder/PointPool.cpp"
 #include "PolygonFinder/src/polygon/finder/Polygon.h"
 #include "PolygonFinder/src/polygon/bitmaps/Bitmap.h"
 #include "PolygonFinder/src/polygon/bitmaps/Bitmap.cpp"
@@ -96,6 +94,8 @@
 #include "PolygonFinder/src/polygon/finder/concurrent/HorizontalMerger.cpp"
 #include "PolygonFinder/src/polygon/finder/concurrent/VerticalMerger.h"
 #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/ShapePool.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.cpp"
 extern "C" {
@@ -184,24 +184,25 @@ class To_Ruby<ProcessResult*>
     return_me[Symbol("named_sequence")] = pr->named_sequence;
     return_me[Symbol("width")] = pr->width;
     return_me[Symbol("height")] = pr->height;
+    return_me[Symbol("versus")] = Symbol(pr->versus == Node::O ? "o" : "a");
 
     Rice::Array out;
     for (Polygon& x : pr->polygons)
     { Rice::Hash poly_hash = Rice::Hash();
-      // OUTER: std::vector<Point*>
+      // OUTER: std::vector<Point>
       Rice::Array outer_flat;
-      for (Point* p : x.outer) {
-        outer_flat.push(p->x);
-        outer_flat.push(p->y);
+      for (const Point& p : x.outer) {
+        outer_flat.push(p.x);
+        outer_flat.push(p.y);
       }
       poly_hash[Symbol("outer")] = outer_flat;
-      // INNER: std::list<std::vector<Point*>>
+      // INNER: std::list<std::vector<Point>>
       Rice::Array inner_collection;
-      for (const std::vector<Point*>& sequence : x.inner) {
+      for (const std::vector<Point>& sequence : x.inner) {
         Rice::Array sequence_flat;
-        for (Point* p : sequence) {
-          sequence_flat.push(p->x);
-          sequence_flat.push(p->y);
+        for (const Point& p : sequence) {
+          sequence_flat.push(p.x);
+          sequence_flat.push(p.y);
         }
         inner_collection.push(sequence_flat);
       }
@@ -249,6 +250,7 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
   Rice::Hash metadata = rb_result.iv_get("@metadata_storage");
   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;
 
   Rice::Array rb_polygons = rb_result.iv_get("@polygons_storage");
   for (size_t i = 0; i < rb_polygons.size(); ++i) {
@@ -268,17 +270,17 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
     for (size_t j = 0; j < outer_flat.size(); j += 2) {
       int px = detail::From_Ruby<int>().convert(outer_flat[j].value());
       int py = detail::From_Ruby<int>().convert(outer_flat[j+1].value());
-      poly.outer.push_back(new Point(px, py));
+      poly.outer.push_back(Point(px, py));
     }
     // INNER
     Rice::Array inner_collection = (Rice::Array)rb_poly[Symbol("inner")];
     for (size_t j = 0; j < inner_collection.size(); ++j) {
       Rice::Array sequence_flat = (Rice::Array)inner_collection[j];
-      std::vector<Point*> hole;
+      std::vector<Point> hole;
       for (size_t k = 0; k < sequence_flat.size(); k += 2) {
         int px = detail::From_Ruby<int>().convert(sequence_flat[k].value());
         int py = detail::From_Ruby<int>().convert(sequence_flat[k+1].value());
-        hole.push_back(new Point(px, py));
+        hole.push_back(Point(px, py));
       }
       poly.inner.push_back(hole);
     }
@@ -290,6 +292,36 @@ ProcessResult ruby_result_to_process_result(Rice::Object rb_result) {
 
 }  // namespace Rice::detail
 
+struct OfstreamWrapper {
+  std::string path;
+  std::ofstream stream;
+  OfstreamWrapper(std::string p) : path(p), stream(p, std::ios::out) {}
+  void close() { stream.close(); }
+  bool closed() { return !stream.is_open(); }
+  void rewind() { /* noop */ }
+  std::string read() {
+    stream.flush();
+    std::ifstream in(path);
+    return std::string((std::istreambuf_iterator<char>(in)),
+                        std::istreambuf_iterator<char>());
+  }
+  std::ofstream& get_stream() { return stream; }
+};
+
+StreamingMerger* create_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);
+}
+
+OfstreamWrapper* create_ofstream(Object self, std::string path) {
+  return new OfstreamWrapper(path);
+}
+
 extern "C"
 void Init_cpp_polygon_finder() {
   #ifdef HAVE_TCMALLOC
@@ -384,9 +416,27 @@ void Init_cpp_polygon_finder() {
     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);
 
-    Data_Type<VerticalMerger> rb_cVerticalMerger =
+  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, std::vector<std::string>*>(), Arg("number_of_threads"), Arg("options") = nullptr, 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_Type<OfstreamWrapper> rb_cstd_ofstream = define_class<OfstreamWrapper>("CPPOfstream");
+    rb_cstd_ofstream.define_singleton_method("new", &create_ofstream);
+    rb_cstd_ofstream.define_method("close",   [](OfstreamWrapper& self) { self.close(); });
+    rb_cstd_ofstream.define_method("closed?", [](OfstreamWrapper& self) { return self.closed(); });
+    rb_cstd_ofstream.define_method("rewind",  [](OfstreamWrapper& self) { self.rewind(); });
+    rb_cstd_ofstream.define_method("read",    [](OfstreamWrapper& self) { return self.read(); });
+
+  Data_Type<StreamingMerger> rb_cstreaming_merger = define_class<StreamingMerger, VerticalMerger>("CPPStreamingMerger");
+    rb_cstreaming_merger.define_method("add_tile", [](StreamingMerger& self, Object rb_result, bool flush) {
+      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);
 
   Module mContrek = define_module("Contrek");
   Module mCpp = define_module_under(mContrek, "Cpp");

data/ext/cpp_polygon_finder/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "mkmf-rice"
 
 has_tcmalloc = find_library("tcmalloc", "malloc")

data/lib/contrek/bitmaps/bitmap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class Bitmap

data/lib/contrek/bitmaps/chunky_bitmap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class ChunkyBitmap < Bitmap
@@ -87,6 +89,17 @@ module Contrek
         puts
       end
 
+      def transpose!
+        transposed = ""
+        w.times do |x|
+          h.times do |y|
+            transposed += value_at(x, y)
+          end
+        end
+        @raw = transposed
+        @module = h
+      end
+
       private
 
       def next_color(color)

data/lib/contrek/bitmaps/painting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     module Painting

data/lib/contrek/bitmaps/png_bitmap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "chunky_png"
 
 module Contrek

data/lib/contrek/bitmaps/raw_bitmap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class RawBitmap < PngBitmap

data/lib/contrek/bitmaps/rgb_color.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class RgbColor

data/lib/contrek/bitmaps/rgb_cpp_color.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class RgbCppColor

data/lib/contrek/bitmaps/sample_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Bitmaps
     class SampleGenerator

data/lib/contrek/cpp/cpp_concurrent_finder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Cpp
     class CPPConcurrentFinder < CPPFinder

data/lib/contrek/cpp/cpp_concurrent_horizontal_merger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Contrek
   module Cpp
     class CPPConcurrentHorizontalMerger < CPPHorizontalMerger