gruff 0.8.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,31 +12,32 @@ 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
-
   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.
+  # 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
+  # Defaults to +0+.
   attr_writer :hide_labels_less_than
 
-  # Affect the distance between the percentages and the pie chart
-  # Defaults to 0.15
+  # Affect the distance between the percentages and the pie chart.
+  # Defaults to +0.15+.
   attr_writer :text_offset_percentage
 
-  ## Use values instead of percentages
+  ## Use values instead of percentages.
   attr_accessor :show_values_as_labels
 
   def initialize_ivars
     super
 
     @show_values_as_labels = false
+
+    @store = Gruff::Store.new(Gruff::Store::CustomData)
   end
+  private :initialize_ivars
 
   def zero_degree
     @zero_degree ||= 0.0
@@ -66,23 +69,21 @@ class Gruff::Pie < Gruff::Base
 
     slices.each do |slice|
       if slice.value > 0
-        set_stroke_color slice
-        set_fill_color
-        set_stroke_width
-        set_drawing_points_for slice
+        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
 
-    trigger_final_draw
+    Gruff::Renderer.finish
   end
 
 private
 
   def slices
     @slices ||= begin
-      slices = @data.map { |data| slice_class.new(data, options) }
+      slices = store.data.map { |data| slice_class.new(data, options) }
 
       slices.sort_by(&:value) if @sort
 
@@ -97,10 +98,6 @@ private
     @hide_line_markers = true
   end
 
-  def data_given?
-    @has_data
-  end
-
   def update_chart_degrees_with(degrees)
     @chart_degrees = chart_degrees + degrees
   end
@@ -115,13 +112,9 @@ private
     @chart_degrees ||= zero_degree
   end
 
-  def graph_height
-    @graph_height
-  end
+  attr_reader :graph_height
 
-  def graph_width
-    @graph_width
-  end
+  attr_reader :graph_width
 
   def diameter
     graph_height
@@ -165,7 +158,7 @@ private
     if slice.percentage >= hide_labels_less_than
       x, y = label_coordinates_for slice
 
-      @d = draw_label(x, y, slice.label)
+      draw_label(x, y, slice.label)
     end
   end
 
@@ -185,58 +178,14 @@ private
 
   # Drawing-Related Methods
 
-  def set_stroke_width
-    @d.stroke_width(radius)
-  end
-
-  def set_stroke_color(slice)
-    @d = @d.stroke slice.color
-  end
-
-  def set_fill_color
-    @d = @d.fill 'transparent'
-  end
-
-  def set_drawing_points_for(slice)
-    @d = @d.ellipse(
-      center_x,
-      center_y,
-      radius / 2.0,
-      radius / 2.0,
-      chart_degrees,
-      chart_degrees + slice.degrees + 0.5
-    )
-  end
-
-  def trigger_final_draw
-    @d.draw(@base_image)
-  end
-
-  def configure_label_styling
-    @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
-  end
-
   def draw_label(x, y, value)
-    configure_label_styling
-
-    @d.annotate_scaled(
-      @base_image,
-      0,
-      0,
-      x,
-      y,
-      value,
-      @scale
-    )
+    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
 

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

data/lib/gruff/renderer/polygon.rb

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

data/lib/gruff/renderer/polyline.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Polyline
+    def initialize(args = {})
+      @color = args[:color]
+      @width = args[:width]
+    end
+
+    def render(points)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke(@color)
+      draw.fill('transparent')
+      draw.stroke_width(@width)
+      draw.polyline(*points)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/rectangle.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Rectangle
+    def initialize(args = {})
+      @color = args[:color]
+    end
+
+    def render(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
+      draw = Renderer.instance.draw
+
+      draw.push
+      draw.stroke('transparent')
+      draw.fill(@color) if @color
+      draw.rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
+      draw.pop
+    end
+  end
+end

data/lib/gruff/renderer/renderer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Gruff
+  # @private
+  class Renderer
+    include Singleton
+
+    attr_accessor :draw, :image, :scale
+
+    class << self
+      def setup(columns, rows, font, scale, theme_options)
+        draw = Magick::Draw.new
+        draw.font = font if font
+        # Scale down from 800x600 used to calculate drawing.
+        draw.scale(scale, scale)
+
+        image = Renderer.instance.background(columns, rows, scale, theme_options)
+
+        Renderer.instance.draw  = draw
+        Renderer.instance.scale = scale
+        Renderer.instance.image = image
+      end
+
+      def setup_transparent_background(columns, rows)
+        image = Renderer.instance.render_transparent_background(columns, rows)
+        Renderer.instance.image = image
+      end
+
+      def background_image=(image)
+        Renderer.instance.image = image
+      end
+
+      def font=(font)
+        draw = Renderer.instance.draw
+        draw.font = font if font
+      end
+
+      def finish
+        draw  = Renderer.instance.draw
+        image = Renderer.instance.image
+
+        draw.draw(image)
+      end
+
+      def write(file_name)
+        Renderer.instance.image.write(file_name)
+      end
+
+      def to_blob(file_format)
+        Renderer.instance.image.to_blob do
+          self.format = file_format
+        end
+      end
+    end
+
+    def background(columns, rows, scale, theme_options)
+      case theme_options[:background_colors]
+      when Array
+        gradated_background(columns, rows, theme_options[:background_colors][0], theme_options[:background_colors][1], theme_options[:background_direction])
+      when String
+        solid_background(columns, rows, theme_options[:background_colors])
+      else
+        image_background(scale, *theme_options[:background_image])
+      end
+    end
+
+    # Make a new image at the current size with a solid +color+.
+    def solid_background(columns, rows, color)
+      Magick::Image.new(columns, rows) do
+        self.background_color = color
+      end
+    end
+
+    # Use with a theme definition method to draw a gradated background.
+    def gradated_background(columns, rows, top_color, bottom_color, direct = :top_bottom)
+      gradient_fill = begin
+        case direct
+        when :bottom_top
+          Magick::GradientFill.new(0, 0, 100, 0, bottom_color, top_color)
+        when :left_right
+          Magick::GradientFill.new(0, 0, 0, 100, top_color, bottom_color)
+        when :right_left
+          Magick::GradientFill.new(0, 0, 0, 100, bottom_color, top_color)
+        when :topleft_bottomright
+          Magick::GradientFill.new(0, 100, 100, 0, top_color, bottom_color)
+        when :topright_bottomleft
+          Magick::GradientFill.new(0, 0, 100, 100, bottom_color, top_color)
+        else
+          Magick::GradientFill.new(0, 0, 100, 0, top_color, bottom_color)
+        end
+      end
+
+      image = Magick::Image.new(columns, rows, gradient_fill)
+      @gradated_background_retry_count = 0
+
+      image
+    rescue StandardError => e
+      @gradated_background_retry_count ||= 0
+      GC.start
+
+      if @gradated_background_retry_count < 3
+        @gradated_background_retry_count += 1
+        gradated_background(top_color, bottom_color, direct)
+      else
+        raise e
+      end
+    end
+
+    # Use with a theme to use an image (800x600 original) background.
+    def image_background(scale, image_path)
+      image = Magick::Image.read(image_path)
+      if scale != 1.0
+        image[0].resize!(scale) # TODO: Resize with new scale (crop if necessary for wide graph)
+      end
+      image[0]
+    end
+
+    # Use with a theme to make a transparent background
+    def render_transparent_background(columns, rows)
+      Magick::Image.new(columns, rows) do
+        self.background_color = 'transparent'
+      end
+    end
+  end
+end