finishm 0.0.1

data/lib/assembly/velvet_c_binding.rb

@@ -0,0 +1,54 @@
+require 'ffi'
+
+class Bio::FinishM::VelvetCBinding
+  extend FFI::Library
+  include Bio::FinishM::Logging
+
+  ffi_lib File.join(File.dirname(__FILE__),'..','external','libfinishm.so.1.0')
+
+  ############## ProbeNodeFinding ##################################
+  # IDnum* extract_best_probe_reads(Graph* graph, IDnum* probeReadIDs, IDnum numProbeReads);
+  attach_function :extract_best_probe_reads, [:pointer, :pointer, :int32], :pointer
+
+  ############## ReadToNode ##################################
+  #   typedef struct {
+  #   IDnum read_id;
+  #   IDnum node_id;
+  # } ReadIdNodeId; //this is a doubly used structure, once for creation of the data structure, and also in the result of the indexation. This is a little bad, but eh.
+  class ReadIdNodeIdStruct < FFI::Struct
+    layout :read_id, :int32,
+    :node_id, :int32
+  end
+
+  # typedef struct {
+  #   IDnum num_contents;
+  #   IDnum num_reads;
+  #   IDnum* index;
+  #   ReadIdNodeId* contents;
+  # } ReadIdToNodeIdLookupTable;
+  class ReadIdToNodeIdLookupTableStruct < FFI::Struct
+    layout :num_contents, :int32,
+    :num_reads, :int32,
+    :index, :pointer,
+    :contents, :pointer
+  end
+
+  # typedef struct {
+  #   IDnum num_nodes;
+  #   ReadIdNodeId* read_ids_node_ids;
+  # } ReadIdToNodeIdIndexation;
+  class ReadIdToNodeIdIndexationStruct < FFI::Struct
+    layout :num_nodes, :int32,
+    :read_ids_node_ids, ReadIdNodeIdStruct.ptr
+  end
+
+  # ReadIdToNodeIdIndexation getReadIdToNodeIdIndexation(ReadIdToNodeIdLookupTable* lookupTable, IDnum readID);
+  attach_function :getReadIdToNodeIdIndexation, [:pointer, :int32], ReadIdToNodeIdIndexationStruct.by_value
+  alias_method :get_read_id_to_node_id_indexation, :getReadIdToNodeIdIndexation
+
+  # ReadIdToNodeIdLookupTable* readReadIdToNodeIdLookupTable(char* fileName);
+  attach_function :readReadIdToNodeIdLookupTable, [:string], :pointer
+  alias_method :read_read_id_to_node_id_lookup_table, :readReadIdToNodeIdLookupTable
+end
+
+

data/lib/assembly/velvet_graph_sequence_extractor.rb

@@ -0,0 +1,123 @@
+require 'bio-velvet'
+require 'bio'
+
+module Bio
+  module AssemblyGraphAlgorithms
+    class GraphWalkingException < Exception; end
+
+    # A class to extract the sequence of a trail of nodes, in a very lazy, give up easily,
+    # kind of way, whenever things get too complicated. This class will throw its hands in
+    # the air (by raising and GraphWalkingException) when both ends of the one node connect
+    # to an adjacent node on the trail.
+    #
+    # Hopefully this method should be sufficient for most cases. It might be improved by
+    # using a fancier algorithm that considers more than two nodes at a time.
+    class LazyGraphWalker
+      # Given a list of nodes, one that Node objects when the #each method is called,
+      # Return the sequence (as a plain string) of the nodes concatenated together,
+      # being cogent of the directionality of the arcs between the nodes.
+      #
+      # This may not be straightforward, particularly in the presence of palindromic
+      # nodes. If any difficulties are encountered, a GraphWalkingException is thrown.
+      def trail_sequence(velvet_graph, ordered_collection_of_nodes)
+        seq = ''
+        last_node = nil
+        last_node_used_up_end = nil
+        state = :first
+        log = Bio::Log::LoggerPlus['finishm']
+
+        add_first_node_forward = lambda do |first_node|
+          seq += first_node.sequence
+        end
+        add_first_node_reverse = lambda do |first_node|
+          seq += revcom first_node.sequence
+        end
+
+        ordered_collection_of_nodes.each do |node|
+          if last_node.nil?
+            # First node in the trail, can't figure it out here
+            last_node = node
+            state = :second
+          else
+            # Now there is two nodes in the frame. What is the edge between them, in terms of its direction?
+            arcs = velvet_graph.get_arcs_by_node(last_node, node)
+
+            if arcs.empty?
+              raise GraphWalkingException, "Attempted to find trail between two unconnected nodes: #{last_node.inspect}, #{node.inspect}"
+            elsif arcs.length > 1
+              raise GraphWalkingException, "Two adjacent nodes in the graph are (at least) doubly connected too each other, LazyGraphWalker is throwing its hands in the air. Nodes are (in the same order as the specified trail) #{last_node.inspect}, #{node.inspect}"
+
+            # There is a link previous => current, the easy case
+            else
+              arc = arcs[0]
+              # Add the first node, if we are adding the second
+              if state == :second
+                state = :after_second
+                log.debug "Adding start node from arc #{arc}, first_node_id=#{last_node.node_id}, second_node_id=#{node.node_id}" if log and log.debug?
+                if arc.connects_end_to_beginning?(last_node.node_id, node.node_id)
+                  log.debug "Adding end to beginning" if log and log.debug?
+                  add_first_node_forward.call last_node
+                  last_node_used_up_end = :start
+                elsif arc.connects_end_to_end?(last_node.node_id, node.node_id)
+                  log.debug "Adding end to end" if log and log.debug?
+                  add_first_node_forward.call last_node
+                  last_node_used_up_end = :start
+                elsif arc.connects_beginning_to_beginning?(last_node.node_id, node.node_id)
+                  log.debug "Adding beginning to beginning" if log and log.debug?
+                  add_first_node_reverse.call last_node
+                  last_node_used_up_end = :end
+                elsif arc.connects_beginning_to_end?(last_node.node_id, node.node_id)
+                  log.debug "Adding beginning to end" if log and log.debug?
+                  add_first_node_reverse.call last_node
+                  last_node_used_up_end = :end
+                else
+                  raise "Programming error"
+                end
+              end
+              log.debug "At crossroads, with node_id=#{node.node_id}, last_node_used_up_end=#{last_node_used_up_end}, arc=#{arc}" if log and log.debug?
+
+              # Add the new node's sequence
+              if state == :after_second
+                if arc.connects_end_to_beginning?(last_node.node_id, node.node_id) and last_node_used_up_end == :start
+                  log.debug "Adding end to beginning" if log and log.debug?
+                  seq += node.ends_of_kmers_of_node
+                  last_node_used_up_end = :start
+                elsif arc.connects_end_to_end?(last_node.node_id, node.node_id) and last_node_used_up_end == :start
+                  log.debug "Adding end to end" if log and log.debug?
+                  seq += node.ends_of_kmers_of_twin_node
+                  last_node_used_up_end = :end
+                elsif arc.connects_beginning_to_beginning?(last_node.node_id, node.node_id) and last_node_used_up_end == :end
+                  log.debug "Adding beginning to beginning" if log and log.debug?
+                  seq += node.ends_of_kmers_of_node
+                  last_node_used_up_end = :start
+                elsif arc.connects_beginning_to_end?(last_node.node_id, node.node_id) and last_node_used_up_end == :end
+                  log.debug "Adding beginning to end" if log and log.debug?
+                  seq += node.ends_of_kmers_of_twin_node
+                  last_node_used_up_end = :end
+                else
+                  raise GraphWalkingException, "The trail being followed to create the trail sequence isn't continuous in a consistent direction. Failed at node #{node.node_id}. last_node_used_up_end=#{last_node_used_up_end}, arc=#{arc}"
+                end
+              else
+                raise "Programming error in state machine"
+              end
+            end
+            last_node = node
+          end
+        end
+        return '' if last_node.nil? #Return nothing when an empty collection is given.
+
+        # When only 1 node is given, return that node's sequence in arbitrary orientation
+        if state == :second
+          return last_node.sequence
+        else
+          return seq
+        end
+      end
+
+      private
+      def revcom(seq)
+        Bio::Sequence::NA.new(seq).reverse_complement.to_s.upcase
+      end
+    end
+  end
+end

data/lib/external/VERSION

@@ -0,0 +1 @@
+1

data/lib/finishm/assemble.rb

@@ -0,0 +1,224 @@
+class Bio::FinishM::Assembler
+  include Bio::FinishM::Logging
+
+  def add_options(optparse_object, options)
+    optparse_object.banner = "\nUsage: finishm assemble --assemble-from <node_shorthand> --output-contigs <output.fa> <assembly_definition>
+
+    Assemble
+    \n\n"
+
+    options.merge!({
+      :output_pathspec => false,
+      :progressbar => true,
+      :min_contig_size => 500,
+      :bubbly => false,
+      :max_tip_length => Bio::AssemblyGraphAlgorithms::BubblyAssembler::DEFAULT_MAX_TIP_LENGTH,
+      :max_bubble_length => Bio::AssemblyGraphAlgorithms::BubblyAssembler::DEFAULT_MAX_BUBBLE_LENGTH,
+      :bubble_node_count_limit => Bio::AssemblyGraphAlgorithms::BubblyAssembler::DEFAULT_BUBBLE_NODE_COUNT_LIMIT,
+      :min_confirming_recoherence_kmer_reads => Bio::AssemblyGraphAlgorithms::SingleEndedAssembler::DEFAULT_MIN_CONFIRMING_RECOHERENCE_READS,
+    })
+
+    optparse_object.separator "\nRequired arguments:\n\n"
+    optparse_object.on("--output-contigs PATH", "Output found paths to this file in fasta format [required]") do |arg|
+      options[:output_trails_file] = arg
+    end
+    optparse_object.separator "\nThere must be some definition of reads too:\n\n" #TODO improve this help
+    Bio::FinishM::ReadInput.new.add_options(optparse_object, options)
+
+    optparse_object.separator "\nOptional arguments:\n\n"
+    optparse_object.on("--assemble-from SHORTHAND", "Specify the node and direction to start assembing from e.g. '3s' to start forward from node 3, '4e' to start reverse from node 4 [default: assemble the entire graph]") do |arg|
+      unless arg.match(/^\d+[se]+/)
+        raise "Unable to parse node shorthand #{arg}"
+      end
+      options[:initial_node_shorthand] = arg
+    end
+    optparse_object.on("--recoherence-kmer LENGTH", Integer, "When paths diverge, try to rescue by using a bigger kmer of this length [default: none]") do |arg|
+      options[:recoherence_kmer] = arg
+    end
+    optparse_object.on("--recoherence-min-reads NUM", Integer, "Number of reads required to agree with recoherence [default: #{options[:min_confirming_recoherence_kmer_reads] } (when --recoherence-kmer is specified)]") do |arg|
+      options[:min_confirming_recoherence_kmer_reads] = arg
+    end
+    optparse_object.on("--max-tip-length LENGTH", Integer, "Maximum length of 'tip' in assembly graph to ignore [default: #{options[:max_tip_length] }]") do |arg|
+      options[:max_tip_length] = arg
+    end
+    optparse_object.on("--bubbly", "Assemble with the bubbly method [default: #{options[:bubbly] }]") do
+      options[:bubbly] = true
+    end
+    optparse_object.on("--max-bubble-size NUM", Integer, "Max bubble size available for bubbly method [default: #{options[:max_bubble_length] }]") do |arg|
+      options[:max_bubble_length] = arg
+    end
+    optparse_object.on("--max-bubble-complexity NUM", Integer, "Max number of nodes in a bubble to explore before giving up (0 for infinite) [default: #{options[:bubble_node_count_limit] }]") do |arg|
+      if arg == 0
+        options[:bubble_node_count_limit] = nil
+      else
+        options[:bubble_node_count_limit] = arg
+      end
+    end
+    optparse_object.on("--output-pathspec", "Give the sequence of nodes used in the path in the output contig file [default: #{options[:output_pathspec] }]") do
+      options[:output_pathspec] = true
+    end
+    optparse_object.on("--output-contig-stats FILE", "Output stats about each contig to this file [default: don't output anything]") do |arg|
+      options[:output_stats] = arg
+    end
+    optparse_object.on("--no-progressbar", "Don't show a progress bar [default: do show one unless --assemble-from is specified]") do
+      options[:progressbar] = false
+    end
+    optparse_object.on("--min-contig-length LENGTH",Integer,"Don't print contigs shorter than this [default: #{options[:min_contig_size] }]") do |arg|
+      options[:min_contig_size] = arg
+    end
+    optparse_object.on("--min-starting-node-coverage COVERAGE",Float,"Only start exploring from nodes with at least this much coverage [default: start from all nodes]") do |arg|
+      options[:min_coverage_of_start_nodes] = arg
+    end
+    optparse_object.on("--min-starting-node-length LENGTH",Integer,"Only start exploring from nodes with at least this length [default: start from all nodes]") do |arg|
+      options[:min_length_of_start_nodes] = arg
+    end
+    optparse_object.on("--max-coverage-at-fork COVERAGE",Float,"When reached a fork, don't take paths with more than this much coverage [default: not applied]") do |arg|
+      options[:max_coverage_at_fork] = arg
+    end
+    optparse_object.on("--badformat FILE", "Output contigs in badformat file") do |arg|
+      options[:output_badformat_file] = arg
+    end
+    optparse_object.on("--debug", "Build the graph, then drop to a pry console. [default: #{options[:debug] }]") do
+      options[:debug] = true
+    end
+
+    Bio::FinishM::GraphGenerator.new.add_options optparse_object, options
+  end
+
+  def validate_options(options, argv)
+    #TODO: give a better description of the error that has occurred
+    #TODO: require reads options
+    if argv.length != 0
+      return "Dangling argument(s) found e.g. #{argv[0]}"
+    else
+      [
+        :output_trails_file,
+      ].each do |sym|
+        if options[sym].nil?
+          return "No option found to specify #{sym}."
+        end
+      end
+
+      # Need reads unless there is already an assembly
+      unless options[:previous_assembly] or options[:previously_serialized_parsed_graph_file]
+        error = Bio::FinishM::ReadInput.new.validate_options(options, [])
+        return error unless error.nil?
+      else
+        return nil
+      end
+    end
+  end
+
+  def run(options, argv)
+    # Generate the graph
+    read_input = Bio::FinishM::ReadInput.new
+    read_input.parse_options options
+
+    finishm_graph = nil
+    if options[:recoherence_kmer].nil?
+      finishm_graph = Bio::FinishM::GraphGenerator.new.generate_graph([], read_input, options.merge({
+        :dont_parse_reads => true,
+        :dont_parse_noded_reads => true,
+        }))
+    else
+      finishm_graph = Bio::FinishM::GraphGenerator.new.generate_graph([], read_input, options)
+    end
+    graph = finishm_graph.graph
+
+    if options[:initial_node_shorthand]
+      # Just check the shorthand is ok before the time consuming task of reading in more data
+      Bio::Velvet::Graph::OrientedNodeTrail.create_from_shorthand(options[:initial_node_shorthand], graph)
+    end
+
+    # Setup assembler
+    assembler = nil
+    if options[:bubbly]
+      assembler = Bio::AssemblyGraphAlgorithms::BubblyAssembler.new graph
+    else
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+    end
+    [
+      :recoherence_kmer,
+      :min_confirming_recoherence_kmer_reads,
+      :min_contig_size,
+      :min_coverage_of_start_nodes,
+      :min_length_of_start_nodes,
+      :max_tip_length,
+      :leash_length,
+      :max_bubble_length,
+      :bubble_node_count_limit,
+      :max_coverage_at_fork,
+      ].each do |opt|
+        assembler.assembly_options[opt] = options[opt]
+      end
+    assembler.assembly_options[:sequences] = finishm_graph.velvet_sequences
+
+    binding.pry if options[:debug]
+
+    if options[:initial_node_shorthand]
+      initial_trail = Bio::Velvet::Graph::OrientedNodeTrail.create_from_shorthand(options[:initial_node_shorthand], graph)
+      log.info "Starting to assemble from specified initial node #{initial_trail.to_shorthand}.."
+      path, visited_nodes = assembler.assemble_from(initial_trail)
+
+      name = options[:initial_node_shorthand]
+      name += " #{path.to_shorthand}" if options[:output_pathspec]
+
+      File.open(options[:output_trails_file],'w') do |output|
+        output.puts ">#{name}"
+        output.puts path.sequence
+      end
+
+      if options[:output_badformat_file]
+        log.info "Writing badformat file to #{options[:output_badformat_file] }" if log.info?
+
+        File.open(options[:output_badformat_file],'w') do |out|
+          badformat = Bio::FinishM::BadFormatWriter.new
+          badformat.add_metapath(name, path)
+          badformat.write out
+        end
+      end
+    else
+
+      log.info "Attempting to assemble the entire graph"
+      contig_count = 0
+      stats_output = nil
+      if options[:output_stats]
+        stats_output = File.open(options[:output_stats],'w')
+        stats_output.puts %w(name coverage).join("\t")
+      end
+      badformat_writer = Bio::FinishM::BadFormatWriter.new
+      File.open(options[:output_trails_file],'w') do |output|
+        progress_io = options[:progressbar] ? $stdout : nil
+        assembler.assembly_options[:progressbar_io] = progress_io
+        assembler.assemble do |path|
+          contig_count += 1
+          name = "contig#{contig_count}"
+          output.print ">#{name}"
+          if options[:output_pathspec]
+            output.print " #{path.to_shorthand}"
+          end
+          output.puts
+          output.puts path.sequence
+
+          if !stats_output.nil?
+            stats_output.puts [
+              name,
+              path.length_in_bp,
+              path.coverage,
+              ].join("\t")
+          end
+
+          badformat_writer.add_metapath(name, path) if options[:output_badformat_file]
+        end
+      end
+      if options[:output_badformat_file]
+        log.info "Writing badformat file to #{options[:output_badformat_file] }" if log.info?
+        File.open(options[:output_badformat_file],'w') do |out|
+          badformat_writer.write out
+        end
+      end
+      log.info "Assembled #{contig_count} contigs"
+      stats_output.close if !stats_output.nil?
+    end
+  end
+end

data/lib/finishm/explore.rb

@@ -0,0 +1,217 @@
+class Bio::FinishM::Explorer
+  include Bio::FinishM::Logging
+
+  class InterestingPlace
+    attr_accessor :contig_name, :start_or_end
+
+    def to_s
+      "#{@contig_name}:#{@start_or_end}"
+    end
+  end
+
+  def add_options(optparse_object, options)
+    optparse_object.banner = "\nUsage: finishm explore --contigs <contig_file> --interesting-ends <contig1:end,contig2:start,..> --fastq-gz <reads..> --output-explored-paths <output.fa>
+
+    Given a contig end, explore the assembly graph to determine what is out there. Does assembly
+    fail because of lack of coverage? Is there more sequence out there that has yet to be explored?
+    \n\n"
+
+    options.merge!({
+      :contig_end_length => 200,
+      :graph_search_leash_length => 20000,
+    })
+
+    optparse_object.separator "\nRequired arguments:\n\n"
+    optparse_object.on("--contigs FILE", "Fasta file containing contigs to find the fluff on [required]") do |arg|
+      options[:contigs_file] = arg
+    end
+    optparse_object.on("--interesting-ends INTERESTING_PLACES", Array, "Comma-separated list of places to explore from e.g. 'contig1:end,MyContig2:start' to explore from the end of contig1 and the start of MyContig2. Names of contigs are as they are in the given --contigs file. Or use 'all' to mean all contig ends in the fasta file [required]") do |arg|
+      if arg == ['all']
+        options[:interesting_places] = :all
+      else
+        arg.each do |tuple|
+          options[:interesting_places] ||= []
+          splits = tuple.split(':')
+          if splits.length != 2
+            log.error "Unable to parse this --interesting-ends argument: #{tuple}"
+            exit 1
+          end
+          place = InterestingPlace.new
+          place.contig_name = splits[0]
+          if %(start end).include?(splits[1])
+            place.start_or_end = splits[1]
+          else
+            log.error "Unable to parse this --interesting-ends argument, second half must be 'start' or 'end': #{tuple}"
+            exit 1
+          end
+          options[:interesting_places].push place
+        end
+      end
+    end
+    optparse_object.on("--output-explored-paths PATH", "Output found paths to this file in fasta format [required]") do |arg|
+      options[:output_trails_file] = arg
+    end
+    optparse_object.separator "\nThere must be some definition of reads too:\n\n" #TODO improve this help
+    Bio::FinishM::ReadInput.new.add_options(optparse_object, options)
+
+    optparse_object.separator "\nOptional arguments:\n\n"
+    optparse_object.on("--overhang NUM", Integer, "Start assembling this far from the ends of the contigs [default: #{options[:contig_end_length]}]") do |arg|
+      options[:contig_end_length] = arg.to_i
+    end
+    optparse_object.on("--unscaffold-first", "Break the scaffolds in the contigs file apart, and then wander between the resultant contigs[default: #{options[:graph_search_leash_length]}]") do |arg|
+      options[:unscaffold_first] = true
+    end
+    optparse_object.on("--leash-length NUM", Integer, "Don't explore too far in the graph, only this far and not much more [default: #{options[:graph_search_leash_length]}]") do |arg|
+      options[:graph_search_leash_length] = arg
+    end
+
+    Bio::FinishM::GraphGenerator.new.add_options optparse_object, options
+  end
+
+  def validate_options(options, argv)
+    #TODO: give a better description of the error that has occurred
+    #TODO: require reads options
+    if argv.length != 0
+      return "Dangling argument(s) found e.g. #{argv[0]}"
+    else
+      [
+        :contigs_file,
+        :interesting_places,
+        :output_trails_file,
+      ].each do |sym|
+        if options[sym].nil?
+          return "No option found to specify #{sym}."
+        end
+      end
+
+      # Need reads unless there is already an assembly
+      unless options[:previous_assembly] or options[:previously_serialized_parsed_graph_file]
+        error = Bio::FinishM::ReadInput.new.validate_options(options, [])
+        return error unless error.nil?
+        if options[:contig_end_length] < options[:velvet_kmer_size]
+          return "The overhang must be greater than the size of the assembly kmer"
+        else
+          return nil
+        end
+      else
+        return nil
+      end
+    end
+  end
+
+  def run(options, argv)
+    # Read in all the contigs sequences, removing those that are too short
+    probe_sequences = []
+    sequence_names = []
+    interesting_place_probe_indices = []
+    process_sequence = lambda do |name,seq|
+      if seq.length < 2*options[:contig_end_length]
+        log.warn "Not attempting to make connections from this contig, as it is overly short: #{name}"
+        next
+      end
+      if sequence_names.include?(name)
+        log.error "Found duplicate sequence names, being conservative and not continuuing #{name}"
+        exit 1
+      end
+      sequence_names.push name
+
+      sequence = seq.seq
+      fwd2 = Bio::Sequence::NA.new(sequence[0...options[:contig_end_length]])
+      probe_sequences.push fwd2.reverse_complement.to_s
+
+      probe_sequences.push sequence[(sequence.length-options[:contig_end_length])...sequence.length]
+    end
+
+    scaffolds = nil
+    if options[:unscaffold_first]
+      log.info "Unscaffolding scaffolds (before trying to connect them together again)"
+      scaffolds = Bio::FinishM::ScaffoldBreaker.new.break_scaffolds options[:contigs_file]
+      scaffolds.each do |scaffold|
+        scaffold.contigs.each do |contig|
+          process_sequence.call contig.name, contig.sequence
+        end
+      end
+    else
+      Bio::FlatFile.foreach(options[:contigs_file]) do |s|
+        process_sequence.call s.definition, s.seq
+      end
+    end
+
+    # Collect the node IDs that I'm interested in before generating the graph so don't have to do a whole assembly before getting an argument error
+    interesting_probe_ids_to_place = {}
+    if options[:interesting_places] == :all
+      options[:interesting_places] = []
+      base = 0
+      sequence_names.each_with_index do |name, i|
+        %w(start end).each do |side|
+          place = InterestingPlace.new
+          place.start_or_end = side
+          place.contig_name = name
+          options[:interesting_places].push place
+
+          interesting_probe_ids_to_place[base] = place
+          base += 1
+        end
+      end
+    else
+      options[:interesting_places].each do |place|
+        seq_index = sequence_names.find_index place.contig_name
+        if seq_index.nil?
+          log.error "Unable to find interesting contig #{place.contig_name}, cannot continue"
+          exit 1
+        else
+          base = seq_index*2
+          if place.start_or_end == 'start'
+            #
+          elsif place.start_or_end == 'end'
+            base += 1
+          end
+          interesting_probe_ids_to_place[base] = place
+        end
+      end
+    end
+
+
+    # Generate the graph with the probe sequences in it.
+    read_input = Bio::FinishM::ReadInput.new
+    read_input.parse_options options
+    finishm_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probe_sequences, read_input, options)
+
+    # Explore from the interesting nodes
+
+    output = nil
+    if options[:output_trails_file] == '-'
+      log.info "When trails are found, writing them to stdout"
+      output = $stdout
+    else
+      log.info "When trails are found, writing them to #{options[:output_trails_file]}"
+      output = File.open(options[:output_trails_file],'w')
+    end
+
+    explorer = Bio::AssemblyGraphAlgorithms::GraphExplorer.new
+    interesting_probe_ids_to_place.each do |probe_id, place|
+      log.info "Exploring from #{place}"
+      if finishm_graph.probe_nodes[probe_id].nil?
+        log.warn "Unable to find anchor node for #{place}, skipping exploration from there"
+      else
+        # Do exploration
+        onode = finishm_graph.initial_path_from_probe probe_id
+        paths = explorer.explore_from_node(finishm_graph.graph, onode, options[:graph_search_leash_length])
+        max_length = paths.collect{|path| path.path.length_in_bp}.max
+        log.info "Found #{paths.length} paths from #{place}, maximal length #{max_length}"
+
+        # Print explorations that come back
+        paths.each do |explore_path|
+          begin
+            seq = explore_path.path.sequence
+            output.puts ">#{place.contig_name}:#{place.start_or_end} #{explore_path.termination_type} nodes:#{explore_path}"
+            output.puts seq
+          rescue Bio::Velvet::Graph::OrientedNodeTrail::InsufficientLengthException
+            log.warn "Unable to retrieve sequence from '#{place.contig_name}:#{place.start_or_end} #{explore_path.termination_type} nodes:#{explore_path}' due to insufficient length of path, ignoring"
+          end
+        end
+      end
+    end
+    output.close unless output == $stdout
+  end
+end