technical_graph 0.0.0

data/lib/technical_graph/graph_image_drawer.rb

@@ -0,0 +1,190 @@
+#encoding: utf-8
+
+require 'rubygems'
+require 'RMagick'
+require 'date'
+
+# Universal class for creating graphs/charts.
+
+# options parameters:
+# :width - width of image
+# :height - height of image
+# :x_min, :x_max, :y_min, :y_max - default or fixed ranges
+# :xy_behaviour:
+# * :default - use them as default ranges
+# * :fixed - ranges will not be changed during addition of layers
+
+class GraphImageDrawer
+
+  attr_reader :technical_graph
+
+  # Accessor for options Hash
+  def options
+    @technical_graph.options
+  end
+
+  # Accessor for DataLayer Array
+  def layers
+    @technical_graph.layers
+  end
+
+  # Calculate everything
+  def data_processor
+    @technical_graph.data_processor
+  end
+
+  def truncate_string
+    options[:truncate_string]
+  end
+
+
+  # default sizes
+  DEFAULT_WIDTH = 1600
+  DEFAULT_HEIGHT = 1200
+
+  def initialize(technical_graph)
+    @technical_graph = technical_graph
+
+    options[:width] ||= DEFAULT_WIDTH
+    options[:height] ||= DEFAULT_HEIGHT
+
+    # colors
+    options[:background_color] ||= 'white'
+    options[:background_hatch_color] ||= 'lightcyan2'
+    options[:axis_color] ||= '#aaaaaa'
+  end
+
+  def width
+    options[:width].to_i
+  end
+
+  def height
+    options[:height].to_i
+  end
+
+  def width=(w)
+    options[:width] = w.to_i if w.to_i > 0
+  end
+
+  def height=(h)
+    options[:height] = h.to_i if h.to_i > 0
+  end
+
+  def font_antialias
+    options[:font_antialias] == true
+  end
+
+  # Calculate image X position
+  def calc_bitmap_x(_x)
+    l = data_processor.x_max - data_processor.x_min
+    offset = _x - data_processor.x_min
+    return (offset.to_f * width.to_f) / l.to_f
+  end
+
+  # Calculate image Y position
+  def calc_bitmap_y(_y)
+    l = data_processor.y_max - data_processor.y_min
+    #offset = _y - data_processor.y_min
+    offset = data_processor.y_max - _y
+    return (offset.to_f * height.to_f) / l.to_f
+  end
+
+  # Create background image
+  def crate_blank_graph_image
+    @image = Magick::ImageList.new
+    @image.new_image(
+      width,
+      height,
+      Magick::HatchFill.new(
+        options[:background_color],
+        options[:background_hatch_color]
+      )
+    )
+
+    return @image
+  end
+
+  attr_reader :image
+
+  # Render data layer
+  def render_data_layer(l)
+    layer_line = Magick::Draw.new
+    layer_text = Magick::Draw.new
+
+    layer_line.stroke_antialias(l.antialias)
+    layer_line.fill(l.color)
+    layer_line.fill_opacity(1)
+    layer_line.stroke(l.color)
+    layer_line.stroke_opacity(1.0)
+    layer_line.stroke_width(1.0)
+    layer_line.stroke_linecap('square')
+    layer_line.stroke_linejoin('miter')
+
+    layer_text.text_antialias(font_antialias)
+    layer_text.pointsize(10)
+    layer_text.font_family('helvetica')
+    layer_text.font_style(Magick::NormalStyle)
+    layer_text.text_align(Magick::LeftAlign)
+    layer_text.text_undercolor(options[:background_color])
+
+    # calculate coords, draw text, and then lines and circles
+    coords = Array.new
+
+    (0...(l.data.size - 1)).each do |i|
+      ax = l.data[i][:x]
+      ax = calc_bitmap_x(ax).round
+      ay = l.data[i][:y]
+      ay = calc_bitmap_y(ay).round
+
+      bx = l.data[i+1][:x]
+      bx = calc_bitmap_x(bx).round
+      by = l.data[i+1][:y]
+      by = calc_bitmap_y(by).round
+
+      coords << {
+        :ax => ax, :ay => ay,
+        :bx => bx, :by => by,
+        :dy => l.data[i][:y]
+      }
+    end
+
+    # labels
+    coords.each do |c|
+      string_label = "#{truncate_string % c[:dy]}"
+      layer_text.text(
+        c[:ax] + 5, c[:ay],
+        string_label
+      )
+    end
+    layer_text.draw(@image)
+
+    # lines and circles
+    coords.each do |c|
+      # additional circle
+      layer_line.circle(
+        c[:ax], c[:ay],
+        c[:ax] + 3, c[:ay]
+      )
+      layer_line.circle(
+        c[:bx], c[:by],
+        c[:bx] + 3, c[:by]
+      )
+
+      # line
+      layer_line.line(
+        c[:ax], c[:ay],
+        c[:bx], c[:by]
+      )
+    end
+    layer_line.draw(@image)
+
+  end
+
+  # Save output to file
+  def save_to_file(file)
+    @image.write(file)
+  end
+
+
+end
+

data/lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer.rb

@@ -0,0 +1,151 @@
+#encoding: utf-8
+
+require 'technical_graph/axis_layer_draw_module'
+
+# Decide min/max values, recalculate all points and draw axises
+
+class AxisLayer
+  include AxisLayerDrawModule
+
+  def initialize(options = { })
+    @options = options
+    @options[:x_min] ||= (Time.now - 24 * 3600).to_f
+    @options[:x_max] ||= Time.now.to_f
+    @options[:y_min] ||= 0.0
+    @options[:y_max] ||= 1.0
+    # :default - coords are default
+    # :fixed or whatever else - min/max coords are fixed
+    @options[:xy_behaviour] ||= :default
+
+    # number of axises
+    @options[:y_axises_count] ||= 10
+    @options[:x_axises_count] ||= 10
+    # interval
+    @options[:y_axises_interval] ||= 1.0
+    @options[:x_axises_interval] ||= 1.0
+    # when false then axises are generated to meet 'count'
+    # when true then axises are generated every X from lowest
+    @options[:x_axises_fixed_interval] = true if @options[:x_axises_fixed_interval].nil?
+    @options[:y_axises_fixed_interval] = true if @options[:y_axises_fixed_interval].nil?
+
+    @zoom_x = 1.0
+    @zoom_y = 1.0
+  end
+
+  # Ranges are fixed
+  def fixed?
+    @options[:xy_behaviour] == :fixed
+  end
+
+  # Ranges without zoom
+  def raw_x_min
+    @options[:x_min]
+  end
+
+  def raw_x_max
+    @options[:x_max]
+  end
+
+  def raw_y_min
+    @options[:y_min]
+  end
+
+  def raw_y_max
+    @options[:y_max]
+  end
+
+  # Ranges with zoom
+  def x_min
+    calc_x_zoomed([self.raw_x_min]).first
+  end
+
+  def x_max
+    calc_x_zoomed([self.raw_x_max]).first
+  end
+
+  def y_min
+    calc_y_zoomed([self.raw_y_min]).first
+  end
+
+  def y_max
+    calc_y_zoomed([self.raw_y_max]).first
+  end
+
+  # Accessors
+  private
+  def raw_x_min=(x)
+    @options[:x_min] = x
+  end
+
+  def raw_x_max=(x)
+    @options[:x_max] = x
+  end
+
+  def raw_y_min=(y)
+    @options[:y_min] = y
+  end
+
+  def raw_y_max=(y)
+    @options[:y_max] = y
+  end
+
+  public
+
+  # Consider changing ranges
+  def process_data_layer(data_layer)
+    # ranges are set, can't change sir
+    return if fixed?
+
+    # updating ranges
+    self.raw_y_max = data_layer.y_max if not data_layer.y_max.nil? and data_layer.y_max > self.raw_y_max
+    self.raw_x_max = data_layer.x_max if not data_layer.x_max.nil? and data_layer.x_max > self.raw_x_max
+
+    self.raw_y_min = data_layer.y_min if not data_layer.y_min.nil? and data_layer.y_min < self.raw_y_min
+    self.raw_x_min = data_layer.x_min if not data_layer.x_min.nil? and data_layer.x_min < self.raw_x_min
+  end
+
+  # Change overall image zoom
+  def zoom=(z = 1.0)
+    self.x_zoom = z
+    self.y_zoom = z
+  end
+
+  # Change X axis zoom
+  def x_zoom=(z = 1.0)
+    @zoom_x = z
+  end
+
+  # Change X axis zoom
+  def y_zoom=(z = 1.0)
+    @zoom_y = z
+  end
+
+  attr_reader :zoom_x, :zoom_y
+
+  # Calculate zoomed X position for Array of X'es
+  def calc_x_zoomed(old_xes)
+    a = (raw_x_max.to_f + raw_x_min.to_f) / 2.0
+    new_xes = Array.new
+
+    old_xes.each do |x|
+      d = x - a
+      new_xes << (a + d * self.zoom_x)
+    end
+
+    return new_xes
+  end
+
+  # Calculate zoomed Y position for Array of Y'es
+  def calc_y_zoomed(old_yes)
+    a = (raw_y_max.to_f + raw_y_min.to_f) / 2.0
+    new_yes = Array.new
+
+    old_yes.each do |y|
+      d = y - a
+      new_yes << (a + d * self.zoom_y)
+    end
+
+    return new_yes
+  end
+
+end

data/lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer_draw_module.rb

@@ -0,0 +1,145 @@
+module AxisLayerDrawModule
+  def x_axis_fixed?
+     @options[:x_axises_fixed_interval] == true
+   end
+
+  # Value axis has fixed count
+  def y_axis_fixed?
+     @options[:y_axises_fixed_interval] == true
+   end
+
+  # Where to put axis values
+  def value_axises
+    return calc_axis(self.y_min, self.y_max, @options[:y_axises_interval], @options[:y_axises_count], y_axis_fixed?)
+  end
+
+  # Where to put axis values
+  def parameter_axises
+    return calc_axis(self.x_min, self.x_max, @options[:x_axises_interval], @options[:x_axises_count], x_axis_fixed?)
+  end
+
+  # Calculate axis using 2 methods
+  def calc_axis(from, to, interval, count, fixed_interval)
+    axises = Array.new
+    l = to - from
+    current = from
+    
+    if fixed_interval
+      while current < to
+        axises << current
+        current += interval
+      end
+      return axises
+
+    else
+      (0...count).each do |i|
+        axises << from + (l.to_f * i.to_f) / count.to_f
+      end
+      return axises
+
+    end
+  end
+
+
+  def calc_bitmap_position(array)
+    # TODO move calculatio of lenght here
+  end
+
+  def calc_bitmap_x(_x)
+    l = self.x_max - self.x_min
+    offset = _x - self.x_min
+    return (offset.to_f * @image.width.to_f) / l.to_f
+  end
+
+  def calc_bitmap_y(_y)
+    l = self.y_max - self.y_min
+    offset = _y - self.y_min
+    return (offset.to_f * @image.width.to_f) / l.to_f
+  end
+
+  # Render axis on image
+  def render_on_image(image)
+    @image = image
+
+    render_values_axis
+    render_parameters_axis
+  end
+
+  def render_values_axis
+    plot_axis_y_line = Magick::Draw.new
+    plot_axis_y_text = Magick::Draw.new
+
+    plot_axis_y_line.fill_opacity(0)
+    plot_axis_y_line.stroke(@image.options[:axis_color])
+    plot_axis_y_line.stroke_opacity(1.0)
+    plot_axis_y_line.stroke_width(1.0)
+    plot_axis_y_line.stroke_linecap('square')
+    plot_axis_y_line.stroke_linejoin('miter')
+
+    plot_axis_y_text.font_family('helvetica')
+    plot_axis_y_text.font_style(Magick::NormalStyle)
+    plot_axis_y_text.text_align(Magick::LeftAlign)
+    plot_axis_y_text.text_undercolor(@image.options[:background_color])
+
+    value_axises.each do |y|
+      by = calc_bitmap_y(y)
+      plot_axis_y_line.line(
+        0, by.round,
+        @image.image.columns-1, by.round
+      )
+
+      plot_axis_y_text.text(
+        5,
+        by.round + 15,
+        "#{y}"
+      )
+    end
+
+    t = Time.now
+    plot_axis_y_line.draw(@image.image)
+    puts "#{Time.now - t} drawing lines"
+    plot_axis_y_text.draw(@image.image)
+    puts "#{Time.now - t} drawing text"
+
+  end
+
+  def render_parameters_axis
+
+    plot_axis_x_line = Magick::Draw.new
+    plot_axis_x_text = Magick::Draw.new
+
+    plot_axis_x_line.fill_opacity(0)
+    plot_axis_x_line.stroke(@image.options[:axis_color])
+    plot_axis_x_line.stroke_opacity(1.0)
+    plot_axis_x_line.stroke_width(1.0)
+    plot_axis_x_line.stroke_linecap('square')
+    plot_axis_x_line.stroke_linejoin('miter')
+
+    plot_axis_x_text.font_family('helvetica')
+    plot_axis_x_text.font_style(Magick::NormalStyle)
+    plot_axis_x_text.text_align(Magick::LeftAlign)
+    plot_axis_x_text.text_undercolor(@image.options[:background_color])
+
+    parameter_axises.each do |x|
+      bx = calc_bitmap_x(x)
+      plot_axis_x_line.line(
+        bx.round, 0,
+        bx.round, @image.image.rows-1
+      )
+
+      plot_axis_x_text.text(
+        bx.round + 15,
+        @image.image.rows - 15,
+        "#{x}"
+      )
+    end
+
+    t = Time.now
+    plot_axis_x_line.draw(@image.image)
+    puts "#{Time.now - t} drawing lines"
+    plot_axis_x_text.draw(@image.image)
+    puts "#{Time.now - t} drawing text"
+
+  end
+
+end

data/lib/technical_graph/refactoring_backup/lib/technical_graph.rb

@@ -0,0 +1,55 @@
+#encoding: utf-8
+
+require 'rubygems'
+require 'technical_graph/data_processor'
+#require 'technical_graph/graph_image'
+#require 'technical_graph/data_layer'
+#require 'technical_graph/axis_layer'
+
+# Universal class for creating graphs/charts.
+
+# options parameters:
+# :width - width of image
+# :height - height of image
+# :x_min, :x_max, :y_min, :y_max - default or fixed ranges
+# :xy_behaviour:
+# * :default - use them as default ranges
+# * :fixed - ranges will not be changed during addition of layers
+
+class TechnicalGraph
+
+  def initialize(options = { })
+    @options = options
+    @data_processor = GraphDataProcessor.new(@options)
+
+    #@image = GraphImage.new(@options)
+    #@axis = AxisLayer.new(@options)
+    #@layers = []
+  end
+  attr_reader :options
+  #attr_reader :image
+  #attr_reader :layers
+  #attr_reader :axis
+
+  # Add new data layer to layer array
+  def add_layer(data = [], options = {})
+    @layers << DataLayer.new(data, options)
+  end
+
+  # Create graph
+  def render
+    @image.render_image
+    # recalculate ranges
+    @layers.each do |l|
+      @axis.process_data_layer(l)
+    end
+    # draw axis
+    @axis.render_on_image(@image)
+    # draw layers
+    @layers.each do |l|
+      # @xis used for calculation purpose
+      l.render_on_image(@image, @axis)
+    end
+  end
+
+end

data/lib/technical_graph/refactoring_backup/test/test_technical_graph.rb

@@ -0,0 +1,104 @@
+require 'helper'
+
+class TestTechnicalGraph < Test::Unit::TestCase
+  context 'initial options' do
+    setup do
+      @technical_graph = TechnicalGraph.new
+    end
+
+    should "has options with default values" do
+      @technical_graph.options.class.should == Hash
+      @technical_graph.options[:width] > 0
+      @technical_graph.options[:height] > 0
+    end
+
+    should "has options with custom values" do
+      s = 10
+      tg = TechnicalGraph.new({ :height => s, :width => s })
+      @technical_graph.options[:width] == s
+      @technical_graph.options[:height] == s
+
+      @technical_graph.image.width == s
+      @technical_graph.image.height == s
+    end
+
+    should "has changeable options" do
+      s = 20
+      tg = TechnicalGraph.new
+      tg.image.width = s
+      tg.image.height = s
+      @technical_graph.options[:width] == s
+      @technical_graph.options[:height] == s
+    end
+  end
+
+  context 'basic layer operation and saving file' do
+    setup do
+      @tg = TechnicalGraph.new
+      @data_size = 100
+
+      # sample data
+      @data = Array.new
+      @second_data = Array.new
+      (0...@data_size).each do |i|
+        @data << { :x => Time.now.to_i - 3600 + i, :y => Math.sin(i.to_f / 10.0) }
+        @second_data << { :x => Time.now.to_i - 1800 + i*2, :y => Math.cos(i.to_f / 10.0) }
+      end
+    end
+
+    should 'has ability do add new layer' do
+      layers = @tg.layers.size
+      @tg.add_layer(@data)
+      @tg.layers.size.should == layers + 1
+
+      layer = @tg.layers.last
+      layer.data.size.should == @data_size
+    end
+
+    should 'has ability to manipulate layers, add more data' do
+      @tg.add_layer(@data)
+      layer = @tg.layers.last
+      layer.class.should == DataLayer
+
+      layer.data.size.should == @data_size
+
+      # adding second data
+      layer.append_data(@second_data)
+      layer.data.size.should == 2 * @data_size
+
+      # @tg.render
+      # @tg.image.save_to_file('test1.png')
+    end
+
+    should 'has ability to filter records with similar x\'es' do
+      @tg.add_layer
+      layer = @tg.layers.last
+      layer.data.size.should == 0
+      layer.append_data([{ :x => 0, :y => 1 }])
+      layer.data.size.should == 1
+
+      # uniq check
+      layer.append_data([{ :x => 0, :y => 1 }])
+      layer.append_data([{ :x => 0, :y => 1 }])
+      layer.data.size.should == 1
+      layer.append_data([{ :x => 2, :y => 1 }])
+      layer.data.size.should == 2
+    end
+
+    should 'has ability to filter bad records' do
+      @tg.add_layer
+      layer = @tg.layers.last
+      layer.data.size.should == 0
+      layer.append_data([{ :x => 0, :y => 1 }])
+      layer.data.size.should == 1
+
+      # uniq check
+      layer.append_data([{ :z => 0, :y => 1 }])
+      layer.append_data([{}])
+      layer.data.size.should == 1
+    end
+
+  end
+
+
+end