unicode_plot 0.0.1

data/lib/unicode_plot/canvas.rb

@@ -0,0 +1,160 @@
+module UnicodePlot
+  class Canvas
+    include BorderPrinter
+
+    def self.create(canvas_type, width, height, **kw)
+      case canvas_type
+      when :ascii
+        AsciiCanvas.new(width, height, **kw)
+      when :braille
+        BrailleCanvas.new(width, height, **kw)
+      else
+        raise ArgumentError, "unknown canvas type: #{canvas_type}"
+      end
+    end
+
+    def initialize(width, height, pixel_width, pixel_height, fill_char,
+                   origin_x: 0,
+                   origin_y: 0,
+                   plot_width: 1,
+                   plot_height: 1,
+                   x_pixel_per_char: 1,
+                   y_pixel_per_char: 1)
+      @width = width
+      @height = height
+      @pixel_width = pixel_width
+      @pixel_height = pixel_height
+      @origin_x = origin_x
+      @origin_y = origin_y
+      @plot_width = plot_width
+      @plot_height = plot_height
+      @x_pixel_per_char = x_pixel_per_char
+      @y_pixel_per_char = y_pixel_per_char
+      @grid = Array.new(@width * @height, fill_char)
+      @colors = Array.new(@width * @height, COLOR_ENCODE[:normal])
+    end
+
+    attr_reader :width
+    attr_reader :height
+    attr_reader :pixel_width
+    attr_reader :pixel_height
+    attr_reader :origin_x
+    attr_reader :origin_y
+    attr_reader :plot_width
+    attr_reader :plot_height
+    attr_reader :x_pixel_per_char
+    attr_reader :y_pixel_per_char
+
+    def show(out)
+      b = BorderMaps::BORDER_SOLID
+      border_length = width
+
+      print_border_top(out, "", border_length, :solid, color: :light_black)
+      out.puts
+      (0 ... height).each do |row_index|
+        print_styled(out, b[:l], color: :light_black)
+        print_row(out, row_index)
+        print_styled(out, b[:r], color: :light_black)
+        out.puts
+      end
+      print_border_bottom(out, "", border_length, :solid, color: :light_black)
+    end
+
+    def print(out)
+      (0 ... height).each do |row_index|
+        print_row(out, row_index)
+        out.puts if row_index < height - 1
+      end
+    end
+
+    def char_at(x, y)
+      @grid[index_at(x, y)]
+    end
+
+    def color_at(x, y)
+      @colors[index_at(x, y)]
+    end
+
+    def index_at(x, y)
+      return nil unless 0 <= x && x < width && 0 <= y && y < height
+      y * width + x
+    end
+
+    def point!(x, y, color)
+      unless origin_x <= x && x <= origin_x + plot_width &&
+             origin_y <= y && y <= origin_y + plot_height
+        return c
+      end
+
+      plot_offset_x = x - origin_x
+      pixel_x = plot_offset_x.fdiv(plot_width) * pixel_width
+
+      plot_offset_y = y - origin_y
+      pixel_y = pixel_height - plot_offset_y.fdiv(plot_height) * pixel_height
+
+      pixel!(pixel_x.floor, pixel_y.floor, color)
+    end
+
+    def points!(x, y, color = :normal)
+      if x.length != y.length
+        raise ArgumentError, "x and y must be the same length"
+      end
+      unless x.length > 0
+        raise ArgumentError, "x and y must not be empty"
+      end
+      (0 ... x.length).each do |i|
+        point!(x[i], y[i], color)
+      end
+    end
+
+    # digital differential analyzer algorithm
+    def line!(x1, y1, x2, y2, color)
+      if (x1 < origin_x && x2 < origin_x) ||
+          (x1 > origin_x + plot_width && x2 > origin_x + plot_width)
+        return color
+      end
+      if (y1 < origin_y && y2 < origin_y) ||
+          (y1 > origin_y + plot_height && y2 > origin_y + plot_height)
+        return color
+      end
+
+      toff = x1 - origin_x
+      px1 = toff.fdiv(plot_width) * pixel_width
+      toff = x2 - origin_x
+      px2 = toff.fdiv(plot_width) * pixel_width
+
+      toff = y1 - origin_y
+      py1 = pixel_height - toff.fdiv(plot_height) * pixel_height
+      toff = y2 - origin_y
+      py2 = pixel_height - toff.fdiv(plot_height) * pixel_height
+
+      dx = px2 - px1
+      dy = py2 - py1
+      nsteps = dx.abs > dy.abs ? dx.abs : dy.abs
+      inc_x = dx.fdiv(nsteps)
+      inc_y = dy.fdiv(nsteps)
+
+      cur_x = px1
+      cur_y = py1
+      pixel!(cur_x.floor, cur_y.floor, color)
+      1.upto(nsteps) do |i|
+        cur_x += inc_x
+        cur_y += inc_y
+        pixel!(cur_x.floor, cur_y.floor, color)
+      end
+      color
+    end
+
+    def lines!(x, y, color = :normal)
+      if x.length != y.length
+        raise ArgumentError, "x and y must be the same length"
+      end
+      unless x.length > 0
+        raise ArgumentError, "x and y must not be empty"
+      end
+      (0 ... (x.length - 1)).each do |i|
+        line!(x[i], y[i], x[i+1], y[i+1], color)
+      end
+    end
+  end
+end

data/lib/unicode_plot/lineplot.rb

@@ -0,0 +1,249 @@
+require 'date'
+
+module UnicodePlot
+  class GridCanvas < Plot
+    MIN_WIDTH = 5
+    DEFAULT_WIDTH = 40
+    MIN_HEIGHT = 2
+    DEFAULT_HEIGHT = 15
+
+    def initialize(x, y, canvas,
+                   width: DEFAULT_WIDTH,
+                   height: DEFAULT_HEIGHT,
+                   xlim: [0, 0], 
+                   ylim: [0, 0],
+                   grid: true,
+                   **kw)
+      unless xlim.length == 2 && ylim.length == 2
+        raise ArgumentError, "xlim and ylim must be 2-length arrays"
+      end
+      width = [width, MIN_WIDTH].max
+      height = [height, MIN_HEIGHT].max
+      min_x, max_x = extend_limits(x, xlim)
+      min_y, max_y = extend_limits(y, ylim)
+      origin_x = min_x
+      origin_y = min_y
+      plot_width = max_x - origin_x
+      plot_height = max_y - origin_y
+      @canvas = Canvas.create(canvas, width, height,
+                              origin_x: origin_x,
+                              origin_y: origin_y,
+                              plot_width: plot_width,
+                              plot_height: plot_height)
+      super(**kw)
+
+      min_x_str = (roundable?(min_x) ? min_x.round : min_x).to_s
+      max_x_str = (roundable?(max_x) ? max_x.round : max_x).to_s
+      min_y_str = (roundable?(min_y) ? min_y.round : min_y).to_s
+      max_y_str = (roundable?(max_y) ? max_y.round : max_y).to_s
+
+      annotate_row!(:l, 0, max_y_str, color: :light_black)
+      annotate_row!(:l, height-1, min_y_str, color: :light_black)
+      annotate!(:bl, min_x_str, color: :light_black)
+      annotate!(:br, max_x_str, color: :light_black)
+
+      if grid
+        if min_y < 0 && 0 < max_y
+          step = plot_width.fdiv(width * @canvas.x_pixel_per_char - 1)
+          min_x.step(max_x, by: step) do |i|
+            @canvas.point!(i, 0, :normal)
+          end
+        end
+        if min_x < 0 && 0 < max_x
+          step = plot_height.fdiv(height * @canvas.y_pixel_per_char - 1)
+          min_y.step(max_y, by: step) do |i|
+            @canvas.point!(0, i, :normal)
+          end
+        end
+      end
+    end
+
+    def origin_x
+      @canvas.origin_x
+    end
+
+    def origin_y
+      @canvas.origin_y
+    end
+
+    def plot_width
+      @canvas.plot_width
+    end
+
+    def plot_height
+      @canvas.plot_height
+    end
+
+    def n_rows
+      @canvas.height
+    end
+
+    def n_columns
+      @canvas.width
+    end
+
+    def points!(x, y, color)
+      @canvas.points!(x, y, color)
+    end
+
+    def lines!(x, y, color)
+      @canvas.lines!(x, y, color)
+    end
+
+    def print_row(out, row_index)
+      @canvas.print_row(out, row_index)
+    end
+
+    def extend_limits(values, limits)
+      mi, ma = limits.minmax.map(&:to_f)
+      if mi == 0 && ma == 0
+        mi, ma = values.minmax.map(&:to_f)
+      end
+      diff = ma - mi
+      if diff == 0
+        ma = mi + 1
+        mi = mi - 1
+      end
+      if limits == [0, 0]
+        plotting_range_narrow(mi, ma)
+      else
+        [mi, ma]
+      end
+    end
+
+    def plotting_range_narrow(xmin, xmax)
+      diff = xmax - xmin
+      xmax = round_up_subtick(xmax, diff)
+      xmin = round_down_subtick(xmin, diff)
+      [xmin.to_f, xmax.to_f]
+    end
+
+    def round_up_subtick(x, m)
+      if x == 0
+        0.0
+      elsif x > 0
+        x.ceil(ceil_neg_log10(m) + 1)
+      else
+        -(-x).floor(ceil_neg_log10(m) + 1)
+      end
+    end
+
+    def round_down_subtick(x, m)
+      if x == 0
+        0.0
+      elsif x > 0
+        x.floor(ceil_neg_log10(m) + 1)
+      else
+        -(-x).ceil(ceil_neg_log10(m) + 1)
+      end
+    end
+
+    def ceil_neg_log10(x)
+      if roundable?(-Math.log10(x))
+        (-Math.log10(x)).ceil
+      else
+        (-Math.log10(x)).floor
+      end
+    end
+
+    def roundable?(x)
+      x.to_i == x
+    end
+  end
+
+  class Lineplot < GridCanvas
+    def initialize(x, y, canvas,
+                   **kw)
+      if x.length != y.length
+        raise ArgumentError, "x and y must be the same length"
+      end
+      unless x.length > 0
+        raise ArgumentError, "x and y must not be empty"
+      end
+      super(x, y, canvas, **kw)
+    end
+  end
+
+  module_function def lineplot(*args,
+                               canvas: :braille,
+                               color: :auto,
+                               name: "",
+                               **kw)
+    case args.length
+    when 1
+      # y only
+      y = Array(args[0])
+      x = Array(1 .. y.length)
+    when 2
+      # x and y
+      x = Array(args[0])
+      y = Array(args[1])
+    else
+      raise ArgumentError, "wrong number of arguments"
+    end
+
+    case x[0]
+    when Time, Date
+      if x[0].is_a? Time
+        d = x.map(&:to_f)
+      else
+        origin = Date.new(1, 1, 1)
+        d = x.map {|xi| xi - origin }
+      end
+      plot = lineplot(d, y, canvas: canvas, color: color, name: name, **kw)
+      xmin, xmax = x.minmax
+      plot.annotate!(:bl, xmin.to_s, color: :light_black)
+      plot.annotate!(:br, xmax.to_s, color: :light_black)
+      plot
+    else
+      plot = Lineplot.new(x, y, canvas, **kw)
+      lineplot!(plot, x, y, color: color, name: name)
+    end
+  end
+
+  module_function def lineplot!(plot,
+                                *args,
+                                color: :auto,
+                                name: "")
+    case args.length
+    when 1
+      # y only
+      y = Array(args[0])
+      x = Array(1 .. y.length)
+    when 2
+      # x and y
+      x = Array(args[0])
+      y = Array(args[1])
+
+      if x.length == 1 && y.length == 1
+        # intercept and slope
+        intercept = x[0]
+        slope = y[0]
+        xmin = plot.origin_x
+        xmax = plot.origin_x + plot.plot_width
+        ymin = plot.origin_y
+        ymax = plot.origin_y + plot.plot_height
+        x = [xmin, xmax]
+        y = [intercept + xmin*slope, intercept + xmax*slope]
+      end
+    else
+      raise ArgumentError, "wrong number of arguments"
+    end
+
+    case x[0]
+    when Time, Date
+      if x[0].is_a? Time
+        d = x.map(&:to_f)
+      else
+        origin = Date.new(1, 1, 1)
+        d = x.map {|xi| xi - origin }
+      end
+      lineplot!(plot, d, y, color: color, name: name)
+    else
+      color = color == :auto ? plot.next_color : color
+      plot.annotate!(:r, name.to_s, color: color) unless name.nil? || name == ""
+      plot.lines!(x, y, color)
+    end
+    plot
+  end
+end

data/lib/unicode_plot/plot.rb

@@ -0,0 +1,139 @@
+module UnicodePlot
+  class Plot
+    include StyledPrinter
+
+    DEFAULT_BORDER = :solid
+    DEFAULT_MARGIN = 3
+    DEFAULT_PADDING = 1
+
+    def initialize(title: nil,
+                   xlabel: nil,
+                   ylabel: nil,
+                   border: DEFAULT_BORDER,
+                   margin: DEFAULT_MARGIN,
+                   padding: DEFAULT_PADDING,
+                   labels: true)
+      @title = title
+      @xlabel = xlabel
+      @ylabel = ylabel
+      @border = border
+      @margin = check_margin(margin)
+      @padding = padding
+      @labels_left = {}
+      @colors_left = {}
+      @labels_right = {}
+      @colors_right = {}
+      @decorations = {}
+      @colors_deco = {}
+      @show_labels = labels
+      @auto_color = 0
+    end
+
+    attr_reader :title,
+                :xlabel,
+                :ylabel,
+                :border,
+                :margin,
+                :padding,
+                :labels_left,
+                :colors_left,
+                :labels_right,
+                :colors_right,
+                :decorations,
+                :colors_deco
+
+    def title_given?
+      title && title != ""
+    end
+
+    def xlabel_given?
+      xlabel && xlabel != ""
+    end
+
+    def ylabel_given?
+      ylabel && ylabel != ""
+    end
+
+    def ylabel_length
+      ylabel&.length || 0
+    end
+
+    def show_labels?
+      @show_labels
+    end
+
+    def annotate!(loc, value, color: :normal)
+      case loc
+      when :l
+        (0 ... n_rows).each do |row|
+          if @labels_left.fetch(row, "") == ""
+            @labels_left[row] = value
+            @colors_left[row] = color
+            break
+          end
+        end
+      when :r
+        (0 ... n_rows).each do |row|
+          if @labels_right.fetch(row, "") == ""
+            @labels_right[row] = value
+            @colors_right[row] = color
+            break
+          end
+        end
+      when :t, :b, :tl, :tr, :bl, :br
+        @decorations[loc] = value
+        @colors_deco[loc] = color
+      else
+        raise ArgumentError,
+          "unknown location to annotate (#{loc.inspect} for :t, :b, :l, :r, :tl, :tr, :bl, or :br)"
+      end
+    end
+
+    def annotate_row!(loc, row_index, value, color: :normal)
+      case loc
+      when :l
+        @labels_left[row_index] = value
+        @colors_left[row_index] = color
+      when :r
+        @labels_right[row_index] = value
+        @colors_right[row_index] = color
+      else
+        raise ArgumentError, "unknown location `#{loc}`, try :l or :r instead"
+      end
+    end
+
+    def render(out)
+      Renderer.render(out, self)
+    end
+
+    COLOR_CYCLE = [
+      :green,
+      :blue,
+      :red,
+      :magenta,
+      :yellow,
+      :cyan
+    ].freeze
+
+    def next_color
+      COLOR_CYCLE[@auto_color]
+    ensure
+      @auto_color = (@auto_color + 1) % COLOR_CYCLE.length
+    end
+
+    def to_s
+      StringIO.open do |sio|
+        render(sio)
+        sio.close
+        sio.string
+      end
+    end
+
+    private def check_margin(margin)
+      if margin < 0
+        raise ArgumentError, "margin must be >= 0"
+      end
+      margin
+    end
+  end
+end