gruff 0.14.0-java → 0.17.0-java

data/lib/gruff/scatter.rb

@@ -114,16 +114,35 @@ private
     @x_label_margin = nil
   end
 
-  def draw_graph
-    # 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
+  def setup_drawing
+    @center_labels_over_point = false
+    super
+  end
+
+  def setup_data
+    # TODO: Need to get x-axis labels working. Current behavior will be to not allow.
+    @labels = {}
+
+    # Update the global min/max values for the x data
+    @maximum_x_value = (@maximum_x_value || store.max_x).to_f
+    @minimum_x_value = (@minimum_x_value || store.min_x).to_f
+
+    if @x_axis_increment
+      # TODO: Make this work for negative values
+      @maximum_x_value = [@maximum_x_value.ceil, @x_axis_increment.to_f].max
+      @minimum_x_value = @minimum_x_value.floor
+    end
 
+    super
+  end
+
+  def draw_graph
     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 - y_value * @graph_height)
+        new_y = @graph_top + (@graph_height - (y_value * @graph_height))
 
         # Reset each time to avoid thin-line errors
         stroke_width  = @stroke_width  || clip_value_if_greater_than(@columns / (store.norm_data.first[1].size * 4), 5.0)
@@ -133,22 +152,7 @@ private
     end
   end
 
-  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:
+  def calculate_spread
     super
     @x_spread = @maximum_x_value.to_f - @minimum_x_value.to_f
     @x_spread = @x_spread > 0 ? @x_spread : 1
@@ -165,49 +169,21 @@ private
     super
     return if @hide_line_markers
 
-    if @x_axis_increment.nil?
-      # 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
-            @marker_x_count = lines
-            break
-          end
-        end
-        @marker_x_count ||= 4
-      end
-      @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_x_value.ceil, @x_axis_increment].max
-      @minimum_x_value = @minimum_x_value.floor
-      calculate_spread
-      normalize
-
-      @marker_x_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 / (@x_spread / x_increment)
 
     # Draw vertical line markers and annotate with numbers
-    (0..@marker_x_count).each do |index|
+    (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 @show_vertical_markers
-        x = @graph_left + @graph_width - index.to_f * increment_x_scaled
-
-        line_renderer = Gruff::Renderer::Line.new(renderer, color: @marker_color, shadow_color: @marker_shadow_color)
-        line_renderer.render(x, @graph_top, x, @graph_bottom)
+        draw_marker_vertical_line(@graph_left + @graph_width - (index * increment_x_scaled))
       end
 
       unless @hide_line_numbers
-        marker_label = BigDecimal(index.to_s) * BigDecimal(@x_increment.to_s) + BigDecimal(@minimum_x_value.to_s)
+        marker_label = (BigDecimal(index.to_s) * BigDecimal(x_increment.to_s)) + BigDecimal(@minimum_x_value.to_s)
         y_offset = @graph_bottom + (@x_label_margin || LABEL_MARGIN)
-        x_offset = get_x_coord(index.to_f, increment_x_scaled, @graph_left)
+        x_offset = get_x_coord(index, increment_x_scaled, @graph_left)
 
-        label = x_axis_label(marker_label, @x_increment)
+        label = x_axis_label(marker_label, x_increment)
         rotation = -90.0 if @use_vertical_x_labels
         text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font, rotation: rotation)
         text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset)
@@ -215,7 +191,39 @@ private
     end
   end
 
-  def get_x_coord(x_data_point, width, offset) #:nodoc:
-    x_data_point * width + offset
+  def get_x_coord(x_data_point, width, offset)
+    (x_data_point * width) + offset
+  end
+
+  def marker_x_count
+    # TODO: Do the same for larger numbers...100, 75, 50, 25
+    @marker_x_count ||= begin
+      if @x_axis_increment.nil?
+        count = nil
+        (3..7).each do |lines|
+          if @x_spread % lines == 0.0
+            count = lines and break
+          end
+        end
+        count || 4
+      else
+        (@x_spread / @x_axis_increment).to_i
+      end
+    end
+  end
+
+  def x_increment
+    @x_increment ||= begin
+      if @x_axis_increment.nil?
+        increment = @x_spread > 0 ? (@x_spread / marker_x_count) : 1
+        unless @disable_significant_rounding_x_axis
+          increment = significant(increment)
+        end
+      else
+        increment = @x_axis_increment
+      end
+
+      increment
+    end
   end
 end

data/lib/gruff/side_bar.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'helper/bar_mixin'
+
 # Graph with individual horizontal bars instead of vertical bars.
 #
 # Here's how to set up a Gruff::SideBar.
@@ -19,6 +21,8 @@
 #   g.write('sidebar.png')
 #
 class Gruff::SideBar < Gruff::Base
+  include BarMixin
+
   # Spacing factor applied between bars.
   attr_writer :bar_spacing
 
@@ -36,6 +40,15 @@ class Gruff::SideBar < Gruff::Base
   # Prevent drawing of column labels left of a side bar graph.  Default is +false+.
   attr_writer :hide_labels
 
+  # Value to avoid completely overwriting the coordinate axis
+  AXIS_MARGIN = 0.5
+  private_constant :AXIS_MARGIN
+
+  def initialize(*)
+    super
+    @has_left_labels = true
+  end
+
   # With Side Bars use the data label for the marker value to the left of the bar.
   # @deprecated
   def use_data_label=(_value)
@@ -51,7 +64,6 @@ private
     @label_formatting = nil
     @show_labels_for_bar_values = false
     @hide_labels = false
-    @has_left_labels = true
   end
 
   def hide_labels?
@@ -59,20 +71,37 @@ private
   end
 
   def hide_left_label_area?
-    hide_labels?
+    hide_labels? && @y_axis_label.nil?
   end
 
   def hide_bottom_label_area?
-    @hide_line_markers
+    @hide_line_markers && @x_axis_label.nil? && @legend_at_bottom == false
   end
 
-  # Value to avoid completely overwriting the coordinate axis
-  AXIS_MARGIN = 0.5
+  def setup_graph_measurements
+    super
+    return if @hide_line_markers
+
+    if @show_labels_for_bar_values
+      if maximum_value >= 0
+        _, metrics = Gruff::BarValueLabel.metrics(maximum_value, @label_formatting, proc_text_metrics)
+        @graph_right -= metrics.width
+      end
+
+      if minimum_value < 0
+        _, metrics = Gruff::BarValueLabel.metrics(minimum_value, @label_formatting, proc_text_metrics)
+        width = metrics.width + LABEL_MARGIN
+        @graph_left += width - @graph_left if width > @graph_left
+      end
+
+      @graph_width = @graph_right - @graph_left
+    end
+  end
 
   def draw_graph
     # Setup spacing.
     #
-    bars_width = (@graph_height - calculate_spacing) / column_count.to_f
+    bars_width = (@graph_height - calculate_spacing) / column_count
     bar_width = bars_width / store.length
     padding = (bar_width * (1 - @bar_spacing)) / 2
 
@@ -82,30 +111,33 @@ private
       minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
     )
 
-    store.norm_data.each_with_index do |data_row, row_index|
-      data_row.points.each_with_index do |data_point, point_index|
-        group_spacing = @group_spacing * @scale * point_index
-
-        left_y = @graph_top + (bars_width * point_index) + (bar_width * row_index) + padding + group_spacing
-        right_y = left_y + bar_width * @bar_spacing
+    group_spacing = @group_spacing * @scale
+    group_left_y = @graph_top
 
-        left_x, right_x = conversion.get_top_bottom_scaled(data_point).sort
+    normalized_group_bars.each_with_index do |group_bars, group_index|
+      right_y = 0
+      group_bars.each_with_index do |bar, index|
+        left_y = group_left_y + (bar_width * index) + padding
+        right_y = left_y + (bar_width * @bar_spacing)
 
-        rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: data_row.color)
-        rect_renderer.render(left_x + AXIS_MARGIN, left_y, right_x + AXIS_MARGIN, right_y)
-
-        # Calculate center based on bar_width and current row
-        label_center = left_y + bars_width / 2
+        bottom_x, top_x = conversion.get_top_bottom_scaled(bar.point).sort
+        if bar.point != 0
+          rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: bar.color)
+          rect_renderer.render(bottom_x + AXIS_MARGIN, left_y, top_x, right_y)
+        end
 
-        # Subtract half a bar width to center left if requested
-        draw_label(label_center, point_index)
-        if @show_labels_for_bar_values
-          bar_value_label = Gruff::BarValueLabel::SideBar.new([left_x, left_y, right_x, right_y], store.data[row_index].points[point_index])
-          bar_value_label.prepare_rendering(@label_formatting, bar_width) do |x, y, text|
-            draw_value_label(x, y, text)
+        if @show_labels_for_bar_values && bar.value
+          bar_value_label = Gruff::BarValueLabel::SideBar.new([bottom_x, left_y, top_x, right_y], bar.value)
+          bar_value_label.prepare_rendering(@label_formatting, proc_text_metrics) do |x, y, text, text_width, _text_height|
+            draw_value_label(text_width, bar_width * @bar_spacing, x, y, text)
           end
         end
       end
+
+      label_center = group_left_y + (bars_width / 2.0)
+      draw_label(label_center, group_index)
+
+      group_left_y = right_y + padding + group_spacing
     end
   end
 
@@ -118,17 +150,15 @@ private
     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)
+    increment = significant(@spread / 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
-
-      line_renderer = Gruff::Renderer::Line.new(renderer, color: @marker_color, shadow_color: @marker_shadow_color)
-      line_renderer.render(x, @graph_bottom, x, @graph_top)
+      draw_marker_vertical_line(x)
 
       unless @hide_line_numbers
         diff = index - number_of_lines
-        marker_label = BigDecimal(diff.abs.to_s) * BigDecimal(increment.to_s) + BigDecimal(minimum_value.to_s)
+        marker_label = (BigDecimal(diff.abs.to_s) * BigDecimal(increment.to_s)) + BigDecimal(minimum_value.to_s)
         label = x_axis_label(marker_label, @increment)
         text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font)
         text_renderer.add_to_render_queue(0, 0, x, @graph_bottom + LABEL_MARGIN, Magick::CenterGravity)
@@ -141,11 +171,15 @@ private
 
   def draw_label(y_offset, index)
     draw_unique_label(index) do
-      draw_label_at(@graph_left - LABEL_MARGIN, 1.0, 0.0, y_offset, @labels[index], Magick::EastGravity)
+      draw_label_at(@graph_left - LABEL_MARGIN, 1.0, 0.0, y_offset, @labels[index], gravity: Magick::EastGravity)
     end
   end
 
   def calculate_spacing
     @scale * @group_spacing * (column_count - 1)
   end
+
+  def proc_text_metrics
+    ->(text) { text_metrics(@marker_font, text) }
+  end
 end

data/lib/gruff/side_stacked_bar.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'helper/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)
@@ -39,6 +41,11 @@ class Gruff::SideStackedBar < Gruff::SideBar
   # Prevent drawing of column labels left of a side stacked bar graph.  Default is +false+.
   attr_writer :hide_labels
 
+  def initialize(*)
+    super
+    @has_left_labels = true
+  end
+
 private
 
   def initialize_attributes
@@ -48,7 +55,7 @@ private
     @label_formatting = nil
     @show_labels_for_bar_values = false
     @hide_labels = false
-    @has_left_labels = true
+    @minimum_value = 0.0
   end
 
   def setup_data
@@ -56,66 +63,48 @@ private
     super
   end
 
-  def hide_labels?
-    @hide_labels
-  end
-
-  def hide_left_label_area?
-    hide_labels?
-  end
-
-  def hide_bottom_label_area?
-    @hide_line_markers
-  end
-
   def draw_graph
     # Setup spacing.
     #
     # Columns sit stacked.
-    bar_width = @graph_height / column_count.to_f
-    height = Array.new(column_count, 0)
-    length = Array.new(column_count, @graph_left)
+    bar_width = @graph_height / column_count
     padding = (bar_width * (1 - @bar_spacing)) / 2
-    stack_bar_value_label = Gruff::BarValueLabel::StackedBar.new
-
-    store.norm_data.each_with_index do |data_row, row_index|
-      data_row.points.each_with_index do |data_point, point_index|
-        ## using the original calculations 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
-
-        left_x = length[point_index]
-        left_y = @graph_top + (bar_width * point_index) + padding
-        right_x = left_x + difference - @segment_spacing
-        right_y = left_y + bar_width * @bar_spacing
-        length[point_index] += difference
-        height[point_index] += (data_point * @graph_width - 2)
-
-        bar_value_label = Gruff::BarValueLabel::SideBar.new([left_x, left_y, right_x, right_y], store.data[row_index].points[point_index])
-        stack_bar_value_label.add(bar_value_label, point_index)
-
-        # 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
-          rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: data_row.color)
-          rect_renderer.render(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 = left_y + bar_width / 2
-        draw_label(label_center, point_index)
+
+    # Setup the BarConversion Object
+    conversion = Gruff::BarConversion.new(
+      top: @graph_right, bottom: @graph_left,
+      minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
+    )
+
+    proc_text_metrics = ->(text) { text_metrics(@marker_font, text) }
+
+    normalized_stacked_bars.each_with_index do |stacked_bars, stacked_index|
+      total = 0
+      left_y = @graph_top + (bar_width * stacked_index) + padding
+      right_y = left_y + (bar_width * @bar_spacing)
+
+      top_x = 0
+      stacked_bars.each do |bar|
+        next if bar.point == 0
+
+        bottom_x, = conversion.get_top_bottom_scaled(total)
+        bottom_x += @segment_spacing
+        top_x, = conversion.get_top_bottom_scaled(total + bar.point)
+
+        rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: bar.color)
+        rect_renderer.render(bottom_x, left_y, top_x, right_y)
+
+        total += bar.point
       end
-    end
 
-    if @show_labels_for_bar_values
-      stack_bar_value_label.prepare_rendering(@label_formatting, bar_width) do |x, y, text|
-        draw_value_label(x, y, text)
+      label_center = left_y + (bar_width / 2.0)
+      draw_label(label_center, stacked_index)
+
+      if @show_labels_for_bar_values
+        bar_value_label = Gruff::BarValueLabel::SideBar.new([@graph_left, left_y, top_x, right_y], stacked_bars.sum(&:value))
+        bar_value_label.prepare_rendering(@label_formatting, proc_text_metrics) do |x, y, text, text_width, _text_height|
+          draw_value_label(text_width, bar_width * @bar_spacing, x, y, text)
+        end
       end
     end
   end

data/lib/gruff/spider.rb

@@ -19,6 +19,11 @@ class Gruff::Spider < Gruff::Base
   attr_writer :hide_axes
   attr_writer :rotation
 
+  def initialize(max_value, target_width = 800)
+    super(target_width)
+    @max_value = max_value
+  end
+
   def transparent_background=(value)
     renderer.transparent_background(@columns, @rows) if value
   end
@@ -27,11 +32,6 @@ class Gruff::Spider < Gruff::Base
     @hide_title = @hide_text = value
   end
 
-  def initialize(max_value, target_width = 800)
-    super(target_width)
-    @max_value = max_value
-  end
-
 private
 
   def initialize_attributes
@@ -46,6 +46,29 @@ private
     @hide_line_markers.freeze
   end
 
+  def setup_drawing
+    @center_labels_over_point = false
+    super
+  end
+
+  def setup_graph_measurements
+    super
+
+    @graph_left += LABEL_MARGIN
+    @graph_top += LABEL_MARGIN
+    @graph_right -= LABEL_MARGIN
+    @graph_bottom -= LABEL_MARGIN
+
+    @graph_width = @graph_right - @graph_left
+    @graph_height = @graph_bottom - @graph_top
+  end
+
+  def setup_data
+    raise(Gruff::IncorrectNumberOfDatasetsException, 'Requires 3 or more data sets') if store.length < 3
+
+    super
+  end
+
   def draw_graph
     # Setup basic positioning
     radius = @graph_height / 2.0
@@ -64,23 +87,38 @@ private
   end
 
   def normalize_points(value)
-    value * @unit_length
+    value.to_f * @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
+    degree = rad2deg(angle)
+    metrics = text_metrics(@marker_font, amount)
+
+    r_offset = LABEL_MARGIN # The distance out from the center of the pie to get point
+    x_offset = center_x # The label points need to be tweaked slightly
+
+    x_offset -= begin
+      case degree
+      when 0..45, 315..360
+        0
+      when 135..225
+        metrics.width
+      else
+        metrics.width / 2
+      end
+    end
+
+    y_offset = center_y - (metrics.height / 2.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_at(1.0, 1.0, x, y, amount, Magick::CenterGravity)
+    draw_label_at(metrics.width, metrics.height, x, y, amount, gravity: Magick::CenterGravity)
   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
+    current_angle = deg2rad(@rotation)
 
     store.data.each do |data_row|
       x_offset = radius * Math.cos(current_angle)
@@ -97,18 +135,14 @@ private
 
   def draw_polygon(center_x, center_y, additive_angle, color = nil)
     points = []
-    current_angle = @rotation * Math::PI / 180.0
+    current_angle = deg2rad(@rotation)
 
     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)
+      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
 
     Gruff::Renderer::Polygon.new(renderer, color: color || @marker_color, opacity: 0.4).render(points)
   end
-
-  def sums_for_spider
-    store.data.sum { |data_row| data_row.points.first }
-  end
 end

data/lib/gruff/stacked_area.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'helper/stacked_mixin'
+
 #
 # Here's how to set up a Gruff::StackedArea.
 #
@@ -20,25 +22,31 @@ class Gruff::StackedArea < Gruff::Base
 
 private
 
+  def initialize_attributes
+    super
+    @minimum_value = 0.0
+  end
+
   def setup_data
     calculate_maximum_by_stack
     super
   end
 
   def draw_graph
-    x_increment = @graph_width / (column_count - 1).to_f
+    x_increment = @graph_width / (column_count - 1)
 
     height = Array.new(column_count, 0)
 
-    data_points = nil
+    prev_data_points = nil
     store.norm_data.each do |data_row|
-      prev_data_points = data_points
+      next if data_row.points.empty?
+
       data_points = []
 
       data_row.points.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])
+        new_y = @graph_top + (@graph_height - (data_point * @graph_height) - height[index])
 
         height[index] += (data_point * @graph_height)
 
@@ -50,20 +58,22 @@ private
 
       poly_points = data_points.dup
       if prev_data_points
-        (prev_data_points.length / 2 - 1).downto(0) do |i|
+        ((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]
+          poly_points << prev_data_points[(2 * i) + 1]
         end
       else
         poly_points << @graph_right
-        poly_points << @graph_bottom - 1
+        poly_points << (@graph_bottom - 1)
         poly_points << @graph_left
-        poly_points << @graph_bottom - 1
+        poly_points << (@graph_bottom - 1)
       end
       poly_points << data_points[0]
       poly_points << data_points[1]
 
       Gruff::Renderer::Polygon.new(renderer, color: data_row.color).render(poly_points)
+
+      prev_data_points = data_points
     end
   end
 end