gerbilcharts 0.0.3

data/lib/gerbilcharts/charts/impulse_chart.rb

@@ -0,0 +1,30 @@
+module GerbilCharts::Charts
+
+# =Impulse Chart
+#
+# Each data point is represented by a thin line whose height is proportional to the value.
+class ImpulseChart < ChartBase
+
+  def initialize(opt={})
+    super(opt)
+  end
+  
+  def create_chart_elements
+    
+    # other elements
+    @thechart.add_child(GerbilCharts::Surfaces::SurfaceBackground.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::BasicGrid.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::TitlePanel.new(:orient => ORIENT_OVERLAY, :dim => 30))
+    @thechart.add_child(GerbilCharts::Surfaces::ImpulseSurface.new(:orient => ORIENT_OVERLAY),:anchor => true)
+    @thechart.add_child(GerbilCharts::Surfaces::Legend.new(:orient=> ORIENT_OVERLAY, :dim => 100))  
+    @thechart.add_child(GerbilCharts::Surfaces::VerticalAxis.new(:orient => ORIENT_WEST, :dim => 40 ))
+    @thechart.add_child(GerbilCharts::Surfaces::HorizontalTimeAxis.new(:orient => ORIENT_SOUTH, :dim => 25 ))
+    
+    # optional features
+    if @feature_timetracker
+        @thechart.add_child(GerbilCharts::Surfaces::Tracker.new(:orient => ORIENT_SOUTH, :dim => 10 ))
+    end
+  end  
+end
+
+end

data/lib/gerbilcharts/charts/line_chart.rb

@@ -0,0 +1,35 @@
+module GerbilCharts::Charts
+
+# =Line Chart
+# Each model is a separate line.
+#
+# options
+#
+# [+width+]			Width of the chart (pixels)
+# [+height+]		Width of the chart (pixels)
+# [+style+]			Stylesheet file to be applied
+#
+# global visual options
+# [+circle_data_points]	  draw a solid circle around each data point  
+#
+class LineChart < ChartBase
+
+
+  def initialize(opt={})
+    super(opt)
+  end
+  
+  def create_chart_elements
+    
+    # other elements
+    @thechart.add_child(GerbilCharts::Surfaces::SurfaceBackground.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::BasicGrid.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::TitlePanel.new(:orient => ORIENT_OVERLAY, :dim => 30))
+    @thechart.add_child(GerbilCharts::Surfaces::LineSurface.new(:orient => ORIENT_OVERLAY),:anchor => true)
+    @thechart.add_child(GerbilCharts::Surfaces::Legend.new(:orient=> ORIENT_OVERLAY, :dim => 100))  
+    @thechart.add_child(GerbilCharts::Surfaces::VerticalAxis.new(:orient => ORIENT_WEST, :dim => 30 ))
+    @thechart.add_child(GerbilCharts::Surfaces::HorizontalTimeAxis.new(:orient => ORIENT_SOUTH, :dim => 25 ))
+  end
+end
+
+end

data/lib/gerbilcharts/charts/stacked_area_chart.rb

@@ -0,0 +1,31 @@
+module GerbilCharts::Charts
+
+# = StackedAreaChart
+# The models are stacked on top of each other !
+#
+class StackedAreaChart < ChartBase
+
+  def initialize(opt={})
+    super(opt)
+  end
+  
+  def create_chart_elements
+    
+    # other elements
+    @thechart.add_child(GerbilCharts::Surfaces::SurfaceBackground.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::StackedGrid.new(:orient => ORIENT_OVERLAY))
+    @thechart.add_child(GerbilCharts::Surfaces::TitlePanel.new(:orient => ORIENT_OVERLAY, :dim => 30))
+    @thechart.add_child(GerbilCharts::Surfaces::StackedAreaSurface.new(:orient => ORIENT_OVERLAY),:anchor => true)
+    @thechart.add_child(GerbilCharts::Surfaces::Legend.new(:orient=> ORIENT_OVERLAY, :dim => 100))  
+    @thechart.add_child(GerbilCharts::Surfaces::VerticalAxis.new(:orient => ORIENT_WEST, :dim => 40 , :cumulative => true ))
+    @thechart.add_child(GerbilCharts::Surfaces::HorizontalTimeAxis.new(:orient => ORIENT_SOUTH, :dim => 25 ))
+
+    # optional features
+    if @feature_timetracker
+        @thechart.add_child(GerbilCharts::Surfaces::Tracker.new(:orient => ORIENT_SOUTH, :dim => 10 ))
+    end
+  end
+end
+
+end
+

data/lib/gerbilcharts/models.rb

@@ -0,0 +1,19 @@
+# == GerbilCharts data models
+#
+# Models feeds your gerbil charts  with data
+#
+
+module GerbilCharts::Models; end;
+
+require 'gerbilcharts/models/presets'
+require 'gerbilcharts/models/raw_range'
+require 'gerbilcharts/models/round_range'
+require 'gerbilcharts/models/round_time_range'
+require 'gerbilcharts/models/discrete_time_range'
+require 'gerbilcharts/models/graph_model'
+require 'gerbilcharts/models/graph_model_group'
+require 'gerbilcharts/models/monotonous_graph_model'
+require 'gerbilcharts/models/time_series_graph_model'
+require 'gerbilcharts/models/bucketized_timeseries_graph_model'
+require 'gerbilcharts/models/sampled_timeseries_graph_model'
+require 'gerbilcharts/models/simple_timeseries_model_group'

data/lib/gerbilcharts/models/bucketized_timeseries_graph_model.rb

@@ -0,0 +1,138 @@
+module GerbilCharts::Models
+
+# == BucketizedTimeSeriedGraphMode
+#
+# Automatically bucketizes incoming timeseries data into predefined buckets
+#
+# [+name+]   			Name of the model
+# [+bucketsec+]         Bucket size in seconds
+# [+opts+]				Model options hash
+# 
+class BucketizedTimeSeriesGraphModel < TimeSeriesGraphModel
+  
+  attr_reader   :bucket_size_secs		# current bucket size
+  attr_reader   :behavior				# :average or :max
+  attr_reader   :last_sweep_pos			# :nodoc:
+  
+  def initialize(name,bucketsec, opt={})
+    super(name,opt)
+    @bucket_size_secs=bucketsec
+    @samp_count =0
+    @behavior = :average
+    @last_sweep_pos=0
+  end
+  
+  def sweep_interval
+      return @bucket_size_secs
+  end
+
+   # add 
+   # [+x_val+]		A Time object 
+   # [+y_val+]		Value 
+   #
+   # This will be bucketized by the model automatically
+   #
+   def add(x_tm,y_val)
+    buckettm_in = to_buckettime(x_tm)
+    
+    # first time
+    if @xarr.length==0
+        super(buckettm_in,y_val)
+        @samp_count=1
+        return
+    end
+      
+    
+    # subsequent times
+    if buckettm_in== latest_x
+        ynew = bucketize(y_val)
+    else
+        npad = bucket_diff(latest_x,buckettm_in)
+        if (npad > 1)
+            pad_empty_buckets(latest_x,npad-1)
+        end
+        super(buckettm_in,y_val)
+        @samp_count=1
+    end
+  end
+
+  # to_buckettime
+  #
+  # [+tv+]	A Time object
+  #
+  # returns the time floor of the bucket this belongs to
+  # example  8:06 AM will belong to the 8:05AM bucket if bucketsize = 5 min
+  #
+  def to_buckettime(tv)
+      exp=tv.tv_sec.divmod(@bucket_size_secs)
+      
+      if exp[1] >= @bucket_size_secs/2
+        return Time.at(exp[0]*@bucket_size_secs + @bucket_size_secs)
+      else
+        return Time.at(exp[0]*@bucket_size_secs)
+      end
+  end
+  
+  # how many buckets separate the two buckettimes
+  def bucket_diff(tv1,tv2)
+    return (tv2-tv1).abs / @bucket_size_secs
+  end
+  
+  # insert zero values to represent missing time buckets
+  def pad_empty_buckets(tv_first,count)
+    for i in (1..count)
+      @yarr << 0
+      @xarr << tv_first + i*@bucket_size_secs
+    end
+  end
+  
+  # accumulate last item
+  def bucketize(val)
+    
+    if @behavior == :average 
+      cval = @yarr.last
+      cval = (cval * @samp_count) + val
+      cval /= (@samp_count+1)
+      @yarr[@yarr.length-1]=cval
+      @samp_count += 1
+    elsif @behavior == :maxima
+      cval = @yarr.last
+      @yarr[@yarr.length-1]=max(cval,val)
+    end
+    return @yarr.last
+
+  end
+    
+  # begin a sweep session
+  def begin_sweep
+      @last_sweep_pos=0
+  end
+
+  # sweep this bucket
+  def sweep(tval)
+    
+    return 0 if @xarr.length == 0
+    return 0 if @last_sweep_pos >= @xarr.length
+    
+    
+    xv=@xarr[@last_sweep_pos]
+    if tval < xv
+        return 0
+    elsif tval == xv
+        @last_sweep_pos+=1
+        rval = @yarr[@last_sweep_pos-1]
+    else 
+        nBucks=bucket_diff(xv,tval)
+        @last_sweep_pos+= nBucks
+    end    
+    return rval.nil? ? 0:rval
+    
+  end
+  
+  
+end
+
+
+end
+
+

data/lib/gerbilcharts/models/discrete_time_range.rb

@@ -0,0 +1,63 @@
+module GerbilCharts::Models
+
+# =DiscreteTimeRange 
+# The range is exactly as specified by individual values.
+# The labels are simply those values formatted based on overall time window
+#
+class DiscreteTimeRange
+
+  attr_reader :points		#discrete points
+  
+  def  initialize(points_arr=[])
+  	@points=points_arr
+  end
+  
+   # provide labels
+   # 	Yields two items (value - seconds since Jan 1 1970, string label)
+   def each_label
+   		@points.each do |t|
+			yield t, format_value(t)
+		end
+   end
+
+  # provide ticks (per label interval)
+  def each_tick(tpl)
+    @points.each do  |t|
+      yield v
+    end
+  end
+  
+  # format min value completely
+  def format_min_value
+  	  return format_value(@points.first) 
+  end
+
+  
+  # scales a value with respect to the range
+  def scale_factor(val)
+  	df = val - @points.first
+	rg = @points.last - @points.first
+	return 0 if rg==0.0
+	return df/rg
+  end
+
+
+  # format the discrete time value
+  def format_value(val)
+  	df = @points.last - @points.first 
+
+  	if df  >  2*24*30 			# > 2months get monthly labels
+		val.strftime("%b")
+  	elsif df  > 1*24*30			# 1-2 months get days
+		val.strftime("%b %d")
+	elsif df > 1*24*7			# > 1 week get days
+		val.strftime("%a")
+	else
+		val.to_s
+	end
+  end
+  
+  
+end
+
+end

data/lib/gerbilcharts/models/graph_model.rb

@@ -0,0 +1,89 @@
+module GerbilCharts::Models
+
+# GraphModel - Basic interface to a model in GerbilCharts
+#
+# You can create your own model as long as all the methods here are implemented
+# or you can use one of the predefined graph models.
+#
+#
+class GraphModel
+  
+  attr_accessor :name			  # name of the model (eg, "backup_server")
+  attr_accessor :altname		  # alternate name 
+  attr_reader   :href			  # href for interactive use
+  attr_reader   :userdata	      # any user object
+  attr_reader   :userlabel1       # map to tooltip 1 
+  attr_reader   :userlabel2       # map to tooltip 2
+  attr_reader   :transformer      # value transformer (a lambda function)
+  
+  def initialize(n="Untitled")
+    @name=n
+	@transformer = nil
+  end
+  
+  def min_max_x
+    yield 0,0    
+  end
+  
+  def min_max_y
+    yield 0,0
+  end
+  
+  def each_value_pair
+    yield 0,0
+  end
+  
+  def count
+    0
+  end
+  
+  # clean up the href (todo: improve this)
+  def setHref(h)
+    h1=h.gsub("{","%7B")
+    @href=h1.gsub("}","%7D")
+  end
+  
+  def hasHref?
+    return @href != nil
+  end
+  
+  def setUserData(d)
+    @userdata=d
+  end
+  
+  def hasUserData?
+    return @userdata != nil
+  end
+  
+  def hasUserTips?
+    return @userlabel1 != nil
+  end
+  
+  def setUserTip1(t)
+    @userlabel1=t
+    @userlabel2="" if @userlabel2.nil?
+  end
+  
+  def setUserTip2(t)
+    @userlabel2=t
+    @userlabel1="" if @userlabel1.nil?
+  end
+  
+  def updateOptions(opts)
+    @name = opts[:name] if opts[:name]
+  end
+  
+  def recreate
+    # no op (override this)
+  end
+  
+  def transformer=(trlambda)
+    @transformer = trlambda
+  end
+
+  def is_timeseries?
+	return false
+  end
+end
+
+end

data/lib/gerbilcharts/models/graph_model_group.rb

@@ -0,0 +1,240 @@
+module GerbilCharts::Models
+
+# GraphModelGroup - a bunch of related models that are targeted at a
+# 		single output surface
+#
+class GraphModelGroup
+  
+  attr_accessor :models
+  attr_accessor :name
+  attr_accessor :href
+  attr_accessor :emptycaption
+  attr_accessor :units
+  
+  def initialize(n="Untitled-Group")
+    @models=[]
+    @name=n
+    @units=""
+  end
+  
+  def <<(m)
+    @models << m
+  end
+  
+  def add(m)
+    @models << m
+  end
+  
+  def delete(m)
+    @models.delete(m)
+  end
+  
+  def delete_by_index(i)
+    @models.delete_at(i)
+  end
+  
+  def set_null(i)
+    @models[i]=nil
+  end
+  
+  def compact_models
+    @models.compact!
+  end
+  
+  def count
+    return @models.size
+  end
+  
+  def each_model
+    @models.each do |m|
+      yield m
+    end
+  end
+  
+  def clear_models
+    @models.clear
+  end
+    
+  # sort options
+  #   :dir => (:ascending or :descending)
+  #   :mode => (:latest, :total )
+  def sort(opts={})
+    
+    raise "Missing sort direction" if not defined? opts[:dir]
+    raise "Missing sort mode" if not defined? opts[:mode]
+    
+    @models.sort! { |m1,m2| m1.latest_val <=> m2.latest_val }
+    
+    @models.reverse! if opts[:dir] == :descending
+  
+  end
+  
+  # each model, index over code block
+  def each_model_with_index
+    @models.each_with_index do |m,i|
+      yield m,i
+    end
+  end
+  
+  # each user data over code block
+  def each_user_data
+    each_model do |mod|
+      yield mod.userdata if mod.hasUserData?
+    end
+  end
+  
+  def effective_round_range
+    
+    if @models.length==0
+      return 0,0
+    end
+    
+    reffx = RawRange.new
+    reffy = RawRange.new
+    @models.each do |m|
+      reffx.update_r(m.xrange)
+      reffy.update_r(m.yrange)
+    end    
+    
+    return models[0].rounderx.round_given(reffx), models[0].roundery.round_given(reffy)
+    
+  end
+
+  def effective_round_range_x
+    
+    reffx = RawRange.new
+    @models.each do |m|
+      reffx.update_r(m.xrange)
+    end    
+    
+    return models[0].round_given_x(reffx)
+  end
+  
+  def effective_round_range_y0
+    reffy = RawRange.new
+    reffy.zeromin
+    @models.each do |m|
+      reffy.update_r(m.yrange)
+    end    
+    
+    return @models[0].round_given_y(reffy)
+  end
+  
+  def sweep_interval
+      return @models[0].sweep_interval
+  end
+  
+  # sum of model ranges 
+  def cumulative_round_range_y0
+    reffy = RawRange.new
+    reffy.update(0)
+    @models.each do |m|
+      reffy.update(m.yrange.rmax+reffy.rmax)
+    end    
+    
+    return models[0].round_given_y(reffy)
+  end
+
+  # sweep for an interval with max
+  def cumulative_sweep_round_range_y0
+      
+    rx = effective_round_range_x
+	reffy = RawRange.new
+	reffy.zeromin
+            
+	# prepare models for sweeping
+	sweep_pos= rx.rmin
+	sweep_to = rx.rmax
+      
+	@models.each do | mod|
+	  mod.begin_sweep
+	end
+        
+	# perform the sweep
+	while (sweep_pos<=sweep_to)  
+		acc_y = 0
+		@models.each do | mod, i|
+			acc_y +=  mod.sweep(sweep_pos)
+		end
+		sweep_pos += sweep_interval
+		reffy.update(acc_y)
+	end
+
+    return models[0].round_given_y(reffy)
+      
+  end  
+  
+  def cumulative_round_range
+    
+    if @models.length==0
+      return 0,0
+    end
+    
+    reffx = RawRange.new
+    reffy = RawRange.new
+    @models.each do |m|
+      reffx.update_r(m.xrange)
+      reffy.update(m.yrange.rmax+reffy.rmax)
+    end    
+    
+    return models[0].rounderx.round_given(reffx), models[0].roundery.round_given(reffy)
+    
+  end
+  
+  def models_digest
+    mnames = ""
+    @models.each do |m|
+      mnames << m.name
+    end
+    dig=Digest::MD5.hexdigest(mnames)
+    return dig
+  end
+  
+  def setSessionKey(k)
+    @sessionKey=k
+  end
+  
+  def contentKey(sessid,extension)
+    return sessid + @sessionKey + "." + extension
+  end
+  
+  def setHref(h)
+    h1=h.gsub("{","%7B")
+    @href=h1.gsub("}","%7D")
+  end
+  
+  def hasHref?
+    return @href != nil
+  end
+  
+  def randomizeModels(mode=:latest_value)
+    @models.each do |m|
+      if mode==:latest_value
+        m.randomizeLastValue
+      end
+    end
+  end
+  
+  # recreate all models with new params
+  def recreateModels(new_opts)
+    @models.each do |m|
+        m.updateOptions(new_opts)
+        m.recreate
+    end
+  
+  end
+  
+  # empty ?
+  def empty?
+    return @models.empty?
+  end
+  
+  # empty string
+  def empty_caption
+    return "No activity" if @emptycaption.nil?
+    return @emptycaption
+  end
+end
+
+end
+