GDET3 Diskrete Faltung GUI.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "# Copyright 2019 Institut für Nachrichtentechnik, RWTH Aachen University\n",
    "%matplotlib widget\n",
    "\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, interactive, fixed, Layout, HBox, VBox\n",
    "from IPython.display import clear_output, display, HTML\n",
    "\n",
    "from scipy import signal # convolution\n",
    "\n",
    "from ient_nb.ient_plots import *\n",
    "from ient_nb.ient_signals import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "    <img src=\"ient_nb/figures/rwth_ient_logo@2x.png\" style=\"float: right;height: 5em;\">\n",
    "</div>\n",
    "\n",
    "# Demonstrator Diskrete Faltung\n",
    "\n",
    "Zum Starten: Im Menü: Run <span class=\"fa-chevron-right fa\"></span> Run All Cells auswählen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Einleitung\n",
    "Ein diskretes Signal ist ein Signal, welches nur für ganzzahlige Werte $n$ einen Wert annimmt und sonst Null ist. Auch für die Elementarsignale existieren jeweils zeitdiskrete Versionen. Diese Demonstration nutzt einige davon. \n",
    "\n",
    "Diskrete Signale können genau wie kontinuierliche Signale gefaltet werden. \n",
    "Im Folgenden wird die diskrete Faltung\n",
    "$$g(n)=s(n)\\ast h(n)=\\sum_{m=-\\infty}^{\\infty}s(m)h(n-m)$$\n",
    "betrachtet und veranschaulicht.\n",
    "\n",
    "## Demo\n",
    "In der Demonstration stehen verschiedene Signale für $s(n)$ und $h(n)$ zur Verfügung. \n",
    "$s(n)$ und $h(n)$ können gewählt werden als zeitdiskrete Varianten von:\n",
    "* Dirac-Impuls  $\\delta(n)$\n",
    "* Sprungfunktion  $\\epsilon(n)$\n",
    "* Exponentialimpuls  $\\epsilon(n)\\cdot\\mathrm{b}^{n}$\n",
    "* Rechteckfunktion  $rect(n) = \\epsilon(n+M)-\\epsilon(n-M-1)$\n",
    "\n",
    "Unter der folgenden Abbildungen können diese Funktionen ausgewählt werden und, falls gewünscht, eine Verschiebung um $n_0$ eingestellt werden. Für den Exponentialimpuls ist ebenfalls der Faktor $b$ variierbar, für die Rechteckfunktion ist die Breite $M$ wählbar. In der Abbildung können dann die gewählten Funktionen mit ihren Parametern betrachtet werden.\n",
    "\n",
    "Zusätzlich zu Elementarsignalen kann auch eine frei definierbare Funktion $s_0(t)$ zur Faltung verwendet werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s_0 = lambda n: gauss(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "n = np.linspace(-10, 10, 21)\n",
    "m = np.linspace(-40, 40, 81) # m Achse\n",
    "n0 = -2\n",
    "\n",
    "container_s = container_h = None\n",
    "\n",
    "def convolution(s, h):\n",
    "    # Convolve s and h numerically\n",
    "    return signal.convolve(s(m), h(m), mode='same')\n",
    "\n",
    "signal_types = {'Dirac-Impuls'       : lambda n, b, M: np.where(n==0, 1, 0),\n",
    "                'Sprungfunktion'     : lambda n, b, M: np.where(n>=0, 1, 0),\n",
    "                'Exponentialimpuls'  : lambda n, b, M: unitstep(n)*b**n,\n",
    "                'Rechteck'           : lambda n, b, M: unitstep(n+M) - unitstep(n-M-1),\n",
    "                'Eigene Kreation s0(n)' : lambda n, b, M: s_0(n)\n",
    "               }\n",
    "\n",
    "fig0, axs0 = plt.subplots(1, 2, figsize=(ient_fig_width, ient_fig_width/4));\n",
    "def update_signals(s_type, s_n0, h_type, h_n0, b_s, b_h, M_s, M_h):\n",
    "    # show widgets according to chosen s and h\n",
    "    w_b_s.layout.visibility = 'visible' if s_type == 'Exponentialimpuls' else 'hidden'; w_M_s.layout.visibility = 'visible' if s_type == 'Rechteck' else 'hidden'\n",
    "    w_b_h.layout.visibility = 'visible' if h_type == 'Exponentialimpuls' else 'hidden'; w_M_h.layout.visibility = 'visible' if h_type == 'Rechteck' else 'hidden'\n",
    "    \n",
    "    # calculate s(m-n0) and h(m-n0)\n",
    "    global s, h, gn, container_s, container_h # reused in second interactive plot\n",
    "    s = lambda m: signal_types[s_type]((m-s_n0), b_s, M_s); # s(m-n0)\n",
    "    h = lambda m: signal_types[h_type]((m-h_n0), b_h, M_h); # h(m-n0)\n",
    "    gn = convolution(s, h) # numerical convolution\n",
    "    \n",
    "    # update second plot if existing\n",
    "    try:\n",
    "        global n0\n",
    "        update_plot(n0)\n",
    "    except NameError:\n",
    "        pass\n",
    "    \n",
    "    # display s and h plots\n",
    "    if container_s is None:\n",
    "        # plot s\n",
    "        ax = axs0[0]; \n",
    "        container_s = ient_stem(ax, m, s(m), 'rwth')\n",
    "        ax.set_xticks(np.arange(-10, 11, step=2))\n",
    "        ax.set_xlabel(r'$\\rightarrow n$'); ax.set_ylabel(r'$\\uparrow s(n)$')\n",
    "        ax.set_xlim([-10.9, 10.9]); ient_axis(ax); ient_grid(ax);\n",
    "    \n",
    "        # plot h\n",
    "        ax = axs0[1]; \n",
    "        container_h = ient_stem(ax, m, h(m), 'rwth')\n",
    "        ax.set_xticks(np.arange(-10, 11, step=2))\n",
    "        ax.set_xlabel(r'$\\rightarrow n$'); ax.set_ylabel(r'$\\uparrow h(n)$')\n",
    "        ax.set_xlim(axs0[0].get_xlim()); ient_axis(ax); ient_grid(ax);\n",
    "\n",
    "    else:\n",
    "        ient_stem_set_ydata(container_s, s(m))\n",
    "        ient_stem_set_ydata(container_h, h(m))\n",
    "        \n",
    "    # update limits\n",
    "    ient_update_ylim(axs0[0], s(m), .19)\n",
    "    ient_update_ylim(axs0[1], h(m), .19)\n",
    "\n",
    "# Widgets\n",
    "w_s_type=widgets.Dropdown(options=list(signal_types.keys()), description=r'Wähle $s(n)$:', style=ient_wdgtl_style)\n",
    "w_s_n0=widgets.FloatSlider(min=-5, max=5, value=0, step=1, description=r'Verschiebung $n_0$', style=ient_wdgtl_style)\n",
    "w_h_type=widgets.Dropdown(options=list(signal_types.keys()), description=r'Wähle $h(n)$:', style=ient_wdgtl_style)\n",
    "w_h_n0=widgets.FloatSlider(min=-5, max=5, value=0, step=1, description=r'Verschiebung $n_0$', style=ient_wdgtl_style)\n",
    "w_b_s=widgets.FloatSlider(min=.1, max=1, value=.5, step=.1, description=r'$b_s$', style=ient_wdgtl_style)\n",
    "w_b_h=widgets.FloatSlider(min=.1, max=1, value=.5, step=.1, description=r'$b_h$', style=ient_wdgtl_style)\n",
    "w_M_s=widgets.FloatSlider(min=0, max=5, value=1, step=1, description=r'$M_s$', style=ient_wdgtl_style)\n",
    "w_M_h=widgets.FloatSlider(min=0, max=5, value=1, step=1, description=r'$M_h$', style=ient_wdgtl_style)\n",
    "w = widgets.interactive(update_signals, s_type=w_s_type, s_n0=w_s_n0, h_type=w_h_type, h_n0 =w_h_n0, b_s=w_b_s, b_h=w_b_h, M_s=w_M_s, M_h=w_M_h)\n",
    "display(widgets.HBox((widgets.VBox((w_s_type, w_s_n0, w_b_s, w_M_s)), widgets.VBox((w_h_type, w_h_n0, w_b_h, w_M_h), layout=Layout(margin='0 0 0 100px'))))); w.update();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anschließend kann hier die Faltung $g(n)=s(n)\\ast h(n)$ der zuvor eingestellten Funktionen betrachtet werden.\n",
    "\n",
    "Über den Schieberegler kann der Wert für $n$ verändert werden und die Funktion $h(n-m)$ bewegt sich in der oberen Grafik. In der unteren Grafik ist das resultierende Ausgangssignal $g(n)$ zu sehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "fig, axs = plt.subplots(2, 1, **ient_landscape)\n",
    "global n0\n",
    "container_ss = container_hh = container_gg = None\n",
    "@widgets.interact(n=widgets.FloatSlider(min=-10, max=10, value=n0, step=1, description='Verschiebung $n$', style=ient_wdgtl_style))\n",
    "def update_plot(n):\n",
    "    global container_ss, container_hh, container_gg\n",
    "    global n0\n",
    "    n0 = n\n",
    "    n_ind = np.where(m>=n); n_ind = n_ind[0][0]; g_plot = gn.copy(); g_plot[n_ind+1:] = 0; # hide g(n') with n'>n\n",
    "    if container_gg is None:\n",
    "        # plot g = s * h\n",
    "        ax = axs[1]\n",
    "        container_gg = ient_stem(ax, m, g_plot)\n",
    "    \n",
    "    if container_ss is not None:\n",
    "        # update data\n",
    "        ient_stem_set_ydata(container_ss, s(m))\n",
    "        ient_stem_set_ydata(container_hh, h(n-m))\n",
    "        ient_stem_set_ydata(container_gg, g_plot)\n",
    "        \n",
    "        # update labels\n",
    "        ax = axs[0]\n",
    "        ax.texts[0].set_x(n); ax.lines[3].set_xdata([n,n])\n",
    "        ax = axs[1]\n",
    "        ax.texts[0].set_x(n); ax.lines[2].set_xdata([n,n]); ax.texts[0].set_y(np.min(ax.get_ylim()));\n",
    "        ax.lines[3].set_xdata([n, n]); ax.lines[3].set_ydata([0, gn[n_ind]]);\n",
    "    else:\n",
    "        # plot s and h\n",
    "        ax = axs[0];  # s and h axis\n",
    "        container_ss = ient_stem(ax, m, s(m),  'grun', label=r'$s(m)$')\n",
    "        container_ss[0].set_markerfacecolor('none'); \n",
    "        container_ss[0].set_markersize(8); \n",
    "        container_ss[0].set_markeredgewidth(2);\n",
    "        container_hh = ient_stem(ax, m, h(n-m), 'rwth', label=r'$h(n-m)$')\n",
    "        \n",
    "        # configure axis settings\n",
    "        ax.set_xlabel(r'$\\rightarrow m$');\n",
    "        ax.set_xlim([-10.2,10.2]); \n",
    "        ax.set_xticks(np.arange(-10, 11, step=2))\n",
    "        ax.legend(); ient_grid(ax); ient_axis(ax);\n",
    "        ient_annotate_xtick(ax, r'$n$', n, -0.1, 'rwth', 15);  # mark n on m axis\n",
    "        \n",
    "        # configure g axis settings\n",
    "        ax = axs[1]\n",
    "        ax.set_xlabel(r'$\\rightarrow n$'); ax.set_ylabel(r'$\\uparrow g(n)=s(n)\\ast h(n)$');\n",
    "        ax.set_xlim(axs[0].get_xlim())\n",
    "        ax.set_xticks(np.arange(-10, 11, step=2))\n",
    "        ient_grid(ax); ient_axis(ax);\n",
    "        ient_annotate_xtick(ax, r'$n$', n, np.min(ax.get_ylim()), 'black', 15);\n",
    "        ax.plot([n, n], [0, gn[n_ind]], 'ko--', lw=1);\n",
    "        \n",
    "    # update limits\n",
    "    if np.all(gn>0):\n",
    "        gn[0] = 0\n",
    "    ient_update_ylim(axs[0], np.concatenate([s(m), h(n-m)]), .19, ymax = 1e3)\n",
    "    ient_update_ylim(axs[1], gn, np.max(np.abs(gn))/10, ymax = 1e3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aufgaben\n",
    "Wähle zunächst für $s(n)$ den Dirac-Impuls und für $h(n)$ verschiedene Funktionen aus. \n",
    "* Beobachte das Faltungsergebnis. Ab welchem $n$ ist ein Ergebnis zu sehen? Was passiert, wenn du eine der Funktionen verschiebst?\n",
    "* Wie sieht das Ergebnis für zwei Rechteckfunktionen aus? Wie für zwei Sprungfunktionen?\n",
    "Wähle nun zwei Rechteckfunktionen mit $M>2$. \n",
    "* Bewege den Schieberegler langsam von links nach rechts. An welcher Stelle tritt der erste Wert des Faltungsergebnisses auf? Wie hoch ist dieser Wert?\n",
    "* Bewege den Schieberegler eins weiter nach rechts. Nun überlagern sich die beiden Signalen an zwei Positionen. Wie hoch ist der Wert des Faltungsergebnisses nun?\n",
    "* Bewege den Schieberegler weiter, bis die beiden Funktionen sich vollständig überlagern. Was passiert, wenn nun der Schieberegler weiter nach rechts geschoben wird? Wie hoch ist der Wert des Faltungsergebnisses? Wie berechnen sich die Höhen des Faltungsergebnisses?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources) (OER). Feel free to use the notebook for your own purposes. The code is licensed under the [MIT license](https://opensource.org/licenses/MIT). \n",
    "\n",
    "Please attribute the work as follows: \n",
    "*Christian Rohlfing, Emin Kosar, Übungsbeispiele zur Vorlesung \"Grundgebiete der Elektrotechnik 3 - Signale und Systeme\"*, gehalten von Jens-Rainer Ohm, 2019, Institut für Nachrichtentechnik, RWTH Aachen University."
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}