technical_graph 0.1.1 → 0.1.2

data/Gemfile

@@ -5,8 +5,6 @@ gem 'rmagick'
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem 'jeweler'
-
   gem "shoulda"
   gem "bundler", "~> 1.0.0"
   gem "rspec"

data/README.md

@@ -121,6 +121,15 @@ size will be enlarged to maintain set distanced between axis.
 * options[:x_axis_min_distance] - minimum distance between X axis, default 30 pixels
 * options[:y_axis_min_distance] - minimum distance between X axis, default 50 pixels
 
+Legend options:
+
+* options[:legend] - draw legend, default false
+* options[:legend_auto] - let legend position to be chosen by algorithm, default true
+* options[:legend_width] - width used for setting proper distance while drawing on right, default 100, legend height is calculated
+* options[:legend_margin] - graph margin used not to draw legend on border, default 50
+* options[:legend_x] - legend X position, default 50
+* options[:legend_y] - legend Y position, default 50
+
 
 Layer options Hash
 ------------------

data/Rakefile

@@ -24,10 +24,23 @@ Jeweler::Tasks.new do |gem|
   gem.authors = ["Aleksander Kwiatkowski"]
 
   #gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+  gem.files = FileList[
+    "[A-Z]*", "{bin,generators,lib,test}/**/*"
+  ]
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
 
+desc "Remove all images created during tests"
+task :clean do
+  `rm *.svg`
+  `rm *.png`
+end
+
+desc "Clean and release"
+task :clean_and_release => [:clean, :release] do
+end
+
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/technical_graph/data_layer.rb

@@ -40,6 +40,10 @@ class DataLayer
     return @data_params[:antialias]
   end
 
+  def label
+    return @data_params[:label] || '' #'data'
+  end
+
   # Clear data
   def clear_data
     @data = Array.new

data/lib/technical_graph/graph_image_drawer.rb

@@ -71,6 +71,17 @@ class GraphImageDrawer
     options[:axis_font_size] ||= 10
     options[:layers_font_size] ||= 10
     options[:axis_label_font_size] ||= 10
+
+    # legend
+    options[:legend] = false if options[:legend].nil?
+    options[:legend_auto] = true if options[:legend_auto].nil?
+    options[:legend_x] ||= 50
+    options[:legend_y] ||= 50
+    options[:legend_width] ||= 100
+    options[:legend_margin] ||= 50
+
+    # array of all points drawn on graph, used for auto positioning of legend
+    @drawn_points = Array.new
   end
 
   def width
@@ -93,6 +104,30 @@ class GraphImageDrawer
     options[:font_antialias] == true
   end
 
+  def draw_legend?
+    options[:legend]
+  end
+
+  def legend_x
+    options[:legend_x]
+  end
+
+  def legend_y
+    options[:legend_y]
+  end
+
+  def legend_auto_position
+    options[:legend_auto]
+  end
+
+  def legend_width
+    options[:legend_width]
+  end
+
+  def legend_margin
+    options[:legend_margin]
+  end
+
   # Calculate image X position
   def calc_bitmap_x(_x)
     l = data_processor.x_max - data_processor.x_min
@@ -206,11 +241,101 @@ class GraphImageDrawer
         c[:ax], c[:ay],
         c[:bx], c[:by]
       )
+
+      # 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]}
+      end
     end
     layer_line.draw(@image)
 
   end
 
+  # height of 1 layer
+  ONE_LAYER_LEGEND_HEIGHT = 15
+
+  # Choose best location
+  def recalculate_legend_position
+    return unless legend_auto_position
+    puts "Auto position calculation, drawn points #{@drawn_points.size}"
+
+    legend_height = layers.size * ONE_LAYER_LEGEND_HEIGHT
+
+    # 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
+    ]
+
+    # calculate nearest distance of all drawn points
+    positions.each do |p|
+      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
+        # modify only if distance is closer
+        if p[:distance] > two_points_distance
+          p[:distance] = two_points_distance
+        end
+      end
+    end
+
+    # chose position with hihest 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]
+
+    puts "Best position x #{options[:legend_x]}, y #{options[:legend_y]}, distance #{best_position[:distance]}"
+    # puts positions.to_yaml
+  end
+
+  # Render legend on graph
+  def render_data_legend
+    return unless draw_legend?
+
+    recalculate_legend_position
+
+    legend_text = Magick::Draw.new
+    legend_text_antialias = options[:layers_font_size]
+    legend_text.stroke_antialias(legend_text_antialias)
+    legend_text.text_antialias(legend_text_antialias)
+    legend_text.pointsize(options[:axis_font_size])
+    legend_text.font_family('helvetica')
+    legend_text.font_style(Magick::NormalStyle)
+    legend_text.text_align(Magick::LeftAlign)
+    legend_text.text_undercolor(options[:background_color])
+
+    x = legend_x
+    y = legend_y
+
+    layers.each do |l|
+      legend_text.fill(l.color)
+      
+      string_label = l.label
+      legend_text.text(
+        x, y,
+        string_label
+      )
+
+      # little dot
+      legend_text.circle(
+        x - 10, y,
+        x - 10 + 3, y
+      )
+
+      y += ONE_LAYER_LEGEND_HEIGHT
+    end
+    legend_text.draw(@image)
+  end
+
   # Save output to file
   def save_to_file(file)
     @image.write(file)

data/lib/technical_graph.rb

@@ -51,5 +51,7 @@ class TechnicalGraph
     @layers.each do |l|
       @image_drawer.render_data_layer(l)
     end
+    # draw legend
+    @image_drawer.render_data_legend
   end
 end

data/test/test_technical_multilayer.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+class TestTechnicalMultilayer < Test::Unit::TestCase
+  context 'initial options' do
+    should 'draw multilayer graph' do
+      @tg = TechnicalGraph.new(
+        {
+          :truncate_string => "%.1f",
+
+          :x_axis_label => 'x',
+          :y_axis_label => 'y',
+
+          :axis_antialias => true,
+          :layers_antialias => true,
+          :font_antialias => true,
+
+          :layers_font_size => 11,
+          :axis_font_size => 11,
+          :axis_label_font_size => 20,
+
+          #:x_axis_count => 20,
+          #:y_axis_count => 20,
+          #:x_axis_interval => 1.0,
+          #:y_axis_interval => 1.0,
+          #:x_axis_fixed_interval => false,
+          #:y_axis_fixed_interval => false,
+
+          #:x_min => -10.0,
+          #:x_max => 10.0,
+          #:y_min => -10.0,
+          #:y_max => 10.0,
+
+          #:width => 4000,
+          #:height => 3000,
+
+          :legend => true,
+          :legend_auto => true,
+          :legend_width => 90,
+          :legend_margin => 60,
+          :legend_x => 50,
+          :legend_y => 50,
+        }
+      )
+
+      max = 50
+
+      # adding simple layer
+      layer_params_a = {
+        :antialias => true,
+        :color => 'red',
+        :label => 'first'
+      }
+      layer_params_b = {
+        :antialias => true,
+        :color => 'green',
+        :label => 'second'
+      }
+      layer_params_c = {
+        :antialias => true,
+        :color => 'blue',
+        :label => 'third'
+      }
+      layer_params_d = {
+        :antialias => true,
+        :color => 'purple',
+        :label => 'fourth'
+      }
+      layer_data_a = Array.new
+      layer_data_b = Array.new
+      layer_data_c = Array.new
+      layer_data_d = Array.new
+      (0..max).each do |i|
+        layer_data_a << { :x => -10.0 + i.to_f, :y => 10.0 * Math.cos(i.to_f * (4.0 * 3.14 / max.to_f)) }
+        layer_data_b << { :x => -10.0 + i.to_f, :y => 10.0 * Math.cos(0.3 + i.to_f * (4.0 * 3.14 / max.to_f)) }
+        layer_data_c << { :x => -10.0 + i.to_f, :y => 10.0 * Math.cos(0.6 + i.to_f * (4.0 * 3.14 / max.to_f)) }
+        layer_data_d << { :x => -10.0 + i.to_f, :y => 10.0 * Math.cos(0.9 + i.to_f * (4.0 * 3.14 / max.to_f)) }
+      end
+      @tg.add_layer(layer_data_a, layer_params_a)
+      @tg.add_layer(layer_data_b, layer_params_b)
+      @tg.add_layer(layer_data_c, layer_params_c)
+      @tg.add_layer(layer_data_d, layer_params_d)
+
+
+      @tg.layers.last.data.size.should > 0
+      @tg.layers.size.should == 4
+
+      @tg.render
+
+      @tg.image_drawer.save_to_file('test_multilayer.png')
+      @tg.image_drawer.to_png.class.should == String
+
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: technical_graph
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Aleksander Kwiatkowski
@@ -43,26 +43,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  name: jeweler
+  name: shoulda
   version_requirements: *id002
   prerelease: false
 - !ruby/object:Gem::Dependency 
   type: :development
   requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  name: shoulda
-  version_requirements: *id003
-  prerelease: false
-- !ruby/object:Gem::Dependency 
-  type: :development
-  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -74,11 +60,11 @@ dependencies:
         - 0
         version: 1.0.0
   name: bundler
-  version_requirements: *id004
+  version_requirements: *id003
   prerelease: false
 - !ruby/object:Gem::Dependency 
   type: :development
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -88,11 +74,11 @@ dependencies:
         - 0
         version: "0"
   name: rspec
-  version_requirements: *id005
+  version_requirements: *id004
   prerelease: false
 - !ruby/object:Gem::Dependency 
   type: :development
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -102,11 +88,11 @@ dependencies:
         - 0
         version: "0"
   name: jeweler
-  version_requirements: *id006
+  version_requirements: *id005
   prerelease: false
 - !ruby/object:Gem::Dependency 
   type: :development
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -116,7 +102,7 @@ dependencies:
         - 0
         version: "0"
   name: rcov
-  version_requirements: *id007
+  version_requirements: *id006
   prerelease: false
 description: Purpose of this gem is to create neat, simple, technical graphs. This is alternative to most new libraries which create small, candy graphs using JavaScript.
 email: bobikx@poczta.fm
@@ -128,9 +114,6 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files: 
-- .document
-- .idea/dictionaries/olek.xml
-- .rvmrc
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -142,18 +125,11 @@ files:
 - lib/technical_graph/graph_axis.rb
 - lib/technical_graph/graph_data_processor.rb
 - lib/technical_graph/graph_image_drawer.rb
-- lib/technical_graph/refactoring_backup/lib/technical_graph.rb
-- lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer.rb
-- lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer_draw_module.rb
-- lib/technical_graph/refactoring_backup/test/test_technical_graph.rb
-- lib/technical_graph/refactoring_backup/test/test_technical_graph_axis.rb
-- samples/1.png
-- samples/home_io_batt_voltage.png
-- technical_graph.gemspec
 - test/helper.rb
 - test/test_technical_axis_enlarge.rb
 - test/test_technical_graph.rb
 - test/test_technical_graph_axis.rb
+- test/test_technical_multilayer.rb
 - test/test_technical_simple_graph.rb
 has_rdoc: true
 homepage: http://github.com/akwiatkowski/technical_graph

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/.idea/dictionaries/olek.xml

@@ -1,8 +0,0 @@
-<component name="ProjectDictionaryState">
-  <dictionary name="olek">
-    <words>
-      <w>antialias</w>
-      <w>magick</w>
-    </words>
-  </dictionary>
-</component>

data/.rvmrc

@@ -1 +0,0 @@
-rvm use 1.8.7@technical_graph --create

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

@@ -1,151 +0,0 @@
-#encoding: utf-8
-
-require 'technical_graph/axis_layer_draw_module'
-
-# Decide min/max values, recalculate all points and draw axis
-
-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 axis
-    @options[:y_axis_count] ||= 10
-    @options[:x_axis_count] ||= 10
-    # interval
-    @options[:y_axis_interval] ||= 1.0
-    @options[:x_axis_interval] ||= 1.0
-    # when false then axis are generated to meet 'count'
-    # when true then axis are generated every X from lowest
-    @options[:x_axis_fixed_interval] = true if @options[:x_axis_fixed_interval].nil?
-    @options[:y_axis_fixed_interval] = true if @options[:y_axis_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

@@ -1,145 +0,0 @@
-module AxisLayerDrawModule
-  def x_axis_fixed?
-     @options[:x_axis_fixed_interval] == true
-   end
-
-  # Value axis has fixed count
-  def y_axis_fixed?
-     @options[:y_axis_fixed_interval] == true
-   end
-
-  # Where to put axis values
-  def value_axis
-    return calc_axis(self.y_min, self.y_max, @options[:y_axis_interval], @options[:y_axis_count], y_axis_fixed?)
-  end
-
-  # Where to put axis values
-  def parameter_axis
-    return calc_axis(self.x_min, self.x_max, @options[:x_axis_interval], @options[:x_axis_count], x_axis_fixed?)
-  end
-
-  # Calculate axis using 2 methods
-  def calc_axis(from, to, interval, count, fixed_interval)
-    axis = Array.new
-    l = to - from
-    current = from
-    
-    if fixed_interval
-      while current < to
-        axis << current
-        current += interval
-      end
-      return axis
-
-    else
-      (0...count).each do |i|
-        axis << from + (l.to_f * i.to_f) / count.to_f
-      end
-      return axis
-
-    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_axis.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_axis.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

@@ -1,55 +0,0 @@
-#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

@@ -1,104 +0,0 @@
-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

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

@@ -1,306 +0,0 @@
-require 'helper'
-
-class TestTechnicalGraphAxis < Test::Unit::TestCase
-  context 'ranges calculation' do
-    setup do
-    end
-
-    should 'provide defined ranges' do
-      x_min = 0.0
-      x_max = 10.0
-      y_min = -5.0
-      y_max = 5.0
-
-      @tg = TechnicalGraph.new(
-        {
-          :x_min => x_min,
-          :x_max => x_max,
-          :y_min => y_min,
-          :y_max => y_max,
-          :xy_behaviour => :fixed
-        }
-      )
-      @tg.render
-
-      @tg.axis.x_min.should == x_min
-      @tg.axis.x_max.should == x_max
-      @tg.axis.y_min.should == y_min
-      @tg.axis.y_max.should == y_max
-    end
-
-    should 'calculate ranges per layer' do
-      # adding simple layer
-      layer_data = [
-        { :x => -1, :y => 3.0 },
-        { :x => 3, :y => -8.0 },
-        { :x => 0, :y => 3.0 },
-        { :x => 10, :y => 10.0 }
-      ]
-      dl = DataLayer.new(layer_data)
-
-      dl.x_min.should == -1
-      dl.x_max.should == 10
-      dl.y_min.should == -8.0
-      dl.y_max.should == 10.0
-    end
-
-
-    should 'provide ranges calculated using data layer, and multiple layers' do
-      x_min = 0.0
-      x_max = 1.0
-      y_min = -1.0
-      y_max = 1.0
-
-      @tg = TechnicalGraph.new(
-        {
-          :x_min => x_min,
-          :x_max => x_max,
-          :y_min => y_min,
-          :y_max => y_max,
-          :xy_behaviour => :default
-        }
-      )
-
-      # adding simple layer
-      layer_data = [
-        { :x => -1, :y => 3.0 },
-        { :x => 3, :y => -8.0 },
-        { :x => 0, :y => 3.0 },
-        { :x => 10, :y => 10.0 }
-      ]
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 0
-      # checking ranger for layer
-
-      @tg.render
-
-
-      @tg.axis.x_min.should_not == x_min
-      @tg.axis.x_max.should_not == x_max
-      @tg.axis.y_min.should_not == y_min
-      @tg.axis.y_max.should_not == y_max
-
-      @tg.axis.x_min.should == -1
-      @tg.axis.x_max.should == 10
-      @tg.axis.y_min.should == -8.0
-      @tg.axis.y_max.should == 10.0
-
-
-
-      # adding another layer
-
-      # adding simple layer
-      layer_data = [
-        { :x => -21, :y => -93.0 },
-        { :x => -5, :y => 3.0 },
-        { :x => 39, :y => -8.0 },
-        { :x => 0, :y => 333.0 },
-        { :x => 10, :y => 50.0 }
-      ]
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 1
-
-      @tg.render
-
-      @tg.axis.x_min.should_not == x_min
-      @tg.axis.x_max.should_not == x_max
-      @tg.axis.y_min.should_not == y_min
-      @tg.axis.y_max.should_not == y_max
-
-      @tg.axis.x_min.should_not == -1.0
-      @tg.axis.x_max.should_not == 10.0
-      @tg.axis.y_min.should_not == -8.0
-      @tg.axis.y_max.should_not == 10.0
-
-      @tg.axis.x_min.should == -21.0
-      @tg.axis.x_max.should == 39.0
-      @tg.axis.y_min.should == -93.0
-      @tg.axis.y_max.should == 333.0
-    end
-
-    should 'provide ranges calculated with zoom' do
-      x_min = 0.0
-      x_max = 1.0
-      y_min = -1.0
-      y_max = 1.0
-
-      @tg = TechnicalGraph.new(
-        {
-          :x_min => x_min,
-          :x_max => x_max,
-          :y_min => y_min,
-          :y_max => y_max,
-          :xy_behaviour => :default
-        }
-      )
-
-      # adding simple layer
-      layer_data = [
-        { :x => -5, :y => 5.0 },
-        { :x => 2, :y => -5.0 },
-        { :x => 0, :y => 5.0 },
-        { :x => 5, :y => 5.0 }
-      ]
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 0
-      # checking ranger for layer
-
-      @tg.render
-
-
-      @tg.axis.x_min.should_not == x_min
-      @tg.axis.x_max.should_not == x_max
-      @tg.axis.y_min.should_not == y_min
-      @tg.axis.y_max.should_not == y_max
-
-      @tg.axis.x_min.should == -5
-      @tg.axis.x_max.should == 5
-      @tg.axis.y_min.should == -5.0
-      @tg.axis.y_max.should == 5.0
-
-      @tg.axis.zoom = 2.0
-
-      @tg.axis.x_min.should == -10.0
-      @tg.axis.x_max.should == 10.0
-      @tg.axis.y_min.should == -10.0
-      @tg.axis.y_max.should == 10.0
-
-      @tg.axis.x_min.should_not == -5
-      @tg.axis.x_max.should_not == 5
-      @tg.axis.y_min.should_not == -5.0
-      @tg.axis.y_max.should_not == 5.0
-
-      @tg.axis.raw_x_min.should == -5
-      @tg.axis.raw_x_max.should == 5
-      @tg.axis.raw_y_min.should == -5.0
-      @tg.axis.raw_y_max.should == 5.0
-    end
-
-
-    should 'calculate axis with fixed interval' do
-      x_min = -5.0
-      x_max = 5.0
-      y_min = -5.0
-      y_max = 5.0
-
-      @tg = TechnicalGraph.new(
-        {
-          :x_min => x_min,
-          :x_max => x_max,
-          :y_min => y_min,
-          :y_max => y_max,
-          :xy_behaviour => :fixed,
-
-          :y_axis_count => 10,
-          :x_axis_count => 10,
-          :y_axis_interval => 1.0,
-          :x_axis_interval => 4.0,
-          :x_axis_fixed_interval => true,
-          :y_axis_fixed_interval => true
-        }
-      )
-
-      # adding simple layer
-      layer_data = [
-        { :x => -1, :y => 2.0 },
-        { :x => 1, :y => -2.0 },
-        { :x => 0, :y => 2.0 },
-        { :x => 1, :y => 2.0 }
-      ]
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 0
-      # checking ranger for layer
-
-      @tg.render
-
-      @tg.axis.value_axis.should == [-5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0]
-      @tg.axis.parameter_axis.should == [-5.0, -1.0, 3.0]
-    end
-
-
-    should 'calculate axis with fixed count' do
-      x_min = -8.0
-      x_max = 8.0
-      y_min = -4.0
-      y_max = 4.0
-
-      @tg = TechnicalGraph.new(
-        {
-          :x_min => x_min,
-          :x_max => x_max,
-          :y_min => y_min,
-          :y_max => y_max,
-          :xy_behaviour => :fixed,
-
-          :x_axis_count => 8,
-          :y_axis_count => 4,
-          :x_axis_interval => 2.0,
-          :y_axis_interval => 1.0,
-          :x_axis_fixed_interval => false,
-          :y_axis_fixed_interval => false
-        }
-      )
-
-      # adding simple layer
-      layer_data = [
-        { :x => -1, :y => 2.0 },
-        { :x => 1, :y => -2.0 },
-        { :x => 0, :y => 2.0 },
-        { :x => 1, :y => 2.0 }
-      ]
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 0
-      # checking ranger for layer
-
-      @tg.render
-
-      @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.save_to_file('test1.png')
-    end
-
-
-    should 'draw simple graph' do
-      @tg = TechnicalGraph.new(
-        {
-          :x_axis_count => 10,
-          :y_axis_count => 10,
-          :x_axis_interval => 1.0,
-          :y_axis_interval => 1.0,
-          :x_axis_fixed_interval => false,
-          :y_axis_fixed_interval => false,
-
-          :x_min => -10.0,
-          :x_max => 10.0,
-          :y_min => -10.0,
-          :y_max => 10.0
-        }
-      )
-
-
-
-      # adding simple layer
-      layer_data = Array.new
-      (0..20).each do |i|
-        layer_data << {:x => Math.sin(i.to_f/10.0) * 10.0, :y => Math.cos(i.to_f/10.0) * 10.0 }
-      end
-      @tg.add_layer(layer_data)
-      # should be added
-      @tg.layers.last.data.size > 0
-      # checking ranger for layer
-
-      @tg.render
-
-      @tg.image.save_to_file('test2.png')
-    end
-
-  end
-
-end
-

data/technical_graph.gemspec

@@ -1,84 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{technical_graph}
-  s.version = "0.1.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Aleksander Kwiatkowski"]
-  s.date = %q{2011-10-09}
-  s.description = %q{Purpose of this gem is to create neat, simple, technical graphs. This is alternative to most new libraries which create small, candy graphs using JavaScript.}
-  s.email = %q{bobikx@poczta.fm}
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    ".document",
-    ".idea/dictionaries/olek.xml",
-    ".rvmrc",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "lib/technical_graph.rb",
-    "lib/technical_graph/data_layer.rb",
-    "lib/technical_graph/graph_axis.rb",
-    "lib/technical_graph/graph_data_processor.rb",
-    "lib/technical_graph/graph_image_drawer.rb",
-    "lib/technical_graph/refactoring_backup/lib/technical_graph.rb",
-    "lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer.rb",
-    "lib/technical_graph/refactoring_backup/lib/technical_graph/axis_layer_draw_module.rb",
-    "lib/technical_graph/refactoring_backup/test/test_technical_graph.rb",
-    "lib/technical_graph/refactoring_backup/test/test_technical_graph_axis.rb",
-    "samples/1.png",
-    "samples/home_io_batt_voltage.png",
-    "technical_graph.gemspec",
-    "test/helper.rb",
-    "test/test_technical_axis_enlarge.rb",
-    "test/test_technical_graph.rb",
-    "test/test_technical_graph_axis.rb",
-    "test/test_technical_simple_graph.rb"
-  ]
-  s.homepage = %q{http://github.com/akwiatkowski/technical_graph}
-  s.licenses = ["LGPLv3"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.2}
-  s.summary = %q{Create simple and neat graphs}
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rmagick>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-    else
-      s.add_dependency(%q<rmagick>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rmagick>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-  end
-end
-