tracksperanto 1.1.1 → 1.2.0

data/History.txt

@@ -1,3 +1,14 @@
+=== 1.2.0 / 2009-09-20
+
+* Add experimental MatchMoverPro import and export support
+* Rewrite the Shake parser, support MatchMove and Stabilize nodes and many tracks per node
+* Officially add and test the Reformat middleware
+* Remove the Close middleware and close IOs automatically at pipeline end
+* Much improved documentation
+* Use IO as base for all the parsers (if a parser needs a string it will have to read by himself)
+* Much improved test coverage
+* Support Nuke import and export
+
 === 1.0.0 / 2009-04-19
 
 * Welcome

data/Manifest.txt

@@ -6,44 +6,88 @@ Rakefile
 bin/tracksperanto
 lib/.DS_Store
 lib/export/base.rb
+lib/export/match_mover.rb
 lib/export/mux.rb
+lib/export/nuke_script.rb
 lib/export/pftrack.rb
 lib/export/shake_text.rb
 lib/export/syntheyes.rb
 lib/import/base.rb
 lib/import/flame_stabilizer.rb
+lib/import/match_mover.rb
+lib/import/nuke_script.rb
 lib/import/pftrack.rb
+lib/import/shake_grammar/catcher.rb
+lib/import/shake_grammar/lexer.rb
 lib/import/shake_script.rb
 lib/import/shake_text.rb
 lib/import/syntheyes.rb
 lib/middleware/base.rb
-lib/middleware/close.rb
 lib/middleware/golden.rb
 lib/middleware/reformat.rb
 lib/middleware/scaler.rb
+lib/middleware/shift.rb
 lib/middleware/slipper.rb
 lib/pipeline/base.rb
 lib/tracksperanto.rb
+lib/tracksperanto/block_init.rb
+lib/tracksperanto/casts.rb
+lib/tracksperanto/format_detector.rb
+lib/tracksperanto/keyframe.rb
+lib/tracksperanto/safety.rb
+lib/tracksperanto/tracker.rb
+lib/tracksperanto/zip_tuples.rb
 test/.DS_Store
+test/export/.DS_Store
+test/export/README_EXPORT_TESTS.txt
+test/export/samples/ref_NukeScript.nk
+test/export/samples/ref_NukeScript.nk.autosave
+test/export/samples/ref_PFTrack.2dt
+test/export/samples/ref_ShakeText.txt
+test/export/samples/ref_Syntheyes.txt
+test/export/samples/ref_matchmover.rz2
+test/export/test_match_mover_export.rb
+test/export/test_mux.rb
+test/export/test_nuke_export.rb
+test/export/test_pftrack_export.rb
+test/export/test_shake_export.rb
+test/export/test_syntheyes_export.rb
 test/helper.rb
-test/samples/.DS_Store
-test/samples/flyover2DP_syntheyes.txt
-test/samples/fromCombustion_fromMidClip_wSnap.stabilizer
-test/samples/hugeFlameSetup.stabilizer
-test/samples/megaTrack.action.3dtrack.stabilizer
-test/samples/one_shake_tracker.txt
-test/samples/one_shake_tracker_from_first.txt
-test/samples/shake_tracker_nodes.shk
-test/samples/shake_tracker_nodes_to_syntheyes.txt
-test/samples/sourcefile_pftrack.2dt
-test/samples/three_tracks_in_one_stabilizer.shk
-test/samples/two_shake_trackers.txt
-test/samples/two_tracks_in_one_tracker.shk
-test/test_flame_import.rb
+test/import/.DS_Store
+test/import/samples/.DS_Store
+test/import/samples/flyover2DP_syntheyes.txt
+test/import/samples/four_tracks_in_one_matchmove.shk
+test/import/samples/four_tracks_in_one_stabilizer.shk
+test/import/samples/fromCombustion_fromMidClip_wSnap.stabilizer
+test/import/samples/hugeFlameSetup.stabilizer
+test/import/samples/kipPointsMatchmover.rz2
+test/import/samples/megaTrack.action.3dtrack.stabilizer
+test/import/samples/one_shake_tracker.txt
+test/import/samples/one_shake_tracker_from_first.txt
+test/import/samples/one_tracker_with_break.nk
+test/import/samples/one_tracker_with_break_in_grp.nk
+test/import/samples/shake_tracker_nodes.shk
+test/import/samples/shake_tracker_nodes_to_syntheyes.txt
+test/import/samples/sourcefile_pftrack.2dt
+test/import/samples/three_tracks_in_one_stabilizer.shk
+test/import/samples/two_shake_trackers.txt
+test/import/samples/two_tracks_in_one_tracker.shk
+test/import/test_flame_import.rb
+test/import/test_match_mover_import.rb
+test/import/test_nuke_import.rb
+test/import/test_pftrack_import.rb
+test/import/test_shake_catcher.rb
+test/import/test_shake_lexer.rb
+test/import/test_shake_script_import.rb
+test/import/test_shake_text_import.rb
+test/import/test_syntheyes_import.rb
+test/middleware/test_golden_middleware.rb
+test/middleware/test_reformat_middleware.rb
+test/middleware/test_scaler_middleware.rb
+test/middleware/test_shift_middleware.rb
+test/middleware/test_slip_middleware.rb
+test/pipeline/test_pipeline_base.rb
+test/test_format_detector.rb
 test/test_keyframe.rb
-test/test_pftrack_import.rb
-test/test_shake_export.rb
-test/test_shake_script_import.rb
-test/test_shake_text_import.rb
-test/test_syntheyes_import.rb
+test/test_tracker.rb
 tracksperanto.gemspec

data/README.txt

@@ -6,51 +6,103 @@
 
 Tracksperanto is a universal 2D-track translator between many apps.
 
+== Why Tracksperanto?
+
+Historically, every matchmoving app uses it's own UI for tracking 2D features.
+Unfortunately, the UIs of these are all different and not very user-friendly. It happens
+that an app cannot solve a shot that another one will, but you usually have to redo your 2D
+tracks in each one of them.
+
+Another problem with today's matchmoving apps is that they are vastly inefficient when
+doing 2D tracks. Almost all of them use OpenGL and want to load the whole frame into memory
+at once. When doing tracks of long shots at high resolutions (like 2K and HD), especially
+on 32bit platforms, the app usually cannot even cache the whole shot and tracking is very
+very slow.
+
+Compositing apps, in contrast, are very efficient in this. Both Shake and Nuke offer very
+fast trackers because they can load only the search area for the tracker into memory and
+not a pixel more. When you use manual feature selection you can create many tracks very
+quickyl even without having fast IO. Flame is also very fast since it has virtually zero IO
+overhead thanks to it's fast storage. Compositing apps also allow for precise, local
+preprocessing of tracking features like boosting contrast, doing expensive (especially
+temporal) denoise, blurs and so on, while matchmoving apps offer only a single, global
+preprocessing step (like a LUT or a gamma curve adjustment) which is not adequate for all
+of the features being tracked.
+
+It's thusly very natural to track in a modern compositing app that has selective image
+loading, and then export one single group of tracks into all of the matchmoving
+applications and figuring out which one gives a better camera solve. Also, you can always
+escape into the 2D world if no 3D app proves to be adequate. If you need to move from one
+app to another, you won't have to retrack.
+
+Another issue with tracks is adjusting to formats. Very few apps allow you to convert your
+tracks in one stop from format to format - like doing an unproportional scale on the
+tracks, or moving them a few pixels left and right. This comes at a high cost of the
+footage you are tracking came cropped or in a wrong aspect - the only way to solve the shot
+will be to retrack it from scratch. Tracksperanto allows you to work around this
+by applying simple transformations to the tracks.
+
+== Usage
+
+The main way to use Tracksperanto is to use the supplied "tracksperanto" binary, like so:
+
+ tracksperanto -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk
+
+-w and -h stand for Width and Height and define the size of your comp (different tracking
+apps use different coordinate systems and we need to know the size of the comp to properly
+convert these). You also have additional options like -xs, -ys and --slip - consult the
+usage info for the tracksperanto binary.
+
+The converted files will be saved in the same directory as the source, if resulting
+converted files already exist <b>they will be overwritten without warning</b>.
+
+== Format support
+
 Import support:
-* Shake script (one tracker node per tracker)
-* Shake tracker node export (textfile with many tracks per file), also exported by Boujou and others
+
+* Flame .stabilizer file (not the .stabilizer.p blob format)
+* Nuke script (Tracker3 nodes, also known as Tracker)
+* Shake script (Tracker, Matchmove and Stabilize nodes)
+* Shake tracker node export (textfile with many tracks per file)
 * PFTrack 2dt files
-* Syntheyes 2D tracking data exports (UV coordinates)
+* Syntheyes 2D tracking data exports
+* MatchMover Pro .rz2
 
 Export support:
 
-* Shake text file (many trackers per file), also accepted by Boujou
+* Shake text file (many trackers per file), also accepted by Boujou.
+  May crash Shake with more than 4-5 tracks.
 * PFTrack 2dt file (with residuals)
 * Syntheyes 2D tracking data import (UV coordinates)
-
-The main way to use Tracksperanto is to use the supplied "tracksperanto" binary, like so:
-  
-  tracksperanto -f ShakeScript -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk
-
-ShakeScript is the name of the translator that will be used to read the file (many apps export tracks as .txt files so
-there is no way for us to autodetect them all). -w and -h stand for Width and Height and define the size of your comp (different
-tracking apps use different coordinate systems and we need to know the size of the comp to properly convert these). You also have
-additional options like -xs, -ys and --slip - consult the usage info for the tracksperanto binary.
-
-The converted files will be saved in the same directory as the source, if resulting converted files already exist ++they will be overwritten without warning++.
+* Nuke script
+* MatchMover Pro .rz2
 
 == Modularity
 
-Tracksperanto supports many export and import formats. It also can help when you need to import and export the same format,
-but you need some operation applied to the result (like scaling a proxy track up). Internally, Tracksperanto talks
-Exporters, Importers and Middlewares. Any processing chain usually works like this:
+Tracksperanto supports many export and import formats. It also can help when you need to
+import and export the same format, but you need some operation applied to the result (like
+scaling a proxy track up). Internally, Tracksperanto talks Exporters, Importers and
+Middlewares. Any processing chain (called a Pipeline) usually works like this:
 
-1) The tracker file is read and trackers and their keyframes are extracted, converting them to the internal representation.
-   For some formats you need to supply the width and height of the source material
-2) The trackers and their keyframes are dumped to all export formats Tracksperanto supports, optionally passing through middleware
+* Tracker file is read and trackers and their
+  keyframes are extracted, converting them to
+  the internal representation.
+* Trackers and their keyframes are dumped to all export
+  formats Tracksperanto supports, optionally passing through middleware
 
-== Internal coordinate system
+== Importing your own formats
 
-Frame numbers start from zero (frame 0 is first frame of the track).
+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
+are themselves arrays of Tracksperanto::Keyframe objects.
 
-Tracksperanto uses the Shake coordinates as base. Image is Y-positive, X-positive, absolute pixel values up and right (zero is in the
-lower left corner). Some apps use a different coordinate system so translation will take place on import or on export, respectively.
+== Exporting your own formats
 
-We also use residual and not correlation (residual is how far the tracker strolls away, correlation is how sure the tracker is
-about what it's doing). Residual is the inverse of correlation (with total correlation of one the residual excursion becomes zero).
+You can easily write an exporter. Refer to the Tracksperanto::Export::Base docs.
 
 == 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).
+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).

data/Rakefile

@@ -9,6 +9,7 @@ Hoe::RUBY_FLAGS.replace ENV['RUBY_FLAGS'] || "-I#{%w(lib test).join(File::PATH_S
   
 Hoe.spec('tracksperanto') do | p |
   p.version = Tracksperanto::VERSION
+  p.extra_deps = {"flexmock" => ">=0"}
   p.rubyforge_name = 'guerilla-di'
   p.developer('Julik Tarkhanov', 'me@julik.nl')
   p.extra_rdoc_files = p.extra_rdoc_files.reject{|e| e =~ "samples\/"}

data/bin/tracksperanto

@@ -14,33 +14,34 @@ require File.dirname(__FILE__) + '/../lib/tracksperanto'
 require 'optparse'
 
 # Sane defaults
-reader_klass = Tracksperanto::Import::ShakeScript
-width = 1920
-height = 1080
+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
 
-readers = Tracksperanto::Import.constants.map{|e| e.to_s }.reject{|e| e == 'Base'}
-informative_readers = readers.reject{|e| e == 'ShakeScript'}
+readers = Tracksperanto.importer_names
 
 parser = OptionParser.new do | p |
  p.banner = "Usage: tracksperanto -f ShakeScript -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk"
- p.on(" -f", "--from TRANSLATOR", String, "Use the specific import translator (defaults to ShakeScript, but can be \
- #{informative_readers.join(', ')})") do | f |
+ p.on(" -f", "--from TRANSLATOR", String, 
+   "Use the specific import translator (will try to autodetect, but can be #{readers.join(', ')})") do | f |
    begin
      reader_klass = Tracksperanto::Import.const_get(f)
    rescue NameError => e
      reader_list = readers.join("\n\t")
-     STDERR.puts "Unknown reader #{f.inspect}, available readers:\n\t#{readers}"
+     STDERR.puts "Unknown reader #{f.inspect}, available readers:\n\t#{readers.join(', ')}"
      exit(-1)
     end
  end
- p.on(" -w", "--width WIDTH_IN_PIXELS", Integer, "Absolute input comp width in pixels") { |w| width = w }
- p.on(" -h", "--height HEIGHT_IN_PIXELS", Integer, "Absolute input comp height in pixels") {|w| height = 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 }
@@ -53,7 +54,12 @@ parser = OptionParser.new do | p |
  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(" -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("--version", "Show the version and exit") {|v| 
+    puts "#{Tracksperanto::VERSION} running on Ruby #{RUBY_VERSION} on #{RUBY_PLATFORM}"
+    exit(0)
+ }
 end
 
 begin
@@ -73,12 +79,13 @@ end
 
 pipe = Tracksperanto::Pipeline::Base.new
 pipe.progress_block = lambda{|percent, msg| puts("#{msg}..#{percent.to_i}%") }
-
-pipe.run(input_file, width, height, reader_klass) do | scaler, slipper, golden, reformat |
+pipe.run(input_file, :pix_w => width, :pix_h => height, :parser => parser) do | scaler, slipper, golden, reformat, shift |
   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.width = reformat_h if reformat_h
+  reformat.height = reformat_h if reformat_h
+  shift.x_shift = x_shift
+  shift.y_shift = y_shift
 end

data/lib/export/base.rb

@@ -1,5 +1,9 @@
-# Base exporter
+# Base exporter. Inherit from this class to automatically register another export format. 
+# The exporters in Tracksperanto are event-driven and follow the same conventions - your
+# exporter will be notified when a tracker will be exported and when a tracker has been passed
+# (the last keyframe has been sent)
 class Tracksperanto::Export::Base
+  
   attr_reader :io
   
   def self.inherited(by)
@@ -7,25 +11,31 @@ class Tracksperanto::Export::Base
     super
   end
   
-  # Should return the suffix and extension of this export file (like "_flame.stabilizer"). It's a class
+  # Should return the suffix and extension of this export file (like "flame.stabilizer"). It's a class
   # method because it gets requested before the exporter is instantiated
   def self.desc_and_extension
     "data.txt"
   end
   
+  # Should return the human-readable (read: with spaces) name of the export module
+  def self.human_name
+    "Abstract export format"
+  end
+  
+  # The constructor for an exporter should accept a handle to the IO object that you can write to.
   def initialize(write_to_io)
     @io = write_to_io
   end
   
-  # Called on export start
+  # Called on export start. Will receive the width and height of the comp being exported
   def start_export( img_width, img_height)
   end
   
-  # Called on export end
+  # Called on export end. No need to close the passed IO, it will be done for you afterwards
   def end_export
   end
   
-  # Called on tracker start, one for each tracker
+  # Called on tracker start, once for each tracker. Receives the name of the tracker.
   def start_tracker_segment(tracker_name)
   end
   
@@ -33,7 +43,7 @@ class Tracksperanto::Export::Base
   def end_tracker_segment
   end
   
-  # Called for each tracker keyframe
+  # Called for each tracker keyframe, with the Tracksperanto internal coordinates and frame numbers
   def export_point(at_frame_i, abs_float_x, abs_float_y, float_residual)
   end
 end

data/lib/export/match_mover.rb

@@ -0,0 +1,40 @@
+# Export for Autodesk MatchMover/Image Modeler
+class Tracksperanto::Export::MatchMover < Tracksperanto::Export::Base
+  
+  def self.desc_and_extension
+    "matchmover.rz2"
+  end
+  
+  def self.human_name
+    "Matchmover 2D export .rz2 file"
+  end
+  
+  PREAMBLE = %[imageSequence	"Sequence 01"\n{\n\t2560\t1080\tf( "D:/temp/sequence.%04d.dpx" )\tb( 1 211 1 )\t\n}\n]
+  TRACKER_PREAMBLE = "pointTrack  %s  rgb( 255 0 0 )	\n{\n"
+  TRACKER_POSTAMBLE = "}\n"
+  FIRST_KEYFRAME_TEMPLATE = "\t%d\t   %.3f     %.3f    ki( 0.8 )\t    s( 66 66 64 64 )  p( 24 24 25 25 )"
+  KEYFRAME_TEMPLATE = "\t%d\t   %.3f     %.3f     p+( %.6f )\t"
+  
+  def start_export( img_width, img_height)
+    @io.puts(PREAMBLE.gsub(/2560/, img_width.to_s).gsub(/1080/, img_height.to_s))
+  end
+  
+  
+  def start_tracker_segment(tracker_name)
+    @tracker_name = tracker_name
+    @at_first_point = true
+    @io.write(TRACKER_PREAMBLE % tracker_name.inspect)
+  end
+  
+  def end_tracker_segment
+    @io.write(TRACKER_POSTAMBLE)
+  end
+  
+  def export_point(frame, abs_float_x, abs_float_y, float_residual)
+    template = @at_first_point ? FIRST_KEYFRAME_TEMPLATE : KEYFRAME_TEMPLATE
+    values = [frame + 1, abs_float_x, abs_float_y, (1 - float_residual)]
+    @io.puts(template % values)
+    @at_first_point = false
+  end
+  
+end

data/lib/export/nuke_script.rb

@@ -0,0 +1,78 @@
+# Export each tracker as a single Tracker3 node
+class Tracksperanto::Export::NukeScript < Tracksperanto::Export::Base
+    NODE_TEMPLATE = %[
+Tracker3 {
+     track1 {%s}
+     name %s
+     xpos 0
+     ypos %d
+}
+]
+    KEYFRAME_PRECISION_TEMPLATE = "%.4f"
+    PREAMBLE = %[
+version 5.1200
+Constant {
+ inputs 0
+ channels rgb
+ format "1920 1080 0 0 1920 1080 1"
+ name CompSize_1920x1080
+ postage_stamp false
+ xpos 0
+ ypos -60
+}]  
+    SCHEMATIC_OFFSET = 30
+    class T < Array
+      attr_accessor :name
+      include ::Tracksperanto::BlockInit
+    end
+    
+    # Should return the suffix and extension of this export file (like "_flame.stabilizer")
+    def self.desc_and_extension
+      "nuke.nk"
+    end
+    
+    def self.human_name
+      "Nuke .nk script"
+    end
+    
+    def start_export(w, h)
+      @io.puts(PREAMBLE.gsub(/1920/, w.to_s).gsub(/1080/, h.to_s))
+      @ypos = 0
+    end
+    
+    # We accumulate a tracker and on end dump it out in one piece
+    def start_tracker_segment(tracker_name)
+      # Setup for the next tracker
+      @tracker = T.new
+      @tracker.name = tracker_name
+    end
+    
+    def end_tracker_segment
+      @io.puts( 
+        NODE_TEMPLATE % [curves_from_tuples(@tracker), @tracker.name, (@ypos += SCHEMATIC_OFFSET)]
+      )
+    end
+    
+    def export_point(frame, abs_float_x, abs_float_y, float_residual)
+      # Nuke uses 1-based frames
+      @tracker << [frame + 1, abs_float_x, abs_float_y]
+    end
+    
+    private 
+    # Generates a couple of Nuke curves (x and y) from the passed tuples of [frame, x, y]
+    def curves_from_tuples(tuples)
+      x_values, y_values, last_frame_exported = [], [], nil
+      tuples.each do | t |
+        f = t.shift
+        unless last_frame_exported == (f - 1) # new section
+          x_values << "x#{f}"
+          y_values << "x#{f}"
+        end
+        t.map!{|e| KEYFRAME_PRECISION_TEMPLATE % e }
+        x_values << t.shift
+        y_values << t.shift
+        last_frame_exported = f
+      end
+      st = [x_values.join(" "), y_values.join(" ")].map{|e| "{curve i %s}" % e }.join(" ")
+    end
+end

data/lib/export/pftrack.rb

@@ -1,10 +1,16 @@
-class Tracksperanto::Export::Pftrack < Tracksperanto::Export::Base
+# Export for PFTrack .2dt files
+class Tracksperanto::Export::PFTrack < Tracksperanto::Export::Base
+    
+    KEYFRAME_TEMPLATE = "%s %.3f %.3f %.3f"
     
-    # Should return the suffix and extension of this export file (like "_flame.stabilizer")
     def self.desc_and_extension
       "pftrack.2dt"
     end
     
+    def self.human_name
+      "PFTrack .2dt file"
+    end
+    
     def start_tracker_segment(tracker_name)
       # Setup for the next tracker
       @prev_tracker = []
@@ -12,21 +18,15 @@ class Tracksperanto::Export::Pftrack < Tracksperanto::Export::Base
     end
     
     def end_tracker_segment
-      # If there was a previous tracker, write it out
-      # - now we know how many keyframes it has
-      if @prev_tracker && @prev_tracker.any?
-        block = [
-          "\n",
-          @tracker_name.inspect, # "autoquotes"
-          @prev_tracker.length,
-          @prev_tracker.join("\n")
-        ]
-        @io.puts block.join("\n")
-      end
+      block = [ "\n",
+        @tracker_name.inspect, # "autoquotes"
+        @prev_tracker.length,
+        @prev_tracker.join("\n") ]
+      @io.puts block.join("\n")
     end
     
     def export_point(frame, abs_float_x, abs_float_y, float_residual)
-      line = "%s %.3f %.3f %.3f" % [frame, abs_float_x, abs_float_y, float_residual]
+      line = KEYFRAME_TEMPLATE % [frame, abs_float_x, abs_float_y, float_residual / 8]
       @prev_tracker << line
     end
 end

data/lib/export/shake_text.rb

@@ -1,3 +1,4 @@
+# Export for Shake .txt tracker blobs
 class Tracksperanto::Export::ShakeText < Tracksperanto::Export::Base
   PREAMBLE = "TrackName %s\n   Frame             X             Y   Correlation\n"
   POSTAMBLE = "\n"
@@ -7,18 +8,16 @@ class Tracksperanto::Export::ShakeText < Tracksperanto::Export::Base
     "shake_trackers.txt"
   end
   
+  def self.human_name
+    "Shake trackers in a .txt file"
+  end
+  
   def start_tracker_segment(tracker_name)
-    if @any_tracks
-      @io.puts POSTAMBLE
-    else
-      @any_tracks = true
-    end
-    
     @io.puts PREAMBLE % tracker_name
   end
   
-  def end_export
-    @io << "\n"
+  def end_tracker_segment
+    @io.puts POSTAMBLE
   end
    
   def export_point(frame, abs_float_x, abs_float_y, float_residual)

data/lib/export/syntheyes.rb

@@ -1,3 +1,4 @@
+# Export for Syntheyes tracker UVs
 class Tracksperanto::Export::SynthEyes < Tracksperanto::Export::Base
   
   # Should return the suffix and extension of this export file (like "_flame.stabilizer")
@@ -5,6 +6,10 @@ class Tracksperanto::Export::SynthEyes < Tracksperanto::Export::Base
     "syntheyes_2dt.txt"
   end
   
+  def self.human_name
+    "Syntheyes 2D tracker .txt file"
+  end
+  
   def start_export( img_width, img_height)
     @width, @height = img_width, img_height
   end
@@ -14,7 +19,7 @@ class Tracksperanto::Export::SynthEyes < Tracksperanto::Export::Base
   end
   
   def export_point(frame, abs_float_x, abs_float_y, float_residual)
-    values = [@tracker_name, frame] + syntheyes_coords(abs_float_x, abs_float_y)
+    values = [@tracker_name, frame] + syntheyes_coords(abs_float_x, abs_float_y, @width, @height)
     @io.puts("%s %d %.6f %.6f 30" % values)
   end
   
@@ -22,10 +27,9 @@ class Tracksperanto::Export::SynthEyes < Tracksperanto::Export::Base
     
     # Syntheyes wants very special coordinates, Y down X right,
     # 0 is center and values are UV float -1 to 1, doubled
-    def syntheyes_coords(abs_x, abs_y)
-      w, h = 2560, 1080
-      x = (abs_x / @width.to_f) - 0.5
-      y = (abs_y / @height.to_f) - 0.5
+    def syntheyes_coords(abs_x, abs_y, w, h)
+      x = (abs_x / w.to_f) - 0.5
+      y = (abs_y / h.to_f) - 0.5
       # .2 to -.3, y is reversed and coords are double
       [x * 2, y * -2]
     end