/// <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);
}
}
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];
}
}
}
// 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);
}
private void buttonOk_Click(object sender, EventArgs e)
{
ChannelConfigurations = new ChannelConfiguration[_signals.Length];
for (int i = 0; i < dgvChannels.RowCount; i++)
{
int index = (int)dgvChannels.Rows[i].Cells[0].Value - 1;
string label = (string)dgvChannels.Rows[i].Cells[1].Value;
bool shown = (bool)dgvChannels.Rows[i].Cells[2].Value;
EDFSignal reference = _signals.SingleOrDefault(s => s.Label == (string)dgvChannels.Rows[i].Cells[3].Value);
ChannelConfigurations[i] = new ChannelConfiguration();
ChannelConfigurations[i].Signal = _signals[index];
ChannelConfigurations[i].Signal.Label = label;
ChannelConfigurations[i].IsShown = shown;
ChannelConfigurations[i].Reference = reference;
}
DialogResult = DialogResult.OK;
Close();
}
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();
}
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 EDFSignal();
ecgSig.Label.Value = "ECG";
ecgSig.NumberOfSamples.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 short[] { 100, 50, 23, 75, 12, 88, 73, 12, 34, 83 };
var soundSig = new EDFSignal();
soundSig.Label.Value = "SOUND";
soundSig.NumberOfSamples.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 short[] { 11, 200, 300, 123, 87, 204, 145, 234, 222, 75 };
soundSig.Reserved.Value = "RESERVED";
edf1.Signals = new EDFSignal[2] {
ecgSig, soundSig
};
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)edf1.Signals.Length;
h.SignalsReserved.Value = Enumerable.Repeat("RESERVED".PadRight(32, ' '), h.NumberOfSignals.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.StartDate.ToAscii(), edf1.Header.StartDate.ToAscii());
Assert.AreEqual(edf2.Header.StartTime.ToAscii(), edf1.Header.StartTime.ToAscii());
Assert.AreEqual(edf2.Header.Reserved.ToAscii(), edf1.Header.Reserved.ToAscii());
Assert.AreEqual(edf2.Header.NumberOfDataRecords.ToAscii(), edf1.Header.NumberOfDataRecords.ToAscii());
Assert.AreEqual(edf2.Header.NumberOfSignals.ToAscii(), edf1.Header.NumberOfSignals.ToAscii());
Assert.AreEqual(edf2.Header.SignalsReserved.ToAscii(), edf1.Header.SignalsReserved.ToAscii());
Assert.AreEqual(edf2.Signals[0].Samples.Length, edf1.Signals[0].Samples.Length);
}
/// <summary>
/// From a signal, returns a series of X,Y values for use with a PlotModel
/// Also returns y axis information and the sample_period of the signal
/// </summary>
/// <param name="sample_period"> Variable to contain the sample period of the signal </param>
/// <param name="Signal"> The input signal name </param>
/// <param name="StartTime"> The input start time to be contained in the series </param>
/// <param name="EndTime"> The input end time to be contained in the series </param>
/// <returns> The series of X,Y values to draw on the plot </returns>
public LineSeries GetSeriesFromSignalName(out float sample_period, string Signal, DateTime StartTime, DateTime EndTime)
{
// Variable To Return
LineSeries series = new LineSeries();
// Check if this signal needs filtering
bool filter = false;
FilteredSignal filteredSignal = sm.FilteredSignals.Find(temp => temp.SignalName == Signal);
if (filteredSignal != null)
{
filter = true;
Signal = sm.FilteredSignals.Find(temp => temp.SignalName == Signal).OriginalName;
}
// Get Signal
if (EDFAllSignals.Contains(Signal))
{
// Get Signal
EDFSignal edfsignal = LoadedEDFFile.Header.Signals.Find(temp => temp.Label.Trim() == Signal);
// Determine Array Portion
sample_period = (float)LoadedEDFFile.Header.DurationOfDataRecordInSeconds / (float)edfsignal.NumberOfSamplesPerDataRecord;
// Get Array
List <float> values = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal, StartTime, EndTime);
// Add Points to Series
for (int y = 0; y < values.Count; y++)
{
series.Points.Add(new DataPoint(DateTimeAxis.ToDouble(StartTime + new TimeSpan(0, 0, 0, 0, (int)(sample_period * (float)y * 1000))), values[y]));
}
}
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 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal1, StartTime, EndTime);
values2 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal2, StartTime, EndTime);
sample_period = (float)LoadedEDFFile.Header.DurationOfDataRecordInSeconds / (float)edfsignal1.NumberOfSamplesPerDataRecord;
}
else if (edfsignal1.NumberOfSamplesPerDataRecord > edfsignal2.NumberOfSamplesPerDataRecord) // Upsample signal 2
{
values1 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal1, StartTime, EndTime);
values2 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal2, StartTime, EndTime);
values2 = Utils.MATLAB_Resample(values2.ToArray(), edfsignal1.NumberOfSamplesPerDataRecord / edfsignal2.NumberOfSamplesPerDataRecord);
sample_period = (float)LoadedEDFFile.Header.DurationOfDataRecordInSeconds / (float)edfsignal1.NumberOfSamplesPerDataRecord;
}
else // Upsample signal 1
{
values1 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal1, StartTime, EndTime);
values2 = Utils.retrieveSignalSampleValuesMod(LoadedEDFFile, edfsignal2, StartTime, EndTime);
values1 = Utils.MATLAB_Resample(values1.ToArray(), edfsignal2.NumberOfSamplesPerDataRecord / edfsignal1.NumberOfSamplesPerDataRecord);
sample_period = (float)LoadedEDFFile.Header.DurationOfDataRecordInSeconds / (float)edfsignal2.NumberOfSamplesPerDataRecord;
}
// Add Points to Series
for (int y = 0; y < Math.Min(values1.Count, values2.Count); y++)
{
series.Points.Add(new DataPoint(DateTimeAxis.ToDouble(StartTime + new TimeSpan(0, 0, 0, 0, (int)(sample_period * (float)y * 1000))), values1[y] - values2[y]));
}
}
if (filter == true)
{
if (filteredSignal.LowPass_Enabled)
{
series = Utils.ApplyLowPassFilter(series, filteredSignal.LowPassCutoff, sample_period);
}
if (filteredSignal.Average_Enabled)
{
float LENGTH;
LENGTH = Math.Max(filteredSignal.Average_Length / (sample_period * 1000), 1);
series = Utils.ApplyAverageFilter(series, (int)LENGTH);
}
}
return(series);
}
/// <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
});
}
}
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>
/// This function completes all the data required for the header. Call generateEDFHeader to get the completed header
/// </summary>
/// <param name="iLabels"></param>
/// <param name="iTransducerTypes"></param>
/// <param name="iPhysicalDimensions"></param>
/// <param name="iPhysicalMinimums"></param>
/// <param name="iPhysicalMaximums"></param>
/// <param name="iDigitalMinimums"></param>
/// <param name="iDigitalMaximums"></param>
/// <param name="iPrefilterings"></param>
/// <param name="iNumSamplesPerRecords"></param>
public void setNSDependantData(List<string> iLabels, List<string> iTransducerTypes, List<string> iPhysicalDimensions,
List<string> iPhysicalMinimums,
List<string> iPhysicalMaximums, List<string> iDigitalMinimums, List<string> iDigitalMaximums, List<string> iPrefilterings,
List<string> iNumSamplesPerRecords)
{
//check if the data conforms to the expected number of signals
int intNs = ConvertEDFHeaderField.toInt32(ns);
if (iLabels.Count != intNs || iTransducerTypes.Count != intNs || iPhysicalDimensions.Count != intNs || iPhysicalMaximums.Count != intNs || iPhysicalMinimums.Count != intNs || iDigitalMinimums.Count != intNs || iDigitalMaximums.Count != intNs || iPrefilterings.Count != intNs || iNumSamplesPerRecords.Count != intNs)
{
throw new ArgumentException("One or more of the lists provuded in setNSDependantData do not have the expected number of elements i.e. the number of signals defined earlier");
}
//Initialise all advanced header field lists
labels = new List<string>();
transducerTypes = new List<string>();
physicalDimensions = new List<string>();
physicalMinimums = new List<string>();
physicalMaximums = new List<string>();
digitalMinimums = new List<string>();
digitalMaximums = new List<string>();
prefilterings = new List<string>();
numSamplesPerRecords = new List<string>();
//initialise EDF Signal list
edfSignals = new List<EDFSignal>();
//copy from the lists to the header fields
setLabels(iLabels);
settransducerTypes(iTransducerTypes);
setphysicalDimensions(iPhysicalDimensions);
setphysicalMinimums(iPhysicalMinimums);
setphysicalMaximums(iPhysicalMaximums);
setdigitalMinimums(iDigitalMinimums);
setdigitalmaximums(iDigitalMaximums);
setprefilterings(iPrefilterings);
setnumSamplesPerRecords(iNumSamplesPerRecords);
for (int i = 0; i < iLabels.Count; i++)
{
//add every signal to the application global list of signals
EDFSignal signal = new EDFSignal();
signal.label = iLabels[i];
signal.transducerType = iTransducerTypes[i];
signal.physicalDimension = iPhysicalDimensions[i];
signal.physicalMinimum = iPhysicalMinimums[i];
signal.physicalMaximum = iPhysicalMaximums[i];
signal.digitalMinimum = iDigitalMinimums[i];
signal.digitalMaximum = iDigitalMaximums[i];
signal.preFiltering = iPrefilterings[i];
signal.numSamples = iNumSamplesPerRecords[i];
edfSignals.Add(signal);
}
}
/// <summary>
/// 解析导联列表
/// </summary>
public void parseSignals(byte[] signals, Encoding encoding)
{
//将转换后的内容写入缓存
_strHeader.Append(encoding.GetChars(signals));
// 解析导联列表。
this.Signals = new List <EDFSignal>();
// TODO 各部分字节数应该写成常量
EDFSignal edf_signal;
int _index;
//遍历33个信道
for (int i = 0; i < this.NumberOfSignalsInDataRecord; i++)
{
edf_signal = new EDFSignal();
_index = 0;
// 标签名
var _labelLength = 16;
byte[] label = getFixedLengthByteArrayFromHeader(signals, (i * _labelLength) + (this.NumberOfSignalsInDataRecord * _index), _labelLength);
edf_signal.Label = new string(encoding.GetChars(label)).Trim();
_index += _labelLength;
// if (edf_signal.Label.IndexOf("Annotations") > 0) continue;
// 序号
edf_signal.IndexNumber = (i + 1);
// 传感器类型
var _transducerTypeLength = 80;
byte[] transducer_type = getFixedLengthByteArrayFromHeader(signals, (i * _transducerTypeLength) + (this.NumberOfSignalsInDataRecord * _index), _transducerTypeLength);
edf_signal.TransducerType = new string(encoding.GetChars(transducer_type));
_index += _transducerTypeLength;
//
var _physicalDimensionLength = 8;
byte[] physical_dimension = getFixedLengthByteArrayFromHeader(signals, (i * _physicalDimensionLength) + (this.NumberOfSignalsInDataRecord * _index), _physicalDimensionLength);
edf_signal.PhysicalDimension = new string(encoding.GetChars(physical_dimension));
_index += _physicalDimensionLength;
//
var _physicalMinLength = 8;
byte[] physical_min = getFixedLengthByteArrayFromHeader(signals, (i * _physicalMinLength) + (this.NumberOfSignalsInDataRecord * _index), _physicalMinLength);
edf_signal.PhysicalMinimum = float.Parse(new string(encoding.GetChars(physical_min)).Trim());
_index += _physicalMinLength;
//
var _physicalMaxLength = 8;
byte[] physical_max = getFixedLengthByteArrayFromHeader(signals, (i * _physicalMaxLength) + (this.NumberOfSignalsInDataRecord * _index), _physicalMaxLength);
edf_signal.PhysicalMaximum = float.Parse(new string(encoding.GetChars(physical_max)).Trim());
_index += _physicalMaxLength;
//
var _digitalMinLength = 8;
byte[] digital_min = getFixedLengthByteArrayFromHeader(signals, (i * _digitalMinLength) + (this.NumberOfSignalsInDataRecord * _index), _digitalMinLength);
edf_signal.DigitalMinimum = float.Parse(new string(encoding.GetChars(digital_min)).Trim());
_index += _digitalMinLength;
//
var _digitalMaxLength = 8;
byte[] digital_max = getFixedLengthByteArrayFromHeader(signals, (i * _digitalMaxLength) + (this.NumberOfSignalsInDataRecord * _index), _digitalMaxLength);
edf_signal.DigitalMaximum = float.Parse(new string(encoding.GetChars(digital_max)).Trim());
_index += _digitalMaxLength;
//
var _prefilteringLength = 80;
byte[] prefiltering = getFixedLengthByteArrayFromHeader(signals, (i * _prefilteringLength) + (this.NumberOfSignalsInDataRecord * _index), _prefilteringLength);
edf_signal.Prefiltering = new string(encoding.GetChars(prefiltering));
_index += _prefilteringLength;
//
var _samplesEachDatarecordLength = 8;
byte[] samples_each_datarecord = getFixedLengthByteArrayFromHeader(signals, (i * _samplesEachDatarecordLength) + (this.NumberOfSignalsInDataRecord * _index), _samplesEachDatarecordLength);
edf_signal.NumberOfSamplesPerDataRecord = int.Parse(new string(encoding.GetChars(samples_each_datarecord)).Trim());
_index += _samplesEachDatarecordLength;
this.Signals.Add(edf_signal);
}
}
