Beispiel #1
0
        /// <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);
            }
        }
Beispiel #2
0
        /// <summary>
        /// 解析自定义的文件  --by zt
        /// </summary>
        /// <param name="sr"></param>
        private void parseMyDataRecordStream(StreamReader sr)
        {
            //set the seek position in the file stream to the beginning of the data records.
            sr.BaseStream.Seek((256 + this.Header.NumberOfSignalsInDataRecord * 256), SeekOrigin.Begin);

            int dataRecordSize = 0;

            foreach (EDFSignal signal in this.Header.Signals)
            {
                signal.SamplePeriodWithinDataRecord = (float)(this.Header.DurationOfDataRecordInSeconds / signal.NumberOfSamplesPerDataRecord);
                dataRecordSize += signal.NumberOfSamplesPerDataRecord;
            }

            byte[] dataRecordBytes = new byte[dataRecordSize * 3];
            byte   first00         = HexToByte("00")[0];

            while (sr.BaseStream.Read(dataRecordBytes, 0, dataRecordSize * 3) > 0)
            {
                //EDFDataRecord dataRecord = new EDFDataRecord();
                MyEDFDataRecord  dataRecord     = new MyEDFDataRecord();
                int              j              = 0;
                int              samplesWritten = 0;
                List <EDFSignal> signals        = this.Header.Signals;

                #region 解析与edf格式相似的方式,以后可能会用到  --by zt

                //for (int i = 0; i < signals.Count; i++)
                //{
                //    List<float> samples = new List<float>();
                //    for (int l = 0; l < signals[i].NumberOfSamplesPerDataRecord; l++)
                //    {
                //        float refVoltage = signals[i].PhysicalMaximum;
                //        //从dataRecordBytes中取3个字节

                //        byte[] temp = new byte[4] { dataRecordBytes[samplesWritten * 3 + 2], dataRecordBytes[samplesWritten * 3 + 1], dataRecordBytes[samplesWritten * 3], first00 };

                //        float value = (float)(BitConverter.ToInt32(temp, 0));
                //        if (value >= 0 && value <= Math.Pow(2, 23) - 1)
                //            value = refVoltage * value / (float)(Math.Pow(2, 23) - 1);
                //        else
                //            value = refVoltage * ((value - (float)Math.Pow(2, 24)) / (float)(Math.Pow(2, 23) - 1));
                //        value = value / multiplyingPower;
                //        samples.Add(value);
                //        samplesWritten++;
                //    }
                //    dataRecord.Add(i.ToString(), samples);
                //    //dataRecord.Add(value);
                //    //dataRecord.Add(signal.IndexNumberWithLabel, value);
                //    j++;
                //}

                #endregion 解析与edf格式相似的方式,以后可能会用到  --by zt

                foreach (EDFSignal signal in this.Header.Signals)
                {
                    //List<float> samples = new List<float>();
                    //for (int l = 0; l < signal.NumberOfSamplesPerDataRecord; l++)
                    //{
                    float refVoltage = signal.PhysicalMaximum;
                    //从dataRecordBytes中取3个字节

                    byte[] temp = new byte[4] {
                        dataRecordBytes[samplesWritten * 3 + 2], dataRecordBytes[samplesWritten * 3 + 1], dataRecordBytes[samplesWritten * 3], first00
                    };

                    float value = (float)(BitConverter.ToInt32(temp, 0));
                    if (value >= 0 && value <= Math.Pow(2, 23) - 1)
                    {
                        value = refVoltage * value / (float)(Math.Pow(2, 23) - 1);
                    }
                    else
                    {
                        value = refVoltage * ((value - (float)Math.Pow(2, 24)) / (float)(Math.Pow(2, 23) - 1));
                    }
                    value = value / multiplyingPower;
                    //samples.Add(value);
                    samplesWritten++;
                    //}
                    //dataRecord.Add(signal.IndexNumberWithLabel, samples);
                    dataRecord.Add(value);
                    //dataRecord.Add(signal.IndexNumberWithLabel, value);
                    j++;
                }
                _mydataRecords.Add(dataRecord);
                //_dataRecords.Add(dataRecord);
            }
        }
Beispiel #3
0
        /// <summary>
        /// 解析BIO-NoDisplay格式的数据
        /// </summary>

        /*
         *   笔记 StreamReader  以一种特定的编码输入字符
         *
         */
        private void parseDataRecordStreamByBIO(StreamReader sr)
        {
            // 先判断是否为NoDisplay格式
            if (this._header.Signals[this._header.Signals.Count - 1].Label.EndsWith("NoRef", StringComparison.InvariantCultureIgnoreCase) == false)
            {
                throw new Exception("格式错误,请选择NoDisplay格式的数据。");
            }

            // 跳过头文件
            sr.BaseStream.Seek((256 + this.Header.NumberOfSignalsInDataRecord * 256), SeekOrigin.Begin);

            // TODO 20170626 暂时先用旧逻辑试试

            #region 旧逻辑

            // 计算每个信道的采样周期和总时长
            int dataRecordSize = 0;
            foreach (EDFSignal signal in this.Header.Signals)
            {
                signal.SamplePeriodWithinDataRecord = (float)(this.Header.DurationOfDataRecordInSeconds / signal.NumberOfSamplesPerDataRecord);
                dataRecordSize += signal.NumberOfSamplesPerDataRecord;
            }

            // 移除最后一个注解通道,不滤波和画图(放在此处移除,是为了解析每个数据块和每个通道的字节数正确) - add by lzy 20170502
            // TODO 移除后少个EKG通道 20170614
            // this.Header.Signals.RemoveAt(this.Header.Signals.Count - 1);

            byte[] dataRecordBytes = new byte[dataRecordSize * 2];

            List <MyEDFDataRecord> myDataRecordList = this._mydataRecords;
            if (myDataRecordList == null)
            {
                myDataRecordList    = new List <MyEDFDataRecord>();
                this._mydataRecords = myDataRecordList;
            }

            // 每次读出一秒内的20个通道的数据
            while (sr.BaseStream.Read(dataRecordBytes, 0, dataRecordSize * 2) > 0)
            {
                // 每个时间点的全部通道的数据
                MyEDFDataRecord myDataRecord = new MyEDFDataRecord();

                int signalIndex    = 0;
                int samplesWritten = 0;
                // 一秒内的全部通道的数据,一维索引为通道数,二维索引为位置
                List <List <float> > samplesList = new List <List <float> >();
                foreach (EDFSignal signal in this.Header.Signals)
                {
                    float refVoltage = signal.PhysicalMaximum;

                    // 一秒内一个通道内的数据
                    List <float> samples = new List <float>();
                    for (int l = 0; l < signal.NumberOfSamplesPerDataRecord; l++)
                    {
                        float value = (float)BitConverter.ToInt16(dataRecordBytes, (samplesWritten * 2));

                        if (this.Header.Version.Equals(NEURO_BOND_FLAG))
                        {
                            if (value >= 0 && value <= Math.Pow(2, 15) - 1)
                            {
                                value = refVoltage * value / (float)(Math.Pow(2, 15) - 1);
                            }
                            else
                            {
                                //value = refVoltage * ((value - (float)Math.Pow(2, 20)) / (float)(Math.Pow(2, 19) - 1));
                                value = refVoltage * value / (float)Math.Pow(2, 15);
                            }
                        }

                        // value /= multiplyingPower;
                        samples.Add(value);
                        samplesWritten++;
                    }
                    signalIndex++;
                    samplesList.Add(samples);
                }

                // 把一秒内的全部通道的数据存入myDataRecordList
                int samplingRate = this.Header.Signals[0].NumberOfSamplesPerDataRecord; // 采样率,即每秒多少点
                for (int i = 0; i < samplingRate; i++)
                {
                    MyEDFDataRecord myEDFDataRecord = new MyEDFDataRecord();
                    for (int j = 0; j < samplesList.Count; j++)
                    {
                        if (i > samplesList[j].Count - 1)
                        {
                            continue;
                        }
                        float value = samplesList[j][i];
                        myEDFDataRecord.Add(value);
                    }
                    this._mydataRecords.Add(myEDFDataRecord);
                }
            }

            #endregion 旧逻辑
        }
Beispiel #4
0
        /// <summary>
        /// 解析edf数据到edfx中 add by lzy 20170427
        /// </summary>
        /// <param name="sr"></param>
        private void parseDataRecordStream2(StreamReader sr)
        {
            //set the seek position in the file stream to the beginning of the data records.
            //设置当前文件流 开始读取的位置
            /*sr.BaseStream.Seek(偏移量,开始位置)*/
            sr.BaseStream.Seek((256 + this.Header.NumberOfSignalsInDataRecord * 256), SeekOrigin.Begin);

            int dataRecordSize = 0;

            //遍历头文件信号
            foreach (EDFSignal signal in this.Header.Signals)
            {
                //数据采样周期=  采样频率 / 每个记录的样本数
                signal.SamplePeriodWithinDataRecord = (float)(this.Header.DurationOfDataRecordInSeconds / signal.NumberOfSamplesPerDataRecord);
                dataRecordSize += signal.NumberOfSamplesPerDataRecord;
                //数据记录长度+=每条记录样本数
            }

            // 移除最后一个注解通道,不滤波和画图(放在此处移除,是为了解析每个数据块和每个通道的字节数正确) - add by lzy 20170502
            // TODO 移除后少个EKG通道 20170614
            // this.Header.Signals.RemoveAt(this.Header.Signals.Count - 1);

            byte[] dataRecordBytes = new byte[dataRecordSize * 2];

            List <MyEDFDataRecord> myDataRecordList = this._mydataRecords;

            if (myDataRecordList == null)
            {
                myDataRecordList    = new List <MyEDFDataRecord>();
                this._mydataRecords = myDataRecordList;
            }

            // 每次读出一秒内的20个通道的数据
            while (sr.BaseStream.Read(dataRecordBytes, 0, dataRecordSize * 2) > 0)
            {
                // 每个时间点的全部通道的数据
                MyEDFDataRecord myDataRecord = new MyEDFDataRecord();

                int signalIndex    = 0;
                int samplesWritten = 0;
                // 一秒内的全部通道的数据,一维索引为通道数,二维索引为位置
                List <List <float> > samplesList = new List <List <float> >();

                foreach (EDFSignal signal in this.Header.Signals)
                {
                    float refVoltage = signal.PhysicalMaximum;//物理信号最大量

                    // 一秒内一个通道内的数据
                    List <float> samples = new List <float>();
                    for (int l = 0; l < signal.NumberOfSamplesPerDataRecord; l++)
                    {
                        float value = (float)BitConverter.ToInt16(dataRecordBytes, (samplesWritten * 2));

                        if (this.Header.Version.Equals(NEURO_BOND_FLAG))
                        {
                            if (value >= 0 && value <= Math.Pow(2, 15) - 1)
                            {
                                value = refVoltage * value / (float)(Math.Pow(2, 15) - 1);
                            }
                            else
                            {
                                //value = refVoltage * ((value - (float)Math.Pow(2, 20)) / (float)(Math.Pow(2, 19) - 1));
                                value = refVoltage * value / (float)Math.Pow(2, 15);
                            }
                        }

                        // value /= multiplyingPower;
                        samples.Add(value);
                        samplesWritten++;
                    }
                    signalIndex++;
                    samplesList.Add(samples);
                }

                // 把一秒内的全部通道的数据存入myDataRecordList
                int samplingRate = this.Header.Signals[0].NumberOfSamplesPerDataRecord; // 采样率,即每秒多少点
                for (int i = 0; i < samplingRate; i++)
                {
                    MyEDFDataRecord myEDFDataRecord = new MyEDFDataRecord();
                    for (int j = 0; j < samplesList.Count; j++)
                    {
                        if (i > samplesList[j].Count - 1)
                        {
                            continue;
                        }
                        float value = samplesList[j][i];
                        myEDFDataRecord.Add(value);
                    }
                    this._mydataRecords.Add(myEDFDataRecord);
                }
            }
        }
Beispiel #5
0
        /// <summary>
        /// 解析EDF数据到EDFX中
        /// </summary>
        /// <param name="sr"></param>
        private void parseDataRecordStream2(StreamReader sr)
        {
            //set the seek position in the file stream to the beginning of the data records.
            //设置当前文件流 开始读取的位置
            /*sr.BaseStream.Seek(偏移量,开始位置)*/
            sr.BaseStream.Seek((256 + this.Header.NumberOfSignalsInDataRecord * 256), SeekOrigin.Begin);

            int dataRecordSize = 0;
            //遍历头文件信号
            int count;

            Console.WriteLine("信号长度:" + this.Header.Signals.Count());
            foreach (EDFSignal signal in this.Header.Signals)
            {
                //数据记录中的采样周期 =  数据记录秒的持续时间 / 每个数据记录的样本数
                signal.SamplePeriodWithinDataRecord = (float)(this.Header.DurationOfDataRecordInSeconds / signal.NumberOfSamplesPerDataRecord);
                //Console.WriteLine($"数据记录中的采样周期={signal.SamplePeriodWithinDataRecord}={this.Header.DurationOfDataRecordInSeconds}/{signal.NumberOfSamplesPerDataRecord}");
                //Console.WriteLine($"数据记录长度={dataRecordSize}+{signal.NumberOfSamplesPerDataRecord}={signal.NumberOfSamplesPerDataRecord+dataRecordSize}\n");


                dataRecordSize += signal.NumberOfSamplesPerDataRecord;
                //数据记录长度+=每条记录样本数
            }

            // 移除最后一个注解通道,不滤波和画图(放在此处移除,是为了解析每个数据块和每个通道的字节数正确) - add by lzy 20170502
            // TODO 移除后少个EKG通道 20170614
            // this.Header.Signals.RemoveAt(this.Header.Signals.Count - 1);
            //记录数据字节数组长度为 33*256*2
            ///<summary>
            ///j录数据字节数组长度
            ///</summary>
            byte[] dataRecordBytes = new byte[dataRecordSize * 2];



            //自定义数据列表
            List <MyEDFDataRecord> myDataRecordList = this._mydataRecords;


            //如果自定义数据列表为空
            if (myDataRecordList == null)
            {
                //实例化自定义记录数据
                myDataRecordList    = new List <MyEDFDataRecord>();
                this._mydataRecords = myDataRecordList;
            }

            // 每次读出一秒内的20个通道的数据
            int a = 0;

            while (sr.BaseStream.Read(dataRecordBytes, 0, dataRecordSize * 2) > 0)
            {
                a++;
                //Console.Write($"[{a}]当前基础流位置:{sr.BaseStream.Read(dataRecordBytes, 0, dataRecordSize * 2)}");
                // 每个时间点的全部通道的数据
                MyEDFDataRecord myDataRecord = new MyEDFDataRecord();

                int signalIndex    = 0;
                int samplesWritten = 0;
                // 一秒内的全部通道的数据,一维索引为通道数,二维索引为位置
                List <List <float> > samplesList = new List <List <float> >();
                String str = "";
                foreach (EDFSignal signal in this.Header.Signals)
                {
                    float refVoltage = signal.PhysicalMaximum;//物理信号最大量(用来计算值)

                    // 一秒内一个通道内的数据
                    List <float> samples = new List <float>();  //数据样本
                    str += $"[{a}]当前记录样本数[{signal.NumberOfSamplesPerDataRecord}]    ";

                    for (int l = 0; l < signal.NumberOfSamplesPerDataRecord; l++)
                    {
                        float value = (float)BitConverter.ToInt16(dataRecordBytes, (samplesWritten * 2));
                        //str += $"{samplesWritten * 2}  ";

                        /*手环模式*/
                        if (this.Header.Version.Equals(NEURO_BOND_FLAG))
                        {
                            if (value >= 0 && value <= Math.Pow(2, 15) - 1)
                            {
                                value = refVoltage * value / (float)(Math.Pow(2, 15) - 1);
                            }
                            else
                            {
                                //value = refVoltage * ((value - (float)Math.Pow(2, 20)) / (float)(Math.Pow(2, 19) - 1));
                                value = refVoltage * value / (float)Math.Pow(2, 15);
                            }
                        }

                        // value /= multiplyingPower;
                        samples.Add(value);
                        //str += $"{value}  ";
                        samplesWritten++;
                    }
                    str += "\n";
                    signalIndex++;
                    samplesList.Add(samples);//往数据集里添加数据
                }
                str += "\n\n";

                //Console.WriteLine(str);
                // 把一秒内的全部通道的数据存入myDataRecordList
                int samplingRate = this.Header.Signals[0].NumberOfSamplesPerDataRecord; // 采样率,即每秒多少点
                for (int i = 0; i < samplingRate; i++)
                {
                    MyEDFDataRecord myEDFDataRecord = new MyEDFDataRecord();
                    for (int j = 0; j < samplesList.Count; j++)
                    {
                        if (i > samplesList[j].Count - 1)
                        {
                            continue;
                        }
                        float value = samplesList[j][i];
                        myEDFDataRecord.Add(value);
                    }
                    this._mydataRecords.Add(myEDFDataRecord);
                }
            }
        }