multiple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If you are working on a new environmnet, you might want to run the following cell to make sure that the MIDIUtil library has been installed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install midiutil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import the variables and definitions from the accompanying music_def.py file "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This file contains all the definitions for the widgets and some constant variables that I had set\n",
    "\n",
    "from music_def import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "\n",
    "### Define your key, scale, and octave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3c21bc6966fc4809be1697f7a170b557",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What key do you want your piece to be in?'), Dropdown(layout=Layout(border_bottom=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "db46c48e80264c88b626a7891fe29261",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What scale do you want to map to?'), Dropdown(layout=Layout(border_bottom='2px sol…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c3ad8b5a870447ee82157a6989a61c46",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='Which octave do you want to assign your notes to? \\n Middle C is in the 4th'), Dro…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First choice with regards to music\n",
    "\n",
    "# Run this cell to get the widgets to show\n",
    "display(vert_note)\n",
    "display(vert_scale)\n",
    "display(vert_octave)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------------------------------------------------\n",
      "You have chosen the Key, C which corresponds to the index: \n",
      " 0\n",
      "The chosen scale is a  minor-harmonic which corresponds to the midi indices: \n",
      " (0, 2, 3, 5, 7, 8, 11, 12)\n",
      "The octave that you have chose to map your notes onto is: \n",
      "  4\n",
      "If this is incorrect, please check with the drop down menu above and run this cell again.\n",
      "--------------------------------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# Processing inputs from cell above\n",
    "\n",
    "note_index = notes_to_index[def_note.value]\n",
    "scale_num = scale_index[def_scale.value]\n",
    "scale_clean = all_scales[scale_num]\n",
    "\n",
    "# Printing outputs to allow user to check whether they are happy with their choices\n",
    "\n",
    "print(\n",
    "    \"--------------------------------------------------------------------------------------------------------------------------\"\n",
    ")\n",
    "\n",
    "print(\n",
    "    \"You have chosen the Key,\",\n",
    "    def_note.value,\n",
    "    \"which corresponds to the index: \\n\",\n",
    "    note_index,\n",
    ")\n",
    "print(\n",
    "    \"The chosen scale is a \",\n",
    "    def_scale.value,\n",
    "    \"which corresponds to the midi indices: \\n\",\n",
    "    scale_clean,\n",
    ")\n",
    "print(\"The octave that you have chose to map your notes onto is: \\n \", def_octave.value)\n",
    "\n",
    "print(\n",
    "    \"If this is incorrect, please check with the drop down menu above and run this cell again.\"\n",
    ")\n",
    "\n",
    "# Mapping chosen scale onto each other\n",
    "scale = []\n",
    "for ix in scale_clean:\n",
    "    a = ix + (len_oct * def_octave.value) + note_index\n",
    "    scale.append(a)\n",
    "\n",
    "print(\n",
    "    \"--------------------------------------------------------------------------------------------------------------------------\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# heatmap (?) data\n",
    "import seaborn as sns\n",
    "\n",
    "file = np.loadtxt(\"sample_data/bound_matrix.csv\", delimiter=\" \")\n",
    "data = file\n",
    "\n",
    "# First look at the data. We can visualise this using seaborn.\n",
    "sns.heatmap(data, linewidth=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are different ways to do this - either we can treat each row sequentially and flatten the array:\n",
    "flat_data = np.reshape(data, -1)\n",
    "\n",
    "# and then assign bins as before for the 2D data\n",
    "bins = np.linspace(\n",
    "    min(flat_data), max(flat_data), len(scale)\n",
    ")  # Defining bins based of the max, min, and length of a scale\n",
    "# sorting the data into the bins defined above\n",
    "abs_binned = np.digitize(flat_data, bins)\n",
    "unique_bins = np.unique(abs_binned)  # making an array of our unique bins\n",
    "\n",
    "# split the scale based on how many unique bins there are\n",
    "revalue = dict(\n",
    "    zip(unique_bins, scale[:: int(len(scale) / len(unique_bins))])\n",
    ")  # dictionary to map our scale to the binned values of our IR absorption\n",
    "notes = [\n",
    "    revalue.get(n, n) for n in abs_binned\n",
    "]  # mapping the data values onto the scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternatively, each row entry gets one track\n",
    "notes_list = []\n",
    "for d in data:\n",
    "\n",
    "    # and then assign bins as before for the 2D data\n",
    "    bins = np.linspace(\n",
    "        min(flat_data), max(flat_data), len(scale)\n",
    "    )  # Defining bins based of the max, min, and length of a scale\n",
    "    # sorting the data into the bins defined above\n",
    "    abs_binned = np.digitize(d, bins)\n",
    "    unique_bins = np.unique(abs_binned)  # making an array of our unique bins\n",
    "\n",
    "    # split the scale based on how many unique bins there are\n",
    "    revalue = dict(\n",
    "        zip(unique_bins, scale[:: int(len(scale) / len(unique_bins))])\n",
    "    )  # dictionary to map our scale to the binned values of our IR absorption\n",
    "    notes = [\n",
    "        revalue.get(n, n) for n in abs_binned\n",
    "    ]  # mapping the data values onto the scale\n",
    "    notes_list.append(notes)\n",
    "\n",
    "num_tracks = len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(len(scale) / len(unique_bins))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "****\n",
    "\n",
    "### Definine rest of parameters for MIDIUtil to work\n",
    "\n",
    "#### If you are confused on the choices please visit the MIDIUtil Docs, a link to it can be found on the learn page. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1ce1f47915164f3cadfc78654902f277",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What is the MIDI channel? \\n (If unknown set as 0)'), IntSlider(value=0, continuou…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0c379f0c0caa4b2ba8bbe41c7ceecbe7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What is the tempo for the track?'), IntSlider(value=120, continuous_update=False, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b12ad67eb65e42248c1975ebebe04b7f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='Volume of track'), IntSlider(value=100, continuous_update=False, layout=Layout(bor…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "About time signature\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ae87bd04c15476d99dc7d1405cb12a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What is the number of beats per bar'), Dropdown(layout=Layout(border_bottom='2px s…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b935c39243b243f59699963d5256434d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='What type of note does each bar correspond to?'), Dropdown(layout=Layout(border_bo…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Displaying the pre-defined widgets to help with musical choice for writing your MIDI file\n",
    "\n",
    "display(vert_channel)\n",
    "display(vert_tempo)\n",
    "display(vert_volume)\n",
    "print(\"About time signature\")\n",
    "display(vert_bpb)\n",
    "display(vert_type_beat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "626585f99a8b4b1387862f34ecaa3a57",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='Name of your midi file:'), Textarea(value='Track_1', layout=Layout(border_bottom='…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f9559ef36964c0c9655ea7eac777309",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Label(value='How often to take a note from the data'), IntSlider(value=4, continuous_update=Fal…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set up some variables for the MIDIUtil program to work\n",
    "\n",
    "# This takes your inputs from above and converts it into a format that the MIDIUtil library can read\n",
    "\n",
    "channel = int(def_channel.value)\n",
    "tempo = int(def_tempo.value)\n",
    "volume = int(def_volume.value)\n",
    "\n",
    "# Final inputs for wirting the MIDI file\n",
    "\n",
    "display(vert_name)\n",
    "display(vert_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can write the data into a new track for each row, so it will appear as different tracks in the music program, or alternatively we can write them all into one track with multiple notes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different tracks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Writing a MIDI for seperate tracks\n",
    "\n",
    "MyMIDI = MIDIFile(numTracks=num_tracks)\n",
    "\n",
    "for track, notes in zip(range(0, num_tracks, 1), notes_list):\n",
    "    MyMIDI.addTempo(track, time, tempo)\n",
    "    MyMIDI.addTimeSignature(\n",
    "        track,\n",
    "        time,\n",
    "        def_bpb.value,\n",
    "        note_name_dictionary[def_type_beat.value],\n",
    "        clocks_per_tick,\n",
    "        notes_per_quarter,\n",
    "    )  # add a time signature, here just 4/4\n",
    "\n",
    "    # loop over each time step\n",
    "\n",
    "    i = 0\n",
    "    for n in notes[::4]:  # loop over each note\n",
    "        MyMIDI.addNote(track, channel, n, time + i, duration, volume)\n",
    "        i = i + 1\n",
    "\n",
    "    # saving the resulting midi file.\n",
    "\n",
    "with open(str(def_name.value) + \".mid\", \"wb\") as output_file:\n",
    "    MyMIDI.writeFile(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same track:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Writing a MIDI file with all the different notes in one shared track\n",
    "\n",
    "# One track, defaults to format 1 (tempo track is created automatically)\n",
    "MyMIDI = MIDIFile(numTracks=1)\n",
    "\n",
    "MyMIDI.addTempo(track, time, tempo)\n",
    "# add a time signature, here just 4/4\n",
    "MyMIDI.addTimeSignature(\n",
    "    track,\n",
    "    time,\n",
    "    def_bpb.value,\n",
    "    note_name_dictionary[def_type_beat.value],\n",
    "    clocks_per_tick,\n",
    "    notes_per_quarter,\n",
    ")\n",
    "\n",
    "# loop over each of the notes in the noteslist\n",
    "# loop over each time step\n",
    "for notes in notes_list:\n",
    "    i = 0\n",
    "    for n in notes[::1]:  # loop over each note\n",
    "        MyMIDI.addNote(track, channel, n, time + i, duration, volume)\n",
    "        i = i + 1\n",
    "\n",
    "    # saving the resulting midi file.\n",
    "\n",
    "with open(str(def_name.value) + \".mid\", \"wb\") as output_file:\n",
    "    MyMIDI.writeFile(output_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "datajam",
   "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.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}