sequencer 1.0.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-02-10
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/seqls
+lib/sequencer.rb
+test/test_sequencer.rb

data/README.txt

@@ -0,0 +1,49 @@
+= sequencer
+
+* http://guerilla-di.org/sequencer
+
+== DESCRIPTION:
+
+Simplifies working with image sequences
+
+== FEATURES/PROBLEMS:
+
+* List all sequences in a directory interspersed with other file entries
+* Detect sequence from single file
+
+== SYNOPSIS:
+
+  require "sequencer"
+	s = Sequencer.from_single_file("/RAID/Film/CONFORM.092183.dpx")
+	s.file_count #=> 3201
+	s.gaps? #=> true
+	s.missing_frames #=> 15, somebody was careless
+
+== INSTALL:
+
+* sudo gem install sequencer
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Julik Tarkhanov (me@julik.nl)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'hoe'
+require File.dirname(__FILE__) + "/lib/sequencer"
+
+Hoe.spec 'sequencer' do | s |
+  s.version = Sequencer::VERSION
+  s.developer('Julik Tarkhanov', 'me@julik.nl')
+  s.extra_dev_deps = {"test-spec" => ">=0"}
+end
+
+# vim: syntax=ruby

data/bin/seqls

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + "/../lib/sequencer"
+d = ARGV.shift || Dir.pwd
+
+Sequencer.entries(d).each do | e |
+  puts e
+end

data/lib/sequencer.rb

@@ -0,0 +1,208 @@
+module Sequencer
+  VERSION = '1.0.0'
+  NUMBERS_AT_END = /(\d+)([^\d]+)?$/
+  
+  extend self
+  
+  # Detects sequences in the passed directory (same as Dir.entries but returns Sequence objects).
+  # Single files will be upgraded to single-frame Sequences
+  def entries(of_dir)
+    actual_files = Dir.entries(of_dir)[2..-1]
+    groups = {}
+    
+    actual_files.each do | e |
+      if e =~ NUMBERS_AT_END
+        base = e[0...-([$1, $2].join.length)]
+        key = [base, $2]
+        groups[key] ||= []
+        groups[key] << e
+      else
+        groups[e] = [e]
+      end
+    end
+    
+    groups.map do | key, filenames |
+      Sequence.new(of_dir, filenames)
+    end
+  end
+  
+  # Detect a Sequence from a single file and return a handle to it
+  def from_single_file(path_to_single_file)
+    File.stat(path_to_single_file)
+    frame_number = path_to_single_file.scan(NUMBERS_AT_END).flatten.shift
+    if frame_number =~ /^0/ # Assume that the input is padded and take the glob path
+      sequence_via_glob(path_to_single_file)
+    else # Take the slower path by pattern-matching on entries
+      sequence_via_patterns(path_to_single_file)
+    end
+  end
+  
+  # Get a glob pattern and padding offset for a file in a sequence
+  def glob_and_padding_for(path)
+    plen = 0
+    glob_pattern = path.gsub(NUMBERS_AT_END) do
+      plen = $1.length
+      ('[0-9]' * plen) + $2.to_s
+    end
+    return nil if glob_pattern == path
+    
+    [glob_pattern, plen]
+  end
+  
+  private 
+  
+  def sequence_via_glob(path_to_single_file)
+    glob, padding = glob_and_padding_for(path_to_single_file)
+    seq_glob = File.join(File.dirname(path_to_single_file), File.basename(glob))
+    files = Dir.glob(seq_glob).map {|f| File.basename(f) }
+    
+    Sequence.new(File.expand_path(File.dirname(path_to_single_file)), files)
+  end
+  
+  def sequence_via_patterns(path_to_single_file)
+    base_glob_pattern = path_to_single_file.gsub(NUMBERS_AT_END, '*')
+    closing_element = $2
+    matching_paths = Dir.glob(base_glob_pattern).select do | p |
+      number, closer = p.scan(NUMBERS_AT_END).flatten
+      closer == closing_element
+    end
+    files = matching_paths.map {|f| File.basename(f) }
+    Sequence.new(File.expand_path(File.dirname(path_to_single_file)), files)
+  end
+  
+  public
+  
+  class Sequence
+    include Enumerable
+    attr_reader :pattern
+    
+    def initialize(directory, filenames)
+      raise "Can't sequence nothingness" if filenames.empty?
+      @directory, @filenames = directory, natural_sort(filenames)
+      @directory.freeze
+      @filenames.freeze
+      detect_gaps!
+      detect_pattern!
+    end
+    
+    # Returns true if the files in the sequence can have numbers
+    def numbered?
+      @numbered ||= !!(@filenames[0] =~ NUMBERS_AT_END)
+    end
+    
+    # Returns true if this sequence has gaps
+    def gaps?
+      @ranges.length > 1
+    end
+    
+    # Tells whether this is a single frame sequence
+    def single_file?
+      @filenames.length == 1
+    end
+    
+    def inspect
+      '#<%s>' % to_s
+    end
+    
+    def to_s
+      return @filenames[0] if (!numbered? || single_file?)
+      
+      printable = unless single_file?
+        @ranges.map do | r |
+          "%d..%d" % [r.begin, r.end]
+        end.join(', ')
+      else
+        @ranges[0].begin
+      end
+      @inspect_pattern % "[#{printable}]"
+    end
+    
+    def expected_frames
+      @expected_frames ||= ((@ranges[-1].end - @ranges[0].begin) + 1)
+    end
+    
+    def gap_count
+      @ranges.length - 1
+    end
+    
+    # Returns the number of frames that the sequence should contain to be continuous
+    def missing_frames
+      expected_frames - file_count
+    end
+    
+    # Returns the actual file count in the sequence
+    def file_count
+      @file_count ||= @filenames.length
+    end
+    
+    # Check if this sequencer includes a file
+    def include?(base_filename)
+      @filenames.include?(base_filename)
+    end
+    
+    # Yield each filename in the sequence to the block
+    def each
+      @filenames.each {|f| yield(f) }
+    end
+    
+    # Yield each absolute path to a file in the sequence to the block
+    def each_path
+      @filenames.each{|f| yield(File.join(@directory, f))}
+    end
+    
+    private
+    
+    def natural_sort(ar)
+      ar.sort_by {|e| e.scan(NUMBERS_AT_END).flatten.shift.to_i }
+    end
+    
+    def detect_pattern!
+      
+      unless numbered?
+        @inspect_pattern = "%s"
+        @pattern = @filenames[0]
+      else
+        @inspect_pattern = @filenames[0].gsub(NUMBERS_AT_END) do
+          ["%s", $2].join
+        end
+      
+        highest_padding = nil
+        @pattern = @filenames[-1].gsub(NUMBERS_AT_END) do
+          highest_padding = $1.length
+          ["%0#{$1.length}d", $2].join
+        end
+      
+        # Look at the first file in the sequence. If it has a lesser number of 
+        lowest_padding = @filenames[0].scan(NUMBERS_AT_END).flatten.shift.length
+        if lowest_padding < highest_padding # Natural numbering
+          @pattern = @filenames[0].gsub(NUMBERS_AT_END) do
+            ["%d", $2].join
+          end
+        end
+      end
+      
+      @inspect_pattern.freeze
+      @pattern.freeze
+    end
+    
+    def detect_gaps!
+      only_numbers = @filenames.map do | f |
+        f.scan(NUMBERS_AT_END).flatten.shift.to_i
+      end
+      @ranges = to_ranges(only_numbers)
+    end
+    
+    def to_ranges(array)
+      array.compact.sort.uniq.inject([]) do | result, elem |
+        result = [elem..elem] if result.length.zero?
+        if [result[-1].end, result[-1].end.succ].include?(elem)
+          result[-1] = result[-1].begin..elem
+        else
+          result.push(elem..elem)
+        end
+        result
+      end
+    end
+  end
+  
+end

data/test/test_sequencer.rb

@@ -0,0 +1,156 @@
+require 'test/unit'
+require 'rubygems'
+require 'test/spec'
+require 'fileutils'
+require File.dirname(__FILE__) + '/../lib/sequencer'
+
+TEST_DIR = File.dirname(__FILE__) + "/tmp"
+
+def emit_test_dirs
+  start_f = 123
+  end_f  = 568
+  
+  FileUtils.mkdir_p(TEST_DIR + "/sequence_and_sole_file")
+  main_seq = TEST_DIR + "/sequence_and_sole_file/seq1.%06d.tif"
+  sole_file = TEST_DIR + "/sequence_and_sole_file/somefile.tif"
+  (start_f..end_f).each do | i |
+    FileUtils.touch(main_seq % i)
+  end
+  FileUtils.touch(sole_file)
+  
+  broken_seq = TEST_DIR + "/sequence_and_sole_file/broken_seq.%06d.tif"
+  
+  (start_f..end_f).each do | i |
+    FileUtils.touch(broken_seq % i)
+  end
+  
+  ((end_f + 10)..(end_f + 134)).each do | i |
+    FileUtils.touch(broken_seq % i)
+  end
+  
+  single_file_seq = TEST_DIR + "/sequence_and_sole_file/single_file.002123154.tif"
+  FileUtils.touch(single_file_seq)
+  
+  FileUtils.mkdir_p(TEST_DIR + "/natural_numbering")
+  nat_seq = TEST_DIR + "/natural_numbering/somefiles %d.png"
+  
+  (5545142...5545172).each do | i |
+    FileUtils.touch(nat_seq % i)
+  end
+  
+  FileUtils.mkdir_p(TEST_DIR + "/many_seqs")
+  (458..512).each do | i |
+    FileUtils.touch(TEST_DIR + "/many_seqs/seq1.%d.tif" % i)
+  end
+  
+  (228..312).each do | i |
+    FileUtils.touch(TEST_DIR + "/many_seqs/anotherS %d.tif" % i)
+  end
+  FileUtils.touch(TEST_DIR + "/many_seqs/single.tif")
+  $emitted = true
+end
+
+def teardown_test_dirs
+  FileUtils.rm_rf(TEST_DIR)
+end
+
+context "Sequencer.glob_and_padding_for should" do
+  
+  specify "return proper glob pattern and padding for a path with extension" do
+    glob, pad = Sequencer.glob_and_padding_for("file.00001.gif")
+    glob.should.equal "file.[0-9][0-9][0-9][0-9][0-9].gif"
+    pad.should.equal 5
+  end
+
+  specify "return proper glob pattern and padding for a path without extension" do
+    glob, pad = Sequencer.glob_and_padding_for("file.00001")
+    glob.should.equal "file.[0-9][0-9][0-9][0-9][0-9]"
+    pad.should.equal 5
+  end
+  
+  specify "return nil for a file that is not a sequence" do
+     glob, pad = Sequencer.glob_and_padding_for("file")
+     glob.should.be.nil
+  end
+end
+
+context "Sequencer.entries should" do
+  before { emit_test_dirs }
+  after { teardown_test_dirs }
+  specify "return entries for every sequence in a directory" do
+    entries = Sequencer.entries(TEST_DIR + "/many_seqs")
+  end
+end
+
+context "A Sequence created from unpadded files should" do
+  before { emit_test_dirs }
+  after { teardown_test_dirs }
+  
+  specify "be properly created" do
+    s = Sequencer.from_single_file(TEST_DIR + "/natural_numbering/somefiles 5545168.png")
+    s.should.not.be.nil
+    s.expected_frames.should.equal 30
+    s.file_count.should.equal 30
+    s.pattern.should.equal "somefiles %07d.png"
+  end
+end
+
+context "A Sequence created from a file that has no numbering slot should" do
+  before { @single = Sequencer::Sequence.new("/tmp", ["foo.tif"]) }
+  
+  specify "report a pattern that is the same as filename" do
+    @single.pattern.should.equal "foo.tif"
+    @single.should.be.single_file?
+    @single.expected_frames.should.equal 1
+    @single.inspect.should.equal "#<foo.tif>"
+  end
+end
+
+context "A Sequence created from pad-numbered files should" do
+  before do
+    emit_test_dirs
+    @gapless = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/seq1.000245.tif")
+    @with_gaps = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/broken_seq.000245.tif")
+    @single = Sequencer.from_single_file(TEST_DIR + "/sequence_and_sole_file/single_file.002123154.tif")
+  end
+  
+  after { teardown_test_dirs }
+  
+  specify "initialize itself from one path to a file in the sequence without gaps" do
+    @gapless.should.not.be.nil
+    @gapless.should.be.kind_of(Sequencer::Sequence)
+    @gapless.should.respond_to(:gaps?)
+    @gapless.should.not.be.single_file?
+    
+    @gapless.should.blaming("this is a gapless sequence").not.be.gaps?
+    @gapless.file_count.should.blaming("actual file count in sequence").equal(446)
+    @gapless.expected_frames.should.blaming("expected frame count in sequence").equal(446)
+    @gapless.inspect.should.blaming("inspect itself").equal('#<seq1.[123..568].tif>')
+    @gapless.pattern.should.equal 'seq1.%06d.tif'
+    files = @gapless.map {|f| f }
+    files.length.should.equal 446
+    files[0].should.equal 'seq1.000123.tif'
+  end
+  
+  specify "initialize itself from one path to a file in the sequence with gaps" do
+    @with_gaps.should.not.be.nil
+    @with_gaps.should.be.kind_of(Sequencer::Sequence)
+    @with_gaps.should.not.be.single_file?
+    
+    @with_gaps.should.be.gaps?
+    @with_gaps.gap_count.should.equal 1
+    @with_gaps.missing_frames.should.equal(9)
+    @with_gaps.inspect.should.blaming("inspect itself").equal('#<broken_seq.[123..568, 578..702].tif>')
+    @with_gaps.should.include("broken_seq.000123.tif")
+    @with_gaps.should.not.include("bogus.123.tif")
+  end
+  
+  specify "initialize itself from a single file" do
+    @single.should.be.single_file?
+    @single.inspect.should.equal '#<single_file.002123154.tif>'
+    @single.should.not.be.gaps?
+    @single.expected_frames.should.equal 1
+    @single.file_count.should.equal 1
+  end
+  
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: sequencer
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-13 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-spec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: Simplifies working with image sequences
+email: 
+- me@julik.nl
+executables: 
+- seqls
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/seqls
+- lib/sequencer.rb
+- test/test_sequencer.rb
+has_rdoc: true
+homepage: http://guerilla-di.org/sequencer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sequencer
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simplifies working with image sequences
+test_files: 
+- test/test_sequencer.rb