tlconnor-scruffy 0.2.17

data/lib/scruffy/layers/scatter.rb

@@ -0,0 +1,29 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Line
+  #
+  # Author:: Mat Schaffer
+  # Date:: March 20th, 2007
+  #
+  # Simple scatter graph
+  class Scatter < Base
+    
+    include Scruffy::Helpers::Marker
+    
+    # Renders scatter graph.
+    def draw(svg, coords, options={})
+      
+      options.merge!(@options)
+      
+      if options[:shadow]
+        svg.g(:class => 'shadow', :transform => "translate(#{relative(0.5)}, #{relative(0.5)})") {
+          coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last + relative(0.9), :r => relative(2), 
+                                            :style => "stroke-width: #{relative(2)}; stroke: black; opacity: 0.35;" ) }
+        }
+      end
+
+      coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => relative(2), 
+                                        :style => "stroke-width: #{relative(2)}; stroke: #{color.to_s}; fill: #{color.to_s}" ) }
+    end
+  end
+end
+

data/lib/scruffy/layers/sparkline_bar.rb

@@ -0,0 +1,39 @@
+module Scruffy
+  module Layers
+    # Experimental, do not use.
+    class SparklineBar < Base
+    
+      def draw(svg, coords, options = {})
+        zero_point = @height / 2.0
+
+        coords.each do |coord|
+          x, y, bar_height = (coord.first-(@bar_width * 0.5)), coord.last, (height - coord.last)
+
+          bar_color = (y > zero_point) ? 'black' : 'red'
+          bar_height = (bar_height - zero_point)
+          
+          #y = (bar_height < 0) ? 
+
+          # svg.rect( :x => x, :y => zero_point, :width => @bar_width, :height => , 
+          #           :fill => bar_color, :stroke => 'none', 'style' => "opacity: #{opacity}" )
+        end
+      end
+
+      protected
+        def generate_coordinates(options = {})
+          @bar_width = (width / points.size) * 0.9
+          options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
+
+          #TODO iteration by index on points.  Needs to change
+          coords = (0...points.size).map do |idx| 
+            x_coord = (options[:point_distance] * idx) + (width / points.size * 0.5)
+
+            relative_percent = ((points[idx] == min_value) ? 0 : ((points[idx] - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+            [x_coord, y_coord]
+          end
+          coords
+        end
+    end
+  end
+end

data/lib/scruffy/layers/stacked.rb

@@ -0,0 +1,87 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Stacked
+  #
+  # Author:: Brasten Sager
+  # Date:: August 12th, 2006
+  #
+  # Provides a generic way for stacking graphs.  This may or may not
+  # do what you'd expect under every situation, but it at least kills
+  # a couple birds with one stone (stacked bar graphs and stacked area
+  # graphs work fine).
+  class Stacked < Base
+    include Scruffy::Helpers::LayerContainer
+    
+    # Returns new Stacked graph.
+    #
+    # You can provide a block for easily adding layers during (just after) initialization.
+    # Example:
+    #   Stacked.new do |stacked|
+    #     stacked << Scruffy::Layers::Line.new( ... )
+    #     stacked.add(:bar, 'My Bar', [...])
+    #   end
+    #
+    # The initialize method passes itself to the block, and since stacked is a LayerContainer,
+    # layers can be added just as if they were being added to Graph.
+    def initialize(options={}, &block)
+      super(options)
+
+      block.call(self)    # Allow for population of data with a block during initialization.
+    end
+    
+    # Overrides Base#render to fiddle with layers' points to achieve a stacked effect.
+    def render(svg, options = {})
+      #TODO ensure this works with new points
+      current_points = points
+      
+      layers.each do |layer|
+        real_points = layer.points
+        layer.points = current_points
+        layer_options = options.dup
+        layer_options[:color] = layer.preferred_color || layer.color || options[:theme].next_color          
+        layer.render(svg, layer_options)
+        options.merge(layer_options)
+        layer.points = real_points
+        
+        layer.points.each_with_index { |val, idx| current_points[idx] -= val }
+      end
+    end
+
+    # A stacked graph has many data sets.  Return legend information for all of them.
+    def legend_data
+      if relevant_data?
+        retval = []
+        layers.each do |layer|
+          retval << layer.legend_data
+        end
+        retval
+      else
+        nil
+      end
+    end
+
+    # TODO, special points accessor  
+    def points
+      longest_arr = layers.inject(nil) do |longest, layer|
+        longest = layer.points if (longest.nil? || longest.size < layer.points.size)
+      end
+      
+      summed_points = (0...longest_arr.size).map do |idx|
+        layers.inject(nil) do |sum, layer|
+          if sum.nil? && !layer.points[idx].nil?
+            sum = layer.points[idx]
+          elsif !layer.points[idx].nil?
+            sum += layer.points[idx]
+          end
+          
+          sum
+        end
+      end
+
+      summed_points
+    end
+
+    def points=(val)
+      throw ArgumentsError, "Stacked layers cannot accept points, only other layers."
+    end
+  end
+end

data/lib/scruffy/rasterizers.rb

@@ -0,0 +1,14 @@
+# ===Scruffy Rasterizers
+#
+# Author:: Brasten Sager
+# Date:: August 10th, 2006
+#
+# These handle the job of rasterizing SVG images to other image formats.
+# At the moment, only RMagickRasterizer exists, but others may soon follow.
+#
+# I'm somewhat interesting in finding a way to integrate Apache Batik, as it's
+# SVG rendering seems to be superior to ImageMagick's.
+module Scruffy::Rasterizers; end
+
+require 'scruffy/rasterizers/rmagick_rasterizer.rb'
+require 'scruffy/rasterizers/batik_rasterizer.rb'

data/lib/scruffy/rasterizers/batik_rasterizer.rb

@@ -0,0 +1,39 @@
+module Scruffy::Rasterizers
+  # == Scruffy::Rasterizers::BatikRasterizer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Purely experimental.  Can be used to rasterize SVG graphs with
+  # Apache Batik.
+  class BatikRasterizer
+    # Returns new BatikRasterizer.
+    #
+    # Options:
+    # command:: Command needed to execute Batik. (ie: 'java -classpath {...}')
+    # temp_folder:: Folder for storing temporary files being passed between Scruffy and Batik.
+    def initialize(options={})
+      @command = options[:command]
+      @temp_folder = options[:temp_folder]
+    end
+    
+    # Rasterize graph.
+    #
+    # Options:
+    # as:: Image format to generate (PNG, JPG, et al.)
+    def rasterize(svg, options={})
+      File.open(@temp_folder + '/temp_svg.svg', 'w') { |file|
+        file.write(svg)
+      }
+      
+      `#{@command} -d #{@temp_folder} -m image/#{options[:as].downcase} #{@temp_folder}/temp_svg.svg`
+      
+      image = ""
+      File.open(@temp_folder + '/temp_svg.' + options[:as].downcase, 'r') { |file|
+        image = file.read
+      }
+      
+      image
+    end
+  end
+end

data/lib/scruffy/rasterizers/mini_magick_rasterizer.rb

@@ -0,0 +1,24 @@
+module Scruffy::Rasterizers
+
+  # == MiniMagickRasterizer
+  #
+  # Author:: Tim Connor
+  # Date:: Feb 9th, 2010
+  #
+  # The MiniMagickRasterizer converts SVG graphs to images using MiniMagick.
+  class MiniMagickRasterizer
+    def rasterize(svg, options={})
+      require 'mini_magick'
+
+      image = MiniMagick::Image::from_blob(svg)
+
+      image.format(options[:as]) do |cmd|
+        cmd.background "#0000" # Transparent background
+      end if options[:as]
+      
+      image.write(options[:to]) if options[:to]
+      image.to_blob
+
+    end
+  end
+end

data/lib/scruffy/rasterizers/rmagick_rasterizer.rb

@@ -0,0 +1,27 @@
+module Scruffy::Rasterizers
+
+  # == RMagickRasterizer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # The RMagickRasterizer converts SVG graphs to images using ImageMagick.
+  class RMagickRasterizer
+    def rasterize(svg, options={})
+      # I know this seems weird, I'm open to suggestions.
+      # I didn't want RMagick required unless absolutely necessary.
+      require 'RMagick'
+
+      image = Magick::Image::from_blob(svg)[0]
+
+      # Removed for now
+      # image.resize!(options[:size][0], options[:size][1], Magick::BoxFilter, 1.25) if options[:actual_size]
+
+      if options[:to]
+        image.write(options[:to]) { self.format = options[:as] }
+      end
+
+      image.to_blob { self.format = options[:as] }
+    end
+  end
+end

data/lib/scruffy/renderers.rb

@@ -0,0 +1,23 @@
+# ===Scruffy Renderers
+#
+# Author:: Brasten Sager
+# Date:: August 14th, 2006
+#
+# Renderers piece the entire graph together from a collection
+# of components.  Creating new renderers allows you to create
+# entirely new layouts for your graphs.
+#
+# Scruffy::Renderers::Base contains the basic functionality needed
+# by a layout.  The easiest way to create a new layout is by subclassing
+# Base.
+module Scruffy::Renderers; end
+
+require 'scruffy/renderers/base'
+require 'scruffy/renderers/empty'
+require 'scruffy/renderers/standard'
+require 'scruffy/renderers/axis_legend'
+require 'scruffy/renderers/reversed'
+require 'scruffy/renderers/cubed'
+require 'scruffy/renderers/split'
+require 'scruffy/renderers/cubed3d'
+require 'scruffy/renderers/pie'

data/lib/scruffy/renderers/axis_legend.rb

@@ -0,0 +1,41 @@
+module Scruffy::Renderers
+  class AxisLegend < Empty
+    
+    def define_layout
+      super do |components|
+        components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+        
+        
+        components << Scruffy::Components::Viewport.new(:view, :position => [6, 22], :size => [90, 66]) do |graph|
+          graph << Scruffy::Components::ValueMarkers.new(:values, :position => [0, 2], :size => [8, 89])
+          graph << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89], :stroke_width => 1)
+          graph << Scruffy::Components::VGrid.new(:vgrid, :position => [10, 0], :size => [90, 89], :stroke_width => 1)
+          graph << Scruffy::Components::DataMarkers.new(:labels, :position => [10, 92], :size => [90, 8])
+          graph << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89])
+        end
+        components << Scruffy::Components::YLegend.new(:y_legend, :position => [1, 26], :size => [5, 66])
+        components << Scruffy::Components::XLegend.new(:x_legend, :position => [5, 92], :size => [90, 6])
+        components << Scruffy::Components::Legend.new(:legend, :position => [5, 13], :size => [90, 6])
+      end
+    end
+    
+    protected
+      def hide_values
+        super
+        component(:view).position[0] = -10
+        component(:view).size[0] = 100
+      end
+    
+      def labels
+        [component(:view).component(:labels)]
+      end
+    
+      def values
+        [component(:view).component(:values)]
+      end
+      
+      def grids
+        [component(:view).component(:grid),component(:view).component(:vgrid)]
+      end
+  end
+end

data/lib/scruffy/renderers/base.rb

@@ -0,0 +1,95 @@
+require 'builder'
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Base
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Provides all the base functionality needed to render a graph, but
+  # does not provide a default layout.
+  #
+  # For a basic layout, see Scruffy::Renderers::Standard.
+  class Base
+    include Scruffy::Helpers::Canvas
+    
+    attr_accessor :options
+
+    def initialize(options = {})
+      self.components = []
+      self.options = options
+      define_layout
+    end
+
+    # Renders the graph and all components.
+    def render(options = {})
+      options[:graph_id]    ||= 'scruffy_graph'
+      options[:complexity]  ||= (global_complexity || :normal)
+
+      # Allow subclasses to muck with components prior to renders.
+      rendertime_renderer = self.clone
+      rendertime_renderer.instance_eval { before_render if respond_to?(:before_render) }
+
+      svg = Builder::XmlMarkup.new(:indent => 2)
+      unless options[:no_doctype_header]
+        svg.instruct!
+        svg.instruct! 'DOCTYPE', 'svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"  type'
+      end
+      svg.svg(:xmlns => "http://www.w3.org/2000/svg", 'xmlns:xlink' => "http://www.w3.org/1999/xlink", :width => options[:size].first, :height => options[:size].last) {
+        svg.g(:id => options[:graph_id]) {
+          rendertime_renderer.components.each do |component|
+            component.render(svg, 
+                             bounds_for( options[:size], component.position, component.size ), 
+                             options)
+          end
+        }
+      }
+      svg.target!
+    end
+    
+    def before_render
+      if self.options
+        set_values(self.options[:values])    if (self.options[:values] && self.options[:values] != :hide)
+        hide_grid     if (self.options[:grid] == :hide)
+        hide_values   if (self.options[:values] == :hide)
+        hide_labels   if (self.options[:labels] == :hide)
+      end
+    end
+    
+    def method_missing(sym, *args)
+      self.options = {} if self.options.nil?
+      
+      if args.size > 0
+        self.options[sym] = args[0]
+      else
+        return self.options[sym]
+      end
+    end
+
+    protected
+      def hide_grid
+        grids.each { |grid| grid.visible = false }
+      end
+    
+      def set_values(val)
+        values.each { |value| value.markers = val }
+        grids.each { |grid| grid.markers = val }
+      end
+    
+      def hide_values
+        values.each { |value| value.visible = false }
+      end
+    
+      def hide_labels
+        labels.each { |label| label.visible = false }
+      end    
+
+    private
+      def global_complexity
+        if Kernel.const_defined? "SCRUFFY_COMPLEXITY"
+          SCRUFFY_COMPLEXITY
+        else
+          nil
+        end
+      end
+  end   # base
+end

data/lib/scruffy/renderers/cubed.rb

@@ -0,0 +1,44 @@
+module Scruffy::Renderers
+  # ===Scruffy::Renderers::Cubed
+  #
+  # Author:: Brasten Sager
+  # Date:: August 14th, 2006
+  #
+  # Graph layout consisting of four separate graphs arranged in a 2x2 grid.
+  class Cubed < Empty
+    VIEWPORT_SIZE = [35, 30]
+    VIEWPORTS     = { :top_left => [10, 25],
+                      :top_right => [55, 25],
+                      :bottom_left => [10, 65],
+                      :bottom_right => [55, 65] }
+    
+    # Returns a Cubed instance.
+    def define_layout
+      super do |components|
+        components << Scruffy::Components::Title.new(:title, :position => [5, 2], :size => [90, 7])
+                      
+        VIEWPORTS.each_pair do |category, position|
+          components << Scruffy::Components::Viewport.new(category, :position => position, 
+                                                          :size => VIEWPORT_SIZE, &graph_block(category))
+        end
+
+        components << Scruffy::Components::Legend.new(:legend, :position => [5, 13], :size => [90, 5])
+      end
+    end
+
+    private
+      # Returns a typical graph layout.
+      #
+      # These are squeezed into viewports.
+      def graph_block(graph_filter)
+        block = Proc.new { |components|
+          components << Scruffy::Components::Grid.new(:grid, :position => [10, 0], :size => [90, 89])
+          components << Scruffy::Components::ValueMarkers.new(:value_markers, :position => [0, 2], :size => [8, 89])
+          components << Scruffy::Components::DataMarkers.new(:data_markers, :position => [10, 92], :size => [90, 8])
+          components << Scruffy::Components::Graphs.new(:graphs, :position => [10, 0], :size => [90, 89], :only => graph_filter)
+        }
+        
+        block
+      end
+  end
+end