gruff 0.5.0 → 0.9.0

data/lib/gruff/pie.rb

@@ -1,4 +1,6 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
+
+require 'gruff/base'
 
 ##
 # Here's how to make a Pie graph:
@@ -10,115 +12,209 @@ require File.dirname(__FILE__) + '/base'
 #   g.write("test/output/pie_keynote.png")
 #
 # To control where the pie chart starts creating slices, use #zero_degree.
-
 class Gruff::Pie < Gruff::Base
-
-  TEXT_OFFSET_PERCENTAGE = 0.15
+  DEFAULT_TEXT_OFFSET_PERCENTAGE = 0.15
 
   # Can be used to make the pie start cutting slices at the top (-90.0)
-  # or at another angle. Default is 0.0, which starts at 3 o'clock.
-  attr_accessor :zero_degree
+  # or at another angle. Default is +0.0+, which starts at 3 o'clock.
+  attr_writer :zero_degree
+
   # Do not show labels for slices that are less than this percent. Use 0 to always show all labels.
-  # Defaults to 0
-  attr_accessor :hide_labels_less_than
+  # Defaults to +0+.
+  attr_writer :hide_labels_less_than
+
+  # Affect the distance between the percentages and the pie chart.
+  # Defaults to +0.15+.
+  attr_writer :text_offset_percentage
+
+  ## Use values instead of percentages.
+  attr_accessor :show_values_as_labels
 
   def initialize_ivars
     super
-    @zero_degree = 0.0
-    @hide_labels_less_than = 0.0
+
+    @show_values_as_labels = false
+
+    @store = Gruff::Store.new(Gruff::Store::CustomData)
+  end
+  private :initialize_ivars
+
+  def zero_degree
+    @zero_degree ||= 0.0
+  end
+
+  def hide_labels_less_than
+    @hide_labels_less_than ||= 0.0
+  end
+
+  def text_offset_percentage
+    @text_offset_percentage ||= DEFAULT_TEXT_OFFSET_PERCENTAGE
+  end
+
+  def options
+    {
+      zero_degree: zero_degree,
+      hide_labels_less_than: hide_labels_less_than,
+      text_offset_percentage: text_offset_percentage,
+      show_values_as_labels: show_values_as_labels
+    }
   end
 
   def draw
-    @hide_line_markers = true
-    
+    hide_line_markers
+
     super
 
-    return unless @has_data
-
-    diameter = @graph_height
-    radius = ([@graph_width, @graph_height].min / 2.0) * 0.8
-    center_x = @graph_left + (@graph_width / 2.0)
-    center_y = @graph_top + (@graph_height / 2.0) - 10 # Move graph up a bit
-    total_sum = sums_for_pie()
-    prev_degrees = @zero_degree
-
-    # Use full data since we can easily calculate percentages
-    data = (@sort ? @data.sort{ |a, b| a[DATA_VALUES_INDEX].first <=> b[DATA_VALUES_INDEX].first } : @data)
-    data.each do |data_row|
-      if data_row[DATA_VALUES_INDEX].first > 0
-        @d = @d.stroke data_row[DATA_COLOR_INDEX]
-        @d = @d.fill 'transparent'
-        @d.stroke_width(radius) # stroke width should be equal to radius. we'll draw centered on (radius / 2)
-
-        current_degrees = (data_row[DATA_VALUES_INDEX].first / total_sum) * 360.0 
-
-        # ellipse will draw the the stroke centered on the first two parameters offset by the second two.
-        # therefore, in order to draw a circle of the proper diameter we must center the stroke at
-        # half the radius for both x and y
-        @d = @d.ellipse(center_x, center_y, 
-                  radius / 2.0, radius / 2.0,
-                  prev_degrees, prev_degrees + current_degrees + 0.5) # <= +0.5 'fudge factor' gets rid of the ugly gaps
-                  
-        half_angle = prev_degrees + ((prev_degrees + current_degrees) - prev_degrees) / 2
-        
-        label_val = ((data_row[DATA_VALUES_INDEX].first / total_sum) * 100.0).round
-        unless label_val < @hide_labels_less_than
-          # RMagick must use sprintf with the string and % has special significance.
-          label_string = label_val.to_s + '%'
-          @d = draw_label(center_x,center_y, half_angle,
-                          radius + (radius * TEXT_OFFSET_PERCENTAGE),
-                          label_string)
-        end
-
-        prev_degrees += current_degrees
+    return unless data_given?
+
+    slices.each do |slice|
+      if slice.value > 0
+        Gruff::Renderer::Ellipse.new(color: slice.color, width: radius)
+                                .render(center_x, center_y, radius / 2.0, radius / 2.0, chart_degrees, chart_degrees + slice.degrees + 0.5)
+        process_label_for slice
+        update_chart_degrees_with slice.degrees
       end
     end
 
-    # TODO debug a circle where the text is drawn...
-    
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
 
 private
 
-  ##
-  # Labels are drawn around a slightly wider ellipse to give room for 
-  # labels on the left and right.
-  def draw_label(center_x, center_y, angle, radius, amount)
-    # TODO Don't use so many hard-coded numbers
-    r_offset = 20.0      # The distance out from the center of the pie to get point
-    x_offset = center_x # + 15.0 # The label points need to be tweaked slightly
-    y_offset = center_y  # This one doesn't though
-    radius_offset = (radius + r_offset)
-    ellipse_factor = radius_offset * TEXT_OFFSET_PERCENTAGE
-    x = x_offset + ((radius_offset + ellipse_factor) * Math.cos(angle.deg2rad))
-    y = y_offset + (radius_offset * Math.sin(angle.deg2rad))
-    
-    # Draw label
-    @d.fill = @font_color
-    @d.font = @font if @font
-    @d.pointsize = scale_fontsize(@marker_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 sums_for_pie
-    total_sum = 0.0
-    @data.collect {|data_row| total_sum += data_row[DATA_VALUES_INDEX].first }
-    total_sum
+  def slices
+    @slices ||= begin
+      slices = store.data.map { |data| slice_class.new(data, options) }
+
+      slices.sort_by(&:value) if @sort
+
+      total = slices.map(&:value).inject(:+).to_f
+      slices.each { |slice| slice.total = total }
+    end
   end
 
-end
+  # General Helper Methods
+
+  def hide_line_markers
+    @hide_line_markers = true
+  end
 
-class Float
-  # Used for degree => radian conversions
-  def deg2rad
-    self * (Math::PI/180.0)
+  def update_chart_degrees_with(degrees)
+    @chart_degrees = chart_degrees + degrees
+  end
+
+  def slice_class
+    PieSlice
+  end
+
+  # Spatial Value-Related Methods
+
+  def chart_degrees
+    @chart_degrees ||= zero_degree
+  end
+
+  attr_reader :graph_height
+
+  attr_reader :graph_width
+
+  def diameter
+    graph_height
+  end
+
+  def half_width
+    graph_width / 2.0
+  end
+
+  def half_height
+    graph_height / 2.0
+  end
+
+  def radius
+    @radius ||= ([graph_width, graph_height].min / 2.0) * 0.8
   end
-end
 
+  def center_x
+    @center_x ||= @graph_left + half_width
+  end
+
+  def center_y
+    @center_y ||= @graph_top + half_height - 10
+  end
+
+  def distance_from_center
+    20.0
+  end
+
+  def radius_offset
+    radius + (radius * text_offset_percentage) + distance_from_center
+  end
+
+  def ellipse_factor
+    radius_offset * text_offset_percentage
+  end
+
+  # Label-Related Methods
+
+  def process_label_for(slice)
+    if slice.percentage >= hide_labels_less_than
+      x, y = label_coordinates_for slice
+
+      draw_label(x, y, slice.label)
+    end
+  end
+
+  def label_coordinates_for(slice)
+    angle = chart_degrees + slice.degrees / 2
+
+    [x_label_coordinate(angle), y_label_coordinate(angle)]
+  end
+
+  def x_label_coordinate(angle)
+    center_x + ((radius_offset + ellipse_factor) * Math.cos(deg2rad(angle)))
+  end
+
+  def y_label_coordinate(angle)
+    center_y + (radius_offset * Math.sin(deg2rad(angle)))
+  end
+
+  # Drawing-Related Methods
+
+  def draw_label(x, y, value)
+    text_renderer = Gruff::Renderer::Text.new(value, font: @font, size: @marker_font_size, color: @font_color, weight: Magick::BoldWeight)
+    text_renderer.render(0, 0, x, y, Magick::CenterGravity)
+  end
+
+  # Helper Classes
+  #
+  # @private
+  class PieSlice < Struct.new(:data_array, :options)
+    attr_accessor :total
+
+    def name
+      data_array[0]
+    end
+
+    def value
+      data_array[1].first
+    end
+
+    def color
+      data_array[2]
+    end
+
+    def size
+      @size ||= value / total
+    end
+
+    def percentage
+      @percentage ||= (size * 100.0).round
+    end
+
+    def degrees
+      @degrees ||= size * 360.0
+    end
+
+    def label
+      options[:show_values_as_labels] ? value.to_s : "#{percentage}%"
+    end
+  end
+end

data/lib/gruff/renderer/bezier.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Bezier
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width] || 1.0
+    end
+
+    def render(points)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke(@color)
+      draw.stroke_width(@width)
+      draw.fill_opacity(0.0)
+      draw.bezier(*points)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/circle.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Circle
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width] || 1.0
+    end
+
+    def render(origin_x, origin_y, perim_x, perim_y)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.fill(@color)
+      draw.stroke(@color)
+      draw.stroke_width(@width)
+      draw.circle(origin_x, origin_y, perim_x, perim_y)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/dash_line.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::DashLine
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width]
+    end
+
+    def render(start_x, start_y, end_x, end_y)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke_color(@color)
+      draw.fill_opacity(0.0)
+      draw.stroke_dasharray(10, 20)
+      draw.stroke_width(@width)
+      draw.line(start_x, start_y, end_x, end_y)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/dot.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Dot
+    def initialize(style, config)
+      @style = style
+      @color = config[:color]
+      @width = config[:width] || 1.0
+    end
+
+    def render(new_x, new_y, circle_radius)
+      draw = Renderer.instance.draw
+
+      # draw.push # TODO
+      draw.stroke_width(@width)
+      draw.stroke(@color)
+      draw.fill(@color)
+      if @style.to_s == 'square'
+        square(draw, new_x, new_y, circle_radius)
+      else
+        circle(draw, new_x, new_y, circle_radius)
+      end
+      # draw.pop # TODO
+    end
+
+    def circle(draw, new_x, new_y, circle_radius)
+      draw.circle(new_x, new_y, new_x - circle_radius, new_y)
+    end
+
+    def square(draw, new_x, new_y, circle_radius)
+      offset = (circle_radius * 0.8).to_i
+      corner1 = new_x - offset
+      corner2 = new_y - offset
+      corner3 = new_x + offset
+      corner4 = new_y + offset
+      draw.rectangle(corner1, corner2, corner3, corner4)
+    end
+  end
+end

data/lib/gruff/renderer/ellipse.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Ellipse
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width] || 1.0
+    end
+
+    def render(origin_x, origin_y, width, height, arc_start, arc_end)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke_width(@width)
+      draw.stroke(@color)
+      draw.fill('transparent')
+      draw.ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/line.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Line
+    EPSILON = 0.001
+
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width]
+    end
+
+    def render(start_x, start_y, end_x, end_y)
+      # FIXME(uwe): Workaround for Issue #66
+      #             https://github.com/topfunky/gruff/issues/66
+      #             https://github.com/rmagick/rmagick/issues/82
+      #             Remove if the issue gets fixed.
+      unless defined?(JRUBY_VERSION)
+        start_x += EPSILON
+        end_x += EPSILON
+        start_y += EPSILON
+        end_y += EPSILON
+      end
+
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke(@color)
+      draw.fill(@color)
+      draw.stroke_width(@width) if @width
+      draw.line(start_x, start_y, end_x, end_y)
+      draw.pop
+    end
+  end
+end