tracksperanto 4.1.2 → 4.1.3

data/test/test_const_name.rb

@@ -1,12 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestConstName < Test::Unit::TestCase
-  
-  def test_const_name
-    assert_equal "Scaler", Tracksperanto::Tool::Scaler.const_name
-    assert_equal "Scaler", Tracksperanto::Tool::Scaler.new(nil).const_name
-    assert_equal "ShakeScript", Tracksperanto::Import::ShakeScript.const_name
-    assert_equal "ShakeText", Tracksperanto::Export::ShakeText.const_name
-  end
-  
-end

data/test/test_extio.rb

@@ -1,28 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestExtio < Test::Unit::TestCase
-  def e(st)
-    Tracksperanto::ExtIO.new(StringIO.new(st))
-  end
-  
-  def test_gets
-    assert_equal "Mary had\n", e("Mary had\n").gets
-  end
-
-  def test_gets_and_strip
-    assert_equal "Mary had", e("Mary had\na little lamb\n").gets_and_strip
-  end
-
-  def test_gets_and_strip_at_end
-    s = e("Mary had\na little lamb\n")
-    s.gets_and_strip
-    s.gets_and_strip
-    
-    assert_nil s.gets_and_strip
-  end
-  
-  def test_gets_non_empty
-    s = e("\n\n\n\nfoo")
-    assert_equal "foo", s.gets_non_empty
-  end
-end

data/test/test_format_detector.rb

@@ -1,39 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestFormatDetector < Test::Unit::TestCase
-  
-  def test_match_unknown
-    file = "/tmp/unknown.someext"
-    d = Tracksperanto::FormatDetector.new(file)
-    
-    assert d.frozen?
-    assert !d.match?
-    assert !d.auto_size?
-    assert_nil d.importer_klass
-    assert_equal "Unknown format", d.human_importer_name
-  end
-  
-  
-  def test_match_nuke
-    file = "C:\\WINDOZE_SHIT\\SUPERDUPER.NK"
-    d = Tracksperanto::FormatDetector.new(file)
-    assert d.frozen?
-    
-    assert d.match?
-    assert !d.auto_size?
-    assert_equal Tracksperanto::Import::NukeScript, d.importer_klass
-    assert_equal Tracksperanto::Import::NukeScript.human_name, d.human_importer_name
-  end
-  
-  def test_match_flame
-    file = "/usr/discreet/project/StupidCommercial/stabilizer/uno.stabilizer"
-    d = Tracksperanto::FormatDetector.new(file)
-    assert d.frozen?
-    
-    assert d.match?
-    assert d.auto_size?
-    assert_equal Tracksperanto::Import::FlameStabilizer, d.importer_klass
-    assert_equal "Flame .stabilizer file", d.human_importer_name
-  end
-  
-end

data/test/test_keyframe.rb

@@ -1,56 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestKeyframe < Test::Unit::TestCase
-  def test_supports_block_init
-    keyframe = Tracksperanto::Keyframe.new do |k| 
-      k.frame = 0
-      k.abs_x = 10.3
-      k.abs_y = 12.5
-    end
-    
-    assert_equal 0, keyframe.frame
-    assert_equal 10.3, keyframe.abs_x
-    assert_equal 12.5, keyframe.abs_y
-  end
-  
-  def test_sorts_on_frame
-    kf = Tracksperanto::Keyframe.new(:frame => 4, :abs_x => 10, :abs_y => 12.0)
-    kf2 = Tracksperanto::Keyframe.new(:frame => 2, :abs_x => 10, :abs_y => 12.0)
-    assert_equal [kf2, kf], [kf, kf2].sort
-  end
-  
-  def test_compares_equally_with_same_values
-    kf = Tracksperanto::Keyframe.new(:frame => 2, :abs_x => 10, :abs_y => 12.0)
-    kf2 = Tracksperanto::Keyframe.new(:frame => 2, :abs_x => 10, :abs_y => 12.0)
-    assert_equal kf, kf2
-  end
-  
-  def test_dup
-    kf = Tracksperanto::Keyframe.new(:frame => 2, :abs_x => 10, :abs_y => 12.0)
-    kf2 = kf.dup
-    kf2.frame = 15
-    assert_not_equal kf, kf2
-  end
-  
-  def test_inspect
-    kf = Tracksperanto::Keyframe.new(:frame => 0, :abs_x => 10, :abs_y => 12.0)
-    assert_equal "#< 10.0x12.0 @0 ~0.00) >", kf.inspect
-  end
-  
-  def test_frame_translated_to_int
-    kf = Tracksperanto::Keyframe.new {|k|  k.frame = '0' }
-    assert_equal 0, kf.frame
-  end
-  
-  def test_residual_defaults_to_zero
-    kf = Tracksperanto::Keyframe.new
-    assert_in_delta 0.0, kf.residual, 0.01
-  end
-
-  def test_abs_x_abs_y_translated_to_float
-    kf = Tracksperanto::Keyframe.new {|k|  k.abs_x = '123.45678'; k.abs_y = '321.45678' }
-    assert_kind_of Float, kf.abs_x
-    assert_kind_of Float, kf.abs_y
-  end
-
-end

data/test/test_parameters.rb

@@ -1,37 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestParameters < Test::Unit::TestCase
-  
-  def setup
-    @class = Class.new do
-      include Tracksperanto::Parameters
-    end
-  end
-  
-  def test_parameters_empty_by_default
-    assert_equal [], @class.parameters
-  end
-  
-  def test_parameter_initialization
-    flexmock(@class).should_receive(:attr_accessor).once.with(:foo)
-    @class.parameter :foo
-    assert_equal 1, @class.parameters.length
-    
-    first_param = @class.parameters[0]
-    assert_equal :foo, first_param.name
-    assert_nil first_param.desc
-  end
-
-  def test_parameter_initialization_with_safety
-    flexmock(@class).should_receive(:attr_accessor).once.with(:foo)
-    flexmock(@class).should_receive(:safe_reader).once.with(:foo)
-    @class.parameter :foo, :required => true
-  end
-  
-  def test_parameter_initialization_with_cast
-    flexmock(@class).should_receive(:attr_accessor).once.with(:foo)
-    flexmock(@class).should_receive(:cast_to_junk).once.with(:foo)
-    @class.parameter :foo, :cast => :junk
-  end
-  
-end

data/test/test_pipeline.rb

@@ -1,192 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestPipeline < Test::Unit::TestCase
-  
-  def create_stabilizer_file
-    @stabilizer = "input.stabilizer"
-    trackers = %w( Foo Bar Baz).map do | name |
-      t = Tracksperanto::Tracker.new(:name => name)
-      t.keyframe!(:frame => 3, :abs_x => 100, :abs_y => 200)
-      t.keyframe!(:frame => 4, :abs_x => 200, :abs_y => 120)
-      t.keyframe!(:frame => 5, :abs_x => 210, :abs_y => 145)
-      t
-    end
-    
-    File.open(@stabilizer, "wb") do | f |
-      exporter = Tracksperanto::Export::FlameStabilizer.new(f)
-      exporter.just_export(trackers, 720, 576)
-    end
-  end
-  
-  def test_supports_block_init
-    pipeline = Tracksperanto::Pipeline::Base.new(:tool_tuples => [:a, :b])
-    assert_equal [:a, :b], pipeline.tool_tuples
-  end
-  
-  def test_run_with_autodetected_importer_and_size_without_progress_block
-    in_temp_dir do
-      create_stabilizer_file
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_nothing_raised { pipeline.run(@stabilizer) }
-      assert_equal 3, pipeline.converted_points
-      assert_equal 9, pipeline.converted_keyframes, "Should report conversion of 9 keyframes"
-    end
-  end
-  
-  def test_run_with_error_picks_up_known_snags_from_importer
-    in_temp_dir do
-      create_stabilizer_file
-      pipeline = Tracksperanto::Pipeline::Base.new
-      flexmock(Tracksperanto::Import::ShakeScript).should_receive(:known_snags).times(1)
-      assert_raise(Tracksperanto::Pipeline::NoTrackersRecoveredError) do
-        pipeline.run(@stabilizer, :importer => "ShakeScript", :width => 2910, :height => 1080)
-      end
-    end
-  end
-  
-  def test_run_for_unsupported_format_raises_exception
-    pipeline = Tracksperanto::Pipeline::Base.new
-    %w( file.MOV file.mb vfx/shots/file.SNI ).each do | path |
-      assert_raise(Tracksperanto::UnsupportedFormatError) do
-        pipeline.run(path)
-      end
-    end
-  end
-  
-  def test_run_with_autodetected_importer_and_size_with_progress_block
-    in_temp_dir do
-      create_stabilizer_file
-      processing_log = ""
-      accum = lambda do | percent, message |
-        processing_log << ("%d -> %s\n" % [percent, message])
-      end
-    
-      pipeline = Tracksperanto::Pipeline::Base.new(:progress_block => accum)
-      assert_nothing_raised { pipeline.run(@stabilizer) }
-      assert processing_log.include?("Parsing the file")
-      assert processing_log.include?("Parsing channel \"tracker1/ref/y\"")
-    end
-  end
-  
-  def test_run_returns_the_number_of_trackers_and_keyframes_processed
-    in_temp_dir do
-      create_stabilizer_file
-      pipeline = Tracksperanto::Pipeline::Base.new
-      result = pipeline.run(@stabilizer)
-      assert_equal [3, 9], result
-    end
-  end
-
-  def test_run_crashes_with_empty_file
-    in_temp_dir do
-      empty_file_path = "input_empty.stabilizer"
-      f = File.open(empty_file_path, "w"){|f| f.write('') }
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_raise(Tracksperanto::Pipeline::EmptySourceFileError) { pipeline.run(empty_file_path) }
-    end
-  end
-  
-  def test_run_crashes_with_no_trackers
-    in_temp_dir do
-      empty_file_path = "input_empty.stabilizer"
-      f = File.open(empty_file_path, "w"){|f| f.write('xx') }
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_raise(Tracksperanto::Pipeline::NoTrackersRecoveredError) { pipeline.run(empty_file_path) }
-    end
-  end
-  
-  def test_tool_initialization_from_tuples
-    in_temp_dir do
-      create_stabilizer_file
-    
-      pipeline = Tracksperanto::Pipeline::Base.new
-      pipeline.tool_tuples = [
-        ["Bla", {:foo=> 234}]
-      ]
-    
-      mock_mux = flexmock("MUX")
-      mock_lint = flexmock("LINT")
-      flexmock(Tracksperanto::Export::Mux).should_receive(:new).and_return(mock_mux)
-      flexmock(Tracksperanto::Tool::Lint).should_receive(:new).with(mock_mux).and_return(mock_lint)
-
-      m = flexmock("tool object")
-      mock_tool_class = flexmock("tool class")
-    
-      flexmock(Tracksperanto).should_receive(:get_tool).with("Bla").once.and_return(mock_tool_class)
-      mock_tool_class.should_receive(:new).with(mock_lint, {:foo => 234}).once
-    
-      assert_raise(NoMethodError) { pipeline.run(@stabilizer) }
-    end
-  end
-  
-  def test_run_with_autodetected_importer_that_requires_size
-    in_temp_dir do
-      FileUtils.cp( File.dirname(__FILE__) + "/import/samples/shake_script/four_tracks_in_one_stabilizer.shk", "input.shk")
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_raise(Tracksperanto::Pipeline::DimensionsRequiredError) { pipeline.run("input.shk") }
-    end
-  end
-  
-  def test_run_with_autodetected_importer_that_requires_size_when_size_supplied
-    in_temp_dir do
-      FileUtils.cp( File.dirname(__FILE__) + "/import/samples/shake_script/four_tracks_in_one_stabilizer.shk", "input.shk")
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_nothing_raised { pipeline.run("input.shk", :width => 720, :height => 576) }
-    end
-  end
-  
-  def test_run_with_overridden_importer_and_no_size
-    in_temp_dir do
-      FileUtils.cp( File.dirname(__FILE__) + "/import/samples/shake_script/four_tracks_in_one_stabilizer.shk", "input.shk")
-      pipeline = Tracksperanto::Pipeline::Base.new
-      num_exporters = Tracksperanto.exporters.length
-      assert_nothing_raised { pipeline.run("input.shk", :importer => "ShakeScript", :width => 720, :height => 576) }
-      assert_equal num_exporters, Dir.glob("input_*").length, "#{num_exporters} files should be present for the input and outputs"
-    end
-  end
-  
-  def test_run_with_overridden_importer_and_size_for_file_that_would_be_recognized_differently
-    in_temp_dir do
-      FileUtils.cp( File.dirname(__FILE__) + "/import/samples/shake_script/four_tracks_in_one_stabilizer.shk", "input.stabilizer")
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_nothing_raised { pipeline.run("input.stabilizer", :importer => "ShakeScript", :width => 720, :height => 576) }
-    end
-  end
-  
-  def test_run_with_unknown_format_raises
-    in_temp_dir do
-      File.open("input.txt", "w"){|f| f.write("foo") }
-    
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_raise(Tracksperanto::Pipeline::UnknownFormatError) { pipeline.run("input.txt") }
-      assert_raise(Tracksperanto::Pipeline::UnknownFormatError) { pipeline.run("input.txt", :width => 100, :height => 100) }
-      assert_raise(Tracksperanto::Pipeline::DimensionsRequiredError) { pipeline.run("input.txt", :importer => "Syntheyes") }
-    end
-  end
-  
-  def test_importing_file_with_trackers_of_zero_length_does_not_accumulate_any_trackers
-    in_temp_dir do
-      pft_with_empty_trackers = File.dirname(__FILE__) + "/import/samples/pftrack5/empty_trackers.2dt"
-      i = Tracksperanto::Import::PFTrack.new(:io => File.open(pft_with_empty_trackers), :width => 1920, :height => 1080)
-      tks = i.to_a
-      assert_equal 3, tks.length
-      assert_equal 0, tks[0].length, "The tracker should have 0 keyframes for this test to make sense"
-    
-      FileUtils.cp(pft_with_empty_trackers, "input_empty.2dt")
-    
-      pipeline = Tracksperanto::Pipeline::Base.new
-      num_t, num_k = pipeline.run("input_empty.2dt", :width => 1920, :height => 1080)
-      assert_equal 1, num_t, "Only one tracker should have been sent through the export"
-    end
-  end
-  
-  def test_run_with_overridden_importer_and_size
-    in_temp_dir do
-      FileUtils.cp( File.dirname(__FILE__) + "/import/samples/3de_v4/3de_export_cube.txt", "input.txt")
-      pipeline = Tracksperanto::Pipeline::Base.new
-      assert_raise(Tracksperanto::Pipeline::DimensionsRequiredError) { pipeline.run("input.txt", :importer => "Equalizer4") }
-      assert_nothing_raised { pipeline.run("input.txt", :importer => "Equalizer4", :width => 720, :height => 576) }
-    end
-  end
-  
-end

data/test/test_safety.rb

@@ -1,20 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TestSafety < Test::Unit::TestCase
-  class Testable
-    include Tracksperanto::Safety
-    attr_accessor :foo, :bar
-    safe_reader :foo, :bar
-  end
-  
-  def test_safe_reader_raises_with_no_ivar
-    t = Testable.new
-    assert_raise(RuntimeError) { t.foo }
-  end
-
-  def test_safe_reader_does_not_raise_with_value_assigned
-    t = Testable.new
-    t.foo = 123
-    assert_nothing_raised { assert_equal 123, t.foo }
-  end
-end

data/test/test_simple_export.rb

@@ -1,22 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class SimpleExportTest < Test::Unit::TestCase
-  
-  class Probe
-    include Tracksperanto::SimpleExport
-  end
-  
-  def test_message_sends
-    probe = Probe.new
-    flexmock(probe).should_receive(:start_export).with(1920, 1080).once
-    flexmock(probe).should_receive(:start_tracker_segment).with("Foo").once
-    flexmock(probe).should_receive(:export_point).with(2, 345.0, 678.0, 0.0).once
-    flexmock(probe).should_receive(:end_tracker_segment).once
-    flexmock(probe).should_receive(:end_export).once
-  
-    t = Tracksperanto::Tracker.new(:name => "Foo")
-    t.keyframe! :frame => 2, :abs_x => 345.0, :abs_y => 678.0, :residual => 0.0
-    probe.just_export([t], 1920, 1080)
-  end
-
-end

data/test/test_tracker.rb

@@ -1,149 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helper'
-
-class TrackerTest < Test::Unit::TestCase
-  
-  def setup
-    @keyframes = [
-      Tracksperanto::Keyframe.new(:frame => 15, :abs_x => 123, :abs_y => 456),
-      Tracksperanto::Keyframe.new(:frame => 8, :abs_x => 678, :abs_y => 901),
-      Tracksperanto::Keyframe.new(:frame => 1, :abs_x => 342, :abs_y => 312),
-    ]
-  end
-  
-  def test_supports_block_init
-    t = Tracksperanto::Tracker.new do |t| 
-      t.name = 'Foo'
-    end
-    assert_equal "Foo", t.name
-  end
-  
-  def test_responds_to_needed_methods
-    t = Tracksperanto::Tracker.new
-    assert_respond_to t, :name
-    assert_respond_to t, :each
-    assert_respond_to t, :keyframes
-  end
-  
-  def test_to_ruby
-    one_f = Tracksperanto::Tracker.new(:name => "Cde") do | t |
-      t.keyframe! :abs_x => 12, :abs_y => 23, :frame => 1
-    end
-    ref = "Tracksperanto::Tracker.new(:name => \"Cde\") do |t|\n  t.keyframe!(:frame => 1, :abs_x => 12.00000, :abs_y => 23.00000, :residual => 0.00000)\nend"
-    assert_equal ref, one_f.to_ruby
-    
-    tracker = Tracksperanto::Tracker.new(:name => "Cde") do | t |
-      t.keyframe! :abs_x => 12, :abs_y => 23, :frame => 1
-      t.keyframe! :abs_x => 13, :abs_y => 24, :frame => 2
-    end
-    
-    result = eval(tracker.to_ruby)
-    assert_equal result, tracker
-  end
-  
-  def test_properly_ignores_flattening
-    t = []
-    t << Tracksperanto::Tracker.new(:name => "Abc")
-    t[-1].keyframe! :abs_x => 12, :abs_y => 23, :frame => 1
-    t[-1].keyframe! :abs_x => 13, :abs_y => 24, :frame => 2
-    
-    t << Tracksperanto::Tracker.new(:name => "Cde")
-    t[-1].keyframe! :abs_x => 12, :abs_y => 23, :frame => 1
-    t[-1].keyframe! :abs_x => 13, :abs_y => 24, :frame => 2
-    
-    assert_kind_of Tracksperanto::Tracker, t.flatten[0]
-    assert_equal 2, t.flatten.length
-  end
-  
-  def test_supports_hash_init
-    assert_equal "Foo", Tracksperanto::Tracker.new(:name => "Foo").name
-  end
-  
-  def test_supports_hash_init_with_keyframes
-    kfs = Tracksperanto::Keyframe.new(:frame => 1, :abs_x => 123, :abs_y => 456)
-    assert_equal [kfs], Tracksperanto::Tracker.new(:keyframes => [kfs]).keyframes
-  end
-  
-  def test_clear
-    t = Tracksperanto::Tracker.new do | t |
-      t.keyframe! :abs_x => 123, :abs_y => 456
-    end
-    assert_equal 1, t.length
-    t.clear
-    assert t.length.zero?
-  end
-  
-  def test_supports_array_methods
-    kfs = Tracksperanto::Keyframe.new(:frame => 1, :abs_x => 123, :abs_y => 456)
-    t = Tracksperanto::Tracker.new(:keyframes => [kfs])
-    
-    assert_equal [kfs], t.to_a
-    assert_equal 1, t.length
-  end
-  
-  def test_push
-    kf = Tracksperanto::Keyframe.new(:frame => 1, :abs_x => 123, :abs_y => 456)
-    t = Tracksperanto::Tracker.new(:name => "Test")
-    t.push(kf)
-    assert_equal 1, t.length
-    
-    kf = Tracksperanto::Keyframe.new(:frame => 1, :abs_x => 333, :abs_y => 456)
-    assert_raise(Tracksperanto::Tracker::Dupe) do
-      t.push(kf)
-    end
-  end
-  
-  def test_set
-    t = Tracksperanto::Tracker.new(:name => "Shmoo", :keyframes => @keyframes)
-    replacement_key = Tracksperanto::Keyframe.new(:frame => 15, :abs_x => 92193921)
-    t.set(replacement_key)
-    assert_in_delta 0.0001, 92193921.0, t[-1].abs_x
-  end
-  
-  def test_bracket_subscript
-    t = Tracksperanto::Tracker.new(:name => "Shmoo", :keyframes => @keyframes)
-    kf = t[0]
-    assert_equal kf, @keyframes[-1], "Keyframe at 1 should be returned"
-  end
-  
-  def test_at_frame
-    t = Tracksperanto::Tracker.new(:name => "Shmoo", :keyframes => @keyframes)
-    assert_equal @keyframes[0], t.at_frame(15)
-    assert_nil t.at_frame(200), "Should return nil for nonexisting frames"
-  end
-  
-  def test_keyframes_assignment_overwrites
-    t = Tracksperanto::Tracker.new(:name => "Shmoo", :keyframes => @keyframes)
-    assert_equal [1, 8, 15], t.to_a.map{|e| e.frame}
-    new_key = @keyframes[1]
-    t.keyframes = [new_key]
-    
-    assert_equal [8], t.to_a.map{|e| e.frame}
-  end
-  
-  def test_empty?
-    t = Tracksperanto::Tracker.new(:name => "Test")
-    assert t.empty?
-    
-    t = Tracksperanto::Tracker.new(:name => "Test")
-    t.keyframe! :frame => 10, :abs_x => 123
-    assert !t.empty?
-  end
-  
-  def test_inspect
-    t = Tracksperanto::Tracker.new(:name => "FooTracker")
-    assert_equal '<T "FooTracker" with 0 keyframes>', t.inspect
-  end
-  
-  def test_ensure_tracker_forbids_spaces_in_names
-    t = Tracksperanto::Tracker.new(:name => "Mary had a \n \t little lamb")
-    assert_equal "Mary_had_a_little_lamb", t.name
-  end
-  
-  def test_enumerates_keyframe_values_and_returns_length
-    t = Tracksperanto::Tracker.new(:keyframes => @keyframes)
-    assert_equal @keyframes.sort, t.map{|e| e}
-    assert_equal 3, t.length
-    assert_equal @keyframes[-1], t[0]
-  end
-  
-end