contrek 1.3.1 → 1.3.2

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,9 @@ 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 +48,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 +60,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

@@ -38,7 +38,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 +65,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,20 +16,22 @@
 #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,

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,43 @@
+/*
+ * 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 "StreamingMerger.h"
+
+class SvgStreamingMerger : public StreamingMerger {
+ private:
+  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:
+  using StreamingMerger::StreamingMerger;
+};

data/ext/cpp_polygon_finder/cpp_polygon_finder.cpp

@@ -96,6 +96,7 @@
 #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/ShapePool.h"
 #include "PolygonFinder/src/polygon/finder/concurrent/ShapePool.cpp"
 extern "C" {
@@ -315,7 +316,7 @@ StreamingMerger* create_streaming_merger(Object self,
                                          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);
 }
 
 OfstreamWrapper* create_ofstream(Object self, std::string path) {

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

@@ -5,7 +5,7 @@ module Contrek
     class Cluster
       attr_reader :tiles, :hub, :finder
 
-      def initialize(finder:, height:, start_x:, end_x:)
+      def initialize(finder:, height:)
         @finder = finder
         @tiles = []
         @hub = Hub.new(height:)
@@ -57,23 +57,24 @@ module Contrek
               new_inners = shape.inner_polylines
               new_inner_polylines = []
               tot_inner += Benchmark.measure do
-                new_inner_polylines = cursor.join_inners!(new_outer, treemap)
+                new_inner_polylines = cursor.join_inners!(treemap)
                 new_inners += new_inner_polylines
                 if treemap
                   new_inner_polylines.each do |inner_polyline|
-                    inner_polyline.sequence.compute_vertical_bounds!
+                    inner_polyline.compute_vertical_bounds!
                     all_new_inner_polylines += new_inner_polylines
                   end
                 end
                 new_inners += cursor.orphan_inners
               end.real
+              shape.clear_inner!
 
               polyline = Polyline.new(tile: tile, polygon: new_outer.to_a)
               inserting_new_shape = Shape.init_by(polyline, new_inners)
               new_shapes << inserting_new_shape
               polyline.shape = inserting_new_shape
 
-              new_inner_polylines.each { |inner_polyline| inner_polyline.sequence.shape = inserting_new_shape }
+              new_inner_polylines.each { |inner_polyline| inner_polyline.shape = inserting_new_shape }
 
               if treemap
                 cursor.shapes_sequence.each do |merged_shape|
@@ -115,7 +116,7 @@ module Contrek
       private
 
       def assign_ancestry(shape, inner_polyline)
-        shape.set_parent_shape(inner_polyline.sequence.shape)
+        shape.set_parent_shape(inner_polyline.shape)
         shape.parent_inner_polyline = inner_polyline
         shape.fixed = true
       end

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

@@ -40,7 +40,7 @@ module Contrek
         outer_joined_polyline
       end
 
-      def join_inners!(outer_seq, treemap)
+      def join_inners!(treemap)
         return_inner_polylines = []
         shape_index = 0
 
@@ -174,6 +174,7 @@ module Contrek
                   if !dest_part.polyline.on?(Polyline::TRACKED_OUTER)
                     @shapes_sequence << shape
                     @orphan_inners += shape.inner_polylines
+                    shape.clear_inner!
                   end
                   dest_part.polyline.turn_on(Polyline::TRACKED_OUTER)
                   if !dest_part.touched

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

@@ -114,18 +114,7 @@ module Contrek
             return
           end
           if (twin_tile = arriving_tiles.find { |b| (b.start_x == (tile.end_x - 1)) || ((b.end_x - 1) == tile.start_x) })
-
-            if twin_tile.start_x == (tile.end_x - 1)
-              start_x = tile.start_x
-              end_x = twin_tile.end_x
-            else
-              start_x = twin_tile.start_x
-              end_x = tile.end_x
-            end
-
-            # puts "start = #{start_x} end = #{end_x}"
-
-            cluster = Cluster.new(finder: self, height: height, start_x:, end_x:)
+            cluster = Cluster.new(finder: self, height: height)
             if twin_tile.start_x == (tile.end_x - 1)
               cluster.add(tile)
               cluster.add(twin_tile)

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

@@ -3,37 +3,20 @@
 module Contrek
   module Concurrent
     class InnerPolyline
-      attr_reader :sequence
+      attr_reader :raw, :vertical_bounds
+      attr_accessor :shape
 
       def initialize(shape: nil, raw_coordinates: [], sequence: nil)
-        @raw = raw_coordinates if raw_coordinates
-        @sequence = sequence if sequence
-        @shape = shape
-      end
-
-      def raw
-        @sequence ? @sequence.to_a : @raw
-      end
-
-      def vertical_bounds
-        if @sequence
-          @sequence.vertical_bounds
+        if sequence
+          @shape = sequence.shape
+          @raw = sequence.to_a
         else
-          raw_vertical_bounds
+          @shape = shape
+          @raw = raw_coordinates
         end
       end
 
-      def shape
-        if @sequence
-          @sequence.shape
-        else
-          @shape
-        end
-      end
-
-      private
-
-      def raw_vertical_bounds
+      def compute_vertical_bounds!
         @vertical_bounds ||= begin
           min_y = Float::INFINITY
           max_y = 0