Meddleying_VIRTUOSO.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.5"
    },
    "colab": {
      "name": "Meddleying VIRTUOSO.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [
        "QA0W-VK1JVQl"
      ],
      "toc_visible": true,
      "machine_shape": "hm",
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/asigalov61/Meddleying-VIRTUOSO/blob/main/Meddleying_VIRTUOSO.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QA0W-VK1JVQl"
      },
      "source": [
        "# Meddleying VIRTUOSO (ver 1.2)\n",
        "\n",
        "***\n",
        "\n",
        "## Full-featured Algorithmic Intelligence Music Augmentator (AIMA)\n",
        "\n",
        "PLEASE NOTE: \n",
        "\n",
        "1) THIS IS A PIANO ONLY VERSION FOR NOW !!!\n",
        "\n",
        "2) THIS IS A BETA/WORK-IN-PROGRESS\n",
        "\n",
        "\n",
        "***\n",
        "\n",
        "### Project Los Angeles\n",
        "\n",
        "### Tegridy Code 2020\n",
        "\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eftzIVKrqR5S"
      },
      "source": [
        "# Setup Environment, clone needed code, and install all required dependencies"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HsUtsJGNz6f2",
        "cellView": "form"
      },
      "source": [
        "#@title Install all dependencies (run only once per session)\n",
        "print('Installing dependencies and creating Dataset dir...')\n",
        "\n",
        "#!git clone https://github.com/asigalov61/Meddleying-VIRTUOSO\n",
        "\n",
        "!pip install pretty_midi\n",
        "!pip install visual_midi\n",
        "\n",
        "!curl -L \"https://raw.githubusercontent.com/asigalov61/Meddleying-MAESTRO/main/MIDI.py\" > 'MIDI.py'\n",
        "\n",
        "!mkdir '/content/Dataset/'\n",
        "print('Done!')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pf8B3p6QySmE",
        "cellView": "form"
      },
      "source": [
        "#@title Import all modules\n",
        "print('Importing modules...')\n",
        "import glob\n",
        "import os\n",
        "import numpy as np\n",
        "import multiprocessing\n",
        "import toolz\n",
        "import itertools\n",
        "import music21\n",
        "from music21 import *\n",
        "import pickle\n",
        "import time\n",
        "import math\n",
        "import sys\n",
        "import tqdm.auto\n",
        "import secrets\n",
        "import pretty_midi\n",
        "from datetime import datetime\n",
        "import statistics\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.patches import Circle\n",
        "from mido import MidiFile\n",
        "from IPython.display import display, Image\n",
        "import MIDI\n",
        "from visual_midi import Plotter\n",
        "from visual_midi import Preset\n",
        "from pretty_midi import PrettyMIDI\n",
        "\n",
        "debug = False\n",
        "print('Done!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKtb-zHFfZ-y",
        "cellView": "form"
      },
      "source": [
        "#@title Declare Tegridy MIDI Processor\n",
        "\n",
        "def Tegridy_MIDI_Processor(file):\n",
        "\n",
        "    '''Tegridy MIDI Processor\n",
        "\n",
        "    Input: A single MIDI file.\n",
        "    Output: A list of MIDI chords and a list of melody notes.\n",
        "    MIDI Chords: Sorted by pitch (chord[0] == highest pitch).\n",
        "    Melody Notes: Sorted by start time.\n",
        "    Format: MIDI.py Score Events format\n",
        "    Precision: 1 ms per note/chord\n",
        "\n",
        "    Enjoy! :)\n",
        "\n",
        "    Project Los Angeles\n",
        "    Tegridy Code 2020'''\n",
        "\n",
        "###########\n",
        "\n",
        "    minimum_number_of_notes_per_chord = 2 # Must be 2 or more...\n",
        "\n",
        "#   debug = False\n",
        "\n",
        "###########\n",
        "\n",
        "    average_note_pitch = 0\n",
        "    min_note = 127\n",
        "    max_note = 0\n",
        "\n",
        "    files_count = 0\n",
        "\n",
        "    ev = 0\n",
        "\n",
        "    chords_list_final = []\n",
        "    chords_list = []\n",
        "    events_matrix = []\n",
        "    melody = []\n",
        "    melody1 = []\n",
        "\n",
        "    itrack = 1\n",
        "\n",
        "    min_note = 0\n",
        "    max_note = 0\n",
        "    ev = 0\n",
        "\n",
        "    score = []\n",
        "\n",
        "###########    \n",
        "\n",
        "    def list_average(num):\n",
        "      sum_num = 0\n",
        "      for t in num:\n",
        "          sum_num = sum_num + t           \n",
        "\n",
        "      avg = sum_num / len(num)\n",
        "      return avg\n",
        "\n",
        "###########\n",
        "\n",
        "    #print('Loading MIDI file...')\n",
        "    midi_file = open(file, 'rb')\n",
        "    if debug: print('Processing File:', file_address)\n",
        "    \n",
        "    try:\n",
        "      opus = MIDI.midi2opus(midi_file.read())\n",
        "    \n",
        "    except:\n",
        "      print('Bad file. Skipping...')\n",
        "      midi_file.close()\n",
        "      exit\n",
        "         \n",
        "    midi_file.close()\n",
        "\n",
        "    score1 = MIDI.to_millisecs(opus)\n",
        "    score = MIDI.opus2score(score1)\n",
        "    \n",
        "    #print('Reading all MIDI events from the MIDI file...')\n",
        "    while itrack < len(score):\n",
        "      chords_list_track = []\n",
        "      for event in score[itrack]:\n",
        "        chords_list = []\n",
        "        if event[0] == 'note':\n",
        "          if len(event) == 6: # Checking for bad notes...\n",
        "              events_matrix.append(event)\n",
        "\n",
        "              min_note = int(min(min_note, event[4]))\n",
        "              max_note = int(max(max_note, event[4]))          \n",
        "              \n",
        "              ev += 1\n",
        "      \n",
        "      itrack +=1 # Going to next track...\n",
        "    \n",
        "    #print('Doing some heavy pythonic sorting...Please stand by...')\n",
        "\n",
        "    #print('Removing zero pitches and zero velocities events')\n",
        "    events_matrix1 = [i for i in events_matrix if i[4] > 0 and i[5] > 0] # removing zero pitches and zero velocities events\n",
        "    events_matrix = events_matrix1\n",
        "    events_matrix1 = []\n",
        "\n",
        "    for event in events_matrix:\n",
        "      seen = set()\n",
        "      event1 = [x for x in event if x not in seen and not seen.add(x)]\n",
        "      events_matrix1.append(event1)\n",
        "\n",
        "    events_matrix = []\n",
        "    events_matrix = events_matrix1 \n",
        "\n",
        "    #print('Sorting input by start time...')\n",
        "    events_matrix.sort(key=lambda x: x[1]) # Sorting input by start time\n",
        "\n",
        "    #print('Grouping by start time. This will take a while...')\n",
        "    values = set(map(lambda x:x[1], events_matrix)) # Non-multithreaded function version just in case\n",
        "\n",
        "    groups = [[y for y in events_matrix if y[1]==x and len(y) == 6] for x in values] # Grouping notes into chords while discarting bad notes...\n",
        "  \n",
        "    chords_list1 = []\n",
        "    #print('Removing single note/excessive events, sorting events by pitch, and creating a chords list...')\n",
        "    for items in groups: \n",
        "      if len(items) >= minimum_number_of_notes_per_chord: # Removing single note events\n",
        "        items.sort(reverse=True, key=lambda x: x[4]) # Sorting events by pitch\n",
        "        chords_list1.append(items) # Creating final chords list\n",
        "\n",
        "    #print('Removing duplicate pitches from chords and creating a final chords list...')\n",
        "    chords_list = []\n",
        "    chord = []\n",
        "    chord1 = []\n",
        "    chord2 = []\n",
        "\n",
        "    for chord in chords_list1:\n",
        "      seen = set()\n",
        "      chord1 = [x for x in chord if x[4] not in seen and not seen.add(x[4])]\n",
        "      chord2 = [x for x in chord1 if len(x) == 6] # Removing bad note events from chords\n",
        "      chords_list.append(chord2)\n",
        "\n",
        "    chords_list_track = [i for i in chords_list if i != []]\n",
        "\n",
        "    chords_list_final = []\n",
        "    chords_list_final.extend(chords_list_track)\n",
        "    \n",
        "    #print('Extracting melody...')\n",
        "    melody_list = []\n",
        "    \n",
        "    #print('Sorting events...')\n",
        "    for items in groups:\n",
        "        items.sort(reverse=True, key=lambda x: x[4]) # Sorting events by pitch \n",
        "        melody_list.append(items) # Creating final chords list\n",
        "    \n",
        "    #print('Removing duplicates if any...')\n",
        "    for item in melody_list:\n",
        "      seen = set()\n",
        "      mel = [x for x in item if x[1] not in seen and not seen.add(x[1])]\n",
        "      melody1.extend(mel)\n",
        "    \n",
        "    #print('Removing bad notes if any...')    \n",
        "    for item in melody1:\n",
        "        if len(item) == 6:\n",
        "          melody.append(item)\n",
        "    \n",
        "    #print('Final sorting by start time...')      \n",
        "    melody.sort(reverse=False, key=lambda x: x[1]) # Sorting events by start time\n",
        "      \n",
        "    return chords_list_final, melody"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "F6oE8vSp3cRX"
      },
      "source": [
        "#@title Load basic chords dictionary\n",
        "\n",
        "# Helper functions/code:\n",
        "\n",
        "'''for i in range(len(y)):\n",
        "  for x in range(len(y[i])):\n",
        "    #for z in range(3):\n",
        "    y[i][x][2] = 0\n",
        "\n",
        "def column(matrix, i):\n",
        "    return [row[i] for row in matrix]\n",
        "\n",
        "CHORDS_DICTIONARY = []\n",
        "\n",
        "for i in range(len(chords_list_final)):    \n",
        "  CHORDS_DICTIONARY.append(column(chords_list_final[i], 4))'''\n",
        "\n",
        "CHORDS_DICTIONARY = [[64, 61, 57],\n",
        " [69, 65, 62],\n",
        " [67, 63, 60],\n",
        " [73, 70, 67],\n",
        " [66, 63, 59],\n",
        " [72, 69, 65],\n",
        " [69, 65, 62],\n",
        " [66, 63, 60],\n",
        " [75, 71, 67],\n",
        " [66, 63, 59],\n",
        " [72, 69, 65],\n",
        " [69, 65, 62],\n",
        " [66, 63, 60],\n",
        " [74, 71, 67],\n",
        " [66, 63, 59],\n",
        " [74, 70, 67, 64],\n",
        " [69, 65, 62],\n",
        " [68, 64, 60],\n",
        " [74, 71, 67],\n",
        " [66, 63, 59],\n",
        " [74, 71, 67, 64],\n",
        " [69, 65, 62],\n",
        " [67, 64, 60],\n",
        " [74, 71, 67],\n",
        " [66, 63, 59],\n",
        " [71, 67, 64],\n",
        " [71, 67, 64, 61],\n",
        " [67, 64, 60],\n",
        " [74, 71, 67],\n",
        " [67, 63, 60, 57],\n",
        " [71, 67, 64],\n",
        " [71, 68, 64, 61],\n",
        " [67, 64, 60],\n",
        " [74, 71, 67],\n",
        " [67, 64, 60, 57],\n",
        " [71, 67, 64],\n",
        " [68, 64, 61],\n",
        " [67, 64, 60],\n",
        " [74, 71, 67],\n",
        " [64, 60, 57],\n",
        " [71, 67, 64],\n",
        " [72, 69, 65],\n",
        " [68, 64, 61],\n",
        " [67, 64, 60],\n",
        " [75, 71, 68, 65],\n",
        " [64, 60, 57],\n",
        " [71, 67, 64],\n",
        " [68, 64, 61],\n",
        " [67, 64, 60],\n",
        " [75, 72, 68, 65],\n",
        " [64, 60, 57],\n",
        " [71, 67, 64],\n",
        " [68, 64, 61],\n",
        " [69, 65, 62, 59],\n",
        " [72, 68, 65],\n",
        " [64, 60, 57],\n",
        " [73, 69, 66, 63],\n",
        " [68, 64, 61],\n",
        " [69, 66, 62, 59],\n",
        " [72, 68, 65],\n",
        " [64, 60, 57],\n",
        " [73, 70, 66, 63],\n",
        " [68, 64, 61],\n",
        " [66, 62, 59],\n",
        " [72, 68, 65],\n",
        " [64, 60, 57],\n",
        " [70, 66, 63],\n",
        " [71, 68, 65, 61],\n",
        " [66, 62, 59],\n",
        " [72, 68, 65],\n",
        " [66, 62, 59, 56],\n",
        " [70, 66, 63],\n",
        " [72, 68, 65, 61],\n",
        " [66, 62, 59],\n",
        " [72, 68, 65],\n",
        " [66, 63, 59, 56],\n",
        " [70, 66, 63],\n",
        " [67, 64, 61],\n",
        " [66, 62, 59],\n",
        " [72, 68, 65],\n",
        " [63, 59, 56],\n",
        " [70, 66, 63],\n",
        " [67, 64, 61],\n",
        " [66, 62, 59],\n",
        " [75, 72, 69, 65],\n",
        " [63, 59, 56],\n",
        " [70, 66, 63],\n",
        " [69, 65, 61],\n",
        " [66, 62, 59],\n",
        " [76, 72, 69, 66],\n",
        " [63, 59, 56],\n",
        " [70, 66, 63],\n",
        " [68, 65, 61],\n",
        " [68, 64, 61, 58],\n",
        " [76, 73, 69, 66],\n",
        " [63, 59, 56],\n",
        " [73, 70, 67, 63],\n",
        " [68, 65, 61],\n",
        " [68, 65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [73, 70, 67],\n",
        " [63, 59, 56],\n",
        " [74, 70, 67, 63],\n",
        " [68, 65, 61],\n",
        " [65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [63, 59, 56],\n",
        " [69, 66, 63],\n",
        " [68, 65, 61],\n",
        " [65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [66, 63, 60, 56],\n",
        " [69, 66, 63],\n",
        " [68, 65, 61],\n",
        " [65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [67, 63, 60, 56],\n",
        " [71, 67, 63],\n",
        " [68, 65, 61],\n",
        " [65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [62, 59, 56],\n",
        " [70, 67, 63],\n",
        " [72, 69, 66, 62],\n",
        " [65, 61, 58],\n",
        " [73, 69, 66],\n",
        " [62, 59, 56],\n",
        " [70, 67, 63],\n",
        " [73, 69, 66, 62],\n",
        " [65, 61, 58],\n",
        " [77, 73, 70, 66],\n",
        " [64, 60, 56],\n",
        " [70, 67, 63],\n",
        " [68, 65, 62],\n",
        " [68, 65, 62, 58],\n",
        " [72, 69, 66],\n",
        " [63, 60, 56],\n",
        " [70, 67, 63],\n",
        " [68, 65, 62],\n",
        " [69, 65, 62, 58],\n",
        " [72, 69, 66],\n",
        " [63, 60, 56],\n",
        " [70, 67, 63],\n",
        " [70, 66, 62],\n",
        " [64, 61, 58],\n",
        " [74, 70, 66],\n",
        " [63, 60, 56],\n",
        " [70, 67, 63],\n",
        " [69, 66, 62],\n",
        " [64, 61, 58],\n",
        " [73, 70, 66],\n",
        " [63, 60, 56],\n",
        " [74, 71, 68, 64],\n",
        " [69, 66, 62],\n",
        " [66, 62, 58],\n",
        " [73, 70, 66],\n",
        " [63, 60, 56],\n",
        " [75, 71, 68, 64],\n",
        " [69, 66, 62],\n",
        " [77, 73, 70, 67],\n",
        " [65, 62, 58],\n",
        " [73, 70, 66],\n",
        " [63, 60, 56],\n",
        " [70, 67, 64],\n",
        " [69, 66, 62],\n",
        " [77, 74, 70, 67],\n",
        " [65, 62, 58],\n",
        " [73, 70, 66],\n",
        " [67, 64, 61, 57],\n",
        " [70, 67, 64],\n",
        " [69, 66, 62],\n",
        " [74, 70, 67],\n",
        " [65, 62, 58],\n",
        " [73, 70, 66],\n",
        " [68, 64, 61, 57],\n",
        " [72, 68, 64],\n",
        " [69, 66, 62],\n",
        " [74, 70, 67],\n",
        " [65, 62, 58],\n",
        " [73, 70, 66],\n",
        " [63, 60, 57],\n",
        " [71, 68, 64],\n",
        " [70, 66, 63, 60],\n",
        " [74, 70, 67],\n",
        " [65, 62, 58],\n",
        " [76, 72, 69, 65],\n",
        " [63, 60, 57],\n",
        " [71, 68, 64],\n",
        " [70, 67, 63, 60],\n",
        " [74, 70, 67],\n",
        " [65, 62, 58],\n",
        " [71, 68, 65],\n",
        " [65, 61, 57],\n",
        " [71, 68, 64],\n",
        " [67, 63, 60],\n",
        " [74, 70, 67],\n",
        " [69, 66, 63, 59],\n",
        " [71, 68, 65],\n",
        " [64, 61, 57],\n",
        " [71, 68, 64],\n",
        " [67, 63, 60],\n",
        " [74, 70, 67],\n",
        " [70, 66, 63, 59],\n",
        " [73, 69, 65],\n",
        " [64, 61, 57],\n",
        " [71, 68, 64],\n",
        " [67, 63, 60],\n",
        " [76, 73, 70, 66],\n",
        " [65, 62, 59],\n",
        " [72, 69, 65],\n",
        " [64, 61, 57],\n",
        " [72, 68, 65, 62],\n",
        " [67, 63, 60],\n",
        " [77, 74, 71, 67],\n",
        " [65, 62, 59],\n",
        " [72, 69, 65],\n",
        " [64, 61, 57],\n",
        " [72, 69, 65, 62],\n",
        " [67, 63, 60],\n",
        " [78, 74, 71, 67],\n",
        " [67, 63, 59],\n",
        " [72, 69, 65],\n",
        " [64, 61, 57],\n",
        " [69, 65, 62],\n",
        " [67, 63, 60],\n",
        " [66, 63, 59]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S4oa9lUWLPN5",
        "cellView": "form"
      },
      "source": [
        "#@title A simple code to unzip MIDI datasets without any hastle\n",
        "!mkdir /content/Dataset/\n",
        "%cd /content/Dataset/\n",
        "!unzip -j /content/Dataset/*.zip\n",
        "!rm /content/Dataset/*.zip\n",
        "%cd /content/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5jsEXxkDLQ9Z"
      },
      "source": [
        "# Process MIDI Dataset to MIDI Notes and MIDI Events Lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QvdZDU6R4U2o",
        "cellView": "form"
      },
      "source": [
        "#@title Please note that processing may take a very long time on a large dataset without the multi-threading\n",
        "print('Meddleying VIRTUOSO Algorithmic Intelligence Music Augmentator')\n",
        "print('Starting up...')\n",
        "full_path_to_output_dataset_to = \"/content/Meddleying-VIRTUOSO-Music-Dataset.data\" #@param {type:\"string\"}\n",
        "enable_multi_threading = False #@param {type:\"boolean\"}\n",
        "number_of_parallel_threads = 64 #@param {type:\"slider\", min:1, max:128, step:1}\n",
        "minimum_number_of_notes_per_chord = 2 #@param {type:\"slider\", min:2, max:10, step:1}\n",
        "\n",
        "melody = []\n",
        "\n",
        "chords_list = []\n",
        "##debug = False #@param {type:\"boolean\"}\n",
        "\n",
        "###########\n",
        "\n",
        "os.chdir(\"./\")\n",
        "\n",
        "###########\n",
        "\n",
        "\n",
        "average_note_pitch = 0\n",
        "min_note = 127\n",
        "max_note = 0\n",
        "\n",
        "files_count = 0\n",
        "\n",
        "ev = 0\n",
        "\n",
        "chords_list_final = []\n",
        "melody_list_final = []\n",
        "chords_list = []\n",
        "\n",
        "###########\n",
        "\n",
        "def list_average(num):\n",
        "  sum_num = 0\n",
        "  for t in num:\n",
        "      sum_num = sum_num + t           \n",
        "\n",
        "  avg = sum_num / len(num)\n",
        "  return avg\n",
        "\n",
        "###########\n",
        "\n",
        "print('Loading MIDI files...')\n",
        "print('This may take a while on a large dataset in particular.')\n",
        "\n",
        "\n",
        "\n",
        "dataset_addr = \"/content/Dataset\"\n",
        "os.chdir(dataset_addr)\n",
        "files = os.listdir(dataset_addr)\n",
        "#print('Now processing the files.')\n",
        "#print('Please stand-by...')\n",
        "\n",
        "if enable_multi_threading:\n",
        "  print('Processing files with multi-threading enabled. Please wait...')\n",
        "  # Main multi-processing loop for MIDIs\n",
        "  pool = multiprocessing.Pool(processes=number_of_parallel_threads)\n",
        "  chords = pool.map(Tegridy_MIDI_Processor, files)\n",
        "  chords_list_final = [chords[0][0]]\n",
        "\n",
        "  melody = chords[0][1]\n",
        "\n",
        "  pool.close()\n",
        "  pool.join()\n",
        "else:\n",
        "  print('Processing files with multi-threading disabled. Please wait...')\n",
        "  for f in tqdm.auto.tqdm(files):\n",
        "    chords_list, melody = Tegridy_MIDI_Processor(f)\n",
        "    melody_list_final.extend(melody)\n",
        "    chords_list_final.extend(chords_list)\n",
        "\n",
        "    files_count += 1\n",
        "\n",
        "average_note_pitch = int((min_note + max_note) / 2)\n",
        "\n",
        "print('Task complete :)')\n",
        "print('==================================================')\n",
        "print('Number of processed dataset MIDI files:', files_count)\n",
        "#print('Average note pitch =', average_note_pitch)\n",
        "#print('Min note pitch =', min_note)\n",
        "#print('Max note pitch =', max_note)\n",
        "#print('Number of MIDI events recorded:', len(events_matrix))\n",
        "print('Number of MIDI chords recorded:', len(chords_list_final))\n",
        "print('Number of MIDI melody notes recorded:', len(melody_list_final))\n",
        "print('The longest chord:', max(chords_list_final, key=len))\n",
        "\n",
        "# Dataset\n",
        "MusicDataset = [chords_list_final]\n",
        "chords_list = chords_list_final\n",
        "\n",
        "with open(full_path_to_output_dataset_to, 'wb') as filehandle:\n",
        "    # store the data as binary data stream\n",
        "    pickle.dump(MusicDataset, filehandle)\n",
        "print('Dataset was saved at:', full_path_to_output_dataset_to)\n",
        "\n",
        "# MIDI/files stats code from the previous version.\n",
        "\n",
        "print('Task complete. Enjoy! :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7TUUCQTxWp9U"
      },
      "source": [
        "# Load/Re-load the processed dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kv4cUwf8yxJK",
        "cellView": "form"
      },
      "source": [
        "#@title Load/Reload pre-processed dataset from a file to memory\n",
        "full_path_to_dataset_file = \"/content/Meddleying-VIRTUOSO-Music-Dataset.data\" #@param {type:\"string\"}\n",
        "\n",
        "chords_list = []\n",
        "chords_list_final = []\n",
        "melody_list = []\n",
        "print('Loading Meddleying VIRTUOSO Dataset')\n",
        "with open(full_path_to_dataset_file, 'rb') as filehandle:\n",
        "    # read the data as binary data stream\n",
        "    MusicDataset = pickle.load(filehandle)\n",
        "    #melody_list = MusicDataset[0]\n",
        "    chords_list = MusicDataset[0]\n",
        "    chords_list_final = MusicDataset[0]\n",
        "print('Task complete. Enjoy! :)')\n",
        "print('==================================================')\n",
        "#print('Number of melody notes in the dataset:', len(melody_list))\n",
        "print('Number of chords in the dataset:', len(chords_list_final))\n",
        "print('Done! Enjoy! :)')   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JIZnfMF1sngq"
      },
      "source": [
        "# Generate Music\r\n",
        "\r\n",
        "## PLEASE NOTE: For best results it is recommended to prime from the dataset, meaning that you need to add files you will be augmenting to the dataset before generating the output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "--DGoti9GygY",
        "cellView": "form"
      },
      "source": [
        "#@title Music Generator\n",
        "\n",
        "file_address = \"/content/Dataset/Deep Relaxation Melody #8.mid\" #@param {type:\"string\"}\n",
        "melody_only_input = True #@param {type:\"boolean\"}\n",
        "output_ticks = 1000\n",
        "trim_the_output_to_this_many_melody_notes = 200 #@param {type:\"slider\", min:10, max:2000, step:10}\n",
        "min_notes_per_chord = 6 #@param {type:\"slider\", min:2, max:10, step:1}\n",
        "max_notes_per_chord = 10 #@param {type:\"slider\", min:2, max:10, step:1}\n",
        "random_search_ratio = 3 #@param {type:\"slider\", min:1, max:50, step:1}\n",
        "melody_only_output = True #@param {type:\"boolean\"}\n",
        "chords_only_output = True #@param {type:\"boolean\"}\n",
        "try_to_match_melody_notes_durations = False #@param {type:\"boolean\"}\n",
        "basic_chords_matching_output = False #@param {type:\"boolean\"}\n",
        "chords_durations_multiplier = 1.2 #@param {type:\"slider\", min:0.1, max:3, step:0.1}\n",
        "transpose_melody_velocity = 0 #@param {type:\"slider\", min:-30, max:30, step:1}\n",
        "transpose_chords_velocity = -10 #@param {type:\"slider\", min:-30, max:30, step:1}\n",
        "output_input_melody_only = False #@param {type:\"boolean\"}\n",
        "output_input_chords_only = False #@param {type:\"boolean\"}\n",
        "\n",
        "score = []\n",
        "output_composition = []\n",
        "\n",
        "print('Meddleying VIRTUOSO Algorithmic Intelligence Music Agumentator.')\n",
        "print('Starting up...')\n",
        "\n",
        "print('Loading input MIDI file...')\n",
        "\n",
        "midi_file = open(file_address, 'rb')\n",
        "print('Processing File:', file_address)\n",
        "try:\n",
        "  opus = MIDI.midi2opus(midi_file.read())\n",
        "\n",
        "except:\n",
        "  print=('Bad file. Please check and try again...')\n",
        "  midi_file.close()\n",
        "  exit\n",
        "midi_file.close()\n",
        "\n",
        "score1 = MIDI.to_millisecs(opus)\n",
        "score2 = MIDI.opus2score(score1)\n",
        "score = MIDI.grep(score2, [0])\n",
        "\n",
        "# Some helper functions and constants\n",
        "flattened_chords_list = list(itertools.chain(*list(itertools.chain(chords_list)))) \n",
        "\n",
        "zero_event = ['note', 0, 0, 0, 0, 0] # Zero note MIDI.py event\n",
        "previous_event = ['note', 0, 0, 0, 0, 0] # Zero note previous MIDI.py event\n",
        "\n",
        "print('Processing input MIDI file...')\n",
        "\n",
        "melody_chords_events = []\n",
        "melody_chords_list = []\n",
        "melody_events = []\n",
        "\n",
        "print('Extracting melody...')\n",
        "\n",
        "# Melody extraction code\n",
        "\n",
        "itrack = 1   # skip 1st element which is ticks\n",
        "\n",
        "while itrack < len(score):\n",
        "    for event in tqdm.auto.tqdm(score[itrack]):\n",
        "      if event[0] == 'note':\n",
        "        if not melody_only_input:\n",
        "\n",
        "          if event[1] <= previous_event[1]:\n",
        "            melody_chords_events.append(event)              \n",
        "          else:\n",
        "            melody_chords_events.sort(key=lambda x: x[4])\n",
        "            #melody_chords_events.reverse() \n",
        "            if melody_chords_events != []: \n",
        "              melody_events.append(melody_chords_events)            \n",
        "            melody_chords_events = []\n",
        "            melody_chords_events.append(event)\n",
        "\n",
        "          previous_event = event             \n",
        "        else:\n",
        "          melody_events.append(event)\n",
        "    previous_event = zero_event\n",
        "    melody_chords_events = []          \n",
        "    itrack += 1\n",
        "\n",
        "if not melody_only_input:\n",
        "  input_chords_list = [i for i in melody_events if i != []]\n",
        "  input_melody_list = [event[0] for event in melody_events]\n",
        "  input_chords_only_list = [i for i in [i[1:] for i in melody_events ] if i != []]\n",
        "  melody_events = list(itertools.chain(*list(itertools.chain(melody_events)))) \n",
        "\n",
        "else:\n",
        "  input_melody_list = melody_events\n",
        "\n",
        "# Main Generator loop\n",
        "print('Generating composition...')\n",
        "print('Please stand by...')\n",
        "\n",
        "i = 0\n",
        "dts = 0\n",
        "c = 0\n",
        "\n",
        "cev = []\n",
        "output_mchord = []\n",
        "chords = []\n",
        "chordz = []\n",
        "\n",
        "if not output_input_melody_only and not output_input_chords_only:\n",
        "  for event in tqdm.auto.tqdm(input_melody_list):\n",
        "    if i <= trim_the_output_to_this_many_melody_notes:\n",
        "      \n",
        "      if melody_only_output:\n",
        "        event1 = event\n",
        "        event1[5] = event[4] + transpose_melody_velocity\n",
        "        event1[3] = 0\n",
        "        output_composition.append(event1)\n",
        "\n",
        "      \n",
        "      if chords_only_output:\n",
        "        for chord in chords_list:\n",
        "            if len(chord) >= min_notes_per_chord and len(chord) <= max_notes_per_chord:\n",
        "              if event[4] == chord[0][4] and secrets.randbelow(random_search_ratio) == 0:\n",
        "                if try_to_match_melody_notes_durations and event[2] == chord[0][2]:      \n",
        "                  output_mchord = []\n",
        "                  chord2 = []\n",
        "                  chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[1][4], event[4] + transpose_chords_velocity])  \n",
        "                  chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[2][4], event[4] + transpose_chords_velocity])\n",
        "                  if len(chord) == 3:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[3][4], event[4] + transpose_chords_velocity])             \n",
        "                  if len(chord) == 4:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[4][4], event[4] + transpose_chords_velocity])\n",
        "                  if len(chord) == 5:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[5][4], event[4] + transpose_chords_velocity])                \n",
        "                  if len(chord) == 6:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[6][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 7:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[7][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 8:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[8][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 9:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[9][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 10:\n",
        "                    chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[10][4], event[4] + transpose_chords_velocity])              \n",
        "                  output_mchord.extend(chord2)\n",
        "                  c += 1\n",
        "                  break\n",
        "\n",
        "                else:\n",
        "                  output_mchord = []\n",
        "                  chord2 = []\n",
        "                  chord2.append(['note', event[1], chord[0][2] * chords_durations_multiplier, event[3], chord[0][4], event[4] + transpose_chords_velocity])  \n",
        "                  chord2.append(['note', event[1], chord[1][2] * chords_durations_multiplier, event[3], chord[1][4], event[4] + transpose_chords_velocity])\n",
        "                  if len(chord) == 3:\n",
        "                    chord2.append(['note', event[1], chord[2][2] * chords_durations_multiplier, event[3], chord[2][4], event[4] + transpose_chords_velocity])             \n",
        "                  if len(chord) == 4:\n",
        "                    chord2.append(['note', event[1], chord[3][2] * chords_durations_multiplier, event[3], chord[3][4], event[4] + transpose_chords_velocity])\n",
        "                  if len(chord) == 5:\n",
        "                    chord2.append(['note', event[1], chord[4][2] * chords_durations_multiplier, event[3], chord[4][4], event[4] + transpose_chords_velocity])                \n",
        "                  if len(chord) == 6:\n",
        "                    chord2.append(['note', event[1], chord[5][2] * chords_durations_multiplier, event[3], chord[5][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 7:\n",
        "                    chord2.append(['note', event[1], chord[6][2] * chords_durations_multiplier, event[3], chord[6][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 8:\n",
        "                    chord2.append(['note', event[1], chord[7][2] * chords_durations_multiplier, event[3], chord[7][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 9:\n",
        "                    chord2.append(['note', event[1], chord[8][2] * chords_durations_multiplier, event[3], chord[8][4], event[4] + transpose_chords_velocity])              \n",
        "                  if len(chord) == 10:\n",
        "                    chord2.append(['note', event[1], chord[9][2] * chords_durations_multiplier, event[3], chord[9][4], event[4] + transpose_chords_velocity])              \n",
        "                  output_mchord.extend(chord2)\n",
        "                  c += 1\n",
        "                  break  \n",
        "                  output_mchord.extend(chord2)\n",
        "                  c += 1\n",
        "                  break                \n",
        "\n",
        "        dts += 1\n",
        "        output_composition.extend(output_mchord)\n",
        "      \n",
        "      i +=1\n",
        "                \n",
        "      if basic_chords_matching_output:\n",
        "        for chord in CHORDS_DICTIONARY:\n",
        "          if len(chord) >= min_notes_per_chord and len(chord) <= max_notes_per_chord:\n",
        "            if event[4] == chord[0] and secrets.randbelow(random_search_ratio) == 0:\n",
        "              output_mchord = []\n",
        "              chord2 = []\n",
        "              chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[0], event[4] + transpose_chords_velocity])  \n",
        "              chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[1], event[4] + transpose_chords_velocity])\n",
        "              chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[2], event[4] + transpose_chords_velocity])              \n",
        "              if len(chord) == 4:\n",
        "                chord2.append(['note', event[1], event[2] * chords_durations_multiplier, event[3], chord[3], event[4] + transpose_chords_velocity])\n",
        "              output_mchord.extend(chord2)\n",
        "              chords.append(output_mchord)\n",
        "              c += 1\n",
        "              break\n",
        "\n",
        "        dts += 1\n",
        "        output_composition.extend(output_mchord)\n",
        "      i +=1\n",
        "\n",
        "# Removing duplicate events just in case and if any\n",
        "output_composition1 = [] \n",
        "for z in output_composition: \n",
        "    if z not in output_composition1: \n",
        "        output_composition1.append(z)\n",
        "\n",
        "print('Done!')\n",
        "print('Processing output melody and chords lists')\n",
        "if not output_input_chords_only and not output_input_melody_only:\n",
        "  output_composition1 = [i for i in output_composition1 if i != []] #or i[5] != 0]\n",
        "  #output_score = list(itertools.chain(*list(itertools.chain(output_composition))))\n",
        "  output_score = output_composition1\n",
        "\n",
        "if output_input_melody_only:\n",
        "  output_score = list(itertools.chain(*list(itertools.chain([input_melody_list]))))\n",
        "  #output = list(itertools.chain(*list(itertools.chain([test]))))\n",
        "\n",
        "if output_input_chords_only:\n",
        "  output_score = list(itertools.chain(*list(itertools.chain(input_chords_list))))\n",
        "\n",
        "print('Generating output MIDI file...')\n",
        "\n",
        "output_ticks = score[0]\n",
        "output_header = [['track_name', 0, b'Meddleying VIRTUOSO']] + score[1][:3] + [['patch_change', 0, 0, 0]]\n",
        "\n",
        "output_opus = output_header + output_score\n",
        "output = [output_ticks,  output_opus]\n",
        "midi_data = MIDI.score2midi(output)\n",
        "\n",
        "# Stuff for datetime stamp\n",
        "now = ''\n",
        "now_n = str(datetime.now())\n",
        "now_n = now_n.replace(' ', '_')\n",
        "now_n = now_n.replace(':', '_')\n",
        "now = now_n.replace('.', '_')\n",
        "    \n",
        "fname = '/content/Meddleying-VIRTUOSO-Composition-' + 'generated-on-' + str(now) + '.mid'  \n",
        "\n",
        "# Writing MIDI\n",
        "print('Writing output MIDI file to disk...')\n",
        "with open(fname, 'wb') as midi_file1:\n",
        "    midi_file1.write(midi_data)\n",
        "    midi_file1.close()\n",
        "print('Done!')\n",
        "\n",
        "# Stats\n",
        "print('Crunching quick stats...')\n",
        "print('First Event:', output[1][0], '=== Last Event:', output[1][-1])\n",
        "print('The dataset was scanned', dts, 'times.')\n",
        "print('Generated', i, 'notes for', len(melody_events), 'input melody notes.')\n",
        "print('Generated', c, 'chords for', len(melody_events), 'input melody notes.')\n",
        "print('Task complete!')\n",
        "\n",
        "# Google Colab file download code\n",
        "print('Downloading your MIDI now :) Enjoy!')\n",
        "from google.colab import files\n",
        "files.download(fname)\n",
        "print('Enjoy! :)')\n",
        "\n",
        "# MIDI.py detailed output MIDI stats\n",
        "print('Final output MIDI stats:')\n",
        "MIDI.score2stats(output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VbK4CaUQOjvW"
      },
      "source": [
        "# Fun MIR stats"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bJIcrVY6o9Gu",
        "cellView": "form"
      },
      "source": [
        "#@title Basic statistical analysis of the output MIDI file\n",
        "\n",
        "MIDI_DIR = \"/content/*.mid\"\n",
        "### https://github.com/brennan2602/FYP\n",
        "\n",
        "\n",
        "def get_piano_roll(midifile):\n",
        "\tmidi_pretty_format = pretty_midi.PrettyMIDI(midifile)\n",
        "\tpiano_midi = midi_pretty_format.instruments[0] # Get the piano channels\n",
        "\tpiano_roll = piano_midi.get_piano_roll(fs=20)\n",
        "\treturn piano_roll\n",
        "\n",
        "#uses split encoding scheme (here only encoding the note values)\n",
        "#works by looping through time increments of the piano roll array and writing the notes being played\n",
        "#at a given time sample as a number on the corresponding line of a string # is written when no notes played for that\n",
        "#sample\n",
        "def encode(arr):\n",
        "    timeinc=0\n",
        "    outString=\"\"\n",
        "    for time in arr:\n",
        "        notesinc = -1\n",
        "        #print(time)\n",
        "        if np.all(time==0):\n",
        "            outString=outString+\"#\"\n",
        "        for vel in arr[timeinc]:\n",
        "            notesinc=notesinc+1\n",
        "            if vel != 0:\n",
        "                noteRep=str(notesinc) + \" \"\n",
        "                #print(noteRep)\n",
        "                outString=outString+noteRep\n",
        "        outString=outString+\"\\n\"\n",
        "        timeinc = timeinc+1\n",
        "    return outString\n",
        "\n",
        "\n",
        "def getSilences(test):\n",
        "    test=test[:-1] #removing last line in string (always blank)\n",
        "    output=test.split(\"\\n\") #splitting into array\n",
        "    res = len(output)\n",
        "    #initialising counters\n",
        "    maxcounter=0\n",
        "    counter=0\n",
        "    silenceCount=0\n",
        "\n",
        "    for x in output:\n",
        "        if x == \"#\": #when a \"#\" is seen nothing is being played that sample\n",
        "            counter=counter+1 #this tracks a streak of silences\n",
        "            silenceCount+=1 #this tracks total silences\n",
        "        if x != \"#\":\n",
        "            counter=0 #reseting streak\n",
        "        if counter>maxcounter:\n",
        "            maxcounter=counter #updating longest silence streak when appropriate\n",
        "    return maxcounter,silenceCount\n",
        "\n",
        "\n",
        "#by looking at the length of song and the amount of silences this returns % silence\n",
        "def getPercentSilence(gen,silences):\n",
        "    test = gen\n",
        "    test = test[:-1]\n",
        "    output = test.split(\"\\n\")\n",
        "    res = len(output)\n",
        "    percent=silences/res\n",
        "    return percent\n",
        "\n",
        "\n",
        "def getStatsNotes(test):\n",
        "    test=test[:-1] #get rid of blank line at the end\n",
        "    notes=[]\n",
        "    output = test.split(\"\\n\") #split string on new lines\n",
        "\n",
        "    #initial values updated while looping through\n",
        "    maxPerSamp=0\n",
        "    silenceSamp=0\n",
        "    notesPlayed=0\n",
        "    maxNotes=0\n",
        "    maxVal=0\n",
        "    minVal=127\n",
        "\n",
        "    for x in output:\n",
        "        samp=x.split(\" \")\n",
        "        samp=samp[:-1] #theres a blank result at the end of array from split this indexing removes it\n",
        "        while \"0\" in samp:\n",
        "            samp.remove(\"0\") #sometimes 0 samples exist this removes them as they aren't notes played\n",
        "        if len(samp)==0:\n",
        "            silenceSamp+=1 #counting silences\n",
        "        notesPlayed=notesPlayed+len(samp) #counting notes played\n",
        "        if len(samp)>0:\n",
        "            #getting max and min note values at this time step\n",
        "            minimum=min(samp)\n",
        "            maximum=max(samp)\n",
        "            #updating max and min values note values for song if appropriate\n",
        "            if int(minimum)<minVal:\n",
        "                minVal=int(minimum)\n",
        "            if int(maximum)>maxVal:\n",
        "                maxVal=int(maximum)\n",
        "        #updating maximum number of notes per sample if appropriate\n",
        "        if len(samp)>maxNotes:\n",
        "            maxNotes=len(samp)\n",
        "    rangeNotes=maxVal-minVal #spread of notes\n",
        "    avgNotes = notesPlayed / len(output) #average notes per sample\n",
        "    adjNotes=notesPlayed /(len(output)-silenceSamp) #average notes per sample adjusted to remove silent samples\n",
        "    return rangeNotes, maxVal, minVal,maxNotes,avgNotes,adjNotes\n",
        "\n",
        "\n",
        "files=glob.glob(MIDI_DIR)#point towards directory with midi files (here same folder)\n",
        "#print(files)\n",
        "\n",
        "for f in files:\n",
        "    print(f)\n",
        "    pr = get_piano_roll(f) #gets piano roll representation of the midi file\n",
        "    arr = pr.T\n",
        "    outString= encode(arr) #gets a string representation of the midi file\n",
        "    maxsilences, silences = getSilences(outString) #by passing in the encoded string get longest silence and the total\n",
        "                                                   #number of samples which are silent\n",
        "    noteRange, maxVal, minVal, maxNotes, avgNotes, adjAvg =getStatsNotes(outString) # getting some stats by looping\n",
        "                                                                                    # through encoded data\n",
        "    percentSilence= getPercentSilence(outString,silences) # get % silence from silence / outString length\n",
        "\n",
        "    #printing out to the user\n",
        "    print(\"longest silence is \",maxsilences,\"samples long\")\n",
        "    print(\"silence covers:\",round(percentSilence,4),\"%\")\n",
        "    print(\"notes span range:\",noteRange)\n",
        "    print(\"max note value:\",maxVal)\n",
        "    print(\"min note value:\",minVal)\n",
        "    print(\"average number of notes per sample:\",round(avgNotes,4))\n",
        "    print(\"average number of notes per sample (adjusted to remove silence samples):\",round(adjAvg,4))\n",
        "    print(\"max number of notes played in a sample:\",maxNotes)\n",
        "    print(\"\\n\")\n",
        "\n",
        "#NOTE some minor discrepencies vs reading in from generated file directly\n",
        "#However this does provide a uniform check to use for songs generated by both encoding schemes\n",
        "#Can also be used to evaluate training file\n",
        "#uses split encoding to get the text representation for ease of development"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4UWsfXb2sla1",
        "cellView": "form"
      },
      "source": [
        "#@title Basic graph of the last output\n",
        "seconds_to_show = 30 #@param {type:\"slider\", min:1, max:180, step:1}\n",
        "show_whole_track = False #@param {type:\"boolean\"}\n",
        "graph_color = \"red\" #@param [\"blue\", \"red\", \"green\"]\n",
        "\n",
        "x = []\n",
        "y = []\n",
        "z = []\n",
        "\n",
        "t = 0\n",
        "itrack = 1\n",
        "fig = plt.figure(figsize=(12,5))\n",
        "while itrack < len(output):\n",
        "  for event in output[itrack]:\n",
        "      if event[0] == 'note':\n",
        "        y.append(event[4])\n",
        "        x.append(t)\n",
        "        plt.plot(x, y, color=graph_color)\n",
        "        t += 0.25       \n",
        "        if not show_whole_track:\n",
        "          if t == seconds_to_show: break\n",
        "  itrack +=1\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-mpUZFB02Da",
        "cellView": "form"
      },
      "source": [
        "#@title Output MIDI bokeh plot\n",
        "\n",
        "preset = Preset(plot_width=850)\n",
        "plotter = Plotter(preset, plot_max_length_bar=4)\n",
        "\n",
        "pm = PrettyMIDI(\"/content/Meddleying-VIRTUOSO-Composition.mid\")\n",
        "plotter.show_notebook(pm)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9uT8VexhsxT",
        "cellView": "form"
      },
      "source": [
        "#@title Bonus Music21 Graphs (slow)\n",
        "display_relative_output = True\n",
        "histogram_pitchSpace_count = False #@param {type:\"boolean\"}\n",
        "histogram_pitchClass_count = False #@param {type:\"boolean\"}\n",
        "Windowed_Keys = False #@param {type:\"boolean\"}\n",
        "scatter_quarterLength_pitchSpace = True #@param {type:\"boolean\"}\n",
        "quarterLength_3DBars_pitchSpace_count = False #@param {type:\"boolean\"}\n",
        "\n",
        "s = converter.parse(\"/content/Meddleying-VIRTUOSO-Composition.mid\")\n",
        "p = 0\n",
        "if histogram_pitchSpace_count:\n",
        "  p = music21.graph.plot.HistogramPitchSpace(s)\n",
        "  p.id\n",
        "  'histogram-pitchSpace-count'\n",
        "  p.run()  # with defaults and proper configuration, will open graph\n",
        "\n",
        "if histogram_pitchClass_count:\n",
        "  p = graph.plot.HistogramPitchClass(s)\n",
        "  p.id\n",
        "  'histogram-pitchClass-count'\n",
        "  p.run()\n",
        "\n",
        "if Windowed_Keys:\n",
        "  p = graph.plot.WindowedKey(s.parts[0])\n",
        "  p.id\n",
        "  p.run()\n",
        "\n",
        "if scatter_quarterLength_pitchSpace:\n",
        "  p = graph.plot.ScatterPitchSpaceQuarterLength(s)\n",
        "  p.id\n",
        "  'scatter-quarterLength-pitchSpace'\n",
        "  p.run()\n",
        "if quarterLength_3DBars_pitchSpace_count:\n",
        "  p = graph.plot.Plot3DBarsPitchSpaceQuarterLength(s)\n",
        "  p.id\n",
        "  '3DBars-quarterLength-pitchSpace-count'\n",
        "  p.run()\n",
        "if p == 0:\n",
        "  print('Please select graph(s) to plot, please :)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Snu3fb4N-Nd"
      },
      "source": [
        "# Congrats! :) You did it :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NxsedAQbS_wR",
        "cellView": "form"
      },
      "source": [
        "#@title Make a nice Arc diagram of the output to show friends and family :)\n",
        "MIDI_file_track_to_visualize = 0\n",
        "multi_track_input = True\n",
        "\n",
        "midi_file = '/content/Meddleying-VIRTUOSO-Composition.mid'\n",
        "plot_title = \"Meddleying VIRTUOSO Output Arc Diagram\"\n",
        "\n",
        "def maximal_matching_pair( s, substring_length, old_index=-1 ):\n",
        "    '''\n",
        "    find the first pair of matching substrings at least as long as the specified length\n",
        "    '''\n",
        "    if substring_length > len(s)/2:\n",
        "        return (len(substring_length), -1) # fail- futile to keep searching with this string\n",
        "\n",
        "    head = s[:substring_length]\n",
        "    tail = s[substring_length:]\n",
        "    index = tail.find(head) \n",
        "    if index == -1:\n",
        "        if substring_length > 2:\n",
        "            return (substring_length-1, old_index) # success\n",
        "        return (substring_length, index) # fail- failed on first 2 character substring attempt \n",
        "    \n",
        "    return maximal_matching_pair(s, substring_length+1, index) # keep looking\n",
        "\n",
        "def first_matching_substring_pair( s, start=0 ):\n",
        "    '''\n",
        "    returns the first matching substring pair of at least length 2 in the given string, \n",
        "    ignoring all characters of the string before the given start index \n",
        "    '''\n",
        "    if start < 0:\n",
        "        return () # invalid input: start must be non-negative\n",
        "\n",
        "    if len(s[start:]) < 4:\n",
        "        return () # fail: string too short to find matching substrings of minimal length 2\n",
        "\n",
        "    minimal_substring_length = 2\n",
        "    (length, distance) = maximal_matching_pair(s[start:], minimal_substring_length)\n",
        "    if distance != -1:\n",
        "        return (start, length, distance) # success\n",
        "    \n",
        "    return first_matching_substring_pair(s, start+1) # keep looking\n",
        "\n",
        "def matching_substring_pairs( string ):\n",
        "    '''\n",
        "    returns a collection of consecutive substring pairs encoded as (start, length, distance) where\n",
        "    * start is the index of the first character of the first substring of the matching substring pair,\n",
        "    * length is the length of the substrings in the matching substring pair, and\n",
        "    * distance is the distance from the end of the first substring to the begining of the second substring\n",
        "    '''\n",
        "    pairs = []\n",
        "    pair = first_matching_substring_pair(string, 0)\n",
        "    while pair:\n",
        "        pairs.append(pair)\n",
        "        (start, length, distance) = pair\n",
        "        pair = first_matching_substring_pair(string, start+length)\n",
        "    return pairs\n",
        "\n",
        "def plot_arc_diagram( string, plot_title=\"\" ):\n",
        "    slds = matching_substring_pairs(string)\n",
        "    bews = map( lambda sld: (sld[0], sum(sld)+sld[1], sld[1]), slds )\n",
        "    plot_arc_diagram_impl(bews, plot_title)\n",
        "\n",
        "#  begin                                        end                 \n",
        "# /                                            /\n",
        "# ***********-----------O-----------***********\n",
        "# |--width--|            \\          |--width--|\n",
        "#           |-inner rad-| \\\n",
        "# |-----outer radius----|  center\n",
        "\n",
        "def plot_ring( ax, begin, end, width ):\n",
        "    cx = 0.5*(begin + end)\n",
        "    center = (cx, 0)\n",
        "    outer_radius = cx - begin\n",
        "    inner_radius = outer_radius - width\n",
        "\n",
        "    mypie, _ = ax.pie([1], radius=outer_radius, colors=[(0.4,0.4, 1.0, 0.3)], center=center )\n",
        "    plt.setp( mypie, width=width)\n",
        "\n",
        "    return outer_radius\n",
        "\n",
        "def plot_arc_diagram_impl( bews, plot_title ):\n",
        "    fig, ax = plt.subplots(subplot_kw={'aspect': 'auto'})\n",
        "\n",
        "    x_min = 0\n",
        "    x_max = 1920\n",
        "    max_width = 1080\n",
        "    for bew in bews:\n",
        "        x_max = max(x_max, bew[1])\n",
        "        orad = plot_ring(ax, bew[0], bew[1], bew[2])\n",
        "        max_width = max(max_width, orad)\n",
        "\n",
        "    ax.set_xlim(x_min, x_max)\n",
        "    ax.set_ylim( -max_width, max_width)\n",
        "\n",
        "    plt.axis('off')\n",
        "\n",
        "    title_obj = plt.title(plot_title, loc='center')\n",
        "    plt.setp(title_obj, color=(0.0, 0.0, 0.0, 1)) \n",
        "\n",
        "    plt.savefig('/content/Meddleying-VIRTUOSO-Arc-Diagram.png', dpi=600)\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def stringify_notes(midi_file, track_number):\n",
        "\n",
        "    mid = MidiFile(midi_file)\n",
        "    track_notes = {}\n",
        "    for i, track in enumerate(mid.tracks):\n",
        "        track_notes[i] = ''\n",
        "        for msg in track:\n",
        "            if( msg.type == 'note_on'):\n",
        "                track_notes[i] += str(msg.note) +'n'\n",
        "            if( msg.type == 'note_off'):\n",
        "                track_notes[i] += str(msg.note) +'f'\n",
        "    return track_notes[track_number]\n",
        "\n",
        "if multi_track_input:\n",
        "  try:\n",
        "    plot_arc_diagram(stringify_notes(midi_file, MIDI_file_track_to_visualize), plot_title)\n",
        "    if debug: \n",
        "      print('Debug mode')\n",
        "    print('MIDI Track #', MIDI_file_track_to_visualize, 'Arc Diagram')\n",
        "    Image('output-absolute.png')\n",
        "  except:\n",
        "    print('Error in processing your MIDI file. Sorry.')\n",
        "    sys.exit\n",
        "from google.colab import files\n",
        "files.download('/content/Meddleying-VIRTUOSO-Arc-Diagram.png')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}