technical_graph 0.2.0 → 0.3.0

data/README.md

@@ -137,6 +137,10 @@ Layer options Hash
 * layer_options[:label] - label used in legend
 * layer_options[:color] - color of graph layer, ex.: 'red', 'green', '#FFFF00'
 * layer_options[:antialias] - use anti-aliasing for this, default false, override options[:layers_antialias]
+* layer_options[:value_labels] - write values near 'dots', default true
+* layer_options[:simple_smoother] - 'smooth' data, default false
+* layer_options[:simple_smoother_level] - strength of smoothing, this is level of window used for processing, default 3
+* layer_options[:simple_smoother_strategy] - strategy used for smoothing data, you can choose between :rectangular or :gauss, default :rectangular
 
 
 Contributing to technical-graph

data/Rakefile

@@ -33,8 +33,8 @@ Jeweler::RubygemsDotOrgTasks.new
 
 desc "Remove all images created during tests"
 task :clean do
-  `rm *.svg`
-  `rm *.png`
+  `rm samples/tests/*.svg`
+  `rm samples/tests/*.png`
 end
 
 desc "Clean and release"

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/technical_graph.rb

@@ -49,6 +49,9 @@ 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
     # draw legend

data/lib/technical_graph/data_layer.rb

@@ -1,6 +1,7 @@
 #encoding: utf-8
 
 require 'technical_graph/graph_color_library'
+require 'technical_graph/data_layer_processor'
 
 # Stores only data used for one layer
 # Instances of this class are used elsewhere
@@ -13,12 +14,27 @@ class DataLayer
 
     @data_params[:color] ||= GraphColorLibrary.instance.get_color
     @data_params[:label] ||= ''
+    # default true, write values near dots
+    @data_params[:value_labels] = false if options[:value_labels] == false
+
+    # smoothing parameters
+    # by default it is false
+    @data_params[:simple_smoother] = true if options[:simple_smoother] == true
+    @data_params[:simple_smoother_level] ||= 3
+    @data_params[:simple_smoother_strategy] ||= DataLayerProcessor::DEFAULT_STRATEGY
+    # was already done
+    @data_params[:processor_finished] = false
+
+    @processor = DataLayerProcessor.new(self)
 
     # set data and append initial data
     clear_data
     append_data(d)
   end
 
+  # can be used to approximation and other data processing
+  attr_reader :processor
+
   # Accessor for setting chart data for layer to draw
   def append_data(d)
     if d.kind_of? Array
@@ -33,6 +49,18 @@ class DataLayer
   # Array of {:x =>, :y =>}
   attr_reader :data
 
+  # Run external processor (smoothing, ...)
+  def process
+    if simple_smoother and not processor_finished?
+      @processor.strategy = simple_smoother_strategy
+      @processor.level = simple_smoother_level
+      @processor.generate_vector
+      @data = @processor.process
+
+      processor_finished!
+    end
+  end
+
   # Additional parameters
   attr_reader :data_params
 
@@ -49,6 +77,36 @@ class DataLayer
     return @data_params[:label]
   end
 
+  # Write values near dots
+  def value_labels
+    return @data_params[:value_labels]
+  end
+
+  # Turn on smoothing processor
+  def simple_smoother
+    return @data_params[:simple_smoother]
+  end
+
+  # Smoother level
+  def simple_smoother_level
+    return @data_params[:simple_smoother_level]
+  end
+
+  # Smoother strategy
+  def simple_smoother_strategy
+    return @data_params[:simple_smoother_strategy]
+  end
+
+  # Was already processed?
+  def processor_finished?
+    @data_params[:processor_finished]
+  end
+
+  # Mark as processed
+  def processor_finished!
+    @data_params[:processor_finished] = true
+  end
+
   # Clear data
   def clear_data
     @data = Array.new

data/lib/technical_graph/data_layer_processor.rb

@@ -0,0 +1,212 @@
+#encoding: utf-8
+
+# Approximate data layer
+
+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
+
+  # default Gauss coefficient
+  DEFAULT_GAUSS_COEFF = 0.2
+
+  def initialize(data_layer)
+    @data_layer = data_layer
+    @strategy = DEFAULT_STRATEGY
+    @level = MIN_LEVEL
+    @vector = Array.new
+    @gauss_coeff = DEFAULT_GAUSS_COEFF
+  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
+  end
+
+  attr_reader :level
+
+  # Choose other strategy from STRATEGIES
+  def strategy=(s)
+    method = STRATEGIES[s]
+    @strategy = s unless method.nil?
+  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
+
+
+  # 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
+  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/graph_image_drawer.rb

@@ -215,14 +215,16 @@ class GraphImageDrawer
     end
 
     # labels
-    coords.each do |c|
-      string_label = "#{truncate_string % c[:dy]}"
-      layer_text.text(
-        c[:ax] + 5, c[:ay],
-        string_label
-      )
+    if l.value_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)
     end
-    layer_text.draw(@image)
 
     # lines and circles
     coords.each do |c|
@@ -244,8 +246,8 @@ class GraphImageDrawer
 
       # used for auto positioning of legend
       if legend_auto_position
-        @drawn_points << {:x => c[:ax], :y => c[:ay]}
-        @drawn_points << {:x => c[:bx], :y => c[:by]}
+        @drawn_points << { :x => c[:ax], :y => c[:ay] }
+        @drawn_points << { :x => c[:bx], :y => c[:by] }
       end
     end
     layer_line.draw(@image)
@@ -264,14 +266,14 @@ class GraphImageDrawer
 
     # check 8 places:
     positions = [
-      {:x => legend_margin, :y => 0 + legend_margin}, # top-left
-      {:x => width/2, :y => 0 + legend_margin}, # top-center
-      {:x => width - legend_margin - legend_width, :y => 0 + legend_margin}, # top-right
-      {:x => legend_margin, :y => height/2}, # middle-left
-      {:x => width - legend_margin - legend_width, :y => height/2}, # middle-right
-      {:x => legend_margin, :y => height - legend_margin - legend_height}, # bottom-left
-      {:x => width/2, :y => height - legend_margin - legend_height}, # bottom-center
-      {:x => width - legend_margin - legend_width, :y => height - legend_margin - legend_height}, # bottom-right
+      { :x => legend_margin, :y => 0 + legend_margin }, # top-left
+      { :x => width/2, :y => 0 + legend_margin }, # top-center
+      { :x => width - legend_margin - legend_width, :y => 0 + legend_margin }, # top-right
+      { :x => legend_margin, :y => height/2 }, # middle-left
+      { :x => width - legend_margin - legend_width, :y => height/2 }, # middle-right
+      { :x => legend_margin, :y => height - legend_margin - legend_height }, # bottom-left
+      { :x => width/2, :y => height - legend_margin - legend_height }, # bottom-center
+      { :x => width - legend_margin - legend_width, :y => height - legend_margin - legend_height }, # bottom-right
     ]
 
     # calculate nearest distance of all drawn points
@@ -279,7 +281,7 @@ class GraphImageDrawer
       p[:distance] = (width ** 2 + height ** 2) ** 0.5 # max distance, diagonal of graph
       @drawn_points.each do |dp|
         # calculate drawn point distance to being checked now legend position
-        two_points_distance = ( (p[:x] - dp[:x]) ** 2 + (p[:y] - dp[:y]) ** 2 ) ** 0.5
+        two_points_distance = ((p[:x] - dp[:x]) ** 2 + (p[:y] - dp[:y]) ** 2) ** 0.5
         # modify only if distance is closer
         if p[:distance] > two_points_distance
           p[:distance] = two_points_distance
@@ -288,7 +290,7 @@ class GraphImageDrawer
     end
 
     # chose position with hihest distance
-    positions.sort!{|a,b| a[:distance] <=> b[:distance]}
+    positions.sort! { |a, b| a[:distance] <=> b[:distance] }
     best_position = positions.last
     options[:legend_x] = best_position[:x]
     options[:legend_y] = best_position[:y]
@@ -318,7 +320,7 @@ class GraphImageDrawer
 
     layers.each do |l|
       legend_text.fill(l.color)
-      
+
       string_label = l.label
       legend_text.text(
         x, y,

data/test/test_technical_autocolor.rb

@@ -82,7 +82,7 @@ class TestTechnicalAutocolor < Test::Unit::TestCase
 
       @tg.render
 
-      @tg.image_drawer.save_to_file('test_autocolor.png')
+      @tg.image_drawer.save_to_file('samples/tests/test_autocolor.png')
       @tg.image_drawer.to_png.class.should == String
 
     end

data/test/test_technical_axis_enlarge.rb

@@ -58,8 +58,8 @@ class TestTechnicalAxisEnlarge < Test::Unit::TestCase
 
       @tg.render
 
-      @tg.image_drawer.save_to_file('test_axis_enlarge.png')
-      @tg.image_drawer.save_to_file('test_axis_enlarge.svg')
+      @tg.image_drawer.save_to_file('samples/tests/test_axis_enlarge.png')
+      @tg.image_drawer.save_to_file('samples/tests/test_axis_enlarge.svg')
       @tg.image_drawer.to_png.class.should == String
 
     end

data/test/test_technical_graph.rb

@@ -67,7 +67,7 @@ class TestTechnicalGraph < Test::Unit::TestCase
       layer.data.size.should == 2 * @data_size
 
       # @tg.render
-      # @tg.image.save_to_file('test1.png')
+      # @tg.image.save_to_file('samples/tests/test1.png')
     end
 
     should 'has ability to filter records with similar x\'es' do

data/test/test_technical_graph_axis.rb

@@ -262,7 +262,7 @@ class TestTechnicalGraphAxis < Test::Unit::TestCase
       @tg.axis.parameter_axis.should == [-8.0, -6.0, -4.0, -2.0, 0.0, 2.0, 4.0, 6.0]
       @tg.axis.value_axis.should == [-4.0, -2.0, 0.0, 2.0]
 
-      @tg.image_drawer.save_to_file('test1.png')
+      @tg.image_drawer.save_to_file('samples/tests/test1.png')
     end
 
 
@@ -297,7 +297,7 @@ class TestTechnicalGraphAxis < Test::Unit::TestCase
 
       @tg.render
 
-      @tg.image_drawer.save_to_file('test2.png')
+      @tg.image_drawer.save_to_file('samples/tests/test2.png')
     end
 
   end

data/test/test_technical_multilayer.rb

@@ -86,7 +86,7 @@ class TestTechnicalMultilayer < Test::Unit::TestCase
 
       @tg.render
 
-      @tg.image_drawer.save_to_file('test_multilayer.png')
+      @tg.image_drawer.save_to_file('samples/tests/test_multilayer.png')
       @tg.image_drawer.to_png.class.should == String
 
     end

data/test/test_technical_simple_graph.rb

@@ -54,7 +54,7 @@ class TestTechnicalSimpleGraph < Test::Unit::TestCase
 
       @tg.render
 
-      @tg.image_drawer.save_to_file('test_simple.png')
+      @tg.image_drawer.save_to_file('samples/tests/test_simple.png')
       @tg.image_drawer.to_png.class.should == String
 
     end

data/test/test_technical_smoother.rb

@@ -0,0 +1,214 @@
+require 'helper'
+
+class TestTechnicalSmoother < Test::Unit::TestCase
+  context 'calculations' do
+    setup do
+      max = 500
+
+      # adding simple layer
+      @layer_params = {
+        :antialias => true,
+        :label => 'first',
+        :value_labels => false,
+        :simple_smother => 4
+      }
+      @layer_data = Array.new
+      (0..max).each do |i|
+        x = -10.0 + (20.0 * i.to_f / max.to_f)
+        y = 10.0 * Math.cos(i.to_f * (0.5 * 3.14 / max.to_f))
+
+        y += rand
+        x += rand / max.to_f
+
+        @layer_data << { :x => x, :y => y }
+      end
+
+
+      @data_layer = DataLayer.new(@layer_data, @layer_params)
+      @processor = @data_layer.processor
+    end
+
+    should 'do some basic tests' do
+      @processor.should.kind_of? DataLayerProcessor
+    end
+
+    should 'calculated vector has proper size and sum eq. 1.0' do
+      @processor.generate_vector.should.kind_of? Array
+      @processor.generate_vector.size.should == @processor.level
+
+      DataLayerProcessor::STRATEGIES.keys.each do |s|
+        @processor.strategy = s
+        @processor.strategy.should == s
+
+        (1...10).each do |i|
+          @processor.level = i
+          @processor.level.should == i
+
+          @processor.generate_vector.size.should == @processor.level
+
+          s = 0.0
+          @processor.generate_vector.each do |t|
+            s += t
+          end
+          s.should be_within(0.01).of(1.0)
+
+          # puts @processor.vector.inspect
+        end
+      end
+
+    end
+
+    should 'processed data has the same size that old one' do
+      DataLayerProcessor::STRATEGIES.keys.each do |s|
+        @processor.strategy = s
+        @processor.strategy.should == s
+        (1...9).each do |i|
+          @processor.level = i
+          @processor.level.should == i
+
+          @processor.generate_vector.size.should == @processor.level
+
+          new_data = @processor.process
+          new_data.size.should == @data_layer.data.size
+
+          # add as new layer
+          #@data_layer = DataLayer.new(@layer_data, @layer_params)
+          # @tg.add_layer(new_data, @layer_params)
+        end
+      end
+    end
+
+    should 'create simple graph with unprocessed and processed layer (gauss)' do
+      tg = TechnicalGraph.new(
+        {
+          :width => 2000,
+          :height => 1500,
+        }
+      )
+      max = 1000
+
+      # adding simple layer
+      layer_params = {
+        :antialias => true,
+        :color => 'red',
+        :label => 'raw',
+        :value_labels => false,
+        # :simple_smother => 8
+      }
+      layer_data = Array.new
+      (0..max).each do |i|
+        x = -10.0 + (20.0 * i.to_f / max.to_f)
+        y = 10.0 * Math.cos(i.to_f * (0.5 * 3.14 / max.to_f))
+
+        y += rand
+        x += rand / max.to_f
+
+        layer_data << { :x => x, :y => y }
+      end
+
+      # non processed
+      tg.add_layer(layer_data, layer_params)
+
+      # process and add
+      approx = layer_data_b = tg.layers[0].processor
+      approx.strategy = :gauss
+      approx.level = 9
+      approx.generate_vector
+      
+      layer_data_b = approx.process
+      layer_params_b = {
+        :antialias => false,
+        :color => 'blue',
+        :label => 'processed',
+        :value_labels => false,
+        # :simple_smother => 9
+      }
+      tg.add_layer(layer_data_b, layer_params_b)
+
+      tg.render
+      tg.image_drawer.save_to_file('samples/tests/test_simple_gauss.png')
+    end
+
+    should 'create simple graph using only layer params' do
+      tg = TechnicalGraph.new(
+        {
+          :width => 5000,
+          :height => 3000,
+
+          :legend => true,
+          :legend_auto => true,
+          :legend_width => 90,
+          :legend_margin => 60,
+          :legend_x => 50,
+          :legend_y => 50,
+        }
+      )
+      max = 2000
+
+      layer_data = Array.new
+      (0..max).each do |i|
+        x = -10.0 + (20.0 * i.to_f / max.to_f)
+        y = 10.0 * Math.cos(i.to_f * (2.0 * 3.14 / max.to_f))
+
+        y += rand * 4.0
+        x += rand / max.to_f
+
+        layer_data << { :x => x, :y => y }
+      end
+
+      # adding simple layer
+      layer_params = {
+        :antialias => false,
+        :color => 'red',
+        :label => 'raw',
+        :value_labels => false,
+        :simple_smoother => true,
+        :simple_smoother_level => 1,
+        :simple_smoother_strategy => :gauss
+      }
+      #tg.add_layer(layer_data.clone, layer_params)
+      #layer_params_b = layer_params.merge({
+      #  :color => 'blue',
+      #  :label => 'processed - level 3',
+      #  :simple_smoother_level => 3,
+      #  :simple_smoother => true
+      #})
+      #tg.add_layer(layer_data.clone, layer_params)
+      layer_params_c = layer_params.clone.merge({
+        :color => 'green',
+        :label => 'processed - level 100',
+        :simple_smoother_level => 100,
+        :simple_smoother => true
+      })
+      #tg.add_layer(layer_data.clone, layer_params)
+      #layer_params_d = layer_params.clone.merge({
+      #  :color => 'brown',
+      #  :label => 'processed - level 50',
+      #  :simple_smoother_level => 50,
+      #  :simple_smoother => true
+      #})
+      tg.add_layer(layer_data.clone, layer_params)
+      #tg.add_layer(layer_data.clone, layer_params_b)
+      tg.add_layer(layer_data.clone, layer_params_c)
+      #tg.add_layer(layer_data.clone, layer_params_d)
+
+
+      layer_params_e = layer_params.clone.merge({
+        :color => 'blue',
+        :label => 'processed (rectangular) - level 100',
+        :simple_smoother_level => 100,
+        :simple_smoother => true,
+        :simple_smoother_strategy => :rectangular
+      })
+      tg.add_layer(layer_data.clone, layer_params_e)
+
+
+      tg.render
+      tg.image_drawer.save_to_file('samples/tests/test_smoothing_multiple.png')
+    end
+
+
+  end
+
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: technical_graph
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Aleksander Kwiatkowski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-09 00:00:00 +02:00
+date: 2011-10-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -122,6 +122,7 @@ files:
 - VERSION
 - lib/technical_graph.rb
 - lib/technical_graph/data_layer.rb
+- lib/technical_graph/data_layer_processor.rb
 - lib/technical_graph/graph_axis.rb
 - lib/technical_graph/graph_color_library.rb
 - lib/technical_graph/graph_data_processor.rb
@@ -133,6 +134,7 @@ files:
 - test/test_technical_graph_axis.rb
 - test/test_technical_multilayer.rb
 - test/test_technical_simple_graph.rb
+- test/test_technical_smoother.rb
 has_rdoc: true
 homepage: http://github.com/akwiatkowski/technical_graph
 licenses: