gruff 0.3.7 → 0.4.0

data/lib/gruff/bezier.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/base'
+
+class Gruff::Bezier < Gruff::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 << @graph_left
+          poly_points << @graph_bottom - 1
+        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/gruff/bullet.rb

@@ -1,5 +1,7 @@
 require File.dirname(__FILE__) + '/base'
+require 'gruff/themes'
 
+# http://en.wikipedia.org/wiki/Bullet_graph
 class Gruff::Bullet < Gruff::Base
 
   def initialize(target_width="400x40")
@@ -15,7 +17,7 @@ class Gruff::Bullet < Gruff::Base
     initialize_ivars
 
     reset_themes
-    theme_greyscale
+    self.theme = Gruff::Themes::GREYSCALE
     @title_font_size = 20
   end
 

data/lib/gruff/dot.rb

@@ -18,31 +18,29 @@ class Gruff::Dot < Gruff::Base
 
     @items_width = @graph_height / @column_count.to_f
     @item_width = @items_width * spacing_factor / @norm_data.size
-    @d         = @d.stroke_opacity 0.0
-    height     = Array.new(@column_count, 0)
-    length     = Array.new(@column_count, @graph_left)
-    padding    = (@items_width * (1 - spacing_factor)) / 2
+    @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) - (@item_width.to_f/6.0).round
-        y_pos        = @graph_top + (@items_width * point_index) + padding + (@item_width.to_f/2.0).round      
+        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.stroke_width 1.0
-          @d           = @d.opacity 0.1
-          @d           = @d.line(@graph_left, y_pos, @graph_left + @graph_width, y_pos)
+          @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)
+        @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)
 
-        # Calculate center based on item_width and current row
-        label_center = @graph_top + (@items_width * point_index + @items_width / 2) + padding
-        draw_label(label_center, point_index)
+        draw_label(y_pos, point_index)
       end
 
     end
@@ -50,11 +48,10 @@ class Gruff::Dot < Gruff::Base
     @d.draw(@base_image)
   end
 
-protected
+  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
@@ -62,29 +59,45 @@ protected
     # Draw horizontal line markers and annotate with numbers
     @d = @d.stroke(@marker_color)
     @d = @d.stroke_width 1
-    number_of_lines = 5
+    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
 
-    # TODO Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
-    increment = significant(@maximum_value.to_f / number_of_lines)
-    (0..number_of_lines).each do |index|
+      number_of_lines = @marker_count
+      increment = @increment
+    end
 
-      line_diff    = (@graph_right - @graph_left) / number_of_lines
-      x            = @graph_right - (line_diff * index) - 1
-      @d           = @d.line(x, @graph_bottom, x, @graph_bottom + 0.5 * LABEL_MARGIN)
-      diff         = index - number_of_lines
-      marker_label = diff.abs * increment
+    (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.fill = @font_color
+        @d.font = @font if @font
+        @d.stroke = 'transparent'
         @d.pointsize = scale_fontsize(@marker_font_size)
-        @d.gravity   = CenterGravity
+        @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
-                          marker_label.to_s, @scale)
+        @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
@@ -95,13 +108,13 @@ protected
 
   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,
+      @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)
@@ -110,4 +123,3 @@ protected
   end
 
 end
-

data/lib/gruff/line.rb

@@ -1,4 +1,3 @@
-
 require File.dirname(__FILE__) + '/base'
 
 ##
@@ -16,17 +15,17 @@ class Gruff::Line < Gruff::Base
 
   # Draw a dashed line at the given value
   attr_accessor :baseline_value
-	
+
   # Color of the baseline
   attr_accessor :baseline_color
-  
+
   # Dimensions of lines and dots; calculated based on dataset size if left unspecified
   attr_accessor :line_width
   attr_accessor :dot_radius
 
   # 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
@@ -41,20 +40,20 @@ class Gruff::Line < Gruff::Base
   # 
   # 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? or ((not Numeric === args.first) && (not String === args.first)) then
+    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
-    
+
     @hide_dots = @hide_lines = false
     @baseline_color = 'red'
     @baseline_value = nil
     @maximum_x_value = nil
     @minimum_x_value = nil
   end
-  
+
   # This method allows one to plot a dataset with both X and Y data.
   #
   # Parameters are as follows:
@@ -63,7 +62,13 @@ class Gruff::Line < Gruff::Base
   #   y_data_points: an array containing the y data points for the graph
   #   color: hex number indicating the line color as an RGB triplet
   #
-  #  Notes: 
+  #   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
@@ -76,67 +81,55 @@ class Gruff::Line < Gruff::Base
   #   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 1st dataset that you 
-  #   #passed in.  In this example the lables are drawn at x locations 1,4,6
-  #   g.labels = {0 => '2003', 2 => '2004', 4 => '2005'}  #labels
- 
+  #   #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
+    raise ArgumentError, 'x_data_points is nil!' if x_data_points.length == 0
 
-    if x_data_points.all?{|p| p.size == 2}
-      x_data_points, y_data_points = x_data_points.map{|p| p[0]}, x_data_points.map{|p| p[1]}
+    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
+    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.
+    # 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
-    lastElem = @data.length()-1
-    @data[lastElem][DATA_VALUES_X_INDEX] = x_data_points
-    
+    # 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_with_index do |x_data_point, index|
+    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
+
+      @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
     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
 
-    #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
-
-    if (defined?(@norm_baseline)) then
+    if defined?(@norm_baseline)
       level = @graph_top + (@graph_height - @norm_baseline * @graph_height)
       @d = @d.push
       @d.stroke_color @baseline_color
@@ -147,23 +140,27 @@ class Gruff::Line < Gruff::Base
       @d = @d.pop
     end
 
-    @norm_data.each_with_index do |data_row, dr_index|
+    @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|
-        next if data_point.nil?
-
+        unless data_point
+          prev_x = prev_y = nil
+          next
+        end
         x_data = data_row[DATA_VALUES_X_INDEX]
-        if (x_data == nil)
+        if x_data == nil
           #use the old method: equally spaced points along the x-axis
-          new_x = @graph_left + (@x_increment * index)  
+          new_x = @graph_left + (@x_increment * index)
+          draw_label(new_x, index)
         else
-          new_x = getXCoord(x_data[index], @graph_width, @graph_left)
+          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
-        
-        draw_label(new_x, index)
 
         new_y = @graph_top + (@graph_height - data_point * @graph_height)
 
@@ -172,13 +169,12 @@ class Gruff::Line < Gruff::Base
         @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)
-
+                                 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)
+            clip_value_if_greater_than(@columns / (@norm_data.first[DATA_VALUES_INDEX].size * 2.5), 5.0)
 
-        if !@hide_lines and !prev_x.nil? and !prev_y.nil? then          
+        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
@@ -186,34 +182,52 @@ class Gruff::Line < Gruff::Base
         end
         @d = @d.circle(new_x, new_y, new_x - circle_radius, new_y) unless @hide_dots
 
-        prev_x = new_x
-        prev_y = new_y
+        prev_x, prev_y = new_x, new_y
       end
-
     end
 
     @d.draw(@base_image)
   end
 
-  def normalize
-    @maximum_value = [@maximum_value.to_f, @baseline_value.to_f].max
+  def setup_data
+    if @baseline_value
+      @maximum_value = [@maximum_value.to_f, @baseline_value.to_f].max
+      @minimum_value = [@minimum_value.to_f, @baseline_value.to_f].min
+    end
     super
-    @norm_baseline = (@baseline_value.to_f / @maximum_value.to_f) if @baseline_value
   end
-  
+
+  def normalize(force=false)
+    super(force)
+    @norm_baseline = ((@baseline_value.to_f - @minimum_value) / @spread.to_f) if @baseline_value
+
+    #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]}
+    super unless @data.any? { |d| d[DATA_VALUES_X_INDEX] }
   end
 
-  def getXCoord(x_data_point, width, offset)
-    return(x_data_point * width + offset)
+  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|
-      if !data_point.nil?
+      unless data_point.nil?
         if one_point
           # more than one point, bail
           return false
@@ -222,7 +236,7 @@ class Gruff::Line < Gruff::Base
         one_point = true
       end
     end
-    return one_point
+    one_point
   end
 
 end