tracksperanto 1.8.4 → 1.9.0

data/History.txt

@@ -1,3 +1,9 @@
+=== 1.9.0 / 2010-03-21
+
+* Use proper progress bars
+* Allow proper chaining of middlewares in the commandline app - you can now apply many middlewares of the same nature in chainn, and they will be ordered correctly
+* Small rewrites to Pipeline::Base (changes API slightly - please consult the docs)
+
 === 1.8.4 / 2010-03-10
 
 * Fix PFTrack imports neglecting the feature name if it only contained digits

data/README.txt

@@ -88,24 +88,42 @@ Middlewares. Any processing chain (called a Pipeline) usually works like this:
 * Trackers and their keyframes are dumped to all export
   formats Tracksperanto supports, optionally passing through Middleware
 
-== Importing your own formats
+
+== Limitations
+
+Information about the search area, reference area and offset is not passed along (outside
+of scope for the app and different trackers handle these differently, if at all). For some
+modules no residual will be passed along (3D tracking apps generally do not export residual
+with backprojected 3D features).
+
+== Extending Tracksperanto
+
+=== Importing your own formats
 
 You can easily write a Tracksperanto import module - refer to Tracksperanto::Import::Base
-docs. Your importer should return an array of Tracksperanto::Tracker objects which
+docs. Your importer will be configured with width and height of the comp that it is importing, and will get an IO 
+object with the file that you are processing. The parse method should then return an array of Tracksperanto::Tracker objects which
 are themselves arrays of Tracksperanto::Keyframe objects.
 
-== Exporting your own formats
+=== Exporting your own formats
 
-You can easily write an exporter. Refer to the Tracksperanto::Export::Base docs.
+You can easily write an exporter. Refer to the Tracksperanto::Export::Base docs. Note that your exporter should be able to chew alot of data
+(hundreds of trackers with thousands of keyframes with exported files growing up to 5-10 megs in size are not uncommon!). This means that
+the exporter should work with streams (smaller parts of the file being exported will be held in memory at a time).
 
-== Ading your own processing steps
+=== Ading your own processing steps
 
-You probably want to write a Middleware (consult the Tracksperanto::Middleware::Base docs). A Middleware is just like
-an exporter, except that it wraps another exporter instead (so you can intercept export calls and massage the data as it is moving through).
+You probably want to write a Middleware (consult the Tracksperanto::Middleware::Base docs) if you need some processing applied to the tracks
+or their data. A Middleware is just like an export module, except that instead it sits between the exporter and the exporting routine. Middlewares wrap export
+modules or each other, so you can stack different middleware modules together (like "scale first, then move").
 
-== Limitations
+=== Writing your own processing routines
 
-Information about the search area, reference area and offset is not passed along (outside
-of scope for the app and different trackers handle these differently, if at all). For some
-modules no residual will be passed along (3D tracking apps generally do not export residual
-with backprojected 3D features).
+You probably want to write a descendant of Tracksperanto::Pipeline::Base. This is a class that manages a conversion from start to finish, including detecting the
+input format, allocating output files and building a chain of Middlewares to process the export. If you want to make a GUI for Tracksperanto you will likely need
+to write your own Pipeline class or reimplement parts of it.
+
+=== Reporting status from long-running operations
+
+Almost every module in Tracksperanto has a method called report_progress. This method is used to notify an external callback of what you are doing, and helps keep
+the software user-friendly. A well-behaved Tracksperanto module should manage it's progress reports properly.

data/Rakefile

@@ -10,6 +10,7 @@ begin
   Hoe.spec('tracksperanto') do | p |
     p.clean_globs = %w( **/.DS_Store )
     p.version = Tracksperanto::VERSION
+    p.extra_deps = {"progressbar" => ">=0"}
     p.extra_dev_deps = {"flexmock" => ">=0"}
     p.rubyforge_name = 'guerilla-di'
     p.developer('Julik Tarkhanov', 'me@julik.nl')

data/bin/tracksperanto

@@ -12,23 +12,16 @@
 
 require File.dirname(__FILE__) + '/../lib/tracksperanto'
 require 'optparse'
+require 'rubygems'
+require 'progressbar'
 
 # Sane defaults
 reader_klass = nil
 width = nil
 height = nil
-reformat_w = nil
-reformat_h = nil
-scale_x = 1.0
-scale_y = 1.0
-slip = 0
-golden_tracks = false
-x_shift = 0
-y_shift = 0
-length_gate = 0
-set_prefix = ''
+
+middlewares = []
 sole_format = nil
-lerp = false
 reader_name = "ShakeScript"
 readers = Tracksperanto.importer_names
 writers = Tracksperanto.exporter_names
@@ -42,34 +35,52 @@ parser = OptionParser.new do | p |
    "Use the specific import translator (will try to autodetect, but can be #{Tracksperanto.importer_names.join(', ')})") do | f |
     reader_name = f
  end
- p.on(" -p", "--prefix PREFIX", String, "A prefix to prepend to tracker names in bulk") { |w| set_prefix = w }
  p.on(" -w", "--width WIDTH_IN_PIXELS", Integer, "Absolute input comp width in pixels (will try to autodetect)") { |w| width = w }
  p.on(" -h", "--height HEIGHT_IN_PIXELS", Integer, "Absolute input comp height in pixels (will try to autodetect)") {|w| height = w }
- p.on(" -xs", "--xscale X_SCALING_FACTOR", Float, "Scale the result in X by this factor (1.0 is the default)") {|sx| scale_x = sx }
- p.on(" -ys", "--yscale Y_SCALING_FACTOR", Float, "Scale the result in Y by this factor (1.0 is the default)") {|sy| scale_y = sy }
- p.on(" -s", "--slip FRAMES", Integer, "Slip the result by this number of frames, positive is 'later'") {|sy| slip = sy }
- p.on(" -g", "--golden", "Reset the residuals of all trackers to 0 (ignore correlation)") {|g_flag| 
-   golden_tracks = g_flag
- }
- p.on(" -rx", "--reformat-x NEW_PIX_WIDTH", Integer, "Reformat the comp to this width and scale all tracks to it") {|rw| 
-   reformat_w = rw
- }
- p.on(" -ry", "--reformat-y NEW_PIX_HEIGHT", Integer, "Reformat the comp to this height and scale all tracks to it") {|rh|
-   reformat_h = rh
- }
- p.on(" -o", "--only EXPORTER_NAME", String, "Only export the selected format, format must be one of #{writers.join(", ")}") {|f|
+ 
+ p.on(" -xs", "--xscale X_SCALING_FACTOR", Float, "Scale the result in X by this factor (1.0 is the default)") do |sx| 
+   middlewares << ["Scaler", {:x_factor => sx}]
+ end
+ p.on(" -ys", "--yscale Y_SCALING_FACTOR", Float, "Scale the result in Y by this factor (1.0 is the default)") do |sy| 
+   middlewares << ["Scaler", {:y_factor => sx}]
+ end
+ p.on(" -s", "--slip FRAMES", Integer, "Slip the result by this number of frames, positive is 'later'") do |sy| 
+   middlewares << ["Slipper", {:slip => sx}]
+ end
+ p.on(" -g", "--golden", "Reset the residuals of all trackers to 0 (ignore correlation)") do |g_flag| 
+   middlewares << ["Golden", {:enabled => true}]
+ end
+ p.on(" -rx", "--reformat-x NEW_PIX_WIDTH", Integer, "Reformat the comp to this width and scale all tracks to it") do |rw| 
+   middlewares << ["Reformat", {:width => rw}]
+ end
+ p.on(" -ry", "--reformat-y NEW_PIX_HEIGHT", Integer, "Reformat the comp to this height and scale all tracks to it") do |rh|
+   middlewares << ["Reformat", {:height => rh}]
+ end
+ p.on(" -m", "--min-length LENGTH_IN_FRAMES", Integer, "Only export trackers having more than X keyframes") do | min_kf | 
+   middlewares << ["LengthCutoff", {:min_length => min_kf}]
+ end
+ p.on(" -xm", "--xshift X_IN_PIXELS", Float, "Move the points left or right") do |sx|
+   middlewares << ["Shift", {:x_shift => sx}]
+ end
+ p.on(" -ym", "--yshift Y_IN_PIXELS", Float, "Move the points up or down") do |sx| 
+   middlewares << ["Shift", {:y_shift => sx}]
+ end
+ p.on(" -p", "--prefix PREFIX", String, "A prefix to prepend to tracker names in bulk") do |w| 
+   middlewares << ["Prefix", {:prefix => w}]
+ end
+ 
+ p.on("--lerp", "Linearly interpolate missing keyframes") do
+   middlewares << ["Lerp", {:enabled => true}]
+ end
+ 
+ p.on(" -o", "--only EXPORTER_NAME", String, "Only export the selected format, format must be one of #{writers.join(", ")}") do |f|
    sole_format = f
- }
- p.on(" -m", "--min-length LENGTH_IN_FRAMES", Integer, "Only export trackers having more than X keyframes") {|f| 
-   length_gate = f
- }
- p.on(" -xm", "--xshift X_IN_PIXELS", Float, "Move the points left or right") {|sx| x_shift = sx }
- p.on(" -ym", "--yshift Y_IN_PIXELS", Float, "Move the points up or down") {|sx| y_shift = sx }
- p.on("--lerp", "Linearly interpolate missing keyframes") {|v| lerp = true }
+ end
+
  p.on("--version", "Show the version and exit") {|v| 
-    puts "#{Tracksperanto::VERSION} running on Ruby #{RUBY_VERSION} on #{RUBY_PLATFORM}"
+    puts "Tracksperanto v.#{Tracksperanto::VERSION} running on Ruby #{RUBY_VERSION} on #{RUBY_PLATFORM}"
     puts "Copyright 2008-#{Time.now.year} by Guerilla-DI (Julik Tarkhanov and contributors)"
-    puts "For questions and support contact info at guerilla-di.org"
+    puts "For questions and support contact info#{64.chr}guerilla-di.org"
     exit(0)
  }
 end
@@ -91,34 +102,12 @@ end
 
 input_file = ARGV.pop
 if !input_file
-  STDERR.puts "No input file provided - should be the last argument"
+  STDERR.puts "No input file provided - should be the last argument. Also use the --help option."
   exit(-1)
 end
 
-class Spinner
-  RING = ['|', '/', '-', '\\', '|', '/', '-', '\\']
-  
-  def initialize
-    @counter, @last_len = 0, 0
-  end
-  
-  def spin(percent, msg)
-    current = RING[(@counter += 1) % RING.length]
-    output = " [%s %d%%]" % [current, percent]
-    STDOUT.write(output + ("\r" * output.length))
-    STDOUT.flush
-    @last_len = output.length
-  end
-  
-  def finish(with_message = '')
-    STDOUT.write("\r" * @last_len.to_i)
-    STDOUT.flush
-    STDOUT.puts(with_message)
-  end
-end
-
-spinner = Spinner.new
-pipe = Tracksperanto::Pipeline::Base.new(:progress_block => spinner.method(:spin).to_proc)
+pbar = ProgressBar.new("Converting", 100)
+pipe = Tracksperanto::Pipeline::Base.new(:progress_block => lambda{|p,m| pbar.set(p) }, :middleware_tuples => middlewares)
 
 if sole_format
   begin
@@ -129,18 +118,6 @@ if sole_format
   end
 end
 
-pipe.run(input_file, :pix_w => width, :pix_h => height, :parser => reader_klass) do | scaler, slipper, golden, reformat, shift, prefix, lerpm, len |
-  slipper.slip = slip
-  scaler.x_factor = scale_x
-  scaler.y_factor = scale_y
-  golden.enabled = golden_tracks
-  reformat.width = reformat_w if reformat_w
-  reformat.height = reformat_h if reformat_h
-  shift.x_shift = x_shift
-  shift.y_shift = y_shift
-  prefix.prefix = set_prefix
-  lerpm.enabled = lerp
-  len.min_length = length_gate
-end
-
-spinner.finish("Converted #{pipe.converted_points} trackers with #{pipe.converted_keyframes} keys")
+pipe.run(input_file, :width => width, :height => height, :parser => reader_klass)
+pbar.finish
+puts ("Converted #{pipe.converted_points} trackers with #{pipe.converted_keyframes} keys")

data/lib/export/flame_stabilizer.rb

@@ -54,19 +54,10 @@ class Tracksperanto::Export::FlameStabilizer < Tracksperanto::Export::Base
   def export_point(frame, abs_float_x, abs_float_y, float_residual)
     flame_frame = frame + 1
     if @write_first_frame
-      @base_x, @base_y = abs_float_x, abs_float_y
-      write_first_frame(abs_float_x, abs_float_y)
-      # For Flame to recognize the reference frame of the Shift channel
-      # we need it to contain zero as an int, not as a float. The shift proceeds
-      # from there.
-      @x_shift_values = [[flame_frame, 0]]
-      @y_shift_values = [[flame_frame, 0]]
+      export_first_point(flame_frame, abs_float_x, abs_float_y)
       @write_first_frame = false
     else
-      # Just continue buffering the upcoming shift keyframes and flush them in the end
-      shift_x, shift_y = @base_x - abs_float_x, @base_y - abs_float_y
-      @x_shift_values.push([flame_frame, shift_x])
-      @y_shift_values.push([flame_frame, shift_y])
+      export_remaining_point(flame_frame, abs_float_x, abs_float_y)
     end
   end
   
@@ -79,6 +70,23 @@ class Tracksperanto::Export::FlameStabilizer < Tracksperanto::Export::Base
   
   private
   
+  def export_remaining_point(flame_frame, abs_float_x, abs_float_y)
+    # Just continue buffering the upcoming shift keyframes and flush them in the end
+    shift_x, shift_y = @base_x - abs_float_x, @base_y - abs_float_y
+    @x_shift_values.push([flame_frame, shift_x])
+    @y_shift_values.push([flame_frame, shift_y])
+  end
+  
+  def export_first_point(flame_frame, abs_float_x, abs_float_y)
+    @base_x, @base_y = abs_float_x, abs_float_y
+    write_first_frame(abs_float_x, abs_float_y)
+    # For Flame to recognize the reference frame of the Shift channel
+    # we need it to contain zero as an int, not as a float. The shift proceeds
+    # from there.
+    @x_shift_values = [[flame_frame, 0]]
+    @y_shift_values = [[flame_frame, 0]]
+  end
+  
   # The shift channel is what determines how the tracking point moves.
   def write_shift_channel(name_without_prefix, values)
     @writer.channel(prefix(name_without_prefix)) do | c |

data/lib/export/shake_text.rb

@@ -2,6 +2,7 @@
 class Tracksperanto::Export::ShakeText < Tracksperanto::Export::Base
   PREAMBLE = "TrackName %s\n   Frame             X             Y   Correlation\n"
   POSTAMBLE = "\n"
+  TEMPLATE = "   %.2f   %.3f   %.3f   %.3f"
   
   def self.desc_and_extension
     "shake_trackers.txt"
@@ -21,7 +22,7 @@ class Tracksperanto::Export::ShakeText < Tracksperanto::Export::Base
    
   def export_point(frame, abs_float_x, abs_float_y, float_residual)
     # Shake starts from frame 1, not 0
-    line = "   %.2f   %.3f   %.3f   %.3f" % [frame + 1, abs_float_x, abs_float_y, 1 - float_residual]
+    line = TEMPLATE % [frame + 1, abs_float_x, abs_float_y, 1 - float_residual]
     @io.puts line
   end
 end

data/lib/import/flame_stabilizer.rb

@@ -14,9 +14,6 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
     "Flame .stabilizer file"
   end
   
-  T = ::Tracksperanto::Tracker
-  K = ::Tracksperanto::Keyframe
-  
   class ChannelBlock < Array
     include ::Tracksperanto::Casts
     cast_to_string :name
@@ -175,7 +172,7 @@ Channel tracker1/ref/x
     end
     
     def grab_tracker(channels, track_x)
-      t = T.new(:name => track_x.name.split('/').shift)
+      t = Tracksperanto::Tracker.new(:name => track_x.name.split('/').shift)
       
       report_progress("Extracting tracker #{t.name}")
       
@@ -200,7 +197,7 @@ Channel tracker1/ref/x
         kf_x, kf_y = base_x - x.to_f, base_y - y.to_f
         
         report_progress("Extracting keyframe #{total_kf += 1} of #{t.name}")
-        K.new(:frame => (at - 1), :abs_x => kf_x, :abs_y => kf_y)
+        Tracksperanto::Keyframe.new(:frame => (at - 1), :abs_x => kf_x, :abs_y => kf_y)
       end
       
       return t

data/lib/import/shake_text.rb

@@ -7,8 +7,7 @@ class Tracksperanto::Import::ShakeText < Tracksperanto::Import::Base
   
   def parse(io)
     trackers = []
-    until io.eof?
-      line = io.gets
+    io.each do | line |
       if line =~ /TrackName (.+)/
         trackers << Tracksperanto::Tracker.new{|t| t.name = $1 }
         # Toss the next following string - header

data/lib/pipeline/base.rb

@@ -4,7 +4,7 @@
 #   pipe = Tracksperanto::Pipeline::Base.new
 #   pipe.progress_block = lambda{|percent, msg| puts("#{msg}..#{percent.to_i}%") }
 #   
-#   pipe.run("/tmp/shakescript.shk", :pix_w => 720, :pix_h => 576) do | *all_middlewares |
+#   pipe.run("/tmp/shakescript.shk", :width => 720, :height => 576) do | *all_middlewares |
 #     # configure middlewares here
 #   end
 #
@@ -12,6 +12,7 @@
 # at the same place where the original file resides,
 # and setup outputs for all supported export formats.
 class Tracksperanto::Pipeline::Base
+  EXTENSION = /\.([^\.]+)$/ #:nodoc:
   
   include Tracksperanto::BlockInit
   
@@ -31,69 +32,77 @@ class Tracksperanto::Pipeline::Base
   # Assign an array of exporters to use them instead of the standard ones 
   attr_accessor :exporters
   
-  DEFAULT_OPTIONS = {:pix_w => 720, :pix_h => 576, :parser => Tracksperanto::Import::ShakeScript }
+  DEFAULT_OPTIONS = {:width => 720, :height => 576, :parser => Tracksperanto::Import::ShakeScript }
+  
+  # Contains arrays of the form ["MiddewareName", {:param => value}]
+  attr_accessor :middleware_tuples
+  
+  def wrap_output_with_middlewares(output)
+    return output unless (middleware_tuples && middleware_tuples.any?)
+    
+    middleware_tuples.reverse.inject(output) do | wrapped, (middleware_name, options) |
+      Tracksperanto.get_middleware(middleware_name).new(wrapped, options || {})
+    end
+  end
   
   # Runs the whole pipeline. Accepts the following options
-  # * pix_w - The comp width, for the case that the format does not support auto size
-  # * pix_h - The comp height, for the case that the format does not support auto size
+  # * width - The comp width, for the case that the format does not support auto size
+  # * height - The comp height, for the case that the format does not support auto size
   # * parser - The parser class, for the case that it can't be autodetected from the file name
   def run(from_input_file_path, passed_options = {}) #:yields: *all_middlewares
     o = DEFAULT_OPTIONS.merge(passed_options)
-    pix_w, pix_h, parser_class = detect_importer_or_use_options(from_input_file_path, o)
     
     # Reset stats
     @converted_keyframes, @converted_points = 0, 0
     
-    # Grab the input
-    read_data = File.open(from_input_file_path, "rb")
-    
     # Assign the parser
-    importer = parser_class.new(:width => pix_w, :height => pix_h)
+    importer = initialize_importer_with_path_and_options(from_input_file_path, o)
     
+    # Open the file
+    read_data = File.open(from_input_file_path, "rb")
+        
     # Setup a multiplexer
     mux = setup_outputs_for(from_input_file_path)
     
     # Setup middlewares
-    middlewares = setup_middleware_chain_with(mux)
-    
-    # Yield middlewares to the block
-    yield(*middlewares) if block_given?
-    
-    @converted_points, @converted_keyframes = run_export(read_data, importer, middlewares[-1])
+    endpoint = wrap_output_with_middlewares(mux)
+    @converted_points, @converted_keyframes = run_export(read_data, importer, endpoint)
   end
   
   def report_progress(percent_complete, message)
     @progress_block.call(percent_complete, message) if @progress_block
   end
   
-  def detect_importer_or_use_options(path, opts)
-    d = Tracksperanto::FormatDetector.new(path)
+  def initialize_importer_with_path_and_options(from_input_file_path, options)
+    d = Tracksperanto::FormatDetector.new(from_input_file_path)
     if d.match? && d.auto_size?
-      return [1, 1, d.importer_klass]
+      d.importer_klass.new
     elsif d.match?
-      raise "Width and height must be provided for a #{d.importer_klass}" unless (opts[:pix_w] && opts[:pix_h])
-      opts[:parser] = d.importer_klass
+      require_dimensions_in!(opts)
+      d.importer_klass.new(:width => opts[:width], :height => opts[:height])
     else
       raise "Cannot autodetect the file format - please specify the importer explicitly" unless opts[:parser]
-      unless opts[:parser].autodetects_size?
-        raise "Width and height must be provided for this importer" unless (opts[:pix_w] && opts[:pix_h])
-      end
+      klass = Tracksperanto.get_exporter(opts[:parser])
+      require_dimensions_in!(opts) unless klass.autodetects_size?
+      klass.new(:width => opts[:width], :height => opts[:height])
     end
-    
-    [opts[:pix_w], opts[:pix_h], opts[:parser]]    
+  end
+  
+  def require_dimensions_in!(opts)
+    raise "Width and height must be provided for this importer" unless (opts[:width] && opts[:height])
   end
   
   # Runs the export and returns the number of points and keyframes processed.
   # If a block is passed, the block will receive the percent complete and the last
   # status message that you can pass back to the UI
-  def run_export(tracker_data_io, parser, processor)
+  def run_export(tracker_data_io, parser, exporter)
     points, keyframes, percent_complete = 0, 0, 0.0
-    
+
     report_progress(percent_complete, "Starting the parser")
-    
+
     # Report progress from the parser
     parser.progress_block = lambda { | m | report_progress(percent_complete, m) }
-    
+
     # Wrap the input in a progressive IO, setup a lambda that will spy on the reader and 
     # update the percentage. We will only broadcast messages that come from the parser 
     # though (complementing it with a percentage)
@@ -101,34 +110,34 @@ class Tracksperanto::Pipeline::Base
       percent_complete = (50.0 / of_total) * offset
     end
     @ios << io_with_progress
-    
+
     trackers = parser.parse(io_with_progress)
-    
+
     report_progress(percent_complete = 50.0, "Validating #{trackers.length} imported trackers")
-    
+
     validate_trackers!(trackers)
-    
+
     report_progress(percent_complete, "Starting export")
-    
+
     percent_per_tracker = (100.0 - percent_complete) / trackers.length
-    
+
     # Use the width and height provided by the parser itself
-    processor.start_export(parser.width, parser.height)
+    exporter.start_export(parser.width, parser.height)
     trackers.each_with_index do | t, tracker_idx |
       kf_weight = percent_per_tracker / t.keyframes.length
       points += 1
-      processor.start_tracker_segment(t.name)
+      exporter.start_tracker_segment(t.name)
       t.each_with_index do | kf, idx |
         keyframes += 1
-        processor.export_point(kf.frame, kf.abs_x, kf.abs_y, kf.residual)
+        exporter.export_point(kf.frame, kf.abs_x, kf.abs_y, kf.residual)
         report_progress(percent_complete += kf_weight, "Writing keyframe #{idx+1} of #{t.name.inspect}, #{trackers.length - tracker_idx} trackers to go")
       end
-      processor.end_tracker_segment
+      exporter.end_tracker_segment
     end
-    processor.end_export
-    
+    exporter.end_export
+
     report_progress(100.0, "Wrote #{points} points and #{keyframes} keyframes")
-    
+
     [points, keyframes]
   ensure
     @ios.reject!{|e| e.close unless (!e.respond_to?(:closed?) || e.closed?) } if @ios
@@ -137,7 +146,7 @@ class Tracksperanto::Pipeline::Base
   # Setup output files and return a single output
   # that replays to all of them
   def setup_outputs_for(input_file_path)
-    file_name = File.basename(input_file_path).gsub(/\.([^\.]+)$/, '')
+    file_name = File.basename(input_file_path).gsub(EXTENSION, '')
     export_klasses = exporters || Tracksperanto.exporters    
     Tracksperanto::Export::Mux.new(
       export_klasses.map do | exporter_class |
@@ -148,21 +157,6 @@ class Tracksperanto::Pipeline::Base
     )
   end
   
-  # Setup and return the output multiplexor wrapped in all necessary middlewares.
-  # Middlewares must be returned in an array to be passed to the configuration block
-  # afterwards
-  def setup_middleware_chain_with(output)
-    scaler = Tracksperanto::Middleware::Scaler.new(output)
-    slipper = Tracksperanto::Middleware::Slipper.new(scaler)
-    golden = Tracksperanto::Middleware::Golden.new(slipper)
-    reformat = Tracksperanto::Middleware::Reformat.new(golden)
-    shift = Tracksperanto::Middleware::Shift.new(reformat)
-    prefix = Tracksperanto::Middleware::Prefix.new(shift)
-    lerp = Tracksperanto::Middleware::Lerp.new(prefix)
-    lengate = Tracksperanto::Middleware::LengthCutoff.new(lerp)
-    [scaler, slipper, golden, reformat, shift, prefix, lerp, lengate]
-  end
-  
   # Open the file for writing and register it to be closed automatically
   def open_owned_export_file(path_to_file)
     @ios ||= []

data/lib/tracksperanto.rb

@@ -4,7 +4,7 @@ require 'tempfile'
 
 module Tracksperanto
   PATH = File.expand_path(File.dirname(__FILE__))
-  VERSION = '1.8.4'
+  VERSION = '1.9.0'
   
   module Import; end
   module Export; end
@@ -38,7 +38,16 @@ module Tracksperanto
   end
   
   self.exporters, self.importers, self.middlewares = [], [], []
-  
+
+  # Case-insensitive search for a middleware class by name
+  def self.get_middleware(name)
+    middlewares.each do | x |
+      return x if x.const_name.downcase == name.downcase
+    end
+    
+    raise NameError, "Unknown middleware #{name}"
+  end
+    
   # Case-insensitive search for an export module by name
   def self.get_exporter(name)
     exporters.each do | x |

data/lib/tracksperanto/buffer_io.rb

@@ -5,7 +5,7 @@ require "tempfile"
 class Tracksperanto::BufferIO < DelegateClass(IO)
   include Tracksperanto::Returning
   
-  IN_MEMORY_SIZE_LIMIT = 100_000
+  MAX_IN_MEM_BYTES = 100_000
   
   def initialize
     __setobj__(StringIO.new)
@@ -37,12 +37,11 @@ class Tracksperanto::BufferIO < DelegateClass(IO)
   def replace_with_tempfile_if_needed
     return if @tempfile_in
     io = __getobj__
-    if io.pos > IN_MEMORY_SIZE_LIMIT
-      @tempfile_in = true
+    if io.pos > MAX_IN_MEM_BYTES
       tf = Tempfile.new("tracksperanto-xbuf")
-      io.rewind
-      tf.write(io.read) until io.eof?
+      tf.write(io.string)
       __setobj__(tf)
+      @tempfile_in = true
     end
   end
 end

data/test/import/test_boujou_import.rb

@@ -12,9 +12,7 @@ class BoujouImportTest < Test::Unit::TestCase
   def test_parsing_from_fixture
      fixture = File.open(File.dirname(__FILE__) + '/samples/boujou_features_text/boujou_txt_export.txt')
      
-     parser = Tracksperanto::Import::Boujou.new
-     parser.width = 2560
-     parser.height = 1200
+     parser = Tracksperanto::Import::Boujou.new(:width => 2560, :height => 1200)
      
      trackers = parser.parse(fixture)
      assert_equal 20, trackers.length

data/test/import/test_pftrack_import.rb

@@ -9,7 +9,7 @@ class PFTrackImportTest < Test::Unit::TestCase
     assert !i.autodetects_size?
   end
   
-  def test_parsing_from_pftrack5_second_file
+  def test_parsing_from_pftrack5_with_digit_names
     fixture = File.open(File.dirname(__FILE__) + '/samples/pftrack5/apft.2dt')
     parser = Tracksperanto::Import::PFTrack.new(:width => 1920, :height => 1080)
     

data/test/test_tracksperanto.rb

@@ -42,6 +42,11 @@ class TracksperantoTest < Test::Unit::TestCase
     assert_equal i1, Tracksperanto::Import::Syntheyes
   end
   
+  def test_get_middleware
+    i1 = Tracksperanto.get_middleware("lERP")
+    assert_equal i1, Tracksperanto::Middleware::Lerp
+  end
+  
   def test_get_importer_multicase
     i1 = Tracksperanto.get_importer("ShakeScript")
     assert_equal i1, Tracksperanto::Import::ShakeScript

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tracksperanto
 version: !ruby/object:Gem::Version 
-  version: 1.8.4
+  version: 1.9.0
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-10 00:00:00 +01:00
+date: 2010-03-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: progressbar
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: flexmock
   type: :development