theseus 1.0.0

data/lib/theseus/formatters/png.rb

@@ -0,0 +1,183 @@
+require 'chunky_png'
+
+module Theseus
+  module Formatters
+    # This is an abstract superclass for PNG formatters. It simply provides some common
+    # utility and drawing methods that subclasses can take advantage of, to render
+    # mazes to a PNG canvas.
+    #
+    # Colors are given as 32-bit integers, with each RGBA component occupying 1 byte.
+    # R is the highest byte, A is the lowest byte. In other words, 0xFF0000FF is an
+    # opaque red, and 0x7f7f7f7f is a semi-transparent gray. 0x0 is fully transparent.
+    #
+    # You may also provide the colors as hexadecimal string values, and they will be
+    # converted to the corresponding integers.
+    class PNG
+      # The default options. Note that not all PNG formatters honor all of these options;
+      # specifically, +:wall_width+ is not consistently supported across all formatters.
+      DEFAULTS = {
+        :cell_size      => 10,
+        :wall_width     => 1,
+        :wall_color     => 0x000000FF,
+        :cell_color     => 0xFFFFFFFF,
+        :solution_color => 0xFFAFAFFF,
+        :background     => 0x00000000,
+        :outer_padding  => 2,
+        :cell_padding   => 1,
+        :solution       => false
+      }
+
+      # North, whether in the under or primary plane
+      ANY_N = Maze::N | (Maze::N << Maze::UNDER_SHIFT)
+
+      # South, whether in the under or primary plane
+      ANY_S = Maze::S | (Maze::S << Maze::UNDER_SHIFT)
+
+      # West, whether in the under or primary plane
+      ANY_W = Maze::W | (Maze::W << Maze::UNDER_SHIFT)
+
+      # East, whether in the under or primary plane
+      ANY_E = Maze::E | (Maze::E << Maze::UNDER_SHIFT)
+
+      # The options to use for the formatter. These are the ones passed
+      # to the constructor, plus the ones from the DEFAULTS hash.
+      attr_reader :options
+
+      # The +options+ must be a hash of any of the following options:
+      #
+      # [:cell_size]      The number of pixels on a side that each cell
+      #                   should occupy. Different maze types will use that
+      #                   space differently. Also, the cell padding is applied
+      #                   inside the cell, and so consumes some of the area.
+      #                   The default is 10.
+      # [:wall_width]     How thick the walls should be drawn. The default is 1.
+      #                   Note that not all PNG formatters will honor this value
+      #                   (yet).
+      # [:wall_color]     The color to use when drawing the wall. Defaults to black.
+      # [:cell_color]     The color to use when drawing the cell. Defaults to white.
+      # [:solution_color] The color to use when drawing the solution path. This is
+      #                   only used when the :solution option is given.
+      # [:background]     The color to use for the background of the maze. Defaults
+      #                   to transparent.
+      # [:outer_padding]  The extra padding (in pixels) to add around the outside
+      #                   edge of the maze. Defaults to 2.
+      # [:cell_padding]   The padding (in pixels) to add around the inside of each
+      #                   cell. This has the effect of separating the cells. The
+      #                   default cell padding is 1.
+      # [:solution]       A boolean value indicating whether or not to draw the
+      #                   solution path as well. The default is false.
+      def initialize(maze, options)
+        @options = DEFAULTS.merge(options)
+
+        [:background, :wall_color, :cell_color, :solution_color].each do |c|
+          @options[c] = ChunkyPNG::Color.from_hex(@options[c]) unless Fixnum === @options[c]
+        end
+
+        @paths = @options[:paths] || []
+
+        if @options[:solution]
+          path = maze.new_solver(type: @options[:solution]).solve.to_path(color: @options[:solution_color])
+          @paths = [path, *@paths]
+        end
+      end
+
+      # Returns the raw PNG data for the formatter.
+      def to_blob
+        @blob
+      end
+
+      # Returns the color at the given point by considering all provided paths. The
+      # +:color: metadata from the first path that is set at the given point is
+      # returned. If no path describes the given point, then the value of the
+      # +:cell_color+ option is returned.
+      def color_at(pt, direction=nil)
+        @paths.each do |path|
+          return path[:color] if direction ? path.path?(pt, direction) : path.set?(pt)
+        end
+
+        return @options[:cell_color]
+      end
+
+      # Returns a new 2-tuple (x2,y2), where x2 is point[0] + dx, and y2 is point[1] + dy.
+      def move(point, dx, dy)
+        [point[0] + dx, point[1] + dy]
+      end
+
+      # Clamps the value +x+ so that it lies between +low+ and +hi+. In other words,
+      # returns +low+ if +x+ is less than +low+, and +high+ if +x+ is greater than
+      # +high+, and returns +x+ otherwise.
+      def clamp(x, low, hi)
+        x = low if x < low
+        x = hi  if x > hi
+        return x
+      end
+
+      # Draws a line from +p1+ to +p2+ on the given canvas object, in the given
+      # color. The coordinates of the given points are clamped (naively) to lie
+      # within the canvas' bounds.
+      def line(canvas, p1, p2, color)
+        canvas.line(
+          clamp(p1[0].round, 0, canvas.width-1),
+          clamp(p1[1].round, 0, canvas.height-1),
+          clamp(p2[0].round, 0, canvas.width-1),
+          clamp(p2[1].round, 0, canvas.height-1),
+          color)
+      end
+
+      # Fills the rectangle defined by the given coordinates with the given color.
+      # The coordinates are clamped to lie within the canvas' bounds.
+      def fill_rect(canvas, x0, y0, x1, y1, color)
+        x0 = clamp(x0, 0, canvas.width-1)
+        y0 = clamp(y0, 0, canvas.height-1)
+        x1 = clamp(x1, 0, canvas.width-1)
+        y1 = clamp(y1, 0, canvas.height-1)
+        [x0, x1].min.ceil.upto([x0, x1].max.floor) do |x|
+          [y0, y1].min.ceil.upto([y0, y1].max.floor) do |y|
+            canvas.point(x, y, color)
+          end
+        end
+      end
+
+      # Fills the polygon defined by the +points+ array, with the given +color+.
+      # Each element of +points+ must be a 2-tuple describing a vertex of the
+      # polygon. It is assumed that the polygon is closed. All points are
+      # clamped (naively) to lie within the canvas' bounds.
+      def fill_poly(canvas, points, color)
+        min_y = 1_000_000
+        max_y = -1_000_000
+        points.each do |x,y|
+          min_y = y if y < min_y
+          max_y = y if y > max_y
+        end
+
+        min_y = clamp(min_y, 0, canvas.height-1)
+        max_y = clamp(max_y, 0, canvas.height-1)
+
+        min_y.floor.upto(max_y.ceil) do |y|
+          nodes = []
+
+          prev = points.last
+          points.each do |point|
+            if point[1] < y && prev[1] >= y || prev[1] < y && point[1] >= y
+              nodes << (point[0] + (y - point[1]).to_f / (prev[1] - point[1]) * (prev[0] - point[0]))
+            end
+            prev = point
+          end
+
+          next if nodes.empty?
+          nodes.sort!
+
+          prev = nil
+          0.step(nodes.length-1, 2) do |a|
+            x1, x2 = nodes[a], nodes[a+1]
+            x1, x2 = x2, x1 if x1 > x2
+            next if x1 < 0 || x2 >= canvas.width
+            x1.ceil.upto(x2.floor) do |x|
+              canvas.point(x, y, color)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theseus/formatters/png/delta.rb

@@ -0,0 +1,85 @@
+require 'theseus/formatters/png'
+
+module Theseus
+  module Formatters
+    class PNG
+      # Renders a DeltaMaze to a PNG canvas. Does not currently support the
+      # +:wall_width+ option.
+      #
+      # You will almost never access this class directly. Instead, use
+      # DeltaMaze#to(:png, options) to return the raw PNG data directly.
+      class Delta < PNG
+        # Create and return a fully initialized PNG::Delta object, with the
+        # maze rendered. To get the maze data, call #to_blob.
+        #
+        # See Theseus::Formatters::PNG for a list of all supported options.
+        def initialize(maze, options={})
+          super
+
+          height = @options[:outer_padding] * 2 + maze.height * @options[:cell_size]
+          width = @options[:outer_padding] * 2 + (maze.width + 1) * @options[:cell_size] / 2
+
+          canvas = ChunkyPNG::Image.new(width, height, @options[:background])
+
+          maze.height.times do |y|
+            py = @options[:outer_padding] + y * @options[:cell_size]
+            maze.row_length(y).times do |x|
+              px = @options[:outer_padding] + x * @options[:cell_size] / 2.0
+              draw_cell(canvas, [x, y], maze.points_up?(x,y), px, py, maze[x, y])
+            end
+          end
+
+          @blob = canvas.to_blob
+        end
+
+        private
+
+        def draw_cell(canvas, point, up, x, y, cell) #:nodoc:
+          return if cell == 0
+
+          p1 = [x + options[:cell_size] / 2.0, up ? (y + options[:cell_padding]) : (y + options[:cell_size] - options[:cell_padding])]
+          p2 = [x + options[:cell_padding], up ? (y + options[:cell_size] - options[:cell_padding]) : (y + options[:cell_padding])]
+          p3 = [x + options[:cell_size] - options[:cell_padding], p2[1]]
+
+          fill_poly(canvas, [p1, p2, p3], color_at(point))
+
+          if cell & (Maze::N | Maze::S) != 0
+            clr = color_at(point, (Maze::N | Maze::S))
+            dy = options[:cell_padding]
+            sign = (cell & Maze::N != 0) ? -1 : 1
+            r1, r2 = p2, move(p3, 0, sign*dy)
+            fill_rect(canvas, r1[0].round, r1[1].round, r2[0].round, r2[1].round, clr)
+            line(canvas, r1, [r1[0], r2[1]], options[:wall_color])
+            line(canvas, r2, [r2[0], r1[1]], options[:wall_color])
+          else
+            line(canvas, p2, p3, options[:wall_color])
+          end
+
+          dx = options[:cell_padding]
+          if cell & ANY_W != 0
+            r1, r2, r3, r4 = p1, move(p1,-dx,0), move(p2,-dx,0), p2
+            fill_poly(canvas, [r1, r2, r3, r4], color_at(point, ANY_W))
+            line(canvas, r1, r2, options[:wall_color])
+            line(canvas, r3, r4, options[:wall_color])
+          end
+
+          if cell & Maze::W == 0
+            line(canvas, p1, p2, options[:wall_color])
+          end
+
+          if cell & ANY_E != 0
+            r1, r2, r3, r4 = p1, move(p1,dx,0), move(p3,dx,0), p3
+            fill_poly(canvas, [r1, r2, r3, r4], color_at(point, ANY_E))
+            line(canvas, r1, r2, options[:wall_color])
+            line(canvas, r3, r4, options[:wall_color])
+          end
+
+          if cell & Maze::E == 0
+            line(canvas, p3, p1, options[:wall_color])
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/theseus/formatters/png/orthogonal.rb

@@ -0,0 +1,87 @@
+require 'theseus/formatters/png'
+
+module Theseus
+  module Formatters
+    class PNG
+      # Renders an OrthogonalMaze to a PNG canvas.
+      #
+      # You will almost never access this class directly. Instead, use
+      # OrthogonalMaze#to(:png, options) to return the raw PNG data directly.
+      class Orthogonal < PNG
+        # Create and return a fully initialized PNG::Orthogonal object, with the
+        # maze rendered. To get the maze data, call #to_blob.
+        #
+        # See Theseus::Formatters::PNG for a list of all supported options.
+        def initialize(maze, options={})
+          super
+
+          width  = @options[:outer_padding] * 2 + maze.width * @options[:cell_size]
+          height = @options[:outer_padding] * 2 + maze.height * @options[:cell_size]
+          
+          canvas = ChunkyPNG::Image.new(width, height, @options[:background])
+
+          @d1 = @options[:cell_padding]
+          @d2 = @options[:cell_size] - @options[:cell_padding]
+          @w1 = (@options[:wall_width] / 2.0).floor
+          @w2 = ((@options[:wall_width] - 1) / 2.0).floor
+
+          maze.height.times do |y|
+            py = @options[:outer_padding] + y * @options[:cell_size]
+            maze.width.times do |x|
+              px = @options[:outer_padding] + x * @options[:cell_size]
+              draw_cell(canvas, [x, y], px, py, maze[x, y])
+            end
+          end
+
+          @blob = canvas.to_blob
+        end
+
+        private
+
+        def draw_cell(canvas, point, x, y, cell) #:nodoc:
+          return if cell == 0
+
+          fill_rect(canvas, x + @d1, y + @d1, x + @d2, y + @d2, color_at(point))
+
+          north = cell & Maze::N == Maze::N
+          north_under = (cell >> Maze::UNDER_SHIFT) & Maze::N == Maze::N
+          south = cell & Maze::S == Maze::S
+          south_under = (cell >> Maze::UNDER_SHIFT) & Maze::S == Maze::S
+          west = cell & Maze::W == Maze::W
+          west_under = (cell >> Maze::UNDER_SHIFT) & Maze::W == Maze::W
+          east = cell & Maze::E == Maze::E
+          east_under = (cell >> Maze::UNDER_SHIFT) & Maze::E == Maze::E
+
+          draw_vertical(canvas, x, y, 1, north || north_under, !north || north_under, color_at(point, ANY_N))
+          draw_vertical(canvas, x, y + options[:cell_size], -1, south || south_under, !south || south_under, color_at(point, ANY_S))
+          draw_horizontal(canvas, x, y, 1, west || west_under, !west || west_under, color_at(point, ANY_W))
+          draw_horizontal(canvas, x + options[:cell_size], y, -1, east || east_under, !east || east_under, color_at(point, ANY_E))
+        end
+
+        def draw_vertical(canvas, x, y, direction, corridor, wall, color) #:nodoc:
+          if corridor
+            fill_rect(canvas, x + @d1, y, x + @d2, y + @d1 * direction, color)
+            fill_rect(canvas, x + @d1 - @w1, y - (@w1 * direction), x + @d1 + @w2, y + (@d1 + @w2) * direction, options[:wall_color])
+            fill_rect(canvas, x + @d2 - @w2, y - (@w1 * direction), x + @d2 + @w1, y + (@d1 + @w2) * direction, options[:wall_color])
+          end
+
+          if wall
+            fill_rect(canvas, x + @d1 - @w1, y + (@d1 - @w1) * direction, x + @d2 + @w2, y + (@d1 + @w2) * direction, options[:wall_color])
+          end
+        end
+
+        def draw_horizontal(canvas, x, y, direction, corridor, wall, color) #:nodoc:
+          if corridor
+            fill_rect(canvas, x, y + @d1, x + @d1 * direction, y + @d2, color)
+            fill_rect(canvas, x - (@w1 * direction), y + @d1 - @w1, x + (@d1 + @w2) * direction, y + @d1 + @w2, options[:wall_color])
+            fill_rect(canvas, x - (@w1 * direction), y + @d2 - @w2, x + (@d1 + @w2) * direction, y + @d2 + @w1, options[:wall_color])
+          end
+
+          if wall
+            fill_rect(canvas, x + (@d1 - @w1) * direction, y + @d1 - @w1, x + (@d1 + @w2) * direction, y + @d2 + @w2, options[:wall_color])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theseus/formatters/png/sigma.rb

@@ -0,0 +1,105 @@
+require 'theseus/formatters/png'
+
+module Theseus
+  module Formatters
+    class PNG
+      # Renders a SigmaMaze to a PNG canvas. Does not currently support the
+      # +:wall_width+ option.
+      #
+      # You will almost never access this class directly. Instead, use
+      # SigmaMaze#to(:png, options) to return the raw PNG data directly.
+      class Sigma < PNG
+        # Create and return a fully initialized PNG::Sigma object, with the
+        # maze rendered. To get the maze data, call #to_blob.
+        #
+        # See Theseus::Formatters::PNG for a list of all supported options.
+        def initialize(maze, options={})
+          super
+
+          width = @options[:outer_padding] * 2 + (3 * maze.width + 1) * @options[:cell_size] / 4
+          height = @options[:outer_padding] * 2 + maze.height * @options[:cell_size] + @options[:cell_size] / 2
+
+          canvas = ChunkyPNG::Image.new(width, height, @options[:background])
+
+          maze.height.times do |y|
+            py = @options[:outer_padding] + y * @options[:cell_size]
+            maze.row_length(y).times do |x|
+              px = @options[:outer_padding] + x * 3 * @options[:cell_size] / 4.0
+              shifted = (x % 2 != 0)
+              dy = shifted ? (@options[:cell_size] / 2.0) : 0
+              draw_cell(canvas, [x, y], shifted, px, py+dy, maze[x, y])
+            end
+          end
+
+          @blob = canvas.to_blob
+        end
+
+        private
+
+        def draw_cell(canvas, point, shifted, x, y, cell) #:nodoc:
+          return if cell == 0
+
+          size = options[:cell_size] - options[:cell_padding] * 2
+          s4 = size / 4.0
+
+          fs4 = options[:cell_size] / 4.0 # fs == full-size, without padding
+
+          p1 = [x + options[:cell_padding] + s4, y + options[:cell_padding]]
+          p2 = [x + options[:cell_size] - options[:cell_padding] - s4, p1[1]]
+          p3 = [x + options[:cell_padding] + size, y + options[:cell_size] / 2.0]
+          p4 = [p2[0], y + options[:cell_size] - options[:cell_padding]]
+          p5 = [p1[0], p4[1]]
+          p6 = [x + options[:cell_padding], p3[1]]
+
+          fill_poly(canvas, [p1, p2, p3, p4, p5, p6], color_at(point))
+
+          n  = Maze::N
+          s  = Maze::S
+          nw = shifted ? Maze::W : Maze::NW
+          ne = shifted ? Maze::E : Maze::NE
+          sw = shifted ? Maze::SW : Maze::W
+          se = shifted ? Maze::SE : Maze::E
+
+          any = proc { |x| x | (x << Maze::UNDER_SHIFT) }
+
+          if cell & any[s] != 0
+            r1, r2 = p5, move(p4, 0, options[:cell_padding]*2)
+            fill_rect(canvas, r1[0], r1[1], r2[0], r2[1], color_at(point, any[s]))
+            line(canvas, p5, move(p5, 0, options[:cell_padding]*2), options[:wall_color])
+            line(canvas, p4, move(p4, 0, options[:cell_padding]*2), options[:wall_color])
+          end
+
+          if cell & any[ne] != 0
+            ne_x = x + 3 * options[:cell_size] / 4.0
+            ne_y = y - options[:cell_size] * 0.5
+            ne_p5 = [ne_x + options[:cell_padding] + s4, ne_y + options[:cell_size] - options[:cell_padding]]
+            ne_p6 = [ne_x + options[:cell_padding], ne_y + options[:cell_size] * 0.5]
+            r1, r2, r3, r4 = p2, p3, ne_p5, ne_p6
+            fill_poly(canvas, [r1, r2, r3, r4], color_at(point, any[ne]))
+            line(canvas, r1, r4, options[:wall_color])
+            line(canvas, r2, r3, options[:wall_color])
+          end
+
+          if cell & any[se] != 0
+            se_x = x + 3 * options[:cell_size] / 4.0
+            se_y = y + options[:cell_size] * 0.5
+            se_p1 = [se_x + s4 + options[:cell_padding], se_y + options[:cell_padding]]
+            se_p6 = [se_x + options[:cell_padding], se_y + options[:cell_size] * 0.5]
+            r1, r2, r3, r4 = p3, p4, se_p6, se_p1
+            fill_poly(canvas, [r1, r2, r3, r4], color_at(point, any[se]))
+            line(canvas, r1, r4, options[:wall_color])
+            line(canvas, r2, r3, options[:wall_color])
+          end
+
+          line(canvas, p1, p2, options[:wall_color]) if cell & n == 0
+          line(canvas, p2, p3, options[:wall_color]) if cell & ne == 0
+          line(canvas, p3, p4, options[:wall_color]) if cell & se == 0
+          line(canvas, p4, p5, options[:wall_color]) if cell & s == 0
+          line(canvas, p5, p6, options[:wall_color]) if cell & sw == 0
+          line(canvas, p6, p1, options[:wall_color]) if cell & nw == 0
+        end
+      end
+    end
+  end
+end
+