Piano_ADSR.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bingsen-wang/EE-Fundamentals/blob/main/Piano_ADSR.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAMKoELNpsK-"
      },
      "source": [
        "<center><h1><b>Fundamental Frequencies of Piano with ADSR Envelope</h1></b>\n",
        "\n",
        "Dr. Bingsen Wang\n",
        "\n",
        "12/6/2023\n",
        "</center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hv0YxDrWU4h8"
      },
      "source": [
        "#Python Code\n",
        "The Python code generates the sound of varies waveforms.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "XeGsHYTt8IXU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "7dff2215-eef6-4a3f-8999-99d0eb7c6a2c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Moviepy - Building video PianoADSRsound.mp4.\n",
            "MoviePy - Writing audio in PianoADSRsoundTEMP_MPY_wvf_snd.mp3\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MoviePy - Done.\n",
            "Moviepy - Writing video PianoADSRsound.mp4\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Moviepy - Done !\n",
            "Moviepy - video ready PianoADSRsound.mp4\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 900x900 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "from logging import WARNING\n",
        "from os import linesep\n",
        "import matplotlib\n",
        "from scipy.io.wavfile import write\n",
        "from moviepy.editor import *\n",
        "from numpy import linspace,cos,pi,sin,arccos,fft,angle,abs,clip,int16,array,heaviside\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.patches import Rectangle\n",
        "from matplotlib.collections import PatchCollection\n",
        "from matplotlib import animation,rc\n",
        "rc('animation', html='jshtml')\n",
        "plt.rcParams.update({\"font.family\" : \"serif\",\"mathtext.fontset\" : \"cm\"})\n",
        "\n",
        "def adsr(t,*args):\n",
        "  T_total,a1,a2,a3,d1,d2,d3=args\n",
        "  t1 = d1*T_total\n",
        "  t2 = t1+d2*T_total\n",
        "  t3 = t2+d3*T_total\n",
        "  t4 = T_total\n",
        "  at = a1/t1*t*(heaviside(t,0)-heaviside(t-t1,0)) #attack\n",
        "  if t1==t2:\n",
        "    dt=0\n",
        "  else:\n",
        "    dt = ((a2-a1)/(t2-t1)*(t-t1)+a1)*(heaviside(t-t1,0)-heaviside(t-t2,0)) #decay\n",
        "  if t2==t3:\n",
        "    st=0\n",
        "  else:\n",
        "    st = ((a3-a2)/(t3-t2)*(t-t2)+a2)*(heaviside(t-t2,0)-heaviside(t-t3,0)) #sustain\n",
        "  if t3==t4:\n",
        "    rt=0\n",
        "  else:\n",
        "    rt = (-a3/(t4-t3)*(t-t3)+a3)*(heaviside(t-t3,0)-heaviside(t-t4,0)) #release\n",
        "  return at+dt+st+rt\n",
        "\n",
        "def x(f,t,*args):\n",
        "  return adsr(t,*args)*sin(2*pi*f*t)\n",
        "\n",
        "def layout_88keys(ax):\n",
        "  kww = 1/52 #key width for white keys\n",
        "  kwb = 1/52*0.6 #key width for white keys\n",
        "  whiteKeys = []\n",
        "  for i in range(52): #52 white keys\n",
        "      whiteKeys.append(Rectangle((i*kww, 0.2), kww ,0.8 ))\n",
        "  blackKeys = []\n",
        "  for i in range(36): #36 black keys\n",
        "    ii=i%5\n",
        "    k=int(i/5)\n",
        "    if ii<1:\n",
        "      blackKeys.append(Rectangle(((ii+1+k*7)*kww - .5*kwb, 0.6), kwb ,0.4 ))\n",
        "    elif ii<3:\n",
        "      blackKeys.append(Rectangle(((ii+2+k*7)*kww - .5*kwb, 0.6), kwb ,0.4 ))\n",
        "    else:\n",
        "      blackKeys.append(Rectangle(((ii+3+k*7)*kww - .5*kwb, 0.6), kwb ,0.4 ))\n",
        "  pc1 = PatchCollection(whiteKeys, facecolor='w',edgecolor='k',lw=0.8)\n",
        "  pc2 = PatchCollection(blackKeys, facecolor='k',edgecolor='k',lw=0)\n",
        "  ax.add_collection(pc1)\n",
        "  ax.add_collection(pc2)\n",
        "  return\n",
        "\n",
        "# parameters\n",
        "Nf = 100 # number of frames per key\n",
        "sr = 44100 #sampling rate\n",
        "tpf = 2 # time per key\n",
        "kw = 1/52 #key width\n",
        "keys_lst,keys_freq =([], [])\n",
        "for i in range(9):\n",
        "  if i==0:\n",
        "    keys_lst.extend(['A0','A♯0/B♭0','B0'])\n",
        "  elif i==8:\n",
        "    keys_lst.extend(['C8'])\n",
        "  else:\n",
        "    keys_lst.extend(['C'+str(i), 'C♯'+str(i)+'/D♭'+str(i),\n",
        "                     'D'+str(i), 'D♯'+str(i)+'/E♭'+str(i),\n",
        "                     'E'+str(i),\n",
        "                     'F'+str(i), 'F♯'+str(i)+'/G♭'+str(i),\n",
        "                     'G'+str(i), 'G♯'+str(i)+'/A♭'+str(i),\n",
        "                     'A'+str(i),'A♯'+str(i)+'/B♭'+str(i),\n",
        "                     'B'+str(i)])\n",
        "for i in range(len(keys_lst)):\n",
        "  keys_freq.append(27.5*(2**(i/12)))\n",
        "key_names = ['C4','C♯4/D♭4','D4','E4','F4','G4','A4','B4'] #keys to play\n",
        "\n",
        "\n",
        "#time and frequency series\n",
        "t = linspace(0,1,1024*124) #time series for plotting\n",
        "#ADSR envelope\n",
        "aa = [tpf,1,1,0.2,.02,0,.95]\n",
        "adsr_piano = adsr(t,*aa)\n",
        "tsnd=linspace(0,tpf,int(tpf*sr)) #time series for sampling\n",
        "\n",
        "xtsnd_lst=[]\n",
        "soundTrack=[]\n",
        "for i in range(len(key_names)):\n",
        "  ki=keys_lst.index(key_names[i]) #key index\n",
        "  xtsnd = x(keys_freq[ki],tsnd,*aa)\n",
        "  xtsnd_lst.append(xtsnd)\n",
        "  soundTrack.extend(int16(xtsnd*32767))\n",
        "\n",
        "fig = plt.figure(figsize=(9,9))\n",
        "fig.tight_layout()\n",
        "ax_frame = [[[0, 0.25, 1, .7], [-.02,1.1], [-1.1,1.1]], #sine waveform\n",
        "            [[0, 0,   1, .2],  [-.02,1.1], [-.0,1]], # keyboard layout\n",
        "            ]# [pos-boundary, xlim, ylim] for subplots\n",
        "ax_lbl=[['$f(t)$', '$t$'],\n",
        "        ['$F_{fft}$', '$t$'],\n",
        "        ] #variables for yx axes of each subplot\n",
        "title_lst = ['','']\n",
        "clst=['b','r'] #colors of lines\n",
        "tx_titles = []\n",
        "ax_lst=[] #axis list or the list of subplots\n",
        "ylabel_lst=[] #y-labels to update\n",
        "for k in range(len(ax_frame)):\n",
        "  xn,xm,yn,ym = ax_frame[k][1]+ax_frame[k][2]\n",
        "  ax=fig.add_axes(ax_frame[k][0],xlim=[xn,xm], ylim=[yn,ym],fc='none') #no fc\n",
        "  ax.axis('off') #turn off axis frames\n",
        "  ax_lst.append(ax)\n",
        "  if k==0:\n",
        "    ax.annotate(\"\", (xm, 0), (xn, 0),arrowprops={'arrowstyle':\"->\"}) #x-axis\n",
        "    ax.annotate(\"\", (0,ym), (0,yn),arrowprops={'arrowstyle':\"->\"}) #y-axis\n",
        "    line_wave = ax.plot([], [],color=clst[k], lw=0.5)[0]\n",
        "    ax.text(xm-.02,0,ax_lbl[k][-1],size=24,va='top',ha='right') #x-axis label\n",
        "    ylabel_lst.append(ax.text(0.01,ym,ax_lbl[k][0],size=24,va='bottom',color=clst[k])) #y label\n",
        "    tx_titles.append(ax.text(0.5,ax_frame[k][2][1]+0.1,title_lst[k],va='top',ha='center',size=20))\n",
        "key_active = ax_lst[1].arrow(0.5*kw,0,0,0.2,)\n",
        "# animation function. This is called sequentially\n",
        "def animate(i):\n",
        "  # print(i)\n",
        "  m=i%Nf\n",
        "  n=int(i/Nf)\n",
        "  ki= keys_lst.index(key_names[n]) #key index\n",
        "  global key_active\n",
        "  ii=ki%12\n",
        "  k=int(ki/12)\n",
        "  key_active.remove()\n",
        "  if ii<3:\n",
        "    key_active = ax_lst[1].arrow(0.5*(1+ii+14*k)*kw,0,0,0.2,width=0.25*kw,color='r',length_includes_head=True)\n",
        "  elif ii<8:\n",
        "    key_active = ax_lst[1].arrow(0.5*(2+ii+14*k)*kw,0,0,0.2,width=0.25*kw,color='r',length_includes_head=True)\n",
        "  else:\n",
        "    key_active = ax_lst[1].arrow(0.5*(3+ii+14*k)*kw,0,0,0.2,width=0.25*kw,color='r',length_includes_head=True)\n",
        "  line_wave.set_data(tsnd[:m*int(len(tsnd)/Nf)]/tpf,xtsnd_lst[n][:m*int(len(tsnd)/Nf)])\n",
        "  tx_titles[0].set_text('Key '+keys_lst[ki]+', $'+str(round(keys_freq[ki],3))+'$ Hz')\n",
        "  return\n",
        "layout_88keys(ax_lst[1])\n",
        "\n",
        "\n",
        "anim = animation.FuncAnimation(fig, animate, frames=len(key_names)*Nf, interval=500)\n",
        "# anim #uncomment to generate animation in the output area\n",
        "# to save the animation, uncomment the following three lines\n",
        "fn = \"PianoADSR\"\n",
        "writervideo = animation.FFMpegWriter(fps=Nf/tpf)\n",
        "anim.save(fn+'noSound.mp4', writer=writervideo,dpi = 120)\n",
        "write(fn+'.wav', sr,array(soundTrack))\n",
        "audio = AudioFileClip(fn+'.wav',fps=sr)\n",
        "video = VideoFileClip(fn+'noSound.mp4')\n",
        "final = video.set_audio(audio)\n",
        "# final.ipython_display()\n",
        "final.write_videofile(fn+\"sound.mp4\")"
      ]
    }
  ]
}