flame_channel_parser 2.0.1 → 2.1.1

data/History.txt

@@ -1,3 +1,12 @@
+=== 2.1.1 / 2011-23-06
+
+* Fixed exceptions for for channel not found errors
+* Uses cli_test for testing the application
+
+=== 2.1.0 / 2011-23-06
+
+* Fixed range detection for setups (we now properly detect the last frame for setups that support it)
+
 === 2.0.1 / 2011-23-06
 
 * Fix the bake_flame_channel binary to use the proper extractor API

data/Rakefile

@@ -3,14 +3,15 @@
 require 'rubygems'
 require 'hoe'
 
+Hoe::RUBY_FLAGS.gsub!(/^\-w/, '') # No thanks undefined ivar warnings
 Hoe.spec 'flame_channel_parser' do | p |
-  Hoe::RUBY_FLAGS.gsub!(/^\-w/, '') # No thanks undefined ivar warnings
-    
+  p.developer('Julik Tarkhanov', 'me@julik.nl')
+  
   p.readme_file   = 'README.rdoc'
   p.extra_rdoc_files  = FileList['*.rdoc'] + FileList['*.txt']
   p.extra_deps = {"update_hints" => ">=0" }
-  p.developer('Julik Tarkhanov', 'me@julik.nl')
-  p.clean_globs = %w( **/.DS_Store  coverage.info **/*.rbc .idea .yardoc *.numbers)
+  p.extra_dev_deps = {"cli_test" => "~> 1.0.0" }
+  p.clean_globs = File.read(".gitignore").split("\n")
 end
 
 # vim: syntax=ruby

data/bin/bake_flame_channel

@@ -30,6 +30,10 @@ op.on(" -s", "--startframe FRAME", Integer,
 op.on(" -e", "--endframe FRAME", Integer,
   "Bake the curve upto this specific frame (defaults to the last keyframe in the setup)"
 ) {|upto| options[:end_frame] = upto }
+op.on(" -k", "--keyframed-range-only",
+  "Bake the curve from the first keyframe to the last only (overrides --startframe and --endframe)"
+) { options[:on_curve_limits] = true }
+
 op.on(" -f", "--to-file FILENAME",  String, 
   "Write the curve to a file at this path instead of printing it to STDOUT"
 ) {|path| options[:destination] = File.open(path, "wb") }

data/lib/extractor.rb

@@ -2,7 +2,6 @@
 class FlameChannelParser::Extractor
   
   DEFAULT_CHANNEL_TO_EXTRACT = "Timing/Timing"
-  DEFAULTS = {:destination => $stdout, :start_frame => nil, :end_frame => nil, :channel => DEFAULT_CHANNEL_TO_EXTRACT }
   
   # Raised when a channel is not found in the setup file
   class ChannelNotFoundError < RuntimeError; end
@@ -10,9 +9,6 @@ class FlameChannelParser::Extractor
   # Raised when you try to autodetect the length of a channel that has no keyframes
   class NoKeyframesError < RuntimeError; end
   
-  # Raised when you try to bake 0 or negative amount of frames
-  class EmptySegmentError < RuntimeError; end
-  
   # Pass the path to Flame setup here and you will get the animation curve on the object passed in
   # the :destionation option (defaults to STDOUT). The following options are accepted:
   #
@@ -27,43 +23,91 @@ class FlameChannelParser::Extractor
   #   1  123.456
   #   2  124.567
   def self.extract(path, options = {})
-    options = DEFAULTS.merge(options)
+    new.extract(path, options)
+  end
+  
+  def extract(path, options)
+    options = DEFAULTS.dup.merge(options)
     File.open(path) do |f|
+      
+      # Then parse
       channels = FlameChannelParser.parse(f)
       selected_channel = find_channel_in(channels, options[:channel])
       interpolator = FlameChannelParser::Interpolator.new(selected_channel)
+      
+      # Configure the range
+      configure_start_and_end_frame(f, options, interpolator)
+      
+      # And finally...
       write_channel(interpolator, options[:destination], options[:start_frame], options[:end_frame])
     end
   end
   
   private
   
-  def self.find_channel_in(channels, channel_path)
+  DEFAULT_START_FRAME = 1
+  DEFAULTS = {:destination => $stdout, :start_frame => nil, :end_frame => nil, :channel => DEFAULT_CHANNEL_TO_EXTRACT, :on_curve_limits => false }
+  
+  SETUP_END_FRAME_PATTERN = /(MaxFrames|Frames)(\s+)(\d+)/
+  SETUP_START_FRAME_PATTERN = /(MinFrame)(\s+)(\d+)/
+  
+  def configure_start_and_end_frame(f, options, interpolator)
+    # If the settings specify last and first frame...
+    if options[:on_curve_limits]
+      options[:start_frame] = interpolator.first_defined_frame.to_i
+      options[:end_frame] = interpolator.last_defined_frame.to_i
+      if (!options[:start_frame] || !options[:end_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."
+      elsif options[:end_frame] == options[:start_frame]
+        raise NoKeyframesError, "This channel has only one keyframe " + 
+          "at frame #{options[:start_frame]}and baking it makes no sense."
+      end
+    else # Detect from the setup itself (the default)
+      # First try to detect start and end frames from the known flags
+      f.rewind
+      detected_start, detected_end = detect_start_and_end_frame_in_io(f)
+      
+      options[:start_frame] = options[:start_frame] || detected_start || DEFAULT_START_FRAME
+      options[:end_frame] ||= detected_end
+    end
+  end
+  
+  
+  def detect_start_and_end_frame_in_io(io)
+    cur_offset, s, e = io.pos, nil, nil
+    io.rewind
+    while line = io.gets
+      if (elements = line.scan(SETUP_START_FRAME_PATTERN)).any? 
+        s = elements.flatten[-1].to_i
+      elsif (elements = line.scan(SETUP_END_FRAME_PATTERN)).any? 
+        e = elements.flatten[-1].to_i
+        return [s, e]
+      end
+    end
+  end
+  
+  def compose_channel_not_found_message(for_channel, other_channels)
+    message = "Channel #{for_channel.inspect} not found in this setup (set the channel with the :channel option). Found other channels though:" 
+    message << "\n"
+    message += other_channels.map{|c| "\t%s\n" % c.path }.join
+  end
+  
+  def find_channel_in(channels, channel_path)
     selected_channel = channels.find{|c| channel_path == c.path }
     unless selected_channel
-      message = "Channel #{channel_path.inspect} not found in this setup (set the channel with the --channel option). Found other channels though:" 
-      message << "\n"
-      message += channels.map{|c| "\t%s\n" % c.path }.join
-      raise ChannelNotFoundError, message
+      raise ChannelNotFoundError, compose_channel_not_found_message(channel_path, channels)
     end
     selected_channel
   end
-
-  def self.write_channel(interpolator, to_io, start_frame, end_frame)
-    
-    from_frame = start_frame || interpolator.first_defined_frame
-    to_frame =  end_frame || interpolator.last_defined_frame
+  
+  def write_channel(interpolator, to_io, from_frame_i, to_frame_i)
     
-    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."
+    if (to_frame_i - from_frame_i) == 1
+      $stderr.puts "WARNING: You are extracting one animation frame. Check the length of your setup, or set the range manually"
     end
     
-    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_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

data/lib/flame_channel_parser.rb

@@ -1,5 +1,5 @@
 module FlameChannelParser
-  VERSION = '2.0.1'
+  VERSION = '2.1.1'
   
   # Parse a Flame setup into an array of Channel
   def self.parse(io)

data/test/snaps/RefT_Steadicam_Extraction.txt

@@ -1,3 +1,43 @@
+1	459.00000
+2	457.00000
+3	455.00000
+4	453.00000
+5	451.00000
+6	449.00000
+7	447.00000
+8	445.00000
+9	443.00000
+10	441.00000
+11	439.00000
+12	437.00000
+13	435.00000
+14	433.00000
+15	431.00000
+16	429.00000
+17	427.00000
+18	425.00000
+19	423.00000
+20	421.00000
+21	419.00000
+22	417.00000
+23	415.00000
+24	413.00000
+25	411.00000
+26	409.00000
+27	407.00000
+28	405.00000
+29	403.00000
+30	401.00000
+31	399.00000
+32	397.00000
+33	395.00000
+34	393.00000
+35	391.00000
+36	389.00000
+37	387.00000
+38	385.00000
+39	383.00000
+40	381.00000
 41	379.00000
 42	377.00000
 43	375.00000

data/test/test_cli.rb

@@ -1,58 +1,57 @@
 require "test/unit"
 require "stringio"
 require "tempfile"
+require "cli_test"
 
-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")
+class TestCli < Test::Unit::TestCase
   
-  # 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
+  def setup
+    binary = File.expand_path(File.dirname(__FILE__) + "/../bin/bake_flame_channel")
+    @app = CLITest.new(binary)
   end
   
   def test_cli_with_no_args_produces_usage
-    status, o, e = cli('')
+    status, o, e = @app.run('')
     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")
+    status, o, e = @app.run(" 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)
+    status, output, e = @app.run(" " + full_path)
     assert_equal 0, status
-    assert_equal 816, output.split("\n").length, "Should have output 816 frames"
+    assert_equal 747, output.split("\n").length, "Should have output 816 frames"
+  end
+  
+  def test_cli_with_file_length
+     full_path = File.expand_path(File.dirname(__FILE__)) + "/snaps/TW_015_010_v03.timewarp"
+     status, output, e = @app.run(full_path)
+     assert_equal 0, status
+     assert_equal 476, output.split("\n").length, "Should have output 476 frames"
+  end
+   
+  def test_cli_with_curve_limits
+     full_path = File.expand_path(File.dirname(__FILE__)) + "/snaps/TW_015_010_v03.timewarp"
+     status, output, e = @app.run(" --keyframed-range-only " + full_path)
+     assert_equal 0, status
+     assert_equal 531, output.split("\n").length, "Should have output 513 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)
-  
+    status, output, e = @app.run(" --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"
+    assert_equal 0, output.length
+    assert_equal 747, File.read(tf.path).split("\n").length, "Should have output 816 frames"
   ensure
     tf.close!
   end

data/test/test_extractor.rb

@@ -4,20 +4,14 @@ require "stringio"
 require File.dirname(__FILE__) + "/../lib/flame_channel_parser"
 
 class TestExtractor < Test::Unit::TestCase
+  
   def test_basic_operation
     io = StringIO.new
-    FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/RefT_Steadicam.timewarp", :destination => io)
+    opts = {:destination => io}
+    FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/RefT_Steadicam.timewarp", opts)
     assert_equal File.read(File.dirname(__FILE__) + "/snaps/RefT_Steadicam_Extraction.txt"), io.string
   end
   
-  def test_channel_selection_by_path_raises_with_not_animated_channel_and_no_start_and_end
-    io = StringIO.new
-    ops = {:destination => io, :channel => "axis1/position/z"}
-    assert_raise(FlameChannelParser::Extractor::NoKeyframesError) do
-      FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/FLEM_curves_example_migrated_to_2012.action", ops)
-    end
-  end
-  
   def test_channel_selection_by_path_outputs_properly
     io = StringIO.new
     ops = {:destination => io, :channel => "axis1/position/y"}
@@ -38,13 +32,32 @@ class TestExtractor < Test::Unit::TestCase
     io = StringIO.new
     o = {:destination => io, :start_frame => 19, :end_frame => 347 }
     FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/RefT_Steadicam.timewarp", o)
-    
     assert_equal File.read(File.dirname(__FILE__) + "/snaps/RefT_Steadicam_Extraction_F19_to_347.txt"), io.string
   end
   
+  def test_properly_recognizes_timewarp_length_in_timewarp
+    io = StringIO.new
+    o = {:destination => io }
+    FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/TW_015_010_v03.timewarp", o)
+    lines = io.string.split("\n")
+    
+    assert_equal 476, lines.length, "Should have parsed out 476 frames even though animation curves go further"
+  end
+  
+  def test_properly_recognizes_timewarp_length_in_action
+    io = StringIO.new
+    o = {:destination => io , :channel => "axis1/position/z"}
+    FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/FLEM_BrokenTangents.action", o)
+    lines = io.string.split("\n")
+    
+    assert_equal 125, lines.length, "Should have parsed out 125 frames even though animation curves go further"
+  end
+  
   def test_constant_channels_need_domain_of_definition_on_time
+    opts = {:channel => "Mix/Mix", :on_curve_limits => true}
+    
     assert_raise(FlameChannelParser::Extractor::NoKeyframesError) do
-      FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/RefT_Steadicam.timewarp", :channel => "Mix/Mix")
+      FlameChannelParser::Extractor.extract(File.dirname(__FILE__) + "/snaps/RefT_Steadicam.timewarp", opts)
     end
   end
   

metadata

@@ -2,7 +2,7 @@
 name: flame_channel_parser
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.0.1
+  version: 2.1.1
 platform: ruby
 authors: 
 - Julik Tarkhanov
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-23 00:00:00 Z
+date: 2011-06-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: update_hints
@@ -24,16 +24,27 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: cli_test
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: 2.9.4
   type: :development
-  version_requirements: *id002
+  version_requirements: *id003
 description: |-
   Includes a small library for extracting, parsing and baking animation curves made on Discrodesk Floke/Inflinto, also known as flame.
   Thanks to Marijn Eken, Philippe Soeiro and Andre Gagnon for their support and advice.