gruff 0.4.0-java

data/lib/gruff/pie.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/base'
+
+##
+# Here's how to make a Pie graph:
+#
+#   g = Gruff::Pie.new
+#   g.title = "Visual Pie Graph Test"
+#   g.data 'Fries', 20
+#   g.data 'Hamburgers', 50
+#   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
+
+  # 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
+  # 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
+
+  def initialize_ivars
+    super
+    @zero_degree = 0.0
+    @hide_labels_less_than = 0.0
+  end
+
+  def draw
+    @hide_line_markers = true
+    
+    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
+      end
+    end
+
+    # TODO debug a circle where the text is drawn...
+    
+    @d.draw(@base_image)
+  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
+  end
+
+end
+
+class Float
+  # Used for degree => radian conversions
+  def deg2rad
+    self * (Math::PI/180.0)
+  end
+end
+

data/lib/gruff/scatter.rb

@@ -0,0 +1,264 @@
+require File.dirname(__FILE__) + '/base'
+
+# Here's how to set up an XY Scatter Chart
+#
+# 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')
+# 
+#
+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
+
+  def setup_drawing
+    # TODO Need to get x-axis labels working. Current behavior will be to not allow.
+    @labels = {}
+
+    super
+
+    # Translate our values so that we can use the base methods for drawing
+    # the standard chart stuff
+    @column_count = @x_spread
+  end
+
+  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? 
+
+        new_x = get_x_coord(x_value, @graph_width, @graph_left)
+        new_y = @graph_top + (@graph_height - data_point * @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)
+      end
+    end
+
+    @d.draw(@base_image)
+  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.
+  #
+  # Can be called multiple times with different datasets for a multi-valued
+  # graph.
+  #
+  # 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().
+  #
+  # ==== 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.
+  #
+  # ==== Exceptions
+  # 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::
+  #   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
+  #
+  # ==== 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')
+  #
+  def data(name, x_data_points=[], y_data_points=[], color=nil)
+    
+    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
+  end
+  
+protected
+  
+  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
+  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
+      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) ? significant(@x_spread / @marker_x_count) : 1
+    else
+      # 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)
+      
+      @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)
+
+    # Draw vertical line markers and annotate with numbers
+    (0..@marker_x_count).each do |index|
+
+      # 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)
+
+      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)
+      end
+    end
+    
+    @d = @d.stroke_antialias true
+  end
+  
+private
+  
+  def get_x_coord(x_data_point, width, offset) #:nodoc:
+    x_data_point * width + offset
+  end
+  
+end # end Gruff::Scatter

data/lib/gruff/scene.rb

@@ -0,0 +1,209 @@
+
+require "observer"
+require File.dirname(__FILE__) + '/base'
+
+##
+# A scene is a non-linear graph that assembles layers together to tell a story.
+# Layers are folders with appropriately named files (see below). You can group 
+# layers and control them together or just set their values individually.
+#
+# Examples:
+#
+# * A city scene that changes with the time of day and the weather conditions.
+# * A traffic map that shows red lines on streets that are crowded and green on free-flowing ones.
+#
+# Usage:
+# 
+#  g = Gruff::Scene.new("500x100", "path/to/city_scene_directory")
+#
+#  # Define order of layers, back to front
+#  g.layers = %w(background haze sky clouds)
+#
+#  # Define groups that will be controlled by the same input
+#  g.weather_group = %w(clouds)
+#  g.time_group = %w(background sky)
+#
+#  # Set values for the layers or groups
+#  g.weather = "cloudy"
+#  g.time = Time.now
+#  g.haze = true
+#
+#  # Write the final graph to disk
+#  g.write "hazy_daytime_city_scene.png"
+#
+#
+# There are several rules that will magically select a layer when possible.
+#
+# * Numbered files will be selected according to the closest value that is less than the input value.
+# * 'true.png' and 'false.png' will be used as booleans.
+# * Other named files will be used if the input matches the filename (without the filetype extension).
+# * If there is a file named 'default.png', it will be used unless other input values are set for the corresponding layer.
+
+class Gruff::Scene < Gruff::Base
+    
+  # An array listing the foldernames that will be rendered, from back to front.
+  #
+  #  g.layers = %w(sky clouds buildings street people)
+  #
+  attr_reader :layers
+
+  def initialize(target_width, base_dir)
+    @base_dir = base_dir
+    @groups = {}
+    @layers = []    
+    super target_width
+  end
+
+  def draw
+    # Join all the custom paths and filter out the empty ones
+    image_paths = @layers.map { |layer| layer.path }.select { |path| !path.empty? }
+    images = Magick::ImageList.new(*image_paths)
+    @base_image = images.flatten_images
+  end
+
+  def layers=(ordered_list)
+    ordered_list.each do |layer_name|
+      @layers << Gruff::Layer.new(@base_dir, layer_name)
+    end
+  end
+
+  # Group layers to input values
+  #
+  #  g.weather_group = ["sky", "sea", "clouds"]
+  #
+  # Set input values
+  #
+  #  g.weather = "cloudy"
+  #
+  def method_missing(method_name, *args)
+    case method_name.to_s
+    when /^(\w+)_group=$/
+      add_group $1, *args
+      return
+    when /^(\w+)=$/
+      set_input $1, args.first
+      return
+    end
+    super
+  end
+
+private
+
+  def add_group(input_name, layer_names)
+    @groups[input_name] = Gruff::Group.new(input_name, @layers.select { |layer| layer_names.include?(layer.name) })
+  end
+
+  def set_input(input_name, input_value)
+    if not @groups[input_name].nil?
+      @groups[input_name].send_updates(input_value)
+    else
+      if chosen_layer = @layers.detect { |layer| layer.name == input_name }
+        chosen_layer.update input_value
+      end
+    end
+  end
+  
+end
+
+
+class Gruff::Group
+
+  include Observable
+  attr_reader :name
+
+  def initialize(folder_name, layers)
+    @name = folder_name
+    layers.each do |layer|
+      layer.observe self
+    end
+  end
+  
+  def send_updates(value)
+    changed
+    notify_observers value
+  end
+  
+end
+
+
+class Gruff::Layer
+  
+  attr_reader :name
+  
+  def initialize(base_dir, folder_name)
+    @base_dir = base_dir.to_s
+    @name = folder_name.to_s
+    @filenames = Dir.open(File.join(base_dir, folder_name)).entries.select { |file| file =~ /^[^.]+\.png$/ }.sort
+    @selected_filename = select_default
+  end
+  
+  # Register this layer so it receives updates from the group
+  def observe(obj)
+    obj.add_observer self
+  end
+  
+  # Choose the appropriate filename for this layer, based on the input
+  def update(value)
+    @selected_filename =  case value.to_s
+                          when /^(true|false)$/
+                            select_boolean value
+                          when /^(\w|\s)+$/
+                            select_string value
+                          when /^-?(\d+\.)?\d+$/
+                            select_numeric value
+                          when /(\d\d):(\d\d):\d\d/
+                            select_time "#{$1}#{$2}"
+                          else
+                            select_default
+                          end
+    # Finally, try to use 'default' if we're still blank
+    @selected_filename ||= select_default
+  end
+
+  # Returns the full path to the selected image, or a blank string
+  def path
+    unless @selected_filename.nil? || @selected_filename.empty?
+      return File.join(@base_dir, @name, @selected_filename)
+    end
+    ''
+  end
+
+private
+
+  # Match "true.png" or "false.png"
+  def select_boolean(value)
+    file_exists_or_blank value.to_s
+  end
+
+  # Match -5 to _5.png
+  def select_numeric(value)
+    file_exists_or_blank value.to_s.gsub('-', '_')
+  end
+  
+  def select_time(value)
+    times = @filenames.map { |filename| filename.gsub('.png', '') }
+    times.each_with_index do |time, index|
+      if (time > value) && (index > 0)
+        return "#{times[index - 1]}.png"
+      end
+    end
+    return "#{times.last}.png"
+  end
+  
+  # Match "partly cloudy" to "partly_cloudy.png"
+  def select_string(value)
+    file_exists_or_blank value.to_s.gsub(' ', '_')
+  end
+  
+  def select_default
+    @filenames.include?("default.png") ? "default.png" : ''
+  end
+
+  # Returns the string "#{filename}.png", if it exists.
+  #
+  # Failing that, it returns default.png, or '' if that doesn't exist.
+  def file_exists_or_blank(filename)
+    @filenames.include?("#{filename}.png") ? "#{filename}.png" : select_default
+  end
+  
+end