Complete - User path.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from datetime import *\n",
    "import datetime \n",
    "from pytz import timezone\n",
    "import os\n",
    "import sys\n",
    "import json\n",
    "import rowingdata \n",
    "import mne\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## COMMON"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def processed_output(user_input, watch_choice, readcsv,\n",
    "                    process_df,get_filenames, preprocess_empatica, add_time_empatica, output):    \n",
    "    watch_choice = watch_choice.lower()\n",
    "    if 'apple' in watch_choice:\n",
    "        apple(readcsv, user_input, process_df, watch_choice)\n",
    "    elif 'fitbit' in watch_choice:\n",
    "        fitbit(readcsv, user_input, process_df, output, watch_choice)\n",
    "    elif 'garmin' in watch_choice:\n",
    "        garmin(user_input, process_df, output, watch_choice)\n",
    "    elif 'miband' in watch_choice:\n",
    "        miband(user_input, process_df, output, watch_choice)\n",
    "    elif 'ecg' in watch_choice:\n",
    "        ecg(user_input, process_df, output, watch_choice)\n",
    "    elif 'biovotion' in watch_choice:\n",
    "        device_id = input(\"Enter Device ID: \")\n",
    "        biovotion(user_input, device_id, get_filenames, output, watch_choice)\n",
    "    elif 'empatica' in watch_choice:\n",
    "        empatica(user_input, get_filenames, preprocess_empatica, add_time_empatica, output, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readcsv(user_input):\n",
    "    if 'apple' in watch_choice:\n",
    "        df = pd.read_csv(user_input, header = None)\n",
    "    else:\n",
    "        df = pd.read_csv(user_input)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apple(readcsv, user_input, process_df, watch_choice):\n",
    "    \n",
    "    def main(df, watch_choice):\n",
    "        dictdf, df = dict_df(df)\n",
    "        start_time = dictdf['Workout date'][0]\n",
    "        start_time = datetime.datetime.strptime(start_time, ' %Y-%m-%d %H:%M:%S ')\n",
    "        df = pre_process_apple(df)\n",
    "        df = process_df(df, watch_choice)\n",
    "        df = add_time(df, start_time)\n",
    "        return dictdf, df\n",
    "\n",
    "    def dict_df(df):\n",
    "        for i in range(0,len(df)):\n",
    "            in_strip = df[df[0].str.contains(\"Time\")].index[0]\n",
    "            dictdf = df.loc[:(in_strip-1), :]\n",
    "            dictdf = dictdf.set_index(0).T.to_dict('list')\n",
    "            df = df.loc[in_strip:, :]\n",
    "            return dictdf, df\n",
    "    \n",
    "    def pre_process_apple(df):\n",
    "        df = df.reset_index()\n",
    "        df = df.drop('index', axis = 1)\n",
    "        new_header = df.iloc[0]\n",
    "        df = df[1:]\n",
    "        df.columns = new_header\n",
    "        return df\n",
    "    \n",
    "    def add_time(df, start_time):\n",
    "        delta = []\n",
    "        df['Actual_time'] = 'NaN'\n",
    "        for i in range(len(df)):\n",
    "            df.iloc[i]['Time_(seconds)'] = df.iloc[i]['Time_(seconds)'].replace(\" \", \"\")\n",
    "            delta_sec = float(df.iloc[i]['Time_(seconds)'])\n",
    "            delta_time = timedelta(seconds = delta_sec)\n",
    "            delta.append(delta_time)\n",
    "            df['Actual_time'].iloc[i] = start_time + delta[i]\n",
    "        return df\n",
    "    \n",
    "    def rename_cols(df):\n",
    "        df = df.rename(columns ={'Time_(seconds)' : 'Elapse_time_(sec)'})\n",
    "        return df\n",
    "    \n",
    "    def output_dict(dictdf,df, no_patient, watch_choice):\n",
    "        names = []\n",
    "        for i in range(no_patient):\n",
    "            pt_no = \"Patient_\" + str(i+1)\n",
    "            names.append(pt_no)\n",
    "        for j in range(no_patient):\n",
    "            df.to_csv(names[j-1] + '_df_apple.csv')\n",
    "            out_file = open(names[j-1]+'_dict_apple.json', \"w\")\n",
    "            json.dump(dictdf, out_file)\n",
    "            out_file.close()\n",
    "    \n",
    "    no_patient = 1\n",
    "    apple_df = readcsv(user_input)\n",
    "    dictdf, df = main(apple_df, watch_choice)\n",
    "    output_dict(dictdf, df,no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitbit(readcsv, user_input, process_df, output, watch_choice):\n",
    "    \n",
    "    def main(df, watch_choice):\n",
    "        df = process_df(df, watch_choice)\n",
    "        start_time = df.iloc[0][0]\n",
    "        df = add_time(df, start_time)\n",
    "        df = rename_cols(df)\n",
    "        return df\n",
    "    \n",
    "    def add_time(df, start_time):\n",
    "        df['Elapsed_time_(sec)'] = 'NaN'\n",
    "        start_time = datetime.datetime.strptime(df['Time'][0], '%H:%M:%S')\n",
    "        for i in range(len(df)):\n",
    "            df['Elapsed_time_(sec)'].iloc[i] = (datetime.datetime.strptime(fitbit_df.iloc[i][0], '%H:%M:%S')-start_time).total_seconds()\n",
    "        return df\n",
    "    \n",
    "    def rename_cols(df):\n",
    "        df = df.rename(columns ={'Time' : 'Actual_time', 'Heart_Rate' : 'Rate_(beats_per_minute)'})\n",
    "        return df\n",
    "    \n",
    "    no_patient = 1\n",
    "    print(user_input)\n",
    "    fitbit_df = readcsv(user_input)\n",
    "    df = main(fitbit_df, watch_choice)\n",
    "    output(df, no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def garmin(user_input, process_df, output, watch_choice):\n",
    "    \n",
    "    garmin_df = rowingdata.TCXParser(user_input)\n",
    "    garmin_df.write_csv(\"garmin_df.csv\")\n",
    "    garmin_df = pd.read_csv('./garmin_df.csv')\n",
    "    \n",
    "    def main(df, watch_choice):\n",
    "        df = process_df(df, watch_choice)\n",
    "        df = add_time(df)\n",
    "        df = rename_cols(df)\n",
    "        df = df.drop('index', axis = 1)\n",
    "        return df\n",
    "    \n",
    "    def add_time(df):\n",
    "        df['Actual_time'] = df['TimeStamp_(sec)'].apply(lambda a : datetime.datetime.utcfromtimestamp(a).strftime('%Y-%m-%d %H:%M:%S'))\n",
    "        start_time = df['Actual_time'][0]\n",
    "        df['Elapsed_time_(sec)'] = 'NaN'\n",
    "        for i in range(len(df)):\n",
    "            df['Elapsed_time_(sec)'].iloc[i] = (datetime.datetime.strptime(df.iloc[i][13],'%Y-%m-%d %H:%M:%S')- datetime.datetime.strptime(start_time,'%Y-%m-%d %H:%M:%S')).total_seconds()\n",
    "        return df\n",
    "    \n",
    "    def rename_cols(df):\n",
    "        df = df.rename(columns ={'Hrcur_(bpm)' : 'Rate_(beats_per_minute)', \n",
    "                                 'Distancemeters' : 'Distance_(meters)',\n",
    "                                 'Strokedistance_(meters)' : 'Stroke_distance_(meters)',\n",
    "                                 'Stroke500mpace_(sec/500m)' : 'Stroke_500m_pace_(sec/500m)',\n",
    "                                })\n",
    "        return df\n",
    "    \n",
    "    no_patient = 1\n",
    "    df = main(garmin_df, watch_choice)\n",
    "    output(df, no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def miband(user_input, process_df, output, watch_choice):\n",
    "    mi_df = pd.read_excel(user_input)\n",
    "    \n",
    "    def main(df, watch_choice):\n",
    "        df = process_df(df, watch_choice)\n",
    "        df = add_time(df)\n",
    "        df = rename_cols(df)\n",
    "        return df\n",
    "    \n",
    "    def add_time(df):\n",
    "        df['Actual_time'] = pd.to_datetime(df['Date'] + ' ' + df['Time'])\n",
    "        start_time = df['Actual_time'][0]\n",
    "        df['Elapsed_time_(sec)'] = 'NaN'\n",
    "        for i in range(len(df)):\n",
    "            df['Elapsed_time_(sec)'].iloc[i] = ((df.iloc[i][5])-start_time).total_seconds()\n",
    "        return df\n",
    "    \n",
    "    def rename_cols(df):\n",
    "        df = df.rename(columns ={'Heart_rate' : 'Rate_(beats_per_minute)'})\n",
    "        return df\n",
    "    \n",
    "    no_patient = 1\n",
    "    df = main(mi_df, watch_choice)\n",
    "    output(df, no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ecg(user_input, process_df, output, watch_choice):\n",
    "    data = mne.io.read_raw_edf(user_input)\n",
    "    raw_data = data.get_data()\n",
    "    info = data.info\n",
    "    channels = data.ch_names\n",
    "    ECG_array = raw_data[0]\n",
    "    \n",
    "    def get_data(data):\n",
    "        header = ','.join(data.ch_names)\n",
    "        np.savetxt('ECG.csv', data.get_data().T, delimiter=',', header=header)\n",
    "        ECG_df = pd.read_csv(\"./ECG.csv\")\n",
    "        info = data.info\n",
    "        return ECG_df, info\n",
    "    \n",
    "    def main(info, df, watch_choice):\n",
    "        df = pre_process_ECG(df)\n",
    "        df = process_df(df, watch_choice)\n",
    "        df = add_time(df, info)\n",
    "        df = rename_cols(df)\n",
    "        return df\n",
    "    \n",
    "    def pre_process_ECG(df):\n",
    "        df = df.drop('Marker', axis = 1)\n",
    "        df = df.drop('HRV', axis = 1)\n",
    "        return df\n",
    "    \n",
    "    def add_time(df, info):\n",
    "        start_time = info['meas_date']\n",
    "        sfreq = info['sfreq']\n",
    "        delta_sec = 1/sfreq\n",
    "        delta_sec = datetime.timedelta(seconds = delta_sec)\n",
    "        ECG_time = [start_time]\n",
    "        df['Elapsed_time_(sec)'] = np.nan\n",
    "        for i in range(1,len(df)):\n",
    "            time = ECG_time[i-1] + delta_sec\n",
    "            ECG_time.append(time)\n",
    "        df['Actual_time'] = ECG_time\n",
    "        df['Elapsed_time_(sec)'] = df['Actual_time'].apply(lambda x : (x-start_time).total_seconds())\n",
    "        return df\n",
    "    \n",
    "    def rename_cols(df):\n",
    "        df = df.rename(columns ={'#_ecg' : 'ECG_(mV)'})\n",
    "        return df\n",
    "    \n",
    "    no_patient = 1\n",
    "    df, info = get_data(data)\n",
    "    df = main(info, df, watch_choice)\n",
    "    output(df, no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def biovotion(user_input, device_id, get_filenames, output, watch_choice):\n",
    "    \n",
    "    def main(user_input, device_id, watch_choice):\n",
    "        filenames = get_filenames(user_input)\n",
    "        colnames = extract_names(device_id, filenames)\n",
    "        dataframes, commoncols = read_data(filenames, colnames)\n",
    "        df = create_df_final(dataframes, commoncols)\n",
    "        df = add_time(df)\n",
    "        return df\n",
    "    \n",
    "#     def get_filenames(user_input):\n",
    "#         files = os.listdir(user_input)    \n",
    "#         filenames = list(filter(lambda f: f.endswith('.csv'), files))\n",
    "#         return filenames\n",
    "\n",
    "    def extract_names(device_id, filenames):\n",
    "        colnames = []\n",
    "        for i in range(1,len(filenames)):\n",
    "            if str.find(filenames[i],'bop') != -1:    \n",
    "                if str.find(filenames[i],'VitalSign') == -1:\n",
    "                    match = re.search('515_(.*)_' + str(device_id), filenames[i])\n",
    "                    name = match.group(0).split('_')[1]\n",
    "                    colnames.append(name)\n",
    "                else:\n",
    "                    match = re.search('n_(.*)_' + str(device_id), filenames[i])\n",
    "                    name = match.group(0).split('_')[1]\n",
    "                    colnames.append(name)\n",
    "            else:\n",
    "                return\n",
    "        return colnames\n",
    "    \n",
    "    def read_data(filenames, colnames):\n",
    "        dataframes = []\n",
    "        for filename in filenames:\n",
    "            if str.find(filename,'bop') != -1:\n",
    "                dataframe = pd.read_csv(user_input+'\\\\'+ filename)\n",
    "                common_cols = pd.DataFrame(dataframe.iloc[:,:4])\n",
    "                dataframe = dataframe[dataframe.columns[~dataframe.columns.str.contains('Device Instance ID')]]\n",
    "                dataframe = dataframe[dataframe.columns[~dataframe.columns.str.contains('Counter')]]\n",
    "                dataframe = dataframe[dataframe.columns[~dataframe.columns.str.contains('Timestamp')]]\n",
    "                dataframe = dataframe[dataframe.columns[~dataframe.columns.str.contains('Timezone')]]\n",
    "                dataframes.append(dataframe)\n",
    "        for i in range(len(colnames)):\n",
    "            dataframes[i].columns = [str(col) + \"_\" + str(colnames[i]) for col in dataframes[i].columns]\n",
    "        return dataframes, common_cols\n",
    "    \n",
    "    def create_df_final(dataframes, commoncols):\n",
    "        df_concat = pd.concat(dataframes, axis = 1, sort = 'False')\n",
    "        df_bio = pd.concat([df_concat, commoncols], axis = 1, sort = 'False')\n",
    "        return df_bio\n",
    "    \n",
    "    def add_time(df):\n",
    "        df['Actual_time'] = df['Timestamp'].apply(lambda a : datetime.datetime.utcfromtimestamp(a).strftime('%Y-%m-%d %H:%M:%S'))\n",
    "        start_time = df['Actual_time'][0]\n",
    "        df['Elapsed_time_(sec)'] = 'NaN'\n",
    "        for i in range(len(df)):\n",
    "            df['Elapsed_time_(sec)'].iloc[i] = (datetime.datetime.strptime(df['Actual_time'][i],'%Y-%m-%d %H:%M:%S')- datetime.datetime.strptime(start_time,'%Y-%m-%d %H:%M:%S')).total_seconds()\n",
    "        return df\n",
    "    \n",
    "    no_patient = 1\n",
    "    df = main(user_input, device_id, watch_choice)\n",
    "    output(df, no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def empatica(user_input, get_filenames, preprocess_empatica, add_time_empatica, output, watch_choice):\n",
    "    \n",
    "    def read_data(user_input, filenames, preprocess_empatica, add_time_empatica):\n",
    "        dataframes = []\n",
    "        for file in filenames:\n",
    "            dataframe = pd.read_csv(user_input + '\\\\' + str(file), header = None)\n",
    "            file = file.split(\".\")[0]\n",
    "            file = file.upper()\n",
    "\n",
    "            if 'ACC' in file:\n",
    "\n",
    "                dataframe, time, freq = preprocess_empatica(dataframe)\n",
    "                dataframe = dataframe.rename(columns = {0 : 'x_acc', 1: 'y_acc', 2: 'z_acc'})\n",
    "\n",
    "                dataframe['Actual_time_x'] = np.nan\n",
    "                dataframe['Actual_time_y'] = np.nan\n",
    "                dataframe['Actual_time_z'] = np.nan\n",
    "\n",
    "                dataframe['Timestamp_x'] = time[0]\n",
    "                dataframe['Timestamp_y'] = time[1]\n",
    "                dataframe['Timestamp_z'] = time[2]\n",
    "\n",
    "                delta_x = 1/freq[0]\n",
    "                delta_x = datetime.timedelta(seconds = delta_x)\n",
    "                delta_y = 1/freq[1]\n",
    "                delta_y = datetime.timedelta(seconds = delta_y)\n",
    "                delta_z = 1/freq[2]\n",
    "                delta_z = datetime.timedelta(seconds = delta_z)   \n",
    "\n",
    "                start_timex = datetime.datetime.utcfromtimestamp(time[0]).strftime('%Y-%m-%d %H:%M:%S')\n",
    "                start_timex = datetime.datetime.strptime(start_timex, '%Y-%m-%d %H:%M:%S')\n",
    "                start_timey = datetime.datetime.utcfromtimestamp(time[1]).strftime('%Y-%m-%d %H:%M:%S')\n",
    "                start_timey = datetime.datetime.strptime(start_timey, '%Y-%m-%d %H:%M:%S')\n",
    "                start_timez = datetime.datetime.utcfromtimestamp(time[2]).strftime('%Y-%m-%d %H:%M:%S')\n",
    "                start_timez = datetime.datetime.strptime(start_timez, '%Y-%m-%d %H:%M:%S')\n",
    "\n",
    "                accx_time = [start_timex]\n",
    "                accy_time = [start_timey]\n",
    "                accz_time = [start_timez]\n",
    "\n",
    "                for i in range(1, len(dataframe['x_acc'])):\n",
    "                    time_x = accx_time[i-1] + delta_x\n",
    "                    accx_time.append(time_x)\n",
    "                dataframe['Actual_time_x'] = accx_time\n",
    "                dataframe['Elapsed_timex_(sec)'] = dataframe['Actual_time_x'].apply(lambda x : (x-start_timex).total_seconds())\n",
    "\n",
    "                for i in range(1, len(dataframe['y_acc'])):\n",
    "                    time_y = accy_time[i-1] + delta_y\n",
    "                    accy_time.append(time_y)\n",
    "                dataframe['Actual_time_y'] = accy_time\n",
    "                dataframe['Elapsed_timey_(sec)'] = dataframe['Actual_time_x'].apply(lambda x : (x-start_timex).total_seconds())\n",
    "\n",
    "                for i in range(1, len(dataframe['z_acc'])):\n",
    "                    time_z = accz_time[i-1] + delta_z\n",
    "                    accz_time.append(time_z)\n",
    "                dataframe['Actual_time_z'] = accz_time\n",
    "                dataframe['Elapsed_timez_(sec)'] = dataframe['Actual_time_x'].apply(lambda x : (x-start_timex).total_seconds())\n",
    "\n",
    "            if 'BVP' in file:\n",
    "                dataframe, time, freq = preprocess_empatica(dataframe)\n",
    "                dataframe = dataframe.rename(columns = {0 : 'BVP'})\n",
    "                dataframe = add_time_empatica(dataframe, time, freq, 'BVP')            \n",
    "\n",
    "            if 'EDA' in file:\n",
    "                dataframe, time, freq = preprocess_empatica(dataframe)\n",
    "                dataframe = dataframe.rename(columns = {0 : 'EDA(microsiemens)'})\n",
    "                dataframe = add_time_empatica(dataframe, time, freq, 'EDA')\n",
    "\n",
    "            if 'HR' in file:\n",
    "                dataframe, time, freq = preprocess_empatica(dataframe)\n",
    "                dataframe = dataframe.rename(columns = {0 : 'HR'})\n",
    "                dataframe = add_time_empatica(dataframe, time, freq, 'HR')\n",
    "\n",
    "            if 'IBI' in file:\n",
    "                ibi_time = dataframe.iloc[0][0]\n",
    "                dataframe = dataframe.iloc[1:]\n",
    "                dataframe = dataframe.rename(columns = {0 : 'Time(sec)', 1: 'IBI'})\n",
    "                dataframe = dataframe.reset_index()\n",
    "                dataframe = dataframe.drop('index', axis = 1)\n",
    "\n",
    "            if 'TEMP' in file:\n",
    "                dataframe, time, freq = preprocess_empatica(dataframe)\n",
    "                dataframe = dataframe.rename(columns = {0 : 'Temp(celsius)'})\n",
    "                dataframe = add_time_empatica(dataframe, time, freq, 'Temp')\n",
    "\n",
    "            if 'TAGS' in file:\n",
    "                dataframe = dataframe.rename(columns = {0 : 'Timestamp_buttonpress'})\n",
    "                dataframe['Time'] = dataframe['Timestamp_buttonpress'].apply(lambda a : datetime.datetime.utcfromtimestamp(a).strftime('%Y-%m-%d %H:%M:%S'))\n",
    "            dataframes.append(dataframe)\n",
    "        return dataframes\n",
    "\n",
    "    def all_dfs(dataframes):\n",
    "        df = pd.concat(dataframes, axis = 1)\n",
    "        return df\n",
    "\n",
    "    def main(user_input, preprocess_empatica, add_time_empatica, all_dfs, watch_choice):\n",
    "        filenames = get_filenames(user_input)\n",
    "        dataframes = read_data(user_input, filenames, preprocess_empatica, add_time_empatica)\n",
    "        df = all_dfs(dataframes)\n",
    "        df['Watch_type'] = watch_choice\n",
    "        return df \n",
    "    \n",
    "    no_patient = 1\n",
    "    df = main(user_input, preprocess_empatica, add_time_empatica, all_dfs, watch_choice)\n",
    "    output(df,no_patient, watch_choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Common\n",
    "\"\"\"\n",
    "def process_df(df, watch_choice):\n",
    "    df.columns = df.columns.str.lstrip(' ')\n",
    "    df.columns = df.columns.str.replace(' ','_')\n",
    "    df['Watch_type'] = watch_choice\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def output(df, no_patient, watch_choice):\n",
    "    names = []\n",
    "    for i in range(no_patient):\n",
    "        pt_no = \"Patient_\" + str(i+1)\n",
    "        names.append(pt_no)\n",
    "    for j in range(no_patient):\n",
    "        df.to_csv(names[j-1] + '_df_output_' + str(watch_choice) + '.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_filenames(user_input):\n",
    "    newnames = []\n",
    "    files = os.listdir(user_input)    \n",
    "    filenames = list(filter(lambda f: f.endswith('.csv'), files))\n",
    "    return filenames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_empatica(dataframe):\n",
    "    time = dataframe.values[0]\n",
    "    freq = dataframe.values[1]\n",
    "    dataframe = dataframe.iloc[2:]\n",
    "    dataframe = dataframe.reset_index()\n",
    "    dataframe = dataframe.drop('index', axis = 1)\n",
    "    return dataframe, time, freq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_time_empatica(dataframe, time, freq, filename):\n",
    "    dataframe['Timestamp' + '_' + str(filename)] = time[0]\n",
    "    delta = 1/freq[0]\n",
    "    delta = datetime.timedelta(seconds = delta)\n",
    "    start_time = datetime.datetime.utcfromtimestamp(time[0]).strftime('%Y-%m-%d %H:%M:%S')\n",
    "    start_time = datetime.datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S')\n",
    "    actual_time = [start_time]\n",
    "    for i in range(1, len(dataframe)):\n",
    "        time = actual_time[i-1] + delta\n",
    "        actual_time.append(time)\n",
    "    dataframe['Actual_time'+ '_' + str(filename)] = actual_time\n",
    "    dataframe['Elapsed_time_(sec)'+ '_' + str(filename)] = dataframe['Actual_time'+ '_' + str(filename)].apply(lambda x : (x-start_time).total_seconds())\n",
    "    return dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Biovotion and Empatica, please enter the path of the folder where all the files are stored, for the rest enter path of the file\n",
      "Choose the type of watch: empatica\n",
      "Enter the path of the folder of raw files: C:\\Users\\GEETIKA\\Documents\\Geetika\\GRE\\Universities- Applied\\Duke\\Courses\\LAB\\Independent Study\\DBDP Project\\Empatica\\Empatica\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "To process multiple files at once, path of the folder where the files are stored\n",
    "\"\"\"\n",
    "\n",
    "print(\"For Biovotion and Empatica, please enter the path of the folder where all the files are stored, for the rest enter path of the file\")\n",
    "watch_choice = input(\"Choose the type of watch: \")\n",
    "user_input = input(\"Enter the path of the folder of raw files: \")\n",
    "processed_output(user_input, watch_choice, readcsv, process_df,get_filenames, preprocess_empatica, add_time_empatica, output)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}