mspire 0.7.8 → 0.7.9

data/Rakefile

@@ -19,6 +19,7 @@ Jeweler::Tasks.new do |gem|
   gem.add_dependency "builder", "~> 3.0.0"
   gem.add_dependency "bio", "~> 1.4.2"
   gem.add_dependency "trollop", "~> 1.16.2"
+  gem.add_dependency "uuid", ">= 2.3.5"
   # this should be a real dependency, but need to document getting this
   # working on windows first!
   gem.add_development_dependency "fftw3", "~> 0.3"

data/VERSION

@@ -1 +1 @@
-0.7.8
+0.7.9

data/lib/mspire/mzml.rb

@@ -150,7 +150,11 @@ module Mspire
       case arg
       when IO
         @io = arg
-        @encoding = @io.bookmark(true) {|io| io.readline.match(/encoding=["'](.*?)["']/)[1] }
+        begin
+          @encoding = @io.bookmark(true) {|io| io.readline.match(/encoding=["'](.*?)["']/)[1] }
+        rescue EOFError
+          raise RuntimeError, "no encoding present in XML!  (Is this even an xml file?)"
+        end
         @index_list = get_index_list
         read_header!
       when Hash

data/lib/mspire/mzml/data_array.rb

@@ -89,7 +89,14 @@ module Mspire
             end
         end
         data = base64.unpack("m*").first
-        unzipped = compressed ? Zlib::Inflate.inflate(data) : data
+        # some implementations leave data blank if there aren't peaks
+        # even if they say it is zlib compressed...
+        unzipped = 
+          if data.size > 0  
+            compressed ? Zlib::Inflate.inflate(data) : data
+          else
+            data
+          end
         self.new( unzipped.unpack(precision_unpack) )
       end
 

data/lib/mspire/peak.rb

@@ -7,5 +7,13 @@ module Mspire
   class Peak < Array
     alias_method :x, :first
     alias_method :y, :last
+
+    def x=(val)
+      self[0] = val
+    end
+
+    def y=(val)
+      self[1] = val
+    end
   end
 end

data/lib/mspire/peak_list.rb

@@ -1,7 +1,8 @@
 require 'mspire/bin'
 
 module Mspire
-  # a collection of peak objects
+  # a collection of peak objects.  At a minimum, each peak should respond to
+  # :x and :y
   class PeakList < Array
 
     def lo_x
@@ -21,22 +22,46 @@ module Mspire
       :centroided => true,
     }
 
+    # for spectral peaks, this is the weighted m/z
+    def weighted_x
+      tot_intensity = self.inject(0.0) {|sum,peak| sum + peak.y }
+      _weighted_x = 0.0
+      self.each do |peak|
+        int = peak.y
+        signal_by_sample_index[peak.sample_id] += int
+        _weighted_x += (peak.first * (int/tot_intensity))
+      end
+      _weighted_x
+    end
+
+    # class methods
     class << self
 
+      # creates a new Mspire::PeakList and coerces each peak into an
+      # Mspire::Peak.  If your peaks already behave like peaks you should use
+      # .new
+      def [](*peaks)
+        self.new( peaks.map {|peak| Mspire::Peak.new(peak) } )
+      end
+
       def create_bins(peaklists, opts)
-        min, max = min_max_mz(peaklists)
+        min, max = min_max_x(peaklists)
 
         divisions = []
         bin_width = opts[:bin_width]
         use_ppm = (opts[:bin_unit] == :ppm)
-        current_mz = min
+
+        puts "using bin width: #{bin_width}" if $VERBOSE
+        puts "using ppm for bins: #{use_ppm}" if $VERBOSE
+
+        current_x = min
         loop do
-          if current_mz >= max
+          if current_x >= max
             divisions << max
             break
           else
-            divisions << current_mz
-            current_mz += ( use_ppm ? current_mz./(1e6).*(bin_width) : bin_width )
+            divisions << current_x
+            current_x += ( use_ppm ? current_x./(1e6).*(bin_width) : bin_width )
           end
         end
         # make each bin exclusive so there is no overlap
@@ -46,10 +71,10 @@ module Mspire
         bins
       end
 
-      def min_max_mz(peaklists)
+      def min_max_x(peaklists)
         # find the min and max across all spectra
         first_peaklist = peaklists.first
-        min = first_peaklist.first[0]; max = first_peaklist.last[0]
+        min = first_peaklist.first.x; max = first_peaklist.last.x
         peaklists.each do |peaklist|
           min = peaklist.lo_x if peaklist.lo_x < min
           max = peaklist.hi_x if peaklist.hi_x > max
@@ -58,53 +83,62 @@ module Mspire
       end
 
       def merge_centroids(peaklists, opts={})
+        opts[:return_data] = true if opts[:only_data]
 
         # Create Mspire::Bin objects
         bins = opts[:bins] ? opts[:bins] : create_bins(peaklists, opts)
+        puts "created #{bins.size} bins" if $VERBOSE
 
         peaklists.each do |peaklist|
-          Mspire::Bin.bin(bins, peaklist, &:first)
+          Mspire::Bin.bin(bins, peaklist, &:x)
         end
 
         pseudo_peaks = bins.map do |bin|
-          [bin, bin.data.reduce(0.0) {|sum,peak| sum + peak[1] }]
+          Mspire::Peak.new( [bin, bin.data.reduce(0.0) {|sum,peak| sum + peak.y }] )
         end
 
         pseudo_peaklist = Mspire::PeakList.new(pseudo_peaks)
 
-        peak_lists = pseudo_peaklist.split(opts[:split])
+        separate_peaklists = pseudo_peaklist.split(opts[:split])
+
+        normalize_factor = opts[:normalize] ? peaklists.size : 1
 
         return_data = []
-        final_peaklist = []
-        peak_lists.each_with_index do |peak_list,i|
-          #peaks.each do |peak|
-          tot_intensity = peak_list.map(&:last).reduce(:+)
-          return_data_per_peak = [] if opts[:return_data]
-          weighted_mz = 0.0
-          peak_list.each do |peak|
-            pre_scaled_intensity = peak[0].data.reduce(0.0) {|sum,v| sum + v.last }
-            post_scaled_intensity = peak[1]
-            # some peaks may have been shared.  In this case the intensity
-            # for that peak was downweighted.  However, the actual data
-            # composing that peak is not altered when the intensity is
-            # shared.  So, to calculate a proper weighted avg we need to
-            # downweight the intensity of any data point found within a bin
-            # whose intensity was scaled.
-            correction_factor = 
-              if pre_scaled_intensity != post_scaled_intensity
-                post_scaled_intensity / pre_scaled_intensity
-              else
-                1.0
-              end
+        final_peaklist = Mspire::PeakList.new unless opts[:only_data]
 
-            return_data_per_peak.push(*peak[0].data) if opts[:return_data]
+        separate_peaklists.each do |pseudo_peaklist|
+          data_peaklist = Mspire::PeakList.new
+          weight_x = 0.0
+          tot_intensity = pseudo_peaklist.inject(0.0) {|sum, bin_peak| sum + bin_peak.y }
+          #puts "TOT INTENSITY:"
+          #p tot_intensity
+          calc_from_lil_bins = pseudo_peaklist.inject(0.0) {|sum, bin_peak| sum + bin_peak.x.data.map(&:y).reduce(:+) }
+          #puts "LILBINS: "
+          #p calc_from_lil_bins
+          pseudo_peaklist.each do |bin_peak|
 
-            peak[0].data.each do |lil_point|
-              weighted_mz += lil_point[0] * ( (lil_point[1].to_f * correction_factor) / tot_intensity)
+            # For the :share method, the psuedo_peak intensity may have been
+            # adjusted, but the individual peaks were not.  Correct this.             
+            if opts[:split] == :share
+              post_scaled_y = bin_peak.y
+              pre_scaled_y = bin_peak.x.data.reduce(0.0) {|sum,peak| sum + peak.last }
+              #puts "PRESCALED Y:"
+              #p pre_scaled_y
+              if (post_scaled_y - pre_scaled_y).abs.round(10) != 0.0
+                correction = post_scaled_y / pre_scaled_y
+                bin_peak.x.data.each {|peak| peak.y = (peak.y * correction) }
+              end
             end
+
+            unless opts[:only_data]
+              bin_peak.x.data.each do |peak|
+                weight_x += peak.x * ( peak.y.to_f / tot_intensity)
+              end
+            end
+            (data_peaklist.push( *bin_peak.x.data )) if opts[:return_data]
           end
-          return_data << return_data_per_peak if opts[:return_data]
-          final_peaklist << Mspire::Peak.new([weighted_mz, tot_intensity])
+          final_peaklist << Mspire::Peak.new([weight_x, tot_intensity / normalize_factor]) unless opts[:only_data]
+          return_data << data_peaklist if opts[:return_data]
         end
         [final_peaklist, return_data]
       end
@@ -116,13 +150,13 @@ module Mspire
       # first):
       #
       #     :bin_width => 5 
-      #     :bin_unit => :ppm | :amu        interpret bin_width as ppm or amu
+      #     :bin_unit => :ppm|:amu        interpret bin_width as ppm or amu
       #     :bins => array of Mspire::Bin objects  for custom bins (overides other bin options)
       #     :normalize => true              if true, divides total intensity by 
       #                                     number of spectra
       #     :return_data => false           returns a parallel array containing
       #                                     the peaks associated with each returned peak
-      #     :split => false | :share | :greedy_y   see Mspire::Peak#split
+      #     :split => :zero|:greedy_y|:share  see Mspire::Peak#split
       #     :centroided => true             treat the data as centroided
       #
       # The binning algorithm is roughly the fastest possible algorithm that
@@ -130,131 +164,167 @@ module Mspire
       # algorithm O(n + m))
       #
       # Assumes the peaklists are already sorted by m/z.
+      #
+      # Note that the peaks themselves will be altered if using the :share
+      # split method.
       def merge(peaklists, opts={})
         opts = DEFAULT_MERGE.merge(opts)
 
         (peaklist, returned_data) =  
           if opts[:centroided]
-            merge_centroids(peaklists, opts)
+            merge_centroids(peaklists, opts.dup)
           else
             raise NotImplementedError, "need to implement profile merging"
           end
 
-        if opts[:normalize]
-          sz = peaklists.size
-          peaklist.each {|peak| peak[1] = peak[1].to_f / sz }
-        end
-        if opts[:return_data]
-          $stderr.puts "returning peaklist (#{peaklist.size}) and data" if $VERBOSE
+        if opts[:only_data]
+          returned_data
+        elsif opts[:return_data]
           [peaklist, returned_data]
         else
-          $stderr.puts "returning peaklist (#{peaklist.size})" if $VERBOSE
-          peaklist 
+          peaklist
         end
       end
+    end # end class << self
+
+
+    # returns an array with the indices outlining each peak.  The first index
+    # is the start of the peak, the last index is the last of the peak.
+    # Interior indices represent local minima.  So, peaks that have only two
+    # indices have no local minima.
+    def peak_boundaries(gt=0.0)
+      in_peak = false
+      prev_y = gt
+      prev_prev_y = gt
+      peak_inds = []
+      self.each_with_index do |peak, index|
+        curr_y = peak.y
+        if curr_y > gt
+          if !in_peak
+            in_peak = true
+            peak_inds << [index]
+          else
+            # if on_upslope
+            if prev_y < curr_y
+              # If we were previously on a downslope and we are now on an upslope
+              # then the previous index is a local min
+              # on_downslope(prev_previous_y, prev_y)
+              if prev_prev_y > prev_y
+                # We have found a local min
+                peak_inds.last << (index - 1)
+              end
+            end # end if (upslope)
+          end # end if !in_peak
+        elsif in_peak
+          peak_inds.last << (index - 1)
+          in_peak = false
+        end 
+        prev_prev_y = prev_y
+        prev_y = curr_y
+      end
+      # add the last one to the last peak if it is a boundary
+      if self[-1].y > gt
+        peak_inds.last << (self.size-1)
+      end
+      peak_inds
     end
 
+    # returns an array of PeakList objects
+    def split_on_zeros(given_peak_boundaries=nil)
+      pk_bounds = given_peak_boundaries || peak_boundaries(0.0)
+      pk_bounds.map do |indices|
+        self.class.new self[indices.first..indices.last]
+      end
+    end
+
+    # returns an array of PeakList objects
+    # assumes that this is one connected list of peaks (i.e., no
+    # zeros/whitespace on the edges or internally)
+    #
+    #       /\       
+    #      /  \/\
+    #     /      \
+    #
+    # if there are no local minima, just returns self inside the array
+    def split_contiguous(methd=:greedy_y, local_min_indices=nil)
+      local_min_indices ||= ((pb=peak_boundaries.first) && pb.shift && pb.pop && pb)
+
+      if local_min_indices.size == 0
+        self
+      else
+        peak_class = first.class
+        prev_lm_i = 0  # <- don't worry, will be set to bumped to zero
+        peak_lists = [ self.class.new([self[0]]) ]
+        local_min_indices.each do |lm_i|
+          peak_lists.last.push( *self[(prev_lm_i+1)..(lm_i-1)] )
+          case methd
+          when :greedy_y
+            if self[lm_i-1].y >= self[lm_i+1].y
+              peak_lists.last << self[lm_i]
+              peak_lists << self.class.new
+            else
+              peak_lists << self.class.new( [self[lm_i]] )
+            end
+          when :share
+            # for each local min, two new peaks will be created, with
+            # intensity shared between adjacent peak_lists
+            lm = self[lm_i]
+            sum = self[lm_i-1].y + self[lm_i+1].y
+            # push onto the last peaklist its portion of the local min
+            peak_lists.last << peak_class.new( [lm.x, lm.y * (self[lm_i-1].y.to_f/sum)] )
+            # create a new peaklist that contains its portion of the local min
+            peak_lists << self.class.new( [peak_class.new([lm.x, lm.y * (self[lm_i+1].y.to_f/sum)])] )
+          end
+          prev_lm_i = lm_i
+        end
+        peak_lists.last.push(*self[(prev_lm_i+1)...(self.size)] )
+        peak_lists
+      end
+    end
 
     # returns an Array of peaklist objects.  Splits run of 1 or more local
     # minima into multiple peaklists.  When a point is 'shared' between two
     # adjacent hill-ish areas, the choice of how to resolve multi-hills (runs
     # of data above zero) is one of:
     #
-    #     false/nil => only split on zeros
-    #     :share => give each peak its rightful portion of shared peaks, dividing the
+    #     :zero = only split on zeros
+    #     :share = give each peak its rightful portion of shared peaks, dividing the
     #               intensity based on the intensity of adjacent peaks
-    #     :greedy_y => give the point to the peak with highest point next to
+    #     :greedy_y = give the point to the peak with highest point next to
     #                  the point in question. tie goes lower.
     #
-    # if return_local_minima is true, a parallel array of local minima indices is
-    # returned (only makes sense if split_multipeaks is false)
-    # 
+    # Note that the peak surrounding a local_minima may be altered if using
+    # :share
+    #
     # assumes that a new peak can be made with an array containing the x
     # value and the y value.
-    def split(split_multipeaks=false, return_local_minima=false)
-      if split_multipeaks
-        (zeroed_peaks, local_min_ind_ar) = self.split(false, true)
-        $stderr.print "splitting on local minima ..." if $VERBOSE
-        no_local_minima_peaks = zeroed_peaks.zip(local_min_ind_ar).map do |peak, lm_indices|
-          new_peaks = [ peak.class.new ]
-          if lm_indices.size > 0
-            prev_lm_i = -1   # <- it's okay, we don't use until it is zero
-            lm_indices.each do |lm_i|
-              lm = peak[lm_i]
-              point_class = lm.class
-
-              # push onto the last peak all the points from right after the previous local min
-              # to just before this local min
-              new_peaks.last.push( *peak[(prev_lm_i+1)..(lm_i-1)] )
-              before_pnt = peak[lm_i-1]
-              after_pnt = peak[lm_i+1]
-
-              case split_multipeaks
-              when :share
-                sum = before_pnt[1] + after_pnt[1]
-                # push onto the last peak its portion of the local min
-                new_peaks.last << point_class.new( [lm[0], lm[1] * (before_pnt[1].to_f/sum)] )
-                # create a new peak that contains its portion of the local min
-                new_peaks << self.class.new( [point_class.new([lm[0], lm[1] * (after_pnt[1].to_f/sum)])] )
-                prev_lm_i = lm_i
-              when :greedy_y
-                if before_pnt[1] >= after_pnt[1]
-                  new_peaks.last << lm
-                  new_peaks << self.class.new
-                  prev_lm_i = lm_i
-                else
-                  new_peaks << self.class.new( [lm] )
-                  prev_lm_i = lm_i
-                end
-              else
-                raise ArgumentError, "only recognize :share, :greedy_y, or false for the arg in #split(arg)"
-              end
-            end
-            new_peaks.last.push( *peak[(prev_lm_i+1)...peak.size] )
-            new_peaks
-          else
-            [peak]
-          end
-        end.flatten(1) # end zip
-        $stderr.puts "now #{no_local_minima_peaks.size} peaks." if $VERBOSE
-        no_local_minima_peaks 
+    def split(split_multipeaks_mthd=:zero)
+      if split_multipeaks_mthd == :zero
+        split_on_zeros
       else
-        $stderr.print "splitting on zeros..." if $VERBOSE
-        # first, split the peaks based on zero intensity values 
-        # and simultaneously keep track of the local minima within each
-        # resulting peak
-        peak_lists = []
-        local_min_ind_ar = []
-        in_peak = false
-        self.each_with_index do |peak, index|
-          previous_y = self[index - 1][1]
-          if peak[1] > 0
-            if !in_peak
-              in_peak = 0
-              peak_lists << self.class.new([peak])
-              local_min_ind_ar << []
-            else
-              peak_lists.last << peak
-              # if on_upslope(previous_y, point[1])
-              if previous_y < peak[1]
-                # If we were previously on a downslope and we are now on an upslope
-                # then the previous index is a local min
-                prev_previous_y = self[index - 2][1]
-                # on_downslope(prev_previous_y, previous_y)
-                if prev_previous_y > previous_y
-                  # We have found a local min
-                  local_min_ind_ar.last << (in_peak-1)
-                end
-              end # end if (upslope)
-            end # end if !in_peak
-            in_peak += 1
-          elsif in_peak
-            in_peak = false
-          end # end if point[1] > 0
+        boundaries = peak_boundaries(0.0)
+        no_lm_pklsts = []
+        boundaries.each do |indices|
+          peak = self[indices.first..indices.last]
+          if indices.size == 2
+            no_lm_pklsts << peak
+          else # have local minima
+            multipeak = PeakList.new(peak)
+            local_min_inds = indices[1..-2].map {|i| i-indices.first}
+            peaklists = multipeak.split_contiguous(split_multipeaks_mthd, local_min_inds)
+            no_lm_pklsts.push *peaklists
+          end
         end
-        $stderr.puts "#{peak_lists.size} no-whitespace-inside peak_lists." if $VERBOSE
-        return_local_minima ? [peak_lists, local_min_ind_ar] : peak_lists
-      end # 
+        #$stderr.puts "now #{no_lm_pklsts.size} peaks." if $VERBOSE
+        no_lm_pklsts 
+      end 
     end # def split
   end
 end
+
+
+
+=begin
+if !opts[:only_data]
+=end
+