amaze 0.2.0

data/lib/amaze/formatter.rb

@@ -0,0 +1,5 @@
+
+module Amaze::Formatter
+  autoload :ASCII, 'amaze/formatter/ascii'
+  autoload :Image, 'amaze/formatter/image'
+end

data/lib/amaze/formatter/ascii.rb

@@ -0,0 +1,91 @@
+
+# all rainbow colors: Rainbow::X11ColorNames::NAMES.keys
+require 'rainbow/ext/string'
+
+class Amaze::Formatter::ASCII
+  autoload :Delta, 'amaze/formatter/ascii/delta'
+  autoload :Ortho, 'amaze/formatter/ascii/ortho'
+  autoload :Sigma, 'amaze/formatter/ascii/sigma'
+  autoload :Upsilon, 'amaze/formatter/ascii/upsilon'
+  autoload :Polar, 'amaze/formatter/ascii/polar'
+  
+  # The grid
+  attr_reader :grid
+  
+  # Options for the ASCII renderer
+  attr_reader :options
+  
+  def initialize grid, options={}
+    @grid = grid
+    @options = options
+  end
+  
+  def char
+    @char ||= Array.new(char_array_height) do |x|
+      Array.new(char_array_width) do |y|
+        clear
+      end
+    end
+  end  
+
+  def render
+    grid.each_cell do |cell|
+      draw_cell cell
+      draw_content cell if distances
+      draw_path cell if path_cell? cell
+    end
+    
+    ansi_clear + char.map{|l| l.join }.join("\n")
+  end
+  
+  def path? direction, cell
+    cell.linked?(cell.send(direction)) && path_cell?(cell.send(direction))
+  end
+  
+  def ansi_clear
+    "\e[H\e[2J"
+  end
+  
+  def clear
+    ' '
+  end
+  
+  # The size of the cell
+  def cell_size
+    options[:cell_size] || 1
+  end
+  
+  # The color of the grid
+  def grid_color
+    options[:grid_color] || :white
+  end
+  
+  # The color used to draw the solution or the longest path
+  def path_color
+    options[:path_color] || :blue
+  end
+  
+  def path_cell? cell
+    Array(options[:path_cells]).include? cell
+  end
+  
+  # Distances
+  def distances
+    options[:distances]
+  end
+  
+  def distance cell
+    # .to_s(36) => 0..9a..z
+    distances && distances[cell] ? distances[cell].to_s(36).upcase : ' '
+  end
+  
+  def distance_color cell
+    return @options[:distances_color] if @options[:distances_color]
+    _, max = distances.max
+    high = (255-47).to_f / max * distances[cell] + 47
+    low = high / 4
+    p [:low, low] unless (0..255).include? low
+    p [:high, high] unless (0..255).include? high
+    [0,low,high]
+  end
+end

data/lib/amaze/formatter/ascii/delta.rb

@@ -0,0 +1,180 @@
+
+class Amaze::Formatter::ASCII::Delta < Amaze::Formatter::ASCII
+
+  def draw_cell cell
+    x0, y0 = coord cell
+    
+    # reverse triangle
+    if (cell.column + cell.row).even?
+      # corner
+      char[y0][x0] = corner.color(grid_color)
+      char[y0][x0+(cell_size+1)*2] = corner.color(grid_color)
+      char[y0+cell_size+1][x0+cell_size+1] = corner.color(grid_color)
+      
+      0.upto(cell_size*2) do |i|
+        # north
+        char[y0][x0+1+i] = h.color(grid_color)
+      end unless cell.linked_to?(:north)
+      1.upto(cell_size) do |i|
+        # west
+        char[y0+i][x0+i] = rw.color(grid_color) unless cell.linked_to?(:west)
+        # east
+        char[y0+i][x0+(cell_size+1)*2-i] = re.color(grid_color) unless cell.linked_to?(:east)
+      end
+      
+    # normal triangle
+    else
+      # corner
+      char[y0+cell_size+1][x0] = corner.color(grid_color)
+      char[y0+cell_size+1][x0+(cell_size+1)*2] = corner.color(grid_color)
+      char[y0][x0+cell_size+1] = corner.color(grid_color)
+      
+      0.upto(cell_size*2) do |i|
+        # south
+        char[y0+cell_size+1][x0+1+i] = h.color(grid_color)
+      end unless cell.linked_to?(:south)
+      1.upto(cell_size) do |i|
+        # west
+        char[y0+i][x0+cell_size+1-i] = nw.color(grid_color) unless cell.linked_to?(:west)
+        # east
+        char[y0+i][x0+cell_size+1+i] = ne.color(grid_color) unless cell.linked_to?(:east)
+      end
+      
+    end
+  end
+
+  def draw_content cell
+    x0, y0 = coord cell
+    
+    if cell_size == 1
+      my = y0 + 1
+      mx = x0 + 2
+      w = 1
+    else
+      mx = x0 + cell_size / 2 + 1
+      w = (cell_size+1) / 2 * 2 + 1
+      if (cell.column+cell.row).even?
+        my = y0 + cell_size / 2
+      else
+        my = y0 + (cell_size+3) / 2
+      end
+    end
+    
+    distance(cell).center(w).chars.each_with_index do |c,i|
+      char[my][mx+i] = c.color(*distance_color(cell))
+    end
+  end
+  
+  def draw_path cell
+    x0, y0 = coord cell
+    
+    mx = x0 + cell_size + 1
+    my = y0 + (cell_size + 1) / 2
+    
+    # center
+    char[my][mx] = center.color(path_color)
+    1.upto(cell_size) do |i|
+      # east-west
+      char[my][mx+i] = h.color(path_color) if path?(:east, cell)
+      # north-south
+      char[my+i][mx] = v.color(path_color) if path?(:south, cell)
+    end
+  end
+  
+  def coord cell
+    [xpos(cell.column), ypos(cell.row)]
+  end
+  
+  def xpos column
+    (cell_size + 1) * column
+  end
+  
+  def ypos row
+    (cell_size + 1) * row
+  end
+  
+  def char_array_width
+    xpos(grid.columns + 1) + 1
+  end
+  
+  def char_array_height
+    ypos(grid.rows) + 1
+  end
+  
+  def h
+    '-'
+  end
+  
+  def v
+    '|'
+  end
+  
+  def rw
+    '\\'
+  end
+  
+  def re
+    '/'
+  end
+  
+  def corner
+    '∙'
+  end
+  
+  alias_method :center, :corner
+  alias_method :nw, :re
+  alias_method :ne, :rw
+  
+end
+
+__END__
+
+∙---∙---∙
+ \...\ / \
+  ∙ . ∙---∙
+ / \./ \ /
+∙---∙---∙
+ \ / \ / \
+  ∙---∙---∙
+
+∙-----∙-----∙
+ \ ....\ * / \
+  \   . \ /   \
+   ∙  .  ∙-----∙
+  /.... / \   /
+ / .   /   \ /
+∙  .  ∙-----∙
+ \ . / \   / \
+  \ /   \ /   \
+   ∙-----∙-----∙
+
+∙-------∙-------∙
+ \       \     / \
+  \ ..... \   /   \
+   \    .  \ /     \
+    ∙   .   ∙-------∙
+   / \  .  / \     / 
+  /   \   /   \   /
+ /     \ /     \ /
+∙-------∙-------∙
+ \     / \     / \
+  \   /   \   /   \
+   \ /     \ /     \
+    ∙-------∙-------∙
+
+∙---------∙---------∙
+ \       / \       / \
+  \  .      \     /   \
+   \    ` .  \   /     \
+    \ /       \ /       \
+     ∙---------∙---------∙
+    / \       / \       / 
+   /   \     /   \     / 
+  /     \   /     \   /
+ /       \ /       \ /
+∙---------∙---------∙
+ \       / \       / \
+  \     /   \     /   \
+   \   /     \   /     \
+    \ /       \ /       \
+     ∙---------∙---------∙

data/lib/amaze/formatter/ascii/ortho.rb

@@ -0,0 +1,105 @@
+
+class Amaze::Formatter::ASCII::Ortho < Amaze::Formatter::ASCII
+  
+  def draw_cell cell
+    left, right, top, bottom = coord cell
+    
+    # corners
+    char[top][left] = corner.color(grid_color)
+    char[top][right] = corner.color(grid_color)
+    char[bottom][left] = corner.color(grid_color)
+    char[bottom][right] = corner.color(grid_color)
+    # top & bottom
+    (left+1).upto(right-1) do |i|
+      # top
+      char[top][i] = h.color(grid_color) unless cell.linked_to?(:north)
+      # bottom
+      char[bottom][i] = h.color(grid_color) unless cell.linked_to?(:south)
+    end
+    # left & right
+    (top+1).upto(bottom-1) do |i|
+      # left
+      char[i][left] = v.color(grid_color) unless cell.linked_to?(:west)
+      # right
+      char[i][right] = v.color(grid_color) unless cell.linked_to?(:east)
+    end
+  end
+
+  def draw_content cell
+    left, right, top, bottom = coord cell
+
+    my = top + cell_size / 2 + 1
+    distance(cell).center(cell_size * 3).chars.each_with_index do |c,i|
+      char[my][left+1+i] = c.color(*distance_color(cell))
+    end
+  end
+
+  def draw_path cell
+    left, right, top, bottom = coord cell
+
+    mx = left + (cell_size * 3 + 1) / 2
+    my = top + cell_size / 2 + 1
+    
+    # TODO: simplify paths, draw only north-south and east-west
+    
+    # to north
+    top.upto(my-1) do |i|
+      char[i][mx] = v.color(path_color) if path?(:north, cell)
+    end if top <= my-1
+    # to east
+    (mx+1).upto(right) do |i|
+      char[my][i] = h.color(path_color) if path?(:east, cell)
+    end if mx+1 <= right
+    # to south
+    (my+1).upto(bottom) do |i|
+      char[i][mx] = v.color(path_color) if path?(:south, cell)
+    end if my+1 <= bottom
+    # to west
+    left.upto(mx-1) do |i|
+      char[my][i] = h.color(path_color) if path?(:west, cell)
+    end if left <= mx-1
+    # center, select the char depeding on how many paths cross the cell
+    center_char = center
+    center_char = v if path?(:north, cell) && path?(:south, cell)
+    center_char = h if path?(:east, cell) && path?(:west, cell)
+    center_char = corner if [:north, :east, :south, :west].select{|d| path?(d, cell) }.size >= 3
+    char[my][mx] = center_char.color(path_color)
+  end
+  
+  # left, right, top, bottom
+  def coord cell
+    [x(cell.column), x(cell.column+1), y(cell.row), y(cell.row+1)]
+  end
+  
+  def x column
+    (cell_size * 3 + 1) * column
+  end
+  
+  def y row
+    (cell_size + 1) * row
+  end
+  
+  def char_array_width
+    x(grid.columns) + 1
+  end
+  
+  def char_array_height
+    y(grid.rows) + 1
+  end
+  
+  def h
+    '-'
+  end
+  
+  def v
+    '|'
+  end
+  
+  def center
+    '∙'
+  end
+    
+  def corner
+    '+'
+  end
+end

data/lib/amaze/formatter/ascii/polar.rb

@@ -0,0 +1,199 @@
+
+class Amaze::Formatter::ASCII::Polar < Amaze::Formatter::ASCII
+  
+  def draw_cell cell
+    x1, x2, y1, y2 = coord cell
+    
+    # corners
+    char[y1][x1] = corner.color(grid_color)
+    char[y1][x2] = corner.color(grid_color)
+    char[y2][x1] = corner.color(grid_color)
+    char[y2][x2] = corner.color(grid_color)
+    # top & bottom
+    (x1+1).upto(x2-1) do |i|
+      # top (inward)
+      char[y1][i] = h.color(grid_color) unless cell.linked_to?(:inward)
+      # bottom (outward)
+      char[y2][i] = h.color(grid_color) if cell.row == grid.rows-1
+    end
+    # left & right
+    (y1+1).upto(y2-1) do |i|
+      # left (cw)
+      char[i][x1] = v.color(grid_color) unless cell.linked_to?(:cw)
+      # right (ccw)
+      char[i][x2] = v.color(grid_color) unless cell.linked_to?(:ccw)
+    end
+  end
+
+  def draw_content cell
+    x1, x2, y1, y2 = coord cell
+    _, my = center_coord cell
+    dx = x2 - x1 - 1 
+
+    distance(cell).center(dx).chars.each_with_index do |c,i|
+      char[my][x1+1+i] = c.color(*distance_color(cell))
+    end
+  end
+
+  def draw_path cell
+    # draw horizontal connections in cells with more than one outward path
+    if outward_subdivided?(cell) && ! path?(:cw, cell) && ! path?(:ccw, cell)
+      outward_cells = path_outward(cell)
+      if outward_cells.any?
+        mx, my = center_coord cell
+        x_outward_cells = outward_cells.map{|c| x,_ = center_coord c; x}
+        mx = x_outward_cells.first if cell.row.zero?
+        mx_min = [mx, *x_outward_cells].min
+        mx_max = [mx, *x_outward_cells].max
+        char[my][mx_min] = center.color(path_color)
+        char[my][mx_max] = center.color(path_color)
+        (mx_min+1).upto(mx_max-1) do |i|
+          char[my][i] = h.color(path_color)
+        end
+      end
+    end
+    
+    # to cw
+    if path?(:cw, cell)
+      mx1, my1 = center_coord cell.cw
+      mx2, my2 = center_coord cell
+      if outward_subdivided? cell
+        outward_cells_cw = path_outward cell.cw
+        mx1, _ = center_coord(outward_cells_cw.first) if outward_cells_cw.any?
+        outward_cells = path_outward cell
+        mx2, _ = center_coord(outward_cells.first) if outward_cells.any?
+      end
+      mx1 = -1 if mx1 > mx2
+      (mx1+1).upto(mx2-1) do |i|
+        char[my1][i] = h.color(path_color)
+      end
+      char[my1][mx2] = center.color(path_color)
+    end
+    
+    # to ccw
+    if path?(:ccw, cell)
+      mx1, my1 = center_coord cell
+      mx2, my2 = center_coord cell.ccw
+      if outward_subdivided? cell
+        outward_cells = path_outward cell
+        mx1, _ = center_coord(outward_cells.first) if outward_cells.any?
+        outward_cells_ccw = path_outward cell.ccw
+        mx2, _ = center_coord(outward_cells_ccw.first) if outward_cells_ccw.any?
+      end
+      mx2 = char_array_width if mx1 > mx2
+      (mx1+1).upto(mx2-1) do |i|
+        char[my1][i] = h.color(path_color)
+      end
+      char[my1][mx1] = center.color(path_color)
+    end
+    
+    # to inward
+    if path?(:inward, cell)
+      mx, my = center_coord cell
+      v1, v2, w1, w2 = coord cell.inward
+      mw = (w1 + w2) / 2
+      (mw+1).upto(my-1) do |i|
+        char[i][mx] = v.color(path_color)
+      end
+    end
+
+    # center
+    mx, my = center_coord cell
+    if outward_subdivided? cell
+      char[my][mx] = h.color(path_color) if path?(:ccw, cell) && path?(:cw, cell)
+      char[my][mx] = center.color(path_color) if path?(:inward, cell) && path_outward(cell).empty?
+    else
+      center_char = center
+      center_char = h if path?(:ccw, cell) && path?(:cw, cell)
+      center_char = v if path?(:inward, cell) && path_outward(cell).any?
+      char[my][mx] = center_char.color(path_color)
+    end
+  end
+  
+  def outward_subdivided? cell
+    return false if grid.rows == cell.row + 1
+    grid.columns(cell.row).size != grid.columns(cell.row+1).size
+  end
+  
+  def path_outward cell
+    cell.outward.select {|o| cell.linked?(o) && path_cell?(o) }
+  end
+  
+  def coord cell
+    columns = grid.columns(cell.row).size
+    x2 = char_array_width - 1 - x(cell.column, columns)
+    x1 = char_array_width - 1 - x(cell.column+1, columns)
+    y1 = y(cell.row)
+    y2 = y(cell.row+1)
+    
+    [x1, x2, y1, y2]
+  end
+  
+  def center_coord cell
+    x1, x2, y1, y2 = coord cell
+    [(x1 + x2) / 2, (y1 + y2) / 2]
+  end
+  
+  def x column, columns=max_columns
+    factor = max_columns / columns
+    (cell_size * 4 * factor) * column
+  end
+  
+  def y row
+    (cell_size + 1) * row
+  end
+  
+  def max_columns
+    grid.columns(grid.rows-1).size
+  end
+  
+  def char_array_width
+    x(max_columns) + 1
+  end
+  
+  def char_array_height
+    y(grid.rows) + 1
+  end
+  
+  def h
+    '-'
+  end
+  
+  def v
+    '|'
+  end
+  
+  def center
+    '∙'
+  end
+    
+  def corner
+    '+'
+  end
+end
+
+__END__
+
++-----------------------------------------------+ 47   f=12  columns/column * 3 + columns/column-1
+|                                               |
++---------------+---------------+---------------+ 15   f=4
+|               |               |               |
++-------+-------+-------+-------+-------+-------+ 7    f=2
+|       |       |       |       |       |       |
++---+---+---+---+---+---+---+---+---+---+---+---+ 3    f=1
+|   |   |   |   |   |   |   |   |   |   |   |   |
++---+---+---+---+---+---+---+---+---+---+---+---+
+
++-----------------------------------------------------------------------------------+
+|                                                                                   |
+|                                                                                   |
++---------------------------+---------------------------+---------------------------+
+|                           |                           |                           |
+|                           |                           |                           |
++-------------+-------------+-------------+-------------+-------------+-------------+
+|             |             |             |             |             |             |
+|             |             |             |             |             |             |
++------+------+------+------+------+------+------+------+------+------+------+------+
+|      |      |      |      |      |      |      |      |      |      |      |      |
+|      |      |      |      |      |      |      |      |      |      |      |      |
++------+------+------+------+------+------+------+------+------+------+------+------+