technical_graph 0.3.0 → 0.3.1

data/lib/technical_graph/data_layer_processor.rb

@@ -1,212 +1,42 @@
 #encoding: utf-8
 
-# Approximate data layer
+require 'technical_graph/data_layer_processor_simple_smoother'
+require 'technical_graph/data_layer_processor_noise_removal'
 
-class DataLayerProcessor
-  STRATEGIES = {
-    :rectangular => 'generate_vector_rectangular',
-    :gauss => 'generate_vector_gauss'
-  }
-  DEFAULT_STRATEGY = :rectangular
-
-  MIN_LEVEL = 1
-  MAX_LEVEL = 200
-
-  # use 'x' axis for processing also
-  PROCESS_WITH_PARAMETER_DISTANCE = false
+# Smooth data layer, approximate, ..
 
-  # default Gauss coefficient
-  DEFAULT_GAUSS_COEFF = 0.2
+class DataLayerProcessor
+  include DataLayerProcessorSimpleSmoother
+  include DataLayerProcessorNoiseRemoval
 
   def initialize(data_layer)
     @data_layer = data_layer
-    @strategy = DEFAULT_STRATEGY
-    @level = MIN_LEVEL
-    @vector = Array.new
-    @gauss_coeff = DEFAULT_GAUSS_COEFF
+    simple_smoother_initialize(data_params)
+    noise_removal_initialize(data_params)
   end
 
-  attr_reader :vector
-  attr_accessor :gauss_coeff
-
-  # Level of approximation
-  def level=(l)
-    @level = l.to_i if l.to_i >= MIN_LEVEL and l.to_i < MAX_LEVEL
+  # Additional layer parameters, processors options
+  def data_params
+    @data_layer.data_params
   end
 
-  attr_reader :level
-
-  # Choose other strategy from STRATEGIES
-  def strategy=(s)
-    method = STRATEGIES[s]
-    @strategy = s unless method.nil?
+  # Data from DataLayer, not raw data
+  def data
+    @data_layer.processed_data
   end
 
-  attr_reader :strategy
-
-
-  # This vector will be used to process values (Y'es)
-  # Use proper strategy
-  def generate_vector
-    method = STRATEGIES[@strategy]
-    if method.nil?
-      method = STRATEGIES[DEFAULT_STRATEGY]
-    end
-    return self.send(method)
-  end
-
-  # Process values
   def process
-    t = Time.now
-    old_data = @data_layer.data
-    new_data = Array.new
-
-    (0...old_data.size).each do |i|
-      new_data << {
-        :x => old_data[i][:x],
-        :y => process_part(old_data, i)
-      }
-    end
-
-    puts "Smoothing completed, level #{level}, data size #{old_data.size}, time #{Time.now - t}"
-
-    return new_data
-  end
-
-  # Process part (size depends on level)
-  def process_part(old_data, position)
-    # neutral data, used where position is near edge to calculate new value
-    neutral_data = {
-      :x => old_data[position][:x],
-      :y => old_data[position][:y]
-    }
-    part_array = Array.new(level, neutral_data)
-
-    # add data from old_data to part_array
-    offset = (level/2.0).floor
-    # copying data
-    (0...level).each do |l|
-      copy_pos = position + l - offset
-      # if copy_pos is inside data
-      if copy_pos >= 0 and old_data.size > copy_pos
-        part_array[l] = old_data[copy_pos]
-      end
-    end
-    # here we should have part_array and vector
-    # and now do some magic :]
-
-    if PROCESS_WITH_PARAMETER_DISTANCE == false
-      y_sum = 0.0
-      (0...level).each do |l|
-        y_sum += part_array[l][:y] * vector[l]
-      end
-      return y_sum
-    else
-      # TODO bugs!, issues with NaN
-      # waged average using inverted distance
-      _sum = 0.0
-      _wages = 0.0
-      _x_position = old_data[position][:x]
-
-      (0...level).each do |l|
-        _x_distance = (part_array[l][:x] - _x_position).abs
-        _wage = (1.0 / _x_distance)
-
-        unless _wage.nan?
-          _wages += _wage
-          _sum += (part_array[l][:y] * vector[l]) / _x_distance
-        end
-      end
-      y = _sum.to_f / _wages.to_f
-      puts y
-      return y
-    end
-
-  end
+    # before processing old processed data is overwritten by cloned raw data
+    @data = data
 
+    # update params before processing
+    simple_smoother_initialize(data_params)
+    noise_removal_initialize(data_params)
 
-  # This vector will be used to process values (Y'es), linear algorithm
-  def generate_vector_rectangular
-    @vector = Array.new
-    # calculated
-    (1..level).each do |i|
-      @vector << 1.0 / level.to_f
-    end
-    return @vector
+    # TODO add in options array to choose order of these methods
+    noise_removal_process
+    simple_smoother_process
+    
+    return @data
   end
-
-  # This vector will be used to process values (Y'es), linear algorithm
-  def generate_vector_gauss
-    # http://www.techotopia.com/index.php/Ruby_Math_Functions_and_Methods#Ruby_Math_Constants
-    # http://pl.wikipedia.org/wiki/Okno_czasowe
-
-    # calculation
-    count = (level.to_f / 2.0).floor + 1
-
-    v = Array.new
-    # calculated
-    (1..count).each do |i|
-      v << Math::E ** ((-0.5) * (i*gauss_coeff) ** 2)
-    end
-
-    @vector = make_mirror(v, level)
-
-    normalize_vector
-
-    return @vector
-  end
-
-  # Multiply vector to have sum eq. 1.0
-  def normalize_vector
-    s = 0.0
-    @vector.each do |v|
-      s += v
-    end
-
-    new_vector = Array.new
-
-    @vector.each do |v|
-      new_vector << v / s
-    end
-
-    @vector = new_vector
-
-    return @vector
-  end
-
-  # Make mirror array
-  # size = 7 => [ i[3], i[2], i[1], i[0], i[1], i[2], i[3] ]
-  # size = 8 => [ i[3], i[2], i[1], i[0], i[0], i[1], i[2], i[3] ]
-  def make_mirror(input, size)
-    a = Array.new(size, 0.1)
-    if size.even?
-      # two 'first' in central
-      c_left = size/2 - 1
-      c_right = size/2
-
-      a[c_left] = input[0]
-      a[c_right] = input[0]
-    else
-      # there is one 'first'
-      c_left = (size/2.0).floor
-      c_right = (size/2.0).floor
-
-      a[c_left] = input[0]
-      # a[c_right] = input[0]
-    end
-
-    # the rest
-    i = 0
-    while c_left > 0
-      i += 1
-      c_left -= 1
-      c_right += 1
-
-      a[c_left] = input[i]
-      a[c_right] = input[i]
-    end
-
-    return a
-  end
-
 end

data/lib/technical_graph/data_layer_processor_noise_removal.rb

@@ -0,0 +1,90 @@
+#encoding: utf-8
+
+require 'technical_graph/array'
+
+module DataLayerProcessorNoiseRemoval
+  DEFAULT_NOISE_REMOVAL_LEVEL = 3
+  DEFAULT_NOISE_REMOVAL_WINDOW_SIZE = 10
+
+  def noise_removal_initialize(options)
+    @noise_removal = options[:noise_removal] == true
+    @noise_removal_level = options[:noise_removal_level] || DEFAULT_NOISE_REMOVAL_LEVEL
+    @noise_removal_window_size = options[:noise_removal_window_size] || DEFAULT_NOISE_REMOVAL_WINDOW_SIZE
+  end
+
+  attr_accessor :noise_removal_level, :noise_removal_window_size, :noise_removal
+
+  # Smooth values
+  def noise_removal_process
+    return if noise_removal == false
+
+    t = Time.now
+    new_data = Array.new
+
+    @noises_removed_count = 0
+
+    puts "Noise removal started"
+
+    (0...data.size).each do |i|
+      if not noise?(i)
+        new_data << data[i]
+      else
+        @noises_removed_count += 1
+      end
+    end
+
+    puts "Noise removal completed, removed #{@noises_removed_count}, time #{Time.now - t}"
+
+    @data = new_data
+    return new_data
+  end
+
+  def noise_removal_window_from(i)
+    return i - (noise_removal_window_size.to_f / 2.0).ceil
+  end
+
+  def noise_removal_window_to(i)
+    return i + (noise_removal_window_size.to_f / 2.0).ceil
+  end
+
+  # Check if data at index is noisy
+  def noise?(i)
+    i_from = noise_removal_window_from(i)
+    i_to = noise_removal_window_to(i)
+
+    # create partial array, TODO move it somewhere else
+    part_array = Array.new
+    border = false
+
+    (i_from..i_to).each do |current_i|
+      # outside ranges
+      if current_i < 0
+        part_array << data.first
+        border = true
+        next
+      end
+
+      if data.size <= current_i
+        part_array << data.last
+        border = true
+        next
+      end
+
+      part_array << data[current_i]
+
+    end
+    y_mean = part_array.collect { |p| p.y }.mean
+
+    # another algorithm
+    noise_strength = (data[i].y - y_mean).abs / y_mean
+    return noise_strength_enough?(noise_strength)
+  end
+
+  # Some magic here, beware
+  def noise_strength_enough?(noise_strength)
+    threshold_strength = Math.log(@noise_removal_level)
+    return noise_strength > threshold_strength
+  end
+
+
+end

data/lib/technical_graph/data_layer_processor_simple_smoother.rb

@@ -0,0 +1,234 @@
+#encoding: utf-8
+
+module DataLayerProcessorSimpleSmoother
+  # Smoothing
+  SIMPLE_SMOOTHER_STRATEGIES = {
+    :rectangular => 'generate_vector_rectangular',
+    :gauss => 'generate_vector_gauss'
+  }
+  DEFAULT_SIMPLE_SMOOTHER_STRATEGY = :rectangular
+
+  MIN_SIMPLE_SMOOTHER_LEVEL = 1
+  MAX_SIMPLE_SMOOTHER_LEVEL = 200
+
+  # use 'x' axis for processing also
+  PROCESS_WITH_PARAMETER_DISTANCE = false
+
+  # default Gauss coefficient
+  DEFAULT_GAUSS_COEFF = 0.2
+
+  def simple_smoother_initialize(options)
+    @simple_smoother = options[:simple_smoother] == true
+    @simple_smoother_strategy = options[:simple_smoother_strategy] || DEFAULT_SIMPLE_SMOOTHER_STRATEGY
+    @simple_smoother_level = options[:simple_smoother_level] || MIN_SIMPLE_SMOOTHER_LEVEL
+    @simple_smoother_x = options[:simple_smoother_x] == true
+
+    @vector = Array.new
+    @gauss_coeff = DEFAULT_GAUSS_COEFF
+  end
+
+  attr_reader :vector, :simple_smoother
+  attr_accessor :gauss_coeff
+
+  # Simple_smoother_level of approximation
+  def simple_smoother_level=(l)
+    @simple_smoother_level = l.to_i if l.to_i >= MIN_SIMPLE_SMOOTHER_LEVEL and l.to_i < MAX_SIMPLE_SMOOTHER_LEVEL
+  end
+
+  attr_reader :simple_smoother_level
+
+  # Choose other simple_smoother_strategy from SIMPLE_SMOOTHER_STRATEGIES
+  def simple_smoother_strategy=(s)
+    method = SIMPLE_SMOOTHER_STRATEGIES[s]
+    @simple_smoother_strategy = s unless method.nil?
+  end
+
+  attr_reader :simple_smoother_strategy
+
+  # smooth using X distance
+  attr_accessor :simple_smoother_x
+
+  # This vector will be used to process values (Y'es)
+  # Use proper simple_smoother_strategy
+  def generate_vector
+    method = SIMPLE_SMOOTHER_STRATEGIES[@simple_smoother_strategy]
+    if method.nil?
+      method = SIMPLE_SMOOTHER_STRATEGIES[DEFAULT_SIMPLE_SMOOTHER_STRATEGY]
+    end
+    return self.send(method)
+  end
+
+  # Smooth values
+  def simple_smoother_process
+    # not turned on
+    return if simple_smoother == false
+
+    # vector used for smoothing
+    generate_vector
+
+    t = Time.now
+    old_data = @data
+    new_data = Array.new
+
+    # pre-processing, distance
+    if simple_smoother_x == true
+      puts "X axis distance smoothing enabled"
+
+      (0...old_data.size).each do |i|
+        new_data << DataPoint.xy(old_data[i].x, process_part(old_data, i, false))
+      end
+
+      old_data = new_data
+      new_data = Array.new
+    end
+
+    puts "Y axis distance smoothing"
+
+    (0...old_data.size).each do |i|
+      new_data << DataPoint.xy(old_data[i].x, process_part(old_data, i))
+    end
+
+    puts "Smoothing completed, simple_smoother_level #{simple_smoother_level}, data size #{old_data.size}, time #{Time.now - t}"
+
+    @data = new_data
+    return new_data
+  end
+
+  # Process part (size depends on simple_smoother_level)
+  def process_part(old_data, position, y_based = true)
+    # neutral data, used where position is near edge to calculate new value
+    neutral_data = DataPoint.xy(old_data[position].x, old_data[position].y)
+    part_array = Array.new(simple_smoother_level, neutral_data)
+
+    # add data from old_data to part_array
+    offset = (simple_smoother_level/2.0).floor
+    # copying data
+    (0...simple_smoother_level).each do |l|
+      copy_pos = position + l - offset
+      # if copy_pos is inside data
+      if copy_pos >= 0 and old_data.size > copy_pos
+        part_array[l] = old_data[copy_pos]
+      end
+    end
+    # here we should have part_array and vector
+    # and now do some magic :]
+
+
+    if y_based
+      return process_part_only_y(part_array)
+    else
+      return process_part_only_x(part_array, neutral_data)
+    end
+  end
+
+  # Process part (size depends on simple_smoother_level), only Y data
+  def process_part_only_y(part_array, neutral_data = nil)
+    y_sum = 0.0
+    (0...simple_smoother_level).each do |l|
+      y_sum += part_array[l].y * vector[l]
+    end
+    return y_sum
+  end
+
+  # Process part (size depends on simple_smoother_level), Y and X data
+  def process_part_only_x(part_array, neutral_data)
+    weights = Array.new
+    w_sum = 0.0
+    (0...simple_smoother_level).each do |l|
+      p = part_array[l]
+      x_distance = p.x_distance(neutral_data)
+      w = (Math::E ** (-1.0 * 0.2 * x_distance)) + 1.0
+      w_sum += w
+      weights << w
+    end
+
+    w_prod = 0.0
+    part_array.each_index { |i| w_prod += part_array[i].y * weights[i].to_f }
+    return w_prod.to_f / w_sum.to_f
+  end
+
+  # This vector will be used to process values (Y'es), linear algorithm
+  def generate_vector_rectangular
+    @vector = Array.new
+    # calculated
+    (1..simple_smoother_level).each do |i|
+      @vector << 1.0 / simple_smoother_level.to_f
+    end
+    return @vector
+  end
+
+  # This vector will be used to process values (Y'es), linear algorithm
+  def generate_vector_gauss
+    # http://www.techotopia.com/index.php/Ruby_Math_Functions_and_Methods#Ruby_Math_Constants
+    # http://pl.wikipedia.org/wiki/Okno_czasowe
+
+    # calculation
+    count = (simple_smoother_level.to_f / 2.0).floor + 1
+
+    v = Array.new
+    # calculated
+    (1..count).each do |i|
+      v << Math::E ** ((-0.5) * (i*gauss_coeff) ** 2)
+    end
+
+    @vector = make_mirror(v, simple_smoother_level)
+
+    normalize_vector
+
+    return @vector
+  end
+
+  # Multiply vector to have sum eq. 1.0
+  def normalize_vector
+    s = 0.0
+    @vector.each do |v|
+      s += v
+    end
+
+    new_vector = Array.new
+
+    @vector.each do |v|
+      new_vector << v / s
+    end
+
+    @vector = new_vector
+
+    return @vector
+  end
+
+  # Make mirror array
+  # size = 7 => [ i[3], i[2], i[1], i[0], i[1], i[2], i[3] ]
+  # size = 8 => [ i[3], i[2], i[1], i[0], i[0], i[1], i[2], i[3] ]
+  def make_mirror(input, size)
+    a = Array.new(size, 0.1)
+    if size.even?
+      # two 'first' in central
+      c_left = size/2 - 1
+      c_right = size/2
+
+      a[c_left] = input[0]
+      a[c_right] = input[0]
+    else
+      # there is one 'first'
+      c_left = (size/2.0).floor
+      c_right = (size/2.0).floor
+
+      a[c_left] = input[0]
+      # a[c_right] = input[0]
+    end
+
+    # the rest
+    i = 0
+    while c_left > 0
+      i += 1
+      c_left -= 1
+      c_right += 1
+
+      a[c_left] = input[i]
+      a[c_right] = input[i]
+    end
+
+    return a
+  end
+
+end

data/lib/technical_graph/data_point.rb

@@ -0,0 +1,43 @@
+class DataPoint
+
+  def initialize(h={ :x => 0, :y => 0 })
+    if h.kind_of? Hash
+      @x = h[:x]
+      @y = h[:y]
+    end
+    if h.kind_of? DataPoint
+      @x = h.x
+      @y = h.y
+    end
+  end
+
+  def self.xy(_x, _y)
+    DataPoint.new({ :x=>_x, :y=>_y })
+  end
+
+  def x_distance(other_dp)
+    return (self.x - other_dp.x).abs
+  end
+
+  def y_distance(other_dp)
+    return (self.y - other_dp.y).abs
+  end
+
+  def x
+    @x
+  end
+
+  def y
+    @y
+  end
+
+  def x=(_x)
+    @x = _x
+  end
+
+  def y=(_y)
+    @y = _y
+  end
+
+
+end

data/lib/technical_graph/graph_axis.rb

@@ -42,6 +42,14 @@ class GraphAxis
     options[:y_axis_fixed_interval] == true
   end
 
+  def y_axis_interval
+    options[:y_axis_interval]
+  end
+
+  def x_axis_interval
+    options[:x_axis_interval]
+  end
+
   # Where to put axis values
   def value_axis
     return calc_axis(data_processor.y_min, data_processor.y_max, options[:y_axis_interval], options[:y_axis_count], y_axis_fixed?)
@@ -178,9 +186,10 @@ class GraphAxis
 
     t = Time.now
     plot_axis_y_line.draw(@image)
-    puts "#{Time.now - t} drawing lines"
+    puts "Y axis time #{Time.now - t}, drawing lines"
+    t = Time.now
     plot_axis_y_text.draw(@image)
-    puts "#{Time.now - t} drawing text"
+    puts "Y axis time #{Time.now - t}, drawing text"
   end
 
   def render_parameters_axis
@@ -222,9 +231,10 @@ class GraphAxis
 
     t = Time.now
     plot_axis_x_line.draw(@image)
-    puts "#{Time.now - t} drawing lines"
+    puts "X axis time #{Time.now - t}, drawing lines"
+    t = Time.now
     plot_axis_x_text.draw(@image)
-    puts "#{Time.now - t} drawing text"
+    puts "X axis time #{Time.now - t}, drawing lines"
 
   end
 
@@ -314,7 +324,8 @@ class GraphAxis
       plot_axis_text.pointsize(options[:axis_label_font_size])
       plot_axis_text.font_family('helvetica')
       plot_axis_text.font_style(Magick::NormalStyle)
-      plot_axis_text.text_align(Magick::LeftAlign)
+      #plot_axis_text.text_align(Magick::LeftAlign)
+      plot_axis_text.text_align(Magick::CenterAlign)
       plot_axis_text.text_undercolor(options[:background_color])
 
       plot_axis_text.text(
@@ -332,7 +343,8 @@ class GraphAxis
       plot_axis_text.pointsize(options[:axis_label_font_size])
       plot_axis_text.font_family('helvetica')
       plot_axis_text.font_style(Magick::NormalStyle)
-      plot_axis_text.text_align(Magick::LeftAlign)
+      #plot_axis_text.text_align(Magick::LeftAlign)
+      plot_axis_text.text_align(Magick::CenterAlign)
       plot_axis_text.text_undercolor(options[:background_color])
 
       plot_axis_text = plot_axis_text.rotate(90)

data/lib/technical_graph/graph_image_drawer.rb

@@ -170,6 +170,8 @@ class GraphImageDrawer
 
   # Render data layer
   def render_data_layer(l)
+    layer_data = l.processed_data
+
     layer_line = Magick::Draw.new
     layer_text = Magick::Draw.new
 
@@ -196,21 +198,21 @@ class GraphImageDrawer
     # 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]
+    (0...(layer_data.size - 1)).each do |i|
+      ax = layer_data[i].x
       ax = calc_bitmap_x(ax).round
-      ay = l.data[i][:y]
+      ay = layer_data[i].y
       ay = calc_bitmap_y(ay).round
 
-      bx = l.data[i+1][:x]
+      bx = layer_data[i+1].x
       bx = calc_bitmap_x(bx).round
-      by = l.data[i+1][:y]
+      by = layer_data[i+1].y
       by = calc_bitmap_y(by).round
 
       coords << {
         :ax => ax, :ay => ay,
         :bx => bx, :by => by,
-        :dy => l.data[i][:y]
+        :dy => layer_data[i].y
       }
     end
 

data/lib/technical_graph.rb

@@ -49,8 +49,6 @@ class TechnicalGraph
     @axis.render_on_image(@image)
     # draw layers
     @layers.each do |l|
-      # external processing
-      l.process
       # drawing
       @image_drawer.render_data_layer(l)
     end