gruffy 0.0.2 → 0.0.3

data/lib/gruffy/bezier.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/base'
+
+class Gruffy::Bezier < Gruffy::Base
+  def draw
+    super
+
+    return unless @has_data
+
+    @x_increment = @graph_width / (@column_count - 1).to_f
+
+    @norm_data.each do |data_row|
+      poly_points = Array.new
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[1].each_with_index do |data_point, index|
+        # Use incremented x and scaled y
+        new_x = @graph_left + (@x_increment * index)
+        new_y = @graph_top + (@graph_height - data_point * @graph_height)
+
+        if index == 0 && RUBY_PLATFORM != 'java'
+          poly_points << new_x
+          poly_points << new_y
+        end
+
+        poly_points << new_x
+        poly_points << new_y
+
+        draw_label(new_x, index)
+      end
+   
+      @d = @d.fill_opacity 0.0
+      @d = @d.stroke data_row[DATA_COLOR_INDEX]
+      @d = @d.stroke_width clip_value_if_greater_than(@columns / (@norm_data.first[1].size * 4), 5.0)
+
+      if RUBY_PLATFORM == 'java'
+        @d = @d.polyline(*poly_points)
+      else
+        @d = @d.bezier(*poly_points)
+      end
+    end
+
+    @d.draw(@base_image)
+  end
+   
+
+end

data/lib/gruffy/bullet.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/base'
+require 'gruffy/themes'
+
+# http://en.wikipedia.org/wiki/Bullet_graph
+class Gruffy::Bullet < Gruffy::Base
+
+  def initialize(target_width="400x40")
+    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 / 5.0
+    end
+
+    initialize_ivars
+
+    reset_themes
+    self.theme = Gruffy::Themes::GREYSCALE
+    @title_font_size = 20
+  end
+
+  def data(value, maximum_value, options={})
+    @value = value.to_f
+    @maximum_value = maximum_value.to_f
+    @options = options
+    @options.map { |k, v| @options[k] = v.to_f if v === Numeric }
+  end
+
+  # 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
+
+  def draw
+    # TODO Left label
+    # TODO Bottom labels and markers
+    # @graph_bottom
+    # Calculations are off 800x???
+
+    @colors.reverse!
+
+    draw_title
+
+    @margin       = 30.0
+    @thickness    = @raw_rows / 6.0
+    @right_margin = @margin
+    @graph_left   = (@title && (@title_width * 1.3)) || @margin
+    @graph_width  = @raw_columns - @graph_left - @right_margin
+    @graph_height = @thickness * 3.0
+
+    # Background
+    @d = @d.fill @colors[0]
+    @d = @d.rectangle(@graph_left, 0, @graph_left + @graph_width, @graph_height)
+
+    [:high, :low].each_with_index do |indicator, index|
+      next unless @options.has_key?(indicator)
+      @d = @d.fill @colors[index + 1]
+      indicator_width_x  = @graph_left + @graph_width * (@options[indicator] / @maximum_value)
+      @d = @d.rectangle(@graph_left, 0, indicator_width_x, @graph_height)
+    end
+
+    if @options.has_key?(:target)
+      @d = @d.fill @font_color
+      target_x = @graph_left + @graph_width * (@options[:target] / @maximum_value)
+      half_thickness = @thickness / 2.0
+      @d = @d.rectangle(target_x, half_thickness, target_x + half_thickness, @thickness * 2 + half_thickness)
+    end
+
+    # Value
+    @d = @d.fill @font_color
+    @d = @d.rectangle(@graph_left, @thickness, @graph_left + @graph_width * (@value / @maximum_value), @thickness * 2)
+
+    @d.draw(@base_image)
+  end
+
+  def draw_title
+    return unless @title
+
+    @font_height = calculate_caps_height(scale_fontsize(@title_font_size))
+    @title_width = calculate_width(@title_font_size, @title)
+
+    @d.fill        = @font_color
+    @d.font        = @font if @font
+    @d.stroke('transparent')
+    @d.font_weight = NormalWeight
+    @d.pointsize   = scale_fontsize(@title_font_size)
+    @d.gravity     = NorthWestGravity
+    @d             = @d.annotate_scaled(*[
+      @base_image,
+      1.0, 1.0,
+      @font_height/2, @font_height/2,
+      @title,
+      @scale
+    ])
+  end
+
+end

data/lib/gruffy/deprecated.rb

@@ -0,0 +1,39 @@
+
+##
+# A mixin for methods that need to be deleted or have been
+# replaced by cleaner code.
+
+module Gruffy
+  module Deprecated
+  
+    def scale_measurements
+      setup_graph_measurements
+    end
+    
+    def total_height
+      @rows + 10
+    end
+    
+    def graph_top
+      @graph_top * @scale
+    end
+    
+    def graph_height
+      @graph_height * @scale
+    end
+    
+    def graph_left 
+      @graph_left * @scale 
+    end
+    
+    def graph_width
+      @graph_width * @scale
+    end
+    
+    # TODO Should be calculate_graph_height
+    # def setup_graph_height
+    #   @graph_height = @graph_bottom - @graph_top
+    # end
+  
+  end
+end

data/lib/gruffy/dot.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/base'
+
+##
+# Graph with dots and labels along a vertical access
+# see: 'Creating More Effective Graphs' by Robbins
+
+class Gruffy::Dot < Gruffy::Base
+
+  def draw
+    @has_left_labels = true
+    super
+
+    return unless @has_data
+
+    # Setup spacing.
+    #
+    spacing_factor = 1.0
+
+    @items_width = @graph_height / @column_count.to_f
+    @item_width = @items_width * spacing_factor / @norm_data.size
+    @d = @d.stroke_opacity 0.0
+    padding = (@items_width * (1 - spacing_factor)) / 2
+
+    @norm_data.each_with_index do |data_row, row_index|
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+        x_pos = @graph_left + (data_point * @graph_width)
+        y_pos = @graph_top + (@items_width * point_index) + padding + (@items_width.to_f/2.0).round
+
+        if row_index == 0
+          @d = @d.stroke(@marker_color)
+          @d = @d.fill(@marker_color)
+          @d = @d.stroke_width 1.0
+          @d = @d.stroke_opacity 0.1
+          @d = @d.fill_opacity 0.1
+          @d = @d.line(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
+          @d = @d.fill_opacity 1
+        end
+
+        @d = @d.fill data_row[DATA_COLOR_INDEX]
+        @d = @d.stroke('transparent')
+        @d = @d.circle(x_pos, y_pos, x_pos + (@item_width.to_f/3.0).round, y_pos)
+
+        draw_label(y_pos, point_index)
+      end
+
+    end
+
+    @d.draw(@base_image)
+  end
+
+  protected
+
+  # Instead of base class version, draws vertical background lines and label
+  def draw_line_markers
+    return if @hide_line_markers
+
+    @d = @d.stroke_antialias false
+
+    # Draw horizontal line markers and annotate with numbers
+    @d = @d.stroke(@marker_color)
+    @d = @d.stroke_width 1
+    if @y_axis_increment
+      increment = @y_axis_increment
+      number_of_lines = (@spread / @y_axis_increment).to_i
+    else
+      # 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 ||= 5
+      end
+      # TODO Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
+      @increment = (@spread > 0 && @marker_count > 0) ? significant(@spread / @marker_count) : 1
+
+      number_of_lines = @marker_count
+      increment = @increment
+    end
+
+    (0..number_of_lines).each do |index|
+      marker_label = @minimum_value + index * increment
+      x = @graph_left + (marker_label - @minimum_value) * @graph_width / @spread
+      @d = @d.line(x, @graph_bottom, x, @graph_bottom + 0.5 * LABEL_MARGIN)
+
+      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 = CenterGravity
+        # TODO Center text over line
+        @d = @d.annotate_scaled(@base_image,
+                                0, 0, # Width of box to draw text in
+                                x, @graph_bottom + (LABEL_MARGIN * 2.0), # Coordinates of text
+                                label(marker_label, increment), @scale)
+      end # unless
+      @d = @d.stroke_antialias true
+    end
+  end
+
+  ##
+  # Draw on the Y axis instead of the X
+
+  def draw_label(y_offset, index)
+    if !@labels[index].nil? && @labels_seen[index].nil?
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.stroke = 'transparent'
+      @d.font_weight = NormalWeight
+      @d.pointsize = scale_fontsize(@marker_font_size)
+      @d.gravity = EastGravity
+      @d = @d.annotate_scaled(@base_image,
+                              1, 1,
+                              -@graph_left + LABEL_MARGIN * 2.0, y_offset,
+                              @labels[index], @scale)
+      @labels_seen[index] = 1
+    end
+  end
+
+end

data/lib/gruffy/line.rb

@@ -0,0 +1,365 @@
+require File.dirname(__FILE__) + '/base'
+
+##
+# Here's how to make a Line graph:
+#
+#   g = Gruffy::Line.new
+#   g.title = "A Line Graph"
+#   g.data 'Fries', [20, 23, 19, 8]
+#   g.data 'Hamburgers', [50, 19, 99, 29]
+#   g.write("test/output/line.png")
+#
+# There are also other options described below, such as #baseline_value, #baseline_color, #hide_dots, and #hide_lines.
+
+class Gruffy::Line < Gruffy::Base
+
+  # Allow for reference lines ( which are like baseline ... just allowing for more & on both axes )
+  attr_accessor :reference_lines
+  attr_accessor :reference_line_default_color
+  attr_accessor :reference_line_default_width
+
+  # Allow for vertical marker lines
+  attr_accessor :show_vertical_markers
+
+  # Dimensions of lines and dots; calculated based on dataset size if left unspecified
+  attr_accessor :line_width
+  attr_accessor :dot_radius
+
+  # default is a circle, other options include square
+  attr_accessor :dot_style
+
+  # Hide parts of the graph to fit more datapoints, or for a different appearance.
+  attr_accessor :hide_dots, :hide_lines
+
+  #accessors for support of xy data
+  attr_accessor :minimum_x_value
+  attr_accessor :maximum_x_value
+
+  # Get the value if somebody has defined it.
+  def baseline_value
+    if (@reference_lines.key?(:baseline))
+      @reference_lines[:baseline][:value]
+    else
+      nil
+    end
+  end
+
+  # Set a value for a baseline reference line..
+  def baseline_value=(new_value)
+    @reference_lines[:baseline] ||= Hash.new
+    @reference_lines[:baseline][:value] = new_value
+  end
+
+  def baseline_color
+    if (@reference_lines.key?(:baseline))
+      @reference_lines[:baseline][:color]
+    else
+      nil
+    end
+  end
+
+  def baseline_color=(new_value)
+    @reference_lines[:baseline] ||= Hash.new
+    @reference_lines[:baseline][:color] = new_value
+  end
+
+  # Call with target pixel width of graph (800, 400, 300), and/or 'false' to omit lines (points only).
+  #
+  #  g = Gruffy::Line.new(400) # 400px wide with lines
+  #
+  #  g = Gruffy::Line.new(400, false) # 400px wide, no lines (for backwards compatibility)
+  #
+  #  g = Gruffy::Line.new(false) # Defaults to 800px wide, no lines (for backwards compatibility)
+  #
+  # The preferred way is to call hide_dots or hide_lines instead.
+  def initialize(*args)
+    raise ArgumentError, 'Wrong number of arguments' if args.length > 2
+    if args.empty? || ((not Numeric === args.first) && (not String === args.first))
+      super()
+    else
+      super args.shift
+    end
+
+    @reference_lines = Hash.new
+    @reference_line_default_color = 'red'
+    @reference_line_default_width = 5
+
+    @hide_dots = @hide_lines = false
+    @maximum_x_value = nil
+    @minimum_x_value = nil
+
+    @dot_style = 'circle'
+
+    @show_vertical_markers = false
+  end
+
+  # This method allows one to plot a dataset with both X and Y data.
+  #
+  # Parameters are as follows:
+  #   name: string, the title of the dataset
+  #   x_data_points: an array containing the x data points for the graph
+  #   y_data_points: an array containing the y data points for the graph
+  #   color: hex number indicating the line color as an RGB triplet
+  #
+  #   or
+  #
+  #   name: string, the title of the dataset
+  #   xy_data_points: an array containing both x and y data points for the graph
+  #   color: hex number indicating the line color as an RGB triplet
+  #
+  #  Notes:
+  #   -if (x_data_points.length != y_data_points.length) an error is
+  #     returned.
+  #   -if the color argument is nil, the next color from the default theme will
+  #     be used.
+  #   -if you want to use a preset theme, you must set it before calling
+  #     dataxy().
+  #
+  # Example:
+  #   g = Gruffy::Line.new
+  #   g.title = "X/Y Dataset"
+  #   g.dataxy("Apples", [1,3,4,5,6,10], [1, 2, 3, 4, 4, 3])
+  #   g.dataxy("Bapples", [1,3,4,5,7,9], [1, 1, 2, 2, 3, 3])
+  #   g.dataxy("Capples", [[1,1],[2,3],[3,4],[4,5],[5,7],[6,9]])
+  #   #you can still use the old data method too if you want:
+  #   g.data("Capples", [1, 1, 2, 2, 3, 3])
+  #   #labels will be drawn at the x locations of the keys passed in.
+  #   In this example the lables are drawn at x positions 2, 4, and 6:
+  #   g.labels = {0 => '2003', 2 => '2004', 4 => '2005', 6 => '2006'}
+  #   The 0 => '2003' label will be ignored since it is outside the chart range.
+  def dataxy(name, x_data_points=[], y_data_points=[], color=nil)
+    raise ArgumentError, 'x_data_points is nil!' if x_data_points.length == 0
+
+    if x_data_points.all? { |p| p.is_a?(Array) && p.size == 2 }
+      x_data_points, y_data_points = x_data_points.map { |p| p[0] }, x_data_points.map { |p| p[1] }
+    end
+
+    raise ArgumentError, 'x_data_points.length != y_data_points.length!' if x_data_points.length != y_data_points.length
+
+    # call the existing data routine for the y data.
+    self.data(name, y_data_points, color)
+
+    x_data_points = Array(x_data_points) # make sure it's an array
+    # append the x data to the last entry that was just added in the @data member
+    @data.last[DATA_VALUES_X_INDEX] = x_data_points
+
+    # Update the global min/max values for the x data
+    x_data_points.each do |x_data_point|
+      next if x_data_point.nil?
+
+      # Setup max/min so spread starts at the low end of the data points
+      if @maximum_x_value.nil? && @minimum_x_value.nil?
+        @maximum_x_value = @minimum_x_value = x_data_point
+      end
+
+      @maximum_x_value = (x_data_point > @maximum_x_value) ?
+          x_data_point : @maximum_x_value
+      @minimum_x_value = (x_data_point < @minimum_x_value) ?
+          x_data_point : @minimum_x_value
+    end
+
+  end
+
+  def draw_reference_line(reference_line, left, right, top, bottom)
+    @d = @d.push
+    @d.stroke_color(reference_line[:color] || @reference_line_default_color)
+    @d.fill_opacity 0.0
+    @d.stroke_dasharray(10, 20)
+    @d.stroke_width(reference_line[:width] || @reference_line_default_width)
+    @d.line(left, top, right, bottom)
+    @d = @d.pop
+  end
+
+  def draw_horizontal_reference_line(reference_line)
+    level = @graph_top + (@graph_height - reference_line[:norm_value] * @graph_height)
+    draw_reference_line(reference_line, @graph_left, @graph_left + @graph_width, level, level)
+  end
+
+  def draw_vertical_reference_line(reference_line)
+    index = @graph_left + (@x_increment * reference_line[:index])
+    draw_reference_line(reference_line, index, index, @graph_top, @graph_top + @graph_height)
+  end
+
+  def draw
+    super
+
+    return unless @has_data
+
+    # Check to see if more than one datapoint was given. NaN can result otherwise.
+    @x_increment = (@column_count > 1) ? (@graph_width / (@column_count - 1).to_f) : @graph_width
+
+    @reference_lines.each_value do |curr_reference_line|
+      draw_horizontal_reference_line(curr_reference_line) if curr_reference_line.key?(:norm_value)
+      draw_vertical_reference_line(curr_reference_line) if curr_reference_line.key?(:index)
+    end
+
+    if (@show_vertical_markers)
+      (0..@column_count).each do |column|
+        x = @graph_left + @graph_width - column.to_f * @x_increment
+
+        @d = @d.fill(@marker_color)
+
+        # FIXME(uwe): Workaround for Issue #66
+        #             https://github.com/topfunky/gruffy/issues/66
+        #             https://github.com/rmagick/rmagick/issues/82
+        #             Remove if the issue gets fixed.
+        x += 0.001 unless defined?(JRUBY_VERSION)
+        # EMXIF
+
+        @d = @d.line(x, @graph_bottom, x, @graph_top)
+        #If the user specified a marker shadow color, draw a shadow just below it
+        unless @marker_shadow_color.nil?
+          @d = @d.fill(@marker_shadow_color)
+          @d = @d.line(x + 1, @graph_bottom, x + 1, @graph_top)
+        end
+      end
+    end
+
+    @norm_data.each do |data_row|
+      prev_x = prev_y = nil
+
+      @one_point = contains_one_point_only?(data_row)
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
+        x_data = data_row[DATA_VALUES_X_INDEX]
+        if x_data == nil
+          #use the old method: equally spaced points along the x-axis
+          new_x = @graph_left + (@x_increment * index)
+          draw_label(new_x, index)
+        else
+          new_x = get_x_coord(x_data[index], @graph_width, @graph_left)
+          @labels.each do |label_pos, _|
+            draw_label(@graph_left + ((label_pos - @minimum_x_value) * @graph_width) / (@maximum_x_value - @minimum_x_value), label_pos)
+          end
+        end
+        unless data_point # we can't draw a line for a null data point, we can still label the axis though
+          prev_x = prev_y = nil
+          next
+        end
+
+        new_y = @graph_top + (@graph_height - data_point * @graph_height)
+
+        # Reset each time to avoid thin-line errors
+        @d = @d.stroke data_row[DATA_COLOR_INDEX]
+        @d = @d.fill data_row[DATA_COLOR_INDEX]
+        @d = @d.stroke_opacity 1.0
+        @d = @d.stroke_width line_width ||
+                                 clip_value_if_greater_than(@columns / (@norm_data.first[DATA_VALUES_INDEX].size * 4), 5.0)
+
+        circle_radius = dot_radius ||
+            clip_value_if_greater_than(@columns / (@norm_data.first[DATA_VALUES_INDEX].size * 2.5), 5.0)
+
+        if !@hide_lines && !prev_x.nil? && !prev_y.nil?
+          @d = @d.line(prev_x, prev_y, new_x, new_y)
+        elsif @one_point
+          # Show a circle if there's just one_point
+          @d = DotRenderers.renderer(@dot_style).render(@d, new_x, new_y, circle_radius)
+        end
+
+        unless @hide_dots
+          @d = DotRenderers.renderer(@dot_style).render(@d, new_x, new_y, circle_radius)
+        end
+
+        prev_x, prev_y = new_x, new_y
+      end
+    end
+
+    @d.draw(@base_image)
+  end
+
+  def setup_data
+
+    # Deal with horizontal reference line values that exceed the existing minimum & maximum values.
+    possible_maximums = [@maximum_value.to_f]
+    possible_minimums = [@minimum_value.to_f]
+
+    @reference_lines.each_value do |curr_reference_line|
+      if (curr_reference_line.key?(:value))
+        possible_maximums << curr_reference_line[:value].to_f
+        possible_minimums << curr_reference_line[:value].to_f
+      end
+    end
+
+    @maximum_value = possible_maximums.max
+    @minimum_value = possible_minimums.min
+
+    super
+  end
+
+  def normalize(force=false)
+    super(force)
+
+    @reference_lines.each_value do |curr_reference_line|
+
+      # We only care about horizontal markers ... for normalization.
+      # Vertical markers won't have a :value, they will have an :index
+
+      curr_reference_line[:norm_value] = ((curr_reference_line[:value].to_f - @minimum_value) / @spread.to_f) if (curr_reference_line.key?(:value))
+
+    end
+
+    #normalize the x data if it is specified
+    @data.each_with_index do |data_row, index|
+      norm_x_data_points = []
+      if data_row[DATA_VALUES_X_INDEX] != nil
+        data_row[DATA_VALUES_X_INDEX].each do |x_data_point|
+          norm_x_data_points << ((x_data_point.to_f - @minimum_x_value.to_f) /
+              (@maximum_x_value.to_f - @minimum_x_value.to_f))
+        end
+        @norm_data[index] << norm_x_data_points
+      end
+    end
+
+  end
+
+  def sort_norm_data
+    super unless @data.any? { |d| d[DATA_VALUES_X_INDEX] }
+  end
+
+  def get_x_coord(x_data_point, width, offset)
+    x_data_point * width + offset
+  end
+
+  def contains_one_point_only?(data_row)
+    # Spin through data to determine if there is just one_value present.
+    one_point = false
+    data_row[DATA_VALUES_INDEX].each do |data_point|
+      unless data_point.nil?
+        if one_point
+          # more than one point, bail
+          return false
+        end
+        # there is at least one data point
+        one_point = true
+      end
+    end
+    one_point
+  end
+
+  module DotRenderers
+    class Circle
+      def render(d, new_x, new_y, circle_radius)
+        d.circle(new_x, new_y, new_x - circle_radius, new_y)
+      end
+    end
+
+    class Square
+      def render(d, new_x, new_y, circle_radius)
+        offset = (circle_radius * 0.8).to_i
+        corner_1 = new_x - offset
+        corner_2 = new_y - offset
+        corner_3 = new_x + offset
+        corner_4 = new_y + offset
+        d.rectangle(corner_1, corner_2, corner_3, corner_4)
+      end
+    end
+
+    def self.renderer(style)
+      if style.to_s == 'square'
+        Square.new
+      else
+        Circle.new
+      end
+    end
+  end
+end