contrek 1.2.9 → 1.3.1

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

@@ -32,6 +32,7 @@ void StreamingMerger::add_tile(ProcessResult& result, bool flush)
     this->process_tiles();
     this->tiles_.queue_push(this->whole_tile);
     this->stream_polygons(this->whole_tile, flush);
+    this->whole_tile->shapes().shrink_to_fit();
   }
 }
 
@@ -45,16 +46,18 @@ 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](const Shape* shape) {
+      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();
   }
@@ -62,18 +65,18 @@ void StreamingMerger::stream_polygons(Tile* tile, bool flush) {
 
 void StreamingMerger::stream_raw_polygon(const Shape* shape) {
   std::ostringstream outer_oss;
-  const std::vector<Point*> points = shape->outer_polyline->raw();
+  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;
+    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();
+    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;
+      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());

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"
@@ -186,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);
       }
@@ -251,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) {
@@ -270,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);
     }

data/lib/contrek/bitmaps/chunky_bitmap.rb

@@ -89,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/finder/concurrent/cluster.rb

@@ -3,7 +3,7 @@
 module Contrek
   module Concurrent
     class Cluster
-      attr_reader :tiles, :hub
+      attr_reader :tiles, :hub, :finder
 
       def initialize(finder:, height:, start_x:, end_x:)
         @finder = finder

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

@@ -102,9 +102,6 @@ module Contrek
         if act_part.is?(Part::EXCLUSIVE)
           return if act_part.size == 0
           while (position = act_part.next_position)
-            return if outer_joined_polyline.size > 1 &&
-              outer_joined_polyline.head.payload == position.payload &&
-              act_part == all_parts.first
             outer_joined_polyline.add(position)
           end
         else

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

@@ -99,6 +99,10 @@ module Contrek
         Contrek::Finder::Result.new(raw_polygons, metadata)
       end
 
+      def transpose?
+        false
+      end
+
       private
 
       def process_tiles!(bitmap, height:)

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

@@ -16,6 +16,7 @@ module Contrek
 
       def add_tile(result)
         @height ||= result.metadata[:height]
+        @options[:versus] ||= result.metadata[:versus]
         end_x = @current_x + result.metadata[:width]
 
         tile = Tile.new(

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

@@ -10,11 +10,13 @@ module Contrek
       ADDED = 2
 
       attr_reader :polyline, :touched
-      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts, :trasmuted, :versus, :mirror
+      attr_accessor :next, :circular_next, :prev, :type, :dead_end, :inverts,
+        :trasmuted, :versus, :mirror, :next_seam, :transmutation_skip
       def initialize(type, polyline)
         @type = type
         @polyline = polyline
         @next = nil
+        @next_seam = nil
         @circular_next = nil
         @prev = nil
         @dead_end = false
@@ -23,6 +25,7 @@ module Contrek
         @trasmuted = false
         @versus = 0
         @mirror = false
+        @transmutation_skip = false
       end
 
       def is?(type)
@@ -80,6 +83,38 @@ module Contrek
         end
       end
 
+      def try_transmutation!
+        head_queues = head.end_point.queues
+        return if head_queues.size == 1
+        other_head_part = head_queues.find { |part| part.polyline.tile == polyline.tile && part != self }
+        if other_head_part
+          tail_queues = tail.end_point.queues
+          if tail_queues.find { |part| part == other_head_part }
+            if (other_head_part.tail.payload[:y] == tail.payload[:y] && other_head_part.head.payload[:y] == head.payload[:y]) ||
+                (other_head_part.tail.payload[:y] == head.payload[:y] && other_head_part.head.payload[:y] == tail.payload[:y])
+              if self.next.nil? && other_head_part.prev.nil?
+                self.mirror = true
+              end
+            else
+              self.type = Part::EXCLUSIVE
+              self.trasmuted = true
+              other_head_part.transmutation_skip = true
+            end
+          end
+        end
+      end
+
+      def within?(other)
+        self_min, self_max = [head.payload[:y], tail.payload[:y]].minmax
+        other_min, other_max = [other.head.payload[:y], other.tail.payload[:y]].minmax
+        self_min >= other_min && self_max <= other_max
+      end
+
+      def same_length?(other)
+        (head.payload[:y] - tail.payload[:y]).abs ==
+          (other.head.payload[:y] - other.tail.payload[:y]).abs
+      end
+
       def continuum_to?(other)
         return [] if size <= 2 && inverts && other.size <= 2 && other.inverts
         return [] if other.head.nil?

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

@@ -8,6 +8,8 @@ module Contrek
       def initialize(*args, **kwargs, &block)
         super
         @parts = []
+        @first_seam = nil
+        @last_seam = nil
       end
 
       def add_part(new_part)
@@ -16,8 +18,14 @@ module Contrek
         last.next = last.circular_next = new_part if last
         new_part.circular_next = @parts.first
         new_part.prev = last
-
-        new_part.orient! if new_part.is?(Part::SEAM)
+        if new_part.is?(Part::SEAM)
+          @first_seam ||= new_part
+          if !@last_seam.nil?
+            @last_seam.next_seam = new_part
+          end
+          @last_seam = new_part
+          new_part.orient!
+        end
       end
 
       def inspect_parts
@@ -27,6 +35,8 @@ module Contrek
       def partition!
         current_part = nil
         @parts = []
+        @first_seam = nil
+        @last_seam = nil
 
         @raw.each_with_index do |position, n|
           if @tile.tg_border?(position)
@@ -49,7 +59,7 @@ module Contrek
         end
         add_part(current_part)
 
-        trasmute_parts!
+        transmute_parts!
       end
 
       private
@@ -57,28 +67,37 @@ module Contrek
       # If there are SEAM parts and one is canceled out by another within the same polyline,
       # meaning that all its points are repeated in another, longer sequence,
       # then the shorter one is converted to EXCLUSIVE and marked as transmuted
-      def trasmute_parts!
-        insides = @parts.select { |p| p.is?(Part::SEAM) }
-        return if insides.size < 2
-
-        insides.each do |inside|
-          (insides - [inside]).each do |inside_compare|
-            next unless inside_compare.is?(Part::SEAM)
-
-            count = 0
-            inside.each do |position|
-              inclusion = position.end_point.queues.include?(inside_compare)
-              count += 1 if inclusion
+      def transmute_parts!
+        transpose = tile.cluster.finder.transpose?
+        if (current_seam = @first_seam)
+          loop do
+            if transpose
+              transmute_transposed_part(current_seam)
+            elsif !current_seam.transmutation_skip
+              current_seam.try_transmutation!
             end
-            if count == inside.size && count < inside_compare.size
-              inside.type = Part::EXCLUSIVE
-              inside.trasmuted = true
-              break
-            end
-            if count == inside.size && count == inside_compare.size &&
-                inside.next.nil? && inside_compare.prev.nil?
-              inside.mirror = true
+            current_seam = current_seam.next_seam
+            break if current_seam.nil?
+          end
+        end
+      end
+
+      def transmute_transposed_part(part)
+        if (current_seam = @first_seam)
+          loop do
+            if current_seam != part
+              if part.within?(current_seam)
+                if !part.same_length?(current_seam)
+                  part.type = Part::EXCLUSIVE
+                  part.trasmuted = true
+                  part.head.end_point.queues.delete(part)
+                  part.tail.end_point.queues.delete(part)
+                  return
+                end
+              end
             end
+            current_seam = current_seam.next_seam
+            break if current_seam.nil?
           end
         end
       end

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

@@ -16,6 +16,10 @@ module Contrek
         transpose(super())
       end
 
+      def transpose?
+        true
+      end
+
       private
 
       def adjust(result)

data/lib/contrek/finder/polygon_finder.rb

@@ -51,7 +51,8 @@ module Contrek
           benchmarks: format_benchmarks,
           width: @source_bitmap.w,
           height: @source_bitmap.h,
-          treemap: (@node_cluster.treemap if @options.has_key?(:treemap))
+          treemap: (@node_cluster.treemap if @options.has_key?(:treemap)),
+          versus: @options[:versus]
         }
         Result.new(@node_cluster.polygons, metadata)
       end

data/lib/contrek/version.rb

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