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;

/// JSON export with metadata and optional block payloads.
pub struct JsonWriter {
    path: PathBuf,
    writer: BufWriter<File>,
    include_samples: bool,
    first_block: bool,
}

impl JsonWriter {
    pub fn create(
        path: impl AsRef<std::path::Path>,
        header: &Med64Header,
        include_samples: bool,
    ) -> 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);
        write!(writer, "{{\"header\":{{").map_err(io_err(&path))?;
        write_header_json(&mut writer, header)?;
        if include_samples {
            write!(writer, "}},\"blocks\":[").map_err(io_err(&path))?;
        } else {
            write!(writer, "}}}}").map_err(io_err(&path))?;
        }
        Ok(Self { path, writer, include_samples, first_block: true })
    }

    pub fn write_block(&mut self, header: &Med64Header, block: &Med64DataBlock) -> Result<()> {
        if !self.include_samples {
            return Ok(());
        }
        if !self.first_block {
            write!(self.writer, ",").map_err(io_err(&self.path))?;
        }
        self.first_block = false;
        let interval = header.interval_ms();
        write!(
            self.writer,
            "{{\"trace\":{},\"block\":{},\"offset_ms\":{},\"points\":[",
            block.trace_number, block.block_number, block.block_offset_ms
        )
        .map_err(io_err(&self.path))?;
        for (point_idx, row) in block.samples.iter().enumerate() {
            if point_idx > 0 {
                write!(self.writer, ",").map_err(io_err(&self.path))?;
            }
            let time_ms =
                block.block_offset_ms + block.trace_offset_ms + point_idx as f64 * interval;
            write!(self.writer, "{{\"t\":{time_ms},\"ch\":[").map_err(io_err(&self.path))?;
            for (col, &counts) in row.iter().enumerate() {
                if col > 0 {
                    write!(self.writer, ",").map_err(io_err(&self.path))?;
                }
                write!(
                    self.writer,
                    "{{\"i\":{},\"c\":{},\"mv\":{}}}",
                    block.channel_indices[col],
                    counts,
                    header.counts_to_millivolts(counts)
                )
                .map_err(io_err(&self.path))?;
            }
            write!(self.writer, "]}}").map_err(io_err(&self.path))?;
        }
        write!(self.writer, "]}}").map_err(io_err(&self.path))?;
        Ok(())
    }

    pub fn finish(mut self) -> Result<()> {
        if self.include_samples {
            writeln!(self.writer, "]}}").map_err(io_err(&self.path))?;
        }
        self.writer.flush().map_err(|source| Med64Error::WriteIo { path: self.path, source })
    }
}

fn write_header_json(writer: &mut impl Write, header: &Med64Header) -> Result<()> {
    write!(
        writer,
        "\"sampling_frequency_hz\":{},\"trace_duration_ms\":{},\"conversion_factor\":{},\"channels\":{},\"blocks\":{}",
        header.sampling_frequency_hz,
        header.trace_duration_ms,
        header.conversion_factor,
        header.num_active_channels(),
        header.number_of_real_data_blocks,
    )
    .map_err(io_err(&header.path))?;
    Ok(())
}

fn io_err(path: &PathBuf) -> impl Fn(std::io::Error) -> Med64Error + '_ {
    move |source| Med64Error::WriteIo { path: path.clone(), source }
}