Normalized_Dataframe_Denoised_iPlots_PeakDetector (1) (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3ce6fe81",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import sklearn\n",
    "from sklearn import preprocessing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "19db2400",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(r\"C:\\Users\\HP\\Downloads\\Ningbo\\Atrial Flutter\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1132,
   "id": "0bb9ff79",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data=pd.read_csv(r\"C:\\Users\\HP\\Downloads\\Ningbo\\Atrial Flutter\\JS15518.csv\", header=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1133,
   "id": "f2f6b239",
   "metadata": {},
   "outputs": [],
   "source": [
    "normalized = preprocessing.normalize(data)\n",
    "#print(\"Normalized Data = \", normalized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1134,
   "id": "97bd5b45",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.DataFrame(normalized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1135,
   "id": "c22b3936",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "from scipy.signal import butter, iirnotch, lfilter\n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "class Denoise:\n",
    "\n",
    "        fs = globals()\n",
    "        order = globals()\n",
    "        cutoff_high = globals()\n",
    "        cutoff_low = globals()\n",
    "        powerline = globals()\n",
    "        nyq = globals()\n",
    "\n",
    "        def set_parameters(**kwargs):\n",
    "            for key, value in kwargs.items():\n",
    "                print(\"{0} = {1}\" .format(key, value))\n",
    "\n",
    "            fs = list(kwargs.values())[0]\n",
    "            order = list(kwargs.values())[1]\n",
    "            cutoff_high = list(kwargs.values())[2]\n",
    "            cutoff_low = list(kwargs.values())[3]\n",
    "            powerline = list(kwargs.values())[4]\n",
    "\n",
    "            nyq = 0.5 * fs\n",
    "\n",
    "            return fs, order, cutoff_high, cutoff_low, powerline, nyq\n",
    "\n",
    "        assert fs == fs\n",
    "        assert order == order\n",
    "        assert cutoff_high == cutoff_high\n",
    "        assert cutoff_low == cutoff_low\n",
    "        assert powerline == powerline\n",
    "\n",
    "        assert nyq == nyq\n",
    "\n",
    "        ## Butter high pass filter allows frequencies higher than a cut-off value\n",
    "        def bhpf(cutoff, order, nyq):\n",
    "            #nyq = 0.5 * fs\n",
    "            normal_cutoff = cutoff/nyq\n",
    "            b, a = butter(order, normal_cutoff, btype='high', analog=False, output='ba')\n",
    "            return b, a\n",
    "\n",
    "        ## Butter low pass filter allows frequencies lower than a cut-off value\n",
    "        def blpf(cutoff, order, nyq):\n",
    "            #nyq = 0.5 * fs\n",
    "            normal_cutoff = cutoff/nyq\n",
    "            b, a = butter(order, normal_cutoff, btype='low', analog=False, output='ba')\n",
    "            return b, a\n",
    "\n",
    "        ## Notch filter \n",
    "        def nf(cutoff, q, nyq):\n",
    "            #nyq = 0.5 * fs\n",
    "            freq = cutoff/nyq\n",
    "            b, a = iirnotch(freq, q)\n",
    "            return b, a\n",
    "\n",
    "        ## Applying high pass filter \n",
    "        def hpfd(data, cutoff_high, order, nyq):\n",
    "            b,a = bhpf(cutoff_high, order, nyq)\n",
    "            x = lfilter(b,a,data)\n",
    "            return x\n",
    "\n",
    "        ## Applying low pass filter \n",
    "        def lpfd(data, cutoff_low, order, nyq):\n",
    "            b,a = blpf(cutoff_low, order, nyq)\n",
    "            y = lfilter(b,a,data)\n",
    "            return y\n",
    "\n",
    "        ## Applying notch filter\n",
    "        def nd(data, powerline, q):\n",
    "            b,a = nf(powerline,q)\n",
    "            z = lfilter(b,a,data)\n",
    "            return z\n",
    "\n",
    "        ## Ensembling of the filter\n",
    "        def overlay_filter(data, cutoff_high, cutoff_low, nyq, powerline, fs, order):\n",
    "            b, a = Denoise.bhpf(cutoff_high, order, nyq)\n",
    "            x = lfilter(b, a, data)\n",
    "            d, c = Denoise.blpf(cutoff_low, order, nyq)\n",
    "            y = lfilter(d, c, x)\n",
    "            f, e = Denoise.nf(powerline, 30, nyq)\n",
    "            z = lfilter(f, e, y)     \n",
    "            return z\n",
    "\n",
    "        def plot_and_write(df, featurecol_index:int, fs=fs, cutoff_high=cutoff_high, cutoff_low=cutoff_low, nyq=nyq, powerline=powerline, order=order):\n",
    "            #fs = 500; cutoff_high = 0.5; cutoff_low = 2; powerline = 60\n",
    "            #order = 5 ## Order of five works well with ECG signals\n",
    "\n",
    "            plt.figure(1)\n",
    "            ax1 = plt.subplot(121)\n",
    "            plt.plot(df.iloc[:,featurecol_index:])\n",
    "            ax1.set_title(\"Raw ECG Signal\")\n",
    "\n",
    "            filter_ts_signal = Denoise.overlay_filter(df.iloc[:,featurecol_index:], cutoff_high, cutoff_low, nyq, powerline, fs, order)\n",
    "            ax2 = plt.subplot(122)\n",
    "            plt.plot(filter_ts_signal)\n",
    "            ax2.set_title(\"Denoised ECG Signal\")\n",
    "            plt.show()\n",
    "            #filtered_dataset = pd.concat([df.iloc[:,:featurecol_index], filter_ts_signal])\n",
    "            cols = list(df.iloc[:,featurecol_index:])\n",
    "            #filtered_dataset = pd.DataFrame({'Date':df.Date, 'Time': df.Time,'ecg1': filter_ts_signal[:, 0], 'ecg2': filter_ts_signal[:, 1],'ecg3': filter_ts_signal[:, 2],'ecg4': filter_ts_signal[:, 3],'ecg5': filter_ts_signal[:, 4]})\n",
    "            filter_ts_signal_dataset = pd.DataFrame(np.array(filter_ts_signal), columns=cols) \n",
    "            filtered_dataset = pd.concat([df.iloc[:, :featurecol_index].reset_index(), filter_ts_signal_dataset.reset_index()], axis=1)\n",
    "            filtered_dataset.drop(columns=['index'], inplace=True)\n",
    "            filtered_dataset.to_csv('JS15518.csv', index=None)\n",
    "            return filtered_dataset\n",
    "\n",
    "        def write_csv():\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1136,
   "id": "7a234be5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fs = 500\n",
      "order = 5\n",
      "cutoff_high = 0.1\n",
      "cutoff_low = 100\n",
      "powerline = 50\n"
     ]
    }
   ],
   "source": [
    "fs, order, cutoff_high, cutoff_low, powerline, nyq = Denoise.set_parameters(fs = 500, order =5, cutoff_high = 0.1, cutoff_low = 100, powerline = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1137,
   "id": "2a5bd572",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "      <th>11</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.000290</td>\n",
       "      <td>-0.000338</td>\n",
       "      <td>0.005694</td>\n",
       "      <td>0.024552</td>\n",
       "      <td>0.043317</td>\n",
       "      <td>0.033577</td>\n",
       "      <td>0.006062</td>\n",
       "      <td>0.043478</td>\n",
       "      <td>0.224728</td>\n",
       "      <td>0.478187</td>\n",
       "      <td>0.571558</td>\n",
       "      <td>0.362723</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.000283</td>\n",
       "      <td>-0.000047</td>\n",
       "      <td>0.007533</td>\n",
       "      <td>0.029855</td>\n",
       "      <td>0.051843</td>\n",
       "      <td>0.041576</td>\n",
       "      <td>0.011190</td>\n",
       "      <td>0.049772</td>\n",
       "      <td>0.236382</td>\n",
       "      <td>0.488640</td>\n",
       "      <td>0.567834</td>\n",
       "      <td>0.342519</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000555</td>\n",
       "      <td>0.003868</td>\n",
       "      <td>0.011249</td>\n",
       "      <td>0.016774</td>\n",
       "      <td>0.011464</td>\n",
       "      <td>0.006371</td>\n",
       "      <td>0.056300</td>\n",
       "      <td>0.226371</td>\n",
       "      <td>0.464475</td>\n",
       "      <td>0.554661</td>\n",
       "      <td>0.347999</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.000272</td>\n",
       "      <td>-0.001351</td>\n",
       "      <td>-0.001857</td>\n",
       "      <td>0.002130</td>\n",
       "      <td>0.009620</td>\n",
       "      <td>0.010739</td>\n",
       "      <td>0.007335</td>\n",
       "      <td>0.048601</td>\n",
       "      <td>0.208497</td>\n",
       "      <td>0.449742</td>\n",
       "      <td>0.557279</td>\n",
       "      <td>0.365626</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.001070</td>\n",
       "      <td>0.007930</td>\n",
       "      <td>0.025602</td>\n",
       "      <td>0.045049</td>\n",
       "      <td>0.041719</td>\n",
       "      <td>0.009459</td>\n",
       "      <td>-0.011638</td>\n",
       "      <td>0.045436</td>\n",
       "      <td>0.223995</td>\n",
       "      <td>0.457495</td>\n",
       "      <td>0.543039</td>\n",
       "      <td>0.343095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4994</th>\n",
       "      <td>-0.005097</td>\n",
       "      <td>-0.022911</td>\n",
       "      <td>-0.018105</td>\n",
       "      <td>0.088393</td>\n",
       "      <td>0.255059</td>\n",
       "      <td>0.268317</td>\n",
       "      <td>0.068655</td>\n",
       "      <td>-0.084985</td>\n",
       "      <td>-0.014868</td>\n",
       "      <td>0.112274</td>\n",
       "      <td>0.098653</td>\n",
       "      <td>-0.006414</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4995</th>\n",
       "      <td>-0.004747</td>\n",
       "      <td>-0.020529</td>\n",
       "      <td>-0.011244</td>\n",
       "      <td>0.098721</td>\n",
       "      <td>0.262314</td>\n",
       "      <td>0.267529</td>\n",
       "      <td>0.063471</td>\n",
       "      <td>-0.087498</td>\n",
       "      <td>-0.011504</td>\n",
       "      <td>0.122135</td>\n",
       "      <td>0.114171</td>\n",
       "      <td>0.011789</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4996</th>\n",
       "      <td>-0.004032</td>\n",
       "      <td>-0.015729</td>\n",
       "      <td>0.002316</td>\n",
       "      <td>0.118286</td>\n",
       "      <td>0.274035</td>\n",
       "      <td>0.262142</td>\n",
       "      <td>0.051747</td>\n",
       "      <td>-0.088124</td>\n",
       "      <td>-0.000721</td>\n",
       "      <td>0.130864</td>\n",
       "      <td>0.115060</td>\n",
       "      <td>0.011496</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4997</th>\n",
       "      <td>-0.003618</td>\n",
       "      <td>-0.012947</td>\n",
       "      <td>0.010200</td>\n",
       "      <td>0.129684</td>\n",
       "      <td>0.280702</td>\n",
       "      <td>0.258373</td>\n",
       "      <td>0.044455</td>\n",
       "      <td>-0.087475</td>\n",
       "      <td>0.004756</td>\n",
       "      <td>0.122537</td>\n",
       "      <td>0.083235</td>\n",
       "      <td>-0.027985</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4998</th>\n",
       "      <td>-0.004005</td>\n",
       "      <td>-0.015485</td>\n",
       "      <td>0.003283</td>\n",
       "      <td>0.120294</td>\n",
       "      <td>0.276002</td>\n",
       "      <td>0.261866</td>\n",
       "      <td>0.049394</td>\n",
       "      <td>-0.088705</td>\n",
       "      <td>-0.000775</td>\n",
       "      <td>0.116737</td>\n",
       "      <td>0.073344</td>\n",
       "      <td>-0.046871</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4999 rows × 12 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             0         1         2         3         4         5         6  \\\n",
       "0    -0.000290 -0.000338  0.005694  0.024552  0.043317  0.033577  0.006062   \n",
       "1    -0.000283 -0.000047  0.007533  0.029855  0.051843  0.041576  0.011190   \n",
       "2     0.000000  0.000555  0.003868  0.011249  0.016774  0.011464  0.006371   \n",
       "3    -0.000272 -0.001351 -0.001857  0.002130  0.009620  0.010739  0.007335   \n",
       "4     0.001070  0.007930  0.025602  0.045049  0.041719  0.009459 -0.011638   \n",
       "...        ...       ...       ...       ...       ...       ...       ...   \n",
       "4994 -0.005097 -0.022911 -0.018105  0.088393  0.255059  0.268317  0.068655   \n",
       "4995 -0.004747 -0.020529 -0.011244  0.098721  0.262314  0.267529  0.063471   \n",
       "4996 -0.004032 -0.015729  0.002316  0.118286  0.274035  0.262142  0.051747   \n",
       "4997 -0.003618 -0.012947  0.010200  0.129684  0.280702  0.258373  0.044455   \n",
       "4998 -0.004005 -0.015485  0.003283  0.120294  0.276002  0.261866  0.049394   \n",
       "\n",
       "             7         8         9        10        11  \n",
       "0     0.043478  0.224728  0.478187  0.571558  0.362723  \n",
       "1     0.049772  0.236382  0.488640  0.567834  0.342519  \n",
       "2     0.056300  0.226371  0.464475  0.554661  0.347999  \n",
       "3     0.048601  0.208497  0.449742  0.557279  0.365626  \n",
       "4     0.045436  0.223995  0.457495  0.543039  0.343095  \n",
       "...        ...       ...       ...       ...       ...  \n",
       "4994 -0.084985 -0.014868  0.112274  0.098653 -0.006414  \n",
       "4995 -0.087498 -0.011504  0.122135  0.114171  0.011789  \n",
       "4996 -0.088124 -0.000721  0.130864  0.115060  0.011496  \n",
       "4997 -0.087475  0.004756  0.122537  0.083235 -0.027985  \n",
       "4998 -0.088705 -0.000775  0.116737  0.073344 -0.046871  \n",
       "\n",
       "[4999 rows x 12 columns]"
      ]
     },
     "execution_count": 1137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Denoise.plot_and_write(df, featurecol_index=0, fs=fs, cutoff_high=cutoff_high, cutoff_low=cutoff_low, nyq = nyq, powerline=powerline, order=order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1138,
   "id": "a98cfe4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "        <script type=\"text/javascript\">\n",
       "        window.PlotlyConfig = {MathJaxConfig: 'local'};\n",
       "        if (window.MathJax && window.MathJax.Hub && window.MathJax.Hub.Config) {window.MathJax.Hub.Config({SVG: {font: \"STIX-Web\"}});}\n",
       "        if (typeof require !== 'undefined') {\n",
       "        require.undef(\"plotly\");\n",
       "        requirejs.config({\n",
       "            paths: {\n",
       "                'plotly': ['https://cdn.plot.ly/plotly-2.12.1.min']\n",
       "            }\n",
       "        });\n",
       "        require(['plotly'], function(Plotly) {\n",
       "            window._Plotly = Plotly;\n",
       "        });\n",
       "        }\n",
       "        </script>\n",
       "        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'cufflinks'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_2400\\3589293898.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0mplotly\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moffline\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mdownload_plotlyjs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minit_notebook_mode\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mplot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miplot\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0minit_notebook_mode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconnected\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mcufflinks\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mcf\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0mcf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgo_offline\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'cufflinks'"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot\n",
    "init_notebook_mode(connected=True)\n",
    "import cufflinks as cf\n",
    "cf.go_offline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "005fcc14",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28b2574a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Clean=pd.read_csv(r\"E:\\RUMSHA\\National University of Sciences & Technology\\DAL Research - Rumsha Fatima\\Data in excel\\XLSX Files\\Denoised.csv\", header=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5319546a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_Clean.iplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a65de756",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pywt\n",
    "\n",
    "\n",
    "try:\n",
    "    import pathlib\n",
    "except ImportError:\n",
    "    import pathlib2 as pathlib\n",
    "import scipy.signal as signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecd1f479",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Detectors:\n",
    "    \"\"\"ECG heartbeat detection algorithms\n",
    "    General useage instructions:\n",
    "    r_peaks = detectors.the_detector(ecg_in_samples)\n",
    "    The argument ecg_in_samples is a single channel ECG in volt\n",
    "    at the given sample rate.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, sampling_frequency = False):\n",
    "        \"\"\"\n",
    "        The constructor takes the sampling rate in Hz of the ECG data.\n",
    "        The constructor can be called without speciying a sampling rate to\n",
    "        just access the detector_list, however, detection won't\n",
    "        be possible.\n",
    "        \"\"\"\n",
    "\n",
    "        ## Sampling rate\n",
    "        self.fs = sampling_frequency\n",
    "\n",
    "        ## This is set to a positive value for benchmarking\n",
    "        self.engzee_fake_delay = 0\n",
    "\n",
    "        ## 2D Array of the different detectors: [[description,detector]]\n",
    "        self.detector_list = [\n",
    "            [\"Elgendi et al (Two average)\",self.two_average_detector],\n",
    "            [\"Kalidas & Tamil (Wavelet transform)\",self.swt_detector],\n",
    "            [\"Engzee\",self.engzee_detector],\n",
    "            [\"Christov\",self.christov_detector],\n",
    "            [\"Hamilton\",self.hamilton_detector],\n",
    "            [\"Pan Tompkins\",self.pan_tompkins_detector],\n",
    "            [\"WQRS\",self.wqrs_detector]\n",
    "        ]\n",
    "\n",
    "    def get_detector_list(self):\n",
    "        \"\"\"\n",
    "        Returns a 2D array of the different detectors in the form:\n",
    "        [[description1,detector1],[description2,detector2], ...]\n",
    "        where description is a string and detector a function pointer\n",
    "        to the detector. Use this for benchmarking to loop through\n",
    "        detectors.\n",
    "        \"\"\"\n",
    "        return self.detector_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0895fb2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hamilton_detector(self, unfiltered_ecg):\n",
    "        \"\"\"\n",
    "        P.S. Hamilton, \n",
    "        Open Source ECG Analysis Software Documentation, E.P.Limited, 2002.\n",
    "        \"\"\"\n",
    "        \n",
    "        f1 = 8/self.fs\n",
    "        f2 = 16/self.fs\n",
    "\n",
    "        b, a = signal.butter(1, [f1*2, f2*2], btype='bandpass')\n",
    "\n",
    "        filtered_ecg = signal.lfilter(b, a, unfiltered_ecg)\n",
    "\n",
    "        diff = abs(np.diff(filtered_ecg))\n",
    "\n",
    "        b = np.ones(int(0.08*self.fs))\n",
    "        b = b/int(0.08*self.fs)\n",
    "        a = [1]\n",
    "\n",
    "        ma = signal.lfilter(b, a, diff)\n",
    "\n",
    "        ma[0:len(b)*2] = 0\n",
    "\n",
    "        n_pks = []\n",
    "        n_pks_ave = 0.0\n",
    "        s_pks = []\n",
    "        s_pks_ave = 0.0\n",
    "        QRS = [0]\n",
    "        RR = []\n",
    "        RR_ave = 0.0\n",
    "\n",
    "        th = 0.0\n",
    "\n",
    "        i=0\n",
    "        idx = []\n",
    "        peaks = []  \n",
    "\n",
    "        for i in range(len(ma)):\n",
    "\n",
    "            if i>0 and i<len(ma)-1:\n",
    "                if ma[i-1]<ma[i] and ma[i+1]<ma[i]:\n",
    "                    peak = i\n",
    "                    peaks.append(i)\n",
    "\n",
    "                    if ma[peak] > th and (peak-QRS[-1])>0.3*self.fs:        \n",
    "                        QRS.append(peak)\n",
    "                        idx.append(i)\n",
    "                        s_pks.append(ma[peak])\n",
    "                        if len(n_pks)>8:\n",
    "                            s_pks.pop(0)\n",
    "                        s_pks_ave = np.mean(s_pks)\n",
    "\n",
    "                        if RR_ave != 0.0:\n",
    "                            if QRS[-1]-QRS[-2] > 1.5*RR_ave:\n",
    "                                missed_peaks = peaks[idx[-2]+1:idx[-1]]\n",
    "                                for missed_peak in missed_peaks:\n",
    "                                    if missed_peak-peaks[idx[-2]]>int(0.360*self.fs) and ma[missed_peak]>0.5*th:\n",
    "                                        QRS.append(missed_peak)\n",
    "                                        QRS.sort()\n",
    "                                        break\n",
    "\n",
    "                        if len(QRS)>2:\n",
    "                            RR.append(QRS[-1]-QRS[-2])\n",
    "                            if len(RR)>8:\n",
    "                                RR.pop(0)\n",
    "                            RR_ave = int(np.mean(RR))\n",
    "\n",
    "                    else:\n",
    "                        n_pks.append(ma[peak])\n",
    "                        if len(n_pks)>8:\n",
    "                            n_pks.pop(0)\n",
    "                        n_pks_ave = np.mean(n_pks)\n",
    "\n",
    "                    th = n_pks_ave + 0.45*(s_pks_ave-n_pks_ave)\n",
    "\n",
    "                    i+=1\n",
    "\n",
    "        QRS.pop(0)\n",
    "\n",
    "        return QRS\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "601123aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def christov_detector(self, unfiltered_ecg):\n",
    "        \"\"\"\n",
    "        Ivaylo I. Christov, \n",
    "        Real time electrocardiogram QRS detection using combined \n",
    "        adaptive threshold, BioMedical Engineering OnLine 2004, \n",
    "        vol. 3:28, 2004.\n",
    "        \"\"\"\n",
    "        total_taps = 0\n",
    "\n",
    "        b = np.ones(int(0.02*self.fs))\n",
    "        b = b/int(0.02*self.fs)\n",
    "        total_taps += len(b)\n",
    "        a = [1]\n",
    "\n",
    "        MA1 = signal.lfilter(b, a, unfiltered_ecg)\n",
    "\n",
    "        b = np.ones(int(0.028*self.fs))\n",
    "        b = b/int(0.028*self.fs)\n",
    "        total_taps += len(b)\n",
    "        a = [1]\n",
    "\n",
    "        MA2 = signal.lfilter(b, a, MA1)\n",
    "\n",
    "        Y = []\n",
    "        for i in range(1, len(MA2)-1):\n",
    "            \n",
    "            diff = abs(MA2[i+1]-MA2[i-1])\n",
    "\n",
    "            Y.append(diff)\n",
    "\n",
    "        b = np.ones(int(0.040*self.fs))\n",
    "        b = b/int(0.040*self.fs)\n",
    "        total_taps += len(b)\n",
    "        a = [1]\n",
    "\n",
    "        MA3 = signal.lfilter(b, a, Y)\n",
    "\n",
    "        MA3[0:total_taps] = 0\n",
    "\n",
    "        ms50 = int(0.05*self.fs)\n",
    "        ms200 = int(0.2*self.fs)\n",
    "        ms1200 = int(1.2*self.fs)\n",
    "        ms350 = int(0.35*self.fs)\n",
    "\n",
    "        M = 0\n",
    "        newM5 = 0\n",
    "        M_list = []\n",
    "        MM = []\n",
    "        M_slope = np.linspace(1.0, 0.6, ms1200-ms200)\n",
    "        F = 0\n",
    "        F_list = []\n",
    "        R = 0\n",
    "        RR = []\n",
    "        Rm = 0\n",
    "        R_list = []\n",
    "\n",
    "        MFR = 0\n",
    "        MFR_list = []\n",
    "\n",
    "        QRS = []\n",
    "\n",
    "        for i in range(len(MA3)):\n",
    "\n",
    "            # M\n",
    "            if i < 5*self.fs:\n",
    "                M = 0.6*np.max(MA3[:i+1])\n",
    "                MM.append(M)\n",
    "                if len(MM)>5:\n",
    "                    MM.pop(0)\n",
    "\n",
    "            elif QRS and i < QRS[-1]+ms200:\n",
    "                newM5 = 0.6*np.max(MA3[QRS[-1]:i])\n",
    "                if newM5>1.5*MM[-1]:\n",
    "                    newM5 = 1.1*MM[-1]\n",
    "\n",
    "            elif QRS and i == QRS[-1]+ms200:\n",
    "                if newM5==0:\n",
    "                    newM5 = MM[-1]\n",
    "                MM.append(newM5)\n",
    "                if len(MM)>5:\n",
    "                    MM.pop(0)    \n",
    "                M = np.mean(MM)    \n",
    "            \n",
    "            elif QRS and i > QRS[-1]+ms200 and i < QRS[-1]+ms1200:\n",
    "\n",
    "                M = np.mean(MM)*M_slope[i-(QRS[-1]+ms200)]\n",
    "\n",
    "            elif QRS and i > QRS[-1]+ms1200:\n",
    "                M = 0.6*np.mean(MM)\n",
    "\n",
    "            # F\n",
    "            if i > ms350:\n",
    "                F_section = MA3[i-ms350:i]\n",
    "                max_latest = np.max(F_section[-ms50:])\n",
    "                max_earliest = np.max(F_section[:ms50])\n",
    "                F = F + ((max_latest-max_earliest)/150.0)\n",
    "\n",
    "            # R\n",
    "            if QRS and i < QRS[-1]+int((2.0/3.0*Rm)):\n",
    "\n",
    "                R = 0\n",
    "\n",
    "            elif QRS and i > QRS[-1]+int((2.0/3.0*Rm)) and i < QRS[-1]+Rm:\n",
    "\n",
    "                dec = (M-np.mean(MM))/1.4\n",
    "                R = 0 + dec\n",
    "\n",
    "\n",
    "            MFR = M+F+R\n",
    "            M_list.append(M)\n",
    "            F_list.append(F)\n",
    "            R_list.append(R)\n",
    "            MFR_list.append(MFR)\n",
    "\n",
    "            if not QRS and MA3[i]>MFR:\n",
    "                QRS.append(i)\n",
    "            \n",
    "            elif QRS and i > QRS[-1]+ms200 and MA3[i]>MFR:\n",
    "                QRS.append(i)\n",
    "                if len(QRS)>2:\n",
    "                    RR.append(QRS[-1]-QRS[-2])\n",
    "                    if len(RR)>5:\n",
    "                        RR.pop(0)\n",
    "                    Rm = int(np.mean(RR))\n",
    "\n",
    "        QRS.pop(0)\n",
    "        \n",
    "        return QRS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73df5f38",
   "metadata": {},
   "outputs": [],
   "source": [
    "def engzee_detector(self, unfiltered_ecg):\n",
    "        \"\"\"\n",
    "        C. Zeelenberg, A single scan algorithm for QRS detection and\n",
    "        feature extraction, IEEE Comp. in Cardiology, vol. 6,\n",
    "        pp. 37-42, 1979 with modifications A. Lourenco, H. Silva,\n",
    "        P. Leite, R. Lourenco and A. Fred, “Real Time\n",
    "        Electrocardiogram Segmentation for Finger Based ECG\n",
    "        Biometrics”, BIOSIGNALS 2012, pp. 49-54, 2012.\n",
    "        \"\"\"\n",
    "                \n",
    "        f1 = 48/self.fs\n",
    "        f2 = 52/self.fs\n",
    "        b, a = signal.butter(4, [f1*2, f2*2], btype='bandstop')\n",
    "        filtered_ecg = signal.lfilter(b, a, unfiltered_ecg)\n",
    "\n",
    "        diff = np.zeros(len(filtered_ecg))\n",
    "        for i in range(4, len(diff)):\n",
    "            diff[i] = filtered_ecg[i]-filtered_ecg[i-4]\n",
    "\n",
    "        ci = [1,4,6,4,1]        \n",
    "        low_pass = signal.lfilter(ci, 1, diff)\n",
    "\n",
    "        low_pass[:int(0.2*self.fs)] = 0\n",
    "      \n",
    "        ms200 = int(0.2*self.fs)\n",
    "        ms1200 = int(1.2*self.fs)        \n",
    "        ms160 = int(0.16*self.fs)\n",
    "        neg_threshold = int(0.01*self.fs)\n",
    "\n",
    "        M = 0\n",
    "        M_list = []\n",
    "        neg_m = []\n",
    "        MM = []\n",
    "        M_slope = np.linspace(1.0, 0.6, ms1200-ms200)\n",
    "\n",
    "        QRS = []\n",
    "        r_peaks = []\n",
    "\n",
    "        counter = 0\n",
    "\n",
    "        thi_list = []\n",
    "        thi = False\n",
    "        thf_list = []\n",
    "        thf = False\n",
    "        newM5 = False\n",
    "\n",
    "        for i in range(len(low_pass)):\n",
    "\n",
    "            # M\n",
    "            if i < 5*self.fs:\n",
    "                M = 0.6*np.max(low_pass[:i+1])\n",
    "                MM.append(M)\n",
    "                if len(MM)>5:\n",
    "                    MM.pop(0)\n",
    "\n",
    "            elif QRS and i < QRS[-1]+ms200:\n",
    "\n",
    "                newM5 = 0.6*np.max(low_pass[QRS[-1]:i])\n",
    "\n",
    "                if newM5>1.5*MM[-1]:\n",
    "                    newM5 = 1.1*MM[-1]\n",
    "\n",
    "            elif newM5 and QRS and i == QRS[-1]+ms200:\n",
    "                MM.append(newM5)\n",
    "                if len(MM)>5:\n",
    "                    MM.pop(0)    \n",
    "                M = np.mean(MM)    \n",
    "            \n",
    "            elif QRS and i > QRS[-1]+ms200 and i < QRS[-1]+ms1200:\n",
    "\n",
    "                M = np.mean(MM)*M_slope[i-(QRS[-1]+ms200)]\n",
    "\n",
    "            elif QRS and i > QRS[-1]+ms1200:\n",
    "                M = 0.6*np.mean(MM)\n",
    "\n",
    "            M_list.append(M)\n",
    "            neg_m.append(-M)\n",
    "\n",
    "\n",
    "            if not QRS and low_pass[i]>M:\n",
    "                QRS.append(i)\n",
    "                thi_list.append(i)\n",
    "                thi = True\n",
    "            \n",
    "            elif QRS and i > QRS[-1]+ms200 and low_pass[i]>M:\n",
    "                QRS.append(i)\n",
    "                thi_list.append(i)\n",
    "                thi = True\n",
    "\n",
    "            if thi and i<thi_list[-1]+ms160:\n",
    "                if low_pass[i]<-M and low_pass[i-1]>-M:\n",
    "                    #thf_list.append(i)\n",
    "                    thf = True\n",
    "                    \n",
    "                if thf and low_pass[i]<-M:\n",
    "                    thf_list.append(i)\n",
    "                    counter += 1\n",
    "                \n",
    "                elif low_pass[i]>-M and thf:\n",
    "                    counter = 0\n",
    "                    thi = False\n",
    "                    thf = False\n",
    "            \n",
    "            elif thi and i>thi_list[-1]+ms160:\n",
    "                    counter = 0\n",
    "                    thi = False\n",
    "                    thf = False                                        \n",
    "            \n",
    "            if counter>neg_threshold:\n",
    "                unfiltered_section = unfiltered_ecg[thi_list[-1]-int(0.01*self.fs):i]\n",
    "                r_peaks.append(self.engzee_fake_delay+\n",
    "                               np.argmax(unfiltered_section)+thi_list[-1]-int(0.01*self.fs))\n",
    "                counter = 0\n",
    "                thi = False\n",
    "                thf = False\n",
    "\n",
    "        # removing the 1st detection as it 1st needs the QRS complex amplitude for the threshold\n",
    "        r_peaks.pop(0)\n",
    "        return r_peaks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0441b335",
   "metadata": {},
   "outputs": [],
   "source": [
    "def swt_detector(self, unfiltered_ecg, MWA_name='cumulative'):\n",
    "        \"\"\"\n",
    "        Stationary Wavelet Transform \n",
    "        based on Vignesh Kalidas and Lakshman Tamil. \n",
    "        Real-time QRS detector using Stationary Wavelet Transform \n",
    "        for Automated ECG Analysis. \n",
    "        In: 2017 IEEE 17th International Conference on \n",
    "        Bioinformatics and Bioengineering (BIBE). \n",
    "        Uses the Pan and Tompkins thresolding.\n",
    "        \"\"\"\n",
    "        \n",
    "        maxQRSduration = 0.150 #sec\n",
    "        swt_level=3\n",
    "        padding = -1\n",
    "        for i in range(1000):\n",
    "            if (len(unfiltered_ecg)+i)%2**swt_level == 0:\n",
    "                padding = i\n",
    "                break\n",
    "\n",
    "        if padding > 0:\n",
    "            unfiltered_ecg = np.pad(unfiltered_ecg, (0, padding), 'edge')\n",
    "        elif padding == -1:\n",
    "            print(\"Padding greater than 1000 required\\n\")    \n",
    "\n",
    "        swt_ecg = pywt.swt(unfiltered_ecg, 'db3', level=swt_level)\n",
    "        swt_ecg = np.array(swt_ecg)\n",
    "        swt_ecg = swt_ecg[0, 1, :]\n",
    "\n",
    "        squared = swt_ecg*swt_ecg\n",
    "\n",
    "        N = int(maxQRSduration*self.fs)\n",
    "        mwa = MWA_from_name(MWA_name)(squared, N)\n",
    "        mwa[:int(maxQRSduration*self.fs*2)] = 0\n",
    "\n",
    "        filt_peaks = panPeakDetect(mwa, self.fs)\n",
    "        \n",
    "        return filt_peaks\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3743f9fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def pan_tompkins_detector(self, unfiltered_ecg, MWA_name='cumulative'):\n",
    "        \"\"\"\n",
    "        Jiapu Pan and Willis J. Tompkins.\n",
    "        A Real-Time QRS Detection Algorithm. \n",
    "        In: IEEE Transactions on Biomedical Engineering \n",
    "        BME-32.3 (1985), pp. 230–236.\n",
    "        \"\"\"\n",
    "        \n",
    "        maxQRSduration = 0.150 #sec\n",
    "        f1 = 5/self.fs\n",
    "        f2 = 15/self.fs\n",
    "\n",
    "        b, a = signal.butter(1, [f1*2, f2*2], btype='bandpass')\n",
    "\n",
    "        filtered_ecg = signal.lfilter(b, a, unfiltered_ecg)        \n",
    "\n",
    "        diff = np.diff(filtered_ecg) \n",
    "\n",
    "        squared = diff*diff\n",
    "\n",
    "        N = int(maxQRSduration*self.fs)\n",
    "        mwa = MWA_from_name(MWA_name)(squared, N)\n",
    "        mwa[:int(maxQRSduration*self.fs*2)] = 0\n",
    "\n",
    "        mwa_peaks = panPeakDetect(mwa, self.fs)\n",
    "\n",
    "        return mwa_peaks\n",
    "    \n",
    "def two_average_detector(self, unfiltered_ecg, MWA_name='cumulative'):\n",
    "        \"\"\"\n",
    "        Elgendi, Mohamed & Jonkman, \n",
    "        Mirjam & De Boer, Friso. (2010).\n",
    "        Frequency Bands Effects on QRS Detection.\n",
    "        The 3rd International Conference on Bio-inspired Systems \n",
    "        and Signal Processing (BIOSIGNALS2010). 428-431.\n",
    "        \"\"\"\n",
    "        \n",
    "        f1 = 8/self.fs\n",
    "        f2 = 20/self.fs\n",
    "\n",
    "        b, a = signal.butter(2, [f1*2, f2*2], btype='bandpass')\n",
    "\n",
    "        filtered_ecg = signal.lfilter(b, a, unfiltered_ecg)\n",
    "\n",
    "        window1 = int(0.12*self.fs)\n",
    "        mwa_qrs = MWA_from_name(MWA_name)(abs(filtered_ecg), window1)\n",
    "\n",
    "        window2 = int(0.6*self.fs)\n",
    "        mwa_beat = MWA_from_name(MWA_name)(abs(filtered_ecg), window2)\n",
    "\n",
    "        blocks = np.zeros(len(unfiltered_ecg))\n",
    "        block_height = np.max(filtered_ecg)\n",
    "\n",
    "        for i in range(len(mwa_qrs)):\n",
    "            if mwa_qrs[i] > mwa_beat[i]:\n",
    "                blocks[i] = block_height\n",
    "            else:\n",
    "                blocks[i] = 0\n",
    "\n",
    "        QRS = []\n",
    "\n",
    "        for i in range(1, len(blocks)):\n",
    "            if blocks[i-1] == 0 and blocks[i] == block_height:\n",
    "                start = i\n",
    "            \n",
    "            elif blocks[i-1] == block_height and blocks[i] == 0:\n",
    "                end = i-1\n",
    "\n",
    "                if end-start>int(0.08*self.fs):\n",
    "                    detection = np.argmax(filtered_ecg[start:end+1])+start\n",
    "                    if QRS:\n",
    "                        if detection-QRS[-1]>int(0.3*self.fs):\n",
    "                            QRS.append(detection)\n",
    "                    else:\n",
    "                        QRS.append(detection)\n",
    "\n",
    "        return QRS   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a185cba",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pathlib\n",
    "from ecgdetectors import Detectors\n",
    "import sys\n",
    "\n",
    "\n",
    "ecg12=r\"E:\\RUMSHA\\National University of Sciences & Technology\\DAL Research - Rumsha Fatima\\Data in excel\\XLSX Files\\Denoised.csv\"\n",
    "unfiltered_ecg_dat = pd.read_csv(ecg12) \n",
    "unfiltered_ecg = unfiltered_ecg_dat.iloc[:5000, 0]\n",
    "fs = 257\n",
    "\n",
    "detectors = Detectors(fs)\n",
    "\n",
    "# selected detector by the user (default is the two average one)\n",
    "seldet = -1\n",
    "\n",
    "if seldet < 0:\n",
    "    # default detector\n",
    "    r_peaks = detectors.two_average_detector(unfiltered_ecg)\n",
    "else:\n",
    "    # We use the input argument to select a detector\n",
    "    r_peaks = detectors.get_detector_list()[seldet][1](unfiltered_ecg)\n",
    "\n",
    "# If you want to always use the same det then directly call it:\n",
    "#r_peaks = detectors.two_average_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.swt_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.engzee_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.christov_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.hamilton_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)\n",
    "\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c03447a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.swt_detector(unfiltered_ecg)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23a321ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.engzee_detector(unfiltered_ecg)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38db46de",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.christov_detector(unfiltered_ecg)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1cec593",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.hamilton_detector(unfiltered_ecg)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df357667",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecg)\n",
    "plt.plot(r_peaks, unfiltered_ecg[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a47a66a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "ecgRaw=r\"E:\\RUMSHA\\National University of Sciences & Technology\\DAL Research - Rumsha Fatima\\Data in excel\\XLSX Files\\I0002.xlsx\"\n",
    "\n",
    "unfiltered_ecg_dat1 = pd.read_excel(ecgRaw) \n",
    "unfiltered_ecgraw = unfiltered_ecg_dat1.iloc[:5000, 0]\n",
    "fs = 257\n",
    "\n",
    "detectors = Detectors(fs)\n",
    "\n",
    "# selected detector by the user (default is the two average one)\n",
    "seldet = -1\n",
    "\n",
    "if seldet < 0:\n",
    "    # default detector\n",
    "    r_peaks = detectors.two_average_detector(unfiltered_ecgraw)\n",
    "else:\n",
    "    # We use the input argument to select a detector\n",
    "    r_peaks = detectors.get_detector_list()[seldet][1](unfiltered_ecgraw)\n",
    "\n",
    "# If you want to always use the same det then directly call it:\n",
    "#r_peaks = detectors.two_average_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.swt_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.engzee_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.christov_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.hamilton_detector(unfiltered_ecg)\n",
    "#r_peaks = detectors.pan_tompkins_detector(unfiltered_ecg)\n",
    "\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69755ec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.swt_detector(unfiltered_ecgraw)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38436b03",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.engzee_detector(unfiltered_ecgraw)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "328660f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.christov_detector(unfiltered_ecgraw)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25eeae91",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.hamilton_detector(unfiltered_ecgraw)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2495e56d",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_peaks = detectors.pan_tompkins_detector(unfiltered_ecgraw)\n",
    "plt.figure()\n",
    "plt.plot(unfiltered_ecgraw)\n",
    "plt.plot(r_peaks, unfiltered_ecgraw[r_peaks], 'ro')\n",
    "plt.title(\"Detected R peaks\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab5a3106",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}