public void OpenTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.IsFalse(record.IsNew);
Assert.AreEqual(" 69 M 1085 1629 x1\n Aldomet, Inderal\nProduced by xform from record 100, beginning at 0:0", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count);
}
Assert.AreEqual(0, record.Signals.Count);
Assert.IsTrue(record.IsNew);
Assert.AreEqual(string.Empty, record.Info);
Assert.AreEqual((Frequency)0, record.SamplingFrequency);
Assert.AreEqual(0, record.Signals.Count);
using (record)
{
record.Open();
Assert.IsFalse(record.IsNew);
Assert.AreEqual(" 69 M 1085 1629 x1", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count);
}
}
public void SeekTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
var expectedFirstSample = expectedSamples[0];
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
signal.Seek(0);
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(expectedFirstSample, signal.ReadNext());
signal.Seek(signal.Duration - 1);
Assert.AreEqual(expectedLastSample, signal.ReadNext());
Assert.IsTrue(signal.IsEof);
signal.Seek(signal.Duration / 2);
var restOfSamples = signal.ReadToEnd();
expectedSamples.RemoveRange(0, signal.Duration / 2);
Assert.AreEqual(expectedSamples, restOfSamples);
}
}
private void OpenRecordFile(string path)
{
if (!this.isWfdbPathSet)
{
throw new WfdbPathException("Path to database is not set!");
}
try
{
string name = Path.GetFileNameWithoutExtension(path);
this.record = new Record(name);
record.Open();
foreach (Signal signal in record.Signals)
{
PointPairList temp = new PointPairList();
List <WfdbCsharpWrapper.Sample> samples = signal.ReadAll().ToList();
for (int i = 0; i < signal.NumberOfSamples; i++)
{
temp.Add(i, samples[i]);
}
this.points.Add(temp);
}
}
catch
{
throw;
}
}
private static void UsingWfdbClasses(int frequency)
{
try
{
Frequency f = frequency;
Time t = 0, t0 = 0, t1 = 0;
using (var record = new Record("data/100s"))
{
record.Open();
if (f <= 0)
{
f = record.SamplingFrequency;
}
Frequency.InputFrequency = f;
t0 = Time.Parse("1");
record.Seek(t);
t1 = Time.Parse("2");
for (t = t0; t <= t1; t++)
{
Console.WriteLine("{0}\t{1}", record[0].ReadNext(), record[1].ReadNext());
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void IsEofTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsFalse(signal.IsEof);
signal.ReadNext((int)signal.NumberOfSamples / 2);
Assert.IsFalse(signal.IsEof);
signal.ReadAll().ToList();
Assert.IsTrue(signal.IsEof);
signal.Seek(0);
Assert.IsFalse(signal.IsEof);
signal.Seek((int)signal.NumberOfSamples - 1);
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsTrue(signal.IsEof);
}
}
public void ReadNextTimeTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
var expectedFirstSample = expectedSamples[0];
Assert.AreEqual(expectedFirstSample, signal.ReadNext(Time.Zero));
Assert.AreEqual(signal.InitValue, signal.ReadNext(Time.Zero));
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
Time lastSampleTime = signal.Duration - 1;
Assert.AreEqual(expectedLastSample, signal.ReadNext(lastSampleTime));
// EOF REACHED
try
{
signal.ReadNext(signal.Duration + 5);
Assert.Fail("InvalidOperationException should have been thrown cause the end of signal has been reached.");
}
catch (InvalidOperationException)
{
}
}
}
private static void UsingWrapperClasses()
{
Frequency f = 0;
Sample[] v;
try
{
Console.WriteLine("Please enter the sampling frequency");
var sFrequency = Console.ReadLine();
f = double.Parse(sFrequency);
Record r = new Record("data/100s");
r.Open();
if (f < 0)
{
f = r.SamplingFrequency;
}
List <Signal> s = r.Signals;
Frequency.InputFrequency = f;
Time t0 = Time.Parse("1");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void ReadNextTimeCountTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
var expectedSamples = signal.ReadAll().ToList();
// lower bound
var expectedFirstSample = expectedSamples[0];
Assert.AreEqual(expectedFirstSample, signal.ReadNext(Time.Zero, 1).FirstOrDefault());
Assert.AreEqual(signal.InitValue, signal.ReadNext(Time.Zero, 1).FirstOrDefault());
// Upper bound
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
Time lastSampleTime = signal.Duration - 1;
Assert.AreEqual(expectedLastSample, signal.ReadNext(lastSampleTime, 1).FirstOrDefault());
var samples = signal.ReadNext(0, (int)signal.NumberOfSamples).ToList();
Assert.AreEqual(expectedSamples, samples);
Assert.IsTrue(signal.IsEof);
samples = signal.ReadNext(0, (int)signal.NumberOfSamples / 2).ToList();
expectedSamples.RemoveRange((int)signal.NumberOfSamples / 2, (int)signal.NumberOfSamples / 2);
Assert.AreEqual(expectedSamples, samples);
Assert.IsFalse(signal.IsEof);
try
{
signal.ReadNext(signal.Duration / 2, (int)signal.NumberOfSamples).ToList();
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
signal.ReadNext(signal.Duration + 5, (int)signal.NumberOfSamples).ToList();
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
try
{
signal.ReadNext(signal.Duration / 2, -5).ToList();
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
}
}
public void InfoTest()
{
using (var record = new Record("data/100s"))
{
record.Open();
Assert.AreNotEqual(null, record.Info);
Assert.AreEqual(" 69 M 1085 1629 x1\n Aldomet, Inderal\nProduced by xform from record 100, beginning at 0:0", record.Info);
}
}
public void SamplingFrequencyTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual((Frequency)360, record.SamplingFrequency); // Get test
record.SamplingFrequency = 320; // set test
Assert.AreEqual((Frequency)320, record.SamplingFrequency); // Get test
}
}
public void SignalsTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual(2, record.Signals.Count);
Assert.AreEqual("100s.dat", record.Signals[0].FileName);
Assert.AreEqual("100s.dat", record.Signals[1].FileName);
Assert.AreEqual("MLII", record.Signals[0].Description);
Assert.AreEqual("V5", record.Signals[1].Description);
Assert.AreEqual(21600, record.Signals[0].NumberOfSamples);
Assert.AreEqual(21600, record.Signals[1].NumberOfSamples);
Assert.AreEqual(SignalStorageFormat.Sf212Bit, record.Signals[0].Format);
Assert.AreEqual(SignalStorageFormat.Sf212Bit, record.Signals[1].Format);
Assert.AreEqual(1, record.Signals[0].SamplesPerFrame);
Assert.AreEqual(1, record.Signals[1].SamplesPerFrame);
Assert.AreEqual(Gain.DefaultGain, record.Signals[0].Gain);
Assert.AreEqual(Gain.DefaultGain, record.Signals[1].Gain);
Assert.AreEqual(200.0, record.Signals[0].Gain.Value);
Assert.AreEqual(200.0, record.Signals[1].Gain.Value);
Assert.AreEqual(11, record.Signals[0].AdcResolution);
Assert.AreEqual(11, record.Signals[1].AdcResolution);
Assert.AreEqual(1024, record.Signals[0].AdcZero);
Assert.AreEqual(1024, record.Signals[1].AdcZero);
Assert.AreEqual(1024, record.Signals[0].Baseline);
Assert.AreEqual(1024, record.Signals[1].Baseline);
Assert.AreEqual(995, record.Signals[0].InitValue);
Assert.AreEqual(1011, record.Signals[1].InitValue);
Assert.AreEqual(0, record.Signals[0].Group);
Assert.AreEqual(0, record.Signals[1].Group);
Assert.AreEqual(0, record.Signals[0].BlockSize);
Assert.AreEqual(0, record.Signals[1].BlockSize);
Assert.AreEqual(21537, record.Signals[0].CheckSum);
Assert.AreEqual(-3962, record.Signals[1].CheckSum);
}
}
private static void UsingRecord()
{
Console.WriteLine("pgain Using Record Class");
using (var record = new Record("data/100s"))
{
record.Open();
int counter = 0;
foreach (var signal in record)// or (var signal in record.Signals)
{
Console.WriteLine("Signal {0} gain = {1}", counter, signal.Gain);
counter++;
}
}
}
private static void UsingRecord()
{
Console.WriteLine("pgain Using Record Class");
using (var record = new Record("data/100s"))
{
record.Open();
int counter = 0;
foreach (var signal in record)// or (var signal in record.Signals)
{
Console.WriteLine("Signal {0} gain = {1}", counter, signal.Gain);
counter++;
}
}
}
public void RecordTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
Assert.IsTrue(r.Signals.ToList()[0].Record == r);
Assert.IsTrue(r.Signals.ToList()[1].Record == r);
}
var signals = new List <Signal>(Signal.GetSignals("data/100s"));
Assert.IsTrue(signals[0].Record == signals[1].Record);
}
private static void UsingWrapperClasses2()
{
Console.WriteLine("exgetvec Using Wrapper Signal class");
using (var record = new Record("data/100s"))
{
record.Open();
var samples1 = record.Signals[0].ReadNext(10);
var samples2 = record.Signals[1].ReadNext(10);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0}\t{1}", samples1[i], samples2[i]);
}
}
Wfdb.Quit();
}
public void ReadNextCountTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r[0];
var expectedSamples = signal.ReadAll().ToList(); // force a loop over the enumerator to generate the list.
signal.Seek(0);
Assert.AreEqual(new List <Sample>(), signal.ReadNext(0));
var samples = signal.ReadNext((int)signal.NumberOfSamples); // or simply signal.Duration
Assert.AreEqual(expectedSamples, samples);
// we reached the end of signal.
try
{
signal.ReadNext(101); // some mandatory number
Assert.Fail("InvalidOperationException should have been thrown.");
}
catch (InvalidOperationException)
{
}
signal.Seek(signal.Duration / 2);
try
{
signal.ReadNext((int)signal.NumberOfSamples);
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
signal.ReadNext(-5);
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
}
}
public void ReadAllTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(signal.NumberOfSamples, signal.ReadAll().Count());
Assert.IsTrue(signal.IsEof);
// Recall
Assert.AreEqual(signal.NumberOfSamples, signal.ReadAll().Count());
Assert.IsTrue(signal.IsEof);
}
}
public void InputFrequencyTest()
{
// Before opening any record
Assert.IsTrue(Frequency.InputFrequency == 0);
Frequency.InputFrequency = 320; // positive
Assert.IsTrue(Frequency.InputFrequency == 0);
// Opening some record
using (Record r = new Record("data/100s"))
{
r.Open();
Frequency.InputFrequency = 320;
Assert.IsTrue(Frequency.InputFrequency == 320);
}
}
private static void UsingWrapperClasses3()
{
Console.WriteLine("exgetvec Using Wrapper Signal class and Signal.Seek Method");
using (var record = new Record("data/100s"))
{
record.Open();
var samples1 = record.Signals[0].ReadNext(10);
record.Signals[1].Seek(10); // moving the reading pointer of the second signal by ten positions
var samples2 = record.Signals[1].ReadNext(10);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0}\t{1}", samples1[i], samples2[i]);
}
}
Wfdb.Quit();
}
public void DisposeTest()
{
var record = new Record("data/100s");
record.Open();
Assert.IsFalse(record.IsNew);
//Assert.AreEqual(" 69 M 1085 1629 x1", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count);
record.Dispose();
Assert.AreEqual(0, record.Signals.Count);
Assert.IsTrue(record.IsNew);
Assert.AreEqual(string.Empty, record.Info);
Assert.AreEqual((Frequency)0, record.SamplingFrequency);
Assert.AreEqual(0, record.Signals.Count);
}
public void DisposeTest()
{
var record = new Record("data/100s");
record.Open();
Assert.IsFalse(record.IsNew);
//Assert.AreEqual(" 69 M 1085 1629 x1", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count());
record.Dispose();
Assert.AreEqual(0, record.Signals.Count());
Assert.IsTrue(record.IsNew);
Assert.AreEqual(string.Empty, record.Info);
Assert.AreEqual((Frequency)0, record.SamplingFrequency);
Assert.AreEqual(0, record.Signals.Count());
}
public void IndexerTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual(record.Signals.ToList()[0], record[0]);
Assert.AreEqual(record.Signals.ToList()[1], record[1]);
}
try
{
var signal = record[0];
Assert.Fail("IndexOutOfRangeException should have been thrown");
}
catch (ArgumentOutOfRangeException)
{
}
}
private static void UsingWrapperClasses1()
{
Console.WriteLine("exgetvec Using Wrapper Record Class");
using (var record = new Record("data/100s"))
{
record.Open();
var samples = record.GetSamples(10);
foreach (var s in samples)
{
for (int i = 0; i < s.Length; i++)
{
Console.Write(string.Format("{0}\t", s[i]));
}
Console.WriteLine();
}
}
Wfdb.Quit();
}
public void IndexerTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual(record.Signals[0], record[0]);
Assert.AreEqual(record.Signals[1], record[1]);
}
try
{
var signal = record[0];
Assert.Fail("IndexOutOfRangeException should have been thrown");
}
catch (ArgumentOutOfRangeException)
{
}
}
public static void UsingWrapperClasses()
{
var record = new Record("data/100s");
record.Open();
Console.WriteLine("Record Name : " + record.Name);
Console.WriteLine("Record Info : " + record.Info);
Console.WriteLine("Record's Sampling Frequency : " + record.SamplingFrequency);
Console.WriteLine("Available signals.");
foreach (Signal signal in record.Signals)
{
Console.WriteLine("=====================================");
Console.WriteLine("Signal's Name : " + signal.FileName);
Console.WriteLine("Signal's Description : " + signal.Description);
Console.WriteLine("Signal's Number of samples : " + signal.NumberOfSamples);
Console.WriteLine("Signal's First Sample : " + signal.InitValue);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Showing the first 10 samples of the signal");
Console.WriteLine("------------------------------------------");
List <Sample> samples = signal.ReadNext(10).ToList();
for (int i = 0; i < samples.Count; i++)
{
Console.WriteLine("Sample " + i + " Value (adu) = " + samples[i].Adu);
Console.WriteLine(" Value (microvolt) = " + samples[i].ToMicrovolts());
Console.WriteLine(" Value (millivolt) = " + samples[i].ToPhys());
}
Console.WriteLine("--------------------------------------");
Console.WriteLine("=====================================");
}
record.Dispose();
}
public static void UsingWrapperClasses()
{
var record = new Record("data/100s");
record.Open();
Console.WriteLine("Record Name : " + record.Name);
Console.WriteLine("Record Info : " + record.Info);
Console.WriteLine("Record's Sampling Frequency : " + record.SamplingFrequency);
Console.WriteLine("Available signals.");
foreach (Signal signal in record.Signals)
{
Console.WriteLine("=====================================");
Console.WriteLine("Signal's Name : " + signal.FileName);
Console.WriteLine("Signal's Description : " + signal.Description);
Console.WriteLine("Signal's Number of samples : " + signal.NumberOfSamples);
Console.WriteLine("Signal's First Sample : " + signal.InitValue);
Console.WriteLine("------------------------------------------");
Console.WriteLine("Showing the first 10 samples of the signal");
Console.WriteLine("------------------------------------------");
List<Sample> samples = signal.ReadNext(10).ToList();
for (int i = 0; i < samples.Count; i++)
{
Console.WriteLine("Sample " + i + " Value (adu) = " + samples[i].Adu);
Console.WriteLine(" Value (microvolt) = " + samples[i].ToMicrovolts());
Console.WriteLine(" Value (millivolt) = " + samples[i].ToPhys());
}
Console.WriteLine("--------------------------------------");
Console.WriteLine("=====================================");
}
record.Dispose();
}
public void ReadToEndTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
var expectedSamples = signal.ReadAll().ToList();
signal.Seek(0);
Assert.AreEqual(expectedSamples, signal.ReadToEnd());
Assert.IsTrue(signal.IsEof);
Assert.AreEqual(new List <Sample>(), signal.ReadToEnd()); // no more samples to read
signal.Seek(signal.Duration / 2);
var samples = signal.ReadToEnd();
expectedSamples.RemoveRange(0, signal.Duration / 2);
Assert.AreEqual(expectedSamples, samples);
}
}
public void ReadNextTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(signal.InitValue, signal.ReadNext());
Assert.IsFalse(signal.IsEof);
signal.Seek(signal.Duration - 1);
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsTrue(signal.IsEof);
try
{
signal.ReadNext();
Assert.Fail("InvalidOperationException should have been thrown, we reached the end of the signal.");
}
catch (InvalidOperationException)
{
}
signal.Seek(0);
var samples = new List <Sample>();
while (!signal.IsEof)
{
samples.Add(signal.ReadNext());
}
Assert.IsTrue(signal.IsEof);
Assert.AreEqual(signal.ReadAll(), samples);
}
}
private void extract_btn_Click(object sender, EventArgs e)
{
if (extractFileDialog.ShowDialog() == DialogResult.OK)
{
try
{
File.WriteAllText(
extractFileDialog.FileName,
_recordFiles.Select(
path =>
RecordPropertyExtractor.PropertyValues(Record.Open(path)).Select(prop => prop.ToString()).Aggregate((prop1, prop2) => prop1 + "," + prop2)
).Aggregate((obj1, obj2) => obj1 + "\n" + obj2)
);
}
catch (SerializationException)
{
MessageBox.Show("Can't open files, one of them is not a record", "Can't open files",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
MessageBox.Show("Property extraction complete", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public void SeekTest()
{
// Testing On Signal's Samples
using (var record = new Record("data/100s"))
{
record.Open();
var expectedSignal1Samples0 = record[0].ReadNext(10); // read 10 samples of the first 10
var expectedSignal2Samples0 = record[1].ReadNext(10); // read 10 samples of the first 10
record.Signals[0].Seek(10); // advance the 1st pointer by ten samples
var expectedSignal1Samples10 = record[0].ReadNext(10); // read 10 samples after the first 10 samples
record.Signals[1].Seek(10); // advance the 1st pointer by ten samples
var expectedSignal2Samples10 = record[1].ReadNext(10); // read 10 samples after the first 10 samples
record.Seek(0);
Assert.AreEqual(expectedSignal1Samples0, record[0].ReadNext(10));
Assert.AreEqual(expectedSignal2Samples0, record[1].ReadNext(10));
record.Seek(10);
Assert.AreEqual(expectedSignal1Samples10, record[0].ReadNext(10));
Assert.AreEqual(expectedSignal2Samples10, record[1].ReadNext(10));
}
}
public void IndexerTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
for (int i = 0; i < expectedSamples.Count; i++)
{
Assert.AreEqual(expectedSamples[i], signal[i]);
}
try
{
var sample = signal[signal.Duration + 5];
Assert.Fail("InvalidOperationException should have been thrown.");
}
catch (InvalidOperationException)
{
}
}
}
public void ReadNextCountTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r[0];
var expectedSamples = signal.ReadAll().ToList(); // force a loop over the enumerator to generate the list.
signal.Seek(0);
Assert.AreEqual(new List<Sample>(), signal.ReadNext(0));
var samples = signal.ReadNext((int)signal.NumberOfSamples); // or simply signal.Duration
Assert.AreEqual(expectedSamples, samples);
// we reached the end of signal.
try
{
signal.ReadNext(101); // some mandatory number
Assert.Fail("InvalidOperationException should have been thrown.");
}
catch (InvalidOperationException)
{
}
signal.Seek(signal.Duration/2);
try
{
signal.ReadNext((int) signal.NumberOfSamples);
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
signal.ReadNext(-5);
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
}
}
public void SeekTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
var expectedFirstSample = expectedSamples[0];
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
signal.Seek(0);
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(expectedFirstSample, signal.ReadNext());
signal.Seek(signal.Duration - 1);
Assert.AreEqual(expectedLastSample, signal.ReadNext());
Assert.IsTrue(signal.IsEof);
signal.Seek(signal.Duration / 2);
var restOfSamples = signal.ReadToEnd();
expectedSamples.RemoveRange(0, signal.Duration / 2);
Assert.AreEqual(expectedSamples, restOfSamples);
}
}
public void RecordTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
Assert.IsTrue(r.Signals.ToList()[0].Record == r);
Assert.IsTrue(r.Signals.ToList()[1].Record == r);
}
var signals = new List<Signal>(Signal.GetSignals("data/100s"));
Assert.IsTrue(signals[0].Record == signals[1].Record);
}
public void ReadNextTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(signal.InitValue, signal.ReadNext());
Assert.IsFalse(signal.IsEof);
signal.Seek(signal.Duration - 1);
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsTrue(signal.IsEof);
try
{
signal.ReadNext();
Assert.Fail("InvalidOperationException should have been thrown, we reached the end of the signal.");
}
catch (InvalidOperationException)
{
}
signal.Seek(0);
var samples = new List<Sample>();
while (!signal.IsEof)
{
samples.Add(signal.ReadNext());
}
Assert.IsTrue(signal.IsEof);
Assert.AreEqual(signal.ReadAll(), samples);
}
}
private void btnStart_Click(object sender, EventArgs e)
{
string inword;
int cnt = 0;
int totCnt = 0;
int sendCnt = 0;
int readCnt = 0;
int iteration = 0;
btnStart.Enabled = false;
btnStop.Enabled = true;
////using (var record = new Record("c:\\users\\Al\\Dropbox\\Medical Projects\\ECG Simulator\\EcgSim\\EcgSim\\data\\100s"))
using (var record = new Record("data/aami-ec13/aami3a"))
//using (var record = new Record(txtFile.Text.Substring(2, txtFile.Text.Length - 6)))
{
record.Open();
//next line added by Al as test
Frequency.InputFrequency = 125;
var samples = record.GetSamples(1000);
int loop = 0;
int val;
string outword;
// serOut.BaudRate = 38400;
serOut.BaudRate = 115200;
serOut.Open();
Console.Write("Ser wBuf Size ");
Console.WriteLine(serOut.WriteBufferSize);
Console.Write("Ser rBuf Size ");
Console.WriteLine(serOut.ReadBufferSize);
Console.WriteLine("Iteration " + iteration);
while (iteration++ < 100)
{
foreach (var s in samples)
{
for (int i = 0; i < s.Length; i++)
{
loop++;
// Console.WriteLine(loop);
//Console.Write(s[i].ToString());
//Console.Write(string.Format("D{0000}\t", s[i]));
//real val = s[i]; // real
//if ((loop == 1) || (loop == 1000))
// Console.WriteLine("BorE " + s[i]);
val = (s[i] - 1950) * 10;
if (val > 4096)
{
val = 4096;
}
if (val < 0)
{
val = 0;
}
// val = loop;
outword = "D" + val.ToString("0000");
serOut.Write(outword);
// Console.WriteLine(outword);
if ((readCnt = serOut.BytesToRead) > 0)
{
// Console.Write("rCnt:");
// Console.WriteLine(readCnt);
inword = serOut.ReadLine();
cnt = inword.Count(c => c == '>');
totCnt += cnt;
Console.Write(inword);
#if VERBOSE
Console.Write("$");
Console.Write(totCnt);
Console.Write("$c");
Console.WriteLine(sendCnt);
#endif
Console.Write("]");
// Console.WriteLine(cnt);
// Thread.Sleep(1);
}
else
{
Console.WriteLine(",");
Thread.Sleep(1);
}
}
Console.WriteLine();
sendCnt++;
do
{
if ((readCnt = serOut.BytesToRead) > 0)
{
// Console.Write("rCnt:");
// Console.WriteLine(readCnt);
Console.Write("[");
inword = serOut.ReadLine();
cnt = inword.Count(c => c == '>');
totCnt += cnt;
Console.Write(inword);
#if VERBOSE
Console.Write("|");
Console.Write(totCnt);
Console.Write("|c");
Console.WriteLine(sendCnt);
Console.WriteLine(cnt);
#endif
Console.Write("]");
Console.Write(totCnt);
// Console.Write("|c");
// Console.WriteLine(cnt);
// Thread.Sleep(1);
}
else
{
Console.Write(".");
Thread.Sleep(1);
}
} while ((sendCnt - totCnt) > 30);
}
Application.DoEvents();
if (btnStart.Enabled)
{
break;
}
}
}
// Wait for final bytes to drain
do
{
if ((readCnt = serOut.BytesToRead) > 0)
{
Console.Write("rCnt:");
Console.WriteLine(readCnt);
inword = serOut.ReadLine();
cnt = inword.Count(c => c == '>');
totCnt += cnt;
Console.Write(inword);
Console.Write("-");
Console.Write(totCnt);
Console.Write("-");
Console.WriteLine(sendCnt);
Thread.Sleep(10);
}
else
{
Console.WriteLine("No1");
Thread.Sleep(1000);
}
} while ((sendCnt - totCnt) > 0);
Console.WriteLine(cnt);
Console.WriteLine("End 1");
if ((readCnt = serOut.BytesToRead) > 0)
{
inword = serOut.ReadLine();
Console.Write(inword);
}
else
{
Console.WriteLine("No2");
Thread.Sleep(1000);
}
Thread.Sleep(1000);
Console.WriteLine("End 2");
if ((readCnt = serOut.BytesToRead) > 0)
{
inword = serOut.ReadLine();
Console.Write(inword);
}
else
{
Console.WriteLine("No3.");
Thread.Sleep(1000);
}
serOut.Close();
btnStart.Enabled = true;
btnStop.Enabled = false;
Wfdb.Quit();
}
public void SeekTest()
{
// Testing On Signal's Samples
using (var record = new Record("data/100s"))
{
record.Open();
var expectedSignal1Samples0 = record[0].ReadNext(10); // read 10 samples of the first 10
var expectedSignal2Samples0 = record[1].ReadNext(10); // read 10 samples of the first 10
record.Signals.First().Seek(10); // advance the 1st pointer by ten samples
var expectedSignal1Samples10 = record[0].ReadNext(10); // read 10 samples after the first 10 samples
record.Signals.Skip(1).First().Seek(10); // advance the 1st pointer by ten samples
var expectedSignal2Samples10 = record[1].ReadNext(10); // read 10 samples after the first 10 samples
record.Seek(0);
Assert.AreEqual(expectedSignal1Samples0, record[0].ReadNext(10));
Assert.AreEqual(expectedSignal2Samples0, record[1].ReadNext(10));
record.Seek(10);
Assert.AreEqual(expectedSignal1Samples10, record[0].ReadNext(10));
Assert.AreEqual(expectedSignal2Samples10, record[1].ReadNext(10));
}
}
public void ReadNextTimeCountTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
var expectedSamples = signal.ReadAll().ToList();
// lower bound
var expectedFirstSample = expectedSamples[0];
Assert.AreEqual(expectedFirstSample, signal.ReadNext(Time.Zero, 1).FirstOrDefault());
Assert.AreEqual(signal.InitValue, signal.ReadNext(Time.Zero, 1).FirstOrDefault());
// Upper bound
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
Time lastSampleTime = signal.Duration - 1;
Assert.AreEqual(expectedLastSample, signal.ReadNext(lastSampleTime, 1).FirstOrDefault());
var samples = signal.ReadNext(0, (int)signal.NumberOfSamples).ToList();
Assert.AreEqual(expectedSamples, samples);
Assert.IsTrue(signal.IsEof);
samples = signal.ReadNext(0, (int)signal.NumberOfSamples / 2).ToList();
expectedSamples.RemoveRange((int)signal.NumberOfSamples / 2, (int)signal.NumberOfSamples / 2);
Assert.AreEqual(expectedSamples, samples);
Assert.IsFalse(signal.IsEof);
try
{
signal.ReadNext(signal.Duration / 2, (int)signal.NumberOfSamples).ToList();
Assert.Fail("ArgumentOutOfRangeException should have been thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
try
{
signal.ReadNext(signal.Duration + 5, (int)signal.NumberOfSamples).ToList();
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
try
{
signal.ReadNext(signal.Duration / 2, -5).ToList();
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
}
}
private static void UsingWfdbClasses(int frequency)
{
try
{
Frequency f = frequency;
Time t = 0, t0 = 0, t1 = 0;
using (var record = new Record("data/100s"))
{
record.Open();
if (f <= 0)
f = record.SamplingFrequency;
Frequency.InputFrequency = f;
t0 = Time.Parse("1");
record.Seek(t);
t1 = Time.Parse("2");
for (t = t0; t <= t1; t++)
{
Console.WriteLine("{0}\t{1}", record[0].ReadNext(), record[1].ReadNext());
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void ReadAllTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
Assert.AreEqual(signal.NumberOfSamples, signal.ReadAll().Count());
Assert.IsTrue(signal.IsEof);
// Recall
Assert.AreEqual(signal.NumberOfSamples, signal.ReadAll().Count());
Assert.IsTrue(signal.IsEof);
}
}
private static void UsingWrapperClasses1()
{
Console.WriteLine("exgetvec Using Wrapper Record Class");
using (var record = new Record("data/100s"))
{
record.Open();
var samples = record.GetSamples(10);
foreach (var s in samples)
{
for (int i = 0; i < s.Length; i++)
{
Console.Write(string.Format("{0}\t", s[i]));
}
Console.WriteLine();
}
}
Wfdb.Quit();
}
private static void UsingWrapperClasses2()
{
Console.WriteLine("exgetvec Using Wrapper Signal class");
using (var record = new Record("data/100s"))
{
record.Open();
var samples1 = record.Signals.ToList()[0].ReadNext(10).ToList();
var samples2 = record.Signals.ToList()[1].ReadNext(10).ToList();
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0}\t{1}", samples1[i], samples2[i]);
}
}
Wfdb.Quit();
}
public void IsEofTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsFalse(signal.IsEof);
signal.ReadNext((int)signal.NumberOfSamples / 2);
Assert.IsFalse(signal.IsEof);
signal.ReadAll().ToList();
Assert.IsTrue(signal.IsEof);
signal.Seek(0);
Assert.IsFalse(signal.IsEof);
signal.Seek((int)signal.NumberOfSamples - 1);
Assert.IsFalse(signal.IsEof);
signal.ReadNext();
Assert.IsTrue(signal.IsEof);
}
}
public void OpenTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.IsFalse(record.IsNew);
Assert.AreEqual(" 69 M 1085 1629 x1\n Aldomet, Inderal\nProduced by xform from record 100, beginning at 0:0", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count());
}
Assert.AreEqual(0, record.Signals.Count());
Assert.IsTrue(record.IsNew);
Assert.AreEqual(string.Empty, record.Info);
Assert.AreEqual((Frequency)0, record.SamplingFrequency);
Assert.AreEqual(0, record.Signals.Count());
using (record)
{
record.Open();
Assert.IsFalse(record.IsNew);
Assert.AreEqual(" 69 M 1085 1629 x1\n Aldomet, Inderal\nProduced by xform from record 100, beginning at 0:0", record.Info);
Assert.AreEqual((Frequency)360, record.SamplingFrequency);
Assert.AreEqual(2, record.Signals.Count());
}
}
public void SignalsTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual(2, record.Signals.Count());
Assert.AreEqual("100s.dat", record.Signals.ToList()[0].FileName);
Assert.AreEqual("100s.dat", record.Signals.ToList()[1].FileName);
Assert.AreEqual("MLII", record.Signals.ToList()[0].Description);
Assert.AreEqual("V5", record.Signals.ToList()[1].Description);
Assert.AreEqual(21600, record.Signals.ToList()[0].NumberOfSamples);
Assert.AreEqual(21600, record.Signals.ToList()[1].NumberOfSamples);
Assert.AreEqual(SignalStorageFormat.Sf212Bit, record.Signals.ToList()[0].Format);
Assert.AreEqual(SignalStorageFormat.Sf212Bit, record.Signals.ToList()[1].Format);
Assert.AreEqual(1, record.Signals.ToList()[0].SamplesPerFrame);
Assert.AreEqual(1, record.Signals.ToList()[1].SamplesPerFrame);
Assert.AreEqual(Gain.DefaultGain, record.Signals.ToList()[0].Gain);
Assert.AreEqual(Gain.DefaultGain, record.Signals.ToList()[1].Gain);
Assert.AreEqual(200.0, record.Signals.ToList()[0].Gain.Value);
Assert.AreEqual(200.0, record.Signals.ToList()[1].Gain.Value);
Assert.AreEqual(11, record.Signals.ToList()[0].AdcResolution);
Assert.AreEqual(11, record.Signals.ToList()[1].AdcResolution);
Assert.AreEqual(1024, record.Signals.ToList()[0].AdcZero);
Assert.AreEqual(1024, record.Signals.ToList()[1].AdcZero);
Assert.AreEqual(1024, record.Signals.ToList()[0].Baseline);
Assert.AreEqual(1024, record.Signals.ToList()[1].Baseline);
Assert.AreEqual(995, record.Signals.ToList()[0].InitValue);
Assert.AreEqual(1011, record.Signals.ToList()[1].InitValue);
Assert.AreEqual(0, record.Signals.ToList()[0].Group);
Assert.AreEqual(0, record.Signals.ToList()[1].Group);
Assert.AreEqual(0, record.Signals.ToList()[0].BlockSize);
Assert.AreEqual(0, record.Signals.ToList()[1].BlockSize);
Assert.AreEqual(21537, record.Signals.ToList()[0].CheckSum);
Assert.AreEqual(-3962, record.Signals.ToList()[1].CheckSum);
}
}
public void ReadNextTimeTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
var expectedFirstSample = expectedSamples[0];
Assert.AreEqual(expectedFirstSample, signal.ReadNext(Time.Zero));
Assert.AreEqual(signal.InitValue, signal.ReadNext(Time.Zero));
var expectedLastSample = expectedSamples[expectedSamples.Count - 1];
Time lastSampleTime = signal.Duration - 1;
Assert.AreEqual(expectedLastSample, signal.ReadNext(lastSampleTime));
// EOF REACHED
try
{
signal.ReadNext(signal.Duration + 5);
Assert.Fail("InvalidOperationException should have been thrown cause the end of signal has been reached.");
}
catch (InvalidOperationException)
{
}
}
}
public void SamplingFrequencyTest()
{
var record = new Record("data/100s");
using (record)
{
record.Open();
Assert.AreEqual((Frequency)360, record.SamplingFrequency); // Get test
record.SamplingFrequency = 320; // set test
Assert.AreEqual((Frequency)320, record.SamplingFrequency); // Get test
}
}
public void IndexerTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
Assert.IsFalse(signal.IsEof);
var expectedSamples = signal.ReadAll().ToList();
for (int i = 0; i < expectedSamples.Count; i++)
{
Assert.AreEqual(expectedSamples[i], signal[i]);
}
try
{
var sample = signal[signal.Duration + 5];
Assert.Fail("InvalidOperationException should have been thrown.");
}
catch (InvalidOperationException)
{
}
}
}
public void InfoTest()
{
using (var record = new Record("data/100s"))
{
record.Open();
Assert.AreNotEqual(null, record.Info);
Assert.AreEqual(" 69 M 1085 1629 x1\n Aldomet, Inderal\nProduced by xform from record 100, beginning at 0:0", record.Info);
}
}
private static void UsingWrapperClasses3()
{
Console.WriteLine("exgetvec Using Wrapper Signal class and Signal.Seek Method");
using (var record = new Record("data/100s"))
{
record.Open();
var samples1 = record.Signals.First().ReadNext(10).ToList();
record.Signals.Skip(1).First().Seek(10); // moving the reading pointer of the second signal by ten positions
var samples2 = record.Signals.Skip(1).First().ReadNext(10).ToList();
for (int i = 0; i < 10; i++)
{
Console.WriteLine("{0}\t{1}", samples1[i], samples2[i]);
}
}
Wfdb.Quit();
}
public void ReadToEndTest()
{
using (var r = new Record("data/100s"))
{
r.Open();
var signal = r.Signals.First();
var expectedSamples = signal.ReadAll().ToList();
signal.Seek(0);
Assert.AreEqual(expectedSamples, signal.ReadToEnd());
Assert.IsTrue(signal.IsEof);
Assert.AreEqual(new List<Sample>(), signal.ReadToEnd()); // no more samples to read
signal.Seek(signal.Duration/2);
var samples = signal.ReadToEnd();
expectedSamples.RemoveRange(0, signal.Duration/2);
Assert.AreEqual(expectedSamples, samples);
}
}
public void InputFrequencyTest()
{
// Before opening any record
Assert.IsTrue(Frequency.InputFrequency == 0);
Frequency.InputFrequency = 320; // positive
Assert.IsTrue(Frequency.InputFrequency == 0);
// Opening some record
using (Record r = new Record("data/100s"))
{
r.Open();
Frequency.InputFrequency = 320;
Assert.IsTrue(Frequency.InputFrequency == 320);
}
}
/// <summary>
/// Retrieves a single record from the dataset.
/// </summary>
///
/// <param name="record">A record from the dataset.</param>
///
public Signal GetSignal(Record record)
{
return(record.Open(this.webClient, this.basePath));
}
