gruff 0.4.0-java

data/lib/gruff/side_bar.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/base'
+
+##
+# Graph with individual horizontal bars instead of vertical bars.
+
+class Gruff::SideBar < Gruff::Base
+
+  # Spacing factor applied between bars
+  attr_accessor :bar_spacing
+
+  def draw
+    @has_left_labels = true
+    super
+
+    return unless @has_data
+    draw_bars
+  end
+
+  protected
+
+  def draw_bars
+    # Setup spacing.
+    #
+    @bar_spacing ||= 0.9
+
+    @bars_width = @graph_height / @column_count.to_f
+    @bar_width = @bars_width / @norm_data.size
+    @d = @d.stroke_opacity 0.0
+    height = Array.new(@column_count, 0)
+    length = Array.new(@column_count, @graph_left)
+    padding = (@bar_width * (1 - @bar_spacing)) / 2
+
+    # if we're a side stacked bar then we don't need to draw ourself at all
+    # because sometimes (due to different heights/min/max) you can actually
+    # see both graphs and it looks like crap
+    return if self.is_a?(Gruff::SideStackedBar)
+
+    @norm_data.each_with_index do |data_row, row_index|
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+
+        # Using the original calcs from the stacked bar chart
+        # to get the difference between
+        # part of the bart chart we wish to stack.
+        temp1 = @graph_left + (@graph_width - data_point * @graph_width - height[point_index])
+        temp2 = @graph_left + @graph_width - height[point_index]
+        difference = temp2 - temp1
+
+        left_x = length[point_index] - 1
+        left_y = @graph_top + (@bars_width * point_index) + (@bar_width * row_index) + padding
+        right_x = left_x + difference
+        right_y = left_y + @bar_width * @bar_spacing
+
+        height[point_index] += (data_point * @graph_width)
+
+        @d = @d.rectangle(left_x, left_y, right_x, right_y)
+
+        # Calculate center based on bar_width and current row
+
+        if @use_data_label
+          label_center = @graph_top + (@bar_width * (row_index+point_index) + @bar_width / 2)
+          draw_label(label_center, row_index, @norm_data[row_index][DATA_LABEL_INDEX])
+        else
+          label_center = @graph_top + (@bars_width * point_index + @bars_width / 2)
+          draw_label(label_center, point_index)
+        end
+        if @show_labels_for_bar_values
+          val = (@label_formatting || '%.2f') % @norm_data[row_index][3][point_index]
+          draw_value_label(right_x+40, (@graph_top + (((row_index+point_index+1) * @bar_width) - (@bar_width / 2)))-12, val.commify, true)
+        end
+      end
+
+    end
+
+    @d.draw(@base_image)
+  end
+
+  # 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
+    number_of_lines = @marker_count || 5
+    number_of_lines = 1 if number_of_lines == 0
+
+    # TODO Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
+    increment = significant(@spread.to_f / number_of_lines)
+    (0..number_of_lines).each do |index|
+
+      line_diff = (@graph_right - @graph_left) / number_of_lines
+      x = @graph_right - (line_diff * index) - 1
+      @d = @d.line(x, @graph_bottom, x, @graph_top)
+      diff = index - number_of_lines
+      marker_label = diff.abs * increment + @minimum_value
+
+      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
+                                marker_label.to_s, @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, label=nil)
+    if !@labels[index].nil? && @labels_seen[index].nil?
+      lbl = (@use_data_label) ? label : @labels[index]
+      @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,
+                              lbl, @scale)
+      @labels_seen[index] = 1
+    end
+  end
+
+end

data/lib/gruff/side_stacked_bar.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/side_bar'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+##
+# New gruff graph type added to enable sideways stacking bar charts 
+# (basically looks like a x/y flip of a standard stacking bar chart)
+#
+# alun.eyre@googlemail.com 
+
+class Gruff::SideStackedBar < Gruff::SideBar
+  include StackedMixin
+
+  # Spacing factor applied between bars
+  attr_accessor :bar_spacing
+  
+  def draw
+    @has_left_labels = true
+    get_maximum_by_stack
+    super
+  end
+
+  protected
+
+  def draw_bars
+    # Setup spacing.
+    #
+    # Columns sit stacked.
+    @bar_spacing ||= 0.9
+
+    @bar_width = @graph_height / @column_count.to_f
+    @d = @d.stroke_opacity 0.0
+    height = Array.new(@column_count, 0)
+    length = Array.new(@column_count, @graph_left)
+    padding = (@bar_width * (1 - @bar_spacing)) / 2
+    if @show_labels_for_bar_values
+      label_values = Array.new
+      0.upto(@column_count-1) {|i| label_values[i] = {:value => 0, :right_x => 0}}
+    end
+    @norm_data.each_with_index do |data_row, row_index|
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+
+    	  ## using the original calcs from the stacked bar chart to get the difference between
+    	  ## part of the bart chart we wish to stack.
+    	  temp1 = @graph_left + (@graph_width -
+                                    data_point * @graph_width - 
+                                    height[point_index]) + 1
+    	  temp2 = @graph_left + @graph_width - height[point_index] - 1
+    	  difference = temp2 - temp1
+
+    	  @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+        left_x = length[point_index] #+ 1
+              left_y = @graph_top + (@bar_width * point_index) + padding
+    	  right_x = left_x + difference
+              right_y = left_y + @bar_width * @bar_spacing
+    	  length[point_index] += difference
+        height[point_index] += (data_point * @graph_width - 2)
+        
+        if @show_labels_for_bar_values
+          label_values[point_index][:value] += @norm_data[row_index][3][point_index]
+          label_values[point_index][:right_x] = right_x
+        end
+                
+        # if a data point is 0 it can result in weird really thing lines
+        # that shouldn't even be there being drawn on top of the existing
+        # bar - this is bad
+        if data_point != 0
+          @d = @d.rectangle(left_x, left_y, right_x, right_y)
+          # Calculate center based on bar_width and current row
+        end
+        # we still need to draw the labels
+        # Calculate center based on bar_width and current row
+        label_center = @graph_top + (@bar_width * point_index) + (@bar_width * @bar_spacing / 2.0)
+        draw_label(label_center, point_index)
+      end
+
+    end
+    if @show_labels_for_bar_values
+      label_values.each_with_index do |data, i|
+        val = (@label_formatting || "%.2f") % data[:value]
+        draw_value_label(data[:right_x]+40, (@graph_top + (((i+1) * @bar_width) - (@bar_width / 2)))-12, val.commify, true)
+      end
+    end
+    
+    @d.draw(@base_image)    
+  end
+
+  def larger_than_max?(data_point, index=0)
+    max(data_point, index) > @maximum_value
+  end
+
+  def max(data_point, index)
+    @data.inject(0) {|sum, item| sum + item[DATA_VALUES_INDEX][index]}
+  end
+
+end

data/lib/gruff/spider.rb

@@ -0,0 +1,131 @@
+
+require File.dirname(__FILE__) + '/base'
+
+# Experimental!!! See also the Net graph.
+#
+# Submitted by Kevin Clark http://glu.ttono.us/
+class Gruff::Spider < Gruff::Base
+  
+  # Hide all text
+  attr_reader :hide_text
+  attr_accessor :hide_axes
+  attr_reader :transparent_background
+  attr_accessor :rotation
+  
+  def transparent_background=(value)
+    @transparent_background = value
+    @base_image = render_transparent_background if value
+  end
+
+  def hide_text=(value)
+    @hide_title = @hide_text = value
+  end
+
+  def initialize(max_value, target_width = 800)
+    super(target_width)
+    @max_value = max_value
+    @hide_legend = true;
+    @rotation = 0
+  end
+  
+  def draw
+    @hide_line_markers = true
+    
+    super
+
+    return unless @has_data
+
+    # Setup basic positioning
+    diameter = @graph_height
+    radius = @graph_height / 2.0
+    top_x = @graph_left + (@graph_width - diameter) / 2.0
+    center_x = @graph_left + (@graph_width / 2.0)
+    center_y = @graph_top + (@graph_height / 2.0) - 25 # Move graph up a bit
+
+    @unit_length = radius / @max_value
+        
+    total_sum = sums_for_spider
+    prev_degrees = 0.0
+    additive_angle = (2 * Math::PI)/ @data.size
+    
+    current_angle = rotation * Math::PI / 180.0
+
+    # Draw axes
+    draw_axes(center_x, center_y, radius, additive_angle) unless hide_axes    
+
+    # Draw polygon
+    draw_polygon(center_x, center_y, additive_angle)
+
+    @d.draw(@base_image)
+  end
+
+private
+
+  def normalize_points(value)
+    value * @unit_length
+  end
+
+  def draw_label(center_x, center_y, angle, radius, amount)
+    r_offset = 50      # The distance out from the center of the pie to get point
+    x_offset = center_x      # The label points need to be tweaked slightly
+    y_offset = center_y + 0  # This one doesn't though
+    x = x_offset + ((radius + r_offset) * Math.cos(angle))
+    y = y_offset + ((radius + r_offset) * Math.sin(angle))
+
+    # Draw label
+    @d.fill = @marker_color
+    @d.font = @font if @font
+    @d.pointsize = scale_fontsize(legend_font_size)
+    @d.stroke = 'transparent'
+    @d.font_weight = BoldWeight
+    @d.gravity = CenterGravity
+    @d.annotate_scaled( @base_image, 
+                      0, 0,
+                      x, y, 
+                      amount, @scale)
+  end
+
+  def draw_axes(center_x, center_y, radius, additive_angle, line_color = nil)
+    return if hide_axes
+
+    current_angle = rotation * Math::PI / 180.0
+
+    @data.each do |data_row|
+      @d.stroke(line_color || data_row[DATA_COLOR_INDEX])
+      @d.stroke_width 5.0
+
+      x_offset = radius * Math.cos(current_angle)
+      y_offset = radius * Math.sin(current_angle)
+
+      @d.line(center_x, center_y,
+              center_x + x_offset,
+              center_y + y_offset)
+
+      draw_label(center_x, center_y, current_angle, radius, data_row[DATA_LABEL_INDEX].to_s) unless hide_text
+
+      current_angle += additive_angle
+    end
+  end
+
+  def draw_polygon(center_x, center_y, additive_angle, color = nil)
+    points = []
+    current_angle = rotation * Math::PI / 180.0
+
+    @data.each do |data_row|
+      points << center_x + normalize_points(data_row[DATA_VALUES_INDEX].first) * Math.cos(current_angle)
+      points << center_y + normalize_points(data_row[DATA_VALUES_INDEX].first) * Math.sin(current_angle)
+      current_angle += additive_angle
+    end
+
+    @d.stroke_width 1.0
+    @d.stroke(color || @marker_color)
+    @d.fill(color || @marker_color)
+    @d.fill_opacity 0.4
+    @d.polygon(*points)
+  end
+
+  def sums_for_spider
+    @data.inject(0.0) {|sum, data_row| sum += data_row[DATA_VALUES_INDEX].first}
+  end
+
+end

data/lib/gruff/stacked_area.rb

@@ -0,0 +1,67 @@
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+class Gruff::StackedArea < Gruff::Base
+  include StackedMixin
+  attr_accessor :last_series_goes_on_bottom
+  
+  def draw
+    get_maximum_by_stack
+    super
+
+    return unless @has_data
+
+    @x_increment = @graph_width / (@column_count - 1).to_f
+    @d = @d.stroke 'transparent'
+
+    height = Array.new(@column_count, 0)
+
+    data_points = nil
+    iterator = last_series_goes_on_bottom ? :reverse_each : :each
+    @norm_data.send(iterator) do |data_row|
+      prev_data_points = data_points
+      data_points = Array.new
+        
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[DATA_VALUES_INDEX].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 - height[index])
+
+        height[index] += (data_point * @graph_height)
+        
+        data_points << new_x
+        data_points << new_y
+          
+        draw_label(new_x, index)
+
+      end
+
+      if prev_data_points
+        poly_points = data_points.dup
+        (prev_data_points.length/2 - 1).downto(0) do |i|
+          poly_points << prev_data_points[2*i] 
+          poly_points << prev_data_points[2*i+1]
+        end
+        poly_points << data_points[0] 
+        poly_points << data_points[1] 
+      else
+        poly_points = data_points.dup
+        poly_points << @graph_right
+        poly_points << @graph_bottom - 1
+        poly_points << @graph_left
+        poly_points << @graph_bottom - 1
+        poly_points << data_points[0] 
+        poly_points << data_points[1] 
+      end
+      @d = @d.polyline(*poly_points)
+
+    end
+
+    @d.draw(@base_image)
+  end
+   
+ 
+end

data/lib/gruff/stacked_bar.rb

@@ -0,0 +1,57 @@
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/stacked_mixin'
+
+class Gruff::StackedBar < Gruff::Base
+    include StackedMixin
+
+    # Spacing factor applied between bars
+    attr_accessor :bar_spacing
+    
+    # Draws a bar graph, but multiple sets are stacked on top of each other.
+    def draw
+      get_maximum_by_stack
+      super
+      return unless @has_data
+
+      # Setup spacing.
+      #
+      # Columns sit stacked.
+      @bar_spacing ||= 0.9
+      @bar_width = @graph_width / @column_count.to_f
+      padding = (@bar_width * (1 - @bar_spacing)) / 2
+    
+      @d = @d.stroke_opacity 0.0
+      
+      height = Array.new(@column_count, 0)
+    
+      @norm_data.each_with_index do |data_row, row_index|      
+        data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+          @d = @d.fill data_row[DATA_COLOR_INDEX]
+          
+          # Calculate center based on bar_width and current row
+          label_center = @graph_left + (@bar_width * point_index) + (@bar_width * @bar_spacing / 2.0)
+          draw_label(label_center, point_index)
+
+          next if (data_point == 0)
+          # Use incremented x and scaled y
+          left_x = @graph_left + (@bar_width * point_index) + padding
+          left_y = @graph_top + (@graph_height -
+                                 data_point * @graph_height - 
+                                 height[point_index]) + 1
+          right_x = left_x + @bar_width * @bar_spacing
+          right_y = @graph_top + @graph_height - height[point_index] - 1
+          
+          # update the total height of the current stacked bar
+          height[point_index] += (data_point * @graph_height ) 
+          
+          @d = @d.rectangle(left_x, left_y, right_x, right_y)
+          
+        end
+
+      end
+    
+      @d.draw(@base_image)    
+    end
+
+end