bvreader 0.1.5

Reader for the BrainVision data format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use regex::Regex;
use std::sync::OnceLock;

/* _unit_dict = {
    "V": 1.0,  # V stands for Volt
    "µV": 1e-6,
    "uV": 1e-6,
    "mV": 1e-3,
    "nV": 1e-9,
    "C": 1,  # C stands for Celsius
    "°C": 1,  # degrees Celsius
    "n/a": 1,  # unit "not available" (or applicable)
    "µS": 1e-6,  # S stands for Siemens
    "uS": 1e-6,
    "ARU": 1,  # ARU is the unity for the breathing data
    "S": 1,
    "N": 1,
} */

#[derive(Default, Clone, Debug, PartialEq, Eq)]
#[allow(non_camel_case_types)]
/// uV is µV
pub enum DataUnit {
    V,
    mV,
    #[default]
    uV, 
    nV,
    C, // Celsius
    ARU, // Unit for breathing data
    S, // Siemens
    uS, 
    N,
    NA,
}


#[derive(Default, Clone, Debug, PartialEq)]
pub struct ChannelInfo {
    pub header_id: String,
    pub label: String,
    pub reference: String,
    pub resolution: Option<f32>,
    pub unit: DataUnit,
}



static CHANINFO_REGEX: OnceLock<Regex> = OnceLock::new();

/// Returns empty Vec if no channelinfo present
pub fn parse_chan_info(textcontent: &str) -> Vec<ChannelInfo> {

    let re = CHANINFO_REGEX.get_or_init(|| {
        Regex::new(r"([Cch].\d.*)=([\w\.,]*)").unwrap() 
      });
    
    let mut results = vec![];

    // Iterate over matches and extract components
    for caps in re.captures_iter(textcontent) {
        let header_id = caps.get(1).map(|m| m.as_str());
        if header_id.is_some() { // serves as validation that we can safely unwrap everything in this line
            let header_id = header_id.unwrap().to_string();
            let second_capture = caps.get(2).map(|m| m.as_str()).unwrap();
            let split_values: Vec<&str> = second_capture.split(',').collect();

            if split_values.len() == 4 {
                let label: String = split_values[0].to_string();
                let reference: String = split_values[1].to_string();
                let _res = split_values[2].parse::<f32>();
                let resolution: Option<f32> = if _res.is_ok() {Some(_res.unwrap())} else {Option::None};
                let unit = split_values[3];
                let unit = match unit {
                    "V" => DataUnit::V,
                    "mV" => DataUnit::mV,
                    "uV"|"µV" => DataUnit::uV,
                    "nV" => DataUnit::nV,
                    "C"|"°C" => DataUnit::C,
                    "S" => DataUnit::S,
                    "uS"|"µS" => DataUnit::uS,
                    "ARU" => DataUnit::ARU,
                    "N" => DataUnit::N,
                    "n/a" => DataUnit::NA,
                    _ => DataUnit::NA,
                };

    
                let chan = ChannelInfo{
                    header_id,
                    label,
                    reference,
                    resolution,
                    unit
                };
                results.push(chan);
            }
        }    
    }
    results

}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_chan_info() {
        let input = "; Commas in channel names are coded as.
        Ch1=Fp1,,0.0488281,µV";
        let output = parse_chan_info(input);
        let expected = vec![ChannelInfo{
            header_id: "Ch1".to_string(),
            label: "Fp1".to_string(),
            reference: "".to_string(),
            resolution: Some(0.0488281),
            unit: DataUnit::uV,
        }];
        assert_eq!(output, expected);
    }

    #[test]
    fn test_parse_chan_info_empty() {
        let input = "[Common Infos]
        Codepage=
        DataFile=01_data.eeg";
        let output = parse_chan_info(input);
        let expected = vec![];
        assert_eq!(output, expected);
    }

}