bio-samtools 0.6.2 → 2.0.3

data/lib/bio-samtools.rb

@@ -1,4 +1,9 @@
-require 'ffi'
+require 'bio-svgenes'
+require 'bio'
 require 'bio/db/sam'
 require 'bio/db/pileup'
-require 'bio/db/vcf'
+require 'bio/db/vcf'
+require 'bio/db/alignment'
+require 'bio/db/fastadb'
+require 'open3'
+require 'bio/BIOExtensions'

data/lib/bio/BIOExtensions.rb

@@ -0,0 +1,89 @@
+class Bio::NucleicAcid
+
+  IUPAC_CODES = {
+
+    'y'	=> 'ct',
+    'r'	=> 'ag',
+    'w'	=> 'at',
+    's'	=> 'cg',
+    'k'	=> 'gt',
+    'm'	=> 'ac',
+
+    'b'	=> 'cgt',
+    'd'	=> 'agt',
+    'h'	=> 'act',
+    'v'	=> 'acg',
+
+    'n'	=> 'acgt',
+
+    'a'	=> 'a',
+    't'	=> 't',
+    'g'	=> 'g',
+    'c'	=> 'c',
+    'u'	=> 'u',
+
+    'ct' => 'y',
+    'ag' => 'r',
+    'at' => 'w',
+    'cg' => 's',
+    'gt' => 'k',
+    'ac' => 'm',
+
+    'cgt' => 'b',
+    'agt' => 'd',
+    'act' => 'h',
+    'acg' => 'v',
+
+    'acgt' => 'n'
+  }
+
+  
+  def self.is_unambiguous(base)
+    "acgtACGT".match(base)
+  end
+
+  def self.to_IUAPC(bases)    
+    base = IUPAC_CODES[bases.to_s.downcase.chars.sort.uniq.join]
+    if base == nil
+      p "Invalid base! #{base}"
+      base = 'n' #This is a patch... as one of the scripts failed here. 
+    end
+    base.upcase
+  end
+
+  def self.is_valid(code, base)
+    IUPAC_CODES[code.downcase].chars.include? base.downcase
+  end
+
+end
+
+#Monkey patching to Bio::Sequence to find snps between sequences. It assumes the
+#sequences are already aligned and doesn't check if a base on the first sequence is
+#valid on the second. 
+class Bio::Sequence
+  def self.snps_between(seq1, seq2)
+    snps=0
+    for i in (0..seq1.size-1)
+      snps += 1 if seq1[i] != seq2[i] 
+    end
+    snps
+  end
+end
+
+class  String
+  #Monkey patching to count how many ambiguity codes are present in the string, for Nucleic Acids
+  def count_ambiguities
+    snps=0
+
+    for i in (0..self.size-1)
+
+      snps += 1 if !Bio::NucleicAcid.is_unambiguous(self[i])
+    end
+    snps
+  end
+  
+  #Counts how many bases are uppercase
+  def upper_case_count
+    match(/[^A-Z]*/).to_s.size
+  end
+end

data/lib/bio/db/alignment.rb

@@ -0,0 +1,59 @@
+module Bio
+  class DB
+    
+    #a class to represent the SAM OPT values, presented in SAM as TAG:VTYPE:VALUE 
+    class Tag
+      attr_accessor :tag, :type, :value
+      def set(str)
+        @tag   = str[0..1]
+        @type  = str[3]
+        @value = str[5..-1]
+      end
+    end
+    
+    #Attrobites frp, the flag field (see chapter 2.2.2 of the sam file documentation)
+    #query_strand and mate_strand are true if they are forward. It is the opposite to
+    #the definition in the BAM format for clarity.
+    #primary is the negation of is_negative from the BAM format
+    class Alignment
+      attr_accessor :qname, :flag, :rname,:pos,:mapq,:cigar, :mrnm, :mpos, :isize, :seq, :qual, :tags, :al, :samstr, :calend, :qlen
+
+      attr_accessor :is_paired, :is_mapped, :query_unmapped, :mate_unmapped, :query_strand, :mate_strand, :first_in_pair,:second_in_pair, :primary, :failed_quality, :is_duplicate
+      
+      #parses the SAM string into its constituents and set its attributes
+      def initialize(sam_string)
+        s = sam_string.chomp.split("\t")
+        @qname = s[0]
+        @flag  = s[1].to_i
+        @rname = s[2]
+        @pos   = s[3].to_i
+        @mapq  = s[4].to_i
+        @cigar = s[5]
+        @mrnm  = s[6]
+        @mpos  = s[7].to_i
+        @isize = s[8].to_i
+        @seq   = s[9]
+        @qual =  s[10]
+        @tags = {} 
+        11.upto(s.size-1) {|n| 
+          t = Bio::DB::Tag.new 
+          t.set(s[n])
+          tags[t.tag] = t
+        }    
+      
+        @is_paired  = (@flag & 0x0001) > 0
+        @is_mapped             = @flag & 0x0002 > 0
+        @query_unmapped        = @flag & 0x0004 > 0
+        @mate_unmapped         = @flag & 0x0008 > 0
+        @query_strand          = !(@flag & 0x0010 > 0)
+        @mate_strand           = !(@flag & 0x0020 > 0)
+        @first_in_pair         = @flag & 0x0040 > 0
+        @second_in_pair        = @flag & 0x0080 > 0
+        @primary               = !(@flag & 0x0100 > 0)
+        @failed_quality        = @flag & 0x0200 > 0
+        @is_duplicate          = @flag & 0x0400 > 0
+      
+      end
+    end
+  end
+end

data/lib/bio/db/fastadb.rb

@@ -0,0 +1,255 @@
+#Module to hold the information about the fasta file
+
+module Bio::DB::Fasta
+  #This class contains the entries in a fasta, as generated by samtools faidx
+  class Index
+    include Enumerable
+    attr_reader :entries
+
+    def initialize
+      @entries=[]
+      @entries_map = Hash.new
+    end
+
+    #This doesnt validate if you are adding the same entry twice. I may add
+    #a validation for that. 
+    def << (entry)
+      @entries << entry
+      @entries_map[entry.id] = entry
+    end
+
+    def each(&block)
+      @entries.entries(&block)
+    end  
+    #Total number of entries
+    def length
+      @entries.length
+    end
+    alias_method :size, :length
+
+    #Returns a new Index just with the specified range, as if it was an Array. 
+    #The return object is of type Index. 
+    def [](args)
+      tmp = @entries[args]
+      new_index = Index.new
+      tmp.each do | entry |
+        @new_index << entry
+      end       
+    end
+
+    #Gets the Region object for the full length of the sequence 
+    #name queried.
+    def region_for_entry(entry)
+      @entries_map[entry]
+    end
+  end
+
+  class Entry
+    attr_reader :id, :length
+
+    def initialize(id, length)
+      @id=id
+      @length=length.to_i
+    end
+
+    def get_full_region
+      reg = Region.new
+      reg.entry = id
+      reg.start = 1
+      reg.end = @length
+      reg.orientation = :forward
+      reg
+    end
+
+    alias_method  :to_region, :get_full_region
+
+  end
+
+  #Class to wrap a region of a chromosome
+  class Region
+    BASE_COUNT_ZERO =  {:A => 0, :C => 0, :G => 0,  :T => 0}
+    attr_accessor :entry, :start, :end, :orientation
+    attr_accessor :pileup, :average_coverage, :snps, :reference, :base_ratios, :consensus, :coverages, :bases, :total_cov, :called
+
+    #TODO: Debug, as it hasnt been tested in the actual code. 
+    def base_ratios_for_base(base)
+      @all_ratios = Hash.new unless @all_ratios
+      unless @all_ratios[base]
+        ratios = Array.new
+        for i in (0..region.size-1)
+          ratios << @base_ratios[i][base]
+        end
+        @all_ratios[base] = ratios
+      end
+      @all_ratios[base]
+    end
+
+    #Calculates the concensus, base ratios, coverages and total coverages in the region
+    #* min_cov minimum coverage to make a call (default 0)
+    #* min_per minimum representation to make make a call. If more than one base 
+    #  can be called, the IUAPC ambiguity code is returned
+    def calculate_stats_from_pile(opts={})
+      min_cov = opts[:min_cov] ? opts[:min_cov] : 0
+      min_per =  opts[:min_per] ? opts[:min_per] : 0.20
+      self.called = 0
+      reference = self.reference.downcase
+
+      self.base_ratios = Array.new(self.size, BASE_COUNT_ZERO) 
+      self.bases = Array.new(self.size, BASE_COUNT_ZERO) 
+      self.coverages = Array.new(self.size, 0)
+      self.total_cov = 0
+
+      self.pileup.each do | pile |
+
+        if pile.coverage > min_cov
+          self.base_ratios[pile.pos - self.start ] = pile.base_ratios
+          reference[pile.pos - self.start   ] = pile.consensus_iuap(min_per).upcase
+          self.coverages[pile.pos - self.start   ]  = pile.coverage.to_i
+          self.bases[pile.pos - self.start       ]  = pile.bases
+          self.called += 1 
+        end
+        #puts "#{pile.pos}\t#{bef}\t#{reference[pile.pos - region.start  - 1 ]} "
+        self.total_cov += pile.coverage
+      end
+
+      self.consensus = Bio::Sequence.new(reference)
+      self.consensus.na
+      if self.orientation == :reverse
+        self.consensus.reverse_complement!()
+      end
+      self.average_coverage = self.total_cov.to_f/self.size.to_f
+      self
+    end
+
+    def to_s
+      string = @entry + ":" + @start.to_s + "-" + @end.to_s 
+      string
+    end
+
+    #Returns a region object from a string in form "name:start-end"
+    def self.parse_region(reg_str)
+      string = reg_str.delete("'")
+      fields_1 = string.split(":")
+      fields_2 = fields_1[1].split("-")
+      raise FastaDBException.new(), "Invalid region. #{string}" if fields_1.length != 2 || fields_2.length != 2
+
+      reg = Region.new
+      reg.entry = fields_1[0]
+      reg.start = fields_2[0].to_i
+      reg.end = fields_2[1].to_i
+
+      if reg.end < reg.start 
+        reg.orientation = :reverse
+      else
+        reg.orientation = :forward
+      end
+      reg
+    end
+
+    #Length of the region
+    def size
+      @end - @start
+    end
+    alias_method :length, :size
+
+  end
+
+  class FastaDBException < StandardError; end
+
+  #Class that holds the fasta file. It is used as a database. 
+  class FastaFile
+    attr_reader :index, :fasta_path
+
+    #Initialize the fasta file. If the fai file doesn't exists, it is generated at startup
+    #* fasta path to the fasta file
+    #* samtools path to samtools, if it is not provided, use the bundled version
+    def initialize(args)
+      @fasta_path = args[:fasta]
+      @samtools = args[:samtools] || File.join(File.expand_path(File.dirname(__FILE__)),'sam','external','samtools')
+      raise FastaDBException.new(), "No path for the refernce fasta file. " if @fasta_path.nil?
+      @fai_file = @fasta_path + ".fai" 
+      unless File.file?(@fai_file) then
+        command = "#{@samtools} faidx '#{@fasta_path}'"
+        @last_command = command
+        system(command)
+      end
+
+    end
+
+    #Loads the fai entries 
+    def load_fai_entries()
+      return  @index.length if @index
+      @index = Index.new
+      fai_file = @fai_file
+      File.open(fai_file).each do | line |
+        fields = line.split("\t")
+        @index << Entry.new(fields[0], fields[1])
+      end     
+      @index.length
+    end
+
+
+
+    #Index reference sequence in the FASTA format or extract subsequence from indexed reference sequence. If no region is specified, faidx will index the file and create <ref.fasta>.fai on the disk. If regions are speficified, the subsequences will be retrieved and printed to stdout in the FASTA format.
+    #Options - if a subsequence is required
+    #* chr - [STRING] the reference name of the subsequence
+    #* start - [INT] the start position for the subsequence
+    #* stop - [INT] the stop position for the subsequence
+    def faidx(opts={})
+      if opts.has_key?(:chr) and opts.has_key?(:start) and opts.has_key?(:stop)
+        opts={:as_bio => false}
+        self.fetch_reference(:chr,:start,:stop,opts)
+      else
+        command = "#{@samtools} faidx #{@fasta_path}"
+        @last_command = command
+        system(command)
+      end
+    end
+
+
+    #The region needs to have a method to_region or a method to_s that ha the format "chromosome:start-end" as in samtools
+    def fetch_sequence(region)
+
+
+      query = region.to_s
+      query = region.to_region.to_s if region.respond_to?(:to_region) 
+      command = "#{@samtools} faidx #{@fasta_path} '#{query}'"
+      puts command
+      @last_command = command
+      seq = ""
+      yield_from_pipe(command, String, :text ) {|line| seq = seq + line unless line =~ /^>/}
+
+      reference = Bio::Sequence::NA.new(seq)
+
+      if region.orientation == :reverse
+        #puts "reversing! #{reference.to_s}"
+        reference.reverse_complement!()
+      end
+      reference
+    end
+
+    private
+    #Returns Process::Status with the execution status. If run in a $VERBOSE environment, stderr of the process
+    #is forwarded to the default stdout
+    def yield_from_pipe(command, klass, type=:text, skip_comments=true, comment_char="#", &block)
+      stdin, pipe, stderr, wait_thr = Open3.popen3(command)
+      pid = wait_thr[:pid]  # pid of the started process.       
+      if type == :text
+        while (line = pipe.gets)
+          next if skip_comments and line[0] == comment_char
+          yield klass.new(line.chomp)
+        end
+      elsif type == :binary
+        while (c = pipe.gets(nil))
+          yield c
+        end
+      end
+      exit_status = wait_thr.value  # Process::Status object returned.
+      puts stderr.read if $VERBOSE 
+      stdin.close
+      pipe.close
+      stderr.close
+      return exit_status
+    end
+  end
+end

data/lib/bio/db/pileup.rb

@@ -26,185 +26,234 @@
 # 
 module Bio
   class DB
-class Pileup
-  attr_accessor :ref_name, :pos, :ref_base, :coverage, :read_bases, :read_quals, :consensus, :consensus_quality, :snp_quality, :rms_mapq, :ar1, :ar2, :ar3, :indel_1, :indel_2
-  
-  #creates the Pileup object
-  #    pile_up_line = "seq2\t151\tG\tG\t36\t0\t99\t12\t...........A\t:9<;;7=<<<<<"
-  #    pile = Bio::DB::Pileup.new(pile_up_line)
-  def initialize(pile_up_line)
-    cols = pile_up_line.split(/\t/)
-    if cols.length == 6 ##should only be able to get 6 lines from mpileup
-      @ref_name, @pos, @ref_base, @coverage, @read_bases, @read_quals = cols
-    elsif (10..13).include?(cols.length) ##incase anyone tries to use deprecated pileup with -c flag we get upto 13 cols...
-      if cols[2] == '*' #indel
-        @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @indel_1, @indel_2, @ar1, @ar2, @ar3 = cols
-      else #snp / identity
-        @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @read_bases, @read_quals = cols
+    class Pileup
+      attr_accessor :ref_name, :pos, :ref_base, :coverage, :read_bases, :read_quals, :consensus, :consensus_quality, :snp_quality, :rms_mapq, :ar1, :ar2, :ar3, :indel_1, :indel_2
+      
+      #creates the Pileup object
+      #    pile_up_line = "seq2\t151\tG\tG\t36\t0\t99\t12\t...........A\t:9<;;7=<<<<<"
+      #    pile = Bio::DB::Pileup.new(pile_up_line)
+      def initialize(pile_up_line)
+        cols = pile_up_line.split(/\t/)
+        if cols.length == 6 ##should only be able to get 6 lines from mpileup
+          @ref_name, @pos, @ref_base, @coverage, @read_bases, @read_quals = cols
+        elsif (10..13).include?(cols.length) ##incase anyone tries to use deprecated pileup with -c flag we get upto 13 cols...
+          if cols[2] == '*' #indel
+            @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @indel_1, @indel_2, @ar1, @ar2, @ar3 = cols
+          else #snp / identity
+            @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @read_bases, @read_quals = cols
+          end
+          @consensus_quality = @consensus_quality.to_f
+          @snp_quality = @snp_quality.to_f
+          @rms_mapq = @rms_mapq.to_f
+        else
+          #raise RuntimeError, "parsing line '#{pile_up_line.chomp}' failed"
+        end
+          
+        @pos = @pos.to_i
+        @coverage = @coverage.to_f
+        @ref_count = nil
+        @non_ref_count_hash = nil 
+        @non_ref_count = nil
       end
-      @consensus_quality = @consensus_quality.to_f
-      @snp_quality = @snp_quality.to_f
-      @rms_mapq = @rms_mapq.to_f
-    else
-      #raise RuntimeError, "parsing line '#{pile_up_line.chomp}' failed"
-    end
       
-    @pos = @pos.to_i
-    @coverage = @coverage.to_f
-    @ref_count = nil
-    @non_ref_count_hash = nil 
-    @non_ref_count = nil
-  end
-  
-  # Calculate the total count of each non-reference nucleotide and return a hash of all 4 nt counts, returns a hash
-  #    pile.non_refs #{:A => 1, :C => 0, :T => 0, :G => 0}
-  def non_refs
-    if @non_ref_count_hash.nil?
-       @non_ref_count_hash = {:A => self.read_bases.count("Aa"), :C => self.read_bases.count("Cc"), :G => self.read_bases.count("Gg"), :T => self.read_bases.count("Tt")}
-    end
-      @non_ref_count_hash
-  end
-  
-  # returns the total non-reference bases in the reads at this position
-  def non_ref_count
-    if @non_ref_count.nil?
-      @non_ref_count = @read_bases.count("ATGCatgc").to_f
-    end
-    @non_ref_count
-  end
-  
-  # returns the count of reference-bases in the reads at this position
-  def ref_count
-    if @ref_count.nil?
-      @ref_count = self.read_bases.count(".,")
-    end
-    @ref_count
-  end
-  
-  # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
-  def consensus
-      if @consensus.nil?
-        max = self.non_refs.values.max
-        if (self.ref_count / self.coverage) > 0.5
-          @consensus = self.ref_base 
-        elsif self.ref_count > max
-          @consensus = self.ref_base
+      #Calculate the total count of each non-reference nucleotide and return a hash of all 4 nt counts
+      #returns a hash pile.non_refs #{:A => 1, :C => 0, :T => 0, :G => 0}
+      def non_refs
+        if @non_ref_count_hash.nil?
+           @non_ref_count_hash = {:A => self.read_bases.count("Aa"), :C => self.read_bases.count("Cc"), :G => self.read_bases.count("Gg"), :T => self.read_bases.count("Tt")}
+        end
+          @non_ref_count_hash
+      end
+      
+      # returns the total non-reference bases in the reads at this position
+      def non_ref_count
+        if @non_ref_count.nil?
+          @non_ref_count = @read_bases.count("ATGCatgc").to_f
+        end
+        @non_ref_count
+      end
+      
+      # returns the count of reference-bases in the reads at this position
+      def ref_count
+        if @ref_count.nil?
+          @ref_count = self.read_bases.count(".,")
+        end
+        @ref_count
+      end
+      
+      # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
+      def consensus
+          if @consensus.nil?
+            max = self.non_refs.values.max
+            if (self.ref_count / self.coverage) > 0.5
+              @consensus = self.ref_base 
+            elsif self.ref_count > max
+              @consensus = self.ref_base
+            else
+              arr = self.non_refs.select {|k,v| v == max }
+              bases = arr.collect {|b| b[0].to_s }
+              bases << self.ref_base if self.ref_count == max
+              @consensus = bases.sort.join
+            end
+          end
+          @consensus
+      end
+      
+      #returns basic VCF string as per samtools/misc sam2vcf.pl except that it scrimps on the ref for indels, returning a '*' instead of the reference allele
+      def to_vcf
+        alt,g = self.genotype_list 
+        alt = self.consensus.split(//).join(',') unless self.ref_base == '*'
+        alt = '.' if alt == self.ref_base
+        [self.ref_name, self.pos, '.', self.ref_base, alt, self.snp_quality.to_i, "0", "DP=#{self.coverage.to_i}", "GT:GQ:DP", "#{g}:#{self.consensus_quality.to_i}:#{self.coverage.to_i}" ].join("\t")
+      end
+      
+      private
+      def Pileup.vcf_header
+        %{##fileformat=VCFv3.3
+          ##INFO=DP,1,Integer,"Total Depth"
+          ##FORMAT=GT,1,String,"Genotype"
+          ##FORMAT=GQ,1,Integer,"Genotype Quality"
+          ##FORMAT=DP,1,Integer,"Read Depth"
+          #CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tDATA
+        }.join("\n")
+      end
+      
+      
+ 
+      #returns the genotype of the indel
+      def indel_gt
+        return "undef" if self.consensus.instance_of?(Array)
+        al1, al2 = self.consensus.split(/\//)
+        if al1 == al2 && al1 == '*'   
+          al1=self.indel_1 
+          al2=self.indel_2
+        end
+        alt1 = parse_indel(al1)
+        alt2 = parse_indel(al2)
+        alt,gt = nil,nil
+        
+        return nil if !alt1 and !alt2
+        if !alt1 
+          alt = alt2
+          gt = '0/1'
+        elsif !alt2
+          alt = alt1
+          gt - '0/1'
+        elsif alt1 == alt2
+          alt = alt1
+          gt = '1/1'
         else
-          arr = self.non_refs.select {|k,v| v == max }
-          bases = arr.collect {|b| b[0].to_s }
-          bases << self.ref_base if self.ref_count == max
-          @consensus = bases.sort.join
+          alt="#{alt1},#{alt2}"
+          gt= '1/2'
         end
+        return [alt, gt]
+        
       end
-      @consensus
-  end
-  
-  #returns basic VCF string as per samtools/misc sam2vcf.pl except that it scrimps on the ref for indels, returning a '*' instead of the reference allele
-  def to_vcf
+      #returns the genotype of the snp
+      def snp_gt
+        return ['.','0/0'] if self.ref_base == self.consensus
+        bases = Pileup.iupac_to_base(self.consensus)
+        if bases[0] == self.ref_base
+           return [bases[1],'0/1']
+        elsif bases[1] == self.ref_base
+           return [bases[0],'0/1']
+        else
+          return ["#{bases[0]},#{bases[1]}",'1/2']
+        end 
+      end
+      
+      #identifies the reference base and returns the indel or snp genotype as applicable
+      public
+      def genotype_list
+        if self.ref_base == '*'
+          return indel_gt
+        else
+         return snp_gt
+        end
+      end
+      
+      #returns the two bases for the corresponding iupac code
+      public
+      def Pileup.iupac_to_base(alt_base)
+          case alt_base
+                when 'K' then ['G','T']
+                when 'M' then ['A','C']
+                when 'S' then ['C','G']
+                when 'R' then ['A','G']
+                when 'W' then ['A','T']
+                when 'Y' then ['C','T']
+                else alt_base.split(//)
+          end
+      end
+      
+      #identifies if the indel is an insertion or a deletion  
+      def parse_indel(alt)
+        return "D#{$'.length}" if alt =~/^-/ 
+        if alt=~/^\+/
+          return "I#{$'}"
+        elsif alt == '*' 
+          return nil
+        end
+      end
+      
+      
+      #returns pileup format line
+      def to_s
+        if @read_quals and !@consensus_quality #6col
+          [@ref_name, @pos, @ref_base, @coverage.to_i, @read_bases, @read_quals].join("\t")    
+        elsif @indel_1 #13 cols
+          [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @indel_1, @indel_2, @ar1, @ar2, @ar3].join("\t")
+        else #10 cols
+          [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @read_bases, @read_quals].join("\t")
+        end
+          
+      end
+      
+      
+      def bases
+         return @bases if @bases
+         @bases = self.non_refs
+         #puts self.ref_count
+         @bases[self.ref_base.upcase.to_sym] = self.ref_count 
+         @bases
+       end
 
-    alt,g = self.genotype_list 
-    alt = self.consensus.split(//).join(',') unless self.ref_base == '*'
-    alt = '.' if alt == self.ref_base
-    [self.ref_name, self.pos, '.', self.ref_base, alt, self.snp_quality.to_i, "0", "DP=#{self.coverage.to_i}", "GT:GQ:DP", "#{g}:#{self.consensus_quality.to_i}:#{self.coverage.to_i}" ].join("\t")
-  end
-  
-  private
-  def Pileup.vcf_header
-    %{##fileformat=VCFv3.3
-      ##INFO=DP,1,Integer,"Total Depth"
-      ##FORMAT=GT,1,String,"Genotype"
-      ##FORMAT=GQ,1,Integer,"Genotype Quality"
-      ##FORMAT=DP,1,Integer,"Read Depth"
-      #CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tDATA
-    }.join("\n")
-  end
-  
-  def parse_indel(alt)
+       def base_coverage
+         total = 0
+         @bases.each do |k,v|
+           total += v  
+         end
+         total
+       end
 
-    return "D#{$'.length}" if alt =~/^-/ 
-    if alt=~/^\+/
-      return "I#{$'}"
-    elsif alt == '*' 
-      return nil
-     end
-  end
-  
-  def indel_gt
-    return "undef" if self.consensus.instance_of?(Array)
-    al1, al2 = self.consensus.split(/\//)
-    if al1 == al2 && al1 == '*'   
-      al1=self.indel_1 
-      al2=self.indel_2
-    end
-    alt1 = parse_indel(al1)
-    alt2 = parse_indel(al2)
-    alt,gt = nil,nil
-    
-    return nil if !alt1 and !alt2
-    if !alt1 
-      alt = alt2
-      gt = '0/1'
-    elsif !alt2
-      alt = alt1
-      gt - '0/1'
-    elsif alt1 == alt2
-      alt = alt1
-      gt = '1/1'
-    else
-      alt="#{alt1},#{alt2}"
-      gt= '1/2'
-    end
-    return [alt, gt]
-    
-  end
-  
-  def snp_gt
-    return ['.','0/0'] if self.ref_base == self.consensus
-    bases = Pileup.iupac_to_base(self.consensus)
-    if bases[0] == self.ref_base
-       return [bases[1],'0/1']
-    elsif bases[1] == self.ref_base
-       return [bases[0],'0/1']
-    else
-      return ["#{bases[0]},#{bases[1]}",'1/2']
-    end 
-  end
-  
-  public
-  def genotype_list
-    if self.ref_base == '*'
-      return indel_gt
-    else
-     return snp_gt
-   end
-  end
-  
-  public
-  #returns 
-  def Pileup.iupac_to_base(alt_base)
-      case alt_base
-            when 'K' then ['G','T']
-            when 'M' then ['A','C']
-            when 'S' then ['C','G']
-            when 'R' then ['A','G']
-            when 'W' then ['A','T']
-            when 'Y' then ['C','T']
-            else alt_base.split(//)
-      end
-  end
-  
-  #returns pileup format line
-  def to_s
-    if @read_quals and !@consensus_quality #6col
-      [@ref_name, @pos, @ref_base, @coverage.to_i, @read_bases, @read_quals].join("\t")    
-    elsif @indel_1 #13 cols
-      [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @indel_1, @indel_2, @ar1, @ar2, @ar3].join("\t")
-    else #10 cols
-      [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @read_bases, @read_quals].join("\t")
+       def base_ratios
+         return @base_ratios if @base_ratios
+         bases = self.bases
+         @base_ratios = Hash.new
+         bases.each do |k,v| 
+           @base_ratios[k] = v.to_f/self.base_coverage.to_f 
+         end
+         @base_ratios
+       end
+
+       # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
+       def consensus_iuap(minumum_ratio_for_iup_consensus)
+         
+         if @consensus_iuap.nil?
+           @consensus_iuap = self.ref_base.downcase
+           bases = self.bases
+           tmp = String.new
+           bases.each do |k,v|
+             tmp << k[0].to_s if v/self.coverage.to_f > minumum_ratio_for_iup_consensus
+           end
+           if tmp.length > 0
+             @consensus_iuap = Bio::NucleicAcid.to_IUAPC(tmp)
+           end
+         end 
+         @consensus_iuap
+       end
+       
+       
     end
-      
   end
-  
-end
-end
 end