cmd_plot 0.0.1 → 0.1.0

data/lib/cmd_plot/color_map.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    # 2D color maps of a matrix, e.g. to eyeball a function of two variables.
+    module ColorMap
+        MAX_SHADES = TEXT_COLORS.length * FILL_SYMBOLS.length
+
+        # data   - array of rows, each an array of numbers
+        # shades - number of distinct shades (default: one per distinct value, at most 28)
+        #
+        # The matrix is averaged down (or stretched up) to the plot size. Each shade is a
+        # combination of a color and a fill symbol.
+        def pcolor(data, shades = nil)
+            raise ArgumentError, 'nothing to plot: no rows' if data.empty? || data.first.empty?
+
+            shades = data.flatten.uniq.length if shades.nil?
+            shades = MAX_SHADES if shades > MAX_SHADES || shades <= 0
+            x_scale = data.first.length / @width.to_f
+            y_scale = data.length / @height.to_f
+            z_min, z_max = data.flatten.minmax
+            buf = +"Pcolor with x_scale: #{x_scale.round(3)}, y_scale: #{y_scale.round(3)}, " \
+                   "z_min: #{z_min.round(3)}, z_max: #{z_max.round(3)}\n"
+
+            @height.times { |row|
+                line = Array.new(@width) { |col|
+                    val = cell_average(data, row, col, x_scale, y_scale)
+                    next ' ' if val.nil?
+
+                    shade = z_max == z_min ? 0 : ((val - z_min) / (z_max - z_min).to_f * (shades - 1)).round
+                    colorize(FILL_SYMBOLS[shade / TEXT_COLORS.length], "3#{TEXT_COLORS[shade % TEXT_COLORS.length]}")
+                }
+                buf << line.join << "\n"
+            }
+            out.print(buf)
+            nil
+        end
+
+        private
+
+        # Average of the data points that fall into one output cell, or nil if none do.
+        def cell_average(data, row, col, x_scale, y_scale)
+            first_row = (row * y_scale).floor
+            first_col = (col * x_scale).floor
+            sum = 0.0
+            n = 0
+            (first_row..[first_row, ((row + 1) * y_scale).floor - 1].max).each { |r|
+                next if r >= data.length
+
+                (first_col..[first_col, ((col + 1) * x_scale).floor - 1].max).each { |c|
+                    next if c >= data[r].length
+
+                    sum += data[r][c]
+                    n += 1
+                }
+            }
+            n.zero? ? nil : sum / n
+        end
+    end
+
+    include ColorMap
+end

data/lib/cmd_plot/data.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    # Numeric helpers used by the plots. Kept inside the CmdPlot namespace so the gem
+    # doesn't define top-level constants in the host application.
+    module Data
+        module_function
+
+        # n evenly spaced floats from min to max, both ends included.
+        def linspace(min, max, n)
+            return [min.to_f] if n == 1
+
+            Array.new(n) { |i| min.to_f + (i.to_f * (max.to_f - min.to_f) / (n - 1).to_f) }
+        end
+
+        # Counts values into bins.
+        #
+        # bins - number of equal-width bins between min and max, or an array of bin limits
+        # maxcap - optional cap applied to every count
+        #
+        # Values below the first limit land in the first bin, values at or above the last
+        # limit in the last bin.
+        #
+        # return - [counts, bin_centers]
+        def histogram(values, bins, maxcap = nil)
+            limits = bins.is_a?(Array) ? bins : linspace(values.min, values.max, bins + 1)
+            counts = Array.new(limits.length - 1, 0)
+            values.each { |v|
+                bin = limits.index { |limit| v < limit } || counts.length
+                bin = 1 if bin.zero?
+                counts[bin - 1] += 1
+            }
+            counts = counts.map { |c| [c, maxcap].min } unless maxcap.nil?
+            centers = limits.each_cons(2).map { |a, b| (a + b) / 2.0 }
+            [counts, centers]
+        end
+    end
+end

data/lib/cmd_plot/legacy.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    # The 0.0.1 classes, kept so code written against them still runs. They delegate to
+    # CmdPlot; new code should use CmdPlot directly.
+    class Plot
+        def initialize(width = 140, height = 40, _symbol = nil)
+            @plotter = CmdPlot.new(width, height)
+        end
+
+        def plot(x, y = nil)
+            @plotter.plot(x, y)
+        end
+    end
+
+    class Bar
+        def initialize(width = 140, height = 40, symbol = '°')
+            @plotter = CmdPlot.new(width, height)
+            @symbol = symbol
+        end
+
+        def bar(values, labels)
+            @plotter.bar(values, labels, @symbol)
+        end
+
+        def histogram(values, bins = 20)
+            counts, centers = Data.histogram(values, bins)
+            bar(counts, centers.map { |c| c.round(1).to_s })
+        end
+    end
+
+    class Pcolor
+        def initialize(width = 140, height = 40)
+            @plotter = CmdPlot.new(width, height)
+        end
+
+        def pcolor(data, shades = nil)
+            @plotter.pcolor(data, shades)
+        end
+    end
+end

data/lib/cmd_plot/line_plot.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    # Line plots drawn with braille dots, one color per series.
+    module LinePlot
+        # Accepted input:
+        #   plot([y0, y1, ...])                     y values, x is the index
+        #   plot([x0, x1, ...], [y0, y1, ...])      separate x and y arrays
+        #   plot({ x0 => y0, x1 => y1 })            one series as a hash
+        #   plot([{ x0 => y0 }, { x0 => y0 }])      several series, one color each
+        #
+        # x values can be Dates. nil y values leave a gap in the line.
+        #
+        # intense: - use the bright color variants
+        # bold:    - draw the dots in bold
+        def plot(data, data2 = nil, intense: true, bold: true)
+            raise ArgumentError, 'a line plot needs at least 2x2 characters' if @width < 2 || @height < 2
+
+            series = plot_series(data, data2)
+            start_date = date_start(series)
+            series = series.map { |s| s.transform_keys { |d| (d - start_date).to_f } } unless start_date.nil?
+
+            ys = series.flat_map(&:values).compact
+            raise ArgumentError, 'nothing to plot: every y value is nil' if ys.empty?
+
+            x_min, x_max = spread(*series.flat_map(&:keys).compact.minmax)
+            y_min, y_max = spread(*ys.minmax)
+
+            cells = Array.new(@height) { Array.new(@width, ' ') }
+            series.each_with_index { |s, i|
+                code = "#{bold ? 1 : 0};#{intense ? 9 : 3}#{TEXT_COLORS[i % TEXT_COLORS.length]}"
+                draw_series(cells, dot_points(s, x_min, x_max, y_min, y_max), code)
+            }
+
+            x_ticks = Data.linspace(x_min, x_max, [2, @width / 15].max).map { |v|
+                start_date.nil? ? format('%.2f', v) : (start_date + v.round).to_s
+            }
+            y_ticks = Data.linspace(y_max, y_min, [2, @height / 10].max).map { |v| format('%.2f', v) }
+
+            buf = +''
+            plot_area(buf, cells.map(&:join), y_ticks)
+            x_axis(buf, x_ticks, y_ticks.map(&:length).max)
+            out.print(buf)
+            nil
+        end
+
+        private
+
+        def plot_series(data, data2)
+            return [data.zip(data2).to_h] unless data2.nil?
+            return [data] if data.is_a?(Hash)
+            raise ArgumentError, 'expected an array or a hash to plot' unless data.is_a?(Array)
+            return [data.each_with_index.to_h { |y, i| [i, y] }] if data.all? { |d| d.nil? || d.is_a?(Numeric) }
+            return data if data.all?(Hash)
+
+            raise ArgumentError, 'expected numbers, a hash, or an array of hashes to plot'
+        end
+
+        def date_start(series)
+            keys = series.flat_map(&:keys).compact
+            return nil unless keys.any?(Date)
+            raise ArgumentError, 'cannot mix Date and numeric x values' unless keys.all?(Date)
+
+            keys.min
+        end
+
+        # Widens a zero-width range so constant data still scales.
+        def spread(min, max)
+            return [min, max] unless min == max
+
+            delta = min.zero? ? 1.0 : min.abs * 0.05
+            [min - delta, max + delta]
+        end
+
+        # Scales a series onto the braille dot grid and connects consecutive points.
+        def dot_points(series, x_min, x_max, y_min, y_max)
+            cols = @width * 2
+            rows = @height * 4
+            xs = series.keys.map { |v| v.nil? ? nil : ((v - x_min) / (x_max - x_min).to_f * (cols - 1)).round }
+            ys = series.values.map { |v| v.nil? ? nil : ((v - y_min) / (y_max - y_min).to_f * (rows - 1)).round }
+            pairs = xs.zip(ys)
+            points = if pairs.length == 1
+                         pairs.reject { |pair| pair[1].nil? }
+                     else
+                         pairs.each_cons(2).flat_map { |(x0, y0), (x1, y1)| Braille.line_points(x0, y0, x1, y1) }
+                     end
+            points.map { |x, y| [x.clamp(0, cols - 1), y.clamp(0, rows - 1)] }
+        end
+
+        # Later series overwrite earlier ones where they share a cell.
+        def draw_series(cells, points, code)
+            masks = Array.new(@height) { Array.new(@width, 0) }
+            points.each { |x, y|
+                masks[@height - 1 - (y / 4)][x / 2] |= Braille::DOT_BITS[3 - (y % 4)][x % 2]
+            }
+            masks.each_with_index { |row, r|
+                row.each_with_index { |mask, c|
+                    next if mask.zero?
+
+                    cells[r][c] = colorize((Braille::BASE + mask).chr(Encoding::UTF_8), code)
+                }
+            }
+        end
+
+        # Spreads the y ticks as evenly as the line count allows.
+        def plot_area(buf, lines, y_ticks)
+            tick_width = y_ticks.map(&:length).max
+            spacing = (@height - y_ticks.length) / (y_ticks.length - 1)
+            missing = @height - ((spacing * (y_ticks.length - 1)) + y_ticks.length)
+            missing_dist = missing.zero? ? @height : y_ticks.length / missing.to_f
+            next_tick = 0
+            tick_offset = 0
+            lines.each_with_index { |line, row|
+                if next_tick < y_ticks.length && row == tick_offset + (next_tick * (spacing + 1))
+                    buf << y_ticks[next_tick].rjust(tick_width) << ' ├ '
+                    next_tick += 1
+                    tick_offset += 1 if ((tick_offset + 1) * missing_dist) < (next_tick + 2)
+                else
+                    buf << (' ' * tick_width) << ' │ '
+                end
+                buf << line << "\n"
+            }
+        end
+
+        def x_axis(buf, x_ticks, indent)
+            buf << (' ' * indent) << ' └─'
+            spread_between(buf, Array.new(x_ticks.length, '┴'), '─')
+            buf << (' ' * indent) << '   '
+            spread_between(buf, x_ticks, ' ')
+        end
+
+        # Writes the items across the plot width, padding the gaps with fill. When the
+        # width doesn't divide evenly the leftover goes into the gaps one by one.
+        def spread_between(buf, items, fill)
+            total = items.sum(&:length)
+            gap = [(@width - total) / (items.length - 1), 1].max
+            missing = @width - ((gap * (items.length - 1)) + total)
+            missing_dist = missing.zero? ? @width : items.length / missing.to_f
+            added = 0
+            items.each_with_index { |item, i|
+                buf << item
+                if i == items.length - 1
+                    buf << "\n"
+                    next
+                end
+                buf << (fill * gap)
+                if ((added + 1) * missing_dist) < (i + 3)
+                    added += 1
+                    buf << fill
+                end
+            }
+        end
+    end
+
+    include LinePlot
+end

data/lib/cmd_plot/tables.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    # Tabular dumps of records.
+    #
+    # data is an array of hashes, or of objects that respond to #attributes (e.g. an
+    # ActiveRecord relation). Objects are turned into hashes with string keys and string
+    # values, so pass field names as strings for them.
+    module Tables
+        # Columns separated by │, each as wide as its longest value.
+        #
+        # fields  - keys to show, in order (default: the keys of the first record)
+        # shorten - cut every column to at most this many characters
+        def table(data, fields = nil, shorten = nil)
+            rows = records(data)
+            fields ||= rows.first&.keys
+            return nil if fields.nil?
+
+            widths = fields.map { |f|
+                width = ([f.to_s.length] + rows.map { |r| r[f].to_s.length }).max
+                shorten.nil? ? width : [width, shorten].min
+            }
+            cut = ->(value) { shorten.nil? ? value.to_s : value.to_s[0, shorten] }
+            line = ->(values) { " #{values.zip(widths).map { |v, w| cut.call(v).rjust(w) }.join(' │ ')}" }
+
+            buf = +''
+            buf << line.call(fields) << "\n"
+            buf << widths.map { |w| '─' * (w + 2) }.join('┼') << "\n"
+            rows.each { |r| buf << line.call(fields.map { |f| r[f] }) << "\n" }
+            out.print(buf)
+            nil
+        end
+
+        # One block per record with a line per field, like psql's \x mode. Useful when
+        # records have too many fields for a table.
+        def expanded_table(data, fields = nil)
+            rows = records(data)
+            fields ||= rows.first&.keys
+            return nil if fields.nil?
+
+            num_width = rows.length.to_s.length
+            name_width = [13 + num_width, fields.map { |f| f.to_s.length }.max + 1].max
+            buf = +''
+            rows.each_with_index { |r, i|
+                buf << "─[ RECORD #{(i + 1).to_s.rjust(num_width)} ]─" << ('─' * (name_width - 13 - num_width))
+                buf << '┬' << ('─' * [70 - name_width, 0].max) << "\n"
+                fields.each { |f| buf << f.to_s.ljust(name_width) << '│ ' << r[f].to_s << "\n" }
+            }
+            out.print(buf)
+            nil
+        end
+
+        # Comma-separated values with a header line. Values that contain a comma, quote or
+        # line break are quoted.
+        def csv(data, fields = nil)
+            rows = records(data)
+            fields ||= rows.first&.keys
+            return nil if fields.nil?
+
+            buf = +''
+            buf << fields.map { |f| csv_value(f) }.join(', ') << "\n"
+            rows.each { |r| buf << fields.map { |f| csv_value(r[f]) }.join(', ') << "\n" }
+            out.print(buf)
+            nil
+        end
+
+        private
+
+        def records(data)
+            data.map { |row|
+                if row.respond_to?(:attributes)
+                    row.attributes.to_h { |k, v| [k.to_s, v.to_s] }
+                else
+                    row
+                end
+            }
+        end
+
+        def csv_value(value)
+            text = value.to_s
+            return text unless text.match?(/[",\r\n]/)
+
+            "\"#{text.gsub('"', '""')}\""
+        end
+    end
+
+    include Tables
+end

data/lib/cmd_plot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class CmdPlot
+    VERSION = '0.1.0'
+end

data/lib/cmd_plot.rb

@@ -1,9 +1,57 @@
+# frozen_string_literal: true
+
+require 'date'
+
+# Quick text-mode plots, charts and tables for the console.
+#
+#   plotter = CmdPlot.new(100, 25)
+#   plotter.plot([1, 4, 9, 16, 25])
+#   plotter.bar([3, 5, 2], %w[a b c])
+#   plotter.table([{ 'id' => 1, 'name' => 'x' }])
+#
+# Every method writes to the output stream and returns nil, so it reads cleanly in an
+# interactive console.
 class CmdPlot
+    # ANSI color numbers: red, green, brown, blue, magenta, cyan, gray
+    TEXT_COLORS = [1, 2, 3, 4, 5, 6, 7].freeze
+    FILL_SYMBOLS = ['█', '▓', '░', '▒'].freeze
 
-end
+    attr_reader :width, :height
+
+    # width  - width of the drawing area in characters
+    # height - height of the drawing area in lines
+    # out:   - IO to write to; defaults to whatever $stdout is at the time of the call
+    # color: - false drops the ANSI escape codes, e.g. when writing to a file
+    def initialize(width = 140, height = 40, out: nil, color: true)
+        raise ArgumentError, 'width must be at least 1' if width.to_i < 1
+        raise ArgumentError, 'height must be at least 1' if height.to_i < 1
+
+        @width = width.to_i
+        @height = height.to_i
+        @out = out
+        @color = color
+    end
 
-require 'cmd_plot/basic_data'
+    private
+
+    def out
+        @out || $stdout
+    end
+
+    def color?
+        @color
+    end
+
+    def colorize(text, code)
+        color? ? "\e[#{code}m#{text}\e[0m" : text
+    end
+end
 
-require 'cmd_plot/plot'
-require 'cmd_plot/bar'
-require 'cmd_plot/pcolor'
+require 'cmd_plot/version'
+require 'cmd_plot/data'
+require 'cmd_plot/braille'
+require 'cmd_plot/line_plot'
+require 'cmd_plot/bar_chart'
+require 'cmd_plot/color_map'
+require 'cmd_plot/tables'
+require 'cmd_plot/legacy'

metadata

@@ -1,33 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: cmd_plot
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Andreas Buschermoehle
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: This is an interface to quickly visualize data on the command line. It
-  supports various kinds of plots (curves, bar diagram, histogram, 2D color, etc)
-  that are presented as text output on the console.
+description: 'Quick visualization of data on the command line: braille line plots
+  with several series and date axes, bar charts, histograms, 2D color maps, and table/CSV
+  dumps of hashes or ActiveRecord-style records. No dependencies.'
 email: andreas@buschermoehle.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE
+- README.md
 - lib/cmd_plot.rb
-- lib/cmd_plot/bar.rb
-- lib/cmd_plot/basic_data.rb
-- lib/cmd_plot/pcolor.rb
-- lib/cmd_plot/plot.rb
-homepage: http://rubygems.org/gems/cmd_plot
+- lib/cmd_plot/bar_chart.rb
+- lib/cmd_plot/braille.rb
+- lib/cmd_plot/color_map.rb
+- lib/cmd_plot/data.rb
+- lib/cmd_plot/legacy.rb
+- lib/cmd_plot/line_plot.rb
+- lib/cmd_plot/tables.rb
+- lib/cmd_plot/version.rb
+homepage: https://github.com/MrBusch/cmdplot
 licenses:
 - GPL-2.0
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/MrBusch/cmdplot
+  source_code_uri: https://github.com/MrBusch/cmdplot
+  changelog_uri: https://github.com/MrBusch/cmdplot/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/MrBusch/cmdplot/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -35,16 +45,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Command line plotting for quick visualization of data.
+summary: Line plots, bar charts, histograms, color maps and tables in the terminal.
 test_files: []

data/lib/cmd_plot/bar.rb

@@ -1,30 +0,0 @@
-class CmdPlot::Bar
-    def initialize(width = 140, height = 40, symbol = '°')
-        @width = width
-        @height = height
-        @symbol = symbol
-    end
-
-    def bar(height, labels)
-        # Calculate scaling of data to plot
-        max_height = height.max.to_f
-        max_label_length = labels.map { |l| l.length }.max
-        max_val_length = height.map { |l| l.to_s.length }.max
-        max_bar_length = (@width - max_label_length - max_val_length - 3)
-        # Plot each bar
-        for data in height.zip(labels)
-            label_fill_space = ' ' * (max_label_length - data[1].length)
-            value_fill_space = ' ' * (max_val_length - data[0].to_s.length)
-            bar_plot = @symbol * ((data[0] / max_height) * max_bar_length).round
-            puts "#{label_fill_space}#{data[1]}: #{value_fill_space}#{data[0]} #{bar_plot}"
-        end
-        return nil
-    end
-
-    def histogram(data, bins = 20)
-        # Turn data into bins with counts
-        counts, bin_centers = BasicData.build_hist(data, bins)
-        # Plot as bar chart
-        bar(counts, bin_centers.map { |p| p.round(1).to_s })
-    end
-end

data/lib/cmd_plot/basic_data.rb

@@ -1,33 +0,0 @@
-class BasicData
-
-    def self.linspace(min, max, n)
-        return Array.new(n) { |i| min.to_f + i.to_f * (max.to_f - min.to_f) / (n - 1).to_f }
-    end
-
-    def self.build_hist(data, bin_spec, maxcap = nil)
-        min = data.min
-        max = data.max
-        if bin_spec.kind_of?(Array)
-            limits = bin_spec
-            nr_bins = limits.length - 1
-        else
-            limits = BasicData.linspace(min, max, bin_spec + 1)
-            nr_bins = bin_spec
-        end
-        counts = Array.new(nr_bins, 0)
-        for d in data
-            bin = limits.map { |x| d < x }.index(true)
-            if bin.nil?
-                bin = counts.length
-            end
-            if bin == 0
-                bin = 1
-            end
-            counts[bin - 1] += 1
-        end
-        counts = counts.map { |v| [v, maxcap].min } unless maxcap.nil?
-        bin_centers = limits.each_cons(2).to_a.map { |a| (a[0] + a[1]) / 2.0 }
-        return counts, bin_centers
-    end
-
-end

data/lib/cmd_plot/pcolor.rb

@@ -1,73 +0,0 @@
-class CmdPlot::Pcolor
-
-    #red, green, brown, blue, magenta, cyan, gray
-    TEXT_COLORS = [31, 32, 33, 34, 35, 36, 37]
-    FILL_SYMBOLS = ['░', '▒', '▓', '█']
-    MAX_SHADES = TEXT_COLORS.length * FILL_SYMBOLS.length
-
-    def initialize(width = 140, height = 40)
-        @width = width
-        @height = height
-    end
-
-    def pcolor(data, shades = nil)
-        # Calculate scaling of data to picture
-        shades = data.flatten.uniq.length if shades.nil?
-        shades = MAX_SHADES if shades > MAX_SHADES or shades <= 0
-        x_scale = data[0].length / @width.to_f
-        y_scale = data.length / @height.to_f
-        z_max = data.map { |r| r.max }.max
-        z_min = data.map { |r| r.min }.min
-        puts "x_scale: #{x_scale}, y_scale: #{y_scale}, z_min: #{z_min}, z_max: #{z_max}"
-
-        # Calculcate scaled data
-        scaled_data = Array.new(@height) { Array.new(@width) { 0.0 } }
-        for row in 0..(scaled_data.length - 1)
-            for col in 0..(scaled_data[row].length - 1)
-                n = 0.0
-                lower_row_idx = (row * y_scale).floor
-                upper_row_idx = [lower_row_idx, ((row + 1) * y_scale).floor - 1].max
-                lower_col_idx = (col * x_scale).floor
-                upper_col_idx = [lower_col_idx, ((col + 1) * x_scale).floor - 1].max
-                for d_row in lower_row_idx..upper_row_idx
-                    for d_col in lower_col_idx..upper_col_idx
-                        scaled_data[row][col] += data[d_row][d_col]
-                        n += 1.0
-                    end
-                end
-                if(n > 0)
-                    scaled_data[row][col] /= n
-                else
-                    scaled_data[row][col] = nil
-                end
-            end
-        end
-
-        # Full picture starts out empty
-        pic = Array.new(@height) { Array.new(@width) { nil } }
-        # Run through data and fill in the plotting symbol/color
-        for row in 0..(scaled_data.length - 1)
-            for col in 0..(scaled_data[row].length - 1)
-                val = scaled_data[row][col]
-                next if val.nil?
-                fill = ((val - z_min) / (z_max - z_min).to_f * (shades - 1)).round
-                pic[row][col] = fill
-            end
-        end
-
-        # Plot the picture
-        for row in pic
-            for col in row
-                if col.nil?
-                    print ' '
-                else
-                    color = TEXT_COLORS[col % TEXT_COLORS.length]
-                    sym = FILL_SYMBOLS[col / TEXT_COLORS.length]
-                    print "\e[#{color}m#{sym}\e[0m"
-                end
-            end
-            print "\n"
-        end
-        return nil
-    end
-end