489 lines
16 KiB
Rust
489 lines
16 KiB
Rust
use std::{collections::HashMap, hash::Hash, u64, vec};
|
|
|
|
use crate::SignalFormat;
|
|
|
|
/// Holds the essential header information about the record, like the amount of
|
|
/// signals, and the sampling frequency.
|
|
///
|
|
/// Only the `name`, `signal_count`, and `sampling_freq` values are required by
|
|
/// default.
|
|
#[derive(Debug, Clone)]
|
|
struct Record {
|
|
name: String,
|
|
seg_num: Option<u64>,
|
|
signal_count: usize,
|
|
sampling_freq: u64,
|
|
counter_freq: Option<u64>,
|
|
base_counter_val: Option<u64>,
|
|
sample_num: Option<u64>,
|
|
basetime: Option<String>, // I dont thing we really need to care much about these
|
|
basedate: Option<String>
|
|
}
|
|
|
|
impl Record {
|
|
/// Attempts to generate the record information from a string of the argument
|
|
/// line that's provided by the WFDB header file
|
|
///
|
|
/// Returns a `Result<Record, &str>`, with the error field potentially
|
|
/// describing why the parsing operation failed
|
|
pub fn from_str(argument_line: &str) -> Result<Record, &str> {
|
|
let args: Vec<&str> = argument_line.split(' ').collect();
|
|
if args.len() < 2 {
|
|
return Err("error: header file provided lacks sufficient record arguments.");
|
|
}
|
|
let name = args[0].to_string();
|
|
let seg_num: Option<u64>;
|
|
let sig_count: usize;
|
|
let sampling_freq: u64;
|
|
// Everything else is initialized with None, this is for sake of me not getting a stroke
|
|
let mut counter_freq: Option<u64> = None;
|
|
let mut base_counter_val: Option<u64> = None;
|
|
let mut sample_num: Option<u64> = None;
|
|
let mut basetime: Option<String> = None;
|
|
let mut basedate: Option<String> = None;
|
|
|
|
|
|
// Signals and segments are kept in a single argument organized as signal/segment
|
|
// segments are optional and we need to check this too
|
|
{
|
|
let seg_sig: Vec<&str> = args[1].split('/').collect();
|
|
if seg_sig.len() == 2 {
|
|
match seg_sig[1].parse::<u64>() {
|
|
Ok(value) => {
|
|
seg_num = Some(value);
|
|
}
|
|
Err(_) => {
|
|
return Err("error: failed to parse segment number from header.");
|
|
}
|
|
}
|
|
} else {
|
|
seg_num = None;
|
|
}
|
|
match seg_sig[0].parse::<usize>() {
|
|
Ok(value) => {
|
|
sig_count = value;
|
|
}
|
|
Err(_) => {
|
|
return Err("error: failed to parse signal number from header.");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parse everything else, if present
|
|
loop { // This is apparently the way to get safe correct goto-like behaviour
|
|
if args.len() <= 2 { // Sampling frequency and counter frequency
|
|
sampling_freq = 250; // Default value
|
|
break;
|
|
}
|
|
|
|
{
|
|
let freq_dual: Vec<&str> = args[2].split('/').collect();
|
|
if freq_dual.len() == 2 {
|
|
match freq_dual[1].parse::<u64>() {
|
|
Ok(value) => {
|
|
counter_freq = Some(value);
|
|
}
|
|
Err(_) => {
|
|
return Err("error: failed to parse counter frequency from header.");
|
|
}
|
|
}
|
|
}
|
|
match freq_dual[0].parse::<u64>() {
|
|
Ok(value) => {
|
|
sampling_freq = value;
|
|
}
|
|
Err(_) => {
|
|
return Err("error: failed to parse sampling frequency from header.");
|
|
}
|
|
}
|
|
}
|
|
|
|
if args.len() <= 3 {break;}
|
|
|
|
match args[3].parse::<u64>() {
|
|
Ok(value) => {
|
|
base_counter_val = Some(value);
|
|
}
|
|
Err(_) => {}
|
|
}
|
|
|
|
if args.len() <= 4 {break;}
|
|
|
|
match args[4].parse::<u64>() {
|
|
Ok(value) => {
|
|
sample_num = Some(value);
|
|
}
|
|
Err(_) => {}
|
|
}
|
|
|
|
if args.len() <= 5 {break;}
|
|
|
|
basetime = Some(args[5].to_string());
|
|
|
|
if args.len() <= 6 {break;}
|
|
|
|
basedate = Some(args[6].to_string());
|
|
|
|
break;
|
|
}
|
|
Ok(Record {
|
|
name: name,
|
|
seg_num: seg_num,
|
|
signal_count: sig_count,
|
|
sampling_freq: sampling_freq,
|
|
counter_freq: counter_freq,
|
|
base_counter_val: base_counter_val,
|
|
sample_num: sample_num,
|
|
basetime: basetime,
|
|
basedate: basedate
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Keys for all the data that can possibly be parsed from the values appended
|
|
/// to the ADC block
|
|
#[derive(Debug, Eq, Hash, PartialEq)]
|
|
enum AdcBlockKeys {
|
|
Gain,
|
|
Baseline,
|
|
Units
|
|
}
|
|
|
|
/// Holds the information relevant to individual signals and their specifications
|
|
///
|
|
/// By minimum, only carries the `filename`, `format`, and `adc_zero` attributes
|
|
#[derive(Debug, Clone)]
|
|
pub struct SignalSpec {
|
|
filename: String,
|
|
format: SignalFormat,
|
|
samples_frame: Option<u64>,
|
|
skew: Option<u64>,
|
|
offset: Option<u64>,
|
|
adc_gain: Option<f64>,
|
|
baseline: Option<i64>,
|
|
units: Option<String>,
|
|
adc_resolution: Option<u64>,
|
|
adc_zero: i64,
|
|
initial_val: Option<i64>,
|
|
checksum: Option<i64>,
|
|
blocksize: Option<u64>,
|
|
desc: Option<String>
|
|
}
|
|
|
|
impl SignalSpec {
|
|
/// Attempts to generate a valid signal specification struct from a supplied
|
|
/// string.
|
|
/// Returns a `Result<SignalSpec, &str>` containing possible error information
|
|
/// relevant to parsing failures.
|
|
///
|
|
/// ## Arguments
|
|
/// - `argument_line` - argument line for the signal specification, taken
|
|
/// from header file
|
|
pub fn from_str(argument_line: &str) -> Result<SignalSpec, &str> {
|
|
let args: Vec<&str> = argument_line.split(' ').collect();
|
|
|
|
if args.len() < 2 {
|
|
return Err("error: signal provided by header file lacks sufficient arguments.");
|
|
}
|
|
let name = args[0].to_string();
|
|
let sigformat: SignalFormat;
|
|
// Optional args
|
|
let samples_frame: Option<u64> = None;
|
|
let skew: Option<u64> = None;
|
|
let offset: Option<u64> = None;
|
|
let mut adc_gain: Option<f64> = None;
|
|
let mut baseline: Option<i64> = None;
|
|
let mut units: Option<String> = None;
|
|
let mut adc_resolution: Option<u64> = None;
|
|
let mut adc_zero:i64 = 0;
|
|
let mut initial_val: Option<i64> = None;
|
|
let mut checksum: Option<i64> = None;
|
|
let mut blocksize: Option<u64> = None;
|
|
let mut desc: Option<String> = None;
|
|
|
|
// TODO: implement samplesperframe, skew, and offset
|
|
match args[1].parse::<u64>() {
|
|
Ok(value) => {
|
|
sigformat = SignalSpec::parse_format(value);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: unable to parse format from signal");
|
|
}
|
|
}
|
|
|
|
loop {
|
|
if args.len() <= 2 {
|
|
break;
|
|
}
|
|
|
|
{
|
|
let mut results: HashMap<AdcBlockKeys, String> = HashMap::new();
|
|
let mut buffer: String = String::new();
|
|
let mut found_baseline = false;
|
|
let mut found_units = false;
|
|
|
|
// Parse through all the characters and get the individual parts
|
|
for character in args[2].chars() {
|
|
loop {
|
|
if !found_baseline && !found_units && character == '(' {
|
|
found_baseline = true;
|
|
results.insert(AdcBlockKeys::Gain, buffer);
|
|
buffer = String::new();
|
|
break;
|
|
}
|
|
else if found_baseline && character == ')' {
|
|
results.insert(AdcBlockKeys::Baseline, buffer);
|
|
buffer = String::new();
|
|
break;
|
|
}
|
|
else if !found_units && character == '/' {
|
|
found_units = true;
|
|
if !found_baseline {
|
|
results.insert(AdcBlockKeys::Gain, buffer);
|
|
}
|
|
buffer = String::new();
|
|
break;
|
|
}
|
|
buffer.push(character);
|
|
break;
|
|
}
|
|
}
|
|
if found_units {
|
|
results.insert(AdcBlockKeys::Units, buffer);
|
|
}
|
|
|
|
// Try and get the actual values out of the results
|
|
match results.get(&AdcBlockKeys::Gain) {
|
|
Some(value ) => {
|
|
match value.parse::<f64>() {
|
|
Ok(parsed) => {
|
|
adc_gain = Some(parsed);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: Signal contains adc gain block with invalid entry");
|
|
}
|
|
}
|
|
},
|
|
None => {
|
|
return Err("error: Signal contains adc gain block but the block is empty.");
|
|
}
|
|
}
|
|
|
|
match results.get(&AdcBlockKeys::Baseline) {
|
|
Some(value) => {
|
|
match value.parse::<i64>() {
|
|
Ok(parsed) => {
|
|
baseline = Some(parsed);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: Unable to parse baseline from signal");
|
|
}
|
|
}
|
|
},
|
|
None => {}
|
|
}
|
|
match results.get(&AdcBlockKeys::Units) {
|
|
Some(value) => {
|
|
units = Some(value.clone());
|
|
},
|
|
None => {}
|
|
}
|
|
}
|
|
|
|
if args.len() <= 3 {
|
|
break;
|
|
}
|
|
match args[3].parse::<u64>() {
|
|
Ok(value) => {
|
|
adc_resolution = Some(value);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: unable to parse resolution from signal");
|
|
}
|
|
}
|
|
|
|
if args.len() <= 4 {
|
|
break;
|
|
}
|
|
match args[4].parse::<i64>() {
|
|
Ok(value) => {
|
|
adc_zero = value;
|
|
},
|
|
Err(_) => {
|
|
adc_zero = 0; // Standard: If this field is missing, a value of zero is assumed.
|
|
}
|
|
}
|
|
|
|
if args.len() <= 5 {
|
|
break;
|
|
}
|
|
match args[5].parse::<i64>() {
|
|
Ok(value) => {
|
|
initial_val = Some(value);
|
|
},
|
|
// Standard: If this field is missing,
|
|
// the adc_zero value is presumed.
|
|
// We do this on the data parsing part.
|
|
Err(_) => {}
|
|
}
|
|
|
|
if args.len() <= 6 {
|
|
break;
|
|
}
|
|
match args[6].parse::<i64>() {
|
|
Ok(value) => {
|
|
checksum = Some(value);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: unable to parse checksum from signal");
|
|
}
|
|
}
|
|
|
|
if args.len() <= 7 {
|
|
break;
|
|
}
|
|
match args[7].parse::<u64>() {
|
|
Ok(value) => {
|
|
blocksize = Some(value);
|
|
},
|
|
Err(_) => {
|
|
return Err("error: unable to parse block size from signal");
|
|
}
|
|
}
|
|
|
|
if args.len() <= 8 {
|
|
break;
|
|
}
|
|
desc = Some(args[8].to_string());
|
|
|
|
break;
|
|
}
|
|
|
|
Ok(
|
|
SignalSpec { filename: name,
|
|
format: sigformat,
|
|
samples_frame: samples_frame,
|
|
skew: skew, offset: offset,
|
|
adc_gain: adc_gain,
|
|
baseline: baseline,
|
|
units: units,
|
|
adc_resolution: adc_resolution,
|
|
adc_zero: adc_zero,
|
|
initial_val: initial_val,
|
|
checksum: checksum,
|
|
blocksize: blocksize,
|
|
desc: desc }
|
|
)
|
|
}
|
|
|
|
/// Parses the WFDB signal format from the format number, if it exists and
|
|
/// is implemented
|
|
fn parse_format(formatnum: u64) -> SignalFormat {
|
|
match formatnum {
|
|
16 => SignalFormat::Format16,
|
|
212 => SignalFormat::Format212,
|
|
0..=u64::MAX => SignalFormat::Unimpl
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Holds all the possible data from the WFDB header file, those being the record
|
|
/// line data and all the possible signal specifications present on the following
|
|
/// lines
|
|
#[derive(Debug, Clone)]
|
|
pub struct Header {
|
|
record: Option<Record>,
|
|
signal_specs: Vec<SignalSpec>
|
|
}
|
|
|
|
impl Header {
|
|
/// Creates a completely empty, not fully initialized header
|
|
///
|
|
/// This is a workaround because I couldn't figure out how to make the compiler
|
|
/// accept non-initializing the value for the first pass of a for loop in
|
|
/// `parse_header()`
|
|
fn new() -> Header {
|
|
Header { record: None, signal_specs: vec![] }
|
|
}
|
|
|
|
/// Creates a Header from a supplied Record struct.
|
|
///
|
|
/// Initializes the signal_specs vector with the correct capacity provided
|
|
/// by the record.
|
|
fn with_record(record: Record) -> Header {
|
|
let capacity = record.signal_count;
|
|
Header { record: Some(record), signal_specs: Vec::with_capacity(capacity) }
|
|
}
|
|
|
|
fn add_signal_spec(&mut self, spec: SignalSpec) {
|
|
self.signal_specs.push(spec);
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
match self.record {
|
|
Some(_) => false,
|
|
None => true
|
|
}
|
|
}
|
|
|
|
pub fn signals_per_file(&self) -> HashMap<String, u64> {
|
|
let mut map: HashMap<String, u64> = HashMap::new();
|
|
for signal in &self.signal_specs {
|
|
map.entry(signal.filename.clone()).and_modify(|val: &mut u64| *val += 1 ).or_insert(1);
|
|
}
|
|
return map;
|
|
}
|
|
}
|
|
|
|
/// Attempts to parse the header file.
|
|
///
|
|
/// Returns a Result either containing the `Header` struct, or the
|
|
/// error string describing why we couldn't parse the header.
|
|
pub fn parse_header(header_data: &str) -> Result<Header, &str> {
|
|
let header_lines: Vec<&str> = header_data.split("\n").collect();
|
|
let mut found_record: bool = false;
|
|
let mut header: Header = Header::new();
|
|
let mut specs_read: usize = 0;
|
|
let mut specs_max: usize = 0;
|
|
for line in header_lines {
|
|
// Ignore commented lines
|
|
if line.starts_with("#") {
|
|
continue;
|
|
}
|
|
|
|
if !found_record {
|
|
let possible_record = Record::from_str(line);
|
|
match possible_record {
|
|
Ok(rec) => {
|
|
specs_max = rec.signal_count;
|
|
header = Header::with_record(rec);
|
|
found_record = true;
|
|
continue;
|
|
}
|
|
Err(e) => {
|
|
return Err(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
let possible_spec = SignalSpec::from_str(line);
|
|
match possible_spec {
|
|
Ok(spec) => {
|
|
header.add_signal_spec(spec);
|
|
}
|
|
Err(e) => {
|
|
return Err(e);
|
|
}
|
|
}
|
|
|
|
specs_read += 1;
|
|
if specs_read >= specs_max {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if header.is_empty() {
|
|
return Err("Unable to parse valid header information");
|
|
}
|
|
Ok(header)
|
|
} |