gruff 0.15.0-java → 0.16.0-java

data/lib/gruff/base.rb

@@ -54,20 +54,18 @@ module Gruff
     #   { 0 => 2005, 3 => 2006, 5 => 2007, 7 => 2008 }
     attr_writer :labels
 
-    # Used internally for spacing.
-    #
-    # By default, labels are centered over the point they represent.
-    attr_writer :center_labels_over_point
-
-    # Used internally for horizontal graph types. Default is +false+.
-    attr_writer :has_left_labels
-
     # Set a label for the bottom of the graph.
     attr_writer :x_axis_label
 
     # Set a label for the left side of the graph.
     attr_writer :y_axis_label
 
+    # Allow passing lambda to format labels for x axis.
+    attr_writer :x_axis_label_format
+
+    # Allow passing lambda to format labels for y axis.
+    attr_writer :y_axis_label_format
+
     # Set increment of the vertical marking lines.
     attr_writer :x_axis_increment
 
@@ -135,12 +133,6 @@ module Gruff
     # Will be scaled down if graph is smaller than 800px wide.
     attr_writer :legend_box_size
 
-    # Allow passing lambdas to format labels for x axis.
-    attr_writer :x_axis_label_format
-
-    # Allow passing lambdas to format labels for y axis.
-    attr_writer :y_axis_label_format
-
     # If one numerical argument is given, the graph is drawn at 4/3 ratio
     # according to the given width (+800+ results in 800x600, +400+ gives 400x300,
     # etc.).
@@ -159,6 +151,9 @@ module Gruff
       @columns.freeze
       @rows.freeze
 
+      @has_left_labels = false
+      @center_labels_over_point = true
+
       initialize_graph_scale
       initialize_attributes
       initialize_store
@@ -209,8 +204,6 @@ module Gruff
       @no_data_message = 'No Data'
 
       @hide_line_markers = @hide_legend = @hide_title = @hide_line_numbers = @legend_at_bottom = false
-      @center_labels_over_point = true
-      @has_left_labels = false
       @label_stagger_height = 0
       @label_max_size = 0
       @label_truncation_style = :absolute
@@ -429,7 +422,7 @@ module Gruff
     #
     # Set it after you have given all your data to the graph object.
     def minimum_value
-      @minimum_value || store.min
+      (@minimum_value || store.min).to_f
     end
     attr_writer :minimum_value
 
@@ -439,7 +432,7 @@ module Gruff
     # If you use this, you must set it after you have given all your data to
     # the graph object.
     def maximum_value
-      @maximum_value || store.max
+      (@maximum_value || store.max).to_f
     end
     attr_writer :maximum_value
 
@@ -512,8 +505,8 @@ module Gruff
     # Perform data manipulation before calculating chart measurements
     def setup_data # :nodoc:
       if @y_axis_increment && !@hide_line_markers
-        self.maximum_value = [@y_axis_increment, maximum_value, (maximum_value.to_f / @y_axis_increment).round * @y_axis_increment].max
-        self.minimum_value = [minimum_value, (minimum_value.to_f / @y_axis_increment).round * @y_axis_increment].min
+        self.maximum_value = [@y_axis_increment, maximum_value, (maximum_value / @y_axis_increment).round * @y_axis_increment].max
+        self.minimum_value = [minimum_value, (minimum_value / @y_axis_increment).round * @y_axis_increment].min
       end
     end
 
@@ -552,7 +545,7 @@ module Gruff
       @marker_count ||= begin
         count = nil
         (3..7).each do |lines|
-          if @spread.to_f % lines == 0.0
+          if @spread % lines == 0.0
             count = lines and break
           end
         end
@@ -565,8 +558,8 @@ module Gruff
       store.normalize(minimum: minimum_value, spread: @spread)
     end
 
-    def calculate_spread # :nodoc:
-      @spread = maximum_value.to_f - minimum_value.to_f
+    def calculate_spread
+      @spread = maximum_value - minimum_value
       @spread = @spread > 0 ? @spread : 1
     end
 
@@ -579,28 +572,24 @@ module Gruff
     end
 
     def hide_left_label_area?
-      @hide_line_markers
+      @hide_line_markers && @y_axis_label.nil?
     end
 
     def hide_bottom_label_area?
-      @hide_line_markers
+      @hide_line_markers && @x_axis_label.nil?
     end
 
     ##
     # Calculates size of drawable area, general font dimensions, etc.
 
     def setup_graph_measurements
-      @marker_caps_height = setup_marker_caps_height
-      @title_caps_height = setup_title_caps_height
-      @legend_caps_height = setup_legend_caps_height
-
       margin_on_right = graph_right_margin
       @graph_right = @raw_columns - margin_on_right
       @graph_left = setup_left_margin
       @graph_top = setup_top_margin
       @graph_bottom = setup_bottom_margin
 
-      @graph_width = @raw_columns - @graph_left - margin_on_right
+      @graph_width = @graph_right - @graph_left
       @graph_height = @graph_bottom - @graph_top
     end
 
@@ -610,9 +599,8 @@ module Gruff
         # X Axis
         # Centered vertically and horizontally by setting the
         # height to 1.0 and the width to the width of the graph.
-        x_axis_label_y_coordinate = @graph_bottom + LABEL_MARGIN + @marker_caps_height
+        x_axis_label_y_coordinate = @graph_bottom + (LABEL_MARGIN * 2) + marker_caps_height
 
-        # TODO: Center between graph area
         text_renderer = Gruff::Renderer::Text.new(renderer, @x_axis_label, font: @marker_font)
         text_renderer.add_to_render_queue(@raw_columns, 1.0, 0.0, x_axis_label_y_coordinate)
       end
@@ -620,7 +608,7 @@ module Gruff
       if @y_axis_label
         # Y Axis, rotated vertically
         text_renderer = Gruff::Renderer::Text.new(renderer, @y_axis_label, font: @marker_font, rotation: -90)
-        text_renderer.add_to_render_queue(1.0, @raw_rows, @left_margin + @marker_caps_height / 2.0, 0.0, Magick::CenterGravity)
+        text_renderer.add_to_render_queue(1.0, @raw_rows, @left_margin + (marker_caps_height / 2.0), 0.0, Magick::CenterGravity)
       end
     end
 
@@ -628,17 +616,17 @@ module Gruff
     def draw_line_markers
       return if @hide_line_markers
 
-      increment_scaled = @graph_height.to_f / (@spread / @increment)
+      increment_scaled = @graph_height / (@spread / @increment)
 
       # Draw horizontal line markers and annotate with numbers
       (0..marker_count).each do |index|
-        y = @graph_top + @graph_height - index.to_f * increment_scaled
+        y = @graph_top + @graph_height - (index * increment_scaled)
 
-        line_renderer = Gruff::Renderer::Line.new(renderer, color: @marker_color, shadow_color: @marker_shadow_color)
-        line_renderer.render(@graph_left, y, @graph_right, y)
+        Gruff::Renderer::Line.new(renderer, color: @marker_color).render(@graph_left, y, @graph_right, y)
+        Gruff::Renderer::Line.new(renderer, color: @marker_shadow_color).render(@graph_left, y + 1, @graph_right, y + 1) if @marker_shadow_color
 
         unless @hide_line_numbers
-          marker_label = BigDecimal(index.to_s) * BigDecimal(@increment.to_s) + BigDecimal(minimum_value.to_s)
+          marker_label = (BigDecimal(index.to_s) * BigDecimal(@increment.to_s)) + BigDecimal(minimum_value.to_s)
           label = y_axis_label(marker_label, @increment)
           text_renderer = Gruff::Renderer::Text.new(renderer, label, font: @marker_font)
           text_renderer.add_to_render_queue(@graph_left - LABEL_MARGIN, 1.0, 0.0, y, Magick::EastGravity)
@@ -658,45 +646,46 @@ module Gruff
 
       legend_labels = store.data.map(&:label)
       legend_square_width = @legend_box_size # small square with color of this item
-      label_widths = calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
+      legend_label_lines = calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
+      line_height = [legend_caps_height, legend_square_width].max + @legend_margin
 
-      current_x_offset = center(label_widths.first.sum)
       current_y_offset = begin
         if @legend_at_bottom
-          @graph_bottom + @legend_margin + @legend_caps_height + LABEL_MARGIN
+          @graph_bottom + @legend_margin + legend_caps_height + LABEL_MARGIN + (@x_axis_label ? (LABEL_MARGIN * 2) + marker_caps_height : 0)
         else
-          hide_title? ? @top_margin + @title_margin : @top_margin + @title_margin + @title_caps_height
+          hide_title? ? @top_margin + @title_margin : @top_margin + @title_margin + title_caps_height
         end
       end
 
-      legend_labels.each_with_index do |legend_label, index|
-        next if legend_label.empty?
-
-        # Draw label
-        text_renderer = Gruff::Renderer::Text.new(renderer, legend_label, font: @legend_font)
-        text_renderer.add_to_render_queue(@raw_columns, 1.0, current_x_offset + (legend_square_width * 1.7), current_y_offset, Magick::WestGravity)
-
-        # Now draw box with color of this dataset
-        rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: store.data[index].color)
-        rect_renderer.render(current_x_offset,
-                             current_y_offset - legend_square_width / 2.0,
-                             current_x_offset + legend_square_width,
-                             current_y_offset + legend_square_width / 2.0)
-
-        width = calculate_width(@legend_font, legend_label)
-        current_x_offset += width + (legend_square_width * 2.7)
-        label_widths.first.shift
-
-        # Handle wrapping
-        if label_widths.first.empty?
-          label_widths.shift
-          current_x_offset = center(label_widths.first.sum) unless label_widths.empty?
-          line_height = [@legend_caps_height, legend_square_width].max + @legend_margin
-          unless label_widths.empty?
-            # Wrap to next line and shrink available graph dimensions
-            current_y_offset += line_height
+      index = 0
+      legend_label_lines.each do |(legend_labels_width, legend_labels_line)|
+        current_x_offset = center(legend_labels_width)
+
+        legend_labels_line.each do |legend_label|
+          unless legend_label.empty?
+            legend_label_width = calculate_width(@legend_font, legend_label)
+
+            # Draw label
+            text_renderer = Gruff::Renderer::Text.new(renderer, legend_label, font: @legend_font)
+            text_renderer.add_to_render_queue(legend_label_width,
+                                              legend_square_width,
+                                              current_x_offset + (legend_square_width * 1.7),
+                                              current_y_offset,
+                                              Magick::CenterGravity)
+
+            # Now draw box with color of this dataset
+            rect_renderer = Gruff::Renderer::Rectangle.new(renderer, color: store.data[index].color)
+            rect_renderer.render(current_x_offset,
+                                 current_y_offset,
+                                 current_x_offset + legend_square_width,
+                                 current_y_offset + legend_square_width)
+
+            current_x_offset += legend_label_width + (legend_square_width * 2.7)
           end
+          index += 1
         end
+
+        current_y_offset += line_height
       end
     end
 
@@ -704,7 +693,7 @@ module Gruff
     def draw_title
       return if hide_title?
 
-      metrics = Gruff::Renderer::Text.new(renderer, @title, font: @title_font).metrics
+      metrics = text_metrics(@title_font, @title)
       if metrics.width > @raw_columns
         @title_font.size = @title_font.size * (@raw_columns / metrics.width) * 0.95
       end
@@ -714,19 +703,14 @@ module Gruff
     end
 
     # Draws column labels below graph, centered over x_offset
-    #--
-    # TODO Allow WestGravity as an option
-    def draw_label(x_offset, index, gravity = Magick::NorthGravity)
+    def draw_label(x_offset, index, gravity = Magick::NorthGravity, &block)
       draw_unique_label(index) do
         y_offset = @graph_bottom + LABEL_MARGIN
-
-        # TESTME
-        # FIXME: Consider chart types other than bar
-        # TODO: See if index.odd? is the best strategy
         y_offset += @label_stagger_height if index.odd?
 
         if x_offset >= @graph_left && x_offset <= @graph_right
           draw_label_at(1.0, 1.0, x_offset, y_offset, @labels[index], gravity)
+          yield if block
         end
       end
     end
@@ -748,11 +732,10 @@ module Gruff
     end
 
     # Draws the data value over the data point in bar graphs
-    def draw_value_label(x_offset, y_offset, data_point)
+    def draw_value_label(width, height, x_offset, y_offset, data_point, gravity = Magick::CenterGravity)
       return if @hide_line_markers
 
-      text_renderer = Gruff::Renderer::Text.new(renderer, data_point, font: @marker_font)
-      text_renderer.add_to_render_queue(1.0, 1.0, x_offset, y_offset)
+      draw_label_at(width, height, x_offset, y_offset, data_point, gravity)
     end
 
     # Shows an error message because you have no data.
@@ -829,15 +812,15 @@ module Gruff
 
   private
 
-    def setup_marker_caps_height
+    def marker_caps_height
       hide_bottom_label_area? ? 0 : calculate_caps_height(@marker_font)
     end
 
-    def setup_title_caps_height
+    def title_caps_height
       hide_title? ? 0 : calculate_caps_height(@title_font) * @title.lines.to_a.size
     end
 
-    def setup_legend_caps_height
+    def legend_caps_height
       @hide_legend ? 0 : calculate_caps_height(@legend_font)
     end
 
@@ -849,7 +832,11 @@ module Gruff
       # Make space for half the width of the rightmost column label.
       # Might be greater than the number of columns if between-style bar markers are used.
       last_label = @labels.keys.max.to_i
-      last_label >= (column_count - 1) && @center_labels_over_point ? calculate_width(@marker_font, @labels[last_label]) / 2.0 : 0
+      if last_label >= (column_count - 1) && @center_labels_over_point
+        calculate_width(@marker_font, truncate_label_text(@labels[last_label])) / 2.0
+      else
+        0
+      end
     end
 
     def setup_left_margin
@@ -859,32 +846,30 @@ module Gruff
         if @has_left_labels
           @labels.values.reduce('') { |value, memo| value.to_s.length > memo.to_s.length ? value : memo }
         else
-          y_axis_label(maximum_value.to_f, @increment)
+          y_axis_label(maximum_value, @increment)
         end
       end
       longest_left_label_width = calculate_width(@marker_font, truncate_label_text(text))
-      longest_left_label_width *= 1.25 if @has_left_labels
 
       # Shift graph if left line numbers are hidden
-      line_number_width = @hide_line_numbers && !@has_left_labels ? 0.0 : (longest_left_label_width + LABEL_MARGIN * 2)
+      line_number_width = !@has_left_labels && (@hide_line_markers || @hide_line_numbers) ? 0.0 : (longest_left_label_width + LABEL_MARGIN)
 
-      @left_margin + line_number_width + (@y_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN * 2)
+      @left_margin + line_number_width + (@y_axis_label.nil? ? 0.0 : marker_caps_height + (LABEL_MARGIN * 2))
     end
 
     def setup_top_margin
       # When @hide title, leave a title_margin space for aesthetics.
       # Same with @hide_legend
       @top_margin +
-        (hide_title? ? @title_margin : @title_caps_height + @title_margin) +
+        (hide_title? ? @title_margin : title_caps_height + @title_margin) +
         (@hide_legend || @legend_at_bottom ? @legend_margin : calculate_legend_height + @legend_margin)
     end
 
     def setup_bottom_margin
-      graph_bottom_margin = hide_bottom_label_area? ? @bottom_margin : @bottom_margin + @marker_caps_height + LABEL_MARGIN
+      graph_bottom_margin = hide_bottom_label_area? ? @bottom_margin : @bottom_margin + marker_caps_height + LABEL_MARGIN
       graph_bottom_margin += (calculate_legend_height + @legend_margin) if @legend_at_bottom
 
-      x_axis_label_height = @x_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN
-      # FIXME: Consider chart types other than bar
+      x_axis_label_height = @x_axis_label.nil? ? 0.0 : marker_caps_height + (LABEL_MARGIN * 2)
       @raw_rows - graph_bottom_margin - x_axis_label_height - @label_stagger_height
     end
 
@@ -919,7 +904,7 @@ module Gruff
           else
             value.to_s
           end
-        elsif (@spread.to_f % (marker_count.to_f == 0 ? 1 : marker_count.to_f) == 0) || !@y_axis_increment.nil?
+        elsif (@spread % (marker_count == 0 ? 1 : marker_count) == 0) || !@y_axis_increment.nil?
           value.to_i.to_s
         elsif @spread > 10.0
           sprintf('%0i', value)
@@ -952,44 +937,31 @@ module Gruff
     end
 
     def calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
-      # May fix legend drawing problem at small sizes
-      label_widths = [[]] # Used to calculate line wrap
+      label_widths = [[]]
+      label_lines = [[]]
       legend_labels.each do |label|
         width = calculate_width(@legend_font, label)
-        label_width = width + legend_square_width * 2.7
+        label_width = width + (legend_square_width * 2.7)
         label_widths.last.push label_width
+        label_lines.last.push label
 
         if label_widths.last.sum > (@raw_columns * 0.9)
           label_widths.push [label_widths.last.pop]
+          label_lines.push [label_lines.last.pop]
         end
       end
 
-      label_widths
+      label_widths.map(&:sum).zip(label_lines)
     end
 
     def calculate_legend_height
       return 0.0 if @hide_legend
 
       legend_labels = store.data.map(&:label)
-      legend_square_width = @legend_box_size
-      label_widths = calculate_legend_label_widths_for_each_line(legend_labels, legend_square_width)
-      legend_height = 0.0
-
-      legend_labels.each_with_index do |legend_label, _index|
-        next if legend_label.empty?
-
-        label_widths.first.shift
-        if label_widths.first.empty?
-          label_widths.shift
-          line_height = [@legend_caps_height, legend_square_width].max + @legend_margin
-          unless label_widths.empty?
-            # Wrap to next line and shrink available graph dimensions
-            legend_height += line_height
-          end
-        end
-      end
+      legend_label_lines = calculate_legend_label_widths_for_each_line(legend_labels, @legend_box_size)
+      line_height = [legend_caps_height, @legend_box_size].max
 
-      legend_height + @legend_caps_height
+      (line_height * legend_label_lines.count) + (@legend_margin * (legend_label_lines.count - 1))
     end
 
     # Returns the height of the capital letter 'X' for the current font and
@@ -998,7 +970,18 @@ module Gruff
     # Not scaled since it deals with dimensions that the regular scaling will
     # handle.
     def calculate_caps_height(font)
-      metrics = Gruff::Renderer::Text.new(renderer, 'X', font: font).metrics
+      calculate_height(font, 'X')
+    end
+
+    # Returns the height of a string at this point size.
+    #
+    # Not scaled since it deals with dimensions that the regular scaling will
+    # handle.
+    def calculate_height(font, text)
+      text = text.to_s
+      return 0 if text.empty?
+
+      metrics = text_metrics(font, text)
       metrics.height
     end
 
@@ -1010,10 +993,14 @@ module Gruff
       text = text.to_s
       return 0 if text.empty?
 
-      metrics = Gruff::Renderer::Text.new(renderer, text, font: font).metrics
+      metrics = text_metrics(font, text)
       metrics.width
     end
 
+    def text_metrics(font, text)
+      Gruff::Renderer::Text.new(renderer, text, font: font).metrics
+    end
+
     def calculate_increment
       if @y_axis_increment.nil?
         # Try to use a number of horizontal lines that will come out even.
@@ -1027,9 +1014,13 @@ module Gruff
       end
     end
 
-    # Used for degree => radian conversions
+    # Used for degree <=> radian conversions
     def deg2rad(angle)
-      angle * (Math::PI / 180.0)
+      (angle * Math::PI) / 180.0
+    end
+
+    def rad2deg(angle)
+      (angle / Math::PI) * 180.0
     end
   end
 

data/lib/gruff/bezier.rb

@@ -22,7 +22,7 @@ class Gruff::Bezier < Gruff::Base
 private
 
   def draw_graph
-    x_increment = @graph_width / (column_count - 1).to_f
+    x_increment = @graph_width / (column_count - 1)
 
     store.norm_data.each do |data_row|
       poly_points = []
@@ -30,7 +30,7 @@ private
       data_row[1].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)
+        new_y = @graph_top + (@graph_height - (data_point * @graph_height))
 
         if index == 0 && RUBY_PLATFORM != 'java'
           poly_points << new_x

data/lib/gruff/box_plot.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+#
+# Here's how to set up a Gruff::BoxPlot.
+#
+#   g = Gruff::BoxPlot.new
+#   g.data "A", [2, 3, 5, 6, 8, 10, 11, 15, 17, 20, 28, 29, 33, 34, 45, 46, 49, 61]
+#   g.data "B", [3, 4, 34, 35, 38, 39, 45, 60, 61, 69, 80, 130]
+#   g.data "C", [4, 40, 41, 46, 57, 64, 77, 76, 79, 78, 99, 153]
+#   g.write("box_plot.png")
+#
+class Gruff::BoxPlot < Gruff::Base
+  # Specifies the filling opacity in area graph. Default is +0.2+.
+  attr_writer :fill_opacity
+
+  # Specifies the stroke width in line. Default is +3.0+.
+  attr_writer :stroke_width
+
+  # Can be used to adjust the spaces between the bars.
+  # Accepts values between 0.00 and 1.00 where 0.00 means no spacing at all
+  # and 1 means that each bars' width is nearly 0 (so each bar is a simple
+  # line with no x dimension).
+  #
+  # Default value is +0.8+.
+  def spacing_factor=(space_percent)
+    raise ArgumentError, 'spacing_factor must be between 0.00 and 1.00' unless (space_percent >= 0) && (space_percent <= 1)
+
+    @spacing_factor = (1 - space_percent)
+  end
+
+private
+
+  def initialize_attributes
+    super
+    @fill_opacity = 0.2
+    @stroke_width = 3.0
+    @spacing_factor = 0.8
+  end
+
+  def draw_graph
+    # Setup the BarConversion Object
+    conversion = Gruff::BarConversion.new(
+      top: @graph_top, bottom: @graph_bottom,
+      minimum_value: minimum_value, maximum_value: maximum_value, spread: @spread
+    )
+
+    width = (@graph_width - calculate_spacing) / normalized_boxes.size
+    bar_width = width * @spacing_factor
+    padding = width - bar_width
+
+    normalized_boxes.each_with_index do |box, index|
+      left_x = @graph_left + (width * index) + (padding / 2.0)
+      right_x = left_x + bar_width
+      center_x = (left_x + right_x) / 2.0
+
+      first_y, = conversion.get_top_bottom_scaled(box.first_quartile)
+      third_y, = conversion.get_top_bottom_scaled(box.third_quartile)
+      Gruff::Renderer::Rectangle.new(renderer, color: box.color, width: @stroke_width, opacity: @fill_opacity)
+                                .render(left_x, first_y, right_x, third_y)
+
+      median_y, = conversion.get_top_bottom_scaled(box.median)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width * 2).render(left_x, median_y, right_x, median_y)
+
+      minmax_left_x  = left_x + (bar_width / 4.0)
+      minmax_right_x = right_x - (bar_width / 4.0)
+      min_y, = conversion.get_top_bottom_scaled(box.lower_whisker)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width).render(minmax_left_x, min_y, minmax_right_x, min_y)
+      Gruff::Renderer::DashLine.new(renderer, color: box.color, width: @stroke_width, dasharray: [@stroke_width, @stroke_width * 2])
+                               .render(center_x, min_y, center_x, first_y)
+
+      max_y, = conversion.get_top_bottom_scaled(box.upper_whisker)
+      Gruff::Renderer::Line.new(renderer, color: box.color, width: @stroke_width).render(minmax_left_x, max_y, minmax_right_x, max_y)
+      Gruff::Renderer::DashLine.new(renderer, color: box.color, width: @stroke_width, dasharray: [@stroke_width, @stroke_width * 2])
+                               .render(center_x, max_y, center_x, third_y)
+
+      box.lower_outliers.each do |outlier|
+        outlier_y, = conversion.get_top_bottom_scaled(outlier)
+        Gruff::Renderer::Dot.new(renderer, :circle, color: box.color, opacity: @fill_opacity).render(center_x, outlier_y, @stroke_width * 2)
+      end
+
+      box.upper_outliers.each do |outlier|
+        outlier_y, = conversion.get_top_bottom_scaled(outlier)
+        Gruff::Renderer::Dot.new(renderer, :circle, color: box.color, opacity: @fill_opacity).render(center_x, outlier_y, @stroke_width * 2)
+      end
+
+      draw_label(center_x, index)
+    end
+  end
+
+  def normalized_boxes
+    @normalized_boxes ||= store.norm_data.map { |data| Gruff::BoxPlot::BoxData.new(data.label, data.points, data.color) }
+  end
+
+  def calculate_spacing
+    @scale * (column_count - 1)
+  end
+
+  # @private
+  class BoxData < Struct.new(:label, :points, :color)
+    def initialize(label, points, color)
+      super(label, points.sort, color)
+    end
+
+    def min
+      points.first || 0
+    end
+
+    def max
+      points.last || 0
+    end
+
+    def min_whisker
+      [min, first_quartile - (1.5 * interquartile_range)].max
+    end
+
+    def max_whisker
+      [max, third_quartile + (1.5 * interquartile_range)].min
+    end
+
+    def upper_whisker
+      max = max_whisker
+      points.select { |point| point <= max }.max
+    end
+
+    def lower_whisker
+      min = min_whisker
+      points.select { |point| point >= min }.min
+    end
+
+    def median
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[points.size / 2]
+      else
+        (points[points.size / 2] + points[(points.size / 2) - 1]) / 2.0
+      end
+    end
+
+    def first_quartile
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[points.size / 4]
+      else
+        (points[points.size / 4] + points[(points.size / 4) - 1]) / 2.0
+      end
+    end
+
+    def third_quartile
+      if points.size.zero?
+        0
+      elsif points.size.odd?
+        points[(points.size * 3) / 4]
+      else
+        (points[(points.size * 3) / 4] + points[((points.size * 3) / 4) - 1]) / 2.0
+      end
+    end
+
+    def lower_outliers
+      min = lower_whisker
+      points.select { |point| point < min }
+    end
+
+    def upper_outliers
+      max = upper_whisker
+      points.select { |point| point > max }
+    end
+
+    def interquartile_range
+      third_quartile - first_quartile
+    end
+  end
+end