ramhoj-scruffy 0.2.6

data/lib/scruffy/layers/average.rb

@@ -0,0 +1,67 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Average
+  #
+  # Author:: Brasten Sager
+  # Date:: August 7th, 2006
+  #
+  # An 'average' graph.  This graph iterates through all the layers and averages
+  # all the data at each point, then draws a thick, translucent, shadowy line graph
+  # indicating the average values.
+  #
+  # This only looks decent in SVG mode.  ImageMagick doesn't retain the transparency
+  # for some reason, creating a massive black line.  Any help resolving this would
+  # be useful.
+  class Average < Base
+    attr_reader :layers
+    
+    # Returns new Average graph.
+    def initialize(options = {})
+      # Set self's relevant_data to false.  Otherwise we get stuck in a
+      # recursive loop.
+      super(options.merge({:relevant_data => false}))
+      
+      # The usual :points argument is actually layers for Average, name it as such
+      @layers = options[:points] 
+    end
+    
+    # Render average graph.
+    def draw(svg, coords, options = {})
+      svg.polyline( :points => coords.join(' '), :fill => 'none', :stroke => 'black',
+                    'stroke-width' => relative(5), 'opacity' => '0.4')
+    end
+
+    protected
+      # Override default generate_coordinates method to iterate through the layers and
+      # generate coordinates based on the average data points.
+      def generate_coordinates(options = {})
+        key_layer = layers.find { |layer| layer.relevant_data? }
+      
+        options[:point_distance] = width / (key_layer.points.size - 1).to_f
+
+        coords = []
+
+        #TODO this will likely break with the new hash model
+        key_layer.points.each_with_index do |layer, idx|
+          sum, objects = points.inject([0, 0]) do |arr, elem|
+            if elem.relevant_data?
+              arr[0] += elem.points[idx]
+              arr[1] += 1
+            end
+            arr
+          end
+
+          average = sum / objects.to_f
+
+          x_coord = options[:point_distance] * idx
+
+          relative_percent = ((average == min_value) ? 0 : ((average - min_value) / (max_value - min_value).to_f))
+          y_coord = (height - (height * relative_percent))
+
+          coords << [x_coord, y_coord].join(',')
+        end
+
+        return coords
+      end
+  
+  end
+end

data/lib/scruffy/layers/bar.rb

@@ -0,0 +1,52 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Bar
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard bar graph.  
+  class Bar < Base
+  
+    # Draw bar graph.
+    def draw(svg, coords, options = {})
+      coords.each do |coord|
+        x, y, bar_height = (coord.first-(@bar_width * 0.5)), coord.last, (height - coord.last)
+
+        svg.g(:transform => "translate(-#{relative(0.5)}, -#{relative(0.5)})") {
+          svg.rect( :x => x, :y => y, :width => @bar_width + relative(1), :height => bar_height + relative(1), 
+                    :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
+          svg.rect( :x => x+relative(0.5), :y => y+relative(2), :width => @bar_width + relative(1), :height => bar_height - relative(0.5), 
+                    :style => "fill: black; fill-opacity: 0.15; stroke: none;" )
+
+        }
+        
+        svg.rect( :x => x, :y => y, :width => @bar_width, :height => bar_height, 
+                  :fill => color.to_s, 'style' => "opacity: #{opacity}; stroke: none;" )
+      end
+    end
+
+    protected
+    
+      # Due to the size of the bar graph, X-axis coords must 
+      # be squeezed so that the bars do not hang off the ends
+      # of the graph.
+      #
+      # Unfortunately this just mean that bar-graphs and most other graphs
+      # end up on different points.  Maybe adding a padding to the coordinates
+      # should be a graph-wide thing?
+      def generate_coordinates(options = {})
+        @bar_width = (width / points.size) * 0.9
+        options[:point_distance] = (width - (width / points.size)) / (points.size - 1).to_f
+
+        #TODO more array work with index, try to rework to be accepting of hashes
+        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

data/lib/scruffy/layers/base.rb

@@ -0,0 +1,191 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Base
+  #
+  # Author:: Brasten Sager
+  # Extended By:: A.J. Ostman
+  # Created:: August 5th, 2006
+  # Last Modified:: August 27, 2006
+  #
+  # Scruffy::Layers::Base contains the basic functionality needed by the various types of graphs.  The Base
+  # class is responsible holding layer information such as the title and data points.
+  #
+  # When the graph is rendered, the graph renderer calls Base#render.  Base#render sets up
+  # some standard information, and calculates the x,y coordinates of each data point.  The draw() method,
+  # which should have been overridden by the current instance, is then called.  The actual rendering of
+  # the graph takes place there.
+  #
+  # ====Create New Graph Types
+  #
+  # Assuming the information generated by Scruffy::Layers::Base is sufficient, you can create a new graph type
+  # simply by overriding the draw() method.  See Base#draw for arguments.
+  #
+  class Base
+    # The following attributes are user-definable at any time.
+    # title, points, relevant_data, preferred_color, options
+    attr_accessor :title
+    attr_accessor :points
+    attr_accessor :relevant_data
+    attr_accessor :preferred_color
+    attr_accessor :options          # On-the-fly values for easy customization / acts as attributes.
+    
+    # The following attributes are set during the layer's render process,
+    # and act more as a record of what just happened for later processes.
+    # height, width, min_value, max_value, color, opacity, complexity
+    attr_reader :height, :width
+    attr_reader :min_value, :max_value
+    attr_reader :color
+    attr_reader :opacity
+    attr_reader :complexity
+
+    # Returns a new Base object.
+    #
+    # Any options other that those specified below are stored in the @options variable for
+    # possible later use.  This would be a good place to store options needed for a custom
+    # graph.
+    #
+    # Options:
+    # title:: Name/title of data group
+    # points:: Array of data points
+    # preferred_color:: Color used to render this graph, overrides theme color.
+    # relevant_data:: Rarely used - indicates the data on this graph should not 
+    #                 included in any graph data aggregations, such as averaging data points.
+    # style:: SVG polyline style. (default: 'fill-opacity: 0; stroke-opacity: 0.35')
+    # stroke_width:: numeric value for width of line (0.1 - 10, default: 1)
+    # relativestroke:: stroke-width relative  to image size? true or false (default)
+    # shadow:: Display line shadow? true or false (default) 
+    # dots:: Display co-ord dots? true or false (default)
+    def initialize(options = {})
+      @title              = options.delete(:title) || ''
+      @preferred_color    = options.delete(:color)
+      @relevant_data      = options.delete(:relevant_data) || true
+      @points             = options.delete(:points) || []
+      @points.extend Scruffy::Helpers::PointContainer unless @points.kind_of? Scruffy::Helpers::PointContainer
+      
+      options[:stroke_width] ||= 1
+      options[:dots] ||= false
+      options[:shadow] ||= false
+      options[:style] ||= false
+      options[:relativestroke] ||= false
+      
+      @options            = options
+    end
+  
+    # Builds SVG code for this graph using the provided Builder object.
+    # This method actually generates data needed by this graph, then passes the
+    # rendering responsibilities to Base#draw.
+    #
+    # svg:: a Builder object used to create SVG code.
+    def render(svg, options = {})
+      setup_variables(options)
+      coords = generate_coordinates(options)
+    
+      draw(svg, coords, options)
+    end
+  
+    # The method called by Base#draw to render the graph.
+    # 
+    # svg:: a Builder object to use for creating SVG code.
+    # coords:: An array of coordinates relating to the graph's data points.  ie: [[100, 120], [200, 140], [300, 40]]
+    # options:: Optional arguments.
+    def draw(svg, coords, options={})
+      raise RenderError, "You must override the Base#draw method."
+    end
+  
+    # Returns a hash with information to be used by the legend.
+    #
+    # Alternatively, returns nil if you don't want this layer to be in the legend,
+    # or an array of hashes if this layer should have multiple legend entries (stacked?)
+    #
+    # By default, #legend_data returns nil automatically if relevant_data is set to false
+    # or the @color attribute is nil.  @color is set when the layer is rendered, so legends
+    # must be rendered AFTER layers.
+    def legend_data
+      if relevant_data? && @color
+        {:title => title, 
+         :color => @color,
+         :priority => :normal}
+      else
+        nil
+      end
+    end
+  
+    # Returns the value of relevant_data
+    def relevant_data?
+      @relevant_data
+    end
+
+    # The highest data point on this layer, or nil if relevant_data == false
+    def top_value
+      @relevant_data ? points.maximum_value : nil
+    end
+  
+    # The lowest data point on this layer, or nil if relevant_data == false
+    def bottom_value
+       @relevant_data ? points.minimum_value : nil
+    end
+
+    # The sum of all values
+    def sum_values
+      points.sum
+    end
+
+    protected
+      # Sets up several variables that almost every graph layer will need to render
+      # itself.
+      def setup_variables(options = {})
+        @color = (preferred_color || options.delete(:color))
+        @width, @height = options.delete(:size)
+        @min_value, @max_value = options[:min_value], options[:max_value]
+        @opacity = options[:opacity] || 1.0
+        @complexity = options[:complexity]
+      end
+
+      # Optimistic generation of coordinates for layer to use.  These coordinates are
+      # just a best guess, and can be overridden or thrown away (for example, this is overridden
+      # in pie charting and bar charts).
+      def generate_coordinates(options = {})
+        options[:point_distance] = width / (points.size - 1).to_f
+
+        points.inject_with_index([]) do |memo, point, idx|
+          x_coord = options[:point_distance] * idx
+
+          if point
+            relative_percent = ((point == min_value) ? 0 : ((point - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+  
+            memo << [x_coord, y_coord]
+          end
+          
+          memo
+        end
+      end
+    
+      # Converts a percentage into a pixel value, relative to the height.
+      #
+      # Example:
+      #   relative(5)   # On a 100px high layer, this returns 5.  200px high layer, this returns 10, etc.
+      def relative(pct)
+        # Default to Relative Height
+        relative_height(pct)
+      end
+
+      def relative_width(pct)
+        if pct # Added to handle nils
+          @width * (pct / 100.to_f)
+        end
+      end
+      
+      def relative_height(pct)
+        if pct # Added to handle nils
+          @height * (pct / 100.to_f)
+        end
+      end      
+
+      # Some SVG elements take a long string of multiple coordinates.  This is here
+      # to make that a little easier.
+      def stringify_coords(coords) # :nodoc:
+        coords.map { |c| c.join(',') }
+      end
+  end
+
+end # scruffy::layers

data/lib/scruffy/layers/line.rb

@@ -0,0 +1,46 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Line
+  #
+  # Author:: Brasten Sager
+  # Date:: August 7th, 2006
+  #
+  # Line graph.
+  class Line < Base
+    
+    # Renders line graph.
+    #
+    # Options:
+    # See initialize()
+    def draw(svg, coords, options={})
+      
+      # Include options provided when the object was created
+      options.merge!(@options)
+      
+      stroke_width = (options[:relativestroke]) ? relative(options[:stroke_width]) : options[:stroke_width]
+      style = (options[:style]) ? options[:style] : ''
+      
+      if options[:shadow]
+        svg.g(:class => 'shadow', :transform => "translate(#{relative(0.5)}, #{relative(0.5)})") {
+          svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'transparent', 
+                        :stroke => 'black', 'stroke-width' => stroke_width, 
+                        :style => 'fill-opacity: 0; stroke-opacity: 0.35' )
+          
+          if options[:dots]
+            coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last + relative(0.9), :r => stroke_width, 
+                                              :style => "stroke-width: #{stroke_width}; stroke: black; opacity: 0.35;" ) }
+          end
+        }
+      end
+    
+
+      svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', :stroke => @color.to_s, 
+                    'stroke-width' => stroke_width, :style => style  )
+      
+      if options[:dots]
+        coords.each { |coord| svg.circle( :cx => coord.first, :cy => coord.last, :r => stroke_width, 
+                                          :style => "stroke-width: #{stroke_width}; stroke: #{color.to_s}; fill: #{color.to_s}" ) }
+      end
+      
+    end
+  end
+end

data/lib/scruffy/layers/pie.rb

@@ -0,0 +1,123 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Pie
+  # 
+  # Author:: A.J. Ostman
+  # Date:: August 15, 2006
+  # 
+  # Provides a container for pie slice.
+  class Pie < Base
+    include Scruffy::Helpers::LayerContainer
+  
+    # Basic Example:
+    # 
+    #   graph = Scruffy::Graph.new
+    #   graph.title = "Snack Preference"
+    #   graph.renderer = Scruffy::Renderers::Pie.new
+    #   graph.add :pie, 'Example', {'Apples' => 90, 'Orange' => 60, 'Taco' => 30}
+    #
+    # Or, using a block to add slices:
+    # 
+    #     graph = Scruffy::Graph.new
+    #     graph.title = "Snack Preference"
+    #     graph.renderer = Scruffy::Renderers::Pie.new
+    #     graph.add :pie do |pie|
+    #       pie.add :pie_slice, 'Apple', [90]
+    #       pie.add :pie_slice, 'Orange', [60]
+    #       pie.add :pie_slice, 'Taco', [30]
+    #     end
+    # 
+    # Another Example:
+    #   graph.title = "Scruff-Pac!"
+    #   graph.renderer = Scruffy::Renderers::Pie.new
+    #   graph.add :pie, :diameter => 40, :degree_offset => 30 do |pie|
+    #     pie.add :pie_slice, '', [160], :preferred_color => "yellow", :shadow => true,
+    #             :shadow_x => -1, :shadow_y => 1, :shadow_color=>"black", :shadow_opacity => 0.4
+    #     pie.add :pie_slice, '', [50], :preferred_color => "green", :explode => 5, :diameter => 20,
+    #           :shadow => true, :shadow_x => -1, :shadow_y => 1, :shadow_color => "black", :shadow_opacity => 0.4
+    #   end
+    # 
+    #   graph.add :pie, :diameter => 3, :center_x => 48, :center_y=> 37, :degree_offset => 20 do |pie|
+    #     pie.add :pie_slice, '', [160], :preferred_color => "blue", :stroke => "black"
+    #   end
+    
+    
+    # Setup Constants
+    RADIANS = Math::PI/180
+
+    attr_accessor :diameter
+    attr_accessor :percent_used
+    attr_accessor :degree_offset
+    attr_accessor :scaler
+    attr_accessor :center_x, :center_y
+
+    
+    # The initialize method passes itself to the block, and since Pie is a
+    # LayerContainer, layers (pie slice) can be added just as if they were being
+    # added to Graph.
+    def initialize(options = {}, &block)
+      super(options)
+
+      # Allow for population of data with a block during initialization.
+      if block
+        block.call(self)
+      else
+        # Otherwise, just iterate over the points, adding the slices
+        if @points.class == Hash
+          @points.keys.each {|k|
+            self.add :pie_slice, k.to_s, [@points[k]]}
+        end
+        if @points.class == Array
+          @points.each {|v|
+            self.add :pie_slice, '', [v]}
+        end
+      end
+    end
+
+    
+    # Overrides Base#render to fiddle with layers' points to achieve a stacked
+    # effect.
+    def render(svg, options = {})
+      # #current_points = points.dup
+
+      @scaler = 1
+      total = 0
+      
+      layers.each do |layer|
+        total += layer.sum_values
+      end 
+      
+      @scaler = 100.0 / total
+      
+      @percent_used = 30
+      
+      layers.each do |layer|
+        layer_options = options.dup
+        layer_options = layer_options.merge(@options)
+        layer_options = layer_options.merge(layer.options)
+        layer_options[:scaler] = @scaler
+        layer_options[:percent_used] = @percent_used
+        @percent_used += @scaler * layer.sum_values
+        layer_options[:color] = layer.preferred_color || layer.color || options[:theme].next_color          
+        
+        layer.render(svg, layer_options)
+      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
+ 
+    def points=(val)
+      throw ArgumentsError, "Pie layers cannot accept points, only pie slices."
+    end
+  end
+end