tracksperanto 1.0.0

data/lib/import/shake_script.rb

@@ -0,0 +1,127 @@
+require 'strscan'
+
+class Tracksperanto::Import::ShakeScript < Tracksperanto::Import::Base
+  
+  # Allow literal strings instead of Regexps
+  class SloppyParser < StringScanner
+    def skip_until(pattern)
+      pattern.is_a?(String) ? super(/#{Regexp.escape(pattern)}/m) : super(pattern)
+    end
+
+    def scan_until(pattern)
+      pattern.is_a?(String) ? super(/#{Regexp.escape(pattern)}/m) : super(pattern)
+    end
+  end
+
+  class ValueAt
+    attr_accessor :value, :frame
+    def self.from_string(str)
+      v = new
+      val_s, frame_s = str.scan(/(.+)@(\d+)/).to_a.flatten
+      v.value, v.frame = val_s.to_f, frame_s.to_i
+      v
+    end
+  end
+
+  class CurveParser < SloppyParser
+    BLOCK_ENDS = /\d,|\)/
+    
+    attr_reader :values
+    def initialize(with_curve_arg)
+      @values = []
+      
+      super(with_curve_arg.to_s)
+      
+      # Skip the interpolation name, we assume it to be linear anyway
+      skip_until '('
+      
+      # Skip the first defining parameter whatever that might be
+      skip_until ','
+      
+      loop do
+        break unless (value_at = scan_until(BLOCK_ENDS))
+        # Grab the value
+        val = ValueAt.from_string(value_at)
+        
+        @values << val
+      end
+    end
+
+  end
+  
+  class TrackerParser < SloppyParser
+    attr_reader :x_curve, :y_curve, :c_curve, :name
+    
+    def initialize(with_tracker_args)
+      super(with_tracker_args)
+
+      # Name me!
+      @name = scan_until(/(\w+) /).strip
+
+      # All the tracker arguments
+      17.times { skip_until ',' } # input data
+      
+      # Grab the curves
+      @x_curve, @y_curve, @c_curve = (0..2).map{ CurveParser.new(scan_until('),')).values }
+      
+      # if the next argument is an integer, we reached the end of the tracks. If not - make a nested one.
+    end
+    
+    def curves
+      [@x_curve, @y_curve, @c_curve]
+    end
+  end
+  
+  class TrackParser < SloppyParser
+    def initialize(with_tracker_block)
+      # scan until the first " - name of the track
+      skip_until  ','
+      # scan values
+      # discard the 8 box determinators
+      7.times { skip_until  ',' }
+      # discard the box animation
+      2.times { skip_until  ',' }
+    end
+  end
+  
+  TRACKER_PATTERN = /((\w+) = Tracker\(([^;]+))/m
+  
+  def parse(sript_file_content)
+    
+    trackers = []
+    
+    sript_file_content.scan(TRACKER_PATTERN).each_with_index do | tracker_text_block, idx |
+      
+      parser = TrackerParser.new(tracker_text_block.to_s)
+      
+      tracker = Tracksperanto::Tracker.new{|t| t.name = parser.name }
+      
+      x_keyframes, y_keyframes, residual_keyframes = TrackerParser.new(tracker_text_block.to_s).curves
+      x_keyframes.each_with_index do | value_at, kf_index |
+        
+        # Find the Y keyframe with the same frame
+        matching_y = y_keyframes.find{|f| f.frame == value_at.frame }
+        
+        # Find the correlation keyframe with the same frame
+        matching_residual = residual_keyframes.find{|f| f.frame == value_at.frame }
+        
+        # Skip frame if only one keyframe is present
+        if !matching_y
+          STDERR.puts "Cannot find matching Y for frame #{value_at.frame} in tracker #{parser.name}, skipping keyframe"
+          next
+        end
+        
+        tracker.keyframes << Tracksperanto::Keyframe.new do |k|
+          k.frame = (value_at.frame - 1)
+          k.abs_x = value_at.value
+          k.abs_y = matching_y.value
+          k.residual = 1 - (matching_residual.value rescue 1.0)
+        end
+      end
+      
+      trackers << tracker
+    end
+    
+    trackers
+  end
+end

data/lib/import/shake_text.rb

@@ -0,0 +1,29 @@
+require 'stringio'
+
+class Tracksperanto::Import::ShakeText < Tracksperanto::Import::Base
+  
+  def parse(track_file_content)
+    trackers = []
+    io = StringIO.new(track_file_content)
+    until io.eof?
+      line = io.gets
+      if line =~ /TrackName (.+)/
+        trackers << 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 |
+          kf.frame = (keyframe_values[0].to_i - 1)
+          kf.abs_x = keyframe_values[1]
+          kf.abs_y = keyframe_values[2]
+          kf.residual = (1 - keyframe_values[3].to_f)
+        end
+      end
+    end
+    
+    trackers
+  end
+end

data/lib/import/syntheyes.rb

@@ -0,0 +1,32 @@
+class Tracksperanto::Import::Syntheyes < Tracksperanto::Import::Base
+  def parse(file_content)
+    trackers = []
+    file_content.split("\n").each do | line |
+      name, frame, x, y, corr = line.split
+      
+      # Do we already have this tracker?
+      t = trackers.find {|e| e.name == name}
+      if !t
+        t = Tracksperanto::Tracker.new{|t| t.name = name }
+        trackers << t
+      end
+      
+      # Add the keyframe
+      t.keyframes << 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
+        e.residual = corr
+      end
+    end
+    
+    trackers
+  end
+  
+  private
+    def convert_from_uv(absolute_side, uv_value)
+      # First, start from zero (-.1 becomes .4)
+      value_off_corner = (uv_value.to_f / 2) + 0.5
+      absolute_side * value_off_corner
+    end
+end

data/lib/middleware/base.rb

@@ -0,0 +1,28 @@
+class Tracksperanto::Middleware::Base
+  include Tracksperanto::Casts
+  
+  def initialize(exporter)
+    @exporter = exporter
+  end
+  
+  # Called on export start
+  def start_export( img_width, img_height)
+    @exporter.start_export(img_width, img_height)
+  end
+  
+  # Called on export end
+  def end_export
+    @exporter.end_export
+  end
+  
+  # Called on tracker start, one for each tracker. Start of the next tracker
+  # signifies that the previous tracker has passed by
+  def start_tracker_segment(tracker_name)
+    @exporter.start_tracker_segment(tracker_name)
+  end
+  
+  # Called for each tracker keyframe
+  def export_point(at_frame_i, abs_float_x, abs_float_y, float_residual)
+    @exporter.export_point(at_frame_i, abs_float_x, abs_float_y, float_residual)
+  end
+end

data/lib/middleware/scaler.rb

@@ -0,0 +1,24 @@
+class Tracksperanto::Middleware::Scaler < Tracksperanto::Middleware::Base
+  DEFAULT_FACTOR = 1
+  
+  attr_accessor :x_factor, :y_factor
+  
+  # Called on export start
+  def start_export( img_width, img_height)
+    # Compute the average factor
+    @residual_factor = (x_factor + y_factor) / 2
+    super( (img_width * x_factor), (img_height * y_factor))
+  end
+  
+  def y_factor
+    @y_factor || DEFAULT_FACTOR
+  end
+  
+  def x_factor
+    @x_factor || DEFAULT_FACTOR
+  end
+  
+  def export_point(frame, float_x, float_y, float_residual)
+    super(frame, (float_x * x_factor), (float_y * y_factor), (float_residual * @residual_factor))
+  end
+end

data/lib/middleware/slipper.rb

@@ -0,0 +1,12 @@
+class Tracksperanto::Middleware::Slipper < Tracksperanto::Middleware::Base
+  DEFAULT_SLIP = 0
+  attr_accessor :slip
+  
+  def slip
+    @slip.to_i || DEFAULT_SLIP
+  end
+  
+  def export_point(frame, float_x, float_y, float_residual)
+    super(frame + slip, float_x, float_y, float_residual)
+  end
+end

data/lib/pipeline.rb

@@ -0,0 +1,54 @@
+class Tracksperanto::Pipeline
+  attr_accessor :converted_points
+  attr_accessor :converted_keyframes
+  def run(from_input_file, pix_w, pix_h, parser_class)
+    # Read the input file
+    read_data = File.read(from_input_file)
+    file_name = File.basename(from_input_file).gsub(/\.([^\.]+)$/, '')
+    
+    # Assign the parser
+    parser = parser_class.new
+    parser.width = pix_w
+    parser.height = pix_h
+    
+    # Setup a multiplexer
+    mux = Tracksperanto::Export::Mux.new(
+      Tracksperanto.exporters.map do | exporter_class |
+        export_name = "%s_%s" % [file_name, exporter_class.desc_and_extension]
+        outfile = File.dirname(from_input_file) + '/' + export_name
+        io = File.open(outfile, 'w')
+        exporter_class.new(io)
+      end
+    )
+    
+    # Setup middlewares - skip for now
+    scaler = Tracksperanto::Middleware::Scaler.new(mux)
+    slipper = Tracksperanto::Middleware::Slipper.new(scaler)
+    golden = Tracksperanto::Middleware::Golden.new(slipper)
+    
+    yield(scaler, slipper, golden) if block_given?
+    
+    processor = golden
+    
+    # Run the export
+    trackers = parser.parse(read_data)
+    processor.start_export(parser.width, parser.height)
+    trackers.each do | t |
+      
+      @converted_points ||= 0
+      @converted_points += 1
+      
+      processor.start_tracker_segment(t.name)
+      t.keyframes.each do | kf |
+        
+        @converted_keyframes ||= 0
+        @converted_keyframes += 1
+        
+        processor.export_point(kf.frame, kf.abs_x, kf.abs_y, kf.residual)
+      end
+    end
+    
+    processor.end_export
+  end
+end
+  

data/lib/tracksperanto.rb

@@ -0,0 +1,131 @@
+module Tracksperanto
+  VERSION = '1.0.0'
+  
+  module Import; end
+  module Export; end
+  module Middleware; end
+  
+  class << self
+    # Returns the array of all exporter classes defined
+    attr_accessor :exporters
+
+    # Returns the array of all importer classes defined
+    attr_accessor :importers
+
+    # Returns the array of all available middlewares
+    attr_accessor :middlewares
+  end
+  self.exporters, self.importers, self.middlewares = [], [], []
+  
+  # Helps to define things that will forcibly become floats, integers or strings
+  module Casts
+    def self.included(into)
+      into.extend(self)
+      super
+    end
+    
+    # Same as attr_accessor but will always convert to Float internally
+    def cast_to_float(*attributes)
+      attributes.each do | an_attr |
+        define_method(an_attr) { instance_variable_get("@#{an_attr}").to_f }
+        define_method("#{an_attr}=") { |to| instance_variable_set("@#{an_attr}", to.to_f) }
+      end
+    end
+    
+    # Same as attr_accessor but will always convert to Integer/Bignum internally
+    def cast_to_int(*attributes)
+      attributes.each do | an_attr |
+        define_method(an_attr) { instance_variable_get("@#{an_attr}").to_i }
+        define_method("#{an_attr}=") { |to| instance_variable_set("@#{an_attr}", to.to_i) }
+      end
+    end
+    
+    # Same as attr_accessor but will always convert to String internally
+    def cast_to_string(*attributes)
+      attributes.each do | an_attr |
+        define_method(an_attr) { instance_variable_get("@#{an_attr}").to_s }
+        define_method("#{an_attr}=") { |to| instance_variable_set("@#{an_attr}", to.to_s) }
+      end
+    end
+  end
+  
+  module Safety
+    def self.included(into)
+      into.extend(self)
+      super
+    end
+    
+    # Inject a reader that checks for nil
+    def safe_reader(*attributes)
+      attributes.each do | an_attr |
+        alias_method "#{an_attr}_without_nil_protection", an_attr
+        define_method(an_attr) do
+          val = send("#{an_attr}_without_nil_protection")
+          raise "Expected #{an_attr} on #{self} not to be nil" if val.nil?
+          val
+        end
+      end
+    end
+  end
+  
+  module BlockInit
+    def initialize
+      yield(self) if block_given?
+    end
+  end
+  
+  # Internal representation of a tracker
+  class Tracker
+    include Casts
+    include BlockInit
+
+    # Contains the array of all Keyframe objects for this tracker
+    attr_accessor :name
+    
+    # Contains the array of all Keyframe objects for this tracker
+    attr_accessor :keyframes
+    
+    cast_to_string :name
+    
+    def initialize
+      @name, @keyframes = 'Tracker', []
+      super if block_given?
+    end
+  end
+  
+  # Internal representation of a keyframe
+  class Keyframe
+    include Casts
+    include BlockInit
+    
+    # Absolute integer frame where this keyframe is placed, 0 based
+    attr_accessor :frame
+    
+    # Absolute float X value of the point, zero is lower left
+    attr_accessor :abs_x
+    
+    # Absolute float Y value of the point, zero is lower left
+    attr_accessor :abs_y
+    
+    # Absolute float residual (0 is "spot on")
+    attr_accessor :residual
+    
+    cast_to_float :abs_x, :abs_y, :residual
+    cast_to_int :frame
+  end
+end
+
+# Load importers
+Dir.glob(File.dirname(__FILE__) + '/import/*.rb').each do | i |
+  require i
+end
+
+# Load exporters
+Dir.glob(File.dirname(__FILE__) + '/export/*.rb').each do | i |
+  require i
+end
+
+# Load middleware
+Dir.glob(File.dirname(__FILE__) + '/middleware/*.rb').each do | i |
+  require i
+end