med64 0.0.2

Headless MED64 electrophysiology toolkit: .modat I/O, spike/burst analysis, assays, spike-rate maps, and CSV/HTML/SVG/HDF5 export
Documentation
use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::PathBuf;

use crate::block::Med64DataBlock;
use crate::error::{Med64Error, Result};
use crate::header::Med64Header;
use crate::pipeline::SampleSink;
use crate::stream::Sample;

/// Streaming CSV export compatible with waveform analysis tools.
pub struct CsvWriter {
    path: PathBuf,
    writer: BufWriter<File>,
    rows: u64,
}

impl CsvWriter {
    pub fn create(path: impl AsRef<std::path::Path>) -> Result<Self> {
        let path = path.as_ref().to_path_buf();
        let file = File::create(&path)
            .map_err(|source| Med64Error::WriteIo { path: path.clone(), source })?;
        let mut writer = BufWriter::new(file);
        writeln!(writer, "time_ms,channel,counts,millivolts")
            .map_err(|source| Med64Error::WriteIo { path: path.clone(), source })?;
        Ok(Self { path, writer, rows: 0 })
    }

    pub fn write_block(&mut self, header: &Med64Header, block: &Med64DataBlock) -> Result<()> {
        let interval = header.interval_ms();
        for (point_idx, row) in block.samples.iter().enumerate() {
            let time_ms =
                block.block_offset_ms + block.trace_offset_ms + point_idx as f64 * interval;
            for (col, &counts) in row.iter().enumerate() {
                let channel = block.channel_indices[col];
                self.write_row(time_ms, channel, counts, header.counts_to_millivolts(counts))?;
            }
        }
        Ok(())
    }

    pub fn write_sample_row(&mut self, sample: Sample) -> Result<()> {
        self.write_row(sample.time_ms, sample.channel, sample.counts, sample.millivolts)
    }

    fn write_row(
        &mut self,
        time_ms: f64,
        channel: usize,
        counts: i16,
        millivolts: f64,
    ) -> Result<()> {
        writeln!(self.writer, "{time_ms},{channel},{counts},{millivolts}")
            .map_err(|source| Med64Error::WriteIo { path: self.path.clone(), source })?;
        self.rows += 1;
        Ok(())
    }

    pub fn finish(mut self) -> Result<()> {
        self.flush()
    }

    pub fn flush(&mut self) -> Result<()> {
        self.writer
            .flush()
            .map_err(|source| Med64Error::WriteIo { path: self.path.clone(), source })
    }

    pub fn rows_written(&self) -> u64 {
        self.rows
    }
}

impl SampleSink for CsvWriter {
    fn write_sample(&mut self, sample: Sample) -> Result<()> {
        self.write_sample_row(sample)
    }

    fn finish(&mut self) -> Result<()> {
        self.flush()
    }
}