scruffy 0.2.6 → 0.3.0.beta1

data/lib/scruffy/layers/base.rb

@@ -26,6 +26,7 @@ module Scruffy::Layers
     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,
@@ -34,6 +35,7 @@ module Scruffy::Layers
     attr_reader :height, :width
     attr_reader :min_value, :max_value
     attr_reader :color
+    attr_reader :outline
     attr_reader :opacity
     attr_reader :complexity
 
@@ -47,39 +49,53 @@ module Scruffy::Layers
     # 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(:preferred_color)
+      @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 = {})
+    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,
@@ -90,14 +106,14 @@ module Scruffy::Layers
     # must be rendered AFTER layers.
     def legend_data
       if relevant_data? && @color
-        {:title => title, 
+        {:title => title,
          :color => @color,
          :priority => :normal}
       else
         nil
       end
     end
-  
+
     # Returns the value of relevant_data
     def relevant_data?
       @relevant_data
@@ -107,12 +123,22 @@ module Scruffy::Layers
     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
@@ -123,6 +149,7 @@ module Scruffy::Layers
       # 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
@@ -132,21 +159,24 @@ module Scruffy::Layers
       # 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 = {})
-        options[:point_distance] = width / (points.size - 1).to_f
+        dy = height.to_f / (options[:max_value] - options[:min_value])
+        dx = width.to_f / (options[:max_key] - options[:min_key] + 1)
 
-        points.inject_with_index([]) do |memo, point, idx|
-          x_coord = options[:point_distance] * idx
+        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])
 
-          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]
+            ret << [x_coord, height - y_coord]
           end
-          
-          memo
         end
+        return ret
       end
     
       # Converts a percentage into a pixel value, relative to the height.

data/lib/scruffy/layers/box.rb

@@ -0,0 +1,114 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Box
+  #
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard bar graph.  
+  class Box < Base
+  
+    # Draw box plot.
+    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.line(:x1=>x+@bar_width/2,:x2=>x+@bar_width/2,:y1=>y[0],:y2=>y[4], :style => "stroke:#{(outline.to_s || options[:theme].marker || 'white').to_s}; stroke-width:1")
+        svg.line(:x1=>x+@bar_width/4,:x2=>x+@bar_width/4*3,:y1=>y[0],:y2=>y[0], :style => "stroke:#{(outline.to_s || options[:theme].marker || 'white').to_s}; stroke-width:1")
+        svg.line(:x1=>x+@bar_width/4,:x2=>x+@bar_width/4*3,:y1=>y[4],:y2=>y[4], :style => "stroke:#{(outline.to_s || options[:theme].marker || 'white').to_s}; stroke-width:1")
+        svg.rect( :x => x, :y => y[1], :width => @bar_width, :height => (y[1]-y[3])*-1, 
+                  :fill => color.to_s, 'style' => "opacity: #{opacity}; stroke:#{(outline.to_s || options[:theme].marker || 'white').to_s}; stroke-width:1;" )
+        svg.line(:x1=>x,:x2=>x+@bar_width,:y1=>y[2],:y2=>y[2], :style => "stroke:#{(outline.to_s || options[:theme].marker || 'white').to_s}; stroke-width:1")
+        #svg.rect( :x => x, :y => y, :width => @bar_width, :height => bar_height, 
+        #          :fill => color.to_s, 'style' => "opacity: #{opacity}; stroke: none;" )
+      end
+    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 = points[0].max
+      points.each do |point_set|
+        topval = ( (topval < point_set.max) ? point_set.max : topval )
+      end
+      #topval = layers.inject(0) { |max, layer| (max = ((max < layer.top_value) ? layer.top_value : max)) unless layer.top_value.nil?; max }
+      below_zero = (topval <= 0)
+      topval = padding == :padded ? (topval + ((topval - bottom_value(nil)) * 0.15)) : topval
+      (below_zero && topval > 0) ? 0 : 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 = points[0].min
+      points.each do |point_set|
+        botval = ( (botval>point_set.min) ? point_set.min : botval )
+      end
+      #botval = layers.inject(0) do |min, layer| 
+      #  (min = ((min > layer.bottom_value) ? layer.bottom_value : min)) unless layer.bottom_value.nil?
+      #  min 
+      #end
+      above_zero = (botval >= 0)
+      botval = (botval - ((top_value(nil) - botval) * 0.15)) if padding == :padded
+    
+      # Don't introduce negative values solely due to padding.
+      # A user-provided value must be negative before padding will extend into negative values.
+      (above_zero && botval < 0) ? 0 : botval
+    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)
+          y_coords = []
+          points[idx].each do |point| 
+            relative_percent = ((point == min_value) ? 0 : ((point - min_value) / (max_value - min_value).to_f))
+            y_coord = (height - (height * relative_percent))
+            y_coords << y_coord
+          end
+          [x_coord, y_coords]
+        end
+        coords
+      end
+  end
+end

data/lib/scruffy/layers/line.rb

@@ -8,22 +8,39 @@ module Scruffy::Layers
   class Line < Base
     
     # Renders line graph.
+    #
+    # Options:
+    # See initialize()
     def draw(svg, coords, options={})
-      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' => relative(2), 
-                      :style => 'fill-opacity: 0; stroke-opacity: 0.35' )
-
-        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;" ) }
-      }
-
-
-      svg.polyline( :points => stringify_coords(coords).join(' '), :fill => 'none', 
-                    :stroke => color.to_s, 'stroke-width' => relative(2) )
+      
+      # 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
+    
 
-      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}" ) }
+      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/multi.rb

@@ -0,0 +1,74 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::Multi
+  #
+  # Author:: Jeremy Green
+  # Date:: July 29th, 2009
+  #
+  # Based on:: Scruffy::Layers::Stacked by
+  # Author:: Brasten Sager
+  # Date:: August 12th, 2006
+  #
+  # Provides a generic way for displaying multiple bar graphs side by side.  
+  class Multi < Base
+    include Scruffy::Helpers::LayerContainer
+    
+    # Returns new Multi graph.
+    #
+    # You can provide a block for easily adding layers during (just after) initialization.
+    # Example:
+    #   Multi.new do |multi|
+    #     multi << Scruffy::Layers::Line.new( ... )
+    #     multi.add(:multi_bar, 'My Bar', [...])
+    #   end
+    #
+    # The initialize method passes itself to the block, and since multi 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 multi effect.
+    def render(svg, options = {})
+      #TODO ensure this works with new points
+      #current_points = points
+      layers.each_with_index do |layer,i|
+        
+        #real_points = layer.points
+        #layer.points = current_points
+        layer_options = options.dup
+ 
+        layer_options[:num_bars] = layers.size
+        layer_options[:position] = i
+        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 multi 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=(val)
+      throw ArgumentsError, "Multi layers cannot accept points, only other layers."
+    end
+  end
+end

data/lib/scruffy/layers/multi_area.rb

@@ -0,0 +1,119 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::MulitArea
+  #
+  # Author:: Martyn Taylor
+  # Date:: July 30th 2010
+  #
+  # Multi Area graph.
+
+  class MultiArea < Base
+
+    attr_accessor :baselines
+    attr_accessor :area_colors
+
+    def initialize(options = {}, &block)
+      super(options)
+      @area_colors = options[:area_colors] ? options[:area_colors] : nil
+      @baselines = options[:baselines] ? options[:baselines] : nil
+    end
+
+    # Render Multi Area graph.
+    def draw(svg, coords, options={})
+      # Check whether to use color from theme, or whether to use user defined colors from the area_colors array
+      color_count = nil
+      if @area_colors && @area_colors.size > 0
+        area_color = @area_colors[0]
+        color_count = 1
+      else
+        puts "Never Set Area Color"
+        area_color = color
+      end
+
+      # Draw Bottom Level Polygons (Original Coords)
+      draw_poly(svg, coords, area_color, options = {})
+
+      # Draw Lower Area Polygons
+      if @baselines
+        # Get the Color of this Area
+        puts "Drawing Baselines"
+        @baselines.sort! {|x,y| y <=> x }
+        @baselines.each do |baseline|
+          if color_count
+            area_color = area_colors[color_count]
+            color_count = color_count + 1
+            puts area_color.to_s
+            if color_count >= area_colors.size
+              color_count = 0
+            end
+          end
+
+          lower_poly_coords = create_lower_polygon_coords(translate_number(baseline), coords, options)
+          draw_poly(svg, lower_poly_coords, area_color, options = {})
+        end
+      end
+    end
+
+    private
+    def draw_poly(svg, coords, color, options={})
+      points_value1 = "0,#{height} #{stringify_coords(coords).join(' ')} #{width},#{height}"
+      svg.polygon(:points => points_value1, :fill => color.to_s, :stroke => color.to_s, 'style' => "opacity: #{opacity}")
+    end
+
+    def calculate_intersection(baseline, point1, point2)
+      x1 = point1[0]
+      y1 = point1[1]
+      x2 = point2[0]
+      y2 = point2[1]
+
+      # Check whether baseline intersects with the two point line from these coords
+      if ((y2 >= baseline) && (y1 <= baseline)) || ((y1 >= baseline) && (y2 <= baseline))
+        # Calculate point of intersection
+        y = baseline.to_f
+        m = (y2.to_f - y1.to_f) / (x2.to_f - x1.to_f)
+        c = y1.to_f
+
+        x = (y.to_f - c.to_f) / m.to_f
+        return [x + x1, y]
+      elsif (y2 <= baseline) && (y1 <= baseline)
+        return nil
+      else
+        return [x2, y2]
+      end
+    end
+
+
+    def create_lower_polygon_coords(baseline, coords, options={})
+      lower_poly_coords = []
+      if coords[0][1] <= baseline
+        lower_poly_coords << [coords[0][0], baseline]
+      else
+        lower_poly_coords << coords[0]
+      end
+
+      coords.each_index do |index|
+        if index + 1 < coords.size
+          poi = calculate_intersection(baseline, coords[index], coords[index + 1])
+          if poi
+            lower_poly_coords << poi
+            if(coords[index + 1][1] > baseline)
+              lower_poly_coords << coords[index + 1]
+            end
+          end
+        end
+      end
+
+      if coords.last[1] <= baseline
+        lower_poly_coords << [coords.last[0], baseline]
+      else
+        lower_poly_coords << coords.last
+      end
+
+      return lower_poly_coords
+    end
+
+    def translate_number(baseline)
+      relative_percent = ((baseline == min_value) ? 0 : ((baseline.to_f - min_value.to_f) / (max_value.to_f - min_value.to_f).to_f))
+      return (height.to_f - (height.to_f * relative_percent))
+    end
+  end
+end