tracksperanto 3.3.13 → 3.4.0

data/History.txt

@@ -1,3 +1,7 @@
+=== 3.4.0
+
+* Add specific Flame/Smoke exporters for IFFS 2014 and above, including updated cornerpin order
+
 === 3.3.13
 
 * Fix the bug in Shake script imports where the import would fail if animation curves contained a non-numeric value

data/README.md

@@ -119,6 +119,8 @@ If you want your own copy of the web application at your facility we can discuss
 * Autodesk Softimage nulls Python script
 * Bare Ruby code
 * Flame/Smoke 2D Stabilizer setup
+* Flame/Smoke 2D Stabilizer setup (v. 2014 and above)
+* Flame/Smoke 2D Stabilizer setup (v. 2014 and above) for corner pins
 * Flame/Smoke 2D Stabilizer setup for bilinear corner pins
 * MatchMover REALVIZ Ascii Point Tracks .rz2 file
 * Maya ASCII scene with locators on an image plane

data/lib/export/flame_stabilizer_2014.rb

@@ -0,0 +1,259 @@
+# -*- encoding : utf-8 -*-
+class Tracksperanto::Export::FlameStabilizer2014 < Tracksperanto::Export::Base
+  
+  COLOR = "50 50 50"
+  DATETIME_FORMAT = '%a %b %d %H:%M:%S %Y'
+  
+  def self.desc_and_extension
+    "flamesmoke2014.stabilizer"
+  end
+  
+  def self.human_name
+    "Flame/Smoke 2D Stabilizer setup (v. 2014 and above)"
+  end
+  
+  def start_export( img_width, img_height)
+    @counter = 0
+    @first_ref_frames = []
+    @width, @height = img_width, img_height
+    @temp = Tracksperanto::BufferIO.new
+    @writer = FlameChannelParser::Builder.new(@temp)
+  end
+  
+  def end_export
+    # Now make another writer, this time for our main IO
+    @writer = FlameChannelParser::Builder.new(@io)
+    
+    # Now we know how many trackers we have so we can write the header
+    # data along with NbTrackers
+    write_header_with_number_of_trackers(@counter)
+    
+    # Now write everything that we accumulated earlier into the base IO
+    @temp.rewind
+    @io.write(@temp.read) until @temp.eof?
+    @temp.close!
+    
+    # Send the ChannelEnd command and list the trackers
+    @writer.channel_end
+    @first_ref_frames.each_with_index do | ref_frame, i|
+      @writer.write_unterminated_block!("tracker", i) do |t|
+        t.active true
+        t.color_hash!("colour", 0, 100, 0)
+        t.fixed_ref true
+        t.fixed_x false
+        t.fixed_y false
+        t.tolerance 100
+        t.offsets_x 0
+        t.offsets_y 0
+        t.first_ref_frame ref_frame
+      end
+    end
+    
+    # Write the finalizing "End"
+    @writer.write_loose!("end")
+  end
+  
+  def start_tracker_segment(tracker_name)
+    @counter += 1
+    @write_first_frame = true
+  end
+  
+  def export_point(frame, abs_float_x, abs_float_y, float_residual)
+    flame_frame = frame + 1
+    if @write_first_frame
+      export_first_point(flame_frame, abs_float_x, abs_float_y)
+      # Record the first ref frame for this tracker
+      @first_ref_frames << flame_frame
+      @write_first_frame = false
+    else
+      export_remaining_point(flame_frame, abs_float_x, abs_float_y)
+    end
+  end
+  
+  def end_tracker_segment
+    # We write these at tracker end since we need to know in advance
+    # how many keyframes they should contain
+    write_shift_channel("shift/x", @x_shift_values)
+    write_shift_channel("shift/y", @y_shift_values)
+    
+    # And finish with the offset channels. The order of channels is important!
+    # (otherwise the last tracker's shift animation is not imported by Flame)
+    # https://github.com/guerilla-di/tracksperanto/issues/1
+    write_offset_channels
+  end
+  
+  private
+  
+  def export_remaining_point(flame_frame, abs_float_x, abs_float_y)
+    # Just continue buffering the upcoming shift keyframes and flush them in the end
+    shift_x, shift_y = @base_x - abs_float_x, @base_y - abs_float_y
+    @x_shift_values.push([flame_frame, shift_x])
+    @y_shift_values.push([flame_frame, shift_y])
+  end
+  
+  def export_first_point(flame_frame, abs_float_x, abs_float_y)
+    @base_x, @base_y = abs_float_x, abs_float_y
+    write_first_frame(abs_float_x, abs_float_y)
+    # For Flame to recognize the reference frame of the Shift channel
+    # we need it to contain zero as an int, not as a float. The shift proceeds
+    # from there.
+    @x_shift_values = [[flame_frame, 0]]
+    @y_shift_values = [[flame_frame, 0]]
+  end
+  
+  # The shift channel is what determines how the tracking point moves.
+  def write_shift_channel(name_without_prefix, values)
+    @writer.channel(prefix(name_without_prefix)) do | c |
+      c.extrapolation :constant
+      c.value values[0][1]
+      c.key_version 1
+      c.size values.length
+      values.each_with_index do | (f, v), i |
+        c.key(i) do | k |
+          k.frame f
+          k.value v
+          # Omit:
+          # RHandle_dX 0.333333343
+          # RHandle_dY -5.7284646
+          # LHandle_dX -0.333333343
+          # LHandle_dY 5.7284646
+          k.curve_mode :hermite
+          k.curve_order :linear
+        end
+      end
+    end
+  end
+  
+  def prefix(tracker_channel)
+    "tracker%d/%s" % [@counter, tracker_channel]
+  end
+  
+  def write_header_with_number_of_trackers(number_of_trackers)
+    @writer.stabilizer_file_version "6.0"
+    @writer.creation_date(Time.now.strftime(DATETIME_FORMAT))
+    @writer.linebreak!(2)
+    
+    @writer.nb_trackers number_of_trackers
+    @writer.selected 0
+    @writer.frame_width @width
+    @writer.frame_height @height
+    @writer.auto_key true
+    @writer.motion_path true
+    @writer.icons true
+    @writer.auto_pan false # hate it!
+    @writer.edit_mode 0
+    @writer.format 0
+    @writer.color_hash!("padding", 0, 100, 0)
+    @writer.oversampling false
+    @writer.opacity 50
+    @writer.zoom 3
+    @writer.field false
+    @writer.backward false
+    @writer.anim
+  end
+  
+  def write_first_frame(x, y)
+    write_track_channels
+    write_track_width_and_height
+    write_ref_width_and_height
+    write_ref_channels(x, y)
+    write_deltax_and_deltay_channels
+  end
+  
+  def write_track_channels
+    ctr_x, ctr_y = @width / 2, @height / 2
+    
+    # track determines where the tracking box is, and should be in the center
+    # of the image for Flame to compute all other shifts properly
+    %w( track/x track/y).map(&method(:prefix)).zip([ctr_x, ctr_y]).each do | cname, default |
+      @writer.channel(cname) do | c |
+        c.extrapolation("constant")
+        c.value(default.to_i)
+        c.colour(COLOR)
+      end
+    end
+  end
+
+  # The size of the tracking area
+  def write_track_width_and_height
+    %w( track/width track/height ).map(&method(:prefix)).each do | channel_name |
+      @writer.channel(channel_name) do | c |
+        c.extrapolation :linear
+        c.value 15
+        c.colour COLOR
+      end
+    end
+  end
+  
+  # The size of the reference area
+  def write_ref_width_and_height
+    %w( ref/width ref/height).map(&method(:prefix)).each do | channel_name |
+      @writer.channel(channel_name) do | c |
+        c.extrapolation :linear
+        c.value 10
+        c.colour COLOR
+      end
+    end
+  end
+
+  # The Ref channel contains the reference for the shift channel in absolute
+  # coordinates, and is set as float. Since we do not "snap" the tracker in
+  # the process it's enough for us to make one keyframe in the ref channels
+  # at the same frame as the first shift keyframe
+  def write_ref_channels(ref_x, ref_y)
+    %w( ref/x ref/y).map(&method(:prefix)).zip([ref_x, ref_y]).each do | cname, default |
+      @writer.channel(cname) do | c |
+        c.extrapolation("constant")
+        c.value(default)
+        c.colour(COLOR)
+        c.key_version 1
+        c.size 1
+        c.key(0) do | k |
+          k.frame 1
+          k.value default
+          k.interpolation :constant
+          k.left_slope 2.4
+          k.right_slope 2.4
+        end
+      end
+    end
+  end
+  
+  def write_deltax_and_deltay_channels
+    # This is used for deltax and deltay (offset tracking).
+    # We set it to zero and lock
+    %w( ref/dx ref/dy).map(&method(:prefix)).each do | chan, v |
+      @writer.channel(chan) do | c |
+        c.extrapolation("constant")
+        c.value 0
+        c.colour(COLOR)
+        c.size 2
+        c.key_version 1
+        c.key(0) do | k |
+          k.frame 0
+          k.value 0
+          k.value_lock true
+          k.delete_lock true
+          k.interpolation :constant
+        end
+        c.key(1) do | k |
+          k.frame 1
+          k.value 0
+          k.value_lock true
+          k.delete_lock true
+          k.interpolation :constant
+        end
+      end # Chan block
+    end
+  end
+  
+  def write_offset_channels
+    %w(offset/x offset/y).map(&method(:prefix)).each do | c |
+      @writer.channel(c) do | chan |
+        chan.extrapolation :constant
+        chan.value 0
+      end
+    end
+  end
+  
+end

data/lib/export/flame_stabilizer_2014_cornerpin.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+# Exports setups with tracker naming that works with the Action bilinears
+class Tracksperanto::Export::FlameStabilizer2014Cornerpin < Tracksperanto::Export::FlameStabilizer2014
+  
+  def self.desc_and_extension
+    "flamesmoke_2014_cornerpin.stabilizer"
+  end
+  
+  def self.human_name
+    "Flame/Smoke 2D Stabilizer setup (v. 2014 and above) for corner pins"
+  end
+  
+  # The trackers for cornerpins should go in Z order, but now
+  # in N order, unline it did previously. Like so:
+  #
+  #     TL(1)     TR(3)
+  #      ˆ \       ˆ
+  #      |  \      |
+  #      |    \    |
+  #      |      \  |
+  #     BL(0)     BR(2)
+  #
+  # This "kinda tool" ensures that this is indeed taking place
+  class Sorter
+    include Tracksperanto::SimpleExport # so that it calls OUR methods
+    
+    def initialize(exporter)
+      @exp = exporter
+    end
+    
+    def start_export(w,h)
+      @width, @height = w, h
+      @corners, @four_done = [], false
+    end
+    
+    def start_tracker_segment(name)
+      @four_done = (@corners.length == 4)
+      return if @four_done
+      @corners.push(Tracksperanto::Tracker.new(:name => name))
+    end
+    
+    def export_point(f, x, y, r)
+      return if @four_done
+      @corners[-1].keyframe! :frame => f, :abs_x => x, :abs_y => y, :residual => r
+    end
+    
+    def end_tracker_segment
+      # Just leave that
+    end
+    
+    def end_export
+      # We will have problems sorting if we have too few trackers
+      return @exp.just_export(@corners, @width, @height) unless @corners.length == 4
+      
+      # Sort the trackers, first in Y of the first keyframe
+      in_y = sort_on_first_keyframe(@corners, :abs_y)
+      
+      # then on the X for the two separate blocks for top and bottom
+      tl, tr = sort_on_first_keyframe(in_y[2..3], :abs_x)
+      bl, br = sort_on_first_keyframe(in_y[0..1], :abs_x)
+      
+      bulk = [bl, tl, br, tr] # New Flame 2014 order
+      
+      @exp.just_export(bulk, @width, @height)
+    end
+    
+    private
+    
+    def sort_on_first_keyframe(enum, property)
+      enum.sort{|a, b| a[0].send(property) <=> b[0].send(property) }
+    end
+  end
+  
+  # Initialize the exporter with a preconfigured sorter around it.
+  # When this object receives the commands they will come from the Sorter instead,
+  # and the trackers will already be in their Z-order
+  def self.new(*arguments)
+    object = super
+    Sorter.new(object)
+  end
+  
+  # Now instead of names we got vague indices. YAY for Rue Duc!
+  CORNERPIN_NAMING = %w( none tracker0_0 tracker0_1 tracker1_0 tracker1_1 )
+  
+  # Overridden to give the right names to trackers
+  def prefix(tracker_channel)
+    tracker_name = CORNERPIN_NAMING[@counter]
+    [tracker_name, tracker_channel].join("/")
+  end
+  
+  def start_tracker_segment(tracker_name)
+    if (@counter == 4)
+      @skip = true
+    else
+      super
+    end 
+  end
+  
+  def export_point(frame, abs_float_x, abs_float_y, float_residual)
+    return if @skip
+    super
+  end
+  
+  def end_tracker_segment
+    return if @skip
+    super
+  end
+end

data/lib/tracksperanto.rb

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