ExampleDigitalSignalProcessingFilters.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Signal Processing Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from stream import StreamArray, run\n",
    "from example_operators import sliding_window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GENERATE WAVE FOR TESTING\n",
    "\n",
    "def generate_trignometric_wave(\n",
    "        func, frequency, max_amplitude,\n",
    "        phase_shift, sample_rate, time_duration):\n",
    "    num_samples = int(time_duration * sample_rate)\n",
    "    time_sequence = np.linspace(0, time_duration, num_samples, endpoint=False)\n",
    "    return max_amplitude*func(2*np.pi*(frequency*time_sequence) + phase_shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GENERATE WAVE FOR TESTING\n",
    "\n",
    "def generate_sine_wave(\n",
    "        frequency, max_amplitude, phase_shift,\n",
    "        sample_rate, time_duration):\n",
    "    return generate_trignometric_wave(\n",
    "        np.sin, frequency, max_amplitude, phase_shift,\n",
    "        sample_rate, time_duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GENERATE WAVE FOR TESTING\n",
    "\n",
    "def generate_cosine_wave(\n",
    "        frequency, max_amplitude, phase_shift,\n",
    "        sample_rate, time_duration):\n",
    "    return generate_trignometric_wave(\n",
    "        np.cos, frequency, max_amplitude, phase_shift,\n",
    "        sample_rate, time_duration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GENERATE WAVE FOR TESTING\n",
    "\n",
    "def generate_square_wave(\n",
    "        frequency, max_amplitude,\n",
    "        phase_shift, sample_rate, time_duration):\n",
    "    num_samples = time_duration * sample_rate\n",
    "    time_sequence = np.linspace(0, time_duration, num_samples, endpoint=False)\n",
    "    def func(v):\n",
    "        return - np.sign((v - v.astype(int)) - 0.45)\n",
    "    return max_amplitude*func(frequency*time_sequence + phase_shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Filter(object):\n",
    "    \"\"\"\n",
    "    The base class of filters that filter input streams to\n",
    "    produce output streams.\n",
    "    Uses a, b parameters from scipy.signal or other libraries.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    a, b: list of float\n",
    "      Parameters that define a filter.\n",
    "      For a Finite Impulse Response filter, a is None.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    N: int\n",
    "      the length of b\n",
    "    x: array of float\n",
    "      The N most recent values of the input stream.\n",
    "      x[0] is the most recent value. For example if\n",
    "      the current value of in_stream is:\n",
    "      in_stream[j-N+1, ... j] then\n",
    "      x[k] = in_stream[j - k]\n",
    "      x is initialized to 0.\n",
    "    y: array of float\n",
    "      The N most recent values of the output stream.\n",
    "      Initialized to 0.\n",
    "      y and x have the same structure.\n",
    "\n",
    "    \"\"\"\n",
    "    def __init__(self, b, a=None):\n",
    "        self.b = np.array(b)\n",
    "        if a is not None:\n",
    "            self.a = np.array(a)\n",
    "        self.N = len(b)\n",
    "        self.x = np.zeros(self.N)\n",
    "        self.y = np.zeros(self.N)\n",
    "\n",
    "    def filter_element(self, element):\n",
    "        \"\"\"\n",
    "        This is the standard filter calculation.\n",
    "        The formula depends on the type of filter.\n",
    "        The formula must be entered for the subclass\n",
    "        derived from the base Filter class.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        element: float or int\n",
    "          The next element of the stream.\n",
    "          \n",
    "        Returns\n",
    "        -------\n",
    "          The next element of the output stream.\n",
    "        \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# BANDPASS FIR (FINITE IMPULSE RESPONSE) FILTER.\n",
    "\n",
    "class BP_FIR(Filter):\n",
    "    \"\"\"\n",
    "    Bandpass FIR (Finite Impulse Response) Filter.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "       b: float or int\n",
    "          Filter parameters obtained from scipy.signal.butter\n",
    "          or other sources.\n",
    "          Filter parameters are a, b. For this filter a is None.\n",
    "\n",
    "    \"\"\"\n",
    "    def __init__(self, b):\n",
    "        Filter.__init__(self, b)\n",
    "\n",
    "    def filter_element(self, element):\n",
    "        \"\"\"\n",
    "        Parameter\n",
    "        ---------\n",
    "        element: an element of the input stream\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "            float: the next element of the output stream.\n",
    "        \n",
    "        Uses a standard formula for FIR filters.\n",
    "        x is an array of the most recent values of the input stream.\n",
    "        x is specified in the parent class: Filter\n",
    "\n",
    "        \"\"\"\n",
    "        # Shift x to the right by 1 to make x[0] empty\n",
    "        self.x[1:] = self.x[:- 1]\n",
    "        self.x[0] = element\n",
    "        return np.sum(self.b * self.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BP_IIR(Filter):\n",
    "    \"\"\"\n",
    "    Bandpass IIR (Infinite Impulse Response) Filter.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "       b, a: float or int\n",
    "          Filter parameters obtained from scipy.signal.butter\n",
    "          or other sources.\n",
    "\n",
    "    \"\"\"\n",
    "    def __init__(self, b, a):\n",
    "        Filter.__init__(self, b, a)\n",
    "\n",
    "    def filter_element(self, element, **kwargs):\n",
    "        \"\"\"\n",
    "        Parameter\n",
    "        ---------\n",
    "        element: element of the input stream\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "            float: the output sequence is the dsp filter of\n",
    "                   the input stream.\n",
    "        \n",
    "        Uses a standard formula for IIR filters.\n",
    "        Shifts x, y to the right by 1 to accomodate\n",
    "        new entry for input x, and then updates y[0].\n",
    "\n",
    "        \"\"\"\n",
    "        # Insert a new value -- element --- into x[0].\n",
    "        # First shift x to the right by 1 to make x[0] empty.\n",
    "        self.x[1:] = self.x[:- 1]\n",
    "        self.x[0] = element\n",
    "        \n",
    "        # Insert a new value into y[0].\n",
    "        # First shift y to the right by 1 to make y[0] empty.\n",
    "        self.y[1:] = self.y[:-1]\n",
    "        # Compute new value for y[0]\n",
    "        self.y[0] = self.b[0] * self.x[0]\n",
    "        self.y[0] += sum(self.b[1:]*self.x[1:] -\n",
    "                         self.a[1:]*self.y[1:])\n",
    "        return self.y[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# See scipy.signal for a library of filters.\n",
    "from scipy.signal import butter, firwin\n",
    "def butter_bandpass(lowcut, highcut, fs, order=2):\n",
    "    \"\"\"\n",
    "    Returns filter parameters b, a given input parameters.\n",
    "    Butterworth IIR filter.\n",
    "    butter() is from scipy.signal\n",
    "\n",
    "    \"\"\"\n",
    "    lowcut, highcut = lowcut*2.0/fs, highcut*2.0/fs\n",
    "    b, a = butter(order, [lowcut, highcut], btype='band')\n",
    "    return b, a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fir_bandpass(lowcut, highcut, fs):\n",
    "    \"\"\"\n",
    "    Returns filter parameters b given input parameters.\n",
    "    FIR filter.\n",
    "    firwin() is from scipy.signal\n",
    "\n",
    "    \"\"\"\n",
    "    lowcut, highcut =lowcut*2.0/fs, highcut*2.0/fs\n",
    "    b =  firwin(\n",
    "        numtaps=201, cutoff = [lowcut, highcut],\n",
    "        window='blackmanharris', pass_zero=False)\n",
    "    return b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SET PARAMETERS OF FILTER\n",
    "# fs: sample rate\n",
    "# order: order of the filter\n",
    "# lowcut, highcut: lower and upper thresholds of a bandpass\n",
    "# filter.\n",
    "fs, order, lowcut, highcut = 50.0, 4, 1.0, 4.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SPECIFY WAVEFORM PARAMETERS\n",
    "low_frequency=0.1,\n",
    "medium_frequency = 2.0\n",
    "high_frequency = 10.0\n",
    "max_amplitude=1.0, \n",
    "phase_shift=0.0, \n",
    "sample_rate=fs,\n",
    "time_duration=10.0\n",
    "\n",
    "# GENERATE WAVEFORMS LOW, MEDIUM, HIGH FREQUENCY AND\n",
    "# SUM OF WAVEFORMS.\n",
    "wave_data_low_frequency = generate_sine_wave(\n",
    "    low_frequency, max_amplitude, phase_shift,\n",
    "    fs, time_duration)\n",
    "wave_data_medium_frequency = generate_sine_wave(\n",
    "    medium_frequency, max_amplitude, phase_shift,\n",
    "    fs, time_duration)\n",
    "wave_data_high_frequency = generate_sine_wave(\n",
    "    high_frequency, max_amplitude, phase_shift,\n",
    "    fs, time_duration)\n",
    "wave_data_total = (wave_data_low_frequency +\n",
    "                   wave_data_medium_frequency +\n",
    "                   wave_data_high_frequency)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TEST BANDPASS IIR FILTER\n",
    "\n",
    "from example_operators import single_item\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "x = StreamArray('x')\n",
    "y = StreamArray('y')\n",
    "\n",
    "# Create bandpass filter \n",
    "b, a = butter_bandpass(lowcut, highcut, fs, order)\n",
    "filter_object = BP_IIR(b, a)\n",
    "\n",
    "def func(element, out_stream):\n",
    "    v = filter_object.filter_element(element)\n",
    "    out_stream.append(v)\n",
    "    \n",
    "# Create agent\n",
    "single_item(in_stream=x, func=func, out_stream=y)\n",
    "#BP_IIR(b, a).filter_stream(in_stream=x, out_stream=y)\n",
    "x.extend(wave_data_total)\n",
    "run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# LOOK AT INPUT WAVEFORM\n",
    "print(len(x.recent_values()))\n",
    "plt.plot(x.recent_values()[25:75])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# LOOK AT FILTERED WAVEFORM\n",
    "\n",
    "print (len(y.recent_values()))\n",
    "plt.plot(y.recent_values()[25:75])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WINDOW_DOT_PRODUCT\n",
    "\n",
    "# Create agent with input stream, output stream, and \n",
    "# keyword argument, multiplicand_vector.\n",
    "# Elements of the output stream are dot products of window and multiplicand_vector.\n",
    "# window is from a sliding window that slides forward with a step_size of 1.\n",
    "# The length of window is set to that of multiplicand_vector.\n",
    "\n",
    "class WindowDotProduct(object):\n",
    "    def __init__(self, in_stream, out_stream, multiplicand_vector):\n",
    "        self.in_stream = in_stream\n",
    "        self.out_stream = out_stream\n",
    "        self.multiplicand_vector = multiplicand_vector\n",
    "        # Create the agent\n",
    "        sliding_window(in_stream=self.in_stream,\n",
    "                       window_size=len(self.multiplicand_vector), step_size=1,\n",
    "                       func=self.func)\n",
    "                       \n",
    "    # The callback function\n",
    "    def func(self, window):\n",
    "        self.out_stream.append(np.dot(window, self.multiplicand_vector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TEST BANDPASS FIR FILTER\n",
    "\n",
    "def bandpass_FIR(in_stream, out_stream, b):\n",
    "    \"\"\"\n",
    "    Creates an agent that executes a\n",
    "    FIR (Finite Impulse Response) filter of\n",
    "    in_stream to produce out_stream using\n",
    "    filter parameter b.\n",
    "    Parameters\n",
    "    ----------\n",
    "       in_stream: Stream\n",
    "       out_stream: Stream\n",
    "       b: array\n",
    "    Note\n",
    "    ----\n",
    "    out_stream[n] = sum over k in [0, M] of b[k]*in_stream[n-k]\n",
    "    Therefore, setting k to M-k:\n",
    "    out_stream[n] = sum over k in [0, M] of b[M-k]*in_stream[n-M+k]\n",
    "    So, out_stream[n] is the dot product of the reverse of b and\n",
    "    the in_stream window consisting of: in_stream[n-M]... in_stream[M].\n",
    "\n",
    "    \"\"\"\n",
    "    # Instantiate an instantiate of the WindowDotProduct class.\n",
    "    WindowDotProduct(in_stream, out_stream, multiplicand_vector=np.flip(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = StreamArray('x')\n",
    "y = StreamArray('y')\n",
    "\n",
    "b = fir_bandpass(lowcut, highcut, fs)\n",
    "bandpass_FIR(in_stream=x, out_stream=y, b=b)\n",
    "\n",
    "x.extend(wave_data_total)\n",
    "run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# LOOK AT FILTERED WAVEFORM\n",
    "plt.plot(y.recent_values()[25:75])\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}