trabajo_practico/noteboks/segunda_entrega.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trabajo Practico - Desarrollo de software para el cálculo de parámetros acústicos ISO 3382 (2da entrega)\n",
    "\n",
    "## Fecha de entrega"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Ingresar fecha*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integrantes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* <Nombre, Apellido>\n",
    "* <Nombre, Apellido>\n",
    "* <Nombre, Apellido>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aspectos generales del notebook\n",
    "\n",
    "* Todas las funciones deben contar con su [docstring](https://realpython.com/documenting-python-code/#docstring-types), como figura en la función de ejemplo (`ruidoRosa_voss`)(1er entrega).\n",
    "* Todos los gráficos deben tener correctamente etiquetados los ejes.\n",
    "* Enviar el notebook (.ipynb) (con las celdas ejecutas) y todos los archivos para reproducir los resultados por Slack.\n",
    "* Todas las señales de audio deben ser grabadas en formato .wav en la misma función que las genera."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Librerias utilizadas\n",
    "Agregar todas las librerias utilizadas, algunas a modo de ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import pandas as pd\n",
    "from scipy import signal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Descargar dataset\n",
    "El objetivo es tener archivos para validar el software creado , para lo cual es necesario contar con la información y los datos de la medición.\n",
    "\n",
    "### 1. Respuestas al impulso: \n",
    "**Consigna:** Descargar **al menos dos** respuestas al impulso (RI o en ingles IR, Impulse Responses) de dos recintos distintos del siguiente [link](https://www.openair.hosted.york.ac.uk/?page_id=36) y toda la información relevante de la medición, ademas de los resultados de los parametros acústicos calculados (para luego comparar). También se pueden usar los archivos dispuestos en el Drive de la asignatura. \n",
    "\n",
    "### 2. Sine sweep logarítmico + filtro inverso: \n",
    "**Consigna:** Descargar **al menos un** sine sweep con su respectivo filtro inverso. Una posibildiad es usar los archivos dispuestos en el GDrive de la asignatura. Para generar el filtro inverso usar la info brindada por el informe técnico en la misma carpeta de los archivos. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Función de carga de archivos de audio\n",
    "\n",
    "**Consigna:** realizar una función que permita cargar archivos de audio, en lo posible \\*.wav, por ejemplo los archivos anteriormente descargados. Contemplar el ingreso de más de un archivo de audio, por tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar a la función con uno de los ejemplos anteriormente descargados y usar la función de visualización de la 1er entrega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Opcional**: el código de la siguiente celda genera un botón de selección (ver los pasos de instalación [aqui](https://ipywidgets.readthedocs.io/en/latest/user_install.html)), y guarda las rutas a los archivos seleccionados en la variable files. La función desarrollada debería tomar las rutas y leer el contenido de los archivos, utilizando alguna de las librerías vistas en clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets import Button\n",
    "from tkinter import Tk, filedialog\n",
    "from IPython.display import clear_output, display\n",
    "files = []\n",
    "def select_files(b,files=files):\n",
    "    clear_output()\n",
    "    root = Tk()\n",
    "    root.withdraw() # Hide the main window.\n",
    "    root.call('wm', 'attributes', '.', '-topmost', True) # Raise the root to the top of all windows.\n",
    "    files.append(filedialog.askopenfilename()) # List of selected files will be set button's file attribute.\n",
    "    print(files) # Print the list of files selected.\n",
    "\n",
    "fileselect = Button(description=\"Seleccione el archivo\")\n",
    "fileselect.on_click(select_files)\n",
    "\n",
    "display(fileselect)\n",
    "files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Función de sintetización de respuesta al impulso\n",
    "\n",
    "**Consigna:** realizar una función para sintetizar una respuesta al impulso. La misma recibira como parametro el $T60$ que se desea obtener, y deberá sintetizar una respuesta al impulso considerando las frecuencias centrales de banda de octava y tercio de octava como establece la norma IEC61260 (IEC61260,1995). La siguiente ecuación define una RI, para una frecuencia central $f_{i}$:\n",
    "\n",
    "\\begin{equation}\n",
    "y_{i}=A_{i}e^{-\\tau_it}\\cos(2πf_{i}t)\n",
    "\\tag{6}\n",
    "\\end{equation}\n",
    "\n",
    "donde $A_{i}$ es el coeficiente de amplitud para esa $f_{i}$(puede ser 1), y  $π_{i}$ define el decaimiento exponencial en función de $T_{60_i}$ (tiempo de reverberación) para una frecuencia $f_{i}$.\n",
    "\n",
    "\\begin{equation}\n",
    "\\tau_i=-\\frac{ln(10^{-3})}{T_{60_i}}\n",
    "\\tag{7}\n",
    "\\end{equation}\n",
    "\n",
    "La suma de varias frecuencias centrales $f_{i}$ se define como:\n",
    "\\begin{equation}\n",
    "  y=\\sum_{y=1}^{n}y_{i}\n",
    "\\tag{8}\n",
    "\\end{equation}\n",
    "\n",
    "Con $n$ la cantidad de frecuencias centrales $f_{i}$ del filtro. La funcion debe recibir el tiempo de reverberacion para cada frecuencia, y devolver la respuesta al impulso correspondiente como un archivo de audio .wav. Al momento de definir la función, buscar la forma de que la misma permita varios $T60_i$ para cada frecuencia. \n",
    "\n",
    "> Con esta funcion se busca obtener un archivo de audio de valores de $T60_i$ conocidos que permita probar el software."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar a la función con un vector que contega varios $T60$ para las cada frecuencias centrales $f_{i}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar la función de visualizar el dominio temporal, de la entrega anterior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graficar el dominio espectral del resultado utilizando el [software Audacity](https://www.audacityteam.org/) (Ayuda: [Plot Spectrum Audacity](https://manual.audacityteam.org/man/plot_spectrum.html))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Reproducir señal resultante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comentar sobre el resultado obtenido, ¿Es una buena aproximación? ¿Qué aspectos estamos dejando de lado en esta sintetización, que en un caso real estan presentes?."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "*completar*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Función obtener respuesta al impulso\n",
    "\n",
    "**Consigna:** realizar una función que permita obtener la respuesta al impulso en formato de señal de audio .wav, a partir del sinesweep logarítmico grabado y el filtro inverso generado utilizando el siguiente método: \n",
    "\n",
    "Supongamos que un recinto es excitado por una señal sinesweep logarítmica $x(t)$ y captada por un micrófono $y(t)$ y buscamos la RI del recinto $h(t)$, lo anterior se expresa de la siguiente manera:\n",
    "\n",
    "\\begin{equation}\n",
    "y(t)=x(t)*h(t)\n",
    "\\tag{9}\n",
    "\\end{equation}\n",
    "\n",
    "Para un sine sweep lineal (que no es nuestro caso) el problema es sencillo, pero en nuestro caso (sine sweep logarítmico) requiere trabajar un poco respecto $x(t)$ para obtener la siguiente expresión:\n",
    "\n",
    "\\begin{equation}\n",
    "h(t) = F^{-1}[H(jw)]=F^{-1}[Y(jw)K(jw)]\n",
    "\\tag{10}\n",
    "\\end{equation}\n",
    "\n",
    "Recordar que $k(t)$ es el filtro inverso (ecu.5) y $K(jw)$ su respectiva transformada de fourier. De esta manera se obtiene la respuesta al impulso buscada.\n",
    "\n",
    "> El desarrollo matemático de la anterior expresión se encuentra en el [Anexo I - Obtener la respuesta al impulso a partir de un sine sweep](../consigna_TP_matlab.pdf) (p.14) del instructivo para Matlab del TP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar a la función con un sine sweep y su respectivo filtro inverso creados con la función de la primer entrega (**no** los descargados)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Visualizar la señal con la función creada en la primer entrega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Reproducir señal resultante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comentar sobre el resultado obtenido. ¿Qué es lo que se esta escuchando? Realizar el mismo procedimiento con la señal descargada y el filtro inverso generado (para dicho sine sweep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "*completar*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mencionar aspectos que diferencian los impulso generados en esta función, con los sintetizados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "*completar*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Función filtros norma IEC61260\n",
    "\n",
    "**Consigna**: Realizar una función que filtre todas las señales en octavas y tercio de octava según la norma IEC61260, con el objetivo de calcular los parámetros acústicos discriminando las frecuencias. \n",
    "\n",
    "Para lo cual utilizar las funciones del modulo [signals de scipy](https://docs.scipy.org/doc/scipy/reference/signal.html). Se adjunta el código capaz de calcular los coeficientes del filtro y aplicarlos a una señal. La función debe completarse con el código necesario para que este proceso se repita para cada una de las frecuencias centrales determinadas en la norma. Así mismo, el primer argumento de la función [iirfilter](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.iirfilter.html) determina el grado del filtro. Evaluar el valor del mismo para que la frecuencia central de la banda coincida con las especificadas en la norma.\n",
    "\n",
    "> Para ver una introducción breve a la implementación de filtros, usar el siguiente [documento](https://github.com/maxiyommi/signal-systems/blob/master/material_extra/Filtros/intro_filtros.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Octava - G = 1.0/2.0 / 1/3 de Octava - G=1.0/6.0\n",
    "G = 1.0/2.0\n",
    "factor = np.power(2, G)\n",
    "centerFrequency_Hz = 1000\n",
    "\n",
    "#Calculo los extremos de la banda a partir de la frecuencia central\n",
    "lowerCutoffFrequency_Hz=centerFrequency_Hz/factor;\n",
    "upperCutoffFrequency_Hz=centerFrequency_Hz*factor;\n",
    "\n",
    "print('Frecuencia de corte inferior: ', round(lowerCutoffFrequency_Hz), 'Hz')\n",
    "print('Frecuencia de corte superior: ', round(upperCutoffFrequency_Hz), 'Hz')\n",
    "\n",
    "# Extraemos los coeficientes del filtro \n",
    "b,a = signal.iirfilter(4, [2*np.pi*lowerCutoffFrequency_Hz,2*np.pi*upperCutoffFrequency_Hz],\n",
    "                            rs=60, btype='band', analog=True,\n",
    "                            ftype='butter') \n",
    "\n",
    "# para aplicar el filtro es más óptimo\n",
    "sos = signal.iirfilter(4, [lowerCutoffFrequency_Hz,upperCutoffFrequency_Hz],\n",
    "                            rs=60, btype='band', analog=False,\n",
    "                            ftype='butter', fs=fs, output='sos') \n",
    "w, h = signal.freqs(b,a)\n",
    "\n",
    "# aplicando filtro al audio\n",
    "filt = signal.sosfilt(sos, audiodata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar a la función con alguna RI generada anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graficar el dominio espectral del resultado en una banda, utilizando el [software Audacity](https://www.audacityteam.org/) (Ayuda: [Plot Spectrum Audacity](https://manual.audacityteam.org/man/plot_spectrum.html))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿El resultado es el esperado? ¿Cumple con los requerimientos de la normativa?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*completar*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Función conversión a escala logarítmica normalizada\n",
    "Para visualizar correctamente la señal es necesario realizar una función que convierta la respuesta al impulso en escala logarítmica, utilizando la siguiente expresión:\n",
    "\n",
    "\\begin{equation}\n",
    "    R(t) = 20\\log_{10}\\frac{A(t)}{A(t)_{max}}\n",
    "\\tag{11}\n",
    "\\end{equation}\n",
    "\n",
    "Donde $A(t)$ es la señal que deseamos transformar de escala. **Consigna:** crear una función que convierta a escala logarítmica la RI que ingresa y devuelva un array con la señal resultante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Llamar a la función con alguna de las señales generadas anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Visualizar la señal con la función creada en la primer entrega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# completar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Informe preliminar (opcional)\n",
    "Realizar un informe preliminar en formato UNTREF para memorias cuatrimestrales (disponible en el Drive de la asignatura), utilizando la plataforma de dición de documentos [LaTeX](https://es.wikipedia.org/wiki/LaTeX). Respetar las siguientes consignas:\n",
    "1. Mencionar los detalles en el diseño de los scripts(con ayuda de diagramas de flujo o pseudocódigo) sin agregar código propiamente dicho.\n",
    "2. Describir el dataset seleccionado para probar el software.\n",
    "3. El informe debe reflejar la arquitectura del software desarrollado y los avances en la producción del mismo. Los datos que se informan tienen que ser relevantes y garantizar la reproducibilidad de los mismos. No ahondar en muchos detalles teóricos y definiciones(hacer uso de referencias),hacer más bien foco en la producción del software, su evaluación y su validación.\n",
    "4. El informe preliminar no debe exceder las 3 páginas. Respetar fecha de entrega.\n",
    "5. Respetar los siguientes porcentajes de contenido por sección(también determinan los grados de importancia)\n",
    "\n",
    "A modo ilustrastivo se muestra los porcentajes del contenido en los informes:\n",
    "\n",
    "| Resumen | Introducción | Marco teórico | Desarrollo experimental | Resultados | Conclusiones |\n",
    "| -- | -- | -- | -- | -- | --  |\n",
    "| 5% | 10% | 10% | 25% | 30% | 20% |\n",
    "\n",
    "> Más información en el siguiente [link](https://github.com/maxiyommi/signal-systems/tree/master/trabajo_practico#informe-t%C3%A9cnico)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}