diff --git a/README.md b/README.md
index 21160b3..41c6f24 100644
--- a/README.md
+++ b/README.md
@@ -1,112 +1,112 @@
# Event based gQRS
This is the official repository for the publication: Silvio Zanoli, Tomas Teijeiro, Fabio Montagna and David Atienza: "An Event-Based System for Low-Power ECG QRS
Detection"
In this repository is possible to find the source code for the event-based gQRS algorithm for QRS complex detection in ECG signals.
The python demonstrative version, C version implemented on the PULP platform, Mr.Wolf, and the tools necessaries to extract and re-sample the data can be found here.
## Getting Started
### Prerequisites
### Python version:
- Jupyter-notebook
- Python 3.6.x
- Numpy
- Pandas
- Matplotlib
- wfdb
- tqdm
### C version:
- gCC
- [PULP platform SDK and toolchain](https://github.com/pulp-platform/pulp-sdk)
## Installing and Running
- Create a data folder on the root direcotry of this project, this will be the directory of your RAW data and the output directory.
- Insert your dataset in the MIT-BIH database format (.dat and .hea files) in a subfolder, for example, "dataRaw".
- The database used for developing and testing this algorithm can be found at [MIT-BIH Arrythmia Database](https://physionet.org/content/mitdb/1.0.0/). NOTE: The code
given here is designed to work specifically with this database
- Move in the "data_parsing" folder and lunch ECG_lvlCrossing.py
```
-python3 ECG_lvlCrossing.py -i ../data/dataRaw -o ../data/dataOut -b 5 [-l 'MLII']
+python3 ECG_lvlCrossing.py -i ../data/dataRaw -o ../data/dataOut -b 5 [-l 'MLII'][--hist 0]
```
-This script will extract and resample with an emulated level crossing ADC with number of bits "-b" all the file in the MIT-BIH format found in the direcotry passed by the "-i" argument and output the results in the folder passed with "-o". The default selected electrode is designated as 'MLII', it is possible to change the used electrode with the argument "-l 'Electrode Name'"
+This script will extract and resample with an emulated level crossing ADC with number of bits "-b" all the file in the MIT-BIH format found in the direcotry passed by the "-i" argument and output the results in the folder passed with "-o", in the subfolder "dataOut/lvlCrossingBits__Hist__". The default selected electrode is designated as 'MLII', it is possible to change the used electrode with the argument "-l 'Electrode Name'". By default no Hysteresis is used around the threshold levels. it is possible to give a histeresis value (in percentage) with the argument '--hist'
(Note: is possible also to pass the path of a single file as input.)
### Python version:
-- Run the jupiter notebook contained in the "python_gQRS" folder.
+- Run the jupiter notebook contained in the "python_gQRS" folder. This notebook will produce, at the end, a "result" folder (../data/results) in wich is possible to find the results (accuracy)
### C version:
Important note: This is not a plain C-99 project. This project was developed for the PULP platform "Mr. Wolf". The C code check only one file
- Move in the "C_gQRS" folder and lunch "makeDataHeader.py"
```
python3 makeDataHeader.py -s ../data/dataOut/selectedFile
```
This will create automatically the header containing the data from file "selectedFile" to be used by the C code
- Move to the "C_gQRS" folder
- follow the steps at [PULP platform SDK and toolchain](https://github.com/pulp-platform/pulp-sdk).
- Execute:
```
make clean all run
```
This will start to run the simulation for the selected file multiple time, measuring several parameters of the simulation and returning an overview of the score-results and the performance-results
## Built With
* [Anaconda](https://www.anaconda.com/) - The iPython framework used
* [PULP SDK](https://github.com/pulp-platform/pulp-sdk) - SDK for the PULP platform
## Authors
* **Silvio Zanoli** - [ESL Lab](https://www.epfl.ch/labs/esl/)
* **Tomas Teijeiro** - [ESL Lab](https://www.epfl.ch/labs/esl/)
* **Fabio Montagna** - [University of Bologna](https://www.unibo.it/en)
## License
This project is licensed under the GPL License - see the LICENSE.txt file for details
## Acknowledgments
Thanks to:
* Prof. Dr. David Atienza Alonso
* The Human Brain Project (HBP) SGA2 (GA No. 785907)
* The DeepHealth Project (GA No. 825111)
* The SNF through the ML-Edge Project (GA No. 182009)
* The [ESL Lab](https://www.epfl.ch/labs/esl/)
diff --git a/data_parsing/ECG_lvlCrossing.py b/data_parsing/ECG_lvlCrossing.py
index 1a6e9b3..b0a6db7 100644
--- a/data_parsing/ECG_lvlCrossing.py
+++ b/data_parsing/ECG_lvlCrossing.py
@@ -1,118 +1,122 @@
"""
Created on Fri Feb 22 09:07:30 2019
Simple script to perform a non-uniform subsampling of an ECG record in the MIT-BIH format, using
the Wall-Danielsson algorithm. As output, it produces a 2-column csv file with the sample times
and values.
Dependencies:
- numpy
- tqdm (https://pypi.org/project/tqdm/)
- wfdb-python (https://pypi.org/project/wfdb/)
@author: T. Teijeiro
"""
import numpy as np
from tqdm import trange
import os
def ADC(v, nBits = 5, hist = 0):
"""
To write
"""
delta = 2048
dV = (delta)/(2**nBits)
lowTh = 0
highTh = dV
pos = 0
index = []
temp = 0
for vn in v:
h = highTh + int(hist/100*dV)
l = lowTh - int(hist/100*dV)
if vn > h:
index.append(temp)
for i in range(pos,2**nBits):
lowTh += dV
highTh += dV
pos += 1
if vn < highTh:
break
if vn < l:
index.append(temp)
for i in range(pos,0,-1):
lowTh -= dV
highTh -= dV
pos -= 1
if vn > lowTh:
break
temp += 1
return index
if __name__ == "__main__":
import argparse
import wfdb
parser = argparse.ArgumentParser(description='Performs a nonuniform subsampling of one lead '
'of a MIT-BIH ECG record, generating as output a two-column '
'csv file with the samples time and value.')
parser.add_argument('-i', metavar='input', required=True, help='Input record to be processed')
parser.add_argument('-o', metavar='output', required=True, help='Name of the output csv file')
parser.add_argument('-l', metavar='lead', default='MLII', help='Name of the lead to subsample')
+ parser.add_argument('--hist', type=float, default = 0, help='Hysteresys (perccentage:0%100) for the level overlapping')
parser.add_argument('-b', required=True, type=int,
help=('Number of bits to use in the subsampler, the number of level is given by 2^b'))
args = parser.parse_args()
if os.path.isdir(args.i):
if not os.path.exists(args.o):
os.makedirs(args.o)
+ subFolder = os.path.join(args.o,'lvlCrossingBits{}Hist{}'.format(args.b,args.hist))
+ if not os.path.exists(subFolder):
+ os.makedirs(subFolder)
#find files:
files = []
for x in os.listdir(args.i):
thisFile = os.path.join(args.i,x)
thisFileNoExt = os.path.splitext(thisFile)[0]
if os.path.isfile(thisFile) and os.path.exists(thisFileNoExt+".hea"):
files.append(thisFileNoExt)
n = 1
listOfFiles = list(set(files))
for f in listOfFiles:
print("working on file: ",f,"( ",n,"/",len(listOfFiles),")")
n+=1
singleName = os.path.basename(f)
if singleName == '102' or singleName == '104':
continue
else:
userChannel = args.l
#Record reading
rec = wfdb.rdrecord(f, channel_names=[userChannel], physical=False)
#Input signal as a plain array
s = rec.d_signal.reshape((1, -1))[0]
#Subsampling
if args.b == 0:
subsampled = list(range(len(s)))
else:
- subsampled = ADC(s, args.b)
+ subsampled = ADC(s, nBits = args.b, hist = args.hist)
#Result storage
- fileName = os.path.basename(os.path.normpath(f))+'_b'+str(args.b)+".csv"
- outPath = os.path.join(args.o,fileName)
+ fileName = os.path.basename(os.path.normpath(f))+".csv"
+ outPath = os.path.join(subFolder,fileName)
np.savetxt(outPath, np.column_stack([subsampled, s[subsampled]]), fmt='%d', delimiter=', ')
else:
#Record reading
singleName = os.path.basename(args.i)
if singleName == '102' or singleName == '104':
exit()
else:
userChannel = args.l
rec = wfdb.rdrecord(args.i, channel_names=[userChannel], physical=False)
#Input signal as a plain array
s = rec.d_signal.reshape((1, -1))[0]
#Subsampling
if args.b == 0:
subsampled = list(range(len(s)))
else:
- subsampled = ADC(s, args.b)
+ subsampled = ADC(s, nBits = args.b, hist = args.hist)
#Result storage
np.savetxt(args.o, np.column_stack([subsampled, s[subsampled]]), fmt='%d', delimiter=', ')
diff --git a/python_gQRS/gQRS-lvlCrossingsampling.ipynb b/python_gQRS/gQRS-lvlCrossingsampling.ipynb
new file mode 100644
index 0000000..75950a9
--- /dev/null
+++ b/python_gQRS/gQRS-lvlCrossingsampling.ipynb
@@ -0,0 +1,2486 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# GQRS Algorithm\n",
+ "### An implementation for non-linealy sampled signal"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this notebook we're going to presenet a ri-formulation of the gqrs algorithm by George B. Moody (george@mit.edu) and persent in the [WFDB](https://www.physionet.org/physiotools/wag/gqrs-1.htm) library.\n",
+ "\n",
+ "The classial gQRS algorithm achieve above-the-average performances in the detection of the QRS complex.\n",
+ "In this notebook we will give an alternative formulation that can work with a sub-class of the non-linarly sampled signal while achiveing good results (when compared to the original ones).\n",
+ "\n",
+ "In partiular, the non-linearly sampled signal where generated from the ECG signal in the [MIT-BIH arithmia database](https://physionet.org/physiobank/database/mitdb/). For each signal, the sub-sampling is based on the idea to keep the error between the real(original) curve and the linearly interpolated signal below a given threshold. \n",
+ "\n",
+ "This give us a strong prior: each pair of point in the sub-sampled signal can be linearly interpolated while keeping the error below the selected threshold. We will not execute a linear interpolation during this work but we will use this fact to obtain an efficient re-formulation.\n",
+ "\n",
+ "It's important to notice the total absence of the original smothing filter present in the gQRS algorithm. This is because the sub-sampling can be thought as a strog pice-wise smothing.\n",
+ "\n",
+ "The original python implementation from which this work departed was originally posted on github from: [MIT Laboratory for Computational Physiology](https://github.com/MIT-LCP/wfdb-python) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:22:58.586110Z",
+ "start_time": "2020-01-06T16:22:58.392597Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "#Let's import some usefull standard library\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import pandas as pd\n",
+ "import collections\n",
+ "import copy\n",
+ "import sys\n",
+ "import os\n",
+ "import time\n",
+ "import pprint\n",
+ "pp = pprint.PrettyPrinter(indent=4)\n",
+ "\n",
+ "#In order to write the results found to a standard ANNOTATION file that can be checked with the WFDB bxb tool\n",
+ "scripts = '../data_parsing'\n",
+ "if scripts not in sys.path:\n",
+ " sys.path.insert(0,scripts)\n",
+ "import MITAnnotation as MITA"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## File opening and showing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Each sub-sampled file is saved inside the data directory, inside the directory of the corresponding threshold.\n",
+ "First let's select a threshold, after that we will be able to select the interested file(s).\n",
+ "If we want to select all thresholds (and, after, all files) we can insert -1.\n",
+ "If we want to select a custom location we can insert -2 and in the file selection, insert the path.\n",
+ "\n",
+ "The file format is a standard CSV file with 2 columns: time and value"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:32:00.879432Z",
+ "start_time": "2020-01-06T16:31:58.072371Z"
+ },
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Directories:\n",
+ "Select using the number (-1 to use all the directories):\n",
+ "0 --> ../data/dataOut/lvlCrossingBits5Hist0\n",
+ "-1\n",
+ "Using:\n",
+ "['../data/dataOut/lvlCrossingBits5Hist0']\n"
+ ]
+ }
+ ],
+ "source": [
+ "# We find the folder in 'dataOut' containing the data to use as input for the gQRS algorithm\n",
+ "# change \"dataRaw\" with the output folder used for the ADC\n",
+ "Folder = \"../data/dataOut\"\n",
+ "\n",
+ "dirOut = []\n",
+ "for f in os.listdir(Folder):\n",
+ " path = os.path.join(Folder,f)\n",
+ " if 'lvlCrossingBits' in f and os.path.isdir(path):\n",
+ " dirOut.append(path)\n",
+ "\n",
+ "print(\"Directories:\")\n",
+ "print(\"Select using the number (-1 to use all the directories):\")\n",
+ "for i,name in zip(range(len(dirOut)),dirOut):\n",
+ " print(str(i)+\" --> \"+str(name))\n",
+ " \n",
+ "selectedFolder = int(input())\n",
+ "if selectedFolder == -1:\n",
+ " pass\n",
+ "elif selectedFolder >= len(dirOut):\n",
+ " print(\"Invalid, used the firs as default\")\n",
+ " dirOut = [dirOut[0]]\n",
+ "else:\n",
+ " dirOut = [dirOut[selectedFolder]]\n",
+ "print(\"Using:\")\n",
+ "print(dirOut)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:23:57.018341Z",
+ "start_time": "2020-01-06T16:23:50.918984Z"
+ },
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[ '221',\n",
+ " '212',\n",
+ " '122',\n",
+ " '228',\n",
+ " '109',\n",
+ " '230',\n",
+ " '207',\n",
+ " '119',\n",
+ " '209',\n",
+ " '112',\n",
+ " '115',\n",
+ " '234',\n",
+ " '106',\n",
+ " '205',\n",
+ " '124',\n",
+ " '202',\n",
+ " '219',\n",
+ " '123',\n",
+ " '201',\n",
+ " '101',\n",
+ " '222',\n",
+ " '217',\n",
+ " '231',\n",
+ " '117',\n",
+ " '200',\n",
+ " '111',\n",
+ " '220',\n",
+ " '118',\n",
+ " '203',\n",
+ " '210',\n",
+ " '100',\n",
+ " '114',\n",
+ " '215',\n",
+ " '214',\n",
+ " '103',\n",
+ " '121',\n",
+ " '233',\n",
+ " '107',\n",
+ " '113',\n",
+ " '213',\n",
+ " '116',\n",
+ " '208',\n",
+ " '105',\n",
+ " '108',\n",
+ " '232',\n",
+ " '223',\n",
+ " -1]\n",
+ "Select the wanted file (-1 to use all thresholds): \n",
+ "-1\n",
+ "Opening: ../data/dataOut/lvlCrossingBits5Hist0\n",
+ "(\"Slected file(s): ['221', '212', '122', '228', '109', '230', '207', '119', \"\n",
+ " \"'209', '112', '115', '234', '106', '205', '124', '202', '219', '123', '201', \"\n",
+ " \"'101', '222', '217', '231', '117', '200', '111', '220', '118', '203', '210', \"\n",
+ " \"'100', '114', '215', '214', '103', '121', '233', '107', '113', '213', '116', \"\n",
+ " \"'208', '105', '108', '232', '223']\")\n"
+ ]
+ }
+ ],
+ "source": [
+ "fileList = [os.path.splitext(name)[0] for name in os.listdir(dirOut[0])]\n",
+ "fileList.append(-1)\n",
+ "pp.pprint(fileList)\n",
+ "print(\"Select the wanted file (-1 to use all thresholds): \")\n",
+ "select = int(input())\n",
+ "if select != -1 and str(select) not in fileList:\n",
+ " select = fileList[0]\n",
+ " print('not present, used: ',select)\n",
+ "select = str(select)\n",
+ "\n",
+ "\n",
+ "\n",
+ "data = []\n",
+ "if select != '-1':\n",
+ " for dire in dirOut:\n",
+ " fileThisThreshold = os.path.join(dire,select+'.csv')\n",
+ " data.append([pd.read_csv(fileThisThreshold,header = None)])\n",
+ " selectedFileNames = [select]\n",
+ "elif select == '-1':\n",
+ " for dire in dirOut:\n",
+ " print(\"Opening: \"+str(dire))\n",
+ " data.append([pd.read_csv(os.path.join(dire,os.listdir(dire)[j]),header = None) \n",
+ " for j in range(len(os.listdir(dire)))])\n",
+ " selectedFileNames = [fileList[j]for j in range(len(os.listdir(dirOut[0])))]\n",
+ "\n",
+ "pp.pprint(\"Slected file(s): \"+str(selectedFileNames))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Let's see one file:\n",
+ "We ordered the \"data\" structure as it follow:\n",
+ "\n",
+ "[Threshold][File][DataFrame]\n",
+ "\n",
+ "Select a starting and a stop time (in seconds)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:24:13.222615Z",
+ "start_time": "2020-01-06T16:24:09.429261Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Start: \n",
+ "5\n",
+ "Stop: \n",
+ "15\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Start: ')\n",
+ "start = int(float(input())*360)\n",
+ "print('Stop: ')\n",
+ "stop = int(float(input())*360)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we define a function that return us the indexes to use given the time vector:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:24:14.617418Z",
+ "start_time": "2020-01-06T16:24:14.606408Z"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def getIdxs(time, start, stop):\n",
+ " startIdx = 0\n",
+ " stopIdx = len(t)-1\n",
+ " for i in range(len(time)-1):\n",
+ " if time[i]<=start and time[i+1]> start:\n",
+ " startIdx = i\n",
+ " if time[i]<=stop and time[i+1]> stop:\n",
+ " stopIdx = i\n",
+ " \n",
+ " return startIdx,stopIdx"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-01-06T16:24:16.064468Z",
+ "start_time": "2020-01-06T16:24:15.171604Z"
+ },
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'thresholdComplete' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'ECG at threshold = '\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthresholdComplete\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mth\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m35\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_xlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Time\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m35\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_ylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"ADC value\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m35\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mNameError\u001b[0m: name 'thresholdComplete' is not defined"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "