plots/tifgan-figure-intro.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import ltfatpy\n",
    "import matplotlib as mpl\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 2**14\n",
    "M = 512\n",
    "a = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "signal = ltfatpy.signals.gspi.gspi()[0][:L]\n",
    "signal = ltfatpy.signals.greasy.greasy()[0][:L]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs2 = {'name': 'gauss', 'tfr': 4}\n",
    "rep2 = ltfatpy.dgtreal(signal, gs2, a, M)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "# ######### COPYRIGHT #########\n",
    "# Credits\n",
    "# #######\n",
    "#\n",
    "# Copyright(c) 2015-2018\n",
    "# ----------------------\n",
    "#\n",
    "# * `LabEx Archimède <http://labex-archimede.univ-amu.fr/>`_\n",
    "# * `Laboratoire d'Informatique Fondamentale <http://www.lif.univ-mrs.fr/>`_\n",
    "#   (now `Laboratoire d'Informatique et Systèmes <http://www.lis-lab.fr/>`_)\n",
    "# * `Institut de Mathématiques de Marseille <http://www.i2m.univ-amu.fr/>`_\n",
    "# * `Université d'Aix-Marseille <http://www.univ-amu.fr/>`_\n",
    "#\n",
    "# This software is a port from LTFAT 2.1.0 :\n",
    "# Copyright (C) 2005-2018 Peter L. Soendergaard <peter@sonderport.dk>.\n",
    "#\n",
    "# Contributors\n",
    "# ------------\n",
    "#\n",
    "# * Denis Arrivault <contact.dev_AT_lis-lab.fr>\n",
    "# * Florent Jaillet <contact.dev_AT_lis-lab.fr>\n",
    "#\n",
    "# Description\n",
    "# -----------\n",
    "#\n",
    "# ltfatpy is a partial Python port of the\n",
    "# `Large Time/Frequency Analysis Toolbox <http://ltfat.sourceforge.net/>`_,\n",
    "# a MATLAB®/Octave toolbox for working with time-frequency analysis and\n",
    "# synthesis.\n",
    "#\n",
    "# Version\n",
    "# -------\n",
    "#\n",
    "# * ltfatpy version = 1.0.16\n",
    "# * LTFAT version = 2.1.0\n",
    "#\n",
    "# Licence\n",
    "# -------\n",
    "#\n",
    "# This program is free software: you can redistribute it and/or modify\n",
    "# it under the terms of the GNU General Public License as published by\n",
    "# the Free Software Foundation, either version 3 of the License, or\n",
    "# (at your option) any later version.\n",
    "#\n",
    "# This program is distributed in the hope that it will be useful,\n",
    "# but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
    "# GNU General Public License for more details.\n",
    "#\n",
    "# You should have received a copy of the GNU General Public License\n",
    "# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n",
    "#\n",
    "# ######### COPYRIGHT #########\n",
    "\n",
    "\n",
    "\"\"\"Module of phase gradient computation\n",
    "\n",
    "Ported from ltfat_2.1.0/gabor/gabphasegrad.m\n",
    "\n",
    ".. moduleauthor:: Florent Jaillet\n",
    "\"\"\"\n",
    "\n",
    "from __future__ import print_function, division\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from ltfatpy.comp.comp_sigreshape_pre import comp_sigreshape_pre\n",
    "from ltfatpy.gabor.dgtlength import dgtlength\n",
    "from ltfatpy.gabor.gabwin import gabwin\n",
    "from ltfatpy.tools.postpad import postpad\n",
    "from ltfatpy.fourier.fftindex import fftindex\n",
    "from ltfatpy.comp.comp_sepdgt import comp_sepdgt\n",
    "from ltfatpy.fourier.pderiv import pderiv\n",
    "\n",
    "\n",
    "def modgabphasegrad(method, *args, **kwargs):\n",
    "    \"\"\"Phase gradient of the discrete Gabor transform\n",
    "\n",
    "    - Usage:\n",
    "\n",
    "        | ``(tgrad, fgrad, c) = gabphasegrad('dgt', f, g, a, M, L=None)``\n",
    "        | ``(tgrad, fgrad) = gabphasegrad('phase', cphase, a)``\n",
    "        | ``(tgrad, fgrad) = gabphasegrad('abs', s, g, a, difforder=4)``\n",
    "\n",
    "    - Input parameters:\n",
    "\n",
    "    :param str method: Method used to compute the phase gradient, see the\n",
    "        possible values below\n",
    "    :param numpy.ndarray f: (defined if ``method='dgt'``) Input signal\n",
    "    :param numpy.ndarray cphase: (defined if ``method='phase'``) Phase of a\n",
    "        :func:`~ltfatpy.gabor.dgt.dgt` of the signal\n",
    "    :param numpy.ndarray s: (defined if ``method='abs'``) Spectrogram of the\n",
    "        signal\n",
    "    :param numpy.ndarray g: (defined if ``method='dgt'`` or ``method='phase'``)\n",
    "        Window function\n",
    "    :param int a: (defined if ``method='dgt'`` or ``method='phase'`` or\n",
    "        ``method='abs'``) Length of time shift\n",
    "    :param int M: (defined if ``method='dgt'``) Number of channels\n",
    "    :param int L: (defined if ``method='dgt'``, optional) Length of transform\n",
    "        to do\n",
    "    :param int difforder: (defined if ``method='abs'``, optional) Order of the\n",
    "        centered finite difference scheme used to perform the needed numerical\n",
    "        differentiation\n",
    "\n",
    "    - Output parameters:\n",
    "\n",
    "    :returns: ``(tgrad, fgrad, c)`` if ``method='dgt'``, or ``(tgrad, fgrad)``\n",
    "        if ``method='phase'`` or ``method='abs'``\n",
    "    :rtype: tuple\n",
    "\n",
    "    :var numpy.ndarray tgrad: Instantaneous frequency\n",
    "    :var numpy.ndarray fgrad: Local group delay\n",
    "    :var numpy.ndarray c: Gabor coefficients\n",
    "\n",
    "    ``gabphasegrad`` computes the time-frequency gradient of the phase of the\n",
    "    :func:`~ltfatpy.gabor.dgt.dgt` of a signal. The derivative in time\n",
    "    **tgrad** is the instantaneous frequency while the frequency derivative\n",
    "    **fgrad** is the local group delay.\n",
    "\n",
    "    **tgrad** and **fgrad** measure the deviation from the current time and\n",
    "    frequency, so a value of zero means that the instantaneous frequency is\n",
    "    equal to the center frequency of the considered channel.\n",
    "\n",
    "    **tgrad** is scaled such that distances are measured in samples. Similarly,\n",
    "    **fgrad** is scaled such that the Nyquist frequency (the highest possible\n",
    "    frequency) corresponds to a value of ``L/2``.\n",
    "\n",
    "    The computation of **tgrad** and **fgrad** is inaccurate when the absolute\n",
    "    value of the Gabor coefficients is low. This is due to the fact the the\n",
    "    phase of complex numbers close to the machine precision is almost\n",
    "    random. Therefore, **tgrad** and **fgrad** may attain very large random\n",
    "    values when ``abs(c)`` is close to zero.\n",
    "\n",
    "    The computation can be done using three different methods:\n",
    "\n",
    "        =========== ===========================================================\n",
    "        ``'dgt'``   Directly from the signal.\n",
    "\n",
    "        ``'phase'`` From the phase of a :func:`~ltfatpy.gabor.dgt.dgt` of the\n",
    "                    signal. This is the classic method used in the phase\n",
    "                    vocoder.\n",
    "\n",
    "        ``'abs'``   From the absolute value of the\n",
    "                    :func:`~ltfatpy.gabor.dgt.dgt`. Currently this method works\n",
    "                    only for Gaussian windows.\n",
    "        =========== ===========================================================\n",
    "\n",
    "    ``(tgrad, fgrad, c) = gabphasegrad('dgt', f, g, a, M)`` computes the\n",
    "    time-frequency gradient using a :func:`~ltfatpy.gabor.dgt.dgt` of the\n",
    "    signal **f**. The :func:`~ltfatpy.gabor.dgt.dgt` is computed using the\n",
    "    window **g** on the lattice specified by the time shift **a** and the\n",
    "    number of channels **M**. The algorithm used to perform this calculation\n",
    "    computes several DGTs, and therefore this routine takes the exact same\n",
    "    input parameters as :func:`~ltfatpy.gabor.dgt.dgt`.\n",
    "\n",
    "    The window **g** may be specified as in :func:`~ltfatpy.gabor.dgt.dgt`. If\n",
    "    the window used is ``'gauss'``, the computation will be done by a faster\n",
    "    algorithm.\n",
    "\n",
    "    ``(tgrad, fgrad, c) = gabphasegrad('dgt', f, g, a, M)`` additionally\n",
    "    returns the Gabor coefficients ``c``, as they are always computed as a\n",
    "    byproduct of the algorithm.\n",
    "\n",
    "    ``(tgrad, fgrad) = gabphasegrad('phase', cphase, a)`` computes the phase\n",
    "    gradient from the phase **cphase** of a :func:`~ltfatpy.gabor.dgt.dgt` of\n",
    "    the signal. The original :func:`~ltfatpy.gabor.dgt.dgt` from which the\n",
    "    phase is obtained must have been computed using a time-shift of **a**.\n",
    "\n",
    "    ``(tgrad, fgrad) = gabphasegrad('abs', s, g, a)`` computes the phase\n",
    "    gradient from the spectrogram **s**. The spectrogram must have been\n",
    "    computed using the window **g** and time-shift **a**.\n",
    "\n",
    "    ``(tgrad, fgrad) = gabphasegrad('abs', s, g, a, difforder=ord)`` uses a\n",
    "    centered finite difference scheme of order ``ord`` to perform the needed\n",
    "    numerical differentiation. Default is to use a 4th order scheme.\n",
    "\n",
    "    Currently the 'abs' method only works if the window **g** is a Gaussian\n",
    "    window specified as a string or cell array.\n",
    "\n",
    "    .. seealso:: :func:`resgram`, :func:`gabreassign`,\n",
    "                 :func:`~ltfatpy.gabor.dgt.dgt`\n",
    "\n",
    "    - References:\n",
    "        :cite:`aufl95,cmdaaufl97,fl65`\n",
    "    \"\"\"\n",
    "\n",
    "    # NOTE: This function doesn't support the parameter lt (lattice type)\n",
    "    # supported by the corresponding octave function and the lattice used is\n",
    "    # seperable (square lattice lt = (0, 1)).\n",
    "\n",
    "    # NOTE: As in the octave version of this function, if needed, the\n",
    "    # undocumented optional keyword minlvl is available when using method=dgt.\n",
    "    # So it can be passed using a call of the following form:\n",
    "    # (tgrad, fgrad, c) = gabphasegrad('dgt', f, g, a, M, minlvl=val)\n",
    "\n",
    "    if not isinstance(method, str):\n",
    "        raise TypeError('First argument must be a str containing the method '\n",
    "                        'name, \"dgt\", \"phase\" or \"abs\".')\n",
    "\n",
    "    method = method.lower()\n",
    "\n",
    "    if method == 'dgt':\n",
    "        # ---------------------------  DGT method ------------------------\n",
    "\n",
    "        (f, g, a, M) = args\n",
    "\n",
    "        if 'L' in kwargs:\n",
    "            L = kwargs['L']\n",
    "        else:\n",
    "            L = None\n",
    "\n",
    "        if 'minlvl' in kwargs:\n",
    "            minlvl = kwargs['minlvl']\n",
    "        else:\n",
    "            minlvl = np.finfo(np.float64).tiny\n",
    "\n",
    "        # # ----- step 1 : Verify f and determine its length -------\n",
    "        # Change f to correct shape.\n",
    "\n",
    "        f, Ls, W, wasrow, remembershape = comp_sigreshape_pre(f, 0)\n",
    "\n",
    "        # # ------ step 2: Verify a, M and L\n",
    "        if not L:\n",
    "            # ----- step 2b : Verify a, M and get L from the signal length f---\n",
    "            L = dgtlength(Ls, a, M)\n",
    "        else:\n",
    "            # ----- step 2a : Verify a, M and get L\n",
    "            Luser = dgtlength(L, a, M)\n",
    "            if Luser != L:\n",
    "                raise ValueError('Incorrect transform length L = {0:d} '\n",
    "                                 'specified. Next valid length is L = {1:d}. '\n",
    "                                 'See the help of dgtlength for the '\n",
    "                                 'requirements.'.format(L, Luser))\n",
    "\n",
    "        # # ----- step 3 : Determine the window\n",
    "        g, info = gabwin(g, a, M, L)\n",
    "\n",
    "        if L < info['gl']:\n",
    "            raise ValueError('Window is too long.')\n",
    "\n",
    "        # # ----- step 4: final cleanup ---------------\n",
    "\n",
    "        f = postpad(f, L)\n",
    "\n",
    "        # # ------ algorithm starts --------------------\n",
    "\n",
    "        # Compute the time weighted version of the window.\n",
    "        hg = fftindex(L) * g\n",
    "\n",
    "        # The computation done this way is insensitive to whether the dgt is\n",
    "        # phaselocked or not.\n",
    "        c = comp_sepdgt(f, g, a, M, 0)\n",
    "\n",
    "        c_h = comp_sepdgt(f, hg, a, M, 0)\n",
    "\n",
    "        c_s = np.abs(c)**2\n",
    "\n",
    "        # Remove small values because we need to divide by c_s\n",
    "        c_s = np.maximum(c_s, minlvl*np.max(c_s))\n",
    "\n",
    "        # Compute the group delay\n",
    "        fgrad = np.real(c_h * c.conjugate() / c_s)\n",
    "\n",
    "        if info['gauss']:\n",
    "            # The method used below only works for the Gaussian window, because\n",
    "            # the time derivative and the time multiplicative of the Gaussian\n",
    "            # are identical.\n",
    "            tgrad = np.imag(c_h * c.conjugate() / c_s) / info['tfr']\n",
    "\n",
    "        else:\n",
    "            # The code below works for any window, and not just the Gaussian\n",
    "\n",
    "            dg = pderiv(g, difforder=float('inf')) / (2*np.pi)\n",
    "            c_d = comp_sepdgt(f, dg, a, M, 0)\n",
    "\n",
    "            # NOTE: There is a bug here in the original octave file as it\n",
    "            # contains a reshape that uses an undefined variable N.\n",
    "            # You can get the error with LTFAT 2.1.0 in octave by running for\n",
    "            # example:\n",
    "            # gabphasegrad('dgt', rand(16,1), rand(16,1), 4, 16)\n",
    "            #\n",
    "            # So we just comment out the corresponding line here, as it appears\n",
    "            # to be unneeded:\n",
    "            # c_d.shape = (M, N, W)\n",
    "\n",
    "            # Compute the instantaneous frequency\n",
    "            tgrad = -np.imag(c_d * c.conjugate() / c_s)\n",
    "\n",
    "        return (tgrad, fgrad, c)\n",
    "\n",
    "    elif method == 'phase':\n",
    "\n",
    "        # ---------------------------  phase method ------------------------\n",
    "\n",
    "        (cphase, a, M) = args\n",
    "\n",
    "        if not np.isrealobj(cphase):\n",
    "            raise TypeError(\"Input phase must be real valued. Use the 'angle'\"\n",
    "                            \" function to compute the argument of complex \"\n",
    "                            \"numbers.\")\n",
    "\n",
    "        # --- linear method ---\n",
    "        if cphase.ndim == 3:\n",
    "            M2, N, W = cphase.shape  # M2 is the number of channels from 0 to Nyquist\n",
    "        else:\n",
    "            M2, N = cphase.shape  # M2 is the number of channels from 0 to Nyquist\n",
    "        L = N*a\n",
    "        b = L/M\n",
    "\n",
    "# NOTE: The following code found in the original octave version of the function\n",
    "# hasn't been translated here to Python as it is not used:\n",
    "#        if 0\n",
    "#\n",
    "#            # This is the classic phase vocoder algorithm by Flanagan.\n",
    "#\n",
    "#            tgrad = cphase-circshift(cphase,[0,-1]);\n",
    "#            tgrad = tgrad- 2*pi*round(tgrad/(2*pi));\n",
    "#            tgrad = -tgrad/(2*pi)*L;\n",
    "#\n",
    "#            # Phase-lock the angles.\n",
    "#            TimeInd = (0:(N-1))*a;\n",
    "#            FreqInd = (0:(M-1))/M;\n",
    "#\n",
    "#            phl = FreqInd'*TimeInd;\n",
    "#            cphase = cphase+2*pi.*phl;\n",
    "#\n",
    "#            fgrad = cphase-circshift(cphase,[1,0]);\n",
    "#            fgrad = fgrad- 2*pi*round(fgrad/(2*pi));\n",
    "#            fgrad = -fgrad/(2*pi)*L;\n",
    "#\n",
    "#        end;\n",
    "\n",
    "        # This is the classic phase vocoder algorithm by Flanagan modified to\n",
    "        # yield a second order centered difference approximation.\n",
    "\n",
    "        # Forward approximation\n",
    "        tgrad_1 = cphase - np.roll(cphase, -1, axis=1)\n",
    "\n",
    "        # numpy round function doesn't use the same convention than octave for\n",
    "        # half-integers but the standard Python round function uses the same\n",
    "        # convention than octave, so we use the Python standard round in the\n",
    "        # computation below\n",
    "        octave_round = np.vectorize(round)\n",
    "        tgrad_1 = tgrad_1 - 2*np.pi*octave_round(tgrad_1/(2*np.pi))\n",
    "        # Backward approximation\n",
    "        tgrad_2 = np.roll(cphase, 1, axis=1) - cphase\n",
    "        tgrad_2 = tgrad_2 - 2*np.pi*octave_round(tgrad_2/(2*np.pi))\n",
    "        # Average\n",
    "        tgrad = (tgrad_1+tgrad_2) / 2\n",
    "\n",
    "        tgrad = -tgrad / (2*np.pi*a) * L\n",
    "\n",
    "        # Phase-lock the angles.\n",
    "        TimeInd = np.arange(N) * a\n",
    "        FreqInd = np.arange(M2) / M\n",
    "\n",
    "        phl = np.dot(FreqInd.reshape((FreqInd.shape[0], 1)),\n",
    "                     TimeInd.reshape((1, TimeInd.shape[0])))\n",
    "        # NOTE: in the following lines, the shape of phl is changed so that\n",
    "        # broadcasting works in the following addition with cphase when cphase\n",
    "        # has more than two dimensions\n",
    "        new_shape = np.ones((len(cphase.shape), ), dtype=int)\n",
    "        new_shape[0] = phl.shape[0]\n",
    "        new_shape[1] = phl.shape[1]\n",
    "        phl = phl.reshape(tuple(new_shape))\n",
    "        cphase = cphase + 2*np.pi*phl\n",
    "        cphase_to_aprox = np.concatenate([-cphase[1:2], cphase, -cphase[-2:-1]])\n",
    "\n",
    "        # Forward approximation\n",
    "        fgrad_1 = cphase_to_aprox - np.roll(cphase_to_aprox, -1, axis=0)\n",
    "        fgrad_1 = fgrad_1 - 2*np.pi*octave_round(fgrad_1/(2*np.pi))\n",
    "        fgrad_1 = fgrad_1[1:-1]\n",
    "        # Backward approximation\n",
    "        fgrad_2 = np.roll(cphase_to_aprox, 1, axis=0) - cphase_to_aprox\n",
    "        fgrad_2 = fgrad_2 - 2*np.pi*octave_round(fgrad_2/(2*np.pi))\n",
    "        fgrad_2 = fgrad_2[1:-1]\n",
    "        # Average\n",
    "        fgrad = (fgrad_1+fgrad_2)/2\n",
    "\n",
    "        fgrad = fgrad/(2*np.pi*b)*L\n",
    "\n",
    "        return (tgrad, fgrad)\n",
    "\n",
    "    elif method == 'abs':\n",
    "        # ---------------------------  abs method ------------------------\n",
    "\n",
    "        (s, g, a) = args\n",
    "\n",
    "        if 'difforder' in kwargs:\n",
    "            difforder = kwargs['difforder']\n",
    "        else:\n",
    "            difforder = 4\n",
    "\n",
    "        if not np.all(s >= 0.):\n",
    "            raise ValueError('First input argument must be positive or zero.')\n",
    "\n",
    "        if s.ndim == 3:\n",
    "            M, N, W = s.shape\n",
    "        else:\n",
    "            M, N = s.shape\n",
    "\n",
    "        L = N*a\n",
    "\n",
    "        g, info = gabwin(g, a, M, L)\n",
    "\n",
    "        if not info['gauss']:\n",
    "            raise ValueError('The window must be a Gaussian window (specified '\n",
    "                             'as a string or as a dictionary).')\n",
    "\n",
    "        b = L/M\n",
    "        # We must avoid taking the log of zero.\n",
    "        # Therefore we add the smallest possible\n",
    "        # number\n",
    "        logs = np.log(s + np.finfo(s.dtype).tiny)\n",
    "\n",
    "        # XXX REMOVE Add a small constant to limit the dynamic range. This\n",
    "        # should lessen the problem of errors in the differentiation for points\n",
    "        # close to (but not exactly) zeros points.\n",
    "        maxmax = np.max(logs)\n",
    "        tt = -11.\n",
    "        logs[logs < (maxmax+tt)] = tt\n",
    "\n",
    "        fgrad = pderiv(logs, 1, difforder)/(2*np.pi)*info['tfr']\n",
    "        tgrad = pderiv(logs, 0, difforder)/(2*np.pi*info['tfr'])\n",
    "\n",
    "        return (tgrad, fgrad)\n",
    "\n",
    "    else:\n",
    "        raise ValueError(\"First argument must be the method name, 'dgt', \"\n",
    "                         \"'phase' or 'abs'.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 2000;\n",
    "\n",
    "M = 2000;\n",
    "M2 = int(M/2+1)\n",
    "a = 1\n",
    "N = L/a\n",
    "b = L/M\n",
    "\n",
    "tfr = a/b\n",
    "\n",
    "f0 = np.arange(L)\n",
    "f3 = np.zeros([L])\n",
    "for kk in range(1,5,1):\n",
    "#     f3 = f3 + np.exp(2*np.pi*1j*f0*kk/20)\n",
    "    f3 = f3 + 2*kk*np.cos(2*np.pi*f0*kk/20)\n",
    "\n",
    "f4 = np.zeros([L])\n",
    "f4[100:L:400] = np.arange(0,5)*np.sqrt(L);\n",
    "f = f3+f4;\n",
    "f = np.real(f)\n",
    "# f = signal[:L]\n",
    "\n",
    "c = ltfatpy.dgtreal(f,{'name': 'gauss', 'tfr': 4},a,M)[0]\n",
    "\n",
    "\n",
    "tgrad, fgrad = modgabphasegrad('phase',np.angle(c),a, M)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unwrap_s(series):\n",
    "    res = [series[0]]\n",
    "    jump = 0\n",
    "    v = -np.diff(series)\n",
    "#     print(np.max(v))\n",
    "    for val,d in zip(series[1:], v):\n",
    "        if d>np.pi:\n",
    "            jump += 2*np.pi\n",
    "        elif d<-np.pi:\n",
    "            jump -= 2*np.pi\n",
    "        res.append(jump+val)\n",
    "    return np.array(res)\n",
    "\n",
    "def unwrap(mat):\n",
    "    matres = np.zeros(mat.shape)\n",
    "    for i, lin in enumerate(mat):\n",
    "        matres[i] = unwrap_s(lin)\n",
    "    return matres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mpl.rcParams['image.cmap'] =  'inferno'\n",
    "# plt.figure(figsize=(15,6));\n",
    "# plt.subplot(231);\n",
    "# ltfatpy.plotdgtreal(c,a,M,dynrange=60);\n",
    "# plt.title('Log magnitude')\n",
    "# plt.subplot(232);\n",
    "# ltfatpy.plotdgtreal(tgrad*(np.abs(c) > np.exp(-5)),a,M,clim=[-50,50], normalization='lin');\n",
    "# plt.title('Phase time-derivative')\n",
    "# plt.subplot(233);\n",
    "# ltfatpy.plotdgtreal(fgrad*(np.abs(c) > np.exp(-5)),a,M,clim=[-100,100], normalization='lin');\n",
    "# plt.title('Phase frequency-derivative')\n",
    "# plt.subplot(234);\n",
    "# ltfatpy.plotdgtreal(np.angle(c),a,M, normalization='lin');\n",
    "# plt.title('Phase')\n",
    "# plt.subplot(235);\n",
    "# ltfatpy.plotdgtreal(unwrap(np.angle(c)),a,M, normalization='lin');\n",
    "# plt.title('Phase unwrapped in time')\n",
    "# plt.subplot(236);\n",
    "# ltfatpy.plotdgtreal(unwrap(np.angle(c).T).T,a,M, normalization='lin');\n",
    "# plt.title('Phase unwrapped in frequency')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x180 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mpl.rcParams['image.cmap'] =  'inferno'\n",
    "plt.figure(figsize=(15,2.5));\n",
    "plt.subplot(131);\n",
    "ltfatpy.plotdgtreal(c,a,M,dynrange=60);\n",
    "plt.title('Log magnitude')\n",
    "# plt.subplot(142);\n",
    "# ltfatpy.plotdgtreal(unwrap(np.angle(c)),a,M, normalization='lin');\n",
    "# plt.title('Phase unwrapped in time')\n",
    "plt.subplot(132);\n",
    "ltfatpy.plotdgtreal(tgrad*(np.abs(c) > np.exp(-5)),a,M,clim=[-50,50], normalization='lin');\n",
    "plt.title('Phase time-derivative')\n",
    "plt.subplot(133);\n",
    "ltfatpy.plotdgtreal(fgrad*(np.abs(c) > np.exp(-5)),a,M,clim=[-100,100], normalization='lin');\n",
    "plt.title('Demodulated phase frequency-derivative')\n",
    "plt.savefig(\"intro-TF.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15, 2))\n",
    "plt.subplot(121)\n",
    "plt.plot(f)\n",
    "plt.xlim([0,L-1])\n",
    "plt.xlabel('Time (sample)')\n",
    "plt.title('Signal')\n",
    "\n",
    "plt.subplot(122)\n",
    "lim = [50,150-1]\n",
    "plt.plot(range(*lim),f[lim[0]:lim[1]])\n",
    "plt.xlim(lim)\n",
    "plt.xlabel('Time (sample)')\n",
    "plt.title('Zoom in')\n",
    "\n",
    "plt.savefig(\"intro-time.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}