Fix up STDIN reading

mobiusklein · Dec 21, 2023 · 21f531a · 21f531a
1 parent 2c72a42
commit 21f531a
Show file tree

Hide file tree

Showing 4 changed files with 66 additions and 15 deletions.
diff --git a/examples/from_stdin.rs b/examples/from_stdin.rs
@@ -0,0 +1,18 @@
+use std::io;
+
+use mzdata::MzMLReader;
+use mzdata::io::PreBufferedStream;
+
+
+
+fn main() -> io::Result<()> {
+    let stream = io::stdin();
+    let stream = PreBufferedStream::new(stream)?;
+
+    let reader = MzMLReader::new(stream);
+    let spectra: Vec<_> = reader.collect();
+    eprintln!("Read {} spectra", spectra.len());
+    assert!(spectra.len() > 0);
+
+    Ok(())
+}
diff --git a/src/io/mzml/writer.rs b/src/io/mzml/writer.rs
@@ -310,6 +310,7 @@ impl ChromatogramCollector {
     }
 
     pub fn add(&mut self, time: f64, intensity: f32) {
+        log::debug!("Storing {time:0.3} {intensity:0.2} ({:?})", self.name);
         self.time.extend(time.to_le_bytes());
         self.intensity.extend(intensity.to_le_bytes());
     }

diff --git a/src/io/utils.rs b/src/io/utils.rs
@@ -172,7 +172,7 @@ impl<R: io::Read> io::Seek for PreBufferedStream<R> {
                 }
                 self.position = offset as usize;
                 let r = self.buffer.seek(pos);
-                eprintln!("Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
+                eprintln!("{pos:?} Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
                 r
             }
             io::SeekFrom::End(_) => {
@@ -197,7 +197,7 @@ impl<R: io::Read> io::Seek for PreBufferedStream<R> {
                     } else {
                         self.position = self.position.saturating_sub(offset.abs() as usize);
                         let r = self.buffer.seek(io::SeekFrom::Start(self.position as u64));
-                        eprintln!("Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
+                        eprintln!("{pos:?} Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
                         r
                     }
                 } else {
@@ -208,28 +208,32 @@ impl<R: io::Read> io::Seek for PreBufferedStream<R> {
                         ));
                     } else {
                         let r = self.buffer.seek(io::SeekFrom::Current(offset));
-                        eprintln!("Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
+                        eprintln!("{pos:?} Position {0} -> {1}: {r:?}", self.position, self.buffer.stream_position().unwrap());
                         r
                     }
                 }
             }
         }
     }
+
+    fn stream_position(&mut self) -> io::Result<u64> {
+        Ok(self.position as u64)
+    }
 }
 
 impl<R: io::Read> io::Read for PreBufferedStream<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let n_total = buf.len();
         let before = self.position;
-        let n_remaining = if self.position < self.buffer_size {
+        let (n_remaining, n_from_buffer) = if self.position < self.buffer_size {
             let n_from_buffer = self.buffer.read(buf)?;
             self.position += n_from_buffer;
-            n_total.saturating_sub(n_from_buffer)
+            (n_total.saturating_sub(n_from_buffer), n_from_buffer)
         } else {
-            n_total
+            (n_total, 0)
         };
         if n_remaining > 0 {
-            let n_rest = self.stream.read(buf)?;
+            let n_rest = self.stream.read(&mut buf[n_from_buffer..])?;
             self.position += n_rest;
         }
         let total_read = self.position - before;

diff --git a/src/spectrum/group.rs b/src/spectrum/group.rs
@@ -571,6 +571,7 @@ mod mzsignal_impl {
     use super::*;
 
     use log::warn;
+    use mzpeaks::{PeakCollection, MZLocated};
     use mzsignal::average::{average_signal, SignalAverager};
     use mzsignal::reprofile::reprofile;
     use mzsignal::{ArrayPair, FittedPeak};
@@ -691,12 +692,20 @@ mod mzsignal_impl {
             averager.array_pairs.clear();
 
             for arrays in self.ms1_context.iter() {
-                let mp = arrays.mz_array.as_ptr();
-                let ip = arrays.intensity_array.as_ptr();
-                let unsafe_mzs = unsafe { std::slice::from_raw_parts(mp, arrays.mz_array.len()) };
-                let unsafe_intens = unsafe { std::slice::from_raw_parts(ip, arrays.intensity_array.len()) };
-                let pair = ArrayPair::from((unsafe_mzs, unsafe_intens));
-                averager.push(pair);
+                if arrays.is_profile {
+                    let mp = arrays.mz_array.as_ptr();
+                    let ip = arrays.intensity_array.as_ptr();
+                    let unsafe_mzs = unsafe { std::slice::from_raw_parts(mp, arrays.mz_array.len()) };
+                    let unsafe_intens = unsafe { std::slice::from_raw_parts(ip, arrays.intensity_array.len()) };
+                    let pair = ArrayPair::from((unsafe_mzs, unsafe_intens));
+                    averager.push(pair);
+                } else {
+                    let peaks: Vec<_> = arrays.mz_array.iter().zip(arrays.intensity_array.iter()).map(|(mz, intensity)| {
+                        FittedPeak { mz: *mz, intensity: *intensity, full_width_at_half_max: 0.01, ..Default::default()}
+                    }).collect();
+                    let pair = reprofile(peaks.iter(), averager.dx).to_owned();
+                    averager.push(pair);
+                }
             }
 
             let avg_intens = averager.interpolate();
@@ -805,8 +814,27 @@ mod mzsignal_impl {
                         None
                     }
                 } else {
-                    warn!("{} was not profile mode", scan.id());
-                    None
+                    if let Some(peaks) = &scan.peaks {
+                        let mut mz = Vec::with_capacity(peaks.len());
+                        let mut inten = Vec::with_capacity(peaks.len());
+                        for p in peaks {
+                            mz.push(p.mz());
+                            inten.push(p.intensity());
+                        }
+                        let mz_a = Arc::new(mz);
+                        let inten_a = Arc::new(inten);
+                        Some(ArcArrays::new(mz_a, inten_a, false))
+                    } else if let Some(array_map) = scan.raw_arrays() {
+                        let mz = array_map.mzs().unwrap().to_vec();
+                        let inten = array_map.intensities().unwrap().to_vec();
+                        let mz_a = Arc::new(mz);
+                        let inten_a = Arc::new(inten);
+                        Some(ArcArrays::new(mz_a, inten_a, false))
+
+                    } else {
+                        warn!("{} did not have raw data arrays", scan.id());
+                        None
+                    }
                 }
             })
         }