tracksperanto 1.6.4 → 1.6.5

data/History.txt

@@ -1,3 +1,8 @@
+=== 1.6.5 / 2009-11-27
+
+* Adds the --only option for the tracksperanto binary to only export a specific format
+* Automatically unlink tempfiles in the Equalizer4 exporter
+
 === 1.6.4 / 2009-11-25
 
 * Adds Boujou 2d feature import support (to export for Boujou use the Shake text format)

data/README.txt

@@ -19,72 +19,62 @@ at once. When doing tracks of long shots at high resolutions (like 2K and HD), e
 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
+Compositing apps, in contrast, are very efficient. Both Shake and Nuke offer very
+fast trackers because they have tiling image engines and 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 quickly 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.
+
+So it's 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.
+applications at once. 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
+tracks, or moving them a few pixels left and right. This comes at a high cost if 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:
+The main way to use Tracksperanto is with the 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.
+convert these). Some formats contain clear hints on the size of the comp, but most don't -
+for formats that do contain them you don't need to supply anything.
+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:
-
-* Flame .stabilizer file (not the .stabilizer.p blob format)
-* Nuke script (Tracker3 nodes, also known as Tracker)
-* Shake script (Tracker, Matchmove and Stabilize nodes)
+Import and export support:
+* Nuke v5 script (Tracker3 nodes, also known as Tracker in the UI - this is the node that you track with)
 * Shake tracker node export (textfile with many tracks per file)
-* PFTrack 2dt files
+* PFTrack 2dt files (version 4 and 5)
 * Syntheyes 2D tracking data exports
 * 3DE point exports (as output by the default script) - versions 3 and 4
 * MatchMover Pro .rz2
 * MayaLive track export (square pixel aspect only)
 
-Export support:
-
-* 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)
-* Nuke script
-* 3DE point exports (as accepted by the default import)
-* MatchMover Pro .rz2
-* MayaLive track export (square pixel aspect only)
+Import only:
+* Boujou feature track export
+* Flame .stabilizer file (not the .stabilizer.p blob format)
+* Shake script (Tracker, Matchmove and Stabilize nodes)
 
 == 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
+Tracksperanto is very modular and can process data passing through it (like
 scaling a proxy track up). Internally, Tracksperanto talks Exporters, Importers and
 Middlewares. Any processing chain (called a Pipeline) usually works like this:
 

data/bin/tracksperanto

@@ -26,8 +26,10 @@ golden_tracks = false
 x_shift = 0
 y_shift = 0
 set_prefix = ''
-
+sole_format = nil
+reader_name = "ShakeScript"
 readers = Tracksperanto.importer_names
+writers = Tracksperanto.exporter_names
 
 parser = OptionParser.new do | p |
  p.banner = "Usage: tracksperanto -f ShakeScript -w 1920 -h 1080 /Films/Blockbuster/Shots/001/script.shk"
@@ -36,15 +38,9 @@ parser = OptionParser.new do | p |
  }
  p.on(" -f", "--from TRANSLATOR", String, 
    "Use the specific import translator (will try to autodetect, but can be #{Tracksperanto.importer_names.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.join(', ')}"
-     exit(-1)
-    end
+    reader_name = f
  end
- p.on(" -p", "--prefix PREFIX", String, "A prefix to prepend to tracker names in bluk") { |w| set_prefix = w }
+ 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 }
@@ -59,6 +55,9 @@ 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(" -o", "--only EXPORTER_NAME", String, "Only export the selected format, format must be one of #{writers.join(", ")}") {|f|
+     sole_format = 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("--version", "Show the version and exit") {|v| 
@@ -75,6 +74,13 @@ rescue OptionParser::MissingArgument => e
   exit(-1)
 end
 
+begin
+  reader_klass = Tracksperanto::Import.const_get(reader_name)
+rescue NameError => e
+  STDERR.puts "Unknown reader #{reader_name}, available readers: #{readers.join(', ')}"
+  exit(-1)
+end
+
 input_file = ARGV.pop
 if !input_file
   STDERR.puts "No input file provided - should be the last argument"
@@ -84,6 +90,15 @@ end
 
 pipe = Tracksperanto::Pipeline::Base.new
 pipe.progress_block = lambda{|percent, msg| STDOUT.write(".") }
+if sole_format
+  begin
+    pipe.exporters = [Tracksperanto::Export.const_get(sole_format)]
+  rescue NameError
+    STDERR.puts "Unknown exporter #{sole_format}. Available exporters: #{writers.join(", ")}"
+    exit(-1)
+  end
+end
+
 pipe.run(input_file, :pix_w => width, :pix_h => height, :parser => reader_klass) do | scaler, slipper, golden, reformat, shift, prefix |
   slipper.slip = slip
   scaler.x_factor = scale_x

data/lib/export/equalizer4.rb

@@ -31,7 +31,7 @@ class Tracksperanto::Export::Equalizer4 < Tracksperanto::Export::Base
     @internal_io.puts("0") # Color of the point, 0 is red
     @internal_io.puts(@num_of_kfs)
     @internal_io.puts(@tracker_buffer.read)
-    @tracker_buffer.close
+    @tracker_buffer.close!
   end
   
   def end_export

data/lib/import/boujou.rb

@@ -8,8 +8,7 @@ class Tracksperanto::Import::Boujou < Tracksperanto::Import::Base
     wrapped_io = Tracksperanto::ExtIO.new(io)
     detect_columns(wrapped_io)
     trackers = {}
-    extract_trackers(wrapped_io) do | k |
-      name, frame, x, y = k["track_id"], k["view"], k["x"], k["y"]
+    filtering_trackers_from(wrapped_io) do | name, frame, x, y |
       trackers[name] ||= Tracksperanto::Tracker.new(:name => name)
       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)
@@ -39,11 +38,12 @@ class Tracksperanto::Import::Boujou < Tracksperanto::Import::Base
   #
   # # track_id    view      x    y
   # Target_track_1  5  252.046  171.677
-  def extract_trackers(io)
+  def filtering_trackers_from(io)
     until io.eof?
       line = io.gets_and_strip
       next if comment?(line)
-      yield(make_column_hash(line))
+      column = make_column_hash(line)
+      yield(column["track_id"], column["view"], column["x"], column["y"])
     end
   end
   

data/lib/import/flame_stabilizer.rb

@@ -70,7 +70,9 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
   end
   
   def parse(io)
+    report_progress("Extracting setup size")
     self.width, self.height = extract_width_and_height_from_stream(io)
+    report_progress("Extracting all animation channels")
     channels = extract_channels_from_stream(io)
     
     raise "The setup contained no channels that we could process" if channels.empty?
@@ -140,6 +142,7 @@ Channel tracker1/ref/x
       until io.eof?
         line = io.gets
         if line =~ channel_matcher
+          report_progress("Extracting channel #{$1}")
           channels << extract_channel_from(io, $1)
         end
       end
@@ -155,6 +158,7 @@ Channel tracker1/ref/x
     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)
       end
       
@@ -174,6 +178,7 @@ Channel tracker1/ref/x
       track_tuples = zip_curve_tuples(track_x, track_y)
       
       base_x, base_y = begin
+        report_progress("Detecting base value")
         find_base_x_and_y(track_tuples, shift_tuples)
       rescue UseBase
         [track_x.base_value, track_y.base_value]

data/lib/import/nuke_script.rb

@@ -37,6 +37,7 @@ class Tracksperanto::Import::NukeScript < Tracksperanto::Import::Base
         elsif line =~ NODENAME
           tracks_in_tracker.each_with_index do | t, i |
             t.name = "#{$1}_track#{i+1}"
+            report_progress("Scavenging Tracker3 node #{t.name}")
           end
           return tracks_in_tracker
         end
@@ -50,21 +51,23 @@ class Tracksperanto::Import::NukeScript < Tracksperanto::Import::Base
       zip_curve_tuples(x_curve, y_curve)
     end
     
-    # Scan a curve to a number of triplets
+    SECTION_START = /^x(\d+)$/
+    KEYFRAME = /^([-\d\.]+)$/
+    
+    # Scan a curve to a number of tuples of [frame, value]
     def parse_curve(curve_text)
       # Replace the closing curly brace with a curly brace with space so that it gets caught by split
       atoms, tuples = curve_text.gsub(/\}/m, ' }').split, []
       # Nuke saves curves very efficiently. x(keyframe_number) means that an uninterrupted sequence of values will start,
       # after which values follow. When the curve is interrupted in some way a new x(keyframe_number) will signifu that we
       # skip to that specified keyframe and the curve continues from there
-      section_start = /^x(\d+)$/
-      keyframe = /^([-\d\.]+)$/
       
       last_processed_keyframe = 1
       while atom = atoms.shift
-        if atom =~ section_start
+        if atom =~ SECTION_START
           last_processed_keyframe = $1.to_i
-        elsif  atom =~ keyframe
+        elsif  atom =~ KEYFRAME
+          report_progress("Reading curve at frame #{last_processed_keyframe}")
           tuples << [last_processed_keyframe, $1.to_f]
           last_processed_keyframe += 1
         elsif atom == '}'

data/lib/import/pftrack.rb

@@ -36,7 +36,7 @@ class Tracksperanto::Import::PFTrack < Tracksperanto::Import::Base
       
       num_of_keyframes = first_tracker_line.to_i
       t.keyframes = (1..num_of_keyframes).map do | keyframe_idx |
-        report_progress("Reading keyframe #{keyframe_idx} of #{num_of_keyframes}")
+        report_progress("Reading keyframe #{keyframe_idx} of #{num_of_keyframes} in #{t.name}")
         Tracksperanto::Keyframe.new do |k| 
           k.frame, k.abs_x, k.abs_y, k.residual = io.gets.chomp.split
         end

data/lib/tracksperanto.rb

@@ -4,7 +4,7 @@ require 'tempfile'
 
 module Tracksperanto
   PATH = File.expand_path(File.dirname(__FILE__))
-  VERSION = '1.6.4'
+  VERSION = '1.6.5'
   
   module Import; end
   module Export; end

data/lib/tracksperanto/zip_tuples.rb

@@ -6,16 +6,16 @@ module Tracksperanto::ZipTuples
   #
   #    zip_curve_tuples( [[0, 12], [1, 23]], [[1, 12]]) #=> [[1, 23, 12]]
   #
+  # We make use of the fact that setting an offset index in an array fills it with nils up to
+  # the index inserted
   def zip_curve_tuples(*curves)
-    tuples = []
-    
-    curves.each do | curve |
-      curve.each do | keyframe |
-        frame, value = keyframe
-        tuples[frame] ? tuples[frame].push(value) : (tuples[frame] = [frame, value])
+    tuples = curves.inject([]) do | tuples, curve_of_at_and_value |
+      curve_of_at_and_value.each do | frame, value |
+       tuples[frame] = tuples[frame] ? (tuples[frame] << value) : [frame, value]
       end
+      tuples
     end
-
-    tuples.compact.reject{|e| e.length < (curves.length + 1) }
+    
+    tuples.reject{|e| e.nil? || (e.length < (curves.length + 1)) }
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tracksperanto
 version: !ruby/object:Gem::Version 
-  version: 1.6.4
+  version: 1.6.5
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-26 00:00:00 +01:00
+date: 2009-11-28 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency