use serde::{Deserialize, Serialize};
use crate::error::{Med64Error, Result};
use crate::recording::Recording;
use std::path::Path;
#[derive(Debug, Clone)]
pub struct CsdOptions {
pub max_blocks: Option<usize>,
pub grid_cols: usize,
pub grid_rows: usize,
pub electrode_pitch_um: f64,
pub sample_index: Option<usize>,
}
impl Default for CsdOptions {
fn default() -> Self {
Self {
max_blocks: Some(5),
grid_cols: 8,
grid_rows: 8,
electrode_pitch_um: 150.0,
sample_index: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CsdCell {
pub channel: usize,
pub row: usize,
pub col: usize,
pub potential_mv: f64,
pub csd: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CsdReport {
pub path: std::path::PathBuf,
pub cells: Vec<CsdCell>,
}
pub fn compute_csd(path: impl AsRef<Path>, options: &CsdOptions) -> Result<CsdReport> {
let path = path.as_ref();
let mut rec = Recording::open(path)?;
let header = rec.header().clone();
let block = rec.blocks().next().ok_or_else(|| Med64Error::InvalidHeader {
path: path.to_path_buf(),
message: "no data blocks".into(),
})??;
let idx = options
.sample_index
.unwrap_or(block.samples.len() / 2)
.min(block.samples.len().saturating_sub(1));
let n = options.grid_rows * options.grid_cols;
let mut potential = vec![0.0_f64; n];
for (col, &ch) in block.channel_indices.iter().enumerate() {
if ch < n {
potential[ch] = header.counts_to_millivolts(block.samples[idx][col]);
}
}
let h = options.electrode_pitch_um / 1000.0; let mut cells = Vec::with_capacity(n);
for ch in 0..n {
let row = ch / options.grid_cols;
let col = ch % options.grid_cols;
let v = potential[ch];
let left = if col > 0 { potential[ch - 1] } else { v };
let right = if col + 1 < options.grid_cols { potential[ch + 1] } else { v };
let up = if row > 0 { potential[ch - options.grid_cols] } else { v };
let down = if row + 1 < options.grid_rows { potential[ch + options.grid_cols] } else { v };
let lap = (left + right + up + down - 4.0 * v) / (h * h);
cells.push(CsdCell { channel: ch, row, col, potential_mv: v, csd: -lap });
}
Ok(CsdReport { path: path.to_path_buf(), cells })
}
#[cfg(test)]
mod tests {
#[test]
fn laplacian_of_constant_is_zero() {
let pot: [f64; 64] = [1.0; 64];
let h: f64 = 0.15;
let mut max_abs: f64 = 0.0;
for ch in 0..64 {
let row = ch / 8;
let col = ch % 8;
let v: f64 = pot[ch];
let left: f64 = if col > 0 { pot[ch - 1] } else { v };
let right: f64 = if col + 1 < 8 { pot[ch + 1] } else { v };
let up: f64 = if row > 0 { pot[ch - 8] } else { v };
let down: f64 = if row + 1 < 8 { pot[ch + 8] } else { v };
let lap: f64 = (left + right + up + down - 4.0 * v) / (h * h);
max_abs = max_abs.max(lap.abs());
}
assert!(max_abs < 1e-9);
}
}