private void loadFileToolStripMenuItem_Click(object sender, EventArgs e)
{
DialogResult result;
OpenFileDialog ofd = new OpenFileDialog();
result = ofd.ShowDialog();
if (result != DialogResult.OK)
{
return;
}
EDFFile EdfFile = new EDFFile();
EdfFile.readFile(ofd.FileName);
var d = new ChannelSelectionForm(EdfFile.Header);
result = d.ShowDialog();
if (result != DialogResult.OK)
{
return;
}
psgViewControl1.SetEdfFile(EdfFile, d.ChannelConfigurations);
psgViewControl1.Invalidate();
psgViewControl1.Update();
}
/// <summary>
/// Returns a signal's Y axis minimum bound
/// </summary>
/// <param name="Signal"> The signal to return Y axis bounds for </param>
/// <param name="woBias"> True if the returned bounds assumes 0 DC </param>
/// <param name="LoadedEDFFile"> The EDF File with all the signal's values in it </param>
/// <param name="sm"> The settings model containing the bounds </param>
/// <returns> The min y axis bounds of a signal</returns>
public static double GetMinSignalValue(string Signal, bool woBias, EDFFile LoadedEDFFile, SettingsModel sm)
{
// Check if the Y Bounds have already been calculated
SignalYAxisExtremes find = sm.SignalsYAxisExtremes.Find(temp => temp.SignalName.Trim() == Signal.Trim());
if (find != null) // If the Y Bounds have been calculated
{
if (!Double.IsNaN(find.yMin) && !Double.IsNaN(find.yAvr)) // Double check if the Y Bounds have been calculated
{
// Remove DC bias?
if (woBias) // Yes
{
return(find.yMin - find.yAvr);
}
else // No
{
return(find.yMin);
}
}
else // Calculate Y Bounds
{
SetYBounds(Signal, LoadedEDFFile, sm);
return(GetMinSignalValue(Signal, woBias, LoadedEDFFile, sm));
}
}
else // Calculate Y Bounds
{
SetYBounds(Signal, LoadedEDFFile, sm);
return(GetMinSignalValue(Signal, woBias, LoadedEDFFile, sm));
}
}
/// <summary>
/// 回放文件初始化
/// </summary>
/// <param name="filePath">edf/edfx文件路径</param>
public void initReplayFile(String filePath)
{
var sw = Stopwatch.StartNew();//运行时间测量对象
/*
* TEDF.ReadFile(filePath);
* TEDF.GetListDataByTime(0, 10);
*
* Console.WriteLine(sw.ElapsedMilliseconds);
*/
sw.Restart(); //停止时间间隔测量，将运行时间重置为零，然后开始测量运行时间。
this._replayFile = null; //初始化 播放文件
this._replayFile = new EDFFile(); //实例化 播放文件
this._replayFile.readFile(filePath); //读取EDF 文件
Console.WriteLine("SW输出" + sw.ElapsedMilliseconds);
this.edfCompatible(this._replayFile); //EDF兼容
this.calcAVG(this._replayFile); //计算AVG
if (this._replayFile == null)
{
throw new Exception("initReplayFile Exception: replayFile is null");
}
this.initMarkInfo(filePath);
this.second = 1;
this.drawEEG(true, true);
}
/// <summary>
/// 计算AVG
/// </summary>
/// <param name="replayFile"></param>
private void calcAVG(EDFFile edfFile)
{
// 1.添加AVG信道
EDFSignal signalAVG = new EDFSignal();
signalAVG.Label = "AVG";
signalAVG.IndexNumber = edfFile.Header.Signals.Count + 1;
signalAVG.NumberOfSamplesPerDataRecord = edfFile.Header.Signals[0].NumberOfSamplesPerDataRecord;
edfFile.Header.Signals.Add(signalAVG);
// 2.添加AVG数据
for (int i = 0; i < edfFile.MyDataRecords.Count; i++)
{
MyEDFDataRecord record = edfFile.MyDataRecords[i];
float sum = 0f;
float avg = 0f;
for (int j = 0; j < record.Count; j++)
{
sum += record[j];
}
avg = sum / record.Count;
record.Add(avg);
}
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
string fileName = null;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter =
"EDF files (*.edf)|*.edf|All files (*.*)|*.*";
dialog.InitialDirectory = initialDirectory;
dialog.Title = "Select a EDF file";
if (dialog.ShowDialog() == DialogResult.OK)
{
fileName = dialog.FileName;
}
dialog.Dispose();
if (fileName != null)
{
toolStripStatusLabel1.Text = "Opening " + fileName;
edfFileInput = new EDFFile();
edfFileInput.readFile(fileName);
}
listBox1.Items.Clear();
foreach (EDFSignal signal in edfFileInput.Header.Signals)
{
listBox1.Items.Add(signal);
}
}
public void LoadFromEdfFile(EDFFile file, EDFSignal signal, EDFSignal reference)
{
Label = signal.Label;
ReferenceLabel = reference?.Label ?? "mono";
SampleRate = signal.NumberOfSamplesPerDataRecord / file.Header.DurationOfDataRecordInSeconds;
int numberOfSamples = signal.NumberOfSamplesPerDataRecord * file.Header.NumberOfDataRecords;
Data = new float[numberOfSamples];
ViewAmplitude = 0.005F;
for (int i = 0; i < Data.Length; i++)
{
EDFDataRecord record = file.DataRecords[i / signal.NumberOfSamplesPerDataRecord];
float[] recordData = record[signal.IndexNumber];
if (reference == null)
{
Data[i] = recordData[i % signal.NumberOfSamplesPerDataRecord];
}
else
{
EDFDataRecord refRecord = file.DataRecords[i / signal.NumberOfSamplesPerDataRecord];
float[] refRecordData = refRecord[reference.IndexNumber];
Data[i] = recordData[i % reference.NumberOfSamplesPerDataRecord] - refRecordData[i % reference.NumberOfSamplesPerDataRecord];
}
}
}
private static void Example2_Read_EDF_From_Base64(string edfBase64FilePath)
{
var edfBase64 = File.ReadAllText(edfBase64FilePath);
var edfFile = new EDFFile();
edfFile.ReadBase64(edfBase64);
edfFile.Save(@"C:\temp\edf_bytes.edf");
}
/// <summary>
/// Background process for loading edf file
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BW_LoadEDFFile(object sender, DoWorkEventArgs e)
{
// Read EDF File
EDFFile temp = new EDFFile();
temp.readFile(e.Argument.ToString());
LoadedEDFFile = temp;
}
public void clearFiles()
{
edfFileInput = null;
edfFileOutput = null;
System.GC.Collect();
listBox1.Items.Clear();
listBox2.Items.Clear();
}
public void GivenChecksumFile_DoesNotDecodeFileContents()
{
const string checksum = "218:13:2:176";
GivenDataFileWithContents(FILE_NAME, checksum);
var file = new EDFFile(FILE_NAME, DataFiles.Checksum);
Assert.AreEqual(1, file.Data.Count);
Assert.AreEqual(checksum, file.Data.Values.Single());
}
// EDF File Parsing
/// <summary>
/// Modified From EDF library function https://edf.codeplex.com/SourceControl/latest#trunk/EDFFile.cs
/// Gets the signal samples from one period of time to another
/// </summary>
/// <param name="file"> The EDFFile class </param>
/// <param name="signal_to_retrieve"> The signal to get samples from </param>
/// <param name="StartTime"> The start time to get samples from </param>
/// <param name="EndTime"> The end time to get samples from </param>
/// <returns> A list of the retrieved samples </returns>
public static List <float> retrieveSignalSampleValuesMod(EDFFile file, EDFSignal signal_to_retrieve, DateTime StartTime, DateTime EndTime)
{
int start_sample, start_record;
int end_sample, end_record;
#region Find Start and End Points
// Duration of record in seconds
double record_duration = file.Header.DurationOfDataRecordInSeconds;
// Samples per record
double samples_per_record = signal_to_retrieve.NumberOfSamplesPerDataRecord;
// The sample period of the signal (Duration of Record)/(Samples per Record)
double sample_period = record_duration / samples_per_record;
{
// Time of start point in seconds
double total_seconds = (StartTime - file.Header.StartDateTime).TotalSeconds;
// Time of start point in samples
double total_samples = total_seconds / sample_period;
start_sample = ((int)(total_samples)) % ((int)samples_per_record); // Start Sample in Record
start_record = (int)((total_samples - start_sample) / samples_per_record); // Start Record
}
{
// Time of end point in seconds
double total_seconds = (EndTime - file.Header.StartDateTime).TotalSeconds;
// Time of end point in samples
double total_samples = total_seconds / sample_period - 1;
end_sample = ((int)total_samples) % ((int)samples_per_record); // End Sample in Record
end_record = (((int)total_samples) - end_sample) / ((int)samples_per_record); // End Record
}
#endregion
List <float> signalSampleValues = new List <float>();
if (file.Header.Signals.Contains(signal_to_retrieve))
{
for (int x = start_record; x <= end_record; x++)
{
EDFDataRecord dr = file.DataRecords[x];
foreach (EDFSignal signal in file.Header.Signals)
{
if (signal.IndexNumberWithLabel.Equals(signal_to_retrieve.IndexNumberWithLabel))
{
int start = x == start_record ? start_sample : 0;
int end = x == end_record ? end_sample : dr[signal.IndexNumberWithLabel].Count - 1;
for (int y = start; y <= end; y++)
{
signalSampleValues.Add(dr[signal.IndexNumberWithLabel][y]);
}
}
}
}
}
return(signalSampleValues);
}
public void GivenCreditsFile_DoesNotDecodeFileContents_SplitsByLines()
{
const string credits = "Created By\nMe :)\nMe again!";
GivenDataFileWithContents(FILE_NAME, credits);
var file = new EDFFile(FILE_NAME, DataFiles.Credits);
var expectedCredits = credits.Split('\n');
CollectionAssert.AreEqual(expectedCredits, file.Data.Values);
}
public void NonSpecialDataFiles_AreDecodedCorrectly()
{
const string fileData = "a7b6cg1f2e3d4 5";
const string expectedString = "abc12345 defg67";
GivenDataFileWithContents(FILE_NAME, fileData);
var valuesToTest = ((DataFiles[])Enum.GetValues(typeof(DataFiles))).Skip(3);
foreach (var file in valuesToTest)
{
var edf = new EDFFile(FILE_NAME, file);
Assert.AreEqual(expectedString, edf.Data.Values.Single());
}
}
public void GivenCurseFile_DecodeStringDelimitedByColons()
{
const string curseString = "CsusrAs:e5:4C3uErSsReU2C:";
GivenDataFileWithContents(FILE_NAME, curseString);
var file = new EDFFile(FILE_NAME, DataFiles.CurseFilter);
var expectedCurses = new[]
{
"Curse", "Curse2", "CURSE345", "Ass"
};
CollectionAssert.AreEqual(expectedCurses, file.Data.Values);
}
public void NonSpecialDataFiles_AreDecodedCorrectly_MultipleLines()
{
const string fileData = "a7b6cg1f2e3d4 5\na7b6cg1f2e3d4 5";
var expectedStrings = new[] { "abc12345 defg67", "abc12345 defg67" };
GivenDataFileWithContents(FILE_NAME, fileData);
var valuesToTest = ((DataFiles[])Enum.GetValues(typeof(DataFiles))).Skip(3);
foreach (var file in valuesToTest)
{
var edf = new EDFFile(FILE_NAME, file);
CollectionAssert.AreEqual(expectedStrings, edf.Data.Values);
}
}
private void initializeEDFOutput()
{
edfFileOutput = new EDFFile();
edfFileOutput.Header.DurationOfDataRecordInSeconds = edfFileInput.Header.DurationOfDataRecordInSeconds;
edfFileOutput.Header.NumberOfBytes = edfFileInput.Header.NumberOfBytes;
edfFileOutput.Header.PatientIdentification = edfFileInput.Header.PatientIdentification;
edfFileOutput.Header.RecordingIdentification = edfFileInput.Header.RecordingIdentification;
edfFileOutput.Header.Reserved = edfFileInput.Header.Reserved;
edfFileOutput.Header.StartDateTime = edfFileInput.Header.StartDateTime;
edfFileOutput.Header.Version = edfFileInput.Header.Version;
foreach (EDFDataRecord dr in edfFileInput.DataRecords)
{
edfFileOutput.DataRecords.Add(new EDFDataRecord());
}
}
public void LoadFromChannelConfigurations(EDFFile file, ChannelConfiguration[] configurations)
{
Duration = file.Header.DurationOfDataRecordInSeconds * file.Header.NumberOfDataRecords;
Channels = new Timeseries[configurations.Length];
VisibleChannels = new bool[configurations.Length];
for (int i = 0; i < Channels.Length; i++)
{
Channels[i] = new Timeseries();
Channels[i].LoadFromEdfFile(file, configurations[i].Signal, configurations[i].Reference);
VisibleChannels[i] = configurations[i].IsShown;
}
}
public void GivenCurseFile_DecodeStringDelimitedByColons_HandlesMultipleLines()
{
const string curseString = "CsusrAs:e5:4C3uErSsReU2C:\nARBQCPDOEN:MF:GLHKIJ:";
GivenDataFileWithContents(FILE_NAME, curseString);
var file = new EDFFile(FILE_NAME, DataFiles.CurseFilter);
var expectedCurses = new[]
{
"Curse", "Curse2", "CURSE345", "Ass",
"ABCDE", "FGHI", "JKL", "MNOPQR"
};
CollectionAssert.AreEqual(expectedCurses, file.Data.Values);
}
public void NonSpecialDataFiles_SwapAdjacentCharacterValues_MultiplesOfSeven()
{
//p, p, and i are adjacent multiples of 7 in this example
//see https://eoserv.net/wiki/EDF_Data_Files for more info
//the expected string would be Crazy steippng without this step
const string fileData = "Cgrnapzpyi est";
var expectedString = "Crazy stepping";
GivenDataFileWithContents(FILE_NAME, fileData);
var valuesToTest = ((DataFiles[])Enum.GetValues(typeof(DataFiles))).Skip(3);
foreach (var file in valuesToTest)
{
var edf = new EDFFile(FILE_NAME, file);
Assert.AreEqual(expectedString, edf.Data.Values.Single());
}
}
private float[] ReadSignalFile(string fileName)
{
var signalSamples = new List <float>();
if (File.Exists(fileName))
{
string ext = Path.GetExtension(fileName).Replace(".", "");
if (ext.ToUpper() == "CSV" || ext.ToUpper() == "TXT")
{
using (var reader = new StreamReader(fileName)) {
string line;
while ((line = reader.ReadLine()) != null)
{
float sample;
if (float.TryParse(line, out sample))
{
signalSamples.Add(sample);
}
}
}
}
if (ext.ToUpper() == "EDF")
{
var edfFile = new EDFFile();
edfFile.Open(fileName);
if (edfFile.Signals.Length >= 1)
{
for (int i = 0; i < edfFile.Signals[0].Samples.Length; i++)
{
//NOTE: Resolution may be different for each ECG sensor
float resolution = 1.8f;
var sample = edfFile.Signals[0].Samples[i] * resolution;
signalSamples.Add(sample);
}
}
}
}
return(signalSamples.ToArray());
}
/// <summary>
/// Loads the derivative definitions into memory
/// </summary>
/// <param name="LoadedEDFFile"> The loaded EDF structure </param>
/// <returns> The derivative definitions </returns>
public static DerivativeSignal[] LoadDerivativesFile(EDFFile LoadedEDFFile)
{
if (!Directory.Exists(settings_folder))
{
Directory.CreateDirectory(settings_folder);
}
List <DerivativeSignal> output = new List <DerivativeSignal>();
if (File.Exists(settings_folder + "\\common_derivatives.txt"))
{
StreamReader sr = new StreamReader(settings_folder + "\\common_derivatives.txt");
List <string> text = sr.ReadToEnd().Replace("\r\n", "\n").Split('\n').ToList();
for (int x = 0; x < text.Count; x++)
{
string[] new_entry = text[x].Split(',');
if (new_entry.Length == 3)
{
if (LoadedEDFFile == null || LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == new_entry[1].Trim()) != null) // Signals Exist
{
if (LoadedEDFFile == null || LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == new_entry[2].Trim()) != null) // Signals Exist
{
if (LoadedEDFFile == null || LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == new_entry[0].Trim()) == null) // Unique Name
{
if (LoadedEDFFile == null || output.Where(temp => temp.DerivativeName.Trim() == new_entry[0].Trim()).ToList().Count == 0) // Unique Name
{
output.Add(new DerivativeSignal(new_entry[0], new_entry[1], new_entry[2]));
}
}
}
}
}
}
sr.Close();
}
return(output.ToArray());
}
private void changePatientNamesBatchToolStripMenuItem_Click(object sender, EventArgs e)
{
string[] fileNames = null;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter =
"EDF files (*.edf)|*.edf|All files (*.*)|*.*";
dialog.InitialDirectory = initialDirectory;
dialog.Title = "Select a EDF file";
dialog.Multiselect = true;
if (dialog.ShowDialog() == DialogResult.OK)
{
fileNames = dialog.FileNames;
}
dialog.Dispose();
if (fileNames != null)
{
foreach (string fileName in fileNames)
{
statusStrip1.Text = "Opening " + fileName;
edfFileOutput = new EDFFile();
edfFileOutput.readFile(fileName);
if (Path.GetFileName(fileName).Contains("_"))
{
edfFileOutput.Header.PatientIdentification.PatientCode = Path.GetFileName(fileName).Split('_')[0];
}
else
{
edfFileOutput.Header.PatientIdentification.PatientCode = "XXXX";
}
edfFileOutput.Header.PatientIdentification.PatientBirthDate = edfFileOutput.Header.PatientIdentification.PatientBirthDate.AddYears(10);
edfFileOutput.Header.PatientIdentification.PatientName = Path.GetFileName(fileName);
edfFileOutput.saveFile(fileName);
}
}
edfFileOutput = null;
}
/// <summary>
/// Converts a DateTime structure into an epoch point in time
/// </summary>
/// <param name="time"> The DateTime structure to convert </param>
/// <param name="file">
/// The EDFFile class used to determine the start
/// DateTime corresponding to epoch 0
/// </param>
/// <returns> The epoch point in time corresponding to the input DateTime </returns>
public static int DateTimetoEpoch(DateTime time, EDFFile file)
{
// epoch = (DateTime - StartTime) / EPOCH_SEC
return((int)((time - file.Header.StartDateTime).TotalSeconds / (double)EPOCH_SEC) + 1);
}
private void edfCompatible(EDFFile edfFile)
{
if (edfFile.isEDFXFile())
{
return;
}
for (int i = 0; i < edfFile.Header.Signals.Count; i++)
{
EDFSignal signal = edfFile.Header.Signals[i];
String label = signal.Label;
if (label.StartsWith("EEG "))
{
label = label.Replace("EEG ", "");
}
if (label.StartsWith("ECG "))
{
label = label.Replace("ECG ", "");
}
if (label.EndsWith("-REF", StringComparison.InvariantCultureIgnoreCase))
{
label = label.Replace("-REF", "");
label = label.Replace("-Ref", "");
}
switch (label)
{
case "EKG":
signal.Label = "X1-Y1";
continue;
case "EMG-LS":
signal.Label = "X5-Y5";
continue;
case "EMG-RS":
signal.Label = "X6-Y6";
continue;
case "PG1":
case "FT9":
signal.Label = "T1";
continue;
case "PG2":
case "FT10":
signal.Label = "T2";
continue;
case "X1-Y1":
case "X5-Y5":
case "X6-Y6":
continue;
}
/*
* if (label.Equals("PG1") || label.Equals("FT9"))
* {
* label = "T1";
* }
* if (label.Equals("PG2") || label.Equals("FT10"))
* {
* label = "T2";
* }
*
* if (label.Equals("X1-Y1"))
* {
* label = "EKG";
* }
* if (label.Equals("X5-Y5"))
* {
* label = "EMG-LS";
* }
* if (label.Equals("X6-Y6"))
* {
* label = "EMG-RS";
* }
*
* if (label.Equals("T1") || label.Equals("T2") || label.Equals("EKG") || label.Equals("EMG-LS") || label.Equals("EMG-RS"))
* {
* signal.Label = label;
* continue;
* }
*/
Boolean isHave = false;
string value = null;
Dictionary <int, string> .Enumerator e = this.leadSource.GetEnumerator();
while (e.MoveNext())
{
KeyValuePair <int, string> kv = e.Current;
if (kv.Value.ToUpper().Equals(label.ToUpper()))
{
isHave = true;
value = kv.Value;
break;
}
}
if (isHave)
{
signal.Label = value;
continue;
}
signal.Label = "ZZZ" + i;
}
}
/// <summary>
/// Given a settings model and edf file, sets the Y axis bounds of a given signal
/// </summary>
/// <param name="Signal"> The signal to set the bounds for </param>
/// <param name="LoadedEDFFile"> The EDF file with the signal's values </param>
/// <param name="sm"> The settings model that bounds are stored in </param>
public static void SetYBounds(string Signal, EDFFile LoadedEDFFile, SettingsModel sm)
{
// Save Signal Name
string OrigName = Signal;
// Check to see if the Signal Y Bounds have already been calculated
SignalYAxisExtremes find = sm.SignalsYAxisExtremes.Find(temp => temp.SignalName.Trim() == Signal.Trim());
// If the Signal Y Bounds have not been calculated
if (find == null)
{
List <float> values = new List <float>();
// Check if this signal needs filtering
FilteredSignal filteredSignal = sm.FilteredSignals.Find(temp => temp.SignalName == Signal);
if (filteredSignal != null)
{
Signal = sm.FilteredSignals.Find(temp => temp.SignalName == Signal).OriginalName;
}
if (LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == Signal) != null) // Regular Signal
{
// Get the EDF Signal Values
EDFSignal edfsignal = LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == Signal);
values = LoadedEDFFile.retrieveSignalSampleValues(edfsignal);
}
else // Derivative Signal
{
// Get Signals
DerivativeSignal deriv_info = sm.DerivedSignals.Find(temp => temp.DerivativeName == Signal);
EDFSignal edfsignal1 = LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == deriv_info.Signal1Name.Trim());
EDFSignal edfsignal2 = LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == deriv_info.Signal2Name.Trim());
// Get Arrays and Perform Resampling if needed
List <float> values1;
List <float> values2;
if (edfsignal1.NumberOfSamplesPerDataRecord == edfsignal2.NumberOfSamplesPerDataRecord) // No resampling
{
values1 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal1);
values2 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal2);
}
else if (edfsignal1.NumberOfSamplesPerDataRecord > edfsignal2.NumberOfSamplesPerDataRecord) // Upsample signal 2
{
values1 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal1);
values2 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal2);
values2 = Utils.MATLAB_Resample(values2.ToArray(), edfsignal1.NumberOfSamplesPerDataRecord / edfsignal2.NumberOfSamplesPerDataRecord);
}
else // Upsample signal 1
{
values1 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal1);
values2 = LoadedEDFFile.retrieveSignalSampleValues(edfsignal2);
values1 = Utils.MATLAB_Resample(values1.ToArray(), edfsignal2.NumberOfSamplesPerDataRecord / edfsignal1.NumberOfSamplesPerDataRecord);
}
for (int x = 0; x < Math.Min(values1.Count, values2.Count); x += 1)
{
values.Add(values1[x] - values2[x]);
}
}
// Remove repeated values
int last_unique = 0;
for (int x = 0; x < values.Count; x++)
{
if (x > 0 && values[x] == values[last_unique])
{
values[x] = float.NaN;
}
else
{
last_unique = x;
}
}
values.RemoveAll(temp => float.IsNaN(temp));
// Find the high and low percentiles of the signal and the average value of the signal
values.Sort();
int high_index = (int)(percent_high / 100 * (values.Count - 1));
int low_index = (int)(percent_low / 100 * (values.Count - 1));
float range = values[high_index] - values[low_index];
float high_value = values[high_index] + range * (100 - (float)percent_high) / 100;
float low_value = values[low_index] - range * ((float)percent_low) / 100;
float av_value = values.Average();
// Save the values so that they do not have to be recalculated
sm.SignalsYAxisExtremes.Add(new SignalYAxisExtremes(OrigName)
{
yMax = high_value, yMin = low_value, yAvr = av_value
});
}
}
public void Test_WriteReadEDF_ShouldReturnSameData()
{
//Write an EDF file with two signals then read it and check the data is correct
var edf1 = new EDFFile();
var ecgSig = new Signal();
ecgSig.Label.Value = "ECG";
ecgSig.SampleCountPerRecord.Value = 10; //Small number of samples for testing
ecgSig.PhysicalDimension.Value = "mV";
ecgSig.DigitalMinimum.Value = -2048;
ecgSig.DigitalMaximum.Value = 2047;
ecgSig.PhysicalMinimum.Value = -10.2325;
ecgSig.PhysicalMaximum.Value = 10.2325;
ecgSig.TransducerType.Value = "UNKNOWN";
ecgSig.Prefiltering.Value = "UNKNOWN";
ecgSig.Reserved.Value = "RESERVED";
ecgSig.Samples = new List <short> {
100, 50, 23, 75, 12, 88, 73, 12, 34, 83
};
var soundSig = new Signal();
soundSig.Label.Value = "SOUND";
soundSig.SampleCountPerRecord.Value = 10;//Small number of samples for testing
soundSig.PhysicalDimension.Value = "mV";
soundSig.DigitalMinimum.Value = -2048;
soundSig.DigitalMaximum.Value = 2047;
soundSig.PhysicalMinimum.Value = -44;
soundSig.PhysicalMaximum.Value = 44.0;
soundSig.TransducerType.Value = "UNKNOWN";
soundSig.Prefiltering.Value = "UNKNOWN";
soundSig.Samples = new List <short> {
11, 200, 300, 123, 87, 204, 145, 234, 222, 75
};
soundSig.Reserved.Value = "RESERVED";
edf1.Signals = new Signal[2] {
ecgSig, soundSig
};
var h = new Header();
h.RecordDurationInSeconds.Value = 1;
h.Version.Value = "0";
h.PatientID.Value = "TEST PATIENT ID";
h.RecordID.Value = "TEST RECORD ID";
h.RecordingStartDate.Value = "11.11.16"; //dd.mm.yy
h.RecordingStartTime.Value = "12.12.12"; //hh.mm.ss
h.Reserved.Value = "RESERVED";
h.RecordCount.Value = 1;
h.SignalCount.Value = (short)edf1.Signals.Length;
h.Signals.Reserveds.Value = Enumerable.Repeat("RESERVED".PadRight(32, ' '), h.SignalCount.Value).ToArray();
edf1.Header = h;
string edfFilePath = @"C:\temp\test1.EDF";
edf1.Save(edfFilePath);
//Read the file back
var edf2 = new EDFFile(edfFilePath);
Assert.AreEqual(edf2.Header.Version.ToAscii(), edf1.Header.Version.ToAscii());
Assert.AreEqual(edf2.Header.PatientID.ToAscii(), edf1.Header.PatientID.ToAscii());
Assert.AreEqual(edf2.Header.RecordID.ToAscii(), edf1.Header.RecordID.ToAscii());
Assert.AreEqual(edf2.Header.RecordingStartDate.ToAscii(), edf1.Header.RecordingStartDate.ToAscii());
Assert.AreEqual(edf2.Header.RecordingStartTime.ToAscii(), edf1.Header.RecordingStartTime.ToAscii());
Assert.AreEqual(edf2.Header.Reserved.ToAscii(), edf1.Header.Reserved.ToAscii());
Assert.AreEqual(edf2.Header.RecordCount.ToAscii(), edf1.Header.RecordCount.ToAscii());
Assert.AreEqual(edf2.Header.SignalCount.ToAscii(), edf1.Header.SignalCount.ToAscii());
Assert.AreEqual(edf2.Header.Signals.Reserveds.ToAscii(), edf1.Header.Signals.Reserveds.ToAscii());
Assert.AreEqual(edf2.Signals[0].Samples.Count, edf1.Signals[0].Samples.Count);
}
/// <summary>
/// Converts an epoch point in time to a DateTime structure
/// </summary>
/// <param name="epoch"> The epoch point in time to convert </param>
/// <param name="file">
/// The EDFFile class used to determine the start
/// DateTime corresponding to epoch 0
/// </param>
/// <returns> A DateTime structure corresponding the input epoch point in time </returns>
public static DateTime EpochtoDateTime(int epoch, EDFFile file)
{
// DateTime = StartTime + (epoch - 1) * EPOCH_SEC
return(file.Header.StartDateTime + new TimeSpan(0, 0, (epoch - 1) * EPOCH_SEC));
}
private static void Example1_Create_And_Save_EDF()
{
//Crreate an empty EDF file
var edfFile = new EDFFile();
//Create a signal object
var ecgSig = new EDFSignal();
ecgSig.Label.Value = "ECG";
ecgSig.NumberOfSamples.Value = 10;
ecgSig.PhysicalDimension.Value = "mV";
ecgSig.DigitalMinimum.Value = -2048;
ecgSig.DigitalMaximum.Value = 2047;
ecgSig.PhysicalMinimum.Value = -10.2325;
ecgSig.PhysicalMaximum.Value = 10.2325;
ecgSig.TransducerType.Value = "UNKNOWN";
ecgSig.Prefiltering.Value = "UNKNOWN";
ecgSig.Reserved.Value = "RESERVED";
ecgSig.Samples = new short[] { 100, 50, 23, 75, 12, 88, 73, 12, 34, 83 };
//Set the signal
edfFile.Signals = new EDFSignal[1] {
ecgSig
};
//Create the header object
var h = new EDFHeader();
h.DurationOfDataRecord.Value = 1;
h.Version.Value = "0";
h.PatientID.Value = "TEST PATIENT ID";
h.RecordID.Value = "TEST RECORD ID";
h.StartDate.Value = "11.11.16"; //dd.mm.yy
h.StartTime.Value = "12.12.12"; //hh.mm.ss
h.Reserved.Value = "RESERVED";
h.NumberOfDataRecords.Value = 1;
h.NumberOfSignals.Value = (short)edfFile.Signals.Length;
h.SignalsReserved.Value = Enumerable.Repeat("RESERVED".PadRight(32, ' '),
h.NumberOfSignals.Value).ToArray();
//Set the header
edfFile.Header = h;
//Print some info
Console.Write(
"\nPatient ID:\t\t" + edfFile.Header.PatientID.Value +
"\nNumber of signals:\t" + edfFile.Header.NumberOfSignals.Value +
"\nStart date:\t\t" + edfFile.Header.StartDate.Value +
"\nSignal label:\t\t" + edfFile.Signals[0].Label.Value +
"\nSignal samples:\t\t"
+ String.Join(",", edfFile.Signals[0].Samples.Skip(0).Take(10).ToArray())
+ "\n\n"
);
//Save the file
string fileName = @"C:\temp\example.edf";
edfFile.Save(fileName);
//Read the file
var f = new EDFFile(fileName);
Console.ReadLine();
}
static void Main(string[] args)
{
//Example1_Create_And_Save_EDF();
//if(args.Length >= 1)
//Example2_Read_EDF_From_Base64(args[0]);
// Read and dump some data
if (args.Count() == 0)
{
Console.WriteLine("Error: Expecting path to folder as argument!");
// Exit code?
return;
}
string filepath = args[0];
DirectoryInfo d = new DirectoryInfo(filepath);
foreach (FileInfo fileInfo in d.GetFiles("*.edf"))
{
Console.WriteLine("======== EDF: " + fileInfo.Name + "========");
DateTime mark = DateTime.Now;
//
EDFFile edf = null;
int signalIndex = -1;
if (args.Count() == 1)
{
// No signal index specified, read the whole file
edf = new EDFFile(fileInfo.FullName);
}
else
{
// Signal specified, just read that one signal
using (edf = new EDFFile())
{
edf.Open(fileInfo.FullName);
// Read specified signals
for (int i = 1; i < args.Count(); i++)
{
Console.WriteLine("Reading signal: " + args[i]);
EDF.Signal signal = edf.ReadSignal(args[i]);
if (signal == null)
{
Console.WriteLine("ERROR: Signal " + args[i] + " not found");
}
}
}
}
// Print loading time
TimeSpan runTime = DateTime.Now - mark;
Console.WriteLine("Load time: " + runTime.TotalSeconds.ToString("0.00") + " s");
// Print headers
Console.WriteLine(edf.Header.ToString());
// Print signals intro
if (signalIndex < 0)
{
// Print all signal
foreach (EDF.Signal s in edf.Signals)
{
Console.WriteLine(s.ToString());
}
}
else
{
// Print the signal we loaded
Console.WriteLine(edf.Signals[signalIndex].ToString());
}
Console.WriteLine("=========================================\n");
//Console.WriteLine("Scaled sample test: " + edf.Signals[31].ScaledSample(0));
//TODO: Test saving files, I guess we would need to fix recording writing function
}
Console.ReadLine();
}
