ProcEEGingV.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desarrollo\n",
    "## Avances\n",
    "- Cargadas las señales en formato MNE y preprocesadas, falta revisar si funciona correctamente\n",
    "\n",
    "## Conclusiones\n",
    "- Hay que ver como cargar el archivo de montage para MNE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LIBRERÍAS\n",
    "\n",
    "#Librerías de Sistema\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "import shutil #Shutil se utiliza para hacer copia de archivos\n",
    "\n",
    "#Librerías de Manejo de Datos\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy.signal as sgn\n",
    "import scipy.stats as sts\n",
    "from numbers import Number #usando isinstance(X, Number) puedo detectar si X es una variable numerica de cualquier tipo\n",
    "\n",
    "#Librerías de Interfaz\n",
    "from tkinter import filedialog\n",
    "from tkinter import *\n",
    "from tkinter import messagebox\n",
    "from tkinter import ttk\n",
    "\n",
    "#Librerías para EEG\n",
    "import mne\n",
    "\n",
    "#Librerías para Plotings\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import plotly.graph_objs as go\n",
    "import plotly.offline as py\n",
    "import plotly\n",
    "\n",
    "#Widgets de Jupyter\n",
    "from ipywidgets import interactive, HBox, VBox, widgets, interact, HTML\n",
    "\n",
    "py.init_notebook_mode(connected = True) #Estableciendo modo Offline para Plotly\n",
    "\n",
    "#Procesamiento\n",
    "from sklearn.decomposition import FastICA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables Globales "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Definir Layouts para Plotly\n",
    "\n",
    "#Layout para plot en tiempo\n",
    "time_layout = go.Layout(title = \"Will be changed in each plot\",\n",
    "                        xaxis = dict(title = 'Time [s]',\n",
    "                                     rangeslider = dict(visible = True,\n",
    "                                                        yaxis = dict(rangemode = 'auto'\n",
    "                                                                    )\n",
    "                                                        )\n",
    "                                    ),\n",
    "                        yaxis = dict(title = 'Amplitude [uV]',\n",
    "                                     fixedrange = False)\n",
    "                       )\n",
    "\n",
    "#Layout para plot en frecuencia\n",
    "freq_layout = go.Layout(title = \"Will be changed in each plot\",\n",
    "                        xaxis = dict(title = 'Frequecy [Hz]',\n",
    "                                     range = [0, 60],\n",
    "                                     rangeslider = dict(visible = True,\n",
    "                                                        yaxis = dict(rangemode = 'auto'\n",
    "                                                                    )\n",
    "                                                        )\n",
    "                                    ),\n",
    "                        yaxis = dict(title = 'Amplitude [uV]',\n",
    "                                     fixedrange = False)\n",
    "                       )\n",
    "\n",
    "#Layout para plot de espectrograma\n",
    "spec_layout = go.Layout(title = \"Will be changed in each plot\",\n",
    "                        xaxis = dict(title = 'Time [s]'\n",
    "                                    ),\n",
    "                        yaxis = dict(title = 'Frequency [Hz]',\n",
    "                                     range = [0, 60],\n",
    "                                     fixedrange = False)\n",
    "                       )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función utilizada para obtener los índices de elementos de una lista\n",
    "\n",
    "get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]\n",
    "\n",
    "#This would work like : X = [\"Mario\", \"Luigi\", \"Yoshi\", \"Mario\"]\n",
    "#print(get_indexes(\"Mario\", X)) -> Out: [0,3]\n",
    "#print(get_indexes(\"Luigi\", X)) -> Out: [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Función utilizada para generar una ventana que haga una pregunta \"Sí/No\"\n",
    "\n",
    "def yn_quest(quest):\n",
    "    yn_quest_win = Tk()\n",
    "    \n",
    "    answer = messagebox.askquestion(\"QUESTION:\",quest)\n",
    "    yn_quest_win.destroy()\n",
    "    \n",
    "    yn_quest_win.mainloop()\n",
    "    \n",
    "    return answer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función usada para cargar la señal\n",
    "\n",
    "def load_signal():   \n",
    "    nom_s = input(\"Which will be the signal name? \") #Pedimos el nombre de la señal\n",
    "\n",
    "    while True:\n",
    "        search_signal_win = Tk()                                             #Crea el ambiente de interfaz TK\n",
    "        xs = filedialog.askopenfilename(title = \"Select Signal File :\",          #Dice que va a sacar la variable xs como el filename de un archivo\n",
    "                                        filetypes = ((\"Documento de texto\",\"*.txt\"),\n",
    "                                                     (\"Excel (post 2003)\", \".xlsx\"),\n",
    "                                                     (\"Excel (prev 2003)\", \".xls\"),\n",
    "                                                     (\"Todos los archivos\",\"*.*\")\n",
    "                                                    )                        #Con titulo de ventana y opciones de abrir archivos de ese tipo\n",
    "                                       )\n",
    "\n",
    "        search_signal_win.destroy()   #Destuimos el ambiente de Tk luego de utilizada la ventana\n",
    "        search_signal_win.mainloop()  #Establecemos que la ventana quede abierta hasta que se de una respuesta\n",
    "\n",
    "        print (xs)\n",
    "\n",
    "        #Detección de tipo de archivo, en este momento el programa sólo puede leer archivos txt y excel\n",
    "        if \".txt\" in xs:\n",
    "            opt = yn_quest('Is it a file exported by the OpenBCI Software?') #Si es txt, puede haber sido exportado por OpenBCI o no\n",
    "            if opt == 'Yes' or opt == 'yes':\n",
    "                XS, col_names, col_types, usecols, skiprows, sep = openbci_topd(xs)\n",
    "            else:\n",
    "                XS, col_names, col_types, usecols, skiprows, sep = csv_topd(xs)\n",
    "            print(\"Signal Loaded. TXT format.\")\n",
    "            break\n",
    "        \n",
    "        elif \".xlsx\" in xs or \".xls\" in xs:\n",
    "            XS, col_names, col_types, usecols, skiprows, sep = excel_topd(xs, interval = False)\n",
    "            print(\"Signal Loaded. Excel format.\") #Esto sería reemplazado por la función \"leer txt\" que tomaría la dirección y parámetros como Cantidad de columnas, Nombres de columnas, etc (o se puede probar con la direccion sola y si no funciona pedir parametros)\n",
    "            break\n",
    "\n",
    "        #Si la persona presiona cancelar, en xs se carga un \"\", por lo que usamos esa condición     \n",
    "        elif xs == \"\":\n",
    "            print(\"Cancelled Operation\")\n",
    "            break  #Al presionar cancelar salimos del loop que abre la ventana de seleccion de archivo\n",
    "\n",
    "        #Si se selecciona un archivo que no sea txt o excel, se aclara que el formato no era correcto, pero no sale del loop\n",
    "        else:\n",
    "            print(\"Wrong File Format. Try Again.\")\n",
    "    \n",
    "    return XS, xs, nom_s, col_names, col_types, usecols, skiprows, sep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export():\n",
    "\n",
    "    folder_name = signalname\n",
    "    n = 1\n",
    "    \n",
    "    while True:\n",
    "        try:\n",
    "            os.mkdir(os.getcwd() + \"/\" + folder_name)\n",
    "        except FileExistsError:\n",
    "            n += 1\n",
    "            print(\"Directory \" + folder_name + \" already exists.\")\n",
    "            folder_name = signalname + \" Run \" + str(n)\n",
    "        else:\n",
    "            print(\"Created directory: \" + folder_name)\n",
    "            folder_dir = os.getcwd() + \"\\\\\" + folder_name\n",
    "            break\n",
    "    \n",
    "    _ = shutil.copy2(signal_filepath, folder_dir)\n",
    "    \n",
    "    return folder_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que transforma un txt (CSV) en DataFrame (tabla) de Pandas\n",
    "\n",
    "def csv_topd(truepath):\n",
    "    \n",
    "    #Creamos un loop que pruebe cargar el archivo CSV con una cierta configuración, y sino solicite los datos nuevamente\n",
    "    while True:\n",
    "        col_names, col_types, usecols, skiprows, sep = col_rows_sep()         #Función que solicita al usuario ingresar los datos necesarios para cargar el archivo CSV\n",
    "        \n",
    "        try:\n",
    "            X = pd.read_csv(truepath,  sep=sep, skiprows=skiprows, names=col_names, usecols=range(usecols), lineterminator = '\\n')\n",
    "        \n",
    "        #Testeamos que los valores ingresados en las columnas de tipo \"Channel\", \"Accel\" y \"Tag\" (que son las que vamos a usar) sean numericas, en realidad solo esta testeando que el primer valor de dicahs columnas sea numerica, tenemos que ver si podemos mejorarlo\n",
    "            for j in range(len(col_types)):\n",
    "                if col_types[j] == \"Channel\" or col_types[j] == \"Tag\" or col_types[j] == \"Accel\":\n",
    "                    assert isinstance(X.values[0,j], Number) and pd.notnull(X.values[0,j]) == True\n",
    " \n",
    "        \n",
    "        except AssertionError:\n",
    "            print(\"\\n\\nThere's a non-numerical value in a column corresponding to Channel, Accel, or Tag, which should be numerical\")\n",
    "        \n",
    "        except:\n",
    "            print('\\n\\nThe input parameters do not match. Please enter them again.\\n\\n')\n",
    "            \n",
    "        else:\n",
    "            save_opt = input('Do you wish to save this configuration?: ') #Todavía no lo implementamos, está de recordatorio, sería poder guardar la configuración de parámetros de carga de un archivo para poder usarla luego\n",
    "            break\n",
    "    \n",
    "    X.col_names = col_names #Esto sería medio de gusto si ahora col_names y col_types son globales, pero quedó.\n",
    "    X.col_types = col_types\n",
    "    \n",
    "    return X, col_names, col_types, usecols, skiprows, sep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que transforma un txt (CSV) exportado por OpenBCI en DataFrame (tabla) de Pandas\n",
    "\n",
    "def openbci_topd(truepath):\n",
    "        \n",
    "    selecc_predet = yn_quest('Will you use the default OpenBCI configuration?') #Esta opción setea los parámetros de carga a los que usa OpenBCI predeterminadamente, que se ven abajo\n",
    "    \n",
    "    if selecc_predet == 'No' or selecc_predet == 'no': #si decide que no, el usuario ingresa los parámetros a utilizar para la carga\n",
    "        col_names, col_types, usecols, skiprows, sep = col_rows_sep()\n",
    "        \n",
    "    elif selecc_predet == 'Yes' or selecc_predet == 'yes': #si decide que si, los parámetros utilizados son los siguientes\n",
    "        \n",
    "        sep = \",\"  #Coma como separador de columnas\n",
    "        col_names = ['Sample', 'Ch1', 'Ch2', 'Ch3', 'Ch4', 'x', 'y', 'z', 'Time', ' '] #Nombre de las columnas\n",
    "        col_types = ['Misc', 'Channel', 'Channel', 'Channel', 'Channel', 'Accel', 'Accel', 'Accel', 'Time', 'Misc'] #Tipo de valores que contiene cada columna\n",
    "        usecols = 10\n",
    "        skiprows = 6\n",
    "\n",
    "    while True:        \n",
    "                \n",
    "        try:\n",
    "            X = pd.read_csv(truepath,  sep=sep, skiprows=skiprows, names=col_names, usecols=range(usecols), lineterminator = '\\n')\n",
    "        \n",
    "        #Testeamos que los valores ingresados en las columnas de tipo \"Channel\", \"Accel\" y \"Tag\" (que son las que vamos a usar) sean numericas, en realidad solo esta testeando que el primer valor de dicahs columnas sea numerica, tenemos que ver si podemos mejorarlo\n",
    "            for j in range(len(col_types)):\n",
    "                if col_types[j] == \"Channel\" or col_types[j] == \"Tag\" or col_types[j] == \"Accel\":\n",
    "                    assert isinstance(X.values[0,j], Number) and pd.notnull(X.values[0,j]) == True\n",
    "        \n",
    "        except AssertionError:\n",
    "            \n",
    "            print(\"\\n\\nThere's a non-numerical value in a column corresponding to Channel, Accel, or Tag, which should be numerical\")\n",
    "            \n",
    "            col_names, col_types, usecols, skiprows, sep = col_rows_sep()         #Función que solicita al usuario ingresar los datos necesarios para cargar el archivo CSV\n",
    "                \n",
    "        except:\n",
    "            print('\\n\\nThe input parameters do not match. Please enter them again.\\n\\n')\n",
    "            \n",
    "            col_names, col_types, usecols, skiprows, sep = col_rows_sep()         #Función que solicita al usuario ingresar los datos necesarios para cargar el archivo CSV\n",
    "            \n",
    "        else:\n",
    "            if selecc_predet == 'No' or selecc_predet == 'no':\n",
    "                save_opt = input('Do you wish to save this configuration?: ') #Todavía no lo implementamos, está de recordatorio, sería poder guardar la configuración de parámetros de carga de un archivo para poder usarla luego\n",
    "            break \n",
    "    \n",
    "    return X, col_names, col_types, usecols, skiprows, sep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que transforma un Excel en DataFrame (tabla) de Pandas, dicho excel puede contener la señal o los datos de los intervalos\n",
    "\n",
    "def excel_topd(truepath, interval = True): #La segunda variable, interval, define si el arvhivo excel a leer es de intervalos o de señal\n",
    "    \n",
    "    while True:\n",
    "        #Si es un excel de intervalos, se pregunta si dicho excel tiene una columna de Endpoint o de duracion de los intervalos, y sino se solicita que el usuario ingrese un valor de duración general para todos los intervalos\n",
    "        if interval == True:\n",
    "            \n",
    "            header = 0\n",
    "            index_col = 0\n",
    "            usecols = 3\n",
    "            skiprows = 0\n",
    "            col_names = ['Number', 'Name', 'Startpoint']\n",
    "\n",
    "            endpoint_opt = yn_quest(\"Does it has an endpoint column?\")\n",
    "            if endpoint_opt == 'Yes' or endpoint_opt == 'yes':\n",
    "                col_names.append('Endpoint')\n",
    "                usecols = usecols + 1\n",
    "\n",
    "            else:\n",
    "                duration_opt = yn_quest(\"Does it has a duration column?\")\n",
    "                if duration_opt == 'Yes' or duration_opt == 'yes':\n",
    "                    col_names.append('Duration')\n",
    "                    usecols = usecols + 1\n",
    "                    \n",
    "        #Si no es un excel de intervalos se usa la función col_rows_sep para definir los parametros de carga\n",
    "        elif interval == False:\n",
    "            header = None\n",
    "            index_col = None\n",
    "            col_names, col_types, usecols, skiprows, sep = col_rows_sep()\n",
    "        \n",
    "        try:\n",
    "            X = pd.read_excel(truepath, usecols = range(usecols), skiprows = skiprows, names = col_names, header=header, index_col=index_col)\n",
    "            \n",
    "            #Testeamos que los valores ingresados en las columnas de tipo \"Channel\", \"Accel\" y \"Tag\" (que son las que vamos a usar) sean numericas, en realidad solo esta testeando que el primer valor de dicahs columnas sea numerica, tenemos que ver si podemos mejorarlo\n",
    "            if interval == False:\n",
    "                for j in range(len(col_types)):\n",
    "                    if col_types[j] == \"Channel\" or col_types[j] == \"Tag\" or col_types[j] == \"Accel\":\n",
    "                        assert isinstance(X.values[0,j], Number) and pd.notnull(X.values[0,j]) == True\n",
    "        \n",
    "        except AssertionError:\n",
    "            print(\"\\n\\nThere's a non-numerical value in a column corresponding to Channel, Accel, or Tag, which should be numerical\")\n",
    "        \n",
    "        except:\n",
    "            print('\\n\\nThe input parameters do not match. Please enter them again.\\n\\n')\n",
    "        \n",
    "        else:\n",
    "            break\n",
    "    \n",
    "    if interval == True:\n",
    "        return X\n",
    "    elif interval == False:\n",
    "        return X, col_names, col_types, usecols, skiprows, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def col_rows_sep():\n",
    "    \n",
    "    def accept_col(columnas, col_n, col_t, window):\n",
    "        window.destroy()\n",
    "                \n",
    "        col_names = []\n",
    "        col_types = []\n",
    "        \n",
    "        for i in range(columnas.get()): \n",
    "            col_names.append(col_n[i].get()) #El comando get permite obtener de una variable Tk a una variable numpy que se pueda leer numericamente\n",
    "            col_types.append(col_t[i].get())\n",
    "            \n",
    "        return col_names, col_types\n",
    "                            \n",
    "    def selec_pd (columnas): #Función llevada a cabo al presionar aceptar en la ventana selec_pd_win       \n",
    "        \n",
    "        #Primero levantamos una ventana para confirmar los valores seleccionados\n",
    "        conf = messagebox.askquestion(\"Confirm\",\"Will you select : \" + str(columnas.get()) + \" columns & \" + str(filas.get()) + \" rows?\")\n",
    "        if conf == \"yes\":\n",
    "                        \n",
    "            #Si se confirman los valores, se destruye la ventana selec_pd_win, y se abre una ventana para dar nombres y tipos a cada columna\n",
    "            selec_pd_win.destroy()\n",
    "            \n",
    "            col_names_win = Tk()\n",
    "            \n",
    "            col_params = []\n",
    "            col_n = []\n",
    "            col_t = []\n",
    "            col_names_win.title(\"Columns\")\n",
    "            col_names_win.label1 = Label(col_names_win, text = \"Name:\").place(x=30,y=20)\n",
    "            col_names_win.label2 = Label(col_names_win, text = \"Type:\").place(x=170,y=20)\n",
    "            \n",
    "            col_names_win.geometry(\"350x\"+str(40+columnas.get()*35))\n",
    "            for i in range(columnas.get()):\n",
    "                col_n.append(StringVar())\n",
    "                col_t.append(StringVar())\n",
    "                col_names_win.entry = Entry(col_names_win, textvariable=col_n[i]).place(x=30 , y=40+i*26)\n",
    "                col_names_win.spinbox = Spinbox(col_names_win, values = (\"Channel\", \"Misc\", \"Tag\", \"Time\", \"Accel\"), wrap =True, textvariable =col_t[i]).place(x=170 , y=40+i*26)\n",
    "            col_names_win.button1 = Button (col_names_win , text=\"Accept\", \n",
    "                                            command=lambda: col_params.append(accept_col(columnas, col_n, col_t, col_names_win))).place(x=100, y=40+26*columnas.get()) #command= imprimir)\n",
    "            col_names_win.mainloop()\n",
    "            \n",
    "            return col_params[0]\n",
    "        \n",
    "    selec_pd_win = Tk() #En este punto comienza la función, creando la ventana de interfaz\n",
    "    \n",
    "    col_params = []\n",
    "    \n",
    "    #Creamos variables tk para los valores de cantidad de columnas, filas y separador\n",
    "    columnas = IntVar()\n",
    "    filas = IntVar()\n",
    "    separador = StringVar()\n",
    "    \n",
    "    #Damos las características de la ventana, titulo, tamaño y componentes(botones, espacios de input, etc)\n",
    "    selec_pd_win.title(\"Set parameters for Pandas\" ) \n",
    "    selec_pd_win.geometry(\"350x200\")\n",
    "\n",
    "    selec_pd_win.label1 = Label(selec_pd_win , text= \"Rows to Skip:\").place(x=30,y=20)\n",
    "    selec_pd_win.entry1 = Entry(selec_pd_win, textvariable=filas).place(x=170 , y=20)\n",
    "\n",
    "    selec_pd_win.label2 = Label(selec_pd_win, text=\"Columns to use:\").place(x=30 , y=60)\n",
    "    selec_pd_win.entry2 = Entry(selec_pd_win, textvariable=columnas).place(x=170 , y=60)\n",
    "\n",
    "    selec_pd_win.label3 = Label(selec_pd_win, text=\"Separator to use:\").place(x=30 , y=100)\n",
    "    selec_pd_win.entry3 = Entry(selec_pd_win, textvariable=separador).place(x=170 , y=100)\n",
    "    \n",
    "    #Al presionar el boton de aceptar, se activa la función selec_pd\n",
    "    selec_pd_win.button1 = Button (selec_pd_win , text=\"Accept\", \n",
    "                                   command=lambda: col_params.append(selec_pd(columnas))).place(x=170 , y=150) #command= imprimir)\n",
    "\n",
    "    selec_pd_win.mainloop()\n",
    "    \n",
    "    return col_params[0][0], col_params[0][1], columnas.get(), filas.get(), separador.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función para seleccionar que canalaes se quieren utilizar, y qué posición tiene cada uno\n",
    "\n",
    "def chan_config(col_names, col_types):\n",
    "    \n",
    "    predet_1020_montage = mne.channels.read_montage(\"standard_1020\")\n",
    "    predet_1020_montage.ch_names.sort()\n",
    "    \n",
    "    def selec_chan(chan_s, chan_p):\n",
    "        chan_pos = []\n",
    "        chan_selecc = []\n",
    "        \n",
    "        chan_selec_win.destroy()\n",
    "        for i in range(chan_quant):\n",
    "            chan_pos.append(chan_p[i].get())\n",
    "            chan_selecc.append(chan_s[i].get())\n",
    "            \n",
    "        return chan_pos, chan_selecc\n",
    "    \n",
    "    chan_quant = 0\n",
    "    chan_all = []\n",
    "    chan_p = []\n",
    "    chan_s = []\n",
    "    \n",
    "    chan_params = []\n",
    "    \n",
    "    i = 0\n",
    "    for word in col_types:\n",
    "        if word == 'Channel':\n",
    "            chan_all.append(col_names[i])\n",
    "            chan_quant += 1\n",
    "        i += 1\n",
    "\n",
    "    chan_selec_win = Tk()\n",
    "    chan_selec_win.title(\"Channel Selection\")\n",
    "    chan_selec_win.label1 = Label(chan_selec_win, text = str(chan_quant) +' Channels were detected, which ones will you use?').place(x=30,y=10)\n",
    "    \n",
    "    chan_selec_win.geometry(\"500x\"+str(80+chan_quant*35))\n",
    "    for i in range(chan_quant):\n",
    "        chan_s.append(IntVar())\n",
    "        chan_p.append(StringVar())\n",
    "\n",
    "        chan_selec_win.label2 = Label(chan_selec_win, text = chan_all[i] + \" column:\").place(x=20 , y=40+i*26)\n",
    "        chan_selec_win.check1 = Checkbutton(chan_selec_win, text = \"Import?\", variable=chan_s[i], onvalue=1, offvalue=0).place(x=90 , y=40+i*26)\n",
    "        chan_selec_win.label3 = Label(chan_selec_win, text = \"Channel Position:\").place(x=180 , y=40+i*26)\n",
    "        chan_selec_win.Combobox1 = ttk.Combobox(chan_selec_win , values = predet_1020_montage.ch_names , textvariable = chan_p[i] ).place(x=300 , y=40+i*26)\n",
    "\n",
    "    chan_selec_win.button1 = Button (chan_selec_win , text=\"Accept Channels\", \n",
    "                                     command= lambda: chan_params.append(selec_chan(chan_s, chan_p))).place(x=100, y=60+26*chan_quant) #command= imprimir)\n",
    "\n",
    "    chan_selec_win.mainloop()\n",
    "    \n",
    "    active_chan_pos =[]\n",
    "    active_chan_names = []\n",
    "    \n",
    "    for i in get_indexes(1, chan_params[0][1]):\n",
    "        \n",
    "        active_chan_pos.append(chan_params[0][0][i])\n",
    "        active_chan_names.append(chan_all[i])\n",
    "            \n",
    "    return chan_params[0][0], chan_quant, chan_params[0][1], len(active_chan_names), active_chan_names, active_chan_pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que transforma la variable Pandas de la cual se leyó la señal previamente, en un arreglo Numpy\n",
    "\n",
    "def pd_toarray(X_pd):\n",
    "    \n",
    "    i = 0\n",
    "    j = 0\n",
    "    chan_list = []\n",
    "    accel_list = []\n",
    "    tag_list = []\n",
    "    \n",
    "    #Leyendo las columnas del archivo pandas\n",
    "    while i < X_pd.shape[-1]:\n",
    "        \n",
    "        #guardaremos aquellas del tipo Channel en una variable\n",
    "        if col_types[i] == \"Channel\":\n",
    "            if chan_selecc[j] == 1:\n",
    "                chan_list.append(X_pd.columns[i])\n",
    "            j += 1\n",
    "        \n",
    "        #las del tipo Accel en otra, por si en algún momento sirve utilizar los datos del acelerómetro\n",
    "        if col_types[i] == \" Accel\":\n",
    "            accel_list.append(X_pd.columns[i])\n",
    "        \n",
    "        #y en otra variable las del tipo Tag, para cuando se necesiten para definir intervalos\n",
    "        if col_types[i] == \"Tag\":\n",
    "            tag_list.append(X_pd.columns[i])\n",
    "        i += 1\n",
    "\n",
    "    X_chan = (X_pd.filter(chan_list)).values\n",
    "    X_accel = (X_pd.filter(accel_list)).values\n",
    "    X_tag = (X_pd.filter(tag_list)).values\n",
    "    \n",
    "    return X_chan, X_accel, X_tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_onecol(col_type, many_col_index):\n",
    "\n",
    "    def set_onecol_action(many_col_index, selection):           \n",
    "\n",
    "        column = many_col_index[selection.get()]\n",
    "\n",
    "        select_onecol_win.destroy()\n",
    "\n",
    "        return column\n",
    "\n",
    "    select_onecol_win = Tk()\n",
    "    select_onecol_win.title(\"Too many columns of \" + col_type + \" type\")\n",
    "    select_onecol_win.geometry(\"350x150\")\n",
    "    Label(select_onecol_win , text =\"Select which one shall be used to detect Sample Rate\").pack(side=\"top\")\n",
    "\n",
    "    selection = IntVar()\n",
    "    column = []\n",
    "    \n",
    "    for i in range(len(many_col_index)):\n",
    "\n",
    "        Radiobutton(select_onecol_win , variable=selection, value=i).place(x=300,y=30 + 20*i)\n",
    "        Label(select_onecol_win , text = str(col_names[many_col_index[i]])).place(x=10,y=30 + 20*i)\n",
    "\n",
    "    Button(select_onecol_win , text=\"Accept\", command= lambda: column.append(set_onecol_action(many_col_index, selection))).place(x=150, y= 50 + 20*len(many_col_index))\n",
    "\n",
    "    select_onecol_win.mainloop()\n",
    "    \n",
    "    return column[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que define la frecuencia de muestreo fundamental (sample_rate)\n",
    "\n",
    "def find_samplerate(X_pd):\n",
    "    \n",
    "    time_col_index = get_indexes(\"Time\", col_types)\n",
    "    \n",
    "    if len(time_col_index) > 1:\n",
    "        \n",
    "        time_col_index = [select_onecol(\"Time\", time_col_index)]\n",
    "    \n",
    "    if len(time_col_index) == 1: #Algorithm to try to detect the sample rate from the Time type column\n",
    "        \n",
    "        try:\n",
    "            \n",
    "            assert(\":\" in X_pd.values[0, time_col_index[0]])\n",
    "            \n",
    "        except:\n",
    "            \n",
    "            freq_detect = 1 / (float(X_pd.values[1, time_col_index[0]]) - float(X_pd.values[0, time_col_index[0]])) \n",
    "        \n",
    "        else:\n",
    "            \n",
    "            (hh0, mm0, ss0) = X_pd.values[0, time_col_index[0]].split(\":\")\n",
    "            (hh1, mm1, ss1) = X_pd.values[1, time_col_index[0]].split(\":\")\n",
    "            t0 = 3600 * float(hh0) + 60 * float(mm0) + float(ss0)\n",
    "            t1 = 3600 * float(hh1) + 60 * float(mm1) + float(ss1)\n",
    "            \n",
    "            if (t1-t0) != 0:\n",
    "                freq_detect = 1 / (t1-t0)\n",
    "            \n",
    "            else:\n",
    "                time_col_index = []\n",
    "            \n",
    "    samplerate_win = Tk()\n",
    "    samplerate_opt = IntVar()\n",
    "    samplerate_entry = DoubleVar()\n",
    "    \n",
    "    sample_rate_params = []\n",
    "\n",
    "    def freqw_destroy (samplerate_opt, samplerate_entry, freq_detect):\n",
    "        \n",
    "        if samplerate_entry.get() != 0 and samplerate_entry.get() != 0.0:\n",
    "            samplerate_opt.set(1)\n",
    "\n",
    "        if samplerate_opt.get() == 0 :\n",
    "            samplerate_conf = messagebox.askquestion(\"Confirm\",\"Will you select \" + str(freq_detect) + \" Hz (detected)?\")\n",
    "            sample_rate = freq_detect\n",
    "            \n",
    "        elif samplerate_opt.get() == 1 :\n",
    "            samplerate_conf = messagebox.askquestion(\"Confirm\",\"Will you select \" + str(samplerate_entry.get()) + \" Hz (entered)?\")\n",
    "            sample_rate = samplerate_entry.get()\n",
    "            \n",
    "        if samplerate_conf == \"yes\":\n",
    "            samplerate_win.destroy()\n",
    "            \n",
    "        return sample_rate\n",
    "\n",
    "    samplerate_win.title(\"Set sample rate\" ) \n",
    "    samplerate_win.geometry(\"350x150\")\n",
    "\n",
    "    if len(time_col_index) == 1:\n",
    "        \n",
    "        Radiobutton(samplerate_win , variable=samplerate_opt , value=0).place(x=300,y=30)\n",
    "        samplerate_win.label1 = Label(samplerate_win , text = ' The detected sample rate is ' + str (freq_detect) + ' Hz').place(x=10,y=30)\n",
    "\n",
    "    if len(time_col_index) == 0: #If there's more than one column with the Time type, then it conflicts with automated detection of samplerate - should be changed later to conflict when there's no Time columns, but when there are more than one, should be choosable\n",
    "        \n",
    "        freq_detect = None\n",
    "        samplerate_win.label1 = Label(samplerate_win , text = ' No Time type columns, unable to detect SampleRate.').place(x=10,y=30)\n",
    "        samplerate_opt.set(1)\n",
    "    \n",
    "    if len(time_col_index) > 1:\n",
    "        \n",
    "        samplerate_win.label1 = Label(samplerate_win , text = ' Too many columns with Time type, no SampleRate detection.').place(x=10,y=30)\n",
    "        samplerate_opt.set(1)\n",
    "    \n",
    "    Radiobutton(samplerate_win , variable=samplerate_opt , value=1).place(x=300,y=70)\n",
    "    samplerate_win.label2 = Label(samplerate_win , text = ' Enter manually : ').place(x=10,y=70)\n",
    "    samplerate_win.entry1 = Entry(samplerate_win , textvariable= samplerate_entry ).place(x=130 , y=70)\n",
    "\n",
    "    samplerate_win.button1 = Button(samplerate_win , text=\"Accept\", \n",
    "                                    command=lambda: sample_rate_params.append(freqw_destroy(samplerate_opt, samplerate_entry, freq_detect))).place(x=150, y=110)\n",
    "\n",
    "    samplerate_win.mainloop()\n",
    "    \n",
    "    return sample_rate_params[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que transforma arreglo Numpy en formato MNE, que nos permitirá manipular datos EEG, EMG, etc\n",
    "\n",
    "def array_tomneRaw(X_chan):\n",
    "    \n",
    "    ch_names = []\n",
    "    #montage = []\n",
    "\n",
    "    for i in get_indexes(1,chan_selecc):\n",
    "        ch_names.append('Ch'+ str(i+1))\n",
    "        #montage.append(chan_pos[i])   No funciona así, porque hay que darle una variable montage especifica, hay que ver como crearla\n",
    "    \n",
    "    #Debemos crear una variable con la información de la señal, nombre y tipo de los canales, y posición\n",
    "    X_mneinfo = mne.create_info(ch_names = ch_names, \n",
    "                                ch_types = 'eeg', \n",
    "                                #montage = montage,  ver como crear el montage https://martinos.org/mne/dev/generated/mne.channels.Montage.html#mne.channels.Montage\n",
    "                                sfreq = sample_rate) \n",
    "    \n",
    "    #Creamos la variable MNE, transponiendo la matriz de datos numpy ya que MNE posiciona los canales como filas\n",
    "    #Se puede acceder a la información dentro de la variable MNE a traves de sus atributos X_mneRaw.get_data(), X_mneRaw.ch_names(), etc\n",
    "    X_mneRaw = mne.io.RawArray(np.transpose(X_chan), info = X_mneinfo)\n",
    "    \n",
    "    return X_mneRaw "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def array_tomneEvoked(signal, zeros_fill): #zeros_fill activa la función para que complete con ceros, ya que, como montage no \n",
    "    #funciona bien, por más que usemos 4 canales tenemos que pasarle toda la configuracion 10-20 para que haga bien el mapa \n",
    "    #topografico, entonces completamos los canales que faltan hasta completar la configuracion con lineas de ceros, supuestamente\n",
    "    #son 97 canales en 10-20, pero hay cuatro que estan repetidos así que los borramos y quedan 93.\n",
    "    \n",
    "    if zeros_fill == True:\n",
    "        predet_1020_montage = mne.channels.read_montage('standard_1020', unit = \"m\")\n",
    "        \n",
    "        #---------------------------------------------------------------------------------------------------------------------\n",
    "        #en el montage 1020 que ofrece MNE predeterminadamente, algunas posiciones se encuentran repetidas,\n",
    "        #idealmente habría que recrear el montage corrigiendo dichas posiciones, pero lo que hacemos por ahora es elegir entre\n",
    "        #esas repetidas una o la otra\n",
    "        duplicate_list = []\n",
    "        \n",
    "        if (\"T7\" in active_chan_pos):\n",
    "            duplicate_list.append(\"T3\")\n",
    "        else:\n",
    "            duplicate_list.append(\"T7\")\n",
    "            \n",
    "        if (\"T8\" in active_chan_pos):\n",
    "            duplicate_list.append(\"T4\")\n",
    "        else:\n",
    "            duplicate_list.append(\"T8\")\n",
    "            \n",
    "        if (\"P7\" in active_chan_pos):\n",
    "            duplicate_list.append(\"T5\")\n",
    "        else:\n",
    "            duplicate_list.append(\"P7\")\n",
    "            \n",
    "        if (\"P8\" in active_chan_pos):\n",
    "            duplicate_list.append(\"T6\")\n",
    "        else:\n",
    "            duplicate_list.append(\"P8\")\n",
    "\n",
    "        noduplicate_coord = predet_1020_montage.pos.copy()\n",
    "        noduplicate_pos = predet_1020_montage.ch_names.copy()\n",
    "\n",
    "        for i in duplicate_list:\n",
    "            j = get_indexes(i, noduplicate_pos)[0]\n",
    "\n",
    "            del noduplicate_pos[j]\n",
    "            noduplicate_coord = np.delete(noduplicate_coord, j, axis = 0)\n",
    "\n",
    "        #Cuando se modifique el montage para que no tenga repetidas, toda esta parte entre comentarios no iria, solo iria \n",
    "        #de aca en adelante\n",
    "        #------------------------------------------------------------------------------------------------------------------\n",
    "        \n",
    "        alt_montage = mne.channels.Montage(pos = noduplicate_coord,\n",
    "                                        ch_names = noduplicate_pos,\n",
    "                                        selection = np.arange(len(noduplicate_pos)),\n",
    "                                        kind = 'standard_1020')\n",
    "\n",
    "        alt_montage.plot()\n",
    "\n",
    "        X_superchan = np.zeros([len(noduplicate_pos), signal.shape[-1]])\n",
    "\n",
    "        for i in range(active_chan_quant):\n",
    "\n",
    "            for j in range(len(noduplicate_pos)):\n",
    "\n",
    "                if active_chan_pos[i] == noduplicate_pos[j]:\n",
    "                    X_superchan[j,:] = signal[i,:].copy()\n",
    "\n",
    "        alt_mneinfo = mne.create_info(ch_names = noduplicate_pos,\n",
    "                                        ch_types = 'eeg', \n",
    "                                        montage = alt_montage,  \n",
    "                                        sfreq = sample_rate) \n",
    "\n",
    "        alt_mneEvoked = mne.EvokedArray(X_superchan, alt_mneinfo)\n",
    "        \n",
    "        return alt_mneEvoked\n",
    "    \n",
    "    elif zeros_fill == False:\n",
    "        \n",
    "        return None #No implementamos todavia crear un evoked con un montage propio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tag_interval(tag_colindex):\n",
    "\n",
    "    int_ini_sample = []\n",
    "    int_end_sample = []\n",
    "    int_ini = []\n",
    "    int_end = []\n",
    "    \n",
    "    int_name = []\n",
    "    int_quant = 0\n",
    "    \n",
    "    a = X_pd.values[:, tag_colindex]\n",
    "\n",
    "    tags = np.unique(a)\n",
    "\n",
    "    tag_names = []\n",
    "\n",
    "    for t in tags:\n",
    "\n",
    "        print(\"Which is the name for the tag '\" + str(t) + \"' \\n\")\n",
    "        tag_name = input(\"Entry:\")\n",
    "        tag_names.append(tag_name)\n",
    "\n",
    "        first = True\n",
    "        n = 1\n",
    "        for i in range(a.shape[0]):\n",
    "\n",
    "            if a[i] ==  t and first == True:\n",
    "\n",
    "                int_ini_sample.append(i)\n",
    "                int_name.append(tag_names[get_indexes(t, tags)[0]] + \" \" + str(n)) #Podriamos hacer que los nombres de los intervalos sean ej: Ojos Cerrados (10-20 seg), Ojos Cerrrados(40-60 seg) en vez de Ojos Cerrados 1, Ojos Cerrados 2\n",
    "                int_quant += 1\n",
    "                n = n + 1\n",
    "\n",
    "                first = False\n",
    "\n",
    "            elif a[i] != t and first == False:\n",
    "\n",
    "                int_end_sample.append(i-1)\n",
    "                first = True\n",
    "\n",
    "            elif a[i] == t and i == (a.shape[0]-1):\n",
    "                int_end_sample.append(i)\n",
    "\n",
    "    for i in int_ini_sample:\n",
    "        int_ini.append(float(i/sample_rate))\n",
    "        \n",
    "    for e in int_end_sample:\n",
    "        int_end.append(float(e/sample_rate))\n",
    "        \n",
    "    return int_ini, int_end, int_name, int_quant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Función que permite definir los intervalos a utilizar, con nombres, inicios y finales\n",
    "\n",
    "def interval_choice ():  \n",
    "    \n",
    "    int_quant = 0\n",
    "    int_name= []\n",
    "    int_ini= []\n",
    "    int_end= []\n",
    "\n",
    "    if len(get_indexes(\"Tag\", col_types)) > 0:\n",
    "        \n",
    "        tag_int_opt = yn_quest(\"Type Tag Column Detected, do you wish to use it to define Intervals?\")\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        tag_int_opt = \"no\"\n",
    "    \n",
    "    if tag_int_opt == \"Yes\" or tag_int_opt == \"yes\":\n",
    "        \n",
    "        tag_col_index = get_indexes(\"Tag\", col_types)\n",
    "        \n",
    "        if len(tag_col_index) > 1:\n",
    "            \n",
    "            tag_col_index = [select_onecol(\"Tag\", tag_col_index)]\n",
    "            \n",
    "        int_ini, int_end, int_name, int_quant = tag_interval(tag_col_index)\n",
    "        excel_int_opt = \"no\"\n",
    "        int_path = None #Si no se carga excel con intervalos, de todos modos creamos la variable int_path pero vacía, para el export\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        excel_int_opt= yn_quest(\"Do you wish to load an excel file with intervals?\")\n",
    "    \n",
    "    #Si el usuario desea, se puede cargar un archivo de excel con los intervalos ya definidos\n",
    "    if excel_int_opt == \"Yes\" or excel_int_opt == \"yes\":  \n",
    "        \n",
    "        search_int_win = Tk() #Crea la ventana root\n",
    "        int_path = filedialog.askopenfilename(title = \"Select Signal File :\",          #Dice que va a sacar la variable Xs como el filename de un archivo\n",
    "                                        filetypes = ((\"Excel (post 2003)\", \".xlsx\"),\n",
    "                                                     (\"Excel (prev 2003)\", \".xls\"),\n",
    "                                                     (\"All files\",\"*.*\")\n",
    "                                                    ) #Con titulo de ventana y opciones de abrir archivos de ese tipo\n",
    "                                       ) \n",
    "        search_int_win.destroy()\n",
    "        \n",
    "        int_pd = excel_topd(int_path)\n",
    "        \n",
    "        int_quant = int_pd.shape[0]\n",
    "        \n",
    "        for i in range(int_quant):\n",
    "        \n",
    "            int_name.append(int_pd.values[i,0])\n",
    "            int_ini.append(int_pd.values[i,1])\n",
    "            \n",
    "            if 'Endpoint' in int_pd.columns:\n",
    "                int_end.append(int_pd.values[i,2])\n",
    "            \n",
    "            elif 'Duration' in int_pd.columns:\n",
    "                int_end.append(int_pd.values[i,1] + int_pd.values[i,2])\n",
    "            \n",
    "            else:\n",
    "                if i == 0:\n",
    "                    int_durat = int(input(\"How long did the intervals last (in sec)?: \"))\n",
    "                int_end.append(int_pd.values[i,1] + int_durat)\n",
    "        \n",
    "        search_int_win.mainloop()\n",
    "    \n",
    "    #Si no, se pueden definir manualmente\n",
    "    elif excel_int_opt == \"No\" or excel_int_opt ==\"no\" and tag_int_opt == \"No\" or tag_int_opt == \"no\":\n",
    "        \n",
    "        int_path = None #Si no se carga excel con intervalos, de todos modos creamos la variable int_path pero vacía, para el export\n",
    "        \n",
    "        before_scat = []\n",
    "    \n",
    "        for j in range(active_chan_quant):\n",
    "            before_scat.append(go.Scatter(x = X_mneRaw.times,\n",
    "                                          y = X_mneRaw.get_data()[j, :] + 100*(j+1)\n",
    "                                         )\n",
    "                              )\n",
    "\n",
    "        before_fig = go.Figure(data = before_scat ,\n",
    "                               layout = time_layout\n",
    "                              )\n",
    "\n",
    "        py.plot(before_fig)\n",
    "\n",
    "        #time.sleep(0.5) #We set it to wait for the plot to be done, and the we ask how many intervals to analyze\n",
    "        \n",
    "        int_quant = int(input(\"How many interval will you analyze?: \"))\n",
    "        i = 0\n",
    "\n",
    "        #Stablish names and sizes\n",
    "        while i < int_quant:\n",
    "            print(\"Name for the interval no. \", (i+1))\n",
    "            int_name.append(input())\n",
    "            #Solicito al usuario los rangos de tiempo para cada intervalo\n",
    "            print(\"Start time for interval \" + int_name [i] , end =\"\\n\")\n",
    "            int_ini.append(float(input('Enter in secs: '))) \n",
    "            print(\"End time for interval \" + int_name [i] , end =\"\\n\")\n",
    "            int_end.append(float(input('Enter in secs: '))) \n",
    "            #Multiplico esos tiempos por la frecuencia de submuestreo, para obtener la cantidad de muestras que quiero ver\n",
    "            \n",
    "            i = i + 1\n",
    "            \n",
    "    print(int_name)\n",
    "    print(int_ini)\n",
    "    print(int_end)\n",
    "    \n",
    "    int_export_opt = yn_quest(\"Will you save Interval Data as an Excel file?\")\n",
    "    \n",
    "    if int_export_opt == \"Yes\" or int_export_opt == \"yes\":\n",
    "        int_export(int_ini, int_end, int_name, int_quant, int_path)\n",
    "    \n",
    "    return int_ini, int_end, int_name, int_quant\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def int_export(ini, end, names, quantity, path):\n",
    "    \n",
    "    if path != None:\n",
    "        \n",
    "        _ = shutil.copy2(path, folder_dir + \"\\Intervals Used.xlsx\")\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        int_array = np.append([names], [ini], axis = 0)\n",
    "        int_array = np.append(int_array, [end], axis = 0)\n",
    "        int_array = np.transpose(int_array)\n",
    "        \n",
    "        int_pd_forexport = pd.DataFrame(data = int_array, columns = [\"Interval Name\", \"Interval Start\", \"Interval End\"])\n",
    "        \n",
    "        int_pd_forexport.to_excel(folder_dir + \"\\Intervals Used.xlsx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interval_sec_tosample():\n",
    "    \n",
    "    int_ini_sample = []\n",
    "    int_end_sample = []\n",
    "    \n",
    "    for i in range(int_quant):\n",
    "        sample_ini= int(int_ini[i]*(fq_sub))\n",
    "        sample_end= int(int_end[i]*(fq_sub))\n",
    "\n",
    "        int_ini_sample.append(sample_ini)\n",
    "        int_end_sample.append(sample_end)\n",
    "        \n",
    "    return int_ini_sample, int_end_sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función para definir los parámetros de preprocesado\n",
    "\n",
    "def preproc_params():\n",
    "    \n",
    "    #Selección del tipo de filtro, Chebyschev o Butterworth\n",
    "    def filter_window_destroy():\n",
    "        filter_window.destroy()\n",
    "        \n",
    "        return filter_opt.get(), filt_order.get(), fq_lo.get(), fq_hi.get(), fq_no.get(), rs_cheby.get() , rp_cheby.get()      \n",
    "    \n",
    "    filter_window = Tk()    \n",
    "    filter_window.title(\"Setting parameters for Filtering\" ) \n",
    "    filter_window.geometry(\"370x330\")\n",
    "    \n",
    "    filter_opt = StringVar()\n",
    "    filt_order = IntVar()\n",
    "    fq_lo = IntVar()\n",
    "    fq_hi = IntVar()\n",
    "    fq_no = IntVar()\n",
    "    fq_sub = IntVar()\n",
    "    rs_cheby = DoubleVar()\n",
    "    rp_cheby = DoubleVar()\n",
    "    \n",
    "    filter_params = []\n",
    "    filter_opt.set(\"Butterworth\")\n",
    "    \n",
    "    filter_window.Combobox1 = ttk.Combobox(filter_window , values = (\"Butterworth\", \"Chebyschev\"), textvariable = filter_opt).place(x=30 , y=20)\n",
    "    \n",
    "    filter_window.label1 = Label(filter_window , text = ' Enter Filter Order : ').place(x=10, y=50)\n",
    "    filter_window.entry1 = Entry(filter_window , textvariable = filt_order ).place(x=200 , y=50)\n",
    "    \n",
    "    filter_window.label2 = Label(filter_window , text = ' Enter Low Frequency : ').place(x=10, y=80)\n",
    "    filter_window.entry2 = Entry(filter_window , textvariable = fq_lo ).place(x=200 , y=80)\n",
    "    \n",
    "    filter_window.label3 = Label(filter_window , text = ' Enter High Frecuency : ').place(x=10, y=110)\n",
    "    filter_window.entry3 = Entry(filter_window , textvariable = fq_hi ).place(x=200 , y=110)\n",
    "    \n",
    "    filter_window.label4 = Label(filter_window , text = ' Enter Filter Notch : ').place(x=10, y=140)\n",
    "    filter_window.entry4 = Entry(filter_window , textvariable = fq_no ).place(x=200 , y=140)\n",
    "    \n",
    "    filter_window.label6 = Label(filter_window , text = ' COMPLETE THE NEXT PARAMETERS ONLY FOR CHEBYSCHEV FILTER').place(x=10, y=170)\n",
    "    \n",
    "    #if filter_opt.get() == \"Chebyschev\" : #buscar que el cambio en en combobox sea un comando que actualice si se pone el entry para la ganancia o no\n",
    "    filter_window.label6 = Label(filter_window , text = ' Enter Atenuatuion for Chebyshev :').place(x=10, y=200)\n",
    "    filter_window.entry6 = Entry(filter_window , textvariable = rs_cheby ).place(x=200 , y=200)\n",
    "    \n",
    "    filter_window.label7 = Label(filter_window , text = ' Enter Ripple for Chebyshev :').place(x=10, y=230)\n",
    "    filter_window.entry7 = Entry(filter_window , textvariable = rp_cheby ).place(x=200 , y=230)  \n",
    "    \n",
    "    filter_window.button1 = Button(filter_window , text=\"Accept\", command=lambda: filter_params.append(filter_window_destroy())).place(x=165, y=280)\n",
    "    #filter_window.button2 = Button(filter_window , text=\"Apply\", command=lambda: filter_params.append(filter_window_destroy())).place(x=165, y=280)\n",
    "    \n",
    "    filter_window.mainloop()\n",
    "    \n",
    "    return filter_params[0][0], filter_params[0][1], filter_params[0][2], filter_params[0][3], filter_params[0][4], filter_params[0][5] , filter_params[0][6] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función para el preprocesado de la señal X_mneRaw\n",
    "\n",
    "def sgn_preproc(X_mneRaw):\n",
    "    \n",
    "    if filt_type == 'Butterworth':\n",
    "        typ = \"butter\"\n",
    "        rs = None\n",
    "        rp = None\n",
    "        \n",
    "    if filt_type == 'Chebyschev':\n",
    "        typ = \"cheby1\"\n",
    "        if cheby_rs == 0:\n",
    "            rs = 60\n",
    "        else:\n",
    "            rs = cheby_rs\n",
    "        \n",
    "        if cheby_rp == 0 :\n",
    "            rp = 2\n",
    "        else :\n",
    "            rp = cheby_rp\n",
    "    \n",
    "    if filt_order == '':\n",
    "        order = 5\n",
    "    else:\n",
    "        order = int(filt_order)\n",
    "    \n",
    "    #Si no se ingresa nada, se supone que no se usará frecuncia de corte inferior (filtro pasabajo)\n",
    "    if fq_lo == '' or fq_lo == 0:\n",
    "        low = None\n",
    "    else:\n",
    "        low = float(fq_lo)\n",
    "    \n",
    "    #Si no se ingresa nada, se supone que no se usará frecuncia de corte superior (filtro pasaalto)\n",
    "    if fq_hi == '' or fq_hi == 0:\n",
    "        high = None\n",
    "    else:\n",
    "        high = float(fq_hi)\n",
    "    \n",
    "    #Creamos una copia de la señal, sino al tratar de filtrarla, filtraremos tambien la señal Raw\n",
    "    filtered_signal = X_mneRaw.copy()\n",
    "    \n",
    "    #Este if significaría que si al menos una de las dos (fq_hi o fq_lo) tiene valor, entonces aplicamos filtro\n",
    "    if low != None or high != None:\n",
    "        filtered_signal.filter(l_freq = low,\n",
    "                               h_freq = high,\n",
    "                               method = 'iir',\n",
    "                               iir_params = dict(order = order,\n",
    "                                                 ftype = typ,\n",
    "                                                 rs = rs,\n",
    "                                                 rp = rp\n",
    "                                                )\n",
    "                            )\n",
    "    \n",
    "    #Si ambas son None, no filtramos\n",
    "    else:\n",
    "        print('No Bandpass Filter applied')\n",
    "    \n",
    "    #Si no se ingresa nada, se supone que no se usará filtro Notch\n",
    "    if fq_no == '' or fq_no == 0:\n",
    "        notch = None\n",
    "    else:\n",
    "        notch = float(fq_no)\n",
    "    \n",
    "    if notch != None:\n",
    "        filtered_signal.notch_filter(freqs = notch,\n",
    "                                    notch_widths = 1,\n",
    "                                    method = 'iir',\n",
    "                                    iir_params = dict(order = filt_order,\n",
    "                                                      ftype = \"butter\"\n",
    "                                                     )\n",
    "                                    )\n",
    "    \n",
    "    else:\n",
    "        print('No Notch Filter applied')\n",
    "    \n",
    "    #Solicitamos la frecuencia de submuestreo\n",
    "    \n",
    "    message = str(sample_rate) + ' Hz is the main sample rate, would you like to Subsample?'\n",
    "    \n",
    "    while True:\n",
    "        fq_sub_opt = yn_quest(message)\n",
    "        \n",
    "        if fq_sub_opt == \"yes\" or fq_sub_opt == \"Yes\":\n",
    "            \n",
    "            fq_sub = input(\"Insert Subsample Frequency (Must be lower than \"  + str(sample_rate) + \"): \")\n",
    "            \n",
    "            if float(fq_sub) < sample_rate:\n",
    "                fq_sub = float(fq_sub)\n",
    "                filtered_signal.resample(sfreq = fq_sub)\n",
    "                break\n",
    "            \n",
    "            else:\n",
    "                message = 'Entered Subsample Frequency is greater than the Manin Sample Rate, would you like to subsample?'\n",
    "        \n",
    "        if fq_sub_opt == \"no\" or fq_sub_opt == \"No\":\n",
    "            \n",
    "            fq_sub = float(sample_rate)\n",
    "            break\n",
    "    \n",
    "    return filtered_signal, fq_sub\n",
    "                \n",
    "    \n",
    "#    #Si no se ingresa nada, se supone que no se usará Submuestreo\n",
    "#    if fq_sub != '' and fq_sub != str(sample_rate) and fq_sub != str(int(sample_rate)):\n",
    "#        fq_sub = float(fq_sub)\n",
    "#        filtered_signal.resample(sfreq = fq_sub)\n",
    "#        return filtered_signal\n",
    "#    else:\n",
    "#        fq_sub = sample_rate\n",
    "#        return filtered_signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sgn_reref(signal):\n",
    "    \n",
    "    def apply_ponderation(signal):\n",
    "        \n",
    "        array = signal.get_data()\n",
    "        \n",
    "        inc = []\n",
    "        channels = []\n",
    "        \n",
    "        for i in range(active_chan_quant):\n",
    "            inc.append(include_list[i].get())\n",
    "            print(pound_list[i].get())\n",
    "            \n",
    "        print(inc)\n",
    "        print(array)\n",
    "        \n",
    "        lap = array[0, :].copy() * 0\n",
    "        avg = 0\n",
    "        \n",
    "        for j in get_indexes(1, inc):\n",
    "            lap = lap + (pound_list[j].get()) * array[j,:] \n",
    "            avg += 1\n",
    "            \n",
    "            channels.append(active_chan_names[j])\n",
    "            \n",
    "        lap = lap / avg\n",
    "        \n",
    "        print(lap)\n",
    "        \n",
    "        for i in range(active_chan_quant):\n",
    "            array[i,:] = array[i,:] - lap\n",
    "        \n",
    "        print(array)\n",
    "        print(channels)\n",
    "        \n",
    "        newsignal = array_tomneRaw(np.transpose(array)) #Transponemos array porque en la funcion arraytomneRaw vuelve a transponerse\n",
    "        newsignal = mne.set_eeg_reference(newsignal, ref_channels=[])\n",
    "        \n",
    "        return newsignal\n",
    "    \n",
    "    def choose_reref_type(signal):\n",
    "            \n",
    "        if reref_type.get() == \"No Rereferencing\":\n",
    "            newref_signal = mne.set_eeg_reference(signal, ref_channels=[])\n",
    "            \n",
    "        if reref_type.get() == \"Common Average Reference\":\n",
    "            newref_signal = mne.set_eeg_reference(signal, ref_channels='average')\n",
    "            \n",
    "        if reref_type.get() == \"Reference from Channel Combination\":\n",
    "            newref_signal = apply_ponderation(signal)\n",
    "            \n",
    "        reref_window.destroy()\n",
    "        \n",
    "        return newref_signal\n",
    "    \n",
    "    reref_window = Tk()\n",
    "        \n",
    "    signal_list = []\n",
    "    \n",
    "    pound_params = []\n",
    "    pound_list = []\n",
    "    include_list = []\n",
    "    \n",
    "    reref_window.geometry(\"600x\" + str(60 + 28*active_chan_quant))\n",
    "    \n",
    "    reref_type = StringVar()\n",
    "    reref_type.set(\"No Rereferencing\")\n",
    "    reref_window.Combobox1 = ttk.Combobox(reref_window , values = (\"No Rereferencing\", \"Common Average Reference\", \"Reference from Channel Combination\"), textvariable = reref_type ).place(x=30 , y=20)\n",
    "    reref_window.title(\"Would you like to stablish a new reference point?\" ) \n",
    "    \n",
    "    reref_window.label1 = Label(reref_window, text = \"Select which Channels to Create Reference from, and insert each Ponderation:\").place(x=180 , y=10)\n",
    "    \n",
    "    for i in range(active_chan_quant):\n",
    "        pound_list.append(DoubleVar())\n",
    "        include_list.append(IntVar())\n",
    "        \n",
    "        pound_list[i].set(1.0)\n",
    "        reref_window.label = Label(reref_window, text = active_chan_names[i] + \" - \" + active_chan_pos[i] + \" Ponderation:\").place(x=200 , y=40+i*26)\n",
    "        reref_window.entry = Entry(reref_window , textvariable = pound_list[i]).place(x=340 , y=40+i*26)\n",
    "        reref_window.check = Checkbutton(reref_window , text = \"Include?\" , variable= include_list[i] , onvalue= 1, offvalue= 0).place(x=470 , y=37+i*26)\n",
    "    \n",
    "    reref_window.Button1 = Button (reref_window , text=\"Apply Reference\", command=lambda: signal_list.append(choose_reref_type(signal))).place(x=50, y=70)\n",
    "    \n",
    "    reref_window.mainloop()\n",
    "    \n",
    "    return signal_list[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sgn_ica(signal):\n",
    "    \n",
    "    restored_array = np.transpose(signal.get_data())\n",
    "    \n",
    "    def plot_ica(interv):\n",
    "        \n",
    "        i = get_indexes(interv.get(), int_names)[0]\n",
    "        \n",
    "        #Plotteamos la señal\n",
    "        signal_scat = []\n",
    "        \n",
    "        for j in range(active_chan_quant):\n",
    "            signal_scat.append(go.Scatter(x = signal.times[int_ini_sample[i] : int_end_sample[i]],\n",
    "                                          y = signal.get_data()[j,int_ini_sample[i] : int_end_sample[i]] + 100*j,\n",
    "                                          name = \"Channel \" + str(j)\n",
    "                                          )\n",
    "                               )\n",
    "        \n",
    "        signal_fig = go.Figure(data = signal_scat, layout = time_layout)\n",
    "        \n",
    "        signal_fig.layout.title = \"Time Spectrum for Signal at Interval \" + int_names[i]\n",
    "        \n",
    "        py.plot(signal_fig)\n",
    "        \n",
    "        time.sleep(5)\n",
    "        \n",
    "        #Obtenemos los componentes para ese intervalo\n",
    "        \n",
    "        ica = FastICA(n_components=active_chan_quant, \n",
    "                  max_iter = 100 , \n",
    "                  tol = 20\n",
    "                  )\n",
    "        \n",
    "        components = ica.fit_transform(np.transpose(signal.get_data()[:, int_ini_sample[i] : int_end_sample[i]]))\n",
    "        \n",
    "        #Visualizamos los componentes\n",
    "\n",
    "        components_scat = []\n",
    "\n",
    "        for j in range(active_chan_quant):\n",
    "            \n",
    "            plot_components = components[:,j] + 0.1*j\n",
    "            components_scat.append(go.Scatter(x = signal.times[int_ini_sample[i] : int_end_sample[i]],\n",
    "                                              y = plot_components,\n",
    "                                              name = \"Component \" + str(j)\n",
    "                                             )\n",
    "                                   )\n",
    "\n",
    "        components_fig = go.Figure(data = components_scat,\n",
    "                                   layout = time_layout\n",
    "                                  )\n",
    "\n",
    "        components_fig.layout.title = \"Time Spectrum for ICA Components of Interval \" + int_names[i]\n",
    "\n",
    "        py.plot(components_fig)\n",
    "\n",
    "        time.sleep(2)\n",
    "\n",
    "        #Visualizamos las transformadas de los componentes\n",
    "        components_transform_scat = []\n",
    "\n",
    "        for j in range(active_chan_quant):\n",
    "\n",
    "            fr, tf = sgn.welch(components[:, j], \n",
    "                               fs=fq_sub, \n",
    "                                nperseg = int(fq_sub)*2, \n",
    "                                noverlap = int(fq_sub)*1,\n",
    "                                scaling = \"spectrum\"\n",
    "                              )\n",
    "\n",
    "            components_transform_scat.append(go.Scatter(x = fr,\n",
    "                                                        y = tf,\n",
    "                                                        name = \"Component \" + str(j)\n",
    "                                                       )\n",
    "                                            )\n",
    "\n",
    "        components_transform_fig = go.Figure(data = components_transform_scat,\n",
    "                                            layout = freq_layout\n",
    "                                            )\n",
    "\n",
    "        components_transform_fig.layout.title = \"Frequency Spectrum for ICA Components of Interval \" + int_names[i]\n",
    "\n",
    "        py.plot(components_transform_fig)\n",
    "        \n",
    "        return components, ica\n",
    "    \n",
    "    def delete_component(components, comp_d, interv, ica, restored_array):\n",
    "        \n",
    "        #Obtenemos los valores del arreglo components_d para borrar o dejar\n",
    "        comp_list = []\n",
    "        \n",
    "        i = get_indexes(interv.get(), int_names)[0]\n",
    "        \n",
    "        for j in range(active_chan_quant):\n",
    "            comp_list.append(comp_d[j].get())\n",
    "        \n",
    "        #Buscamos donde el arreglo de components_d vale 1, y en esos eliminamos el componente\n",
    "        for d in get_indexes(1, comp_list):\n",
    "            components[:, d] = 0\n",
    "        \n",
    "        restored = ica.inverse_transform(components)\n",
    "        \n",
    "        restored_array[int_ini_sample[i]:int_end_sample[i], :] = restored\n",
    "        \n",
    "        newsignal_scat = []\n",
    "        \n",
    "        for j in range(active_chan_quant):\n",
    "            newsignal_scat.append(go.Scatter(x = signal.times[int_ini_sample[i] : int_end_sample[i]],\n",
    "                                          y = restored_array[int_ini_sample[i] : int_end_sample[i], j]+100*j,\n",
    "                                          name = \"Channel \" + str(j)\n",
    "                                          )\n",
    "                               )\n",
    "        \n",
    "        newsignal_fig = go.Figure(data = newsignal_scat, layout = time_layout)\n",
    "        \n",
    "        newsignal_fig.layout.title = \"Time Spectrum for Cleaned Signal at Interval \" + int_names[i]\n",
    "        \n",
    "        py.plot(newsignal_fig)\n",
    "        \n",
    "        return restored_array\n",
    "    \n",
    "    def close_win(win):\n",
    "        \n",
    "        win.destroy()\n",
    "    \n",
    "    ica_win_list = []\n",
    "    ica_win_list2 = []\n",
    "    ica_win_list2.append(restored_array)\n",
    "    \n",
    "    component_d = []\n",
    "    comp_win_list = []\n",
    "    \n",
    "    ica_win = Tk()\n",
    "    selected_interv = StringVar()\n",
    "    ica_win.title(\"ICA Analysis\")\n",
    "    ica_win.label1 = Label(ica_win, text = 'Select Interval to Analyse: ').place(x=120,y=10)\n",
    "\n",
    "    ica_win.geometry(\"500x\" + str(60 + 26*active_chan_quant))\n",
    "    \n",
    "    for i in range(active_chan_quant):\n",
    "\n",
    "            component_d.append(IntVar())\n",
    "            ica_win.check = Checkbutton(ica_win ,  text =  \"Component no \" + str(i) , variable= component_d[i] , onvalue= 1, offvalue= 0).place(x=300 , y=20+i*26)\n",
    "    \n",
    "    ica_win.Combobox1 = ttk.Combobox(ica_win, values = int_names, textvariable = selected_interv).place(x=100,y=40)\n",
    "    \n",
    "    ica_win.button1 = Button(ica_win, text=\"Apply ICA\", command = lambda: ica_win_list.append(plot_ica(selected_interv))).place(x=60,y=100) \n",
    "    \n",
    "    #components = ica_win_list[0][-2]\n",
    "    #ica = ica_win_list[0][-1]\n",
    "    \n",
    "    ica_win.button2 = Button(ica_win, text=\"Delete Components\", command = lambda: ica_win_list2.append(delete_component(ica_win_list[-1][-2], component_d, selected_interv, ica_win_list[-1][-1], ica_win_list2[-1]))).place(x=129,y=100)\n",
    "    \n",
    "    ica_win.button3 = Button(ica_win, text=\"Close\", command = lambda: close_win(ica_win)).place(x=250,y=100)\n",
    "\n",
    "    ica_win.mainloop()\n",
    "    \n",
    "    restored_array = ica_win_list2[-1]\n",
    "    \n",
    "    return array_tomneRaw(restored_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Función que grafica las señales en tiempo, actualmente de todos los intervalos, luego se implementaría la selección de algunos intervalos\n",
    "\n",
    "def plot_time(Raw_or_Proc, int_selecc_forplot, chan_selec_forplot):\n",
    "    \n",
    "    for i in int_selecc_forplot:  #Iria en vez de int_quant algún int_selecc que indique solo intervalos seleccionados\n",
    "        scale = 0\n",
    "        raw_scat = []\n",
    "        proc_scat = []\n",
    " \n",
    "        for j in chan_selec_forplot:\n",
    "            raw_scat.append(go.Scatter(x = np.arange(int_ini[i], int_end[i], 1/sample_rate),\n",
    "                                       y = X_mneRaw.get_data()[j, int(int_ini[i]*sample_rate):int(int_end[i]*sample_rate)] + scale, #Si submuestreamos, raw tiene que usar los datos originales\n",
    "                                       name = active_chan_names[j] + \" - \" + active_chan_pos[j] #cambiar despues por posicion en montage, cuando montage este implementado\n",
    "                                      )\n",
    "                           )\n",
    "            proc_scat.append(go.Scatter(x = np.arange(int_ini[i], int_end[i], 1/fq_sub),\n",
    "                                        y = X_mneProc.get_data()[j, int_ini_sample[i]:int_end_sample[i]] + scale,\n",
    "                                        name = active_chan_names[j] + \" - \" + active_chan_pos[j] #cambiar despues por posicion en montage, cuando montage este implementado\n",
    "                                       )\n",
    "                           )\n",
    "            \n",
    "            if Raw_or_Proc == \"Raw Time Scaled\" or Raw_or_Proc == \"Processed Time Scaled\":\n",
    "                scale += 3*max(X_mneRaw.get_data()[j, int(int_ini[i]*sample_rate):int(int_end[i]*sample_rate)]) #Generamos una variable que se suma al proximo arreglo, para que se vayan separando y se puedan visualizar mejor, para escalar usamos el doble del máximo\n",
    "        \n",
    "        \n",
    "        if Raw_or_Proc == \"Raw Time\" or Raw_or_Proc == \"Raw Time Scaled\": \n",
    "            time_layout.title = int_names[i] + ' (' + str(int_ini[i]) + ' - ' + str(int_end[i]) + 's) ' + ' Raw'\n",
    "            \n",
    "            raw_fig = go.Figure(data = raw_scat, layout = time_layout)\n",
    "            \n",
    "            py.plot(raw_fig, filename = folder_dir + \"\\\\Raw Time Plot of Interval \" + int_names[i] + \".html\")\n",
    "            \n",
    "        elif Raw_or_Proc == \"Processed Time\" or Raw_or_Proc == \"Processed Time Scaled\":\n",
    "            time_layout.title = int_names[i] + ' (' + str(int_ini[i]) + ' - ' + str(int_end[i]) + 's) '  + ' Processed'\n",
    "            \n",
    "            proc_fig = go.Figure(data = proc_scat, layout = time_layout)\n",
    "    \n",
    "            py.plot(proc_fig, filename = folder_dir + \"\\\\Processed Time Plot of Interval \" + int_names[i] + \".html\")\n",
    "        \n",
    "        time.sleep(1.5)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que grafica las señales en frecuencia, actualmente de todos los intervalos, luego se implementaría la selección de algunos intervalos\n",
    "\n",
    "def plot_freq(int_selecc_forplot, chan_selec_forplot): #Ver si hace falta mostrar la FFT de Raw data signal\n",
    "    \n",
    "    for i in int_selecc_forplot:  #Iria en vez de int_quant algún int_selecc que indique solo intervalos seleccionados\n",
    "        fft_scat = []\n",
    " \n",
    "        for j in chan_selec_forplot:\n",
    "            fft_scat.append(go.Scatter(x = FFT_matrixProc[i][0],\n",
    "                                       y = FFT_matrixProc[i][j+1],\n",
    "                                       name = active_chan_names[j] + \" - \" + active_chan_pos[j] #cambiar despues por posicion en montage, cuando montage este implementado\n",
    "                                      )\n",
    "                           )\n",
    "         \n",
    "            \n",
    "        freq_layout.title = int_names[i] + ' (' + str(int_ini[i]) + ' - ' + str(int_end[i]) + 's) ' \n",
    "            \n",
    "        fft_fig = go.Figure(data = fft_scat, layout = freq_layout)\n",
    "        py.plot(fft_fig, filename = folder_dir + \"\\\\Frequency Spectrum Plot of Interval \" + int_names[i] + \".html\")\n",
    "        \n",
    "        time.sleep(1.5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que grafica espectrogramas, actualmente de todos los intervalos, luego se implementaría la selección de algunos intervalos\n",
    "\n",
    "def plot_spec(int_selecc_forplot, chan_selec_forplot):\n",
    "     \n",
    "    def update_range(y):\n",
    "        spec_fig.data[0].zmin = y[0]\n",
    "        spec_fig.data[0].zmax = y[1]\n",
    "    \n",
    "    for i in int_selecc_forplot:  #Iria en vez de int_quant algún int_selecc que indique solo intervalos seleccionados\n",
    "        \n",
    "        for j in chan_selec_forplot:\n",
    "            spec_heatmap = go.Heatmap(x = Spec_matrixProc[i][0],\n",
    "                                      y = Spec_matrixProc[i][1],\n",
    "                                      z = Spec_matrixProc[i][j+2],\n",
    "                                      colorscale='Viridis',\n",
    "                                     )         \n",
    "            \n",
    "            slider = widgets.FloatRangeSlider(\n",
    "                                                min=spec_heatmap.z.min(),\n",
    "                                                max=spec_heatmap.z.max(),\n",
    "                                                step=(spec_heatmap.z.min() - spec_heatmap.z.max()) / 1000.0,\n",
    "                                                readout=True,\n",
    "                                                description='Z-Scale',\n",
    "                                                orientation = 'vertical'\n",
    "                                                )\n",
    "\n",
    "            slider.layout.height = '300px'\n",
    "            \n",
    "            spec_layout.title = int_names[i] + ' (' + str(int_ini[i]) + ' - ' + str(int_end[i]) + 's) '  + ' ' + active_chan_names[j] + \" - \" + active_chan_pos[j]\n",
    "              \n",
    "            spec_fig = go.FigureWidget(data = [spec_heatmap], layout = spec_layout)\n",
    "            \n",
    "            #Ya que a espectrogramas los tenemos que meter en HBox para agregar el slider, no lo tenemos en html directamente\n",
    "            #por lo que no es tan simple de exportar. Por ahora lo exportamos como html de PLotly sin el Slider, agregando la \n",
    "            #opcion auto_open = False para que no abra el html, sino que solamente lo guarde.\n",
    "            py.plot(spec_fig, filename = folder_dir + \"\\\\Spectrogram Plot of Interval \" + int_names[i] + \" and Channel \" + active_chan_names[j] +\".html\", auto_open = False)\n",
    "            \n",
    "            hb = HBox((spec_fig, interactive(update_range, y=slider)))\n",
    "            hb.layout.align_items = 'center'\n",
    "                   \n",
    "            display(hb)\n",
    "            \n",
    "            time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_topomap(int_selecc_forplot):\n",
    "    \n",
    "    for i in int_selecc_forplot:\n",
    "            \n",
    "        alt_mneEvoked.plot_topomap(times = float((int_ini[i]+int_end[i])/2),\n",
    "                                       average = float(int_end[i]-int_ini[i]),\n",
    "                                       size = 6, \n",
    "                                       colorbar = True, \n",
    "                                       show_names= True,\n",
    "                                       title = int_names[i] + \" averaged\",\n",
    "                                       time_unit='s',\n",
    "                                       ch_type = 'eeg',\n",
    "                                       scalings = 1,\n",
    "                                       units = \"uV\",\n",
    "                                       #cmap = \"interactive\",\n",
    "                                       contours = 0,\n",
    "                                       res=32)\n",
    "\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_sgn():\n",
    "\n",
    "    selecc_predet = yn_quest('Do you want to plot de signal ?')\n",
    "\n",
    "    if selecc_predet == 'Yes' or selecc_predet == 'yes':\n",
    "        \n",
    "        int_s = []\n",
    "        chan_s = []\n",
    "        \n",
    "        plot_window = Tk()\n",
    "        \n",
    "        reset_list = []\n",
    "        plot_type = StringVar()\n",
    "        plot_window.Combobox1 = ttk.Combobox(plot_window , values = (\"Raw Time\", \"Raw Time Scaled\", \"Processed Time\", \"Processed Time Scaled\", \"Freq Spectrum\", \"Spectrogram\", \"Topographic Map\"), textvariable = plot_type ).place(x=30 , y=20)\n",
    "        plot_window.title(\"Plot Window\" ) \n",
    "\n",
    "        def choose_plot_type():\n",
    "            \n",
    "            int_selecc_forplot = []\n",
    "            chan_selecc_forplot = []\n",
    "            \n",
    "            for i in range(len(int_s)):\n",
    "                if int_s[i].get() == 1:\n",
    "                    int_selecc_forplot.append(i)\n",
    "            \n",
    "            for j in range(len(chan_s)):\n",
    "                if chan_s[j].get() == 1:\n",
    "                    chan_selecc_forplot.append(j)\n",
    "            \n",
    "            if plot_type.get() == \"Raw Time\" or plot_type.get() == \"Raw Time Scaled\" or plot_type.get() == \"Processed Time\" or plot_type.get() == \"Processed Time Scaled\":\n",
    "                plot_time(plot_type.get(), int_selecc_forplot, chan_selecc_forplot)\n",
    "            \n",
    "            if plot_type.get() == \"Freq Spectrum\":\n",
    "                plot_freq(int_selecc_forplot, chan_selecc_forplot)\n",
    "            \n",
    "            if plot_type.get() == \"Spectrogram\":\n",
    "                for inter in int_selecc_forplot:\n",
    "                    for chan in chan_selecc_forplot:\n",
    "                        plot_spec([inter], [chan])\n",
    "                \n",
    "            if plot_type.get() == \"Topographic Map\":\n",
    "                plot_topomap(int_selecc_forplot)\n",
    "\n",
    "        def close_window(reset):\n",
    "            \n",
    "            plot_window.destroy()\n",
    "            \n",
    "            return reset\n",
    "\n",
    "        if int_quant >= active_chan_quant:\n",
    "            largo = int_quant\n",
    "\n",
    "        elif active_chan_quant > int_quant:\n",
    "            largo = active_chan_quant\n",
    "            \n",
    "        plot_window.geometry(\"482x\"+str(80+largo*45))\n",
    "\n",
    "        for i in range(int_quant):\n",
    "\n",
    "            int_s.append(IntVar())\n",
    "\n",
    "            plot_window.label = Label(plot_window , text = int_names[i]  + ' (' + str(int_ini[i]) + ' - ' + str(int_end[i]) + 's) ' + \" Interval:\").place(x=20 , y=60+i*26)\n",
    "            plot_window.check = Checkbutton(plot_window , text = \"Import?\" , variable= int_s[i] , onvalue= 1, offvalue= 0).place(x=210 , y=60+i*26)\n",
    "\n",
    "        for j in range(active_chan_quant):\n",
    "\n",
    "            chan_s.append(IntVar())\n",
    "\n",
    "            plot_window.label1 = Label(plot_window , text = active_chan_names[j] + \" - \" + active_chan_pos[j]).place(x=320 , y=60+j*26)\n",
    "            plot_window.check1 = Checkbutton(plot_window , text = \"Import?\", variable= chan_s[j] , onvalue= 1, offvalue= 0).place(x=380 , y=60+j*26)\n",
    "\n",
    "\n",
    "        plot_window.button1 = Button (plot_window , text=\"Plot\", command=lambda: choose_plot_type()).place(x=100, y=86+26*largo)\n",
    "        plot_window.button1 = Button (plot_window , text=\"Close\", command=lambda: reset_list.append(close_window(False))).place(x=300, y=86+26*largo)\n",
    "        plot_window.button1 = Button (plot_window , text=\"Reset Parameters\", command=lambda: reset_list.append(close_window(True))).place(x=150, y=86+26*largo)\n",
    "\n",
    "        plot_window.mainloop()\n",
    "        \n",
    "        return reset_list[0]\n",
    "    \n",
    "    elif selecc_predet == 'No' or selecc_predet == 'no':\n",
    "\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que genera las fft de la señal en cada intervalo y cada canal, colocandolas a todas en una unica variable para poder acceder a ellas la momento de graficar\n",
    "\n",
    "def sgn_fft(signal):\n",
    "    \n",
    "    fft_list = [] #Esta lista contendra un arreglo de varias listas, una por cada intervalo, cada una con las transformadas de los canales seleccionados para cada intervalo\n",
    "    \n",
    "    #Se solicita al usuario si quiere utilizar Welch (transformada con ventana en trasladada) o transformada FFT normal\n",
    "    welch_opt = yn_quest(\"Will you use Welch's method for tranforming?\")\n",
    "    \n",
    "    if welch_opt == 'Yes' or welch_opt == 'yes':\n",
    "        #Si se acepta el uso de Welch, se solicitan sus parámetros\n",
    "        welch_twin = float(input('How long shall the transform window be (in secs)?: '))\n",
    "        welch_twin_overlap = float(input('How many seconds will be overlapped?: '))\n",
    "        \n",
    "        for i in range(int_quant):\n",
    "            \n",
    "            each_fft_list = [] #En cada iteración se cargará esta lista con los residuos de frecuencia y las transformadas de cada canal, para un cierto intervalo\n",
    "            \n",
    "            for j in range(signal.shape[0]):\n",
    "                \n",
    "                fr, tf = sgn.welch(signal[j, int_ini_sample[i]:int_end_sample[i]], \n",
    "                                   fs=fq_sub, \n",
    "                                   nperseg = int(fq_sub*welch_twin), \n",
    "                                   noverlap = int(fq_sub*welch_twin_overlap),\n",
    "                                   scaling = \"spectrum\"\n",
    "                                  )\n",
    "                if j == 0: #En la primera iteración se guardan los residuos de frecuencia, iguales para todos los canales, y luego cada una de las transformadas\n",
    "                    each_fft_list.append(fr)\n",
    "                \n",
    "                each_fft_list.append(tf)\n",
    "                \n",
    "            #De esta manera queda una lista formada each_fft_list[0]=residuos de frecuencia para el intervalo i, each_fft_list[<0]=transformada para cada canal seleccionadopara el intervalo i\n",
    "            #Esta lista se agrega a la lista general y luego se resetea para el proximo intervalo.\n",
    "            fft_list.append(each_fft_list)\n",
    "    \n",
    "    else:\n",
    "        \n",
    "        for i in range(int_quant):\n",
    "            \n",
    "            each_fft_list = [] \n",
    "            \n",
    "            fr = np.fft.fftfreq(int_end_sample[i]-int_ini_sample[i], d = 1/fq_sub)\n",
    "            each_fft_list.append(fr) #en el caso de FFT, funciona similar solo que no se solicitan parámetros de Welch, y se agregan los resiudos por separado, ya que np.fft tiene un comando para ello.\n",
    "            \n",
    "            for j in range(signal.shape[0]):\n",
    "                \n",
    "                tf = np.fft.fft(signal[j, int_ini_sample[i]:int_end_sample[i]])\n",
    "                each_fft_list.append(abs(tf)/(int_end_sample[i]-int_ini_sample[i]))\n",
    "            \n",
    "            fft_list.append(each_fft_list)\n",
    "                                \n",
    "    \n",
    "    return(fft_list)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función que genera las fft de la señal en cada intervalo y cada canal, colocandolas a todas en una unica variable para poder acceder a ellas la momento de graficar\n",
    "\n",
    "def sgn_spec(signal) :\n",
    "    \n",
    "    spec_list = [] #Similar al caso de las FFT, esta lista contendra un arreglo con listas para cada intervalo, donde cada lista posee los residuos de tiempo y frecuencia, y los espectrogramas para cada canal\n",
    "        \n",
    "    spec_twin = float(input('How long shall the spectrogram window be (in secs)?: '))\n",
    "    spec_twin_overlap = float(input('How many seconds will be overlapped?: '))\n",
    "        \n",
    "    for i in range(int_quant):\n",
    "            \n",
    "        each_spec_list = [] #En cada iteración se cargaran en esta lista los resiudos de tiempo y frecuencia, y los espectrogramas de cada canal, para un cierto intervalo i\n",
    "            \n",
    "        for j in range(signal.shape[0]):\n",
    "            Freq_spec , Time_spec , Values_spec = sgn.spectrogram (x=signal[j,int_ini_sample[i]:int_end_sample[i]],\n",
    "                                                                   fs=fq_sub ,\n",
    "                                                                   nperseg= int(spec_twin*fq_sub),\n",
    "                                                                   noverlap= int(spec_twin_overlap*fq_sub),\n",
    "                                                                   scaling = \"spectrum\"\n",
    "                                                                  )\n",
    "                                                                \n",
    "            if j == 0:\n",
    "                each_spec_list.append(Time_spec)\n",
    "                each_spec_list.append(Freq_spec)\n",
    "                \n",
    "            each_spec_list.append(Values_spec)\n",
    "                \n",
    "        spec_list.append(each_spec_list)\n",
    "    \n",
    "    return spec_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función de calculo de la correlación entre los canales de la señal, para cada intervalo\n",
    "\n",
    "def sgn_correlation ():\n",
    "    index = []\n",
    "\n",
    "    chan_num = active_chan_quant\n",
    "    \n",
    "    #Creamos dos matrices que reciban los datos de correlacion (rho y pvalor) de tamaño (cant de canales)^2 x (cant de intervalos) ya que se cruzan cada canal con todos los otros en cada intervalo \n",
    "    rho_list = np.zeros((chan_num**2, int_quant))  \n",
    "    pval_list = np.zeros((chan_num**2, int_quant))\n",
    "\n",
    "    n = 0\n",
    "    for i in range(chan_num): #Recorremos la combinación de cada canal i con cada canal j\n",
    "        for j in range(chan_num):\n",
    "\n",
    "            for k in range(int_quant): #Recorremos todos los intervalos con k\n",
    "                rho, pval = sts.spearmanr(X_mneProc.get_data()[i , int_ini_sample[k]:int_end_sample[k]], \n",
    "                                          X_mneProc.get_data()[j , int_ini_sample[k]:int_end_sample[k]],\n",
    "                                          axis = 0\n",
    "                                         )\n",
    "                rho_list[n, k] = rho\n",
    "                pval_list[n, k] = pval\n",
    "\n",
    "\n",
    "            n += 1 #ya que las filas estan indicadas por i y j a la vez, lo más simple es crear un puntero n que apunte a cada posicion\n",
    "            \n",
    "            #en cada vuelta agregamos al index los canales que se estan correlacionando\n",
    "            index.append(str(X_mneRaw.ch_names[i]) + ' vs ' + str(X_mneRaw.ch_names[j])) #cambiaremos ch_names por montage\n",
    " \n",
    "    #Creamos las variables pandas Dataframe con las matrices de datos, index como nombres de filas (canal vs canal) y nombres de intervalos para cada columna\n",
    "    cor_rho_pd = pd.DataFrame(data = rho_list, columns=int_names , index = index)\n",
    "    cor_pval_pd = pd.DataFrame(data = pval_list, columns=int_names , index = index)\n",
    "    #cor_rho_pd.set_caption(\"Correlation Rho Values\")  Ver como hacer que funcione\n",
    "    #cor_pval_pd.set_caption(\"Correlation P-Values\")  Ver como hacer que funcione\n",
    "    \n",
    "    print(\"Correlation Rho Values:\")\n",
    "    display(cor_rho_pd)\n",
    "    \n",
    "    cor_rho_pd.to_excel(folder_dir + \"\\\\Correlation Rho Values.xlsx\")\n",
    "    \n",
    "    pval_opt = yn_quest(\"According to SciPy documentation, P-values are not entirely reliable but are probably reasonable for datasets larger than 500 or so. Do you want to show them anyways?\")\n",
    "    \n",
    "    if pval_opt == \"Yes\" or pval_opt == \"yes\":\n",
    "        print(\"Correlation P-Values:\")\n",
    "        display(cor_pval_pd)\n",
    "        \n",
    "        cor_pval_pd.to_excel(folder_dir + \"\\\\Correlation P-Values.xlsx\")\n",
    "\n",
    "    return cor_rho_pd , cor_pval_pd "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función de calculo de la coherencia entre los canales de la señal, para cada intervalo\n",
    "\n",
    "def sgn_coherence ():\n",
    "    \n",
    "    index= []\n",
    "\n",
    "    chan_num = active_chan_quant\n",
    "    \n",
    "    #Creamos una matriz que reciba los datos de correlacion media, de tamaño (cant de canales)^2 x (cant de intervalos) ya que se cruzan cada canal con todos los otros en cada intervalo \n",
    "    coh_mean_list = np.zeros((chan_num**2, int_quant))\n",
    "\n",
    "    n = 0\n",
    "    \n",
    "    for i in range(chan_num):\n",
    "        for j in range(chan_num):\n",
    "\n",
    "            for k in range(int_quant):\n",
    "\n",
    "                f, cxy = sgn.coherence(x = X_mneProc.get_data()[i , int_ini_sample[k]:int_end_sample[k]],\n",
    "                                       y = X_mneProc.get_data()[j , int_ini_sample[k]:int_end_sample[k]],\n",
    "                                       fs = fq_sub,\n",
    "                                       nperseg = 0.5*fq_sub,\n",
    "                                       noverlap = 0.1*fq_sub,\n",
    "                                       axis = 0\n",
    "                                   )\n",
    "\n",
    "                coh_mean_list[n, k] = np.mean(cxy) #En cada posicion cargamos la media de coherencia\n",
    "\n",
    "            n += 1 \n",
    "\n",
    "            index.append(str(X_mneRaw.ch_names[i]) + ' vs ' + str(X_mneRaw.ch_names[j])) #cambiaremos ch_names por montage\n",
    "\n",
    "    coh_mean_pd = pd.DataFrame(data = coh_mean_list, columns=int_names, index = index)\n",
    "    #coh_mean_pd.style.set_caption(\"Coherence Values\") Ver como hacer que funcione\n",
    "    \n",
    "    print(\"Coherence Values:\")\n",
    "    display(coh_mean_pd)\n",
    "    \n",
    "    coh_mean_pd.to_excel(folder_dir + \"\\\\Coherence Values.xlsx\")\n",
    "    \n",
    "    return coh_mean_pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cuerpo del Código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "X_pd, signal_filepath, signalname, col_names, col_types, usecols, skiprows, sep = load_signal()\n",
    "\n",
    "folder_dir = export()\n",
    "\n",
    "chan_pos, chan_quant, chan_selecc, active_chan_quant, active_chan_names, active_chan_pos = chan_config(col_names, col_types)\n",
    "\n",
    "X_chan, X_accel, X_tag = pd_toarray(X_pd)\n",
    "\n",
    "sample_rate = find_samplerate(X_pd)\n",
    "\n",
    "X_mneRaw = array_tomneRaw(X_chan)\n",
    "\n",
    "int_ini, int_end, int_names, int_quant = interval_choice() \n",
    "\n",
    "while True:\n",
    "\n",
    "    filt_type, filt_order, fq_lo, fq_hi, fq_no, cheby_rs , cheby_rp = preproc_params() \n",
    "\n",
    "    X_mneProc,  fq_sub = sgn_preproc(X_mneRaw)\n",
    "    \n",
    "    int_ini_sample, int_end_sample = interval_sec_tosample()\n",
    "    \n",
    "    X_mneProc = sgn_reref(X_mneProc)\n",
    "    \n",
    "    ica_opt = yn_quest(\"Would you like to apply an ICA Method?\")\n",
    "    \n",
    "    if ica_opt == \"Yes\" or ica_opt == \"yes\":\n",
    "        X_mneProc =  sgn_ica(X_mneProc)\n",
    "    \n",
    "    alt_mneEvoked = array_tomneEvoked(X_mneProc.get_data(), zeros_fill = True) #como mne.Evoked no tiene notch filter no le podemos aplicar sgn_preproc, así que construimos el evoked con la mneProc (señal procesada)\n",
    "    \n",
    "    #FFT_matrixRaw = sgn_fft(X_mneRaw.get_data())\n",
    "\n",
    "    FFT_matrixProc = sgn_fft(X_mneProc.get_data())\n",
    "\n",
    "    Spec_matrixProc = sgn_spec(X_mneProc.get_data())\n",
    "\n",
    "    reset = plot_sgn()\n",
    "    \n",
    "    if reset == False:\n",
    "        break\n",
    "\n",
    "Rho_pd , Pval_pd = sgn_correlation ()\n",
    "\n",
    "Coh_pd = sgn_coherence()"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}