tracksperanto 1.1.1 → 1.2.0

data/lib/import/shake_script.rb

@@ -1,128 +1,214 @@
-require 'strscan'
+require File.dirname(__FILE__) + "/shake_grammar/lexer"
+require File.dirname(__FILE__) + "/shake_grammar/catcher"
 
 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
+  def self.human_name
+    "Shake .shk script file"
   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
+  
+  def self.distinct_file_ext
+    ".shk"
   end
-
-  class CurveParser < SloppyParser
-    BLOCK_ENDS = /\d,|\)/
+  
+  class Traxtractor < Tracksperanto::ShakeGrammar::Catcher
+    include Tracksperanto::ZipTuples
     
-    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
+    class << self
+      attr_accessor :accumulator
+      attr_accessor :progress_block
+    end
+    
+    self.accumulator = []
+    
+    # For Linear() curve calls. If someone selected JSpline or Hermite it's his problem.
+    # We put the frame number at the beginning since it works witih oru tuple zipper
+    def linear(first_arg, *keyframes)
+      report_progress("Translating Linear animation")
+      keyframes.map do | kf |
+        [kf[1][1], kf[0][1]]
       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
+    # image Tracker( 
+    #   image In,
+    #   const char * trackRange,
+    #   const char * subPixelRes,
+    #   const char * matchSpace,
+    #   float referenceTolerance,
+    #   const char * referenceBehavior,
+    #   float failureTolerance,
+    #   const char * failureBehavior,
+    #   int limitProcessing,
+    #   float referencFrame 
+    #   ...
+    #  );  
+    def tracker(input, trackRange, subPixelRes, matchSpace,
+        referenceTolerance, referenceBehavior, failureTolerance, failureBehavior, limitProcessing, referencFrame, s1, s2,
+        s3, s4, s5, s6, *trackers)
       
-      # Grab the curves
-      @x_curve, @y_curve, @c_curve = (0..2).map{ CurveParser.new(scan_until('),')).values }
+      report_progress("Parsing Tracker node")
+      collect_trackers_from(get_variable_name, trackers)
+      true
+    end
+    
+    # stabilize {
+    #   image In,
+    #   int applyTransform,
+    #   int inverseTransform
+    #   const char * trackType,
+    #   float track1X,
+    #   float track1Y,
+    #   int stabilizeX,
+    #   int stabilizeY,
+    #   float track2X,
+    #   float track2Y,
+    #   int matchScale,
+    #   int matchRotation,
+    #   float track3X,
+    #   float track3Y,
+    #   float track4X,
+    #   float track4Y,
+    #   const char * xFilter,
+    #   const char * yFilter,
+    #   const char * transformationOrder,
+    #   float motionBlur, 
+    #   float shutterTiming,
+    #   float shutterOffset,
+    #   float referenceFrame,
+    #   float aspectRatio,
+    #   ...
+    # };
+    def stabilize(imageIn, applyTransform, inverseTransform, trackType,
+      track1X, track1Y,
+      stabilizeX, stabilizeY,
+      track2X, track2Y,
+      matchScale,
+      matchRotation,
+      track3X, track3Y,
+      track4X, track4Y,
+      *useless_args)
       
-      # if the next argument is an integer, we reached the end of the tracks. If not - make a nested one.
+      report_progress("Parsing Stabilize node")
+      node_name = get_variable_name
+      collect_stabilizer_tracker("#{node_name}_track1", track1X, track1Y)
+      collect_stabilizer_tracker("#{node_name}_track2", track2X, track2Y)
+      collect_stabilizer_tracker("#{node_name}_track3", track3X, track3Y)
+      collect_stabilizer_tracker("#{node_name}_track4", track4X, track4Y)
     end
     
-    def curves
-      [@x_curve, @y_curve, @c_curve]
+    #  image = MatchMove( 
+    #    Background,
+    #    Foreground,
+    #    applyTransform,
+    #    "trackType",
+    #    track1X,
+    #    track1Y,
+    #    matchX,
+    #    matchY,
+    #    track2X,
+    #    track2Y,
+    #    scale,
+    #    rotation,
+    #    track3X,
+    #    track3Y,
+    #    track4X,
+    #    track4Y,
+    #    x1, 
+    #    y1,
+    #    x2,
+    #    y2,
+    #    x3,
+    #    y3,
+    #    x4,
+    #    y4,
+    #    "xFilter",
+    #    "yFilter",
+    #    motionBlur, 
+    #    shutterTiming,
+    #    shutterOffset,
+    #    referenceFrame,
+    #    "compositeType",
+    #    clipMode,
+    #   "trackRange",
+    #    "subPixelRes",
+    #    "matchSpace",
+    #    float referenceTolerance,
+    #    "referenceBehavior",
+    #    float failureTolerance,
+    #    "failureBehavior",
+    #    int limitProcessing,
+    #    ...
+    #  );
+    def matchmove(bgImage, fgImage, applyTransform,
+      trackType,
+      track1X,
+      track1Y,
+      matchX,
+      matchY,
+      track2X,
+      track2Y,
+      scale,
+      rotation,
+      track3X,
+      track3Y,
+      track4X,
+      track4Y, *others)
+      
+      report_progress("Parsing MatchMove node")
+      node_name = get_variable_name
+      collect_stabilizer_tracker("#{node_name}_track1", track1X, track1Y)
+      collect_stabilizer_tracker("#{node_name}_track2", track2X, track2Y)
+      collect_stabilizer_tracker("#{node_name}_track3", track3X, track3Y)
+      collect_stabilizer_tracker("#{node_name}_track4", track4X, track4Y)
+      
     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  ',' }
+    
+    private
+    
+    def report_progress(with_message)
+      self.class.progress_block.call(with_message) if self.class.progress_block
     end
-  end
-  
-  TRACKER_PATTERN = /((\w+) = Tracker\(([^;]+))/m
-  
-  def parse(sript_file_content)
     
-    trackers = []
+    def collect_trackers_from(name, array)
+      parameters_per_node = 16
+      nb_trackers = array.length / parameters_per_node
+      nb_trackers.times do | idx |
+        from_index, to_index = (idx * parameters_per_node), (idx+1) * parameters_per_node
+        tracker_args = array[from_index...to_index]
+        tracker_args[0] = "#{name}_#{tracker_args[0]}"
+        collect_tracker(*tracker_args)
+      end
+    end
     
-    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 }
+    def collect_stabilizer_tracker(name, x_curve, y_curve)
+      return if (x_curve == :unknown || y_curve == :unknown)
       
-      report_progress("Reading tracker #{tracker.name}")
+      keyframes = zip_curve_tuples(x_curve, y_curve).map do | (frame, x, y) |
+        Tracksperanto::Keyframe.new(:frame => frame - 1, :abs_x => x, :abs_y => y)
+      end
       
-      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
+      t = Tracksperanto::Tracker.new(:name => name, :keyframes => keyframes )
+      self.class.accumulator.push(t)
+    end
+    
+    def collect_tracker(name, x_curve, y_curve, corr_curve, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12)
+      report_progress("Scavenging tracker #{name}")
+      keyframes = zip_curve_tuples(x_curve, y_curve, corr_curve).map do | (frame, x, y, corr) |
+        Tracksperanto::Keyframe.new(:frame => frame - 1, :abs_x => x, :abs_y => y, :residual => (1 - corr))
       end
       
-      trackers << tracker
+      t = Tracksperanto::Tracker.new(:name => name, :keyframes => keyframes )
+      self.class.accumulator.push(t)
     end
+  end
+  
+  def parse(script_io)
+    trackers = []
+    
+    Traxtractor.accumulator = trackers
+    Traxtractor.progress_block = lambda{|msg| report_progress(msg) }
+    Traxtractor.new(script_io)
     
     trackers
   end

data/lib/import/shake_text.rb

@@ -1,10 +1,12 @@
-require 'stringio'
 
 class Tracksperanto::Import::ShakeText < Tracksperanto::Import::Base
   
-  def parse(track_file_content)
+  def self.human_name
+    "Shake .txt tracker file"
+  end
+  
+  def parse(io)
     trackers = []
-    io = StringIO.new(track_file_content)
     until io.eof?
       line = io.gets
       if line =~ /TrackName (.+)/

data/lib/import/syntheyes.rb

@@ -1,12 +1,18 @@
 class Tracksperanto::Import::Syntheyes < Tracksperanto::Import::Base
-  def parse(file_content)
+  
+  def self.human_name
+    "Syntheyes tracker export (UV) file"
+  end
+  
+  def parse(io)
     trackers = []
-    file_content.split("\n").each do | line |
+    io.each_line do | line |
       name, frame, x, y, corr = line.split
       
       # Do we already have this tracker?
       t = trackers.find {|e| e.name == name}
       if !t
+        report_progress("Allocating tracker #{name}")
         t = Tracksperanto::Tracker.new{|t| t.name = name }
         trackers << t
       end
@@ -18,6 +24,7 @@ class Tracksperanto::Import::Syntheyes < Tracksperanto::Import::Base
         e.abs_y = height - convert_from_uv(height, y) # Convert TL to BL
         e.residual = corr
       end
+      report_progress("Adding keyframe #{frame} to #{name}")
     end
     
     trackers

data/lib/middleware/base.rb

@@ -1,8 +1,13 @@
+# The base middleware class works just like a Tracksperanto::Export::Base, but it only wraps another exporting object and does not get registered on it's own
+# as an export format. Middleware can be used to massage the tracks being exported in various interesting ways - like moving the coordinates, clipping the keyframes,
+# scaling the whole export or even reversing the trackers to go backwards
 class Tracksperanto::Middleware::Base
   include Tracksperanto::Casts
+  include Tracksperanto::BlockInit
   
-  def initialize(exporter)
+  def initialize(exporter, *args_for_block_init)
     @exporter = exporter
+    super(*args_for_block_init)
   end
   
   # Called on export start

data/lib/middleware/golden.rb

@@ -1,6 +1,13 @@
+# This middleware marks all trackers as being 100% accurate
 class Tracksperanto::Middleware::Golden < Tracksperanto::Middleware::Base
   attr_accessor :enabled
+  
+  def enabled
+    @enabled || false
+  end
+  
   def export_point(frame, float_x, float_y, float_residual)
     super(frame, float_x, float_y, (enabled ? 0.0 : float_residual))
   end
+  
 end

data/lib/middleware/reformat.rb

@@ -1,8 +1,14 @@
 require File.dirname(__FILE__) + '/scaler'
 
-# Reformats (scales) the track setup to a specific pixel resolution
+# This middleware reformats (scales) the track setup to a specific pixel resolution. Very useful for
+# applying proxy tracks to full-res images
 class Tracksperanto::Middleware::Reformat < Tracksperanto::Middleware::Scaler
+  
+  # To which format we have to scale
   attr_accessor :width, :height
+  cast_to_int :width, :height
+  
+  private :x_factor=, :y_factor=
   
   # Called on export start
   def start_export( img_width, img_height)
@@ -10,7 +16,8 @@ class Tracksperanto::Middleware::Reformat < Tracksperanto::Middleware::Scaler
     @height ||= img_height
     
     self.x_factor, self.y_factor = (@width / img_width.to_f), (@height / img_height.to_f)  
-    
-    super(@width, @height)
+    set_residual_factor
+    # Do not call super since it scales by itself :-)
+    @exporter.start_export(@width, @height)
   end
 end

data/lib/middleware/scaler.rb

@@ -1,13 +1,14 @@
+# Scales the comp being exported by a specific factor, together with the tracker keyframes
 class Tracksperanto::Middleware::Scaler < Tracksperanto::Middleware::Base
   DEFAULT_FACTOR = 1
   
   attr_accessor :x_factor, :y_factor
+  cast_to_float :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))
+    set_residual_factor
+    super( (img_width * x_factor).to_i, (img_height * y_factor).to_i)
   end
   
   def y_factor
@@ -19,6 +20,15 @@ class Tracksperanto::Middleware::Scaler < Tracksperanto::Middleware::Base
   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))
+    super(frame, 
+      (float_x * x_factor), 
+      (float_y * y_factor), 
+      (float_residual * @residual_factor)
+    )
   end
+  
+  private
+    def set_residual_factor
+      @residual_factor = Math.sqrt((x_factor ** 2) + (y_factor ** 2))
+    end
 end

data/lib/middleware/shift.rb

@@ -0,0 +1,10 @@
+# This middleware moves the keyframs by a preset number of pixels
+class Tracksperanto::Middleware::Shift < Tracksperanto::Middleware::Base
+  attr_accessor :x_shift, :y_shift
+  cast_to_float :x_shift, :y_shift
+  
+  def export_point(frame, float_x, float_y, float_residual)
+    super(frame, float_x + (@x_shift || 0), float_y + (@y_shift || 0), float_residual)
+  end
+  
+end

data/lib/middleware/slipper.rb

@@ -1,6 +1,9 @@
+# Slips the keyframe positions by a specific integer amount of frames, positive values slip forward (later in time). Useful if you just edited some stuff onto
+# the beginning if your sequence and need to extend your tracks.
 class Tracksperanto::Middleware::Slipper < Tracksperanto::Middleware::Base
   DEFAULT_SLIP = 0
   attr_accessor :slip
+  cast_to_int :slip
   
   def slip
     @slip.to_i || DEFAULT_SLIP

data/lib/pipeline/base.rb

@@ -1,62 +1,113 @@
-# This is currently a bit of a mess.
-module Tracksperanto::Pipeline
-class Base
-  attr_accessor :converted_points
-  attr_accessor :converted_keyframes
+# The base pipeline is the whole process of track conversion from start to finish. The pipeline object organizes the import formats, scans them,
+# applies the default middlewares and yields them for processing. Here's how a calling sequence for a pipeline looks like:
+#
+#   pipe = Tracksperanto::Pipeline::Base.new
+#   pipe.progress_block = lambda{|percent, msg| puts("#{msg}..#{percent.to_i}%") }
+#   
+#   pipe.run(input_file, width, height, reader_klass) do | scaler, slipper, golden, reformat |
+#     golden.enabled = false
+#     reformat.width = 1024
+#     reformat.width = 576
+#   end
+#
+# The pipeline will also automatically allocate output files with the right extensions at the same place where the original file resides,
+# and setup outputs for all supported export formats. The pipeline will also report progress (with percent) using the passed progress block
+class Tracksperanto::Pipeline::Base
+  
+  # How many points have been converted. In general, the pipeline does not preserve the parsed tracker objects
+  # after they have been exported
+  attr_reader :converted_points
+  
+  # How many keyframes have been converted
+  attr_reader :converted_keyframes
+  
+  # A block acepting percent and message vars can be assigned here.
+  # When it's assigned, the pipeline will pass the status reports
+  # of all the importers and exporters to the block, together with
+  # percent complete
   attr_accessor :progress_block
   
-  def run(from_input_file_path, pix_w, pix_h, parser_class)
-    # Read the input file
-    read_data = File.read(from_input_file_path)
+  # Assign an array of exporters to use them instead of the standard ones 
+  attr_accessor :exporters
+  
+  DEFAULT_OPTIONS = {:pix_w => 720, :pix_h => 576, :parser => Tracksperanto::Import::ShakeScript }
+  
+  # Runs the whole pipeline. Accepts the following options
+  # * pix_w - The comp width, for the case that the format does not support auto size
+  # * pix_h - The comp height, for the case that the format does not support auto size
+  # * parser - The parser class, for the case that the format does not support auto size
+  
+  def run(from_input_file_path, passed_options = {})
+    pix_w, pix_h, parser_class = detect_importer_or_use_options(from_input_file_path, DEFAULT_OPTIONS.merge(passed_options))
+    
+    # Reset stats
+    @converted_keyframes, @converted_points = 0, 0
+    
+    # Grab the input
+    read_data = File.open(from_input_file_path)
     
     # Assign the parser
-    parser = create_parser(parser_class, pix_w, pix_h)
+    importer = parser_class.new(:width => pix_w, :height => pix_h)
     
     # Setup a multiplexer
     mux = setup_outputs_for(from_input_file_path)
     
-    # Setup middlewares - skip for now
-    scaler = Tracksperanto::Middleware::Scaler.new(mux)
-    slipper = Tracksperanto::Middleware::Slipper.new(scaler)
-    golden = Tracksperanto::Middleware::Golden.new(slipper)
-    reformat = Tracksperanto::Middleware::Reformat.new(golden)
+    # Setup middlewares
+    middlewares = setup_middleware_chain_with(mux)
     
     # Yield middlewares to the block
-    yield(scaler, slipper, golden, reformat) if block_given?
+    yield(*middlewares) if block_given?
     
-    @converted_points, @converted_keyframes = run_export(read_data, parser, reformat) do | p, m |
+    @converted_points, @converted_keyframes = run_export(read_data, importer, middlewares[-1]) do | p, m |
       @progress_block.call(p, m) if @progress_block
     end
   end
   
+  def detect_importer_or_use_options(path, opts)
+    d = Tracksperanto::FormatDetector.new(path)
+    if d.match? && d.auto_size?
+      return [1, 1, d.importer_klass]
+    elsif d.match?
+      raise "Width and height must be provided for a #{d.importer_klass}" unless (opts[:pix_w] && opts[:pix_h])
+      opts[:parser] = d.importer_klass
+    else
+      raise "Cannot autodetect the file format - please specify the importer explicitly" unless opts[:parser]
+      raise "Width and height must be provided for this importer" unless (opts[:pix_w] && opts[:pix_h])
+    end
+    
+    [opts[:pix_w], opts[:pix_h], opts[:parser]]    
+  end
+  
   # Runs the export and returns the number of points and keyframes processed.
   # If a block is passed, the block will receive the percent complete and the last
   # status message that you can pass back to the UI
-  # # :yields: percent_complete, status_message
-  def run_export(tracker_data_blob, parser, processor)
+  def run_export(tracker_data_io, parser, processor)
+    @ios << tracker_data_io
+    
     points, keyframes, percent_complete = 0, 0, 0.0
     
-    yield(percent_complete, "Starting the parse routine") if block_given?
+    yield(percent_complete, "Starting the parser") if block_given?
     parser.progress_block = lambda do | message |
       yield(percent_complete, message) if block_given?
     end
     
-    trackers = parser.parse(tracker_data_blob)
+    trackers = parser.parse(tracker_data_io)
     
-    yield(percent_complete = 20.0, "Starting export for #{trackers.length} trackers") if block_given?
+    validate_trackers!(trackers)
     
-    percent_per_tracker = 80.0 / trackers.length
+    yield(percent_complete = 50.0, "Parsing complete, starting export for #{trackers.length} trackers") if block_given?
     
-    # Use the width and height provided by the parser itself
-    processor.start_export(parser.width, parser.height)
+    percent_per_tracker = (100.0 - percent_complete) / trackers.length
     
     yield(percent_complete, "Starting export") if block_given?
     
+    # Use the width and height provided by the parser itself
+    processor.start_export(parser.width, parser.height)
     trackers.each do | t |
       kf_weight = percent_per_tracker / t.keyframes.length
       points += 1
       processor.start_tracker_segment(t.name)
-      t.keyframes.each do | kf |
+      t.each do | kf |
         keyframes += 1
         processor.export_point(kf.frame, kf.abs_x, kf.abs_y, kf.residual)
         yield(percent_complete += kf_weight, "Writing keyframe") if block_given?
@@ -68,24 +119,47 @@ class Base
     yield(100.0, "Wrote #{points} points and #{keyframes} keyframes") if block_given?
     
     [points, keyframes]
+  ensure
+    @ios.reject!{|e| e.close unless (!e.respond_to?(:closed?) || e.closed?) } if @ios
   end
   
-  def create_parser(parser_class, w, h)
-    p = parser_class.new
-    p.width, p.height = w, h
-    p
-  end
-  
+  # Setup output files and return a single output
+  # that replays to all of them
   def setup_outputs_for(input_file_path)
     file_name = File.basename(input_file_path).gsub(/\.([^\.]+)$/, '')
+    export_klasses = exporters || Tracksperanto.exporters    
     Tracksperanto::Export::Mux.new(
-      Tracksperanto.exporters.map do | exporter_class |
-        export_name = "%s_%s" % [file_name, exporter_class.desc_and_extension]
-        export_path = File.dirname(input_file_path) + '/' + export_name
-        exporter = exporter_class.new(File.open(export_path, 'w'))
-        Tracksperanto::Middleware::Close.new(exporter)
+      export_klasses.map do | exporter_class |
+        export_name = [file_name, exporter_class.desc_and_extension].join("_")
+        export_path = File.join(File.dirname(input_file_path), export_name)
+        exporter = exporter_class.new(open_owned_export_file(export_path))
       end
     )
   end
-end
+  
+  # Setup and return the output multiplexor wrapped in all necessary middlewares.
+  # Middlewares must be returned in an array to be passed to the configuration block
+  # afterwards
+  def setup_middleware_chain_with(output)
+    scaler = Tracksperanto::Middleware::Scaler.new(output)
+    slipper = Tracksperanto::Middleware::Slipper.new(scaler)
+    golden = Tracksperanto::Middleware::Golden.new(slipper)
+    reformat = Tracksperanto::Middleware::Reformat.new(golden)
+    shift = Tracksperanto::Middleware::Shift.new(reformat)
+    [scaler, slipper, golden, reformat, shift]
+  end
+  
+  # Open the file for writing and register it to be closed automatically
+  def open_owned_export_file(path_to_file)
+    @ios ||= []
+    handle = File.open(path_to_file, "w")
+    @ios << handle
+    handle
+  end
+  
+  # Check that the trackers made by the parser are A-OK
+  def validate_trackers!(trackers)
+    raise "Could not recover any trackers from this file. Wrong import format maybe?" if trackers.empty?
+    trackers.reject!{|t| t.empty? }
+  end
 end