image_paradise 0.4.8

data/lib/image_paradise/graphs/scatter.rb

@@ -0,0 +1,264 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+require 'image_paradise/graphs/base.rb'
+
+# 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')
+module ImageParadise
+
+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
+
+
+  # === initialize
+  #
+  # 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
+  # === draw
+  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 # end Gruff::Scatter

data/lib/image_paradise/graphs/scene.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+begin
+  require 'observer'
+rescue LoadError; end
+require 'image_paradise/graphs/base.rb'
+
+##
+# 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.
+
+module ImageParadise
+
+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
+  # === initialize
+  def initialize(target_width, base_dir)
+    @base_dir = base_dir
+    @groups = {}
+    @layers = []    
+    super target_width
+  end
+  # === draw
+  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
+  # === layers=
+  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; end

data/lib/image_paradise/graphs/side_bar.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+require 'image_paradise/graphs/base.rb'
+
+##
+# Graph with individual horizontal bars instead of vertical bars.
+
+module ImageParadise
+
+class Gruff::SideBar < Gruff::Base
+
+  # Spacing factor applied between bars
+  attr_accessor :bar_spacing
+
+  def draw
+    @has_left_labels = true
+    super
+
+    return unless @has_data
+    draw_bars
+  end
+
+  protected
+
+  def draw_bars
+    # Setup spacing.
+    #
+    @bar_spacing ||= 0.9
+
+    @bars_width = @graph_height / @column_count.to_f
+    @bar_width = @bars_width / @norm_data.size
+    @d = @d.stroke_opacity 0.0
+    height = Array.new(@column_count, 0)
+    length = Array.new(@column_count, @graph_left)
+    padding = (@bar_width * (1 - @bar_spacing)) / 2
+
+    # if we're a side stacked bar then we don't need to draw ourself at all
+    # because sometimes (due to different heights/min/max) you can actually
+    # see both graphs and it looks like crap
+    return if self.is_a?(Gruff::SideStackedBar)
+
+    @norm_data.each_with_index do |data_row, row_index|
+      @d = @d.fill data_row[DATA_COLOR_INDEX]
+
+      data_row[DATA_VALUES_INDEX].each_with_index do |data_point, point_index|
+
+        # Using the original calcs 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])
+        temp2 = @graph_left + @graph_width - height[point_index]
+        difference = temp2 - temp1
+
+        left_x = length[point_index] - 1
+        left_y = @graph_top + (@bars_width * point_index) + (@bar_width * row_index) + padding
+        right_x = left_x + difference
+        right_y = left_y + @bar_width * @bar_spacing
+
+        height[point_index] += (data_point * @graph_width)
+
+        @d = @d.rectangle(left_x, left_y, right_x, right_y)
+
+        # Calculate center based on bar_width and current row
+
+        if @use_data_label
+          label_center = @graph_top + (@bar_width * (row_index+point_index) + @bar_width / 2)
+          draw_label(label_center, row_index, @norm_data[row_index][DATA_LABEL_INDEX])
+        else
+          label_center = @graph_top + (@bars_width * point_index + @bars_width / 2)
+          draw_label(label_center, point_index)
+        end
+        if @show_labels_for_bar_values
+          val = (@label_formatting || '%.2f') % @norm_data[row_index][3][point_index]
+          draw_value_label(right_x+40, (@graph_top + (((row_index+point_index+1) * @bar_width) - (@bar_width / 2)))-12, val.commify, true)
+        end
+      end
+
+    end
+
+    @d.draw(@base_image)
+  end
+
+  # Instead of base class version, draws vertical background lines and label
+  def draw_line_markers
+
+    return if @hide_line_markers
+
+    @d = @d.stroke_antialias false
+
+    # Draw horizontal line markers and annotate with numbers
+    @d = @d.stroke(@marker_color)
+    @d = @d.stroke_width 1
+    number_of_lines = @marker_count || 5
+    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)
+    (0..number_of_lines).each do |index|
+
+      line_diff = (@graph_right - @graph_left) / number_of_lines
+      x = @graph_right - (line_diff * index) - 1
+      @d = @d.line(x, @graph_bottom, x, @graph_top)
+      diff = index - number_of_lines
+      marker_label = diff.abs * increment + @minimum_value
+
+      unless @hide_line_numbers
+        @d.fill = @font_color
+        @d.font = @font if @font
+        @d.stroke = 'transparent'
+        @d.pointsize = scale_fontsize(@marker_font_size)
+        @d.gravity = CenterGravity
+        # TODO Center text over line
+        @d = @d.annotate_scaled(@base_image,
+                                0, 0, # Width of box to draw text in
+                                x, @graph_bottom + (LABEL_MARGIN * 2.0), # Coordinates of text
+                                marker_label.to_s, @scale)
+      end # unless
+      @d = @d.stroke_antialias true
+    end
+  end
+
+  ##
+  # Draw on the Y axis instead of the X
+
+  def draw_label(y_offset, index, label=nil)
+    if !@labels[index].nil? && @labels_seen[index].nil?
+      lbl = (@use_data_label) ? label : @labels[index]
+      @d.fill = @font_color
+      @d.font = @font if @font
+      @d.stroke = 'transparent'
+      @d.font_weight = NormalWeight
+      @d.pointsize = scale_fontsize(@marker_font_size)
+      @d.gravity = EastGravity
+      @d = @d.annotate_scaled(@base_image,
+                              1, 1,
+                              -@graph_left + LABEL_MARGIN * 2.0, y_offset,
+                              lbl, @scale)
+      @labels_seen[index] = 1
+    end
+  end
+
+end; end