amaze 0.2.0

data/lib/amaze/formatter/image.rb

@@ -0,0 +1,127 @@
+
+require 'rmagick'
+
+class Amaze::Formatter::Image
+  autoload :Ortho, 'amaze/formatter/image/ortho'
+  autoload :Sigma, 'amaze/formatter/image/sigma'
+  autoload :Delta, 'amaze/formatter/image/delta'
+  autoload :Upsilon, 'amaze/formatter/image/upsilon'
+  autoload :Polar, 'amaze/formatter/image/polar'
+  
+  # The grid
+  attr_reader :grid
+  
+  # Options for the Image renderer
+  attr_reader :options
+  
+  def initialize grid, options={}
+    @grid = grid
+    @options = options
+  end
+  
+  def path? direction, cell
+    cell.linked?(cell.send(direction)) && path_cell?(cell.send(direction))
+  end
+  
+  def path_cell? cell
+    path_cells.include? cell
+  end
+  
+  def path_cells
+    Array(options[:path_cells])
+  end
+  
+  def path_start
+    options[:path_start]
+  end
+  
+  def path_finish
+    options[:path_finish]
+  end
+  
+  def render
+    render_background if distances
+    render_grid if show_grid?
+    render_wall unless hide_walls?
+    render_path if path_cells.any?
+  end
+  
+  def image
+    @image ||= Magick::Image.new image_width, image_height, Magick::SolidFill.new(background_color)
+  end
+  
+  def canvas
+    @canvas ||= Magick::Draw.new
+  end
+
+  def write filename
+    canvas.draw image
+    image.write(filename)
+  end
+  
+  def cell_width
+    @options[:cell_width] || 100
+  end
+  
+  def border_width
+    @options[:border_width] || 0
+  end
+  
+  def wall_width
+    @options[:wall_width] || 5
+  end
+
+  def wall_color
+    @options[:wall_color].to_s || 'black'
+  end
+
+  def path_width
+    @options[:path_width] || 3
+  end
+
+  def path_color
+    @options[:path_color].to_s || 'red'
+  end
+
+  def background_color
+    @options[:background_color].to_s || 'white'
+  end
+  
+  def show_grid?
+    @options[:show_grid]
+  end
+  
+  def hide_walls?
+    @options[:hide_walls]
+  end
+  
+  def cell_offset
+    wall_width / 2.0 + border_width
+  end
+  
+  def distances
+    options[:distances]
+  end
+
+  def distances_max
+    @distances_max ||= distances.max[1]
+  end
+  
+  # Returns the background color of a cell, depending on its distance from the origin
+  def distance_color cell
+    if distances && distances[cell]
+      intensity = (distances_max - distances[cell].to_f) / distances_max
+      '#' + gradient.at(intensity).color.hex
+    else
+      nil
+    end
+  end
+  
+  def gradient
+    options[:gradient_map]
+  end
+  
+  def self.colors
+    Magick.colors.map(&:name)
+  end
+end

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

@@ -0,0 +1,123 @@
+
+class Amaze::Formatter::Image::Delta < Amaze::Formatter::Image
+  
+  def render_background
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'round'
+    canvas.stroke_linejoin 'round'
+    canvas.stroke 'none'
+    grid.each_cell do |cell|
+      color = distance_color cell
+      next unless color
+      canvas.fill color
+      canvas.polygon *coord(cell)
+    end
+  end
+  
+  def render_grid
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'round'
+    canvas.stroke_linejoin 'round'
+    canvas.stroke 'gray90'
+    canvas.stroke_width 1
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      canvas.polygon *coord(cell)
+    end
+  end
+  
+  def render_wall
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'round'
+    canvas.stroke_linejoin 'round'
+    canvas.stroke wall_color
+    canvas.stroke_width wall_width
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      ax, ay, bx, by, cx, cy = coord cell
+      
+      canvas.line ax, ay, cx, cy unless cell.linked_to?(:west)
+      canvas.line bx, by, cx, cy unless cell.linked_to?(:east)
+
+      direction = (cell.row+cell.column).even? ? :north : :south
+      canvas.line ax, ay, bx, by unless cell.linked_to?(direction)
+    end
+  end
+  
+  def render_path
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'round'
+    canvas.stroke_linejoin 'round'
+    canvas.fill 'none'
+    canvas.stroke path_color
+    canvas.stroke_width path_width
+    
+    grid.each_cell do |cell|
+      next unless path_cell? cell
+
+      x1, y1 = center_coord cell
+      %i( north east ).each do |direction|
+        next unless path?(direction, cell)
+        x2, y2 = center_coord cell.send(direction)
+        canvas.line x1, y1, x2, y2
+      end
+    end
+
+    # draw start and finish
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'round'
+    canvas.fill path_color
+    canvas.stroke 'none'
+    [path_start, path_finish].compact.each do |cell|
+      x, y = center_coord cell
+      canvas.ellipse x, y, path_width*2, path_width*2, 0, 360
+    end
+  end
+  
+  def coord cell
+    row, column = cell.row, cell.column
+
+    x1 = column * pattern_width + cell_offset
+    y1 = row * pattern_height + cell_offset
+    x2 = x1 + pattern_width
+    x3 = x2 + pattern_width
+    y2 = y1 + pattern_height
+    
+    if (row+column).even?
+      [x1, y1, x3, y1, x2, y2]
+    else
+      [x1, y2, x3, y2, x2, y1]
+    end
+  end
+  
+  def center_coord cell
+    row, column = cell.row, cell.column
+    
+    x = (column+1) * pattern_width + cell_offset
+    y0 = row * pattern_height + cell_offset
+    
+    dy = cell_width * Math.sqrt(3)
+    fraction = (row+column).even? ? 6.0 : 3.0
+    y = y0 + dy / fraction
+    
+    [x, y]
+  end
+  
+  def pattern_width
+    @pattern_width ||= cell_width / 2.0
+  end
+  
+  def pattern_height
+    @pattern_height ||= cell_width * Math.sqrt(3) / 2.0
+  end
+  
+  def image_width
+    pattern_width * (grid.columns + 1) + wall_width + border_width * 2 + 1
+  end
+  
+  def image_height
+    pattern_height * grid.rows + wall_width + border_width * 2 + 1
+  end
+end

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

@@ -0,0 +1,103 @@
+
+class Amaze::Formatter::Image::Ortho < Amaze::Formatter::Image
+  
+  def render_background
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.stroke 'none'
+    grid.each_cell do |cell|
+      color = distance_color cell
+      next unless color
+      canvas.fill color
+      x1, x2, y1, y2 = coord cell
+      canvas.polygon x1, y1, x2, y1, x2, y2, x1, y2
+    end
+  end
+  
+  def render_grid
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.stroke 'gray90'
+    canvas.stroke_width 1
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      x1, x2, y1, y2 = coord cell
+      canvas.polygon x1, y1, x2, y1, x2, y2, x1, y2
+    end
+  end  
+
+  def render_wall
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.stroke wall_color
+    canvas.stroke_width wall_width
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      x1, x2, y1, y2 = coord cell
+      
+      canvas.line x1, y1, x2, y1 unless cell.linked_to?(:north)
+      canvas.line x2, y1, x2, y2 unless cell.linked_to?(:east)
+      canvas.line x1, y2, x2, y2 unless cell.linked_to?(:south)
+      canvas.line x1, y1, x1, y2 unless cell.linked_to?(:west)
+    end
+  end
+  
+  def render_path
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.fill 'none'
+    canvas.stroke path_color
+    canvas.stroke_width path_width
+    
+    grid.each_cell do |cell|
+      next unless path_cell? cell
+
+      x1, y1 = center_coord cell
+      %i( north east ).each do |direction|
+        next unless path?(direction, cell)
+        x2, y2 = center_coord cell.send(direction)
+        canvas.line x1, y1, x2, y2
+      end
+    end
+
+    # draw start and finish
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.fill path_color
+    canvas.stroke 'none'
+    [path_start, path_finish].compact.each do |cell|
+      x, y = center_coord cell
+      canvas.ellipse x, y, path_width*2, path_width*2, 0, 360
+    end
+  end
+  
+  def coord cell
+    row, column = cell.row, cell.column
+    
+    x1 = column * cell_width + cell_offset
+    x2 = (column+1) * cell_width + cell_offset
+    y1 = row * cell_width + cell_offset
+    y2 = (row+1) * cell_width + cell_offset
+    
+    [x1, x2, y1, y2]
+  end
+  
+  def center_coord cell
+    row, column = cell.row, cell.column
+    
+    x = (column+0.5) * cell_width + cell_offset
+    y = (row+0.5) * cell_width + cell_offset
+    
+    [x, y]
+  end
+  
+  def image_width
+    cell_width * grid.columns + wall_width + border_width * 2 + 1
+  end
+  
+  def image_height
+    cell_width * grid.rows + wall_width + border_width * 2 + 1
+  end
+end

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

@@ -0,0 +1,173 @@
+
+class Amaze::Formatter::Image::Polar < Amaze::Formatter::Image
+  
+  def render_background
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'butt'
+    canvas.stroke_width cell_width
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      color = distance_color cell
+      next unless color
+      canvas.stroke color
+      _, _, _, _, _, ccw, cw = coord cell
+      radius, _ = center_coord cell
+      canvas.ellipse image_center, image_center, radius, radius, ccw, cw
+    end
+  end
+  
+  def render_grid
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.stroke 'gray90'
+    canvas.stroke_width 1
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      next if cell.row == 0
+      cx, cy, dx, dy, radius, ccw, cw = coord cell
+  
+      canvas.ellipse image_center, image_center, radius, radius, ccw, cw
+      canvas.line cx, cy, dx, dy
+    end
+    canvas.ellipse(image_center, image_center, grid.rows * cell_width, grid.rows * cell_width, 0, 360)
+  end
+  
+  def render_wall
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.stroke wall_color
+    canvas.stroke_width wall_width
+    canvas.fill 'none'
+
+    grid.each_cell do |cell|
+      next if cell.row == 0
+      cx, cy, dx, dy, radius, ccw, cw = coord cell
+      
+      canvas.ellipse image_center, image_center, radius, radius, ccw, cw unless cell.linked_to?(:inward)
+      canvas.line cx, cy, dx, dy unless cell.linked_to?(:cw)
+    end
+    
+    canvas.ellipse(image_center, image_center, grid.rows * cell_width, grid.rows * cell_width, 0, 360)
+  end
+  
+  def render_path
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.fill 'none'
+    canvas.stroke path_color
+    canvas.stroke_width path_width
+
+    grid.each_cell do |cell|
+      next unless path_cell? cell
+
+      unless path?(:cw, cell) || path?(:ccw, cell)
+        # draw arc to close the gap if outward ring is subdivided
+        # and cell is linked outwards but not cw and ccw
+        # this can be the case even for cell(0,0)
+        outward_cells = path_outward(cell)
+        if outward_subdivided?(cell) && outward_cells.any?
+          radius, angle = center_coord cell
+          angles_outward_cells = outward_cells.map {|o| _, a = center_coord(o); a }
+          # don't use cell(0,0) own angel, override with one of the outward cells
+          angle = angles_outward_cells.first if cell.row == 0
+          angle1 = [angle, *angles_outward_cells].min
+          angle2 = [angle, *angles_outward_cells].max
+          canvas.ellipse image_center, image_center, radius, radius, angle1, angle2 unless angle1 == angle2
+        end
+      end
+
+      next if cell.row == 0
+      
+      if path?(:inward, cell)
+        radius, theta = center_coord cell, :radian
+        # center of cell
+        x1, y1 = polar2cartesian(radius, theta)
+        # center of inward cell, but adjusted to the same angle of the current cell
+        x2, y2 = polar2cartesian(radius - cell_width, theta)
+        canvas.line x1, y1, x2, y2
+      end
+      
+      if path?(:cw, cell)
+        radius1, angle1 = center_coord cell
+        radius2, angle2 = center_coord cell.cw
+        # adjust angle if outward ring is subdivided
+        if outward_subdivided?(cell)
+          outward_cells = path_outward(cell)
+          _, angle1 = center_coord(outward_cells.first) if outward_cells.any?
+          outward_cells_cw = path_outward(cell.cw)
+          _, angle2 = center_coord(outward_cells_cw.first) if outward_cells_cw.any?
+        end
+        canvas.ellipse image_center, image_center, radius1, radius1, angle1, angle2
+      end
+    end
+    
+    # draw start and finish
+    canvas.stroke_antialias true
+    canvas.stroke_linecap 'square'
+    canvas.fill path_color
+    canvas.stroke 'none'
+    [path_start, path_finish].compact.each do |cell|
+      x, y = polar2cartesian(*center_coord(cell, :radian))
+      canvas.ellipse x, y, path_width*2, path_width*2, 0, 360
+    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, unit=:degree
+    inner_radius = cell.row * cell_width
+    outer_radius = (cell.row + 1) * cell_width
+    theta = 2 * Math::PI / grid.columns(cell.row).size
+    theta_ccw = cell.column * theta
+    theta_cw = (cell.column + 1) * theta
+    
+    # we need only the cartesian coords of the cw wall
+    # ax, ay = polar2cartesian(inner_radius, theta_ccw)
+    # bx, by = polar2cartesian(outer_radius, theta_ccw)
+    cx, cy = polar2cartesian(inner_radius, theta_cw)
+    dx, dy = polar2cartesian(outer_radius, theta_cw)
+    
+    if unit == :degree
+      theta_ccw = radian2degree theta_ccw
+      theta_cw = radian2degree theta_cw
+    end
+    
+    [cx, cy, dx, dy, inner_radius, theta_ccw, theta_cw]
+  end
+
+  def center_coord cell, unit=:degree
+    radius = (cell.row + 0.5) * cell_width
+    theta = 2 * Math::PI / grid.columns(cell.row).size
+    angle = (cell.column + 0.5) * theta
+    angle = radian2degree(angle) if unit == :degree
+
+    [radius, angle]
+  end
+  
+  def polar2cartesian radius, theta
+    [image_center + radius * Math.cos(theta), image_center + radius * Math.sin(theta)]
+  end
+  
+  def radian2degree value
+    360 / (2 * Math::PI) * value
+  end
+  
+  def image_width
+    cell_width * grid.rows * 2 + wall_width + border_width * 2 + 3 # why? +3
+  end
+  
+  alias_method :image_height, :image_width
+  
+  def image_center
+    image_width / 2
+  end
+end