scruffy 0.2.0 → 0.2.1

data/lib/scruffy/helpers.rb

@@ -1,2 +1,10 @@
+# ==Scruffy Helpers
+#
+# Author:: Brasten Sager
+# Date:: August 16th, 2006
+#
+# Modules which provide helper methods for various situations.
+module Scruffy::Helpers; end
+
 require 'scruffy/helpers/canvas'
 require 'scruffy/helpers/layer_container'

data/lib/scruffy/helpers/canvas.rb

@@ -1,22 +1,25 @@
-module Scruffy
-  module Helpers
-    
-    # Helper methods for objects that act as canvases/viewports/etc.
-    #
-    # Primarily used for calculating relative positions.
-    module Canvas
-      
-      protected
-        def bounds_for(canvas_size, position, size)
-          return nil if (position.nil? || size.nil?)
-          bounds = {}
-          bounds[:x] = canvas_size.first * (position.first / 100.to_f)
-          bounds[:y] = canvas_size.last  * (position.last  / 100.to_f)
-          bounds[:width] = canvas_size.first * (size.first / 100.to_f)
-          bounds[:height] = canvas_size.last * (size.last  / 100.to_f)
-          bounds
-        end
-
-    end
-  end
-end
+module Scruffy::Helpers
+  # ==Scruffy::Helpers::Canvas
+  #
+  # Author:: Brasten Sager
+  # Date:: August 16th, 2006
+  #
+  # Provides common methods for canvas objects.  Primarily used for providing spacial-type calculations
+  # where necessary.
+  module Canvas
+    protected
+      # Converts percentage values into actual pixe values based on the known render size.
+      #
+      # Returns a hash consisting of :x, :y, :width, and :height elements.
+      def bounds_for(canvas_size, position, size)
+        return nil if (position.nil? || size.nil?)
+        bounds = {}
+        bounds[:x] = canvas_size.first * (position.first / 100.to_f)
+        bounds[:y] = canvas_size.last  * (position.last  / 100.to_f)
+        bounds[:width] = canvas_size.first * (size.first / 100.to_f)
+        bounds[:height] = canvas_size.last * (size.last  / 100.to_f)
+        bounds
+      end
+  end # canvas
+  
+end # scruffy::helpers

data/lib/scruffy/helpers/layer_container.rb

@@ -1,4 +1,12 @@
 module Scruffy::Helpers
+  # ==Scruffy::Helpers::LayerContainer
+  #
+  # Author:: Brasten Sager
+  # Date:: August 16th, 2006
+  #
+  # Adds some common functionality to any object which needs to act as a
+  # container for graph layers.  The best example of this is the Scruffy::Graph
+  # object itself, but this module is also used by Scruffy::Layer::Stacked.
   module LayerContainer
     # Adds a Layer to the Graph/Container.  Accepts either a list of arguments used to build a new layer, or
     # a Scruffy::Layers::Base-derived object.  When passing a list of arguments, all arguments are optional, but the arguments
@@ -32,23 +40,33 @@ module Scruffy::Helpers
       end
       layer
     end
-
+    
     alias :add :<<
     
 
-    # Custom Layer Accessors
+    # Layer Writer
     def layers=(val)
       @layers = val
     end
+    
+    # Layer Reader
     def layers
       @layers ||= []
     end
     
+    # Returns the highest value in any of this container's layers.
+    #
+    # If padding is set to :padded, a 15% padding is added to the highest value.
     def top_value(padding=nil) # :nodoc:
       topval = layers.inject(0) { |max, layer| (max = ((max < layer.top_value) ? layer.top_value : max)) unless layer.top_value.nil?; max }
       padding == :padded ? (topval - ((topval - bottom_value) * 0.15)) : topval
     end
   
+    # Returns the lowest value in any of this container's layers.
+    #
+    # If padding is set to :padded, a 15% padding is added below the lowest value.
+    # If the lowest value is greater than zero, then the padding will not cross the zero line, preventing
+    # negative values from being introduced into the graph purely due to padding.
     def bottom_value(padding=nil) # :nodoc:
       botval = layers.inject(top_value) { |min, layer| (min = ((min > layer.bottom_value) ? layer.bottom_value : min)) unless layer.bottom_value.nil?; min }
       above_zero = (botval > 0)

data/lib/scruffy/layers.rb

@@ -1,4 +1,18 @@
-# Layer files
+# ==Scruffy::Layers
+#
+# Author:: Brasten Sager
+# Date:: August 10th, 2006
+#
+# See documentation in Scruffy::Layers::Base
+#
+module Scruffy::Layers
+
+  # Should be raised whenever a predictable error during rendering occurs,
+  # particularly if you do not want to terminate the graph rendering process.
+  class RenderError < StandardError; end
+  
+end
+
 require 'scruffy/layers/base'
 require 'scruffy/layers/area'
 require 'scruffy/layers/all_smiles'

data/lib/scruffy/layers/all_smiles.rb

@@ -1,113 +1,137 @@
-module Scruffy
-  module Layers
-    class AllSmiles < Base
-      attr_accessor :standalone
+module Scruffy::Layers
+  # ==Scruffy::Layers::AllSmiles
+  #
+  # Author:: Brasten Sager
+  # Date:: August 8th, 2006
+  #
+  # The AllSmiles graph consists of smiley faces for data points, with smiles or frowns depending upon
+  # their relative location on the graph.  The highest point is crowned with a wizard hat.  The Wizard
+  # Smiley eventually become 'Scruffy', our mascot.
+  #
+  # I don't know why.
+  #
+  # This graph only looks decent in SVG mode.  If you're rasterizing the graph with ImageMagick, you
+  # must use the :complexity => :minimal option on Graph#render.  This will make the graph look really
+  # nasty, but still better than if you try to rasterize with all the gradients in place.
+  class AllSmiles < Base
+    attr_accessor :standalone
+
+    # Returns a new AllSmiles graph.
+    #
+    # Options:
+    # standalone:: If set to true, dashed lines under smilies run vertically, like bar graphs.
+    #              If false (default), dashed lines run from smiley to smiley, like a line-graph.
+    def initialize(options = {})
+      super
+      @standalone = options[:standalone] || false
+    end
+  
+    # Renders graph.
+    def draw(svg, coords, options={})
     
-      def initialize(options = {})
-        super
-        @standalone = options[:standalone] || false
-      end
+      hero_smiley = nil
+      coords.each { |c| hero_smiley = c.last if (hero_smiley.nil? || c.last < hero_smiley) }
     
-      def draw(svg, coords, options={})
-      
-        hero_smiley = nil
-        coords.each { |c| hero_smiley = c.last if (hero_smiley.nil? || c.last < hero_smiley) }
-      
-        svg.defs {
-          svg.radialGradient(:id => 'SmileyGradient', :cx => '50%', 
-                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-              svg.stop(:offset => '0%', 'stop-color' => '#FFF')
-              svg.stop(:offset => '20%', 'stop-color' => '#FFC')
-              svg.stop(:offset => '45%', 'stop-color' => '#FF3')
-              svg.stop(:offset => '60%', 'stop-color' => '#FF0')
-              svg.stop(:offset => '90%', 'stop-color' => '#990')
-              svg.stop(:offset => '100%', 'stop-color' => '#220')
-          }
-          svg.radialGradient(:id => 'HeroGradient', :cx => '50%', 
-                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-              svg.stop(:offset => '0%', 'stop-color' => '#FEE')
-              svg.stop(:offset => '20%', 'stop-color' => '#F0E0C0')
-              svg.stop(:offset => '45%', 'stop-color' => '#8A2A1A')
-              svg.stop(:offset => '60%', 'stop-color' => '#821')
-              svg.stop(:offset => '90%', 'stop-color' => '#210')
-          }
-          svg.radialGradient(:id => 'StarGradient', :cx => '50%', 
-                             :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
-                             
-              svg.stop(:offset => '0%', 'stop-color' => '#FFF')
-              svg.stop(:offset => '20%', 'stop-color' => '#EFEFEF')
-              svg.stop(:offset => '45%', 'stop-color' => '#DDD')
-              svg.stop(:offset => '60%', 'stop-color' => '#BBB')
-              svg.stop(:offset => '90%', 'stop-color' => '#888')
-          }
+      svg.defs {
+        svg.radialGradient(:id => 'SmileyGradient', :cx => '50%', 
+                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                           
+            svg.stop(:offset => '0%', 'stop-color' => '#FFF')
+            svg.stop(:offset => '20%', 'stop-color' => '#FFC')
+            svg.stop(:offset => '45%', 'stop-color' => '#FF3')
+            svg.stop(:offset => '60%', 'stop-color' => '#FF0')
+            svg.stop(:offset => '90%', 'stop-color' => '#990')
+            svg.stop(:offset => '100%', 'stop-color' => '#220')
+        }
+        svg.radialGradient(:id => 'HeroGradient', :cx => '50%', 
+                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                           
+            svg.stop(:offset => '0%', 'stop-color' => '#FEE')
+            svg.stop(:offset => '20%', 'stop-color' => '#F0E0C0')
+            svg.stop(:offset => '45%', 'stop-color' => '#8A2A1A')
+            svg.stop(:offset => '60%', 'stop-color' => '#821')
+            svg.stop(:offset => '90%', 'stop-color' => '#210')
         }
-            
-        unless standalone
-          svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
+        svg.radialGradient(:id => 'StarGradient', :cx => '50%', 
+                           :cy => '50%', :r => '50%', :fx => '30%', :fy => '30%') {
+                           
+            svg.stop(:offset => '0%', 'stop-color' => '#FFF')
+            svg.stop(:offset => '20%', 'stop-color' => '#EFEFEF')
+            svg.stop(:offset => '45%', 'stop-color' => '#DDD')
+            svg.stop(:offset => '60%', 'stop-color' => '#BBB')
+            svg.stop(:offset => '90%', 'stop-color' => '#888')
+        }
+      }
+          
+      unless standalone
+        svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
+                      :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
+      end
+    
+      # Draw smilies.
+      coords.each do |coord|
+        if standalone
+          svg.line( :x1 => coord.first, :y1 => coord.last, :x2 => coord.first, :y2 => height, :fill => 'none', 
                         :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
         end
+        svg.circle( :cx => coord.first + scaled(2), :cy => coord.last + scaled(2), :r => scaled(15), 
+                    :fill => 'black', :stroke => 'none', :opacity => 0.4)
+        svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(15), 
+                    :fill => (complexity == :minimal ? 'yellow' : 'url(#SmileyGradient)'), :stroke => 'black', 'stroke-width' => scaled(1) )
+        svg.line( :x1 => (coord.first - scaled(3)), 
+                  :x2 => (coord.first - scaled(3)),
+                  :y1 => (coord.last),
+                  :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
+        svg.line( :x1 => (coord.first + scaled(3)), 
+                  :x2 => (coord.first + scaled(3)),
+                  :y1 => (coord.last),
+                  :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
+                
       
-        coords.each do |coord|
-          if standalone
-            svg.line( :x1 => coord.first, :y1 => coord.last, :x2 => coord.first, :y2 => height, :fill => 'none', 
-                          :stroke => '#660', 'stroke-width' => scaled(10), 'stroke-dasharray' => "#{scaled(10)}, #{scaled(10)}" )
-          end
-          svg.circle( :cx => coord.first + scaled(2), :cy => coord.last + scaled(2), :r => scaled(15), 
-                      :fill => 'black', :stroke => 'none', :opacity => 0.4)
-          svg.circle( :cx => coord.first, :cy => coord.last, :r => scaled(15), 
-                      :fill => (complexity == :minimal ? 'yellow' : 'url(#SmileyGradient)'), :stroke => 'black', 'stroke-width' => scaled(1) )
-          svg.line( :x1 => (coord.first - scaled(3)), 
-                    :x2 => (coord.first - scaled(3)),
-                    :y1 => (coord.last),
-                    :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-          svg.line( :x1 => (coord.first + scaled(3)), 
-                    :x2 => (coord.first + scaled(3)),
-                    :y1 => (coord.last),
-                    :y2 => (coord.last  - scaled(7)), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-                  
+        # Some minor mathematics for the smile/frown
+        percent = 1.0 - (coord.last.to_f / height.to_f)
+        corners = scaled(8 - (5 * percent))
+        anchor  = scaled((20 * percent) - 5)
         
-          percent = 1.0 - (coord.last.to_f / height.to_f)
+        # Draw the mouth
+        svg.path( :d => "M#{coord.first - scaled(9)} #{coord.last + corners} Q#{coord.first} #{coord.last + anchor} #{coord.first + scaled(9)} #{coord.last + corners}",
+                  :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => 'none' )
+                
+                
+        # Wizard hat for hero smiley.
+        if coord.last == hero_smiley
+          svg.ellipse(:cx => coord.first, :cy => (coord.last - scaled(13)), 
+                      :rx => scaled(17), :ry => scaled(6.5), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'), :stroke => 'black', 'stroke-width' => scaled(1.4) )
         
-          corners = scaled(8 - (5 * percent))
-          anchor  = scaled((20 * percent) - 5)
-          svg.path( :d => "M#{coord.first - scaled(9)} #{coord.last + corners} Q#{coord.first} #{coord.last + anchor} #{coord.first + scaled(9)} #{coord.last + corners}",
-                    :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => 'none' )
-                  
-                  
-          # top hat
-          if coord.last == hero_smiley
-            svg.ellipse(:cx => coord.first, :cy => (coord.last - scaled(13)), 
-                        :rx => scaled(17), :ry => scaled(6.5), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'), :stroke => 'black', 'stroke-width' => scaled(1.4) )
-          
-            svg.path(:d => "M#{coord.first} #{coord.last - scaled(60)} " +
-                           "L#{coord.first + scaled(10)} #{coord.last - scaled(14)} " +
-                           "C#{coord.first + scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(14)}" +
-                           "L#{coord.first} #{coord.last - scaled(60)}",
-                      :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'))
-
-            svg.path(:d =>  "M#{coord.first - scaled(4)} #{coord.last - scaled(23)}" +
-                            "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-            svg.path(:d =>  "M#{coord.first + scaled(2)} #{coord.last - scaled(30)}" +
-                            "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-            svg.path(:d =>  "M#{coord.first - scaled(2)} #{coord.last - scaled(33)}" +
-                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => 'white' )
-            svg.path(:d =>  "M#{coord.first - scaled(2.2)} #{coord.last - scaled(32.7)}" +
-                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-            svg.path(:d =>  "M#{coord.first + scaled(4.5)} #{coord.last - scaled(20)}" +
-                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
-            svg.path(:d =>  "M#{coord.first} #{coord.last - scaled(40)}" +
-                            "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+          svg.path(:d => "M#{coord.first} #{coord.last - scaled(60)} " +
+                         "L#{coord.first + scaled(10)} #{coord.last - scaled(14)} " +
+                         "C#{coord.first + scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(9)} #{coord.first - scaled(10)},#{coord.last - scaled(14)}" +
+                         "L#{coord.first} #{coord.last - scaled(60)}",
+                    :stroke => 'black', 'stroke-width' => scaled(1.4), :fill => (complexity == :minimal ? 'purple' : 'url(#HeroGradient)'))
 
-          end
+          svg.path(:d =>  "M#{coord.first - scaled(4)} #{coord.last - scaled(23)}" +
+                          "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+          svg.path(:d =>  "M#{coord.first + scaled(2)} #{coord.last - scaled(30)}" +
+                          "l-#{scaled(2.5)} #{scaled(10)} l#{scaled(7.5)} -#{scaled(5)} l-#{scaled(10)} 0 l#{scaled(7.5)} #{scaled(5)} l-#{scaled(2.5)} -#{scaled(10)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+          svg.path(:d =>  "M#{coord.first - scaled(2)} #{coord.last - scaled(33)}" +
+                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => 'white' )
+          svg.path(:d =>  "M#{coord.first - scaled(2.2)} #{coord.last - scaled(32.7)}" +
+                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+          svg.path(:d =>  "M#{coord.first + scaled(4.5)} #{coord.last - scaled(20)}" +
+                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
+          svg.path(:d =>  "M#{coord.first} #{coord.last - scaled(40)}" +
+                          "l-#{scaled(1.25)} #{scaled(5)} l#{scaled(3.75)} -#{scaled(2.5)} l-#{scaled(5)} 0 l#{scaled(3.75)} #{scaled(2.5)} l-#{scaled(1.25)} -#{scaled(5)}", :stroke => 'none', :fill => (complexity == :minimal ? 'white': 'url(#StarGradient)') )
 
         end
-      end
 
-      def scaled(pt)
-        relative(pt) / 2
       end
     end
+
+    # Legacy (4 days old).  Removed scaled from layout engine, 
+    # changed to #relative, with different math involved.
+    # Translate here so I don't have to entirely redo this graph.
+    def scaled(pt)
+      relative(pt) / 2
+    end
   end
 end

data/lib/scruffy/layers/area.rb

@@ -1,35 +1,43 @@
-module Scruffy
-  module Layers
-    class Area < Base
-      def draw(svg, coords, options={})
-        points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
+module Scruffy::Layers
+  # ==Scruffy::Layers::Area
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard area graph.
+  class Area < Base
+    
+    # Render area graph.
+    def draw(svg, coords, options={})
+      # svg.polygon wants a long string of coords. 
+      points_value = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
 
-        # Experimental, for later user.
-        # Neither ImageMagick nor Mozilla SVG render this well (at all).  Maybe a future thing.
-        #
-        # svg.defs {
-        #   svg.filter(:id => 'MyFilter', :filterUnits => 'userSpaceOnUse', :x => 0, :y => 0, :width => 200, :height => '120') {
-        #     svg.feGaussianBlur(:in => 'SourceAlpha', :stdDeviation => 4, :result => 'blur')
-        #     svg.feOffset(:in => 'blur', :dx => 4, :dy => 4, :result => 'offsetBlur')
-        #     svg.feSpecularLighting( :in => 'blur', :surfaceScale => 5, :specularConstant => '.75',
-        #                             :specularExponent => 20, 'lighting-color' => '#bbbbbb',
-        #                             :result => 'specOut') {
-        #       svg.fePointLight(:x => '-5000', :y => '-10000', :z => '20000')
-        #     }
-        #     
-        #     svg.feComposite(:in => 'specOut', :in2 => 'SourceAlpha', :operator => 'in', :result => 'specOut')
-        #     svg.feComposite(:in => 'sourceGraphic', :in2 => 'specOut', :operator => 'arithmetic',
-        #                     :k1 => 0, :k2 => 1, :k3 => 1, :k4 => 0, :result => 'litPaint')
-        #                     
-        #     svg.feMerge {
-        #       svg.feMergeNode(:in => 'offsetBlur')
-        #       svg.feMergeNode(:in => 'litPaint')
-        #     }
-        #   }
-        # }
+      # Experimental, for later user.
+      # This was supposed to add some fun filters, 3d effects and whatnot.
+      # Neither ImageMagick nor Mozilla SVG render this well (at all).  Maybe a future thing.
+      #
+      # svg.defs {
+      #   svg.filter(:id => 'MyFilter', :filterUnits => 'userSpaceOnUse', :x => 0, :y => 0, :width => 200, :height => '120') {
+      #     svg.feGaussianBlur(:in => 'SourceAlpha', :stdDeviation => 4, :result => 'blur')
+      #     svg.feOffset(:in => 'blur', :dx => 4, :dy => 4, :result => 'offsetBlur')
+      #     svg.feSpecularLighting( :in => 'blur', :surfaceScale => 5, :specularConstant => '.75',
+      #                             :specularExponent => 20, 'lighting-color' => '#bbbbbb',
+      #                             :result => 'specOut') {
+      #       svg.fePointLight(:x => '-5000', :y => '-10000', :z => '20000')
+      #     }
+      #     
+      #     svg.feComposite(:in => 'specOut', :in2 => 'SourceAlpha', :operator => 'in', :result => 'specOut')
+      #     svg.feComposite(:in => 'sourceGraphic', :in2 => 'specOut', :operator => 'arithmetic',
+      #                     :k1 => 0, :k2 => 1, :k3 => 1, :k4 => 0, :result => 'litPaint')
+      #                     
+      #     svg.feMerge {
+      #       svg.feMergeNode(:in => 'offsetBlur')
+      #       svg.feMergeNode(:in => 'litPaint')
+      #     }
+      #   }
+      # }
 
-        svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}")
-      end
+      svg.polygon(:points => points_value, :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}")
     end
   end
 end

data/lib/scruffy/layers/average.rb

@@ -1,45 +1,62 @@
-module Scruffy
-  module Layers
-    class Average < Base
-      def initialize(options = {})
-        super(options.merge({:relevant_data => false}))
-      end
+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
+    
+    # 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}))
+    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 = points.find { |layer| layer.relevant_data? }
       
-      def draw(svg, coords, options = {})
-        svg.polyline( :points => coords.join(' '), :fill => 'none', :stroke => 'black',
-                      'stroke-width' => relative(5), 'opacity' => '0.4')
-      end
+        options[:point_distance] = width / (key_layer.points.size - 1).to_f
 
-      protected
-        def generate_coordinates(options = {})
-          key_layer = points.find { |layer| layer.relevant_data? }
-        
-          options[:point_distance] = width / (key_layer.points.size - 1).to_f
-
-          coords = []
-
-          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
+        coords = []
 
-            average = sum / objects.to_f
+        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
 
-            x_coord = options[:point_distance] * idx
+          average = sum / objects.to_f
 
-            relative_percent = ((average == min_value) ? 0 : ((average - min_value) / (max_value - min_value).to_f))
-            y_coord = (height - (height * relative_percent))
+          x_coord = options[:point_distance] * idx
 
-            coords << [x_coord, y_coord].join(',')
-          end
+          relative_percent = ((average == min_value) ? 0 : ((average - min_value) / (max_value - min_value).to_f))
+          y_coord = (height - (height * relative_percent))
 
-          return coords
+          coords << [x_coord, y_coord].join(',')
         end
-    
-    end
+
+        return coords
+      end
+  
   end
 end