gruff 0.6.0 → 0.11.0

data/lib/gruff/spider.rb

@@ -1,20 +1,28 @@
+# frozen_string_literal: true
 
-require File.dirname(__FILE__) + '/base'
+require 'gruff/base'
 
 # Experimental!!! See also the Net graph.
 #
-# Submitted by Kevin Clark http://glu.ttono.us/
+# Here's how to set up a Gruff::Spider.
+#
+#   g = Gruff::Spider.new(30)
+#   g.title = "Spider Graph"
+#   g.data :Strength, [10]
+#   g.data :Dexterity, [16]
+#   g.data :Constitution, [12]
+#   g.data :Intelligence, [12]
+#   g.data :Wisdom, [10]
+#   g.data 'Charisma', [16]
+#   g.write("spider.png")
+
 class Gruff::Spider < Gruff::Base
-  
-  # Hide all text
-  attr_reader :hide_text
-  attr_accessor :hide_axes
-  attr_reader :transparent_background
-  attr_accessor :rotation
-  
+  # Hide all text.
+  attr_writer :hide_axes
+  attr_writer :rotation
+
   def transparent_background=(value)
-    @transparent_background = value
-    @base_image = render_transparent_background if value
+    Gruff::Renderer.setup_transparent_background(@columns, @rows) if value
   end
 
   def hide_text=(value)
@@ -24,39 +32,40 @@ class Gruff::Spider < Gruff::Base
   def initialize(max_value, target_width = 800)
     super(target_width)
     @max_value = max_value
-    @hide_legend = true;
+  end
+
+  def initialize_ivars
+    super
+    @hide_legend = true
+    @hide_axes = false
+    @hide_text = false
     @rotation = 0
   end
-  
+  private :initialize_ivars
+
   def draw
     @hide_line_markers = true
-    
+
     super
 
-    return unless @has_data
+    return unless data_given?
 
     # 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
+
+    additive_angle = (2 * Math::PI) / store.length
 
     # Draw axes
-    draw_axes(center_x, center_y, radius, additive_angle) unless hide_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)
+    Gruff::Renderer.finish
   end
 
 private
@@ -66,42 +75,30 @@ private
   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
+    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)
+    text_renderer = Gruff::Renderer::Text.new(amount, font: @font, size: @legend_font_size, color: @marker_color, weight: Magick::BoldWeight)
+    text_renderer.add_to_render_queue(0, 0, x, y, Magick::CenterGravity)
   end
 
   def draw_axes(center_x, center_y, radius, additive_angle, line_color = nil)
-    return if hide_axes
+    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
+    current_angle = @rotation * Math::PI / 180.0
 
+    store.data.each do |data_row|
       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)
+      Gruff::Renderer::Line.new(color: line_color || data_row.color, width: 5.0)
+                           .render(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
+      draw_label(center_x, center_y, current_angle, radius, data_row.label.to_s) unless @hide_text
 
       current_angle += additive_angle
     end
@@ -109,23 +106,18 @@ private
 
   def draw_polygon(center_x, center_y, additive_angle, color = nil)
     points = []
-    current_angle = rotation * Math::PI / 180.0
+    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)
+    store.data.each do |data_row|
+      points << center_x + normalize_points(data_row.points.first) * Math.cos(current_angle)
+      points << center_y + normalize_points(data_row.points.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)
+    Gruff::Renderer::Polygon.new(color: color || @marker_color, opacity: 0.4).render(points)
   end
 
   def sums_for_spider
-    @data.inject(0.0) {|sum, data_row| sum += data_row[DATA_VALUES_INDEX].first}
+    store.data.reduce(0.0) { |sum, data_row| sum + data_row.points.first }
   end
-
 end

data/lib/gruff/stacked_area.rb

@@ -1,67 +1,75 @@
+# frozen_string_literal: true
 
-require File.dirname(__FILE__) + '/base'
-require File.dirname(__FILE__) + '/stacked_mixin'
+require 'gruff/base'
+require 'gruff/helper/stacked_mixin'
 
+#
+# Here's how to set up a Gruff::StackedArea.
+#
+#   g = Gruff::StackedArea.new
+#   g.title = 'StackedArea Graph'
+#   g.data :Jimmy, [25, 36, 86, 39, 25, 31, 79, 88]
+#   g.data :Charles, [80, 54, 67, 54, 68, 70, 90, 95]
+#   g.data :Julie, [22, 29, 35, 38, 36, 40, 46, 57]
+#   g.write('stacked_area.png')
+#
 class Gruff::StackedArea < Gruff::Base
   include StackedMixin
-  attr_accessor :last_series_goes_on_bottom
-  
+  attr_writer :last_series_goes_on_bottom
+
+  def initialize_ivars
+    super
+    @last_series_goes_on_bottom = false
+  end
+  private :initialize_ivars
+
   def draw
-    get_maximum_by_stack
+    calculate_maximum_by_stack
     super
 
-    return unless @has_data
+    return unless data_given?
 
-    @x_increment = @graph_width / (@column_count - 1).to_f
-    @d = @d.stroke 'transparent'
+    x_increment = @graph_width / (column_count - 1).to_f
 
-    height = Array.new(@column_count, 0)
+    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|
+    iterator = @last_series_goes_on_bottom ? :reverse_each : :each
+    store.norm_data.public_send(iterator) do |data_row|
       prev_data_points = data_points
-      data_points = Array.new
-        
-      @d = @d.fill data_row[DATA_COLOR_INDEX]
+      data_points = []
 
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
+      data_row.points.each_with_index do |data_point, index|
         # Use incremented x and scaled y
-        new_x = @graph_left + (@x_increment * index)
+        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)
 
+        draw_label(new_x, index)
       end
 
+      poly_points = data_points.dup
       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]
+        (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)
+      poly_points << data_points[0]
+      poly_points << data_points[1]
 
+      Gruff::Renderer::Polygon.new(color: data_row.color).render(poly_points)
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
-   
- 
 end

data/lib/gruff/stacked_bar.rb

@@ -1,61 +1,94 @@
+# frozen_string_literal: true
 
-require File.dirname(__FILE__) + '/base'
-require File.dirname(__FILE__) + '/stacked_mixin'
+require 'gruff/base'
+require 'gruff/helper/stacked_mixin'
+require 'gruff/helper/bar_value_label_mixin'
 
+#
+# Here's how to set up a Gruff::StackedBar.
+#
+#   g = Gruff::StackedBar.new
+#   g.title = 'StackedBar Graph'
+#   g.data :Art, [0, 5, 8, 15]
+#   g.data :Philosophy, [10, 3, 2, 8]
+#   g.data :Science, [2, 15, 8, 11]
+#   g.write('stacked_bar.png')
+#
 class Gruff::StackedBar < Gruff::Base
-    include StackedMixin
-
-    # Spacing factor applied between bars
-    attr_accessor :bar_spacing
-
-    # Number of pixels between bar segments
-    attr_accessor :segment_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
-      @segment_spacing ||= 1
-      @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]) + @segment_spacing
-          right_x = left_x + @bar_width * @bar_spacing
-          right_y = @graph_top + @graph_height - height[point_index] - @segment_spacing
-          
-          # 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
+  include StackedMixin
+  include BarValueLabelMixin
 
+  # Spacing factor applied between bars.
+  attr_writer :bar_spacing
+
+  # Number of pixels between bar segments.
+  attr_writer :segment_spacing
+
+  # Set the number output format for labels using sprintf.
+  # Default is +"%.2f"+.
+  attr_writer :label_formatting
+
+  # Output the values for the bars on a bar graph.
+  # Default is +false+.
+  attr_writer :show_labels_for_bar_values
+
+  def initialize_ivars
+    super
+    @bar_spacing = 0.9
+    @segment_spacing = 2
+    @label_formatting = nil
+    @show_labels_for_bar_values = false
+  end
+  private :initialize_ivars
+
+  # Draws a bar graph, but multiple sets are stacked on top of each other.
+  def draw
+    calculate_maximum_by_stack
+    super
+    return unless data_given?
+
+    # Setup spacing.
+    #
+    # Columns sit stacked.
+    bar_width = @graph_width / column_count.to_f
+    padding = (bar_width * (1 - @bar_spacing)) / 2
+
+    height = Array.new(column_count, 0)
+    bar_value_label = BarValueLabel.new(column_count, bar_width)
+
+    store.norm_data.each_with_index do |data_row, row_index|
+      data_row.points.each_with_index do |data_point, 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]) + @segment_spacing
+        right_x = left_x + bar_width * @bar_spacing
+        right_y = @graph_top + @graph_height - height[point_index]
+
+        # update the total height of the current stacked bar
+        height[point_index] += (data_point * @graph_height)
+
+        rect_renderer = Gruff::Renderer::Rectangle.new(color: data_row.color)
+        rect_renderer.render(left_x, left_y, right_x, right_y)
+
+        # Calculate center based on bar_width and current row
+        label_center = left_x + bar_width * @bar_spacing / 2.0
+        draw_label(label_center, point_index)
+
+        bar_value_label.coordinates[point_index] = [left_x, left_y, right_x, right_y]
+        bar_value_label.values[point_index] += store.data[row_index].points[point_index]
+      end
+    end
+
+    if @show_labels_for_bar_values
+      bar_value_label.prepare_rendering(@label_formatting) do |x, y, text|
+        draw_value_label(x, y, text, true)
       end
-    
-      @d.draw(@base_image)    
     end
 
+    Gruff::Renderer.finish
+  end
 end

data/lib/gruff/store/base_data.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Gruff
+  # @private
+  class Store
+    class BaseData < Struct.new(:label, :points, :color)
+      def initialize(label, points, color)
+        self.label = label.to_s
+        self.points = Array(points)
+        self.color = color
+      end
+
+      def empty?
+        points.empty?
+      end
+
+      def columns
+        points.length
+      end
+
+      def min
+        points.compact.min
+      end
+
+      def max
+        points.compact.max
+      end
+
+      def normalize(args = {})
+        norm_points = points.map do |point|
+          point.nil? ? nil : (point.to_f - args[:minimum].to_f) / args[:spread]
+        end
+
+        self.class.new(label, norm_points, color)
+      end
+    end
+  end
+end