tracksperanto 1.1.1 → 1.2.0

data/lib/import/base.rb

@@ -1,34 +1,67 @@
-require 'stringio'
-
+# The base class for all the import modules. By default, when you inherit from this class the inherited class will be included
+# in the list of supported Tracksperanto importers. The API that an importer should present is very basic, and consists only of a few methods.
+# The main method is parse(io) which should return an array of Tracker objects.
 class Tracksperanto::Import::Base
   include Tracksperanto::Safety
   include Tracksperanto::Casts
+  include Tracksperanto::BlockInit
+  include Tracksperanto::ZipTuples
   
+  # 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
+  # yourself)
   attr_accessor :progress_block
   
-  # The original width of the tracked image
-  # Some importers need it
-  cast_to_int :width
+  # The original width of the tracked image.
+  # If you need to know the width for your specific format and cannot autodetect it,
+  # Trakcksperanto will assign the passed width and height to the importer object before running
+  # the import. If not, you can replace the assigned values with your own. At the end of the import
+  # procedure, Tracksperanto will read the values from you again and will use the read values
+  # for determining the original comp size. +width+ and +height+ MUST return integer values after
+  # the import completes
+  attr_accessor :width
   
-  # The original height of the original image.
-  # Some importers need it
-  cast_to_int :height
+  # The original height of the comp, same conventions as for width apply
+  attr_accessor :height
   
-  # Safety on readers
+  # These reader methods will raise when the values are nil
+  cast_to_int :width, :height
   safe_reader :width, :height
   
+  # Used to register your importer in the list of supported formats
   def self.inherited(by)
     Tracksperanto.importers << by
     super
   end
   
-  # Call this method to tell what you are doing. This gets propagated to the caller
+  # Return an extension WITH DOT if this format has a typical extension that
+  # you can detect 
+  def self.distinct_file_ext
+    nil
+  end
+  
+  # Should return a human-readable (read: properly capitalized and with spaces) name of the
+  # import format
+  def self.human_name
+    "Abstract import format"
+  end
+  
+  # Return true from this method if your importer can deduce the comp size from the passed file
+  def self.autodetects_size?
+    false
+  end
+  
+  # Call this method to tell what you are doing. This gets propagated to the caller automatically, or
+  # gets ignored if the caller did not request any progress reports
   def report_progress(message)
     @progress_block.call(message) if @progress_block
   end
   
-  # Should return an array of Tracksperanto::Tracker objects
-  def parse(track_file_content)
+  # 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.
+  def parse(track_file_io)
     []
   end
 end

data/lib/import/flame_stabilizer.rb

@@ -1,12 +1,17 @@
-require 'stringio'
 
 class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
   
-  class Kf
-    include ::Tracksperanto::Casts
-    include ::Tracksperanto::BlockInit
-    cast_to_int :frame
-    cast_to_float :value
+  # Flame setups contain clear size indications
+  def self.autodetects_size?
+    true
+  end
+  
+  def self.distinct_file_ext
+    ".stabilizer"
+  end
+  
+  def self.human_name
+    "Flame .stabilizer file"
   end
   
   T = ::Tracksperanto::Tracker
@@ -56,7 +61,7 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
           frame = $1.to_i
         elsif line =~ value_matcher
           value = $1.to_f
-          return Kf.new(:frame => frame, :value => value)
+          return [frame,value]
         end
       end
       
@@ -64,17 +69,14 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
     end
   end
   
-  def parse(stabilizer_setup_content)
-    
-    io = StringIO.new(stabilizer_setup_content)
-    
+  def parse(io)
     self.width, self.height = extract_width_and_height_from_stream(io)
     channels = extract_channels_from_stream(io)
     
     raise "The setup contained no channels that we could process" if channels.empty?
     raise "A channel was nil" if channels.find{|e| e.nil? }
     
-    trackers = scavenge_trackers_from_channels(channels)
+    scavenge_trackers_from_channels(channels)
   end
   
   private
@@ -97,7 +99,7 @@ class Tracksperanto::Import::FlameStabilizer < Tracksperanto::Import::Base
       
     end
 =begin
-  Here's how a Flame channel looks like
+Here's how a Flame channel looks like
 The Size will not be present if there are no keyframes
   
 Channel tracker1/ref/x
@@ -132,7 +134,6 @@ Channel tracker1/ref/x
 	Colour 50 50 50 
 	End
 =end
-    
     def extract_channels_from_stream(io)
       channels = []
       channel_matcher = /Channel (.+)\n/
@@ -169,8 +170,8 @@ Channel tracker1/ref/x
       shift_x = channels.find{|e| e.name == "#{t.name}/shift/x" }
       shift_y = channels.find{|e| e.name == "#{t.name}/shift/y" }
       
-      shift_tuples = zip_channels(shift_x, shift_y)
-      track_tuples = zip_channels(track_x, track_y)
+      shift_tuples = zip_curve_tuples(shift_x, shift_y)
+      track_tuples = zip_curve_tuples(track_x, track_y)
       
       base_x, base_y = begin
         find_base_x_and_y(track_tuples, shift_tuples)
@@ -205,20 +206,4 @@ Channel tracker1/ref/x
         raise UseBase
       end
     end
-    
-    # Zip two channel objects to tuples of [frame, valuex, valuey] 
-    # skipping keyframes that do not match in the two
-    def zip_channels(a, b)
-      tuples = []
-    
-      a.each do | keyframe |
-        tuples[keyframe.frame] = [keyframe.frame, keyframe.value]
-      end
-    
-      b.each do | keyframe |
-        tuples[keyframe.frame] = (tuples[keyframe.frame] << keyframe.value) if tuples[keyframe.frame]
-      end
-    
-      tuples.compact
-    end
 end

data/lib/import/match_mover.rb

@@ -0,0 +1,65 @@
+class Tracksperanto::Import::MatchMover < Tracksperanto::Import::Base
+  
+  def self.autodetects_size?
+    true
+  end
+  
+  def self.human_name
+    "MatchMover .rz2 file"
+  end
+  
+  def self.distinct_file_ext
+    ".rz2"
+  end
+  
+  def parse(io)
+    trackers = []
+    detect_format(io)
+    extract_trackers(io)
+  end
+  
+  private
+  
+  def detect_format(io)
+    lines = (0..2).map{ io.gets }
+    last_line = lines[-1]
+    w, h, _ = last_line.scan(/(\d+)/).flatten
+    @width, @height = w.to_i, h.to_i
+  end
+  
+  def extract_trackers(io)
+    tracks = []
+    while(line = io.gets) do
+      tracks << extract_track(line, io) if line =~ /^pointTrack/
+    end
+    tracks
+  end
+  
+  def extract_track(start_line, io)
+    tracker_name = start_line.scan(/\"([^\"]+)\"/).to_s
+    t = Tracksperanto::Tracker.new(:name => tracker_name)
+    while(line = io.gets) do
+      return t if line =~ /\}/
+      t.keyframes.push(extract_key(line.strip)) if line =~ /^(\s+?)(\d)/
+    end
+    raise "Track didn't close"
+  end
+  
+  LINE_PATTERN = /(\d+)(\s+)([\-\d\.]+)(\s+)([\-\d\.]+)(\s+)(.+)/
+  
+  def extract_key(line)
+    frame, x, y, residual, rest = line.scan(LINE_PATTERN).flatten.reject{|e| e.strip.empty? }
+    Tracksperanto::Keyframe.new(
+      :frame => (frame.to_i() - 1),
+      :abs_x => x,
+      :abs_y => y,
+      :residual => extract_residual(residual)
+    )
+  end
+  
+  def extract_residual(residual_segment)
+    # Parse to the first opening brace and pick the residual from there
+    float_pat = /([\-\d\.]+)/
+    1 - residual_segment.scan(float_pat).flatten.shift.to_f
+  end
+end

data/lib/import/nuke_script.rb

@@ -0,0 +1,96 @@
+require 'delegate'
+
+class Tracksperanto::Import::NukeScript < Tracksperanto::Import::Base
+  
+  def self.human_name
+    "Nuke .nk script file"
+  end
+  
+  def self.distinct_file_ext
+    ".nk"
+  end
+  
+  # Nuke files are extensively indented and indentation is significant.
+  # We use this to always strip the lines we process since we capture before
+  # indentation becomes crucial
+  class IOC < DelegateClass(IO)
+    def initialize(h)
+      __setobj__(h)
+    end
+    
+    def gets_and_strip
+      s = __getobj__.gets
+      s ? s.strip : nil
+    end
+    
+  end
+  
+  def parse(io)
+    scan_for_tracker3_nodes(IOC.new(io))
+  end
+  
+  private
+    
+    TRACKER_3_PATTERN = /^Tracker3 \{/
+    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 = []
+      while line = io.gets_and_strip
+        if line =~ TRACK_PATTERN
+          tuples = scan_track(line)
+          tk = Tracksperanto::Tracker.new(
+            :keyframes => tuples.map do | (f, x, y) | 
+              Tracksperanto::Keyframe.new(:frame => f -1, :abs_x => x, :abs_y => y) 
+            end
+          )
+          tracks_in_tracker.push(tk)
+        elsif line =~ NODENAME
+          tracks_in_tracker.each_with_index do | t, i |
+            t.name = "#{$1}_track#{i+1}"
+          end
+          return tracks_in_tracker
+        end
+      end
+      raise "Tracker node went all the way to end of stream"
+    end
+    
+    def scan_track(line_with_curve)
+      x_curve, y_curve = line_with_curve.split(/\}/).map{ | one_curve| parse_curve(one_curve) }
+      zip_curve_tuples(x_curve, y_curve)
+    end
+    
+    # Scan a curve to a number of triplets
+    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(/\}/, ' }').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
+          last_processed_keyframe = $1.to_i
+        elsif  atom =~ keyframe
+          tuples << [last_processed_keyframe, $1.to_f]
+          last_processed_keyframe += 1
+        elsif atom == '}'
+          return tuples
+        end
+      end
+      tuples
+    end
+    
+end

data/lib/import/pftrack.rb

@@ -1,7 +1,14 @@
 class Tracksperanto::Import::PFTrack < Tracksperanto::Import::Base
-  def parse(file_content)
+  def self.human_name
+    "PFTrack .2dt file"
+  end
+  
+  def self.distinct_file_ext
+    ".2dt"
+  end
+  
+  def parse(io)
     trackers = []
-    io = StringIO.new(file_content)
     until io.eof?
       line = io.gets
       next unless line

data/lib/import/shake_grammar/catcher.rb

@@ -0,0 +1,56 @@
+module Tracksperanto::ShakeGrammar
+  # Will replay funcalls through to methods if such methods exist in the public insntance
+  class Catcher < Lexer
+  
+    def push(atom_array)
+      atom_name = atom_array[0]
+      if atom_name == :funcall
+        func, funcargs = atom_array[1], atom_array[2..-1]
+        meth_for_shake_func = func.downcase
+        if can_handle_meth?(meth_for_shake_func)
+          super([:retval, exec_funcall(meth_for_shake_func, funcargs)])
+        else
+          # This is a funcall we cannot perform, replace the return result of the funcall
+          # with a token to signify that some unknown function's result would have been here
+          super(:unknown_func)
+        end
+      elsif atom_name == :comment
+        # Skip comments
+      else
+        super
+      end
+    end
+    
+    private
+    
+    def get_variable_name
+      @stack[-2][1]
+    end
+    
+    def can_handle_meth?(m)
+      self.class.public_instance_methods(false).include?(m)
+    end
+    
+    def exec_funcall(methname, args)
+      ruby_args = unwrap_atoms_in_args(args)
+      send(methname, *ruby_args)
+    end
+    
+    def unwrap_atoms_in_args(args)
+      args.map do | arg |
+        (arg.is_a?(Array) && arg[0].is_a?(Symbol)) ? unwrap_atom(arg) : arg
+      end
+    end
+    
+    def unwrap_atom(atom)
+      kind = atom.shift
+      case kind
+        when :retval, :atom_i, :atom_c, :atom_f
+          atom.shift
+        else
+          :unknown
+      end
+    end
+
+  end
+end

data/lib/import/shake_grammar/lexer.rb

@@ -0,0 +1,95 @@
+module Tracksperanto::ShakeGrammar
+  # Since Shake uses a C-like language for it's scripts we rig up a very sloppy
+  # but concise C-like lexer to cope
+  class Lexer
+    
+    attr_reader :stack
+    
+    def initialize(with_io)
+      @io, @stack, @buf  = with_io, [], ''
+      parse until (@io.eof? || @stop)
+      in_comment? ? consume_comment("\n") : consume_atom!
+    end
+    
+    private
+    
+    def in_comment?
+      (@buf.strip =~ /^\/\//) ? true : false
+    end
+    
+    def consume_comment(c)
+      if c == "\n" # Comment
+        push [:comment, @buf.gsub(/(\s+?)\/\/{1}/, '')]
+        @buf = ''
+      else
+        @buf << c
+      end
+    end
+    
+    def parse
+      c = @io.read(1)
+      return consume_comment(c) if in_comment? 
+      
+      if !@buf.empty? && (c == "(") # Funcall
+        push([:funcall, @buf.strip] + self.class.new(@io).stack)
+        @buf = ''
+      elsif c == "[" # Array, booring
+        push([:arr] + self.class.new(@io).stack)
+      elsif (c == "]" || c == ")")
+        # Funcall end, and when it happens assume we are called as
+        # a subexpression.
+        consume_atom!
+        @stop = true
+      elsif (c == ",")
+        consume_atom!
+      elsif (c == ";" || c == "\n")
+        # Skip these - the subexpression already is expanded anyway
+      elsif (c == "=")
+        push [:var, @buf.strip]
+        push [:eq]
+        @buf = ''
+      else
+        @buf << c
+      end
+    end
+    
+    INT_ATOM = /^(\d+)$/
+    FLOAT_ATOM = /^([\-\d\.]+)$/
+    STR_ATOM = /^\"/
+    AT_ATOM = /^([\-\d\.]+)@([\-\d\.]+)$/
+    AT_CONSUMED = /^@(\d+)/
+    VAR_ASSIGN = /^([\w_]+)(\s+?)\=(\s+?)(.+)/
+    
+    # Grab the minimum atomic value
+    def consume_atom!
+      at, @buf = @buf.strip, ''
+      return if at.empty?
+      
+      the_atom = case at
+        when INT_ATOM
+          [:atom_i, at.to_i]
+        when STR_ATOM
+          [:atom_c, unquote_s(at)]
+        when FLOAT_ATOM
+          [:atom_f, at.to_f]
+        when AT_ATOM
+          v, f = at.strip.split("@")
+          [[:atom_f, v.to_f], [:atom_at_i, f.to_i]]
+        when AT_CONSUMED
+          [:atom_at_i, $1.to_i]
+        else
+          [:atom, at]
+      end
+      
+      push(the_atom)
+    end
+    
+    def unquote_s(string)
+      string.strip.gsub(/^\"/, '').gsub(/\"$/, '').gsub(/\\\"/, '"')
+    end
+    
+    def push(atom_array)
+      @stack << atom_array
+    end
+  end
+end