gerbilcharts 0.0.3

data/lib/gerbilcharts/models/round_time_range.rb

@@ -0,0 +1,105 @@
+module GerbilCharts::Models
+
+# 
+# rounded time range - Rounds the max to a nice preset
+#  This class allows for labels at clean intervals instead of
+#  "Jan 17 2008 11:27:92"
+#
+class RoundTimeRange < RawRange
+ 
+  attr_reader  :ldelta		# label delta seconds   (eg label every = 2 hrs)
+  attr_reader  :rdelta		# range delta seconds 	(eg chart span = 6 hrs)
+
+  # given a raw range, we calculate a round range
+  def initialize(raw_range)
+    super()
+    @rdelta,@ldelta=round_delta(raw_range.delta)
+    @rmin=raw_range.rmin
+    @rmax=round_max(raw_range.rmax,@rdelta)
+	@gmhalfhour = Time.now.gmt_offset%3600 
+  end
+ 
+   # provide labels
+   # 	Yields two items (value - seconds since Jan 1 1970, string label)
+   def each_label
+     
+    raise "Range not aligned with presets (call round range first)" if not @ldelta
+    
+    return if @ldelta == 0
+      
+	if (@rmin.tv_sec % @ldelta) != @gmhalfhour
+      ni_sec = (@rmin.tv_sec+@ldelta)/@ldelta
+
+	  # if labeling hours, make sure you account tz weirdness like india GMT +5:30
+	  if @ldelta >= 3600
+		 v = Time.at(@ldelta * ni_sec.to_i  - @gmhalfhour)
+	  else
+	  	 v = Time.at(@ldelta * ni_sec.to_i)
+	  end
+    else
+      v = @rmin
+    end
+
+    while (v<=@rmax) do
+      yield v, format_timeval(v,@rdelta)    
+      v = v+@ldelta
+    end
+   end
+
+  # provide ticks (per label interval)
+  def each_tick(tpl)
+    raise "Range not aligned with presets (call round range first)" if not @ldelta
+  
+    lint = @lmax/tpl
+    if @rmin % lint != 0
+      v = (@rmin+lint) - (@rmin%lint)
+    else
+      v = @rmin
+    end
+    while (v<@rmax) do
+      yield v
+      v = v+lint
+    end
+  end
+  
+  # format min value completely
+  def format_min_value
+      t = Time.at(@rmin).getlocal
+      return t.to_s
+  end
+  
+private
+  # round_max (ceiling)
+  def round_max(raw, interval)
+    return 0 if interval == 0 
+    ni_secs = (raw.tv_sec+interval)/interval
+    return Time.at(interval * ni_secs.to_i)
+  end
+     
+  # round_min (floor)
+  def round_min(raw, interval)
+    ni_secs = (raw.tv_sec-interval)/interval
+    return Time.at(interval * ni_secs.to_i )
+  end
+  
+  # rounded delta time 
+  def round_delta(raw_delta)
+    
+    last_pre=1
+    last_lab=1
+    if raw_delta > TIMEPRESETS.last[0]
+      return raw_delta,raw_delta/10
+    else
+      TIMEPRESETS.reverse_each do |pre|
+        break if pre[0] < raw_delta
+        last_pre=pre[0]
+        last_lab=pre[1]
+      end
+    end
+    return last_pre,last_lab
+  end
+
+  
+end
+
+end

data/lib/gerbilcharts/models/sampled_timeseries_graph_model.rb

@@ -0,0 +1,80 @@
+module GerbilCharts::Models
+
+
+# = SampledTimeSeriesGraphModel
+# Time series graph model with sample polling interval
+# we expect discrete points at approx regular intervals
+# a missing interval implies zero value !
+#
+# This class is mainly used for its sweep methods.
+# TODO: Example here
+#
+class SampledTimeSeriesGraphModel < TimeSeriesGraphModel
+
+  attr_reader :bucketsize		# sample interval (polling interval)
+
+  def initialize(name,bucketsize,opt={})
+    super(name,opt)
+    raise "Sampled time series model : required param bucketsize missing" unless opt[:bucketsize]
+    @bucketsize = opt[:bucketsize] 
+  end
+  
+  def sweep_interval
+      return @bucketsize
+  end
+  
+  # begin a sweep session
+  def begin_sweep
+      @last_sweep_pos=0
+  end
+
+  # sweep this bucket
+  def sweep2(tval)
+    
+    return 0 if @xarr.length == 0
+    return 0 if @last_sweep_pos >= @xarr.length
+    
+    p "Sweep at tval = #{tval}"
+    
+    xv=@xarr[@last_sweep_pos]
+    if bucket_diff(tval,xv) < 1
+        @last_sweep_pos+=1
+        return @yarr[@last_sweep_pos-1]
+    else 
+        return 0
+    end    
+  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
+    end
+    
+    nBucks=bucket_diff(xv,tval)
+    if nBucks <= 1
+        @last_sweep_pos+=1
+        rval = @yarr[@last_sweep_pos-1]
+    else 
+        @last_sweep_pos+= nBucks
+    end    
+    return rval.nil? ? 0:rval
+   
+  end
+    
+  # how many buckets separate the two buckettimes
+  def bucket_diff(tv1,tv2)
+    return (tv2-tv1).abs / @bucketsize
+  end
+  
+end
+
+end
+

data/lib/gerbilcharts/models/simple_timeseries_model_group.rb

@@ -0,0 +1,68 @@
+module GerbilCharts::Models
+
+# = SimpleTimeSeriesModelGroup 
+# A quick way to create a model group and models using a single statement.
+# This works if all models have data points at fixed times.
+#
+# Example code :
+#
+#   my_modelgroup = GerbilCharts::Models::SimpleTimeSeriesModelGroup.new 
+#                   (
+#   					:title => "Sales figures",
+#  						:timeseries  =>  (1..6).collect { |month| Time.local(2008,month) },
+#  						:models =>       [  ["Bruce", 1, 10, 18, 28, 80,  122],
+#  											["Rex"  , 12,22, 45, 70, 218, 109],
+#  											["Buzo" , 0, 23, 25, 40, 18,  59]   
+#                                        ]
+#					)
+#  
+#
+class SimpleTimeSeriesModelGroup < GraphModelGroup
+
+  attr_reader		:discrete_range
+  
+  # Create the model group
+  #
+  # [+title+]      The name of the modelgroup, shows up as chart title (eg, "Sales Figures")
+  # [+timeseries+] An array of Time objects representing each datapoint
+  # [+models+]	   An array of models (array of name followed by values) eg, [ "Bruce", 0.1, 2.3, etc]
+  #
+  # All three are required parameters. If you want more flexibility then use a GraphModelGroup
+  # object directly. See SimpleTimeseriesModelGroup documentation for an example.
+  #
+  def initialize(opts)
+
+  	raise "Required parameter :title missing" unless opts[:title]
+  	raise "Required array parameter :timeseries missing" unless opts[:timeseries]
+  	raise "Required models missing" unless opts[:models]
+
+	super(opts[:title])
+
+	# user supplied 
+	tvals = opts[:timeseries]
+	modelitems = opts[:models]
+
+	# create a timeseries graph model using user supplied data
+	modelitems.each do |mitem|
+		mod = TimeSeriesGraphModel.new( mitem.shift )	
+		mitem.each_with_index do | datapt, idx |
+			mod.add(tvals[idx], datapt)	if idx < tvals.size
+		end
+		add(mod)
+	end
+
+	# a discrete range object 
+	@discrete_range = DiscreteTimeRange.new(tvals)
+
+  end
+
+  # return a discrete range for the X items (timeseries)
+  def effective_round_range_x
+  	return @discrete_range
+  end
+
+  
+end
+
+end
+

data/lib/gerbilcharts/models/time_series_graph_model.rb

@@ -0,0 +1,34 @@
+module GerbilCharts::Models
+
+# = TimeSeriesGraphModel
+# time series graph model (special case of monotonous)
+# we expect discrete points, mainly the x_values are interpreted as timestamp
+# therefore we can construct the appropriate preset axis labels.
+#
+# Eg. We can create round labels such as  8:15 instead of 8:16:47 
+#
+class TimeSeriesGraphModel < MonotonousGraphModel
+
+  def initialize(name,opt={})
+    super(name,opt)
+    @rounderx=RoundTimeRange
+    @roundery=RoundRange
+  end
+
+  def add(timeobj, val)
+	super timeobj, val
+  end
+  
+  # crop older than the given timestamp
+  def crop_older(cutofftime)
+    crop_at(cutofftime)
+  end
+
+  # just a check if we need time series
+  def is_timeseries?
+  	return true
+  end
+  
+end
+
+end

data/lib/gerbilcharts/public/brushmetal.css

@@ -0,0 +1,197 @@
+.surfacepanel
+{
+	fill: none;
+	stroke-width: 1;
+	stroke: black;
+}
+.gridlineh
+{	
+	stroke-width: 1;
+	stroke: lightgray;
+}
+.gridlinev
+{
+	stroke-width: 1;
+	stroke: lightgray;	
+}
+.surfaceback
+{
+	fill: url(#vertgrad);
+}
+.axispanel
+{
+	fill: lightgray;
+}
+.axistickmajor
+{
+	stroke-width: 2;
+	stroke: black;
+}
+.axistickminor
+{
+	stroke-width: 1;
+	stroke: black;
+}
+.panel
+{
+	fill: white;
+}
+.legend
+{
+	fill: red;
+}
+#item0
+{
+	stroke:	blue;
+	fill: blue;
+}
+#item1
+{
+	stroke: red;
+	fill: red;
+}
+#item2
+{
+	stroke: yellow;
+	fill: yellow ;
+}
+#item3
+{
+	stroke: aqua;
+	fill: magenta;
+}
+#item4
+{
+	stroke:	gray;
+	fill: blue;
+}
+#item5
+{
+	stroke: green;
+	fill: green;
+}
+#item6
+{
+	stroke: orange;
+	fill: orange;
+}
+#item7
+{
+	stroke: lime;
+	fill: violet;
+}
+#item8
+{
+    stroke: brown;
+    fill: navy;
+}
+#lineitem0
+{
+    stroke: blue;
+    stroke-width: 2;
+}
+#lineitem1
+{
+    stroke: red;
+    stroke-width: 2;
+}
+#lineitem2
+{
+    stroke: yellow;
+    stroke-width: 2;
+}
+#lineitem3
+{
+    stroke: aqua;
+    stroke-width: 2;
+}
+#lineitem4
+{
+    stroke: gray;
+    stroke-width: 2;
+}
+#lineitem5
+{
+    stroke: green;
+    stroke-width: 2;
+}
+#lineitem6
+{
+    stroke: orange;
+    stroke-width: 2;
+}
+#lineitem7
+{
+    stroke: lime;
+    stroke-width: 2;
+}
+#lineitem8
+{
+    stroke: brown;
+    stroke-width: 2;
+}
+.axislabel
+{
+	font-family: sans;
+	font-size: 10px;
+	fill: black;
+	stroke: none;
+}
+
+.axislabelt0
+{
+	font-family: sans;
+	font-size: 8px;
+	fill: black;
+	stroke: none;
+}
+.titletext
+{
+	fill: gray;
+	stroke: none;
+	font-family: Arial, Helvetica, sans-serif;;
+	font-size: 24px;
+	font-weight: bold;
+}
+.titlepanel
+{
+	fill: white;
+	fill-opacity: 0.5;
+}
+.legendpanel
+{
+	fill: white;
+	fill-opacity: 0.5;
+}
+.legendtext
+{
+	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;
+	font-size: 10px;
+	fill: black;
+	stroke: none;
+}
+.elementlabel
+{
+	font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;
+	font-size: 10px;
+}
+.trackerpanel
+{
+    fill: yellow;
+    fill-opacity: 0.5;
+}
+.trackerrect
+{
+    fill: red;
+    fill-opacity: 0.2;
+}
+.trackertextinterval
+{
+    font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;
+    font-size: 14px;
+}
+.trackertextfromts
+{
+    font-family: Verdana, Geneva, Arial, Helvetica, sans-serif;
+    font-size: 10px;
+}