gruff 0.6.0-java → 0.11.0-java

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,42 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Line
+    EPSILON = 0.001
+
+    def initialize(args = {})
+      @color = args[:color]
+      @shadow_color = args[:shadow_color]
+      @width = args[:width]
+    end
+
+    def render(start_x, start_y, end_x, end_y)
+      render_line(start_x, start_y, end_x, end_y, @color)
+      render_line(start_x, start_y + 1, end_x, end_y + 1, @shadow_color) if @shadow_color
+    end
+
+  private
+
+    def render_line(start_x, start_y, end_x, end_y, color)
+      # 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,132 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Gruff
+  # @private
+  class Renderer
+    include Singleton
+
+    attr_accessor :draw, :image, :scale, :text_renderers
+
+    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
+        Renderer.instance.text_renderers = []
+      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)
+
+        Renderer.instance.text_renderers.each do |renderer|
+          renderer.render(renderer.width, renderer.height, renderer.x, renderer.y, renderer.gravity)
+        end
+      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(columns, rows, 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

data/lib/gruff/renderer/text.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Gruff
+  class Renderer::Text
+    def initialize(text, args = {})
+      @text = text.to_s
+      @font = args[:font]
+      @font_size = args[:size]
+      @font_color = args[:color]
+      @font_weight = args[:weight] || Magick::NormalWeight
+      @rotation = args[:rotation]
+    end
+
+    attr_reader :width, :height, :x, :y, :gravity
+    def add_to_render_queue(width, height, x, y, gravity = Magick::NorthGravity)
+      @width = width
+      @height = height
+      @x = x
+      @y = y
+      @gravity = gravity
+
+      Renderer.instance.text_renderers << self
+    end
+
+    def render(width, height, x, y, gravity = Magick::NorthGravity)
+      draw  = Renderer.instance.draw
+      image = Renderer.instance.image
+      scale = Renderer.instance.scale
+
+      draw.rotation = @rotation if @rotation
+      draw.fill = @font_color
+      draw.stroke = 'transparent'
+      draw.font = @font if @font
+      draw.font_weight = @font_weight
+      draw.pointsize = @font_size * scale
+      draw.gravity = gravity
+      draw.annotate_scaled(image,
+                           width, height,
+                           x, y,
+                           @text, scale)
+      draw.rotation = -@rotation if @rotation
+    end
+
+    def self.metrics(text, size, font_weight = Magick::NormalWeight)
+      draw  = Renderer.instance.draw
+      image = Renderer.instance.image
+
+      draw.font_weight = font_weight
+      draw.pointsize = size
+      draw.get_type_metrics(image, text.to_s)
+    end
+  end
+end

data/lib/gruff/scatter.rb

@@ -1,109 +1,93 @@
-require File.dirname(__FILE__) + '/base'
+# frozen_string_literal: true
 
-# Here's how to set up an XY Scatter Chart
+require 'gruff/base'
+
+#
+# Here's how to set up a Gruff::Scatter.
 #
-# g = Gruff::Scatter.new(800)
-# g.data(:apples, [1,2,3,4], [4,3,2,1])
-# g.data('oranges', [5,7,8], [4,1,7])
-# g.write('test/output/scatter.png')
-# 
+#   g = Gruff::Scatter.new(800)
+#   g.data :apples, [1,2,3,4], [4,3,2,1]
+#   g.data 'oranges', [5,7,8], [4,1,7]
+#   g.write('scatter.png')
 #
 class Gruff::Scatter < Gruff::Base
-
   # Maximum X Value. The value will get overwritten by the max in the
-  # datasets.  
-  attr_accessor :maximum_x_value
-  
-  # Minimum X Value. The value will get overwritten by the min in the 
-  # datasets.  
-  attr_accessor :minimum_x_value
-  
-  # The number of vertical lines shown for reference
-  attr_accessor :marker_x_count
-  
-  #~ # Draw a dashed horizontal line at the given y value
-  #~ attr_accessor :baseline_y_value
-	
-  #~ # Color of the horizontal baseline
-  #~ attr_accessor :baseline_y_color
-  
-  #~ # Draw a dashed horizontal line at the given y value
-  #~ attr_accessor :baseline_x_value
-	
-  #~ # Color of the horizontal baseline
-  #~ attr_accessor :baseline_x_color
-  
-  
-  # Gruff::Scatter takes the same parameters as the Gruff::Line graph
-  #
-  # ==== Example
-  #
-  # g = Gruff::Scatter.new
-  #
-  def initialize(*args)
-    super(*args)
-    
-    @maximum_x_value = @minimum_x_value = nil
-    @baseline_x_color = @baseline_y_color = 'red'
-    @baseline_x_value = @baseline_y_value = nil
-    @marker_x_count = nil
-  end
+  # datasets.
+  attr_writer :maximum_x_value
 
-  def setup_drawing
-    # TODO Need to get x-axis labels working. Current behavior will be to not allow.
-    @labels = {}
+  # Minimum X Value. The value will get overwritten by the min in the
+  # datasets.
+  attr_writer :minimum_x_value
+
+  # The number of vertical lines shown for reference.
+  attr_writer :marker_x_count
+
+  # Attributes to allow customising the size of the points.
+  attr_writer :circle_radius
+  attr_writer :stroke_width
+
+  # Allow disabling the significant rounding when labeling the X axis.
+  # This is useful when working with a small range of high values (for example, a date range of months, while seconds as units).
+  attr_writer :disable_significant_rounding_x_axis
+
+  # Allow enabling vertical lines. When you have a lot of data, they can work great.
+  attr_writer :enable_vertical_line_markers
 
+  # Allow using vertical labels in the X axis (and setting the label margin).
+  attr_writer :x_label_margin
+  attr_writer :use_vertical_x_labels
+
+  # Allow passing lambdas to format labels.
+  attr_writer :y_axis_label_format
+  attr_writer :x_axis_label_format
+
+  def initialize_store
+    @store = Gruff::Store.new(Gruff::Store::XYData)
+  end
+  private :initialize_store
+
+  def initialize_ivars
     super
 
-    # Translate our values so that we can use the base methods for drawing
-    # the standard chart stuff
-    @column_count = @x_spread
+    @baseline_x_color = @baseline_y_color = 'red'
+    @baseline_x_value = @baseline_y_value = nil
+    @circle_radius = nil
+    @disable_significant_rounding_x_axis = false
+    @enable_vertical_line_markers = false
+    @marker_x_count = nil
+    @maximum_x_value = @minimum_x_value = nil
+    @stroke_width = nil
+    @use_vertical_x_labels = false
+    @x_axis_label_format = nil
+    @x_label_margin = nil
+    @y_axis_label_format = nil
   end
+  private :initialize_ivars
 
   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
-
-    #~ if (defined?(@norm_y_baseline)) then
-      #~ level = @graph_top + (@graph_height - @norm_baseline * @graph_height)
-      #~ @d = @d.push
-      #~ @d.stroke_color @baseline_color
-      #~ @d.fill_opacity 0.0
-      #~ @d.stroke_dasharray(10, 20)
-      #~ @d.stroke_width 5
-      #~ @d.line(@graph_left, level, @graph_left + @graph_width, level)
-      #~ @d = @d.pop
-    #~ end
-
-    #~ if (defined?(@norm_x_baseline)) then
-      
-    #~ end
-
-    @norm_data.each do |data_row|      
-      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, index|
-        x_value = data_row[DATA_VALUES_X_INDEX][index]
-        next if data_point.nil? || x_value.nil? 
+    return unless data_given?
+
+    # Check to see if more than one datapoint was given. NaN can result otherwise.
+    @x_increment = (@x_spread > 1) ? (@graph_width / (@x_spread - 1).to_f) : @graph_width
+
+    store.norm_data.each do |data_row|
+      data_row.coordinates.each do |x_value, y_value|
+        next if y_value.nil? || x_value.nil?
 
         new_x = get_x_coord(x_value, @graph_width, @graph_left)
-        new_y = @graph_top + (@graph_height - data_point * @graph_height)
+        new_y = @graph_top + (@graph_height - y_value * @graph_height)
 
         # Reset each time to avoid thin-line errors
-        @d = @d.stroke data_row[DATA_COLOR_INDEX]
-        @d = @d.fill data_row[DATA_COLOR_INDEX]
-        @d = @d.stroke_opacity 1.0
-        @d = @d.stroke_width clip_value_if_greater_than(@columns / (@norm_data.first[1].size * 4), 5.0)
-
-        circle_radius = clip_value_if_greater_than(@columns / (@norm_data.first[1].size * 2.5), 5.0)
-        @d = @d.circle(new_x, new_y, new_x - circle_radius, new_y)
+        stroke_width  = @stroke_width  || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
+        circle_radius = @circle_radius || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 2.5), 5.0)
+        Gruff::Renderer::Circle.new(color: data_row.color, width: stroke_width).render(new_x, new_y, new_x - circle_radius, new_y)
       end
     end
 
-    @d.draw(@base_image)
+    Gruff::Renderer.finish
   end
-  
+
   # The first parameter is the name of the dataset.  The next two are the
   # x and y axis data points contain in their own array in that respective
   # order.  The final parameter is the color.
@@ -114,95 +98,83 @@ class Gruff::Scatter < Gruff::Base
   # If the color argument is nil, the next color from the default theme will
   # be used.
   #
-  # NOTE: If you want to use a preset theme, you must set it before calling
-  # data().
+  # @note If you want to use a preset theme, you must set it before calling {#data}.
   #
-  # ==== Parameters
-  # name:: String or Symbol containing the name of the dataset.
-  # x_data_points:: An Array of of x-axis data points. 
-  # y_data_points:: An Array of of y-axis data points. 
-  # color:: The hex string for the color of the dataset.  Defaults to nil.
+  # @param name [String, Symbol] containing the name of the dataset.
+  # @param x_data_points [Array] An Array of of x-axis data points.
+  # @param y_data_points [Array] An Array of of y-axis data points.
+  # @param color [String] The hex string for the color of the dataset. Defaults to nil.
   #
-  # ==== Exceptions
-  # Data points contain nil values::
+  #
+  # @raise [ArgumentError] Data points contain nil values.
   #   This error will get raised if either the x or y axis data points array
-  #   contains a <tt>nil</tt> value.  The graph will not make an assumption
-  #   as how to graph <tt>nil</tt>
-  # x_data_points is empty::
+  #   contains a +nil+ value.  The graph will not make an assumption
+  #   as how to graph +nil+.
+  # @raise [ArgumentError] +x_data_points+ is empty.
   #   This error is raised when the array for the x-axis points are empty
-  # y_data_points is empty::
-  #   This error is raised when the array for the y-axis points are empty
-  # x_data_points.length != y_data_points.length::
-  #   Error means that the x and y axis point arrays do not match in length
+  # @raise [ArgumentError] +y_data_points+ is empty.
+  #   This error is raised when the array for the y-axis points are empty.
+  # @raise [ArgumentError] +x_data_points.length != y_data_points.length+.
+  #   Error means that the x and y axis point arrays do not match in length.
   #
-  # ==== Examples
-  # g = Gruff::Scatter.new
-  # g.data(:apples, [1,2,3], [3,2,1])
-  # g.data('oranges', [1,1,1], [2,3,4])
-  # g.data('bitter_melon', [3,5,6], [6,7,8], '#000000')
+  # @example
+  #   g = Gruff::Scatter.new
+  #   g.data(:apples, [1,2,3], [3,2,1])
+  #   g.data('oranges', [1,1,1], [2,3,4])
+  #   g.data('bitter_melon', [3,5,6], [6,7,8], '#000000')
   #
-  def data(name, x_data_points=[], y_data_points=[], color=nil)
-    
+  def data(name, x_data_points = [], y_data_points = [], color = nil)
+    # make sure it's an array
+    x_data_points = Array(x_data_points)
+    y_data_points = Array(y_data_points)
+
     raise ArgumentError, 'Data Points contain nil Value!' if x_data_points.include?(nil) || y_data_points.include?(nil)
     raise ArgumentError, 'x_data_points is empty!' if x_data_points.empty?
     raise ArgumentError, 'y_data_points is empty!' if y_data_points.empty?
     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 axis data
-    super(name, y_data_points, color)
-    
-    #append the x data to the last entry that was just added in the @data member
-    last_elem = @data.length()-1
-    @data[last_elem] << x_data_points
-    
-    if @maximum_x_value.nil? && @minimum_x_value.nil?
-      @maximum_x_value = @minimum_x_value = x_data_points.first
-    end
-    
-    @maximum_x_value = x_data_points.max > @maximum_x_value ?
-                        x_data_points.max : @maximum_x_value
-    @minimum_x_value = x_data_points.min < @minimum_x_value ?
-                        x_data_points.min : @minimum_x_value
+
+    # Call the existing data routine for the x/y axis data
+    store.add(name, y_data_points, color, x_data_points)
   end
-  
-protected
-  
+
+  alias dataxy data
+
+private
+
+  def setup_data
+    # Update the global min/max values for the x data
+    @maximum_x_value ||= store.max_x
+    @minimum_x_value ||= store.min_x
+
+    super
+  end
+
+  def setup_drawing
+    # TODO: Need to get x-axis labels working. Current behavior will be to not allow.
+    @labels = {}
+
+    super
+  end
+
   def calculate_spread #:nodoc:
     super
     @x_spread = @maximum_x_value.to_f - @minimum_x_value.to_f
     @x_spread = @x_spread > 0 ? @x_spread : 1
   end
-  
-  def normalize(force=@xy_normalize)
-    if @norm_data.nil? || force 
-      @norm_data = []
-      return unless @has_data
-      
-      @data.each do |data_row|
-        norm_data_points = [data_row[DATA_LABEL_INDEX]]
-        norm_data_points << data_row[DATA_VALUES_INDEX].map do |r|  
-                                (r.to_f - @minimum_value.to_f) / @spread
-                            end
-        norm_data_points << data_row[DATA_COLOR_INDEX]
-        norm_data_points << data_row[DATA_VALUES_X_INDEX].map do |r|  
-                                (r.to_f - @minimum_x_value.to_f) / @x_spread 
-                            end
-        @norm_data << norm_data_points
-      end
-    end
-    #~ @norm_y_baseline = (@baseline_y_value.to_f / @maximum_value.to_f) if @baseline_y_value
-    #~ @norm_x_baseline = (@baseline_x_value.to_f / @maximum_x_value.to_f) if @baseline_x_value
+
+  def normalize
+    return unless data_given?
+
+    store.normalize(minimum_x: @minimum_x_value, spread_x: @x_spread, minimum_y: minimum_value, spread_y: @spread)
   end
-  
+
   def draw_line_markers
     # do all of the stuff for the horizontal lines on the y-axis
     super
     return if @hide_line_markers
-    
-    @d = @d.stroke_antialias false
 
     if @x_axis_increment.nil?
-      # TODO Do the same for larger numbers...100, 75, 50, 25
+      # TODO: Do the same for larger numbers...100, 75, 50, 25
       if @marker_x_count.nil?
         (3..7).each do |lines|
           if @x_spread % lines == 0.0
@@ -212,53 +184,62 @@ protected
         end
         @marker_x_count ||= 4
       end
-      @x_increment = (@x_spread > 0) ? significant(@x_spread / @marker_x_count) : 1
+      @x_increment = (@x_spread > 0) ? (@x_spread / @marker_x_count) : 1
+      unless @disable_significant_rounding_x_axis
+        @x_increment = significant(@x_increment)
+      end
     else
-      # TODO Make this work for negative values
-      @maximum_x_value = [@maximum_value.ceil, @x_axis_increment].max
+      # TODO: Make this work for negative values
+      @maximum_x_value = [maximum_value.ceil, @x_axis_increment].max
       @minimum_x_value = @minimum_x_value.floor
       calculate_spread
-      normalize(true)
-      
+      normalize
+
       @marker_count = (@x_spread / @x_axis_increment).to_i
       @x_increment = @x_axis_increment
     end
-    @increment_x_scaled = @graph_width.to_f / (@x_spread / @x_increment)
+    increment_x_scaled = @graph_width.to_f / (@x_spread / @x_increment)
 
     # Draw vertical line markers and annotate with numbers
     (0..@marker_x_count).each do |index|
+      # TODO: Fix the vertical lines, and enable them by default. Not pretty when they don't match up with top y-axis line
+      if @enable_vertical_line_markers
+        x = @graph_left + @graph_width - index.to_f * increment_x_scaled
 
-      # TODO Fix the vertical lines.  Not pretty when they don't match up with top y-axis line
-      # x = @graph_left + @graph_width - index.to_f * @increment_x_scaled
-      # @d = @d.stroke(@marker_color)
-      # @d = @d.stroke_width 1
-      # @d = @d.line(x, @graph_top, x, @graph_bottom)
+        line_renderer = Gruff::Renderer::Line.new(color: @marker_color, shadow_color: @marker_shadow_color)
+        line_renderer.render(x, @graph_top, x, @graph_bottom)
+      end
 
       unless @hide_line_numbers
         marker_label = index * @x_increment + @minimum_x_value.to_f
-        y_offset = @graph_bottom + LABEL_MARGIN 
-        x_offset = get_x_coord(index.to_f, @increment_x_scaled, @graph_left)
-
-        @d.fill = @font_color
-        @d.font = @font if @font
-        @d.stroke('transparent')
-        @d.pointsize = scale_fontsize(@marker_font_size)
-        @d.gravity = NorthGravity
-        
-        @d = @d.annotate_scaled(@base_image, 
-                          1.0, 1.0, 
-                          x_offset, y_offset, 
-                          label(marker_label, @x_increment), @scale)
+        y_offset = @graph_bottom + (@x_label_margin || LABEL_MARGIN)
+        x_offset = get_x_coord(index.to_f, increment_x_scaled, @graph_left)
+
+        label = vertical_label(marker_label, @x_increment)
+        rotation = -90.0 if @use_vertical_x_labels
+        text_renderer = Gruff::Renderer::Text.new(label, font: @font, size: @marker_font_size, color: @font_color, rotation: rotation)
+        text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset)
       end
     end
-    
-    @d = @d.stroke_antialias true
   end
-  
-private
-  
+
+  def label(value, increment)
+    if @y_axis_label_format
+      @y_axis_label_format.call(value)
+    else
+      super
+    end
+  end
+
+  def vertical_label(value, increment)
+    if @x_axis_label_format
+      @x_axis_label_format.call(value)
+    else
+      label(value, increment)
+    end
+  end
+
   def get_x_coord(x_data_point, width, offset) #:nodoc:
     x_data_point * width + offset
   end
-  
-end # end Gruff::Scatter
+end