willbryant-scruffy 0.2.16

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

@@ -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/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_bar.rb

@@ -0,0 +1,51 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::MultiBar
+  #
+  # Author:: Jeremy Green
+  # Date:: July 29th, 2009
+  #
+  # Based on:: Scruffy::Layers::Bar by
+  # Author:: Brasten Sager
+  # Date:: August 6th, 2006
+  #
+  # Standard multi_bar graph.  
+  class MultiBar < Bar
+  
+    
+
+    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 = {})
+        @point_width = (width / points.size)
+        @point_space = @point_width * 0.1
+        @point_width = @point_width - @point_space
+        @bar_width = @point_width/options[:num_bars]
+        @bar_space = @bar_width * 0.1
+        @bar_width = @bar_width * 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 = (@point_width * idx) + @point_space/2 + @point_space*idx + @bar_width * options[:position] +   @bar_space*(options[:position].to_f - 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/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

data/lib/scruffy/layers/pie_slice.rb

@@ -0,0 +1,119 @@
+module Scruffy::Layers
+  # ==Scruffy::Layers::PieSlice
+  # 
+  # Author:: A.J. Ostman
+  # Date:: August 14th, 2006
+  # 
+  # Basic Pie Chart Slice..
+    
+  class PieSlice < Base
+  
+    # Setup Constants
+    RADIANS = Math::PI / 180 
+    MARKER_OFFSET_RATIO = 1.2
+    MARKER_FONT_SIZE = 6
+    
+    attr_accessor :diameter
+    attr_accessor :percent_used
+    attr_accessor :degree_offset
+    attr_accessor :scaler
+    attr_accessor :center_x, :center_y
+    
+    def draw(svg, coords, options = {})
+      # Scaler is the multiplier to normalize the values to a percentage across
+      # the Pie Chart
+      @scaler = options[:scaler] || 1
+      
+      # Degree Offset is degrees by which the pie chart is twisted when it
+      # begins
+      @degree_offset = options[:degree_offset] || @options[:degree_offset] || 0
+      
+      # Percent Used keeps track of where in the pie chart we are
+      @percent_used = options[:percent_used] || @options[:percent_used] || 0
+      
+      # Diameter of the pie chart defaults to 80% of the height
+      @diameter = relative(options[:diameter]) || relative(@options[:diameter]) || relative(80.0)
+      
+      # Stroke
+      stroke = options[:stroke] || @options[:stroke] || "none"
+
+      # Shadow
+      shadow = options[:shadow] || @options[:shadow_] || false
+      shadow_x = relative(options[:shadow_x]) || relative(@options[:shadow_x]) || relative(-0.5)
+      shadow_y = relative(options[:shadow_y]) || relative(@options[:shadow_y]) || relative(0.5)
+      shadow_color = options[:shadow_color] || @options[:shadow_color] || "white"
+      shadow_opacity = options[:shadow_opacity] || @options[:shadow_opacity] || 0.06
+      
+      # Coordinates for the center of the pie chart.
+      @center_x = relative_width(options[:center_x]) || relative_width(@options[:center_x]) || relative_width(50)
+      @center_y = relative_height(options[:center_y]) || relative_height(@options[:center_y]) || relative_height(50)
+      radius = @diameter / 2.0
+      
+      # Graphing calculated using percent of graph. We later multiply by 3.6 to
+      # convert to 360 degree system.
+      percent = @scaler * sum_values
+      
+
+      # Calculate the Radian Start Point
+      radians_start = ((@percent_used * 3.6) + @degree_offset) * RADIANS
+      # Calculate the Radian End Point
+      radians_end = ((@percent_used + percent) * 3.6 + @degree_offset) * RADIANS
+
+      radians_mid_point = radians_start + ((radians_end - radians_start) / 2)
+      
+      if options[:explode]
+        @center_x = @center_x + (Math.sin(radians_mid_point) * relative(options[:explode]))
+        @center_y = @center_y - (Math.cos(radians_mid_point) * relative(options[:explode]))
+      end
+  
+
+      # Calculate the beginning coordinates
+      x_start = @center_x + (Math.sin(radians_start) * radius)
+      y_start = @center_y - (Math.cos(radians_start) * radius)
+      
+      # Calculate the End Coords
+      x_end = @center_x + (Math.sin(radians_end) * radius)
+      y_end = @center_y - (Math.cos(radians_end) * radius)
+
+      
+
+      # If percentage is really really close to 100% then draw a circle instead!
+      if percent >= 99.9999
+        
+        if shadow
+          svg.circle(:cx => "#{@center_x + shadow_x}", :cy => "#{@center_y + shadow_y}", :r=>"#{radius}",:stroke => "none", 
+            :fill => shadow_color.to_s,  :style => "fill-opacity: #{shadow_opacity.to_s};")
+        end
+        
+        svg.circle(:cx => "#{@center_x}", :cy => "#{@center_y}", :r=>"#{radius}",:stroke => stroke, :fill => color.to_s)
+
+      else  
+        if shadow
+          svg.path(:d =>  "M#{@center_x + shadow_x},#{@center_y + shadow_y} L#{x_start + shadow_x},#{y_start + shadow_y} A#{radius},#{radius} 0, #{percent >= 50 ? '1' : '0'}, 1, #{x_end + shadow_x} #{y_end + shadow_y} Z", 
+            :fill => shadow_color.to_s, :style => "fill-opacity: #{shadow_opacity.to_s};")
+        end
+        
+        svg.path(:d =>  "M#{@center_x},#{@center_y} L#{x_start},#{y_start} A#{radius},#{radius} 0, #{percent >= 50 ? '1' : '0'}, 1, #{x_end} #{y_end} Z", 
+          :stroke => stroke, :fill => color.to_s)
+      end
+      
+      text_x = @center_x + (Math.sin(radians_mid_point) * radius * MARKER_OFFSET_RATIO)
+      text_y = @center_y - (Math.cos(radians_mid_point) * radius * MARKER_OFFSET_RATIO)
+
+      svg.text("#{sprintf('%d', percent)}%",
+        :x => text_x,
+        :y => text_y + relative(MARKER_FONT_SIZE / 2), 
+        'font-size' => relative(MARKER_FONT_SIZE),
+        'font-family' => options[:theme].font_family,
+        :fill => (options[:theme].marker || 'black').to_s, 
+        'text-anchor' => 'middle')
+    end
+
+    protected
+    def generate_coordinates(options = {})
+      # Coordinate Generation didn't make much sense here. Overridden just
+      # because Brasten said this would be overridden.
+    end
+  end
+  
+end