Lab01 - Análise de Sinal.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import LogNorm\n",
    "\n",
    "from IPython.display import Audio\n",
    "from ipywidgets import interactive\n",
    "\n",
    "import numpy as np\n",
    "import scipy\n",
    "\n",
    "import soundfile as sf\n",
    "from utils import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Índice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Sinais](#sinais)\n",
    "    1.1 [Ondas Harmônicas](#ondas)\n",
    "    1.2 [Sinais compostos](#compostos)\n",
    "2. [Análise de Sinal](#analise)\n",
    "    2.1 [Amostragem](#amostragem)\n",
    "    2.2 [Transformada de Fourier](#Fourier)\n",
    "    2.3 [Resolução](#resolução)\n",
    "    2.4 [Curiosidade  - Imagens escondidas](#curiosidade)\n",
    "3. [Explorações](#exp)\n",
    "4. [Epílogo](#epi)\n",
    "5. [Links](#link)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Sinais \n",
    "\n",
    "<a id=\"sinais\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando ligamos o receptor de VLF ao microfone do nosso computador e gravamos o sinal que está a ser recebido pela placa de som, o que registamos será semelhante ao que gravámos no seguinte ficheiro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio(\"media/vlf_sample.wav\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver que sinal é este:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/vlf_sample.wav\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Amostra de uma gravação de VLF', x_label='tempo (segundos)', y_label='amplitude', fig_size=(14,7))\n",
    "\n",
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O sinal representado na figura anterior é muito complexo. Ele é resultado da soma de muitos sinais, provenientes de fontes distintas, detectados pelo nosso receptor. Uns provenientes de emissores militares ou emissores de sinal horário, outros de fontes de ruído domésticas como electrodomésticos, lâmpadas fluorescentes ou até mesmo motores.  \n",
    "\n",
    "Quando estamos a fazer observações de rádio, regra geral, pretendemos isolar uma das fontes, de forma a centrar a análise na informação dela registada. Para isso, temos que escolher uma representação do sinal recebido com a qual sejamos capazes de diferenciar as suas várias componentes, permitindo isolar posteriormente o que se pretende.\n",
    "\n",
    "Com esse fim em vista, este primeiro guião pretende fazer uma (muito) breve introdução/revisão de alguns conceitos e técnicas de análise de sinal que nos permitirá desenvolver algumas atividades com os sinais gravados numa série de observações feitas em VLF."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Ondas harmônicas\n",
    "\n",
    "<a id=\"ondas\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sinais periódicos podem ser descritos, ou aproximados, por ondas harmónicas. As mesmas são descritas por uma expressão da forma: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "x(t)=A \\sin (\\omega t + \\phi)\n",
    "$$\n",
    "\n",
    "onde:\n",
    "* $A$ - amplitude\n",
    "* $\\omega$ - frequência angular $(rad/s)$\n",
    "* $\\phi$ - constante de fase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Associado a uma onda harmónica podemos obter:\n",
    "\n",
    "* $T=\\frac{2\\pi}{\\omega}$ - período da onda $(s)$\n",
    "* $f=\\frac{1}{T}=\\frac{\\omega}{2\\pi}$ - frequência (número de ciclos por segundo) $(s^{-1},Hz)$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É mais fácil se visualizarmos um exemplo particular:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "freq = 1 #hz - ciclos por segundo\n",
    "amplitude = 3\n",
    "time_to_plot = 2 # segundos\n",
    "sample_rate = 100 # Taxa de amostragem - amostras por segundo - (Nota: mais à frente iremos analisar melhor este parâmetro...)\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # tempo\n",
    "\n",
    "signal = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "plt.plot(t, signal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_wave(freq = 1,phase=0,ampl = 3):\n",
    "\n",
    "    time_to_plot = 2 # segundos\n",
    "    sample_rate = 200 # Taxa de amostragem \n",
    "    num_samples = sample_rate * time_to_plot\n",
    "\n",
    "    t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "    signal = ampl * np.sin(2*np.pi*freq*t+phase)  \n",
    "\n",
    "    setup_graph(x_label='time (in seconds)', y_label='amplitude', title='time domain', ylim = 5)\n",
    "    \n",
    "    plt.plot(t, signal) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interactive(plot_wave, freq=(1.0,10.0),phase=(0,2*np.pi),ampl = (1,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ouvir uns senos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_rate = 44100 # Taxa de amostragem \n",
    "time_to_plot = 1.5    # segundos\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "freq = 250  # frequência - 200 Hz\n",
    "signal1 = np.sin(2*np.pi*freq*t) # pure sine wave at 250 Hz\n",
    "\n",
    "Audio(signal1, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_to_plot = 1.5    # segundos\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "freq = 500  # frequência \n",
    "signal2 = np.sin(2*np.pi*freq*t)                \n",
    "\n",
    "Audio(signal2, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**Ex.**: Crie $3$ segundos de um sinal sonoro de frequência $f=1500Hz$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "time_to_plot = 1.5    # seconds\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "\n",
    "freq = 1500  # frequency \n",
    "signal3 = np.sin(2*np.pi*freq*t)                \n",
    "\n",
    "# load a NumPy array\n",
    "Audio(signal3, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "**Ex.**: Crie $2$ segundos de um sinal sonoro de frequência $f=17kHz$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "time_to_plot = 1.5    # seconds\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "\n",
    "freq = 17000  # frequency \n",
    "signal3 = np.sin(2*np.pi*freq*t)                \n",
    "\n",
    "# load a NumPy array\n",
    "Audio(signal3, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos escrever os comandos anteriores numa única função e explorar um pouco mais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def audio_wave(f1=220.0):\n",
    "    sample_rate = 44100 # taxa de amostragem\n",
    "    time_to_plot = 4    # segundos\n",
    "    times = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "    \n",
    "    signal = np.sin(2*np.pi*f1*times)\n",
    "    display(Audio(data=signal, rate=sample_rate))\n",
    "    return signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = interactive(audio_wave, f1=(10.0,20000.0))\n",
    "display(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ex.**: Efetue um varrimento no intervalo de frequências anteriores e determine os valores mínimos e máximos que o seu ouvido consegue detetar.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Sinais compostos\n",
    "<a id=\"compostos\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A soma de vários sinais simples forma um sinal composto. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_to_plot = 3 # segundo\n",
    "sample_rate = 4410 # amostras por segundo\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "\n",
    "freq1 = 500  # frequency \n",
    "freq2 = 730  # frequency \n",
    "freq3 = 910  # frequency \n",
    "\n",
    "signal1 = 1.5*np.sin(2*np.pi*freq1*t)   \n",
    "signal2 = 2*np.sin(2*np.pi*freq2*t)                \n",
    "signal3 = 0.5*np.sin(2*np.pi*freq3*t)                \n",
    "\n",
    "signal = signal1+signal2+signal3\n",
    "\n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "plt.plot(t[0:441], signal[0:441])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio(signal, rate=sample_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os sons que ouvimos no nosso dia a dia são compostos por muitas frequências diferentes..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ora vejamos um exemplo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio(\"media/cow.wav\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/cow.wav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Mugir de uma vaca', x_label='tempo (segundos)', y_label='amplitude', fig_size=(12,6))\n",
    "\n",
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos escolher uma janela temporal mais pequena para melhor ver a forma deste sinal sonoro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Mugir de uma vaca', x_label='time (in seconds)', y_label='amplitude', fig_size=(12,6))\n",
    "\n",
    "# Gráfico entre os instante de tempo t1 e t2 (segundos)\n",
    "ti = 0.5\n",
    "tf = 0.6\n",
    "\n",
    "# Determinação dos indices correspondentes no vetor contendo o sinal \n",
    "i1, i2 = int(ti * sample_rate), int(tf * sample_rate)\n",
    "\n",
    "plt.plot(time_array[i1:i2], input_signal[i1:i2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora até podemos observar algumas semelhanças com o gráfico do nossso primeiro sinal composto ... Seria bom se conseguissemos saber quais as frequências base que constituem (ou predominam) neste sinal... Será possível?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iremos ver que sim! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Análise de Sinal\n",
    "<a id=\"analise\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Amostragem\n",
    "\n",
    "<a id=\"amostragem\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando estamos a fazer a fazer um registo de sinais acontece que quem está a efectuar observações, vai registar os valores dos sinais recebidos com um computador e este não regista continuamente os valores do sinal, mas sim, efectua registos, espaçados por um dado intervalo de tempo $\\Delta$, dos sinais que está a receber. \n",
    "\n",
    "A este processo chamamos amostragem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vejamos um exemplo. Suponhamos que o nosso detector está a receber uma onda com frequência $f_0=3Hz$ descrita por \n",
    "$x(t)= 2\\sin(6\\pi t)$, mas que só efectuamos registos do valor do sinal de $0.125$ em $0.125$ segundos ($\\Delta=0.125s$), ou seja, uma frequência de amostragem de $f_a = \\frac{1}{0.125} s= 8Hz$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#--- simulação do sinal contínuo:\n",
    "\n",
    "\n",
    "freq = 3 #hz - ciclos por segundo\n",
    "amplitude = 3\n",
    "time_to_plot = 1 # segundos\n",
    "\n",
    "n_pontos = 1024 # \n",
    "\n",
    "num_samples = n_pontos * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*n_pontos), endpoint=False) # tempo\n",
    "\n",
    "signal = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "plt.plot(t, signal)\n",
    "\n",
    "\n",
    "# ----Determinação dos pontos amostrados do sinal \n",
    "\n",
    "sample_rate = 8 # taxa de amostragem\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # tempo\n",
    "\n",
    "amostra = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou seja, depois de gravarmos $1s$ de deste sinal, ficamos com um conjunto discreto de $8$ pontos com informação do sinal original:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou seja, um vetor com $8$ entradas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amostra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos colocar o problema ao contrário e questionarmos-nos se com este conjunto discreto de pontos conseguimos reconstruir o sinal de onde foram obtidos.\n",
    "\n",
    "No exemplo anterior, ao conjunto de valores registados podemos de facto associar um conjunto arbitrário de sinusoides. A frequência de amostragem\n",
    "$$\n",
    "f_a=\\frac{1}{\\Delta} s^{-1}\n",
    "$$\n",
    "foi de $8Hz$ e por consequência, vamos poder ajustar aos pontos uma qualquer sinosoide que tenha uma frequência igual à frequência $f_0$ mais um múltiplo inteiro da frequência de amostragem $f_a$, como, por exemplo, mostra a figura seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- Pontos amostrados do sinal \n",
    "\n",
    "sample_rate = 8 # taxa de amostragem\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # tempo\n",
    "\n",
    "amostra = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')\n",
    "\n",
    "\n",
    "# ---- Ajuste de vários sinais aos pontos amostrados\n",
    "\n",
    "n_pontos = 1024 # \n",
    "\n",
    "num_samples = n_pontos * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*n_pontos), endpoint=False) # tempo\n",
    "\n",
    "signal = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "plt.plot(t, signal,'-', c='b', alpha=0.75)\n",
    "\n",
    "for k in [1,2]:\n",
    "    signal = amplitude * np.sin(2*np.pi*(freq+k*sample_rate)*t)  \n",
    "\n",
    "    plt.plot(t, signal,'--', c='b', alpha=0.5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se analisarmos com cuidado podemos ver o porquê disto acontecer. Tomemos, por exemplo, o valor da quinta medição da figura anterior. Este registo foi efectuado ao segundo $4 \\times \\frac{1}{8}= 0.5$, e tem como valor\n",
    "\n",
    "$$\n",
    "x(4\\Delta)= 2\\sin(2\\pi \\times 3\\times  (4 \\Delta)).\n",
    "$$\n",
    "\n",
    "Agora, se considerarmos que a onda têm uma frequência igual a $f_0+m f_a$, onde $m=0,\\pm 1, \\pm 2,\\ldots$ vamos obter \n",
    "\n",
    "$$\n",
    "\\phi(4\\Delta)= 2\\sin(2\\pi(f_0+mf_a)4\\Delta)= 2\\sin(2\\pi f_0 4 \\Delta+ 2\\pi m f_a 4\\Delta),\n",
    "$$\n",
    "como $f_a=1 / \\Delta$, vemos que $f_a\\times \\Delta = 1$ e podemos simplificar a expressão anterior obtendo\n",
    "\n",
    "$$\n",
    "\\phi(4\\Delta)=  2\\sin(2\\pi f_0 4 \\Delta+ 4 m 2\\pi)=2\\sin(2\\pi f_0 4 \\Delta),\n",
    "$$\n",
    "uma vez que a função seno é uma função $2\\pi$ periódica. Assim, concluímos que o valor de $\\phi(4\\Delta)$ é igual ao valor de $x(4\\Delta)$. \n",
    "\n",
    "É fácil ver que o facto de termos considerado o quinto registo não particulariza em nada o resultado e que generalizando temos que a sequência de valores obtidos por amostragem com uma frequência $f_a Hz$, de uma onda com frequência $f_0Hz$, são indistinguíveis dos de uma amostra obtida de uma onde com frequência $(f_0+mf_a)Hz$, com $m=0,\\pm 1, \\pm 2,\\ldots$, tal como mostra a figura anterior. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por outro lado, um resultado muito importante da teoria da análise de sinal, o [teorema de amostragem de Nyquist](https://pt.wikipedia.org/wiki/Teorema_da_amostragem_de_Nyquist%E2%80%93Shannon),  garante que um sinal continuo pode ser completamente recuperado de uma sequência de valores obtidos por amostragem, desde que esta seja efectuada com uma taxa de aquisição duas vezes maior à frequência máxima do sinal registado, $f_a \\geqslant 2\\times f_{\\max}$.\n",
    "Por outras palavras, o teorema afirma que, ao efectuar amostragem de um sinal com uma frequência de $f_a Hz$, apenas se conseguirá discernir sinais de frequências menores ou iguais a $f_a /2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que o resultado é correcto pode ser observado com um exemplo. Contráriamente ao exemplo anterior, onde a frequência  da onda era inferior a taxa de amostragem, consideremos que efectuamos um registo de uma onda de $8Hz$ com uma taxa de amostragem de $6Hz$. Como facilmente observamos pela figura seguinte:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#--- simulação do sinal contínuo:\n",
    "\n",
    "\n",
    "freq = 8 #hz - ciclos por segundo\n",
    "amplitude = 3\n",
    "time_to_plot = 1 # segundos\n",
    "\n",
    "n_pontos = 1024 # \n",
    "\n",
    "num_samples = n_pontos * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*n_pontos), endpoint=False) # tempo\n",
    "\n",
    "signal = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "plt.plot(t, signal)\n",
    "\n",
    "\n",
    "# ----Determinação dos pontos amostrados do sinal \n",
    "\n",
    "sample_rate = 6 # taxa de amostragem\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # tempo\n",
    "\n",
    "amostra = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparando com o que foi dito anteriormente, vemos que neste exemplo as condições do teorema não são verificadas e efectivamente temos $8Hz> \\frac{6}{2}=3Hz$. Logo, ao reconstruir o sinal, este aparece-nos como tendo sido obtido de uma onda de $2Hz$ que, esta sim, apresenta uma frequência menor que metade da frequência de amostragem, $3Hz$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---- Pontos amostrados do sinal \n",
    "\n",
    "sample_rate = 6 # taxa de amostragem\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # tempo\n",
    "\n",
    "amostra = amplitude * np.sin(2*np.pi*freq*t)  \n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "\n",
    "plt.plot(t, amostra, 'o', c='r')\n",
    "\n",
    "\n",
    "# ---- Ajuste de vários sinais aos pontos amostrados\n",
    "\n",
    "n_pontos = 1024 # \n",
    "\n",
    "num_samples = n_pontos * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*n_pontos), endpoint=False) # tempo\n",
    "\n",
    "\n",
    "signal = amplitude * np.sin(2*np.pi*2*t)  \n",
    "\n",
    "plt.plot(t, signal,'--', c='b', alpha=0.7)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este limite imposto pela frequência de amostragem está sempre presente em  todas as observações de VLF/LF, uma vez que as placas de som dos computadores actuais só suportam taxas de 44000, 48000, 96000 e 19200 amostras/segundo, permitindo assim frequências máximas de observação de 22000, 24000, 48000 e 96000$Hz$ respectivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Transformada de [Fourier](https://pt.wikipedia.org/wiki/Jean_Baptiste_Joseph_Fourier)\n",
    "\n",
    "<a id=\"Fourier\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suponhamos agora que temos uma amostra de um sinal composto. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_to_plot = 2 # segundos\n",
    "sample_rate = 1024 # amostras por segundo\n",
    "\n",
    "num_samples = sample_rate * time_to_plot\n",
    "\n",
    "t = np.linspace(0, time_to_plot, int(time_to_plot*sample_rate), endpoint=False) # time variable\n",
    "\n",
    "freq1 = 200  # frequência 1 \n",
    "freq2 = 350  # frequência 2\n",
    "freq3 = 500  # frequência 3\n",
    "\n",
    "sinal1 = 1.5*np.sin(2*np.pi*freq1*t)   \n",
    "sinal2 = 2*np.sin(2*np.pi*freq2*t)                \n",
    "sinal3 = 0.5*np.sin(2*np.pi*freq3*t)                \n",
    "\n",
    "sinal = sinal1+sinal2+sinal3\n",
    "\n",
    "setup_graph(x_label='tempo (segundos)', y_label='amplitude', title=' ', fig_size=(12,6))\n",
    "plt.plot(t[0:241], sinal[0:241])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, gerados $3$ segundos de um sinal, a uma taxa de amostragem de $1024Hz$, iremos obter  $2048$ pontos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fft_out = np.fft.rfftn(sinal)\n",
    "\n",
    "fft_mag = np.abs(fft_out)/len(fft_out)\n",
    "num_samples = len(sinal)\n",
    "\n",
    "rfreqs = sample_rate/2*np.linspace(0,1,num_samples//2+1)\n",
    "\n",
    "setup_graph(title='FFT', x_label='Frequência', y_label='Amplitude', fig_size=(12,6))\n",
    "plt.plot(rfreqs, fft_mag)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observando o gráfico anterior podemos constatar que o sinal analisado tem $3$ frequências base de $200$, $350$ e $500Hz$, com amplitudes de $1.5$, $2$, e $0.5$ respetivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voltemos agora a um sinal mais complexo com frequências a variar no tempo (Ficheiro gerado no site- [audiocheck](https://www.audiocheck.net/audiocheck_dtmf.php)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio(\"media/tele_15924.wav\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vejamos a sua forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/tele_15924.wav\")\n",
    "print('A taxa de amostragem do ficheiro é de %i Hz' %sample_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(input_signal)/sample_rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "\n",
    "setup_graph(title='sound', x_label='time (in seconds)', y_label='amplitude', fig_size=(12,6))\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fft_out = np.fft.rfft(input_signal)\n",
    "\n",
    "fft_mag = np.abs(fft_out)/len(fft_out)\n",
    "num_samples = len(input_signal)\n",
    "\n",
    "rfreqs=sample_rate/2*np.linspace(0,1,num_samples//2+1)\n",
    "\n",
    "setup_graph(title='FFT', x_label='Frequência', y_label='Amplitude', fig_size=(12,6))\n",
    "plt.plot(rfreqs, fft_mag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O sinal anterior é composto por tons de duas frequências - [DTMF](https://pt.wikipedia.org/wiki/DTMF), da sigla em inglês de “Dual-Tone Multi-Frequency”. Em concreto, podemos constatar que é formado por $5$ tons diferentes, contendo $6$ frequências distintas: $697Hz$, $770Hz$,  $852Hz$, $1209Hz$,\t$1336Hz$ e $1477Hz$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como aplicámos uma transformada de Fourier à totalidade do sinal, conseguimos identificar as frequências distintas que o sinal contem, mas não nos é possível perceber como variam estas frequências ao longo do tempo\n",
    "\n",
    "Uma forma de conseguir isso, consiste em aplicar uma transformada de Fourier, não à totalidade do sinal que \n",
    "estamos a analisar, mas sim a blocos sucessivos do mesmo.\n",
    "\n",
    "Para analisarmos as variações de frequência em função do tempo podemos recorrer a um [espetrograma](https://en.wikipedia.org/wiki/Spectrogram) do sinal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', NFFT=256)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver o sinal e o seu espetrograma em simultâneo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(12, 8))\n",
    "\n",
    "ax1 = fig.add_subplot(211)\n",
    "ax1.set_title('Raw wave of ')\n",
    "ax1.set_ylabel('Amplitude')\n",
    "\n",
    "Tempgrav= float(len(input_signal))/float(sample_rate)\n",
    "\n",
    "ax1.plot(np.arange(0,Tempgrav,1/float(sample_rate)), input_signal)\n",
    "ax1.autoscale(enable=True, axis='both', tight=True)\n",
    "\n",
    "ax2 = fig.add_subplot(212)\n",
    "ax2.imshow(Sxx, aspect='auto', origin='lower', \n",
    "           extent=[times.min(), times.max(), freqs.min(), freqs.max()])\n",
    "ax2.set_yticks(freqs[::10])\n",
    "ax2.set_xticks(times[::10])\n",
    "ax2.set_title('Spectrogram of ')\n",
    "ax2.set_ylabel('Freqs in Hz')\n",
    "ax2.set_xlabel('Seconds')\n",
    "ax2.autoscale(enable=True, axis='both', tight=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desta forma conseguimos perceber ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Resolução\n",
    "\n",
    "<a id=\"resolução\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> *Não podemos simultâneamente detalhar a nossa análise no tempo e na frequência. Se pretendermos uma resolução temporal elevada, temos de abdicar de resolução em frequência e vice-versa.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No espetrograma anterior, definimos uma janela temporal com $256$ pontos. Como o sinal foi gravado com uma taxa de amostragem de $8000 Hz$, cada janela corresponde a:\n",
    "\n",
    "$$\\textrm{resolução temporal}:\\;\\;\\;\\frac{\\textrm{tamanho da janela}}{\\textrm{taxa de amostragem}} = \\frac{256}{8000}= 0.032\\; \n",
    "\\textrm{  segundos}$$\n",
    "\n",
    "O recriproco dá-nos informação sobre a resolução em frequência:\n",
    "\n",
    "$$\\textrm{resolução frequência}:\\;\\;\\;\\frac{\\textrm{taxa de amostragem}}{\\textrm{tamanho da janela}} = \\frac{8000}{256}= 31.25\\; \n",
    "\\textrm{  Hz}$$\n",
    "\n",
    "Assim, podemos ver que a resolução em frequência é inversamente proporcional à resolução no tempo, e logo, nunca podemos aumentar uma sem diminuir a outra. Qual a melhor resolução em tempo/frequência depende do sinal e da aplicação em vista, podendo ser obtida por tentativa e experiência.\n",
    "\n",
    "\n",
    "Vejamos alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', noverlap=0, NFFT=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', noverlap=0, NFFT=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', noverlap=0, NFFT=512)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', noverlap=0, NFFT=1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx, freqs, times, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', noverlap=0, NFFT=2048)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reparar que quando aumentamos o número de pontos da nossa janela temporal, `NFFT` no função `plt.specgram`, vamos aumentando a resolução em termos de frequência, mas perdendo resolução temporal. No último espetrograma, este efeito leva à perda de informação relevante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Curiosidade  - Imagens escondidas\n",
    "\n",
    "<a id=\"curiosidade\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagens escondida na 2ª faixa do album [\"Windowlicker\"](https://en.wikipedia.org/wiki/Windowlicker) de Aphex Twin. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio('media/equation9sec.wav') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/equation9sec.wav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(10,6))\n",
    "\n",
    "Sxx,freqs, times, im = plt.specgram(np.sum(input_signal, axis=1), Fs=sample_rate, NFFT=512, cmap='YlGnBu_r')\n",
    "\n",
    "plt.axis('tight')\n",
    "ax = plt.gca()\n",
    "ax.set_yscale('log')\n",
    "ax.set_ylim(100, 22000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Explorações\n",
    "\n",
    "<a id=\"exp\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analise as amostras de som seguintes efetuando para cada uma delas um gráfico do espectro e espectrograma. \n",
    "\n",
    "Consegue identificar as frequências predominantes nos repetivos sinais?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio('media/crickets.wav') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/crickets.wav\")\n",
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "setup_graph(title='sound', x_label='time (in seconds)', y_label='amplitude', fig_size=(12,6))\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio('media/housefly.wav') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/housefly.wav\")\n",
    "\n",
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "setup_graph(title='sound', x_label='time (in seconds)', y_label='amplitude', fig_size=(12,6))\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Epílogo\n",
    "<a id=\"epi\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora que já temos mais ferramentas, vamos voltar ao sinal inicial para fazermos uma breve análise do mesmo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_signal, sample_rate = sf.read(\"media/vlf_sample.wav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Amostra de uma gravação de VLF', x_label='time (in seconds)', y_label='amplitude', fig_size=(12,6))\n",
    "time_array = np.arange(0, len(input_signal)/sample_rate, 1/sample_rate)\n",
    "plt.plot(time_array, input_signal)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fft_out = np.fft.rfft(input_signal)\n",
    "\n",
    "fft_mag = np.abs(fft_out)/len(fft_out)\n",
    "\n",
    "num_samples = len(input_signal)\n",
    "\n",
    "rfreqs=sample_rate/2*np.linspace(0,1,num_samples//2+1)\n",
    "\n",
    "setup_graph(title='FFT', x_label='FFT Bins', y_label='magnitude', fig_size=(12,6))\n",
    "plt.plot(rfreqs, fft_mag)\n",
    "plt.axis('tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fazendo o espectrograma do mesmo obtemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "setup_graph(title='Spectrogram', x_label='tempo(segundos)', y_label='Frequência', fig_size=(12,6))\n",
    "\n",
    "Sxx,f, t, im = plt.specgram(input_signal, Fs=sample_rate, scale='linear', NFFT=1024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparentemente ainda não conseguimos observar nada de interessante, mas avancemos para o próximo guião e vamos descobrir..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nota"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste guião analisámos sinais gravados através da placa de som de um computador. De notar que, embora estejam todos gravados no mesmo formato, em ficheiros wav, temos presentes sinais sonoros e sinais de rádio. Apesar da análise que deles fizémos ser semelhante, eles correspondem a fenómenos físicos diferentes, sendo muito importante fazer a sua distinção quando estamos a trabalhar com [ondas sonoras](https://pt.wikipedia.org/wiki/Som) ou [ondas electromagnéticas](https://pt.wikipedia.org/wiki/Radia%C3%A7%C3%A3o_eletromagn%C3%A9tica). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Links \n",
    "\n",
    "<a id=\"links\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Sound Analysis with the Fourier Transform and Python](https://github.com/calebmadrigal/FourierTalkOSCON)\n",
    "\n",
    "2. [Image to Spectrogram](http://www.devrand.org/2013/04/image-to-spectrogram.html)\n",
    "\n",
    "3. [Hidden images in spectrograms](http://scipython.com/blog/hidden-images-in-spectrograms/)\n",
    "\n",
    "4. [implement-the-spectrogram-from-scratch](https://fairyonice.github.io/implement-the-spectrogram-from-scratch-in-python.html)\n",
    "\n",
    "5. [decode-the-dial-up-sounds-using-spectrogram](https://fairyonice.github.io/decode-the-dial-up-sounds-using-spectrogram.html)\n",
    "\n",
    "6. [Free Engineering Lectures - The Short Time Fourier Transform ](https://www.youtube.com/watch?v=g1_wcbGUcDY&feature=youtu.be&t=713)\n",
    "\n",
    "7. [Construção de recetores rádio como introdução à Física das Telecomunicações - parte I ](https://www.spf.pt/magazines/GFIS/113/913)\n",
    "\n",
    "8. [Construção de recetores rádio como introdução à Física das Telecomunicações - parte II ](https://www.spf.pt/magazines/GFIS/114/931)\n",
    "\n",
    "9. [Ouvindo o emissor SAQ de Grimeton ](https://www.spf.pt/magazines/GFIS/118/969)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "vlf",
   "language": "python",
   "name": "vlf"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}