willbryant-scruffy 0.2.16

data/lib/scruffy/layers.rb

@@ -0,0 +1,28 @@
+# ==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'
+require 'scruffy/layers/bar'
+require 'scruffy/layers/box'
+require 'scruffy/layers/line'
+require 'scruffy/layers/average'
+require 'scruffy/layers/stacked'
+require 'scruffy/layers/multi'
+require 'scruffy/layers/multi_bar'
+require 'scruffy/layers/pie'
+require 'scruffy/layers/pie_slice'
+require 'scruffy/layers/scatter'

data/lib/scruffy/layers/all_smiles.rb

@@ -0,0 +1,137 @@
+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={})
+    
+      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')
+        }
+      }
+          
+      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) )
+                
+      
+        # 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)
+        
+        # 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) )
+        
+          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)') )
+
+        end
+
+      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

@@ -0,0 +1,46 @@
+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.
+      # 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.g(:transform => "translate(0, -#{relative(2)})") {
+        svg.polygon(:points => points_value, :style => "fill: black; stroke: black; fill-opacity: 0.06; stroke-opacity: 0.06;")
+      }
+
+      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

@@ -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,68 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Bar
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard bar graph.  
+  class Bar < Base
+  
+    # Draw bar graph.
+    # Now handles positive and negative values gracefully.
+    def draw(svg, coords, options = {})
+      coords.each_with_index do |coord,idx|
+        x, y, bar_height = (coord.first), coord.last, 1#(height - coord.last)
+        
+          valh = max_value + min_value * -1 #value_height
+          maxh = max_value * height / valh #positive area height
+          minh = min_value * height / valh #negative area height
+          #puts "height = #{height} and max_value = #{max_value} and min_value = #{min_value} and y = #{y} and point = #{points[idx]}"
+          if points[idx] > 0
+            bar_height = points[idx]*maxh/max_value
+          else
+            bar_height = points[idx]*minh/min_value
+          end
+        
+        #puts " y = #{y} and point = #{points[idx]}"  
+        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?
+      #
+      # Update : x-axis coords for lines and area charts should now line
+      # up with the center of bar charts.
+      
+      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) - (@bar_width * 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,211 @@
+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 :preferred_outline
+    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 :outline
+    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.
+    # preferred_outline:: Color used to render this graph outline, overrides theme outline.
+    # 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)
+      @preferred_outline    = options.delete(:outline)
+      @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 highest data point on this layer, or nil if relevant_data == false
+    def bottom_key
+      @relevant_data ? points.minimum_key : nil
+    end
+  
+    # The lowest data point on this layer, or nil if relevant_data == false
+    def top_key
+       @relevant_data ? points.maximum_key : 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))
+        @outline = (preferred_outline || options.delete(:outline))
+        @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).
+      
+      # Updated : Assuming n number of points, the graph is divided into n rectangles
+      # and the points are plotted in the middle of each rectangle.  This allows bars to 
+      # play nice with lines.
+      def generate_coordinates(options = {})
+        
+        dy = height.to_f / (options[:max_value] - options[:min_value]) 
+        dx = width.to_f / (options[:max_key] - options[:min_key] + 1)
+
+        ret = []
+        points.each_point do |x, y|
+          if y
+            x_coord = dx * (x - options[:min_key]) + dx/2
+            y_coord = dy * (y - options[:min_value])
+
+            ret << [x_coord, height - y_coord]
+          end
+        end
+        return ret
+      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