jslade-gruff 0.3.5

data/lib/gruff/bar.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/bar_conversion'
+require File.dirname(__FILE__) + '/ldata_mixin'
+
+class Gruff::Bar < Gruff::Base
+  include LdataMixin
+
+  def draw
+    # Labels will be centered over the left of the bar if
+    # there are more labels than columns. This is basically the same 
+    # as where it would be for a line graph.
+    @center_labels_over_point = (@labels.keys.length > @column_count ? true : false)
+    
+    super
+    draw_bars if @has_data
+    draw_ldata if @has_ldata
+  end
+
+protected
+
+  def draw_bars
+    # Setup spacing.
+    #
+    # Columns sit side-by-side.
+    spacing_factor = 0.9 # space between the bars
+    @bar_width = @graph_width / (@column_count * @data.length).to_f
+    padding = (@bar_width * (1 - spacing_factor)) / 2
+
+    @d = @d.stroke_opacity 0.0
+
+    # Setup the BarConversion Object
+    conversion = Gruff::BarConversion.new()
+    conversion.graph_height = @graph_height
+    conversion.graph_top = @graph_top
+
+    # Set up the right mode [1,2,3] see BarConversion for further explanation
+    if @minimum_value >= 0 then
+      # all bars go from zero to positiv
+      conversion.mode = 1
+    else
+      # all bars go from 0 to negativ
+      if @maximum_value <= 0 then
+        conversion.mode = 2
+      else
+        # bars either go from zero to negativ or to positiv
+        conversion.mode = 3
+        conversion.spread = @spread
+        conversion.minimum_value = @minimum_value
+        conversion.zero = -@minimum_value/@spread
+      end
+    end
+
+    # iterate over all normalised data
+    @norm_data.each_with_index do |data_row, row_index|
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+        # Use incremented x and scaled y
+        # x
+        left_x = @graph_left + (@bar_width * (row_index + point_index + ((@data.length - 1) * point_index))) + padding
+        right_x = left_x + @bar_width * spacing_factor
+        # y
+        conv = []
+        conversion.getLeftYRightYscaled( data_point, conv )
+
+        # create new bar
+        @d = @d.fill data_row[DATA_COLOR_INDEX]
+        @d = @d.rectangle(left_x, conv[0], right_x, conv[1])
+
+        # Calculate center based on bar_width and current row
+        label_center = @graph_left + 
+                      (@data.length * @bar_width * point_index) + 
+                      (@data.length * @bar_width / 2.0)
+        # Subtract half a bar width to center left if requested
+        draw_label(label_center - (@center_labels_over_point ? @bar_width / 2.0 : 0.0), point_index)
+
+	if @has_ldata
+	  @ldata_offset_and_increment[row_index] ||=
+	    [ label_center, @bar_width * @norm_data.size ]
+	end
+      end
+      
+    end
+
+    # Draw the last label if requested
+    draw_label(@graph_right, @column_count) if @center_labels_over_point
+
+    @d.draw(@base_image)
+  end
+
+  
+  def calc_ldata_on_bar row_index, point_index, label_center, bar_width
+    # Save the x mid point of the first bar and the x distance between 2
+    # bars of the same data set to be used to position ldata points.
+    line_info = @ldata_offset_and_increment[row_index] ||= Array.new
+    if point_index == 0
+      line_info[0] = label_center
+    else
+      if line_info[1].nil?
+	line_info[1] = label_center - line_info[0]
+      end
+    end
+  end
+
+  
+end

data/lib/gruff/bar_conversion.rb

@@ -0,0 +1,46 @@
+##
+# Original Author: David Stokar
+#
+#	This class perfoms the y coordinats conversion for the bar class.
+#
+#	There are three cases: 
+#
+#   1. Bars all go from zero in positive direction
+#		2. Bars all go from zero to negative direction	
+#		3. Bars either go from zero to positive or from zero to negative
+#
+class Gruff::BarConversion
+	attr_writer :mode
+	attr_writer :zero
+	attr_writer :graph_top
+	attr_writer :graph_height
+	attr_writer :minimum_value
+	attr_writer :spread
+	
+	def getLeftYRightYscaled( data_point, result )
+		case @mode
+		when 1 then # Case one
+			# minimum value >= 0 ( only positiv values )
+      result[0] = @graph_top + @graph_height*(1 - data_point) + 1
+  		result[1] = @graph_top + @graph_height - 1
+		when 2 then  # Case two
+			# only negativ values
+   		result[0] = @graph_top + 1
+  		result[1] = @graph_top + @graph_height*(1 - data_point) - 1
+		when 3 then # Case three
+			# positiv and negativ values
+    	val = data_point-@minimum_value/@spread
+    	if ( data_point >= @zero ) then
+    		result[0] = @graph_top + @graph_height*(1 - (val-@zero)) + 1
+	    	result[1] = @graph_top + @graph_height*(1 - @zero) - 1
+    	else
+				result[0] = @graph_top + @graph_height*(1 - (val-@zero)) + 1
+	    	result[1] = @graph_top + @graph_height*(1 - @zero) - 1
+    	end
+		else
+			result[0] = 0.0
+			result[1] = 0.0
+		end				
+	end	
+
+end

data/lib/gruff/base.rb

@@ -0,0 +1,925 @@
+require 'rubygems'
+require 'RMagick'
+
+require File.dirname(__FILE__) + '/deprecated'
+
+##
+# = Gruff. Graphs.
+#
+# Author:: Geoffrey Grosenbach boss@topfunky.com
+#
+# Originally Created:: October 23, 2005
+#
+# Extra thanks to Tim Hunter for writing RMagick, and also contributions by
+# Jarkko Laine, Mike Perham, Andreas Schwarz, Alun Eyre, Guillaume Theoret,
+# David Stokar, Paul Rogers, Dave Woodward, Frank Oxener, Kevin Clark, Cies
+# Breijs, Richard Cowin, and a cast of thousands.
+#
+# See Gruff::Base#theme= for setting themes.
+
+module Gruff
+
+  # This is the version of Gruff you are using.
+  VERSION = '0.3.5'
+
+  class Base
+
+    include Magick
+    include Deprecated
+
+    # Draw extra lines showing where the margins and text centers are
+    DEBUG = false
+
+    # Used for navigating the array of data to plot
+    DATA_LABEL_INDEX = 0
+    DATA_VALUES_INDEX = 1
+    DATA_COLOR_INDEX = 2
+    DATA_ATTRS_INDEX = 3
+
+    # Space around text elements. Mostly used for vertical spacing
+    LEGEND_MARGIN = TITLE_MARGIN = LABEL_MARGIN = 10.0
+
+    DEFAULT_TARGET_WIDTH = 800
+
+    # Blank space above the graph
+    attr_accessor :top_margin
+
+    # Blank space below the graph
+    attr_accessor :bottom_margin
+
+    # Blank space to the right of the graph
+    attr_accessor :right_margin
+
+    # Blank space to the left of the graph
+    attr_accessor :left_margin
+
+    # A hash of names for the individual columns, where the key is the array
+    # index for the column this label represents.
+    #
+    # Not all columns need to be named.
+    #
+    # Example: 0 => 2005, 3 => 2006, 5 => 2007, 7 => 2008
+    attr_accessor :labels
+
+    # Labels can be rotated from 0-90 degrees
+    attr_accessor :label_rotation
+
+    # Used internally for spacing.
+    #
+    # By default, labels are centered over the point they represent.
+    attr_accessor :center_labels_over_point
+
+    # Used internally for horizontal graph types.
+    attr_accessor :has_left_labels
+
+    # A label for the bottom of the graph
+    attr_accessor :x_axis_label
+
+    # A label for the left side of the graph
+    attr_accessor :y_axis_label
+
+    # attr_accessor :x_axis_increment
+
+    # Manually set increment of the horizontal marking lines
+    attr_accessor :y_axis_increment
+
+    # Get or set the list of colors that will be used to draw the bars or lines.
+    attr_accessor :colors
+
+    # The large title of the graph displayed at the top
+    attr_accessor :title
+
+    # Font used for titles, labels, etc. Works best if you provide the full
+    # path to the TTF font file.  RMagick must be built with the Freetype
+    # libraries for this to work properly.
+    #
+    # Tries to find Bitstream Vera (Vera.ttf) in the location specified by
+    # ENV['MAGICK_FONT_PATH']. Uses default RMagick font otherwise.
+    #
+    # The font= method below fulfills the role of the writer, so we only need
+    # a reader here.
+    attr_reader :font
+
+    attr_accessor :font_color
+
+    # Prevent drawing of line markers
+    attr_accessor :hide_line_markers
+
+    # Prevent drawing of the legend
+    attr_accessor :hide_legend
+
+    # Prevent drawing of the title
+    attr_accessor :hide_title
+
+    # Prevent drawing of line numbers
+    attr_accessor :hide_line_numbers
+
+    # Message shown when there is no data. Fits up to 20 characters. Defaults
+    # to "No Data."
+    attr_accessor :no_data_message
+
+    # The font size of the large title at the top of the graph
+    attr_accessor :title_font_size
+
+    # Optionally set the size of the font. Based on an 800x600px graph.
+    # Default is 20.
+    #
+    # Will be scaled down if graph is smaller than 800px wide.
+    attr_accessor :legend_font_size
+
+    # The font size of the labels around the graph
+    attr_accessor :marker_font_size
+
+    # The color of the auxiliary lines
+    attr_accessor :marker_color
+
+    # The number of horizontal lines shown for reference
+    attr_accessor :marker_count
+
+    # You can manually set a minimum value instead of having the values
+    # guessed for you.
+    #
+    # Set it after you have given all your data to the graph object.
+    attr_accessor :minimum_value
+
+    # You can manually set a maximum value, such as a percentage-based graph
+    # that always goes to 100.
+    #
+    # If you use this, you must set it after you have given all your data to
+    # the graph object.
+    attr_accessor :maximum_value
+
+    # Set to false if you don't want the data to be sorted with largest avg
+    # values at the back.
+    attr_accessor :sort
+
+    # Experimental
+    attr_accessor :additional_line_values
+
+    # Experimental
+    attr_accessor :stacked
+
+    # Optionally set the size of the colored box by each item in the legend.
+    # Default is 20.0
+    #
+    # Will be scaled down if graph is smaller than 800px wide.
+    attr_accessor :legend_box_size
+
+    # If one numerical argument is given, the graph is drawn at 4/3 ratio
+    # according to the given width (800 results in 800x600, 400 gives 400x300,
+    # etc.).
+    #
+    # Or, send a geometry string for other ratios ('800x400', '400x225').
+    #
+    # Looks for Bitstream Vera as the default font. Expects an environment var
+    # of MAGICK_FONT_PATH to be set. (Uses RMagick's default font otherwise.)
+    def initialize(target_width=DEFAULT_TARGET_WIDTH)
+      @top_margin = @bottom_margin = @left_margin = @right_margin = 20.0
+
+      if not Numeric === target_width
+        geometric_width, geometric_height = target_width.split('x')
+        @columns = geometric_width.to_f
+        @rows = geometric_height.to_f
+      else
+        @columns = target_width.to_f
+        @rows = target_width.to_f * 0.75
+      end
+
+      # Call any other initializers -- open-ended to allow for
+      # subclass extensions
+      self.class.instance_methods.
+	select{|m| m.to_s =~ /^initialize_/o}.each do |initializer|
+	self.send(initializer)
+      end
+
+      reset_themes
+      theme_keynote
+    end
+
+    # Set instance variables for this object.
+    #
+    # Subclasses can override this, call super, then set values separately.
+    #
+    # This makes it possible to set defaults in a subclass but still allow
+    # developers to change this values in their program.
+    def initialize_ivars
+      # Internal for calculations
+      @raw_columns = 800.0
+      @raw_rows = 800.0 * (@rows/@columns)
+      @column_count = 0
+      @marker_count = nil
+      @maximum_value = @minimum_value = nil
+      @has_data = false
+      @data = Array.new
+      @labels = Hash.new
+      @labels_seen = Hash.new
+      @sort = true
+      @title = nil
+
+      @scale = @columns / @raw_columns
+
+      vera_font_path = File.expand_path('Vera.ttf', ENV['MAGICK_FONT_PATH'])
+      @font = File.exists?(vera_font_path) ? vera_font_path : nil
+
+      @marker_font_size = 21.0
+      @legend_font_size = 20.0
+      @title_font_size = 36.0
+
+      @legend_box_size = 20.0
+
+      @no_data_message = "No Data"
+
+      @hide_line_markers = @hide_legend = @hide_title = @hide_line_numbers = false
+      @center_labels_over_point = true
+      @has_left_labels = false
+
+      @label_rotation = 0
+
+      @additional_line_values = []      
+      @additional_line_colors = []
+      @theme_options = {}
+
+      @x_axis_label = @y_axis_label = nil
+      @y_axis_increment = nil
+      @stacked = nil
+      @norm_data = nil
+
+    end
+
+    # Sets the top, bottom, left and right margins to +margin+.
+    def margins=(margin)
+      @top_margin = @left_margin = @right_margin = @bottom_margin = margin
+    end
+
+    # Sets the font for graph text to the font at +font_path+.
+    def font=(font_path)
+      @font = font_path
+      @d.font = @font
+    end
+
+    # Add a color to the list of available colors for lines.
+    #
+    # Example:
+    #  add_color('#c0e9d3')
+    def add_color(colorname)
+      @colors << colorname
+    end
+
+    # Replace the entire color list with a new array of colors. You need to
+    # have one more color than the number of datasets you intend to draw. Also
+    # aliased as the colors= setter method.
+    #
+    # Example:
+    #  replace_colors ['#cc99cc', '#d9e043', '#34d8a2']
+    def replace_colors(color_list=[])
+      @colors = color_list
+    end
+
+    # Parameters are an array where the first element is the name of the dataset
+    # and the value is an array of values to plot.
+    #
+    # Can be called multiple times with different datasets for a multi-valued
+    # graph.
+    #
+    # If the color argument is nil, the next color from the default theme will
+    # be used.
+    #
+    # NOTE: If you want to use a preset theme, you must set it before calling
+    # data().
+    #
+    # Example:
+    #   data("Bart S.", [95, 45, 78, 89, 88, 76], '#ffcc00')
+    def data(name, data_points=[], color=nil)
+      data_points = Array(data_points) # make sure it's an array
+      @data << [name, data_points, (color || increment_color)]
+      # Set column count if this is larger than previous counts
+      @column_count = (data_points.length > @column_count) ? data_points.length : @column_count
+
+      # Pre-normalize
+      data_points.each_with_index do |data_point, index|
+        next if data_point.nil?
+
+        # Setup max/min so spread starts at the low end of the data points
+        if @maximum_value.nil? && @minimum_value.nil?
+          @maximum_value = @minimum_value = data_point
+        end
+
+        # TODO Doesn't work with stacked bar graphs
+        # Original: @maximum_value = larger_than_max?(data_point, index) ? max(data_point, index) : @maximum_value
+        @maximum_value = larger_than_max?(data_point) ? data_point : @maximum_value
+        @has_data = true if @maximum_value > 0
+
+        @minimum_value = less_than_min?(data_point) ? data_point : @minimum_value
+        @has_data = true if @minimum_value < 0
+      end
+    end
+
+    # Writes the graph to a file. Defaults to 'graph.png'
+    #
+    # Example:
+    #   write('graphs/my_pretty_graph.png')
+    def write(filename="graph.png")
+      draw()
+      @base_image.write(filename)
+    end
+
+    # Return the graph as a rendered binary blob.
+    def to_blob(fileformat='PNG')
+      draw()
+      return @base_image.to_blob do
+        self.format = fileformat
+      end
+    end
+
+
+
+    protected
+
+    # Overridden by subclasses to do the actual plotting of the graph.
+    #
+    # Subclasses should start by calling super() for this method.
+    def draw
+      make_stacked if @stacked
+      setup_drawing
+
+      debug {
+        # Outer margin
+        @d.rectangle( @left_margin, @top_margin,
+        @raw_columns - @right_margin, @raw_rows - @bottom_margin)
+        # Graph area box
+        @d.rectangle( @graph_left, @graph_top, @graph_right, @graph_bottom)
+      }
+    end
+
+    # Calculates size of drawable area and draws the decorations.
+    #
+    # * line markers
+    # * legend
+    # * title
+    def setup_drawing
+      # Maybe should be done in one of the following functions for more granularity.
+      unless @has_data
+        draw_no_data()
+        return
+      end
+
+      normalize()
+      setup_graph_measurements()
+      sort_norm_data() if @sort # Sort norm_data with avg largest values set first (for display)
+
+      draw_legend()
+      draw_line_markers()
+      draw_axis_labels()
+      draw_title
+    end
+
+    # Make copy of data with values scaled between 0-100
+    def normalize(force=false)
+      if @norm_data.nil? || force
+        @norm_data = []
+        return unless @has_data
+
+        calculate_spread
+
+        @data.each do |data_row|
+          norm_data_points = []
+          data_row[DATA_VALUES_INDEX].each do |data_point|
+            if data_point.nil?
+              norm_data_points << nil
+            else
+              norm_data_points << ((data_point.to_f - @minimum_value.to_f ) / @spread)
+            end
+          end
+          @norm_data << [data_row[DATA_LABEL_INDEX], norm_data_points, data_row[DATA_COLOR_INDEX]]
+        end
+      end
+    end
+
+    def calculate_spread # :nodoc:
+      @spread = @maximum_value.to_f - @minimum_value.to_f
+      @spread = @spread > 0 ? @spread : 1
+    end
+
+    # Draw the optional labels for the x axis and y axis.
+    def draw_axis_labels
+      draw_x_axis_label
+      draw_y_axis_label
+    end
+
+    def draw_x_axis_label
+      unless @x_axis_label.nil?
+        # X Axis
+        # Centered vertically and horizontally by setting the
+        # height to 1.0 and the width to the width of the graph.
+        x_axis_label_y_coordinate = @raw_rows - @x_axis_label_margin
+
+        # TODO Center between graph area
+        @d.fill = @font_color
+        @d.font = @font if @font
+        @d.stroke('transparent')
+        @d.pointsize = scale_fontsize(@marker_font_size)
+        @d.gravity = NorthGravity
+        @d = @d.annotate_scaled( @base_image,
+        @raw_columns, 1.0,
+        0.0, x_axis_label_y_coordinate,
+        @x_axis_label, @scale)
+        debug { @d.line 0.0, x_axis_label_y_coordinate, @raw_columns, x_axis_label_y_coordinate }
+      end
+    end
+
+    def draw_y_axis_label
+      unless @y_axis_label.nil?
+        # Y Axis, rotated vertically
+        @d.rotation = 90.0
+        @d.gravity = CenterGravity
+        @d = @d.annotate_scaled( @base_image,
+        1.0, @raw_rows,
+        @left_margin + @marker_caps_height / 2.0, 0.0,
+        @y_axis_label, @scale)
+        @d.rotation = -90.0
+      end
+    end
+
+    # Draws horizontal background lines and labels
+    def draw_line_markers
+      return if @hide_line_markers
+
+      @d = @d.stroke_antialias false
+
+      if @y_axis_increment.nil?
+        # Try to use a number of horizontal lines that will come out even.
+        #
+        # TODO Do the same for larger numbers...100, 75, 50, 25
+        if @marker_count.nil?
+          (3..7).each do |lines|
+            if @spread % lines == 0.0
+              @marker_count = lines
+              break
+            end
+          end
+          @marker_count ||= 4
+        end
+        @increment = (@spread > 0) ? significant(@spread / @marker_count) : 1
+      else
+        # TODO Make this work for negative values
+        @maximum_value = [@maximum_value.ceil, @y_axis_increment].max
+        @minimum_value = @minimum_value.floor
+        calculate_spread
+        normalize(true)
+
+        @marker_count = (@spread / @y_axis_increment).to_i
+        @increment = @y_axis_increment
+      end
+      @increment_scaled = @graph_height.to_f / (@spread / @increment)
+
+      # Draw horizontal line markers and annotate with numbers
+      (0..@marker_count).each do |index|
+        y = @graph_top + @graph_height - index.to_f * @increment_scaled
+
+        @d = @d.stroke(@marker_color)
+        @d = @d.stroke_width 1
+        @d = @d.line(@graph_left, y, @graph_right, y)
+
+        marker_label = index * @increment + @minimum_value.to_f
+
+        unless @hide_line_numbers
+          @d.fill = @font_color
+          @d.font = @font if @font
+          @d.stroke('transparent')
+          @d.pointsize = scale_fontsize(@marker_font_size)
+          @d.gravity = EastGravity
+
+          # Vertically center with 1.0 for the height
+          @d = @d.annotate_scaled( @base_image,
+          @graph_left - LABEL_MARGIN, 1.0,
+          0.0, y,
+          label(marker_label), @scale)
+        end
+      end
+
+      # # Submitted by a contibutor...the utility escapes me
+      # i = 0
+      # @additional_line_values.each do |value|
+      #   @increment_scaled = @graph_height.to_f / (@maximum_value.to_f / value)
+      #
+      #   y = @graph_top + @graph_height - @increment_scaled
+      #
+      #   @d = @d.stroke(@additional_line_colors[i])
+      #   @d = @d.line(@graph_left, y, @graph_right, y)
+      #
+      #
+      #   @d.fill = @additional_line_colors[i]
+      #   @d.font = @font if @font
+      #   @d.stroke('transparent')
+      #   @d.pointsize = scale_fontsize(@marker_font_size)
+      #   @d.gravity = EastGravity
+      #   @d = @d.annotate_scaled( @base_image,
+      #                     100, 20,
+      #                     -10, y - (@marker_font_size/2.0),
+      #                     "", @scale)
+      #   i += 1
+      # end
+
+      @d = @d.stroke_antialias true
+    end
+
+    ##
+    # Return the sum of values in an array.
+    #
+    # Duplicated to not conflict with active_support in Rails.
+
+    def sum(arr)
+      arr.inject(0) { |i, m| m + i }
+    end
+
+    ##
+    # Return a calculation of center
+
+    def center(size)
+      (@raw_columns - size) / 2
+    end
+
+    ##
+    # Draws a legend with the names of the datasets matched
+    # to the colors used to draw them.
+
+    def draw_legend
+      return if @hide_legend
+      setup_legend_labels
+      setup_legend_label_measurements
+      draw_legend_labels
+    end
+
+    def setup_legend_labels
+      @legend_labels = @data.collect {|item| item[DATA_LABEL_INDEX] }
+    end
+
+    def setup_legend_label_measurements
+      # May fix legend drawing problem at small sizes
+      @d.font = @font if @font
+      @d.pointsize = @legend_font_size
+
+      @legend_label_widths = [[]] # Used to calculate line wrap
+      @legend_labels.each do |label|
+        metrics = @d.get_type_metrics(@base_image, label.to_s)
+        label_width = metrics.width + @legend_box_size * 2.7
+        @legend_label_widths.last.push label_width
+
+        if sum(@legend_label_widths.last) > (@raw_columns * 0.9)
+          @legend_label_widths.push [@legend_label_widths.last.pop]
+        end
+      end
+    end
+
+    def draw_legend_labels
+      current_x_offset = center(sum(@legend_label_widths.first))
+      current_y_offset =  @hide_title ?
+      @top_margin + LEGEND_MARGIN :
+      @top_margin + TITLE_MARGIN + @title_caps_height + LEGEND_MARGIN
+
+      @legend_labels.each_with_index do |legend_label, index|
+        draw_legend_label(legend_label,index,
+                          current_x_offset,current_y_offset)
+        current_x_offset, current_y_offset =
+          step_legend_position(current_x_offset,current_y_offset,legend_label)
+      end
+      @color_index = 0
+    end
+
+    def draw_legend_label(legend_label, index,
+			  current_x_offset,current_y_offset)
+      draw_legend_label_text(legend_label, index,
+			     current_x_offset, current_y_offset)
+      draw_legend_label_box(index, current_x_offset, current_y_offset)
+    end
+    
+    def draw_legend_label_text(legend_label, index,
+			       current_x_offset,current_y_offset)
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.pointsize = scale_fontsize(@legend_font_size)
+      @d.stroke('transparent')
+      @d.font_weight = NormalWeight
+      @d.gravity = WestGravity
+      @d = @d.annotate_scaled(@base_image, 
+			      @raw_columns, 1.0,
+			      current_x_offset + (@legend_box_size * 1.7),
+                              current_y_offset, 
+			      legend_label.to_s, @scale)
+    end
+
+    def draw_legend_label_box(index,current_x_offset,current_y_offset)
+      # Now draw box with color of this dataset
+      @d = @d.stroke('transparent')
+      @d = @d.fill @data[index][DATA_COLOR_INDEX]
+      @d = @d.rectangle(current_x_offset, 
+			current_y_offset - @legend_box_size / 2.0, 
+			current_x_offset + @legend_box_size, 
+			current_y_offset + @legend_box_size / 2.0)
+    end
+
+    def step_legend_position(current_x_offset,current_y_offset,legend_label)
+      # Handle wrapping
+      first = @legend_label_widths.first
+      first.shift if first
+      if first and first.empty?
+        debug { @d.line 0.0, current_y_offset, @raw_columns, current_y_offset }
+
+        @legend_label_widths.shift # next row
+        current_x_offset = center(sum(@legend_label_widths.first)) unless @legend_label_widths.empty?
+        line_height = [@legend_caps_height, @legend_box_size].max + LEGEND_MARGIN
+        if @legend_label_widths.length > 0
+          # Wrap to next line and shrink available graph dimensions
+          current_y_offset += line_height
+          @graph_top += line_height
+          @graph_height = @graph_bottom - @graph_top
+        end
+      else
+        @d.pointsize = @legend_font_size
+        metrics = @d.get_type_metrics(@base_image, legend_label.to_s)
+        current_string_offset = metrics.width + (@legend_box_size * 2.7)
+        current_x_offset += current_string_offset
+      end
+
+      [ current_x_offset, current_y_offset ]
+    end
+
+
+    # Draws a title on the graph.
+    def draw_title
+      return if (@hide_title || @title.nil?)
+
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.stroke('transparent')
+      @d.pointsize = scale_fontsize(@title_font_size)
+      @d.font_weight = BoldWeight
+      @d.gravity = NorthGravity
+      @d = @d.annotate_scaled( @base_image,
+      @raw_columns, 1.0,
+      0, @top_margin,
+      @title, @scale)
+    end
+
+    # Draws column labels below graph, centered over x_offset
+    #--
+    # TODO Allow WestGravity as an option
+    def draw_label(x_offset, index)
+      return if @hide_line_markers
+
+      if !@labels[index].nil? && @labels_seen[index].nil?
+        y_offset = @graph_bottom + LABEL_MARGIN
+
+        @d.fill = @font_color
+        @d.font = @font if @font
+        @d.stroke('transparent')
+	@d.rotation = @label_rotation
+        @d.font_weight = NormalWeight
+        @d.pointsize = scale_fontsize(@marker_font_size)
+	@d.gravity = @label_rotation == 0 ? NorthGravity : NorthWestGravity
+        @d = @d.annotate_scaled(@base_image,
+                                1.0, 1.0,
+                                x_offset, y_offset,
+                                @labels[index], @scale)
+	@d.rotation = -@label_rotation
+        @labels_seen[index] = 1
+        debug { @d.line 0.0, y_offset, @raw_columns, y_offset }
+      end
+    end
+
+    # Shows an error message because you have no data.
+    def draw_no_data
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.stroke('transparent')
+      @d.font_weight = NormalWeight
+      @d.pointsize = scale_fontsize(80)
+      @d.gravity = CenterGravity
+      @d = @d.annotate_scaled( @base_image,
+      @raw_columns, @raw_rows/2.0,
+      0, 10,
+      @no_data_message, @scale)
+    end
+
+    # Finds the best background to render based on the provided theme options.
+    #
+    # Creates a @base_image to draw on.
+    def render_background
+      case @theme_options[:background_colors]
+      when Array
+        @base_image = render_gradiated_background(*@theme_options[:background_colors])
+      when String
+        @base_image = render_solid_background(@theme_options[:background_colors])
+      else
+        @base_image = render_image_background(*@theme_options[:background_image])
+      end
+    end
+
+    # Make a new image at the current size with a solid +color+.
+    def render_solid_background(color)
+      Image.new(@columns, @rows) {
+        self.background_color = color
+      }
+    end
+
+    # Use with a theme definition method to draw a gradiated background.
+    def render_gradiated_background(top_color, bottom_color)
+      Image.new(@columns, @rows,
+      GradientFill.new(0, 0, 100, 0, top_color, bottom_color))
+    end
+
+    # Use with a theme to use an image (800x600 original) background.
+    def render_image_background(image_path)
+      image = Image.read(image_path)
+      if @scale != 1.0
+        image[0].resize!(@scale) # TODO Resize with new scale (crop if necessary for wide graph)
+      end
+      image[0]
+    end
+
+    # Use with a theme to make a transparent background
+    def render_transparent_background
+      Image.new(@columns, @rows) do
+        self.background_color = 'transparent'
+      end
+    end
+
+    # Resets everything to defaults (except data).
+    def reset_themes
+      @color_index = 0
+      @labels_seen = {}
+      @theme_options = {}
+
+      @d = Draw.new
+      # Scale down from 800x600 used to calculate drawing.
+      @d = @d.scale(@scale, @scale)
+    end
+
+    def scale(value) # :nodoc:
+      value * @scale
+    end
+
+    # Return a comparable fontsize for the current graph.
+    def scale_fontsize(value)
+      new_fontsize = value * @scale
+      # return new_fontsize < 10.0 ? 10.0 : new_fontsize
+      return new_fontsize
+    end
+
+    def clip_value_if_greater_than(value, max_value) # :nodoc:
+      (value > max_value) ? max_value : value
+    end
+
+    # Overridden by subclasses such as stacked bar.
+    def larger_than_max?(data_point, index=0) # :nodoc:
+      data_point > @maximum_value
+    end
+
+    def less_than_min?(data_point, index=0) # :nodoc:
+      data_point < @minimum_value
+    end
+
+    # Overridden by subclasses that need it.
+    def max(data_point, index) # :nodoc:
+      data_point
+    end
+
+    # Overridden by subclasses that need it.
+    def min(data_point, index) # :nodoc:
+      data_point
+    end
+
+    def significant(inc) # :nodoc:
+      return 1.0 if inc == 0 # Keep from going into infinite loop
+      factor = 1.0
+      while (inc < 10)
+        inc *= 10
+        factor /= 10
+      end
+
+      while (inc > 100)
+        inc /= 10
+        factor *= 10
+      end
+
+      res = inc.floor * factor
+      if (res.to_i.to_f == res)
+        res.to_i
+      else
+        res
+      end
+    end
+
+    # Sort with largest overall summed value at front of array so it shows up
+    # correctly in the drawn graph.
+    def sort_norm_data
+      @norm_data.sort! { |a,b| sums(b[DATA_VALUES_INDEX]) <=> sums(a[DATA_VALUES_INDEX]) }
+    end
+
+    def sums(data_set) # :nodoc:
+      total_sum = 0
+      data_set.collect {|num| total_sum += num.to_f }
+      total_sum
+    end
+
+    # Used by StackedBar and child classes.
+    #
+    # May need to be moved to the StackedBar class.
+    def get_maximum_by_stack
+      # Get sum of each stack
+      max_hash = {}
+      @data.each do |data_set|
+        data_set[DATA_VALUES_INDEX].each_with_index do |data_point, i|
+          max_hash[i] = 0.0 unless max_hash[i]
+          max_hash[i] += data_point.to_f
+        end
+      end
+
+      # @maximum_value = 0
+      max_hash.keys.each do |key|
+        @maximum_value = max_hash[key] if max_hash[key] > @maximum_value
+      end
+      @minimum_value = 0
+    end
+
+    def make_stacked # :nodoc:
+      stacked_values = Array.new(@column_count, 0)
+      @data.each do |value_set|
+        value_set[DATA_VALUES_INDEX].each_with_index do |value, index|
+          stacked_values[index] += value
+        end
+        value_set[DATA_VALUES_INDEX] = stacked_values.dup
+      end
+    end
+
+    private
+
+    # Takes a block and draws it if DEBUG is true.
+    #
+    # Example:
+    #   debug { @d.rectangle x1, y1, x2, y2 }
+    def debug
+      if DEBUG
+        @d = @d.fill 'transparent'
+        @d = @d.stroke 'turquoise'
+        @d = yield
+      end
+    end
+
+    # Uses the next color in your color list.
+    def increment_color
+      if @color_index == 0
+        @color_index += 1
+        return @colors[0]
+      else
+        if @color_index < @colors.length
+          @color_index += 1
+          return @colors[@color_index - 1]
+        else
+          # Start over
+          @color_index = 0
+          return @colors[-1]
+        end
+      end
+    end
+
+    # Return a formatted string representing a number value that should be
+    # printed as a label.
+    def label(value)
+      if (@spread.to_f % @marker_count.to_f == 0) || !@y_axis_increment.nil?
+        return value.to_i.to_s
+      end
+
+      if @spread > 10.0
+        sprintf("%0i", value)
+      elsif @spread >= 3.0
+        sprintf("%0.2f", value)
+      else
+        value.to_s
+      end
+    end
+
+  end # Gruff::Base
+
+  class IncorrectNumberOfDatasetsException < StandardError; end
+
+end # Gruff
+
+module Magick
+
+  class Draw
+
+    # Additional method to scale annotation text since Draw.scale doesn't.
+    def annotate_scaled(img, width, height, x, y, text, scale)
+      scaled_width = (width * scale) >= 1 ? (width * scale) : 1
+      scaled_height = (height * scale) >= 1 ? (height * scale) : 1
+
+      self.annotate( img,
+      scaled_width, scaled_height,
+      x * scale, y * scale,
+      text)
+    end
+
+  end
+
+end # Magick