tracksperanto 1.9.8 → 1.9.9

data/Manifest.txt

@@ -58,6 +58,7 @@ lib/tracksperanto/simple_export.rb
 lib/tracksperanto/tracker.rb
 lib/tracksperanto/uv_coordinates.rb
 lib/tracksperanto/zip_tuples.rb
+lib/tracksperanto/accumulator.rb
 test/export/README_EXPORT_TESTS.txt
 test/export/samples/ref_Mayalive.txt
 test/export/samples/ref_Mayalive_CustomAspect.txt

data/bin/tracksperanto

@@ -5,7 +5,7 @@
 #
 # == Usage
 # 
-#   tracksperanto -f ShakeScript -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk
+#   tracksperanto -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk --only flamestabilizer
 #   
 # == Author
 #   Julik <me@julik.nl>

data/lib/import/base.rb

@@ -8,6 +8,9 @@ class Tracksperanto::Import::Base
   include Tracksperanto::ZipTuples
   include Tracksperanto::ConstName
   
+  # Every time the importer accumulates a tracker this block will be called
+  attr_accessor :receiver
+  
   # Tracksperanto will assign a proc that reports the status of the import to the caller.
   # This block is automatically used by report_progress IF the proc is assigned. Should
   # the proc be nil, the report_progress method will just pass (so you don't need to check for nil
@@ -60,12 +63,30 @@ class Tracksperanto::Import::Base
     @progress_block.call(message) if @progress_block
   end
   
+  # OBSOLETE: do not implement this method in your importer. This is used to accumulate trackers in an array
+  # and then send it to the caller. Used in tests.
+  def parse(track_file_io)
+    @receiver = []
+    class << @receiver
+      def call(with)
+        push(with)
+      end
+    end
+    
+    stream_parse(track_file_io)
+    @receiver
+  end
+  
   # The main method of the parser. Will receive an IO handle to the file being imported, and should
-  # return an array of Tracksperanto::Tracker objects containing keyframes. If you have a problem
-  # doing an import, raise from here. Note that in general it's a good idea to stream-parse a document
+  # send each consecutive tracker via the send_tracker method.
+  # Note that in general it's a good idea to stream-parse a document
   # instead of bulk-reading it into memory (since Tracksperanto tries to be mem-efficient when dealing
   # with large files)
-  def parse(track_file_io)
-    []
+  def stream_parse(track_file_io)
+  end
+  
+  # When a tracker has been detected completely (all keyframes) call this method with the tracker object as argument
+  def send_tracker(tracker_obj)
+    @receiver.call(tracker_obj) if @receiver
   end
 end

data/lib/import/boujou.rb

@@ -4,16 +4,25 @@ class Tracksperanto::Import::Boujou < Tracksperanto::Import::Base
     "Boujou feature tracks export"
   end
   
-  def parse(io)
+  def stream_parse(io)
     wrapped_io = Tracksperanto::ExtIO.new(io)
     detect_columns(wrapped_io)
     trackers = {}
     filtering_trackers_from(wrapped_io) do | name, frame, x, y |
-      trackers[name] ||= Tracksperanto::Tracker.new(:name => name)
+      if @last_tracker && (name != @last_tracker.name)
+        send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
+        @last_tracker = nil
+      end
+      
+      if !@last_tracker
+        @last_tracker = Tracksperanto::Tracker.new(:name => name)
+      end
+      
       report_progress("Extracting frame #{frame} of #{name}")
-      trackers[name].keyframe!(:frame => (frame.to_i - 1), :abs_y => (@height.to_f - y.to_f), :abs_x => x)
+      @last_tracker.keyframe!(:frame => (frame.to_i - 1), :abs_y => (@height.to_f - y.to_f), :abs_x => x)
     end
-    trackers.values.sort{|a,b| a.name <=> b.name }
+    
+    send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
   end
   
   private

data/lib/import/equalizer3.rb

@@ -9,9 +9,8 @@ class Tracksperanto::Import::Equalizer3 < Tracksperanto::Import::Base
     true
   end
   
-  def parse(passed_io)
+  def stream_parse(passed_io)
     io = Tracksperanto::ExtIO.new(passed_io)
-    
     detect_format!(io)
     extract_trackers(io)
   end
@@ -24,31 +23,22 @@ class Tracksperanto::Import::Equalizer3 < Tracksperanto::Import::Base
     end
     
     def extract_trackers(io)
-      ts = []
       while line = io.gets do
         if line =~ /^(\w+)/ # Tracker name
-          discard_last_empty_tracker!(ts)
-          ts.push(Tracksperanto::Tracker.new(:name => line.strip))
+          send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
+          @last_tracker = Tracksperanto::Tracker.new(:name => line.strip)
           report_progress("Capturing tracker #{line.strip}")
         elsif line =~ /^\t/
-          ts[-1].push(make_keyframe(line))
+          @last_tracker.keyframe!(make_keyframe(line))
         end
       end
       
-      discard_last_empty_tracker!(ts)
-      ts
-    end
-    
-    def discard_last_empty_tracker!(in_array)
-      if (in_array.any? && in_array[-1].empty?)
-        in_array.delete_at(-1)
-        report_progress("Removing the last tracker since it had no keyframes")
-      end
+      send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
     end
     
     def make_keyframe(from_line)
       frame, x, y = from_line.split
       report_progress("Capturing keyframe #{frame}")
-      Tracksperanto::Keyframe.new(:frame => (frame.to_i - 1), :abs_x => x, :abs_y => y)
+      {:frame => (frame.to_i - 1), :abs_x => x, :abs_y => y}
     end
 end

data/lib/import/equalizer4.rb

@@ -6,14 +6,10 @@ class Tracksperanto::Import::Equalizer4 < Tracksperanto::Import::Base
   end
   
   
-  def parse(passed_io)
-    ts = []
+  def stream_parse(passed_io)
     io = Tracksperanto::ExtIO.new(passed_io)
-    
     num_t = detect_num_of_points(io)
-    num_t.times { ts << extract_tracker(io) }
-    
-    ts
+    num_t.times { send_tracker(extract_tracker(io)) }
   end
   
   private

data/lib/import/flame_stabilizer.rb

@@ -71,7 +71,7 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
     private :to_ary
   end
   
-  def parse(io)
+  def stream_parse(io)
     report_progress("Extracting setup size")
     self.width, self.height = extract_width_and_height_from_stream(io)
     report_progress("Extracting all animation channels")
@@ -81,7 +81,7 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
     raise "A channel was nil" if channels.find{|e| e.nil? }
     
     report_progress("Assembling tracker curves from channels")
-    scavenge_trackers_from_channels(channels)
+    scavenge_trackers_from_channels(channels) {|t| send_tracker(t) }
   end
   
   private
@@ -154,6 +154,12 @@ Channel tracker1/ref/x
     end
     
     USEFUL_CHANNELS = %w( /shift/x /shift/y /ref/x /ref/y ).map(&Regexp.method(:new))
+    
+    # This method tells the importer whether a channel that has been found in the source
+    # setup is needed. If that method returns ++false++ the channel will be discarded and not
+    # kept in memory. Should you need to write a module that scavenges other Flame animation channels
+    # inherit from this class and rewrite this method to either return +true+ always (then all the channels
+    # will be recovered) or to return +true+ only for channels that you actually need.
     def channel_is_useful?(channel_name)
       USEFUL_CHANNELS.any?{|e| channel_name =~ e }
     end
@@ -161,13 +167,10 @@ Channel tracker1/ref/x
     REF_CHANNEL = "ref" # or "track" - sometimes works sometimes don't
     
     def scavenge_trackers_from_channels(channels)
-      trackers = []
       channels.select{|e| e.name =~ /\/#{REF_CHANNEL}\/x/}.each do | track_x |
         report_progress("Detected reference channel #{track_x}")
-        trackers << grab_tracker(channels, track_x)
+        yield grab_tracker(channels, track_x)
       end
-      
-      trackers
     end
     
     def grab_tracker(channels, track_x)

data/lib/import/match_mover.rb

@@ -12,10 +12,10 @@ class Tracksperanto::Import::MatchMover < Tracksperanto::Import::Base
     ".rz2"
   end
   
-  def parse(io)
+  def stream_parse(io)
     trackers = []
     detect_format(io)
-    extract_trackers(io)
+    extract_trackers(io) { |t| send_tracker(t) }
   end
   
   private
@@ -29,11 +29,9 @@ class Tracksperanto::Import::MatchMover < Tracksperanto::Import::Base
   end
   
   def extract_trackers(io)
-    tracks = []
     while(line = io.gets) do
-      tracks << extract_track(line, io) if line =~ /^pointTrack/
+      yield(extract_track(line, io)) if line =~ /^pointTrack/
     end
-    tracks
   end
   
   def extract_track(start_line, io)

data/lib/import/maya_live.rb

@@ -15,24 +15,24 @@ class Tracksperanto::Import::MayaLive < Tracksperanto::Import::Base
   
   COMMENT = /^# /
   
-  def parse(original_io)
+  def stream_parse(original_io)
     io = Tracksperanto::ExtIO.new(original_io)
     extract_width_height_and_aspect(io.gets_non_empty)
-    trackers = []
     
     while line = io.gets_and_strip
       if line =~ COMMENT
-        trackers << Tracksperanto::Tracker.new(:name => line.gsub(/#{COMMENT} Name(\s+)/, ''))
+        send_tracker(@last_tracker) if @last_tracker
+        @last_tracker = Tracksperanto::Tracker.new(:name => line.gsub(/#{COMMENT} Name(\s+)/, ''))
         next
       end
       
       tracker_num, frame, x, y, residual = line.split
       
       abs_x, abs_y = aspect_values_to_pixels(x, y)
-      trackers[-1].keyframe! :frame => frame, :abs_x => abs_x, :abs_y => abs_y,  :residual => set_residual(residual)
+      @last_tracker.keyframe! :frame => frame, :abs_x => abs_x, :abs_y => abs_y,  :residual => set_residual(residual)
     end
     
-    trackers
+    send_tracker(@last_tracker) if @last_tracker
   end
   
   private

data/lib/import/nuke_script.rb

@@ -10,8 +10,14 @@ class Tracksperanto::Import::NukeScript < Tracksperanto::Import::Base
     ".nk"
   end
   
-  def parse(io)
-    scan_for_tracker3_nodes(Tracksperanto::ExtIO.new(io))
+  def stream_parse(in_io)
+    io = Tracksperanto::ExtIO.new(in_io)
+    while line = io.gets_and_strip
+      if line =~ TRACKER_3_PATTERN
+        scan_tracker_node(io).each { |t| send_tracker(t) }
+      end
+    end
+    
   end
   
   private
@@ -20,13 +26,6 @@ class Tracksperanto::Import::NukeScript < Tracksperanto::Import::Base
     TRACK_PATTERN = /^track(\d) \{/
     NODENAME = /^name ([^\n]+)/
     
-    def scan_for_tracker3_nodes(io)
-      tracks = []
-      while line = io.gets_and_strip
-        tracks += scan_tracker_node(io) if line =~ TRACKER_3_PATTERN
-      end
-      tracks
-    end
     
     def scan_tracker_node(io)
       tracks_in_tracker = []

data/lib/import/pftrack.rb

@@ -9,8 +9,7 @@ class Tracksperanto::Import::PFTrack < Tracksperanto::Import::Base
   
   CHARACTERS_OR_QUOTES = /[AZaz"]/
   
-  def parse(io)
-    trackers = []
+  def stream_parse(io)
     until io.eof?
       line = io.gets
       next if (!line || line =~ /^#/)
@@ -19,11 +18,9 @@ class Tracksperanto::Import::PFTrack < Tracksperanto::Import::Base
         t = Tracksperanto::Tracker.new{|t| t.name = line.strip.gsub(/"/, '') }
         report_progress("Reading tracker #{t.name}")
         parse_tracker(t, io)
-        trackers << t
+        send_tracker(t)
       end
     end
-    
-    trackers
   end
   
   private
@@ -35,10 +32,10 @@ class Tracksperanto::Import::PFTrack < Tracksperanto::Import::Base
       end
       
       num_of_keyframes = first_tracker_line.to_i
-      t.keyframes = (1..num_of_keyframes).map do | keyframe_idx |
+      (1..num_of_keyframes).map do | keyframe_idx |
         report_progress("Reading keyframe #{keyframe_idx} of #{num_of_keyframes} in #{t.name}")
         f, x, y, residual = io.gets.chomp.split
-        Tracksperanto::Keyframe.new(:frame => f, :abs_x => x, :abs_y => y, :residual => residual.to_f * 8)
+        t.keyframe!(:frame => f, :abs_x => x, :abs_y => y, :residual => residual.to_f * 8)
       end
     end
 end

data/lib/import/shake_script.rb

@@ -25,8 +25,8 @@ class Tracksperanto::Import::ShakeScript < Tracksperanto::Import::Base
       node_name = atom[1][-1]
       trackers = atom[2][1][1..-1]
       trackers.map do | tracker |
-       tracker.name = [node_name, tracker.name].join("_")
-       sentinel[0].push(tracker)
+        tracker.name = [node_name, tracker.name].join("_")
+        sentinel[0].call(tracker)
       end
     end
     
@@ -239,11 +239,19 @@ class Tracksperanto::Import::ShakeScript < Tracksperanto::Import::Base
     end
   end
   
-  def parse(script_io)
-    trackers = []
+  class PushCall
+    def initialize(proc)
+      @proc = proc
+    end
+    
+    def push(t)
+      @proc.call(t)
+    end
+  end
+  
+  def stream_parse(script_io)
     progress_proc = lambda{|msg| report_progress(msg) }
-    Traxtractor.new(script_io, [trackers, progress_proc])
-    trackers
+    Traxtractor.new(script_io, [method(:send_tracker), progress_proc])
   end
   
 end

data/lib/import/shake_text.rb

@@ -1,22 +1,22 @@
-
+# Import for Shake Text files
 class Tracksperanto::Import::ShakeText < Tracksperanto::Import::Base
   
   def self.human_name
     "Shake .txt tracker file"
   end
   
-  def parse(io)
-    trackers = []
+  def stream_parse(io)
     io.each do | line |
       if line =~ /TrackName (.+)/
-        trackers << Tracksperanto::Tracker.new{|t| t.name = $1 }
+        send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
+        @last_tracker = Tracksperanto::Tracker.new{|t| t.name = $1 }
         # Toss the next following string - header
         io.gets
       else
         keyframe_values = line.split
         next if keyframe_values.length < 4
         
-        trackers[-1].keyframes << Tracksperanto::Keyframe.new do | kf |
+        @last_tracker.keyframes << Tracksperanto::Keyframe.new do | kf |
           kf.frame = (keyframe_values[0].to_i - 1)
           kf.abs_x = keyframe_values[1]
           kf.abs_y = keyframe_values[2]
@@ -25,6 +25,7 @@ class Tracksperanto::Import::ShakeText < Tracksperanto::Import::Base
       end
     end
     
-    trackers
+    send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
   end
+  
 end

data/lib/import/syntheyes.rb

@@ -5,29 +5,28 @@ class Tracksperanto::Import::Syntheyes < Tracksperanto::Import::Base
     "Syntheyes 2D tracker paths file"
   end
   
-  def parse(io)
-    trackers = []
+  def stream_parse(io)
     io.each_line do | line |
       name, frame, x, y, frame_status = line.split
       
       # Do we already have this tracker?
-      t = trackers.find {|e| e.name == name}
-      if !t
+      unless @last_tracker && @last_tracker.name == name
+        send_tracker(@last_tracker) if @last_tracker
         report_progress("Allocating tracker #{name}")
-        t = Tracksperanto::Tracker.new{|t| t.name = name }
-        trackers << t
+        @last_tracker = Tracksperanto::Tracker.new{|t| t.name = name }
       end
       
       # Add the keyframe
-      t.keyframes << Tracksperanto::Keyframe.new do |e| 
+      k = Tracksperanto::Keyframe.new do |e| 
         e.frame = frame
         e.abs_x = convert_from_uv(width, x)
         e.abs_y = height - convert_from_uv(height, y) # Convert TL to BL
       end
+      
+      @last_tracker.push(k)
       report_progress("Adding keyframe #{frame} to #{name}")
     end
+    send_tracker(@last_tracker) if @last_tracker && @last_tracker.any?
     
-    trackers
   end
-
 end

data/lib/pipeline/base.rb

@@ -116,25 +116,31 @@ class Tracksperanto::Pipeline::Base
     end
     @ios << io_with_progress
     
-    trackers = importer.parse(io_with_progress)
-    report_progress(percent_complete = 50.0, "Validating #{trackers.length} imported trackers")
+    accumulator = Tracksperanto::Accumulator.new
+    importer.receiver = accumulator
+    @ios << accumulator
     
-    validate_trackers!(trackers)
+    importer.stream_parse(io_with_progress)
+    
+    report_progress(percent_complete = 50.0, "Validating #{accumulator.length} imported trackers")
+    raise "Could not recover any non-empty trackers from this file. Wrong import format maybe?" if accumulator.numt.zero?
     
     report_progress(percent_complete, "Starting export")
     
-    percent_per_tracker = (100.0 - percent_complete) / trackers.length
+    percent_per_tracker = (100.0 - percent_complete) / accumulator.numt
     
     # Use the width and height provided by the parser itself
     exporter.start_export(importer.width, importer.height)
-    trackers.each_with_index do | t, tracker_idx |
+    accumulator.each_object_with_index do | t, tracker_idx |
+      raise "Not a Tracker" unless t.is_a?(Tracksperanto::Tracker)
+      
       kf_weight = percent_per_tracker / t.keyframes.length
       points += 1
       exporter.start_tracker_segment(t.name)
       t.each_with_index do | kf, idx |
         keyframes += 1
         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")
+        report_progress(percent_complete += kf_weight, "Writing keyframe #{idx+1} of #{t.name.inspect}, #{accumulator.numt - tracker_idx} trackers to go")
       end
       exporter.end_tracker_segment
     end
@@ -166,10 +172,4 @@ class Tracksperanto::Pipeline::Base
     @ios ||= []
     @ios.push(File.open(path_to_file, "wb"))[-1]
   end
-  
-  # Check that the trackers made by the parser are A-OK
-  def validate_trackers!(trackers)
-    trackers.reject!{|t| t.empty? }
-    raise "Could not recover any non-empty trackers from this file. Wrong import format maybe?" if trackers.empty?
-  end
 end

data/lib/tracksperanto/accumulator.rb

@@ -0,0 +1,33 @@
+class Tracksperanto::Accumulator < DelegateClass(IO)
+  
+  attr_reader :numt
+  def initialize
+    __setobj__(Tracksperanto::BufferIO.new)
+    @numt = 0
+  end
+  
+  def call(with_arrived_tracker)
+    
+    @numt += 1
+    
+    d = Marshal.dump(with_arrived_tracker)
+    bytelen = d.size
+    write(bytelen)
+    write("\t")
+    write(d)
+    write("\n")
+  end
+  
+  def each_object_with_index
+    rewind
+    @numt.times { |i| yield(recover_tracker, i - 1) }
+  end
+  
+  private
+  
+  def recover_tracker
+    # Read everything upto the tab
+    demarshal_bytes = gets("\t").strip.to_i
+    Marshal.load(read(demarshal_bytes))
+  end
+end

data/lib/tracksperanto.rb

@@ -4,7 +4,7 @@ require 'tempfile'
 
 module Tracksperanto
   PATH = File.expand_path(File.dirname(__FILE__))
-  VERSION = '1.9.8'
+  VERSION = '1.9.9'
   
   module Import; end
   module Export; end
@@ -83,6 +83,7 @@ end
   simple_export
   uv_coordinates
   flame_builder
+  accumulator
 ).each do | submodule |
   require File.join(Tracksperanto::PATH, "tracksperanto", submodule)
 end

data/test/helper.rb

@@ -80,8 +80,7 @@ module ParabolicTracks
   def ensure_same_output(exporter_klass, reference_path, message = "The line should be identical")
     if ENV['OVERWRITE']
       File.open(reference_path, "w") do | out |
-        x = exporter_klass.new(out)
-        export_parabolics_with(x)
+        export_parabolics_with(exporter_klass.new(out))
       end
     end
     

data/test/import/test_3de_import.rb

@@ -15,8 +15,8 @@ class EqualizerImportTest < Test::Unit::TestCase
     parser = Tracksperanto::Import::Equalizer4.new
     parser.width = 1024
     parser.height = 512
-    
     trackers = parser.parse(fixture)
+    
     assert_equal 8, trackers.length
     
     first_t = trackers[0]

data/test/import/test_3de_import3.rb

@@ -13,7 +13,6 @@ class Equalizer3ImportTest < Test::Unit::TestCase
     fixture = File.open(File.dirname(__FILE__) + '/samples/3de_v3/3de_export_v3.txt')
     
     parser = Tracksperanto::Import::Equalizer3.new
-    
     trackers = parser.parse(fixture)
     
     assert_equal 2048, parser.width

data/test/import/test_boujou_import.rb

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

data/test/test_flame_builder.rb

@@ -1,5 +1,4 @@
 require File.dirname(__FILE__) + '/helper'
-require "benchmark"
 
 class FlameBuilderTest < Test::Unit::TestCase
   def setup

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tracksperanto
 version: !ruby/object:Gem::Version 
-  hash: 35
+  hash: 33
   prerelease: false
   segments: 
   - 1
   - 9
-  - 8
-  version: 1.9.8
+  - 9
+  version: 1.9.9
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 +02:00
+date: 2010-11-29 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,12 +54,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 21
         segments: 
         - 2
         - 6
-        - 0
-        version: 2.6.0
+        - 1
+        version: 2.6.1
   type: :development
   version_requirements: *id003
 description: Tracksperanto is a universal 2D-track translator between many apps.
@@ -135,6 +135,7 @@ files:
 - lib/tracksperanto/tracker.rb
 - lib/tracksperanto/uv_coordinates.rb
 - lib/tracksperanto/zip_tuples.rb
+- lib/tracksperanto/accumulator.rb
 - test/export/README_EXPORT_TESTS.txt
 - test/export/samples/ref_Mayalive.txt
 - test/export/samples/ref_Mayalive_CustomAspect.txt