flame_channel_parser 1.4.0 → 2.0.1

data/History.txt

@@ -1,3 +1,12 @@
+=== 2.0.1 / 2011-23-06
+
+* Fix the bake_flame_channel binary to use the proper extractor API
+* Add a test for the binary
+
+=== 2.0.0 / 2011-08-06
+
+* Remove most of the Array methods from the Channel object
+
 === 1.4.0 / 2011-06-06
 
 * Implement cycle and reverse-cycle extrapolation
@@ -6,11 +15,11 @@
 
 * Fix linear extrapolation occurring after linear keyframes, enforce the tangent/increment of zero for linear extrap. segments
 
-=== 1.3.1 / 2011-05-30
+=== 1.3.1 / 2011-30-05
 
 * Add minor fixes and imporvements to the curve extraction bin
 
-=== 1.3.0 / 2011-05-20
+=== 1.3.0 / 2011-20-05
 
 * Added the Extractor class that does simple per-frame baking to STDOUT
 * Add bake_flame_channel binary

data/Manifest.txt

@@ -4,11 +4,12 @@ Manifest.txt
 README.rdoc
 Rakefile
 bin/bake_flame_channel
+lib/channel.rb
 lib/extractor.rb
 lib/flame_channel_parser.rb
 lib/interpolator.rb
-lib/parser_2011.rb
-lib/parser_2012.rb
+lib/key.rb
+lib/parser.rb
 lib/segments.rb
 test/channel_with_constants.dat
 test/sample_channel.dat
@@ -30,7 +31,10 @@ test/snaps/RefT_Steadicam_TwoKFs_HermiteAtBegin.timewarp
 test/snaps/TW.timewarp
 test/snaps/TW_SingleFrameExtrapolated_from2011.timewarp
 test/snaps/timewarp_where_interp_fails_at_end.timewarp
+test/test_channel.rb
+test/test_cli.rb
 test/test_extractor.rb
 test/test_flame_channel_parser.rb
 test/test_interpolator.rb
+test/test_key.rb
 test/test_segments.rb

data/README.rdoc

@@ -32,7 +32,7 @@ To use the library:
     frame_channel = channels.find{|c| c.name == "Timing/Timing" }
     
     # Grab the interpolator object for this channel.
-    interpolator = FlameChannelParser::Interpolator.new(frame_channel)
+    interpolator = frame_channel.to_interpolator
     
     # Now sample from frame 20 to frame 250.
     # You can also sample at fractional frames if you want to.

data/Rakefile

@@ -4,6 +4,8 @@ require 'rubygems'
 require 'hoe'
 
 Hoe.spec 'flame_channel_parser' do | p |
+  Hoe::RUBY_FLAGS.gsub!(/^\-w/, '') # No thanks undefined ivar warnings
+    
   p.readme_file   = 'README.rdoc'
   p.extra_rdoc_files  = FileList['*.rdoc'] + FileList['*.txt']
   p.extra_deps = {"update_hints" => ">=0" }

data/bin/bake_flame_channel

@@ -1,8 +1,21 @@
 #!/usr/bin/env ruby
-require File.expand_path(File.dirname(__FILE__)) + '/../lib/flame_channel_parser'
+# == Synopsis
+# 
+# Extract an animation channel from a Flame setup
+#
+# == Usage
+# 
+#   bake_flame_channel TW_015_v03.timewarp
+#   
+# == Author
+#   Julik <me@julik.nl>
+
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/flame_channel_parser' unless defined?(FlameChannelParser)
 require 'optparse'
+require 'rubygems'
+require "update_hints"
 
-options = {}
+options = {:destination => $stdout}
 
 op = OptionParser.new
 op.banner = "Usage: bake_flame_channel --channel Timing/Timing -e 123 /usr/discreet/projects/Luxury/timewarp/shot2_tw.timewarp > /mnt/3d/curves/shot2_tw.framecurve.txt\n" +
@@ -23,9 +36,17 @@ op.on(" -f", "--to-file FILENAME",  String,
 
 op.parse!
 setup_path = ARGV.shift
-raise "No input file path provided. Please see bake_flame_channel --help for usage information" unless setup_path
+unless setup_path
+  $stderr.puts "No input file path provided. Please see bake_flame_channel --help for usage information." 
+  exit -1
+end
+
+unless File.exist?(setup_path)
+  $stderr.puts "File does not exist." 
+  exit -1
+end
 
-FlameChannelParser::Extractor.new.extract(setup_path, options)
+FlameChannelParser::Extractor.extract(setup_path, options)
 options[:destination].close if options[:destination].respond_to?(:close)
 
-UpdateHints.version_check("flame_channel_parser", FlameChannelParser::VERSION)
+UpdateHints.version_check("flame_channel_parser", FlameChannelParser::VERSION, $stderr)

data/lib/channel.rb

@@ -0,0 +1,36 @@
+require "forwardable"
+
+module FlameChannelParser
+  # Represents a channel parsed from the Flame setup. Contains
+  # the channel metadata and keyframes (Key objects).
+  # Supports the following standard Array methods:
+  # :empty?, :size, :each, :[], :push
+  class Channel
+    include Enumerable
+    extend Forwardable
+    
+    attr_reader :node_type, :node_name
+    attr_accessor :base_value, :name, :extrapolation
+    
+    def_delegators :@keys, :empty?, :length, :each, :[], :push, :<<
+    
+    def initialize(channel_name, node_type, node_name)
+      @keys = []
+      @node_type, @node_name, @name = node_type, node_name, channel_name.strip
+    end
+    
+    # Returns path to the channel (like axis1/position/x)
+    def path
+      [@node_name, name].compact.join("/")
+    end
+    
+    # Get an Interpolator for this channel
+    def to_interpolator
+      FlameChannelParser::Interpolator.new(self)
+    end
+    
+    def inspect
+      "<Channel (%s %s) with %d keys>" % [@node_type, path, @keys.size]
+    end
+  end
+end

data/lib/extractor.rb

@@ -1,4 +1,4 @@
-# Extracts and bakes a specific animation channel
+# Extracts and bakes a specific animation channel to a given buffer, one string per frame
 class FlameChannelParser::Extractor
   
   DEFAULT_CHANNEL_TO_EXTRACT = "Timing/Timing"
@@ -20,6 +20,12 @@ class FlameChannelParser::Extractor
   #  :start_frame - From which frame the curve should be baked. Will default to the first keyframe of the curve
   #  :end_frame - Upto which frame to bake. Will default to the last keyframe of the curve
   #  :channel - Name of the channel to extract from the setup. Defaults to "Timing/Timing" (timewarp frame)
+  #
+  # Note that start_frame and end_frame will be converted to integers.
+  # The output will look like this:
+  #
+  #   1  123.456
+  #   2  124.567
   def self.extract(path, options = {})
     options = DEFAULTS.merge(options)
     File.open(path) do |f|
@@ -47,6 +53,7 @@ class FlameChannelParser::Extractor
     
     from_frame = start_frame || interpolator.first_defined_frame
     to_frame =  end_frame || interpolator.last_defined_frame
+    
     unless (from_frame && to_frame)
       raise NoKeyframesError, "This channel probably has no animation so there is no way to automatically tell how many keyframes it has. " +
         "Please set the start and end frame explicitly."
@@ -54,7 +61,10 @@ class FlameChannelParser::Extractor
     
     raise EmptySegmentError, "The segment you are trying to bake is too small (it has nothing in it)" if to_frame - from_frame < 1
     
-    (from_frame..to_frame).each do | frame |
+    from_frame_i = from_frame.to_f.floor
+    to_frame_i = to_frame.to_f.ceil
+    
+    (from_frame_i..to_frame_i).each do | frame |
       line = "%d\t%.5f\n" % [frame, interpolator.sample_at(frame)]
       to_io << line
     end

data/lib/flame_channel_parser.rb

@@ -1,33 +1,12 @@
-require "delegate"
-
 module FlameChannelParser
-  VERSION = '1.4.0'
+  VERSION = '2.0.1'
   
-  # Parse a Flame setup into an array of ChannelBlock objects
+  # Parse a Flame setup into an array of Channel
   def self.parse(io)
-    parser_class = detect_parser_class_from(io)
-    parser_class.new.parse(io)
-  end
-  
-  private
-  
-  def self.detect_parser_class_from(io)
-    # Scan the IO
-    until io.eof?
-      str = io.gets
-      if str =~ /RHandleX/ # Flame 2012, use that parser
-        io.rewind
-        return Parser2012
-      end
-    end
-    
-    io.rewind
-    Parser2011
+    Parser.new.parse(io)
   end
 end
 
-require File.expand_path(File.dirname(__FILE__)) + "/parser_2011"
-require File.expand_path(File.dirname(__FILE__)) + "/parser_2012"
-require File.expand_path(File.dirname(__FILE__)) + "/segments"
-require File.expand_path(File.dirname(__FILE__)) + "/interpolator"
-require File.expand_path(File.dirname(__FILE__)) + "/extractor"
+%w(
+  key channel parser segments interpolator extractor
+).each {|f| require File.expand_path(File.dirname(__FILE__) + "/" + f ) }

data/lib/interpolator.rb

@@ -5,7 +5,7 @@ require File.expand_path(File.dirname(__FILE__)) + "/segments"
 # frames.
 #
 #   i = Interpolator.new(parsed_channel)
-#   i.value_at(245.5) # => will interpolate and return the value
+#   i.value_at(245.5) # => will interpolate and return the value at frame 245.5
 class FlameChannelParser::Interpolator
   include FlameChannelParser::Segments
   
@@ -19,20 +19,10 @@ class FlameChannelParser::Interpolator
     @extrap = channel.extrapolation
     
     # Edge case - channel has no anim at all
-    if channel.length.zero?
-      @segments << ConstantFunction.new(channel.base_value)
+    @segments = if channel.length.zero?
+      [ConstantFunction.new(channel.base_value)]
     else
-      
-      # First the prepolating segment
-      @segments << pick_prepolation(channel.extrapolation, channel[0], channel[1])
-      
-      # Then all the intermediate segments, one segment between each pair of keys
-      channel[0..-2].each_with_index do | key, index |
-        @segments << key_pair_to_segment(key, channel[index + 1])
-      end
-      
-      # so we just output it separately
-      @segments << pick_extrapolation(channel.extrapolation, channel[-2], channel[-1])
+      create_segments_from_channel(channel)
     end
   end
   
@@ -65,24 +55,37 @@ class FlameChannelParser::Interpolator
   
   private
   
+  def create_segments_from_channel(channel)
+    # First the prepolating segment
+    segments = [pick_prepolation(channel.extrapolation, channel[0], channel[1])]
+    
+    # Then all the intermediate segments, one segment between each pair of keys
+    channel[0..-2].each_with_index do | key, index |
+      segments << key_pair_to_segment(key, channel[index + 1])
+    end
+    
+    # and the extrapolator
+    segments << pick_extrapolation(channel.extrapolation, channel[-2], channel[-1])
+  end
+  
   def frame_number_in_revcycle(frame)
     animated_across = (last_defined_frame - first_defined_frame)
-    anchor_frame = (frame < first_defined_frame) ? first_defined_frame : last_defined_frame
-    frame_within_loop = (frame - anchor_frame) % animated_across
-    
-    coeff = ((frame - first_defined_frame) / animated_across).abs
-    if (coeff % 2).zero?
-      first_defined_frame + frame_within_loop
+    # Absolute offset from the first keyframe of the animated segment
+    offset = (frame - first_defined_frame).abs
+    absolute_unit = offset % animated_across
+    cycles = (offset / animated_across).floor
+    if (cycles % 2).zero?
+      first_defined_frame + absolute_unit
     else
-      last_defined_frame - frame_within_loop
+      last_defined_frame - absolute_unit
     end
   end
   
   def frame_number_in_cycle(frame)
     animated_across = (last_defined_frame - first_defined_frame)
-    anchor_frame = (frame < first_defined_frame) ? first_defined_frame : last_defined_frame
-    frame_within_loop = (frame - anchor_frame) % animated_across
-    first_defined_frame + frame_within_loop
+    offset = (frame - first_defined_frame)
+    modulo = (offset % animated_across)
+    first_defined_frame + modulo
   end
   
   def sample_from_segments(at_frame)

data/lib/key.rb

@@ -0,0 +1,76 @@
+# Represents a keyframe
+class FlameChannelParser::Key
+  
+  # Frame on which the keyframe is set
+  attr_accessor :frame
+  
+  # Value at this keyframe
+  attr_accessor :value
+  
+  # Inteprolation type from this key onwards
+  attr_accessor :interpolation
+  
+  # Curve order (relevant for 2012 only)
+  attr_accessor :curve_order, :curve_mode
+  
+  # Left and right slope (will return raw slope values for pre-2012, and computed ones for 2012)
+  attr_accessor :left_slope, :right_slope
+  
+  # Whether the tangents are broken at this keyframe
+  attr_accessor :break_slope
+  
+  # Coordinates of the handles for 2012 setups
+  attr_accessor :l_handle_x, :l_handle_y, :r_handle_x, :r_handle_y
+  
+  # Default value is 0.f
+  def value
+    @value.to_f
+  end
+
+  # Default frame is 1.0f
+  def frame
+    (@frame || 1).to_f
+  end
+  
+  # Returns the RightSlope parameter of the keyframe which we use for interpolations
+  def left_slope
+    return right_slope unless break_slope
+    
+    if has_2012_tangents? # 2012 setups do not have slopes but have tangents
+      dy = @value - @l_handle_y
+      dx = @l_handle_x.to_f - @frame
+      (dy / dx  * -1)
+    else
+      @left_slope.to_f
+    end
+  end
+  
+  # Returns the LeftSlope parameter of the keyframe which we use for interpolations
+  def right_slope
+    if has_2012_tangents?
+      dy = @value - @r_handle_y
+      dx = @frame.to_f - @r_handle_x
+      dy / dx
+    else
+      (@right_slope || nil).to_f 
+    end
+  end
+  
+  # Tells if this keyframe has 2012 tangents in it
+  def has_2012_tangents?
+    @has_tangents ||= !!(l_handle_x && l_handle_y)
+  end
+  
+  # Adapter for old interpolation
+  def interpolation
+    # Just return the interpolation type for pre-2012 setups
+    return (@interpolation || :constant) unless has_2012_tangents?
+    
+    return :constant if curve_order.to_s == "constant"
+    return :hermite if curve_order.to_s == "cubic" && (curve_mode.to_s == "hermite" || curve_mode.to_s == "natural")
+    return :bezier if curve_order.to_s == "cubic" && curve_mode.to_s == "bezier"
+    return :linear if curve_order.to_s == "linear"
+    
+    raise "Cannot determine interpolation for #{inspect}"
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,115 @@
+require "forwardable"
+
+# Basic parser used for setups from versions up to 2011
+module FlameChannelParser
+  class Parser
+    # Parses the setup passed in the IO
+    def parse(io)
+      channels = []
+      node_name, node_type = nil, nil
+      
+      until io.eof?
+        line = io.gets
+        if line =~ NODE_TYPE_MATCHER
+          node_type = $1
+        elsif line =~ NODE_NAME_MATCHER
+          node_name = $1
+        elsif line =~ CHANNEL_MATCHER && channel_is_useful?($1)
+          channels << parse_channel(io, $1, node_type, node_name)
+        end
+      end
+      
+      channels
+    end
+  
+    # Override this method to skip some channels, this will speedup
+    # your code alot
+    def channel_is_useful?(channel_name)
+      true
+    end
+    
+    # Defines a number of regular expression matchers applied to the file as it is being parsed
+    def key_matchers #:nodoc:
+      [
+        # Previously:
+        
+        [:frame, :to_f,  /Frame ([\-\d\.]+)/],
+        [:value, :to_f,  /Value ([\-\d\.]+)/],
+        [:left_slope, :to_f, /LeftSlope ([\-\d\.]+)/],
+        [:right_slope, :to_f, /RightSlope ([\-\d\.]+)/],
+        [:interpolation, :to_s, /Interpolation (\w+)/],
+        [:break_slope, :to_s, /BreakSlope (\w+)/],
+        
+        # 2012 intoroduces:
+        
+        [:r_handle_x, :to_f, /RHandleX ([\-\d\.]+)/],
+        [:l_handle_x, :to_f, /LHandleX ([\-\d\.]+)/],
+        [:r_handle_y, :to_f, /RHandleY ([\-\d\.]+)/],
+        [:l_handle_y, :to_f, /LHandleY ([\-\d\.]+)/],
+        [:curve_mode, :to_s,  /CurveMode (\w+)/],
+        [:curve_order, :to_s,  /CurveOrder (\w+)/],
+      ]
+    end
+    base_value_matcher = /Value ([\-\d\.]+)/
+    keyframe_count_matcher = /Size (\d+)/
+    
+    BASE_VALUE_MATCHER = /Value ([\-\d\.]+)/
+    KF_COUNT_MATCHER = /Size (\d+)/
+    EXTRAP_MATCHER = /Extrapolation (\w+)/
+    CHANNEL_MATCHER = /Channel (.+)\n/
+    NODE_TYPE_MATCHER = /Node (\w+)/
+    NODE_NAME_MATCHER = /Name (\w+)/
+    LITERALS = %w( linear constant natural hermite cubic bezier cycle revcycle )
+    
+    def parse_channel(io, channel_name, node_type, node_name)
+      c = Channel.new(channel_name, node_type, node_name)
+      
+      indent, end_mark = nil, "ENDMARK"
+      
+      while line = io.gets
+      
+        unless indent 
+          indent = line.scan(/^(\s+)/)[1]
+          end_mark = "#{indent}End"
+        end
+      
+        if line =~ KF_COUNT_MATCHER
+          $1.to_i.times { c.push(extract_key_from(io)) }
+        elsif line =~ BASE_VALUE_MATCHER# && empty?
+          c.base_value = $1.to_f
+        elsif line =~ EXTRAP_MATCHER
+          c.extrapolation = symbolize_literal($1)
+        elsif line.strip == end_mark
+          break
+        end
+      end
+      
+      return c
+    end
+    
+    def extract_key_from(io)
+      frame = nil
+      end_matcher = /End/
+      key = Key.new
+      
+      until io.eof?
+        line = io.gets
+        if line =~ end_matcher
+          return key
+        else
+          key_matchers.each do | property, cast_method, pattern  |
+              if line =~ pattern
+                v = symbolize_literal($1.send(cast_method))
+                key.send("#{property}=", v) 
+              end
+          end
+        end
+      end
+      raise "Did not detect any keyframes!"
+    end
+    
+    def symbolize_literal(v)
+      LITERALS.include?(v) ? v.to_sym : v
+    end
+  end
+end

data/test/test_channel.rb

@@ -0,0 +1,22 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/flame_channel_parser"
+
+D = 0.001
+
+class TestChannel < Test::Unit::TestCase
+  def test_responds_to_array_methods
+    c = FlameChannelParser::Channel.new("b/c", "d", "f")
+    [:empty?, :length, :each, :[], :push, :<<].each {|m| assert c.respond_to?(m) }
+  end
+  
+  def test_path_for_present_nodename
+    c = FlameChannelParser::Channel.new("position/x", "Axis", "axis1")
+    assert_equal "axis1/position/x", c.path
+  end
+  
+  def test_path_for_absent
+    c = FlameChannelParser::Channel.new("Frame/Frame", nil, nil)
+    assert_equal "Frame/Frame", c.path
+  end
+  
+end

data/test/test_cli.rb

@@ -0,0 +1,59 @@
+require "test/unit"
+require "stringio"
+require "tempfile"
+
+require File.dirname(__FILE__) + "/../lib/flame_channel_parser"
+
+class CliTest < Test::Unit::TestCase
+  BIN_P = File.expand_path(File.dirname(__FILE__) + "/../bin/bake_flame_channel")
+  
+  # Run the binary under test with passed options, and return [exit_code, stdout_content, stderr_content]
+  def cli(commandline_arguments)
+    old_stdout, old_stderr, old_argv = $stdout, $stderr, ARGV.dup
+    os, es = StringIO.new, StringIO.new
+    begin
+      $stdout, $stderr, verbosity = os, es, $VERBOSE
+      ARGV.replace(commandline_arguments.split)
+      $VERBOSE = false
+      load(BIN_P)
+      return [0, os.string, es.string]
+    rescue SystemExit => boom # The binary uses exit(), we use that to preserve the output code
+      return [boom.status, os.string, es.string]
+    ensure
+      $VERBOSE = verbosity
+      ARGV.replace(old_argv)
+      $stdout, $stderr = old_stdout, old_stderr
+    end
+  end
+  
+  def test_cli_with_no_args_produces_usage
+    status, o, e = cli('')
+    assert_equal -1, status
+    assert_match /No input file path provided/, e
+    assert_match /--help for usage information/, e
+  end
+  
+  def test_cli_with_nonexisting_file
+    status, o, e = cli(" amazing.action")
+    assert_equal -1, status
+    assert_match /does not exist/, e
+  end
+  
+  def test_cli_with_proper_output
+    full_path = File.expand_path(File.dirname(__FILE__)) + "/snaps/TW.timewarp"
+    status, output, e = cli(" " + full_path)
+    assert_equal 0, status
+    assert_equal 816, output.split("\n").length, "Should have output 816 frames"
+  end
+  
+  def test_cli_with_output_to_file
+    tf = Tempfile.new("experiment")
+    full_path = File.expand_path(File.dirname(__FILE__)) + "/snaps/TW.timewarp"
+    status, output, e = cli(" --to-file " + tf.path + " " + full_path)
+  
+    assert_equal 0, status
+    assert_equal 816, File.read(tf.path).split("\n").length, "Should have output 816 frames"
+  ensure
+    tf.close!
+  end
+end

data/test/test_flame_channel_parser.rb

@@ -18,7 +18,7 @@ class TestFlameChannelParser < Test::Unit::TestCase
     assert_kind_of Array, channels
     assert_equal 1, channels.length, "Should find one channel"
     
-    assert_kind_of FlameChannelParser::Parser2011::Channel, channels[0]
+    assert_kind_of FlameChannelParser::Channel, channels[0]
     
     ch = channels[0]
     assert_equal 4, ch.length

data/test/test_interpolator.rb

@@ -57,11 +57,11 @@ class TestInterpolator < Test::Unit::TestCase
   
   def test_simple_setup_from_2011
     data = File.open(File.dirname(__FILE__) + "/snaps/FLEM_curves_example.action")
-    channels_in_action = FlameChannelParser::Parser2011.new.parse(data)
+    channels_in_action = FlameChannelParser.parse(data)
     channels_in_action.reject!{|c| c.length < 4 }
     
-    reference = channels_in_action.find{|c| c.name == "position/x" && c.length > 2}
-    sampled = channels_in_action.find{|c| c.name == "position/y"  && c.length > 2}
+    reference = channels_in_action.find{|c| c.path == "axis1/position/x" }
+    sampled = channels_in_action.find{|c| c.path == "axis1/position/y"}
     assert_same_interpolation(1..200, reference, sampled)
   end
   
@@ -121,7 +121,7 @@ class TestInterpolator < Test::Unit::TestCase
     channels_in_tw = FlameChannelParser.parse(data)
     chan = channels_in_tw.find{|c| c.name == "Timing/Timing"}
     interp = chan.to_interpolator
-    assert_in_delta -7, interp.sample_at(1), DELTA
+    assert_in_delta( -7, interp.sample_at(1), DELTA)
     assert_in_delta 492, interp.sample_at(502), DELTA
     assert_in_delta 492, interp.sample_at(502), DELTA
     assert_in_delta 494, interp.sample_at(504), DELTA
@@ -159,7 +159,6 @@ class TestInterpolator < Test::Unit::TestCase
     assert_in_delta 683.772, interp.sample_at(1), DELTA
   end
   
-  
   def test_cycle_extrapolation
     data = File.open(File.dirname(__FILE__) + "/snaps/Cycle_and_revcycle.action")
     channels_in_ac = FlameChannelParser.parse(data)

data/test/test_key.rb

@@ -0,0 +1,86 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../lib/flame_channel_parser"
+
+class TestKey < Test::Unit::TestCase
+  D = 0.001
+  def test_default_values
+    k = FlameChannelParser::Key.new
+    assert_in_delta 1.0, k.frame, D
+    assert_in_delta 0.0, k.value, D
+    assert_equal :constant, k.interpolation
+    assert_equal false, k.has_2012_tangents?
+    
+    assert_nil k.l_handle_x 
+    assert_nil k.l_handle_y 
+    assert_nil k.r_handle_y 
+    assert_nil k.r_handle_x 
+  end
+  
+  def test_constant_curve_mode_translated_to_interpolation
+    k = FlameChannelParser::Key.new
+    k.curve_mode = :constant
+    assert_equal :constant, k.interpolation
+  end
+
+  def test_hermite_curve_mode_translated_to_interpolation
+    k = FlameChannelParser::Key.new
+    assign_tangents_to(k)
+    
+    k.curve_order = :cubic
+    k.curve_mode = :hermite
+    assert_equal :hermite, k.interpolation
+  end
+
+  def test_natural_curve_mode_translated_to_interpolation
+    k = FlameChannelParser::Key.new
+    assign_tangents_to(k)
+    
+    k.curve_order = :cubic
+    k.curve_mode = :natural
+    assert_equal :hermite, k.interpolation
+  end
+  
+  def test_bezier_curve_mode
+    k = FlameChannelParser::Key.new
+    assign_tangents_to(k)
+    
+    k.curve_order = :cubic
+    k.curve_mode = :bezier
+    assert_equal :bezier, k.interpolation
+  end
+  
+  def test_tangent_computed_from_right_handle
+    k = FlameChannelParser::Key.new
+    k.frame = 123
+    k.value = 123
+    
+    k.l_handle_x = 120
+    k.l_handle_y = 110
+    k.r_handle_x = 124
+    k.r_handle_y = 145
+    
+    assert_in_delta 22, k.right_slope, D
+    assert_in_delta 22, k.left_slope, D
+  end
+  
+  def test_tangent_computed_from_right_handle_with_broken_slope
+    k = FlameChannelParser::Key.new
+    k.frame = 123
+    k.value = 123
+    k.break_slope = true
+    
+    k.l_handle_x = 120
+    k.l_handle_y = 110
+    k.r_handle_x = 124
+    k.r_handle_y = 145
+    
+    assert_in_delta 22, k.right_slope, D
+    assert_in_delta 4.333, k.left_slope, D
+  end
+  
+  private
+  
+  def assign_tangents_to(to_key)
+    to_key.l_handle_x = to_key.l_handle_y = to_key.r_handle_x = to_key.r_handle_y = 1
+  end
+end

data/test/test_segments.rb

@@ -1,11 +1,11 @@
 require "test/unit"
 require File.dirname(__FILE__) + "/../lib/flame_channel_parser"
 
-D = 0.001
 
 include FlameChannelParser::Segments
 
 class TestConstantFunction < Test::Unit::TestCase
+  D = 0.001
   def test_segment
     seg = ConstantFunction.new(123.4)
     assert seg.defines?(-1), "The segment should define this frame"
@@ -16,6 +16,7 @@ end
 
 
 class TestConstantSegment < Test::Unit::TestCase
+  D = 0.001
   def test_segment
     seg = ConstantSegment.new(12, 25, 2.5)
     
@@ -31,7 +32,7 @@ class TestConstantSegment < Test::Unit::TestCase
 end
 
 class TestBezierSegment < Test::Unit::TestCase
-  
+  D = 0.001
   def test_segment
     seg = BezierSegment.new(
       frame_from = 117,
@@ -54,6 +55,8 @@ class TestBezierSegment < Test::Unit::TestCase
 end
 
 class TestLinearSegment < Test::Unit::TestCase
+  D = 0.001
+  
   def test_segment
     seg = LinearSegment.new(12, 25, 2.5, 4.5)
     
@@ -80,6 +83,8 @@ class TestConstantPrepolate < Test::Unit::TestCase
 end
 
 class TestHermiteSegment < Test::Unit::TestCase
+  D = 0.001
+  
   def test_last_curve_segment
     refdata = %w(
       258.239

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: flame_channel_parser
 version: !ruby/object:Gem::Version 
-  hash: 7
   prerelease: 
-  segments: 
-  - 1
-  - 4
-  - 0
-  version: 1.4.0
+  version: 2.0.1
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -15,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-06 00:00:00 +02:00
-default_executable: 
+date: 2011-06-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: update_hints
@@ -26,9 +20,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
@@ -40,12 +31,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 2
-        - 9
-        - 1
-        version: 2.9.1
+        version: 2.9.4
   type: :development
   version_requirements: *id002
 description: |-
@@ -68,11 +54,12 @@ files:
 - README.rdoc
 - Rakefile
 - bin/bake_flame_channel
+- lib/channel.rb
 - lib/extractor.rb
 - lib/flame_channel_parser.rb
 - lib/interpolator.rb
-- lib/parser_2011.rb
-- lib/parser_2012.rb
+- lib/key.rb
+- lib/parser.rb
 - lib/segments.rb
 - test/channel_with_constants.dat
 - test/sample_channel.dat
@@ -94,12 +81,14 @@ files:
 - test/snaps/TW.timewarp
 - test/snaps/TW_SingleFrameExtrapolated_from2011.timewarp
 - test/snaps/timewarp_where_interp_fails_at_end.timewarp
+- test/test_channel.rb
+- test/test_cli.rb
 - test/test_extractor.rb
 - test/test_flame_channel_parser.rb
 - test/test_interpolator.rb
+- test/test_key.rb
 - test/test_segments.rb
 - .gemtest
-has_rdoc: true
 homepage: http://guerilla-di.org/flame-channel-parser
 licenses: []
 
@@ -114,28 +103,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: flame_channel_parser
-rubygems_version: 1.4.1
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Includes a small library for extracting, parsing and baking animation curves made on Discrodesk Floke/Inflinto, also known as flame
 test_files: 
+- test/test_channel.rb
+- test/test_cli.rb
 - test/test_extractor.rb
 - test/test_flame_channel_parser.rb
 - test/test_interpolator.rb
+- test/test_key.rb
 - test/test_segments.rb

data/lib/parser_2011.rb

@@ -1,156 +0,0 @@
-require "delegate"
-
-# Basic parser used for setups from versions up to 2011
-class FlameChannelParser::Parser2011
-  
-  # Represents a keyframe
-  class Key < Struct.new(:frame, :value, :interpolation, :extrapolation, :left_slope, :right_slope, :break_slope)
-    
-    # Unless the key is broken? we should just use the right slope
-    def left_slope
-      return right_slope unless broken?
-      super
-    end
-    
-    # Tells whether the slope of this keyframe is broken (not smooth)
-    def broken?
-      break_slope
-    end
-  end
-  
-  # Defines a number of regular expression matchers applied to the file as it is being parsed
-  def matchers
-    [
-      [:frame, :to_i,  /Frame ([\-\d\.]+)/],
-      [:value, :to_f,  /Value ([\-\d\.]+)/],
-      [:left_slope, :to_f, /LeftSlope ([\-\d\.]+)/],
-      [:right_slope, :to_f, /RightSlope ([\-\d\.]+)/],
-      [:interpolation, :to_s, /Interpolation (\w+)/],
-      [:extrapolation, :to_s, /Extrapolation (\w+)/],
-      [:break_slope, :to_s, /BreakSlope (\w+)/]
-    ]
-  end
-  
-  def create_key
-    Key.new
-  end
-  
-  # Represents a channel parsed from the Flame setup. Contains
-  # the channel metadata and keyframes
-  class Channel < DelegateClass(Array)
-    attr_reader :node_type
-    attr_reader :node_name
-    attr_accessor :base_value
-    attr_accessor :name
-    attr_accessor :extrapolation
-    
-    def initialize(io, channel_name, parent_parser, node_type, node_name)
-      super([])
-      
-      @node_type = node_type
-      @node_name = node_name
-      @parser = parent_parser
-      @name = channel_name.strip
-      
-      base_value_matcher = /Value ([\-\d\.]+)/
-      keyframe_count_matcher = /Size (\d+)/
-      extrapolation_matcher = /Extrapolation (\w+)/
-      
-      indent = nil
-      
-      while line = io.gets
-        
-        unless indent 
-          indent = line.scan(/^(\s+)/)[1]
-          end_mark = "#{indent}End"
-        end
-        
-        if line =~ keyframe_count_matcher
-          $1.to_i.times { push(extract_key_from(io)) }
-        elsif line =~ base_value_matcher && empty?
-          self.base_value = $1.to_f
-        elsif line =~ extrapolation_matcher
-          self.extrapolation = symbolize_literal($1)
-        elsif line.strip == end_mark
-          break
-        end
-      end
-      
-    end
-    
-    def path
-      [@node_name, name].compact.join("/")
-    end
-    
-    # Get an Interpolator from this channel
-    def to_interpolator
-      FlameChannelParser::Interpolator.new(self)
-    end
-    
-    private
-    
-    def create_key
-      Key.new
-    end
-    
-    INTERPS = [:constant, :linear, :hermite, :natural, :bezier]
-    
-    def extract_key_from(io)
-      frame = nil
-      end_matcher = /End/
-      
-      key = @parser.create_key
-      matchers = @parser.matchers
-      
-      until io.eof?
-        line = io.gets
-        if line =~ end_matcher
-          return key
-        else
-          matchers.each do | property, cast_method, pattern  |
-              if line =~ pattern
-                v = symbolize_literal($1.send(cast_method))
-                key.send("#{property}=", v) 
-              end
-          end
-        end
-      end
-      raise "Did not detect any keyframes!"
-    end
-    
-    LITERALS = %w( linear constant natural hermite cubic bezier cycle revcycle )
-    
-    def symbolize_literal(v)
-      LITERALS.include?(v) ? v.to_sym : v
-    end
-    
-  end
-  
-  CHANNEL_MATCHER = /Channel (.+)\n/
-  NODE_TYPE_MATCHER = /Node (\w+)/
-  NODE_NAME_MATCHER = /Name (\w+)/
-  
-  def parse(io)
-    channels = []
-    node_name, node_type = nil, nil
-    
-    until io.eof?
-      line = io.gets
-      if line =~ NODE_TYPE_MATCHER
-        node_type = $1
-      elsif line =~ NODE_NAME_MATCHER
-        node_name = $1
-      elsif line =~ CHANNEL_MATCHER && channel_is_useful?($1)
-        channels << Channel.new(io, $1, self, node_type, node_name)
-      end
-    end
-    channels
-  end
-  
-  # Override this method to skip some channels, this will speedup
-  # your code alot
-  def channel_is_useful?(channel_name)
-    true
-  end
-  
-end

data/lib/parser_2012.rb

@@ -1,59 +0,0 @@
-require "delegate"
-require File.dirname(__FILE__) + "/interpolator"
-
-# This parser is automatically used for 2012 setups
-class FlameChannelParser::Parser2012 < FlameChannelParser::Parser2011
-
-  class ModernKey < Struct.new(:frame, :value, :r_handle_x, :l_handle_x, :r_handle_y, :l_handle_y, :curve_mode, :curve_order, :break_slope)
-    alias_method :to_s, :inspect
-    
-    # Adapter for old interpolation
-    def interpolation
-      return :constant if curve_order.to_s == "constant"
-      return :hermite if curve_order.to_s == "cubic" && (curve_mode.to_s == "hermite" || curve_mode.to_s == "natural")
-      return :bezier if curve_order.to_s == "cubic" && curve_mode.to_s == "bezier"
-      return :linear if curve_order.to_s == "linear"
-      
-      raise "Cannot determine interpolation for #{self.inspect}"
-    end
-    
-    # Compute pre-212 slope which we use for interpolations
-    def left_slope
-      return right_slope unless broken?
-      
-      dy = value - l_handle_y
-      dx = l_handle_x - frame
-      dy / dx  * -1
-    end
-    
-    # Compute pre-212 slope which we use for interpolations
-    def right_slope
-      dy = value - r_handle_y
-      dx = frame - r_handle_x
-      dy / dx
-    end
-    
-    def broken?
-      break_slope
-    end
-  end
-  
-  def matchers
-     [
-       [:frame, :to_i,  /Frame ([\-\d\.]+)/],
-       [:value, :to_f,  /Value ([\-\d\.]+)/],
-       [:r_handle_x, :to_f, /RHandleX ([\-\d\.]+)/],
-       [:l_handle_x, :to_f, /LHandleX ([\-\d\.]+)/],
-       [:r_handle_y, :to_f, /RHandleY ([\-\d\.]+)/],
-       [:l_handle_y, :to_f, /LHandleY ([\-\d\.]+)/],
-       [:curve_mode, :to_s,  /CurveMode (\w+)/],
-       [:curve_order, :to_s,  /CurveOrder (\w+)/],
-       [:break_slope, :to_s,  /BreakSlope (\w+)/],
-     ]
-   end
-   
-  
-  def create_key
-    ModernKey.new
-  end
-end