bach_dux_investigation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#includes\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import itertools\n",
    "import numpy as np\n",
    "from music21 import *\n",
    "import matplotlib.pyplot as plt\n",
    "%load_ext music21.ipython21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "os.rename(os.path.join(path, \"719631-Prelude_and_Fugue_1_-_OpenWTC.mxl\"), \n",
    "          os.path.join(path, \"Prelude_and_Fugue_1.mxl\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "code_folding": [],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_1.mxl <music21.stream.Score 0x1162522b0> C major\n",
      "Prelude_and_Fugue_10.mxl <music21.stream.Score 0x116252940> e minor\n",
      "Prelude_and_Fugue_11.mxl <music21.stream.Score 0x105fe9be0> d minor\n",
      "Prelude_and_Fugue_12.mxl <music21.stream.Score 0x11674c5c0> f minor\n",
      "Prelude_and_Fugue_13.mxl <music21.stream.Score 0x11654d668> F# major\n",
      "Prelude_and_Fugue_14.mxl <music21.stream.Score 0x118b77b70> f# minor\n",
      "Prelude_and_Fugue_15.mxl <music21.stream.Score 0x11622d160> G major\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_16.mxl <music21.stream.Score 0x11b8f6f98> g minor\n",
      "Prelude_and_Fugue_17.mxl <music21.stream.Score 0x1165a9f60> A- major\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_18.mxl <music21.stream.Score 0x1162cbcf8> g# minor\n",
      "Prelude_and_Fugue_19.mxl <music21.stream.Score 0x1162e5be0> A major\n",
      "Prelude_and_Fugue_2.mxl <music21.stream.Score 0x11ae0ccf8> c minor\n",
      "Prelude_and_Fugue_20.mxl <music21.stream.Score 0x11b2b8dd8> a minor\n",
      "Prelude_and_Fugue_21.mxl <music21.stream.Score 0x115ae9080> B- major\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_22.mxl <music21.stream.Score 0x115c31550> b- minor\n",
      "Prelude_and_Fugue_23.mxl <music21.stream.Score 0x11761a908> B major\n",
      "Prelude_and_Fugue_24.mxl <music21.stream.Score 0x1165ec7b8> b minor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_3.mxl <music21.stream.Score 0x1159cd4e0> C# major\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_4.mxl <music21.stream.Score 0x118e1f438> c# minor\n",
      "Prelude_and_Fugue_5.mxl <music21.stream.Score 0x11606ada0> D major\n",
      "Prelude_and_Fugue_6.mxl <music21.stream.Score 0x11a704668> d minor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_7.mxl <music21.stream.Score 0x1162072e8> E- major\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "musicxml.xmlToM21: WARNING: Line <bracket> stop without start\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prelude_and_Fugue_8.mxl <music21.stream.Score 0x115fc2a20> e- minor\n",
      "Prelude_and_Fugue_9.mxl <music21.stream.Score 0x117319da0> E major\n"
     ]
    }
   ],
   "source": [
    "#import all duxes\n",
    "\n",
    "import os\n",
    "path = os.getcwd()+\"/bach/xmls/\"\n",
    "files = os.listdir(path)\n",
    "i = 1\n",
    "\n",
    "for file in files:\n",
    "    #print(file)\n",
    "    score = converter.parse(os.path.join(path, file))\n",
    "    key = score.analyze('key')\n",
    "    print(file,score,key)\n",
    "    #os.rename(os.path.join(path, file), os.path.join(path, str(i)+'.jpg'))\n",
    "    #print(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [
     0,
     21
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#analyse movement\n",
    "d = {\n",
    "0:{\"Name\":\"Prelude_and_Fugue_1.mxl\",\"TonalCenter\":\"C4\",\"Staff\":1,\"Voice\":2,\"StartMeasure\":36,\"EndMeasure\":37,\"DuxLen\":19},\n",
    "1:{\"Name\":\"Prelude_and_Fugue_2.mxl\", \"TonalCenter\":\"C4\",\"Staff\":1,\"Voice\":2,\"StartMeasure\":39,\"EndMeasure\":41,\"DuxLen\":20},\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "code_folding": [
     0,
     10
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C major\n",
      "<music21.stream.PartStaff P1-Staff1>\n",
      "<music21.stream.PartStaff P1-Staff2>\n"
     ]
    }
   ],
   "source": [
    "\n",
    "score = converter.parse(os.path.join(path, \"Prelude_and_Fugue_1.mxl\"))\n",
    "key = score.analyze('key')\n",
    "\n",
    "print(key)\n",
    "score.groups\n",
    "for e in score.parts:\n",
    "    n = e.measures(37,38)\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "{0.0} <music21.instrument.Instrument P1: Piano: Piano>\n",
      "{0.0} <music21.clef.TrebleClef>\n",
      "{0.0} <music21.key.KeySignature of no sharps or flats>\n",
      "{0.0} <music21.stream.Measure 36 offset=0.0>\n",
      "    {0.0} <music21.meter.TimeSignature 4/4>\n",
      "    {0.0} <music21.expressions.TextExpression \"a 4 voci\">\n",
      "    {0.0} <music21.layout.PageLayout>\n",
      "    {0.0} <music21.layout.SystemLayout>\n",
      "    {0.0} <music21.stream.Voice 1>\n",
      "        {0.0} <music21.note.Rest rest>\n",
      "    {0.0} <music21.stream.Voice 2>\n",
      "        {0.0} <music21.note.Rest rest>\n",
      "        {0.5} <music21.note.Note C>\n",
      "        {1.0} <music21.note.Note D>\n",
      "        {1.5} <music21.note.Note E>\n",
      "        {2.0} <music21.note.Note F>\n",
      "        {2.75} <music21.note.Note G>\n",
      "        {2.875} <music21.note.Note F>\n",
      "        {3.0} <music21.note.Note E>\n",
      "        {3.5} <music21.note.Note A>\n",
      "{4.0} <music21.stream.Measure 37 offset=4.0>\n",
      "    {0.0} <music21.stream.Voice 1>\n",
      "        {0.0} <music21.note.Rest rest>\n",
      "        {2.0} <music21.note.Rest rest>\n",
      "        {2.5} <music21.note.Note G>\n",
      "        {3.0} <music21.note.Note A>\n",
      "        {3.5} <music21.note.Note B>\n",
      "    {0.0} <music21.stream.Voice 2>\n",
      "        {0.0} <music21.note.Note D>\n",
      "        {0.5} <music21.note.Note G>\n",
      "        {1.0} <music21.note.Note G>\n",
      "        {1.25} <music21.note.Note A>\n",
      "        {1.5} <music21.note.Note G>\n",
      "        {1.75} <music21.note.Note F>\n",
      "        {2.0} <music21.note.Note E>\n",
      "        {2.25} <music21.note.Note F>\n",
      "        {2.5} <music21.note.Note E>\n",
      "        {2.75} <music21.note.Note D>\n",
      "        {3.0} <music21.note.Note C>\n",
      "        {3.25} <music21.note.Note D>\n",
      "        {3.5} <music21.note.Note C>\n",
      "        {3.75} <music21.note.Note B>\n"
     ]
    }
   ],
   "source": [
    "p = score.parts[0]\n",
    "m = p.measures(36,37)\n",
    "print(len(m.flat.notesAndRests.voices))\n",
    "m.show(\"text\")\n",
    "for n in m.notes.parts:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "code_folding": [
     0,
     57
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "score = converter.parse(os.path.join(path, \"Prelude_and_Fugue_1.mxl\"))\n",
    "key = score.analyze('key')\n",
    "\n",
    "note_array = []\n",
    "start_measure = 36\n",
    "end_measure = 37\n",
    "staff_num = 1\n",
    "voice_num = 2\n",
    "\n",
    "dux_len = 19#notes to extract\n",
    "\n",
    "tonal_center = pitch.Pitch(\"C4\")\n",
    "\n",
    "for i,part in enumerate(score.parts[staff_num-1].measures(start_measure,end_measure)):\n",
    "    if part.isStream:\n",
    "        if part.isClassOrSubclass:\n",
    "            note_array += [n.pitch for n in part.voices[voice_num-1].notes]\n",
    "\n",
    "#trim to dux notes only            \n",
    "note_array = note_array[:dux_len]\n",
    "#Calculate sum in dux\n",
    "old_num = tonal_center\n",
    "num_array = []\n",
    "for i, e in enumerate(note_array):\n",
    "    #print(e.midi)\n",
    "    num_array.append(e.midi - old_num.midi)\n",
    "    #interval.notesToInterval(aNote, bNote)\n",
    "    #aInterval = interval.notesToInterval(old_num, e)\n",
    "    old_num = e\n",
    "    #print(e.step)\n",
    "    #print(e.pitchClass)\n",
    "    #print(key.getScaleDegreeFromPitch(e))\n",
    "print(sum(num_array))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#analyse movement\n",
    "d = {\n",
    "0:{\"Name\":\"Prelude_and_Fugue_1.mxl\",\"TonalCenter\":\"C4\",\"Staff\":1,\"Voice\":2,\"StartMeasure\":36,\"EndMeasure\":37,\"DuxLen\":19},\n",
    "1:{\"Name\":\"Prelude_and_Fugue_2.mxl\", \"TonalCenter\":\"C4\",\"Staff\":1,\"Voice\":2,\"StartMeasure\":39,\"EndMeasure\":41,\"DuxLen\":20},\n",
    "2:{\"Name\":\"Prelude_and_Fugue_3.mxl\", \"TonalCenter\":\"C#4\",\"Staff\":1,\"Voice\":1,\"StartMeasure\":105,\"EndMeasure\":107,\"DuxLen\":17},\n",
    "3:{\"Name\":\"Prelude_and_Fugue_4.mxl\", \"TonalCenter\":\"C#3\",\"Staff\":2,\"Voice\":1,\"StartMeasure\":40,\"EndMeasure\":43,\"DuxLen\":5},\n",
    "4:{\"Name\":\"Prelude_and_Fugue_5.mxl\", \"TonalCenter\":\"D3\",\"Staff\":2,\"Voice\":1,\"StartMeasure\":36,\"EndMeasure\":37,\"DuxLen\":17},\n",
    "5:{\"Name\":\"Prelude_and_Fugue_6.mxl\", \"TonalCenter\":\"D4\",\"Staff\":1,\"Voice\":1,\"StartMeasure\":27,\"EndMeasure\":29,\"DuxLen\":20},\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def interface(dict_iter):\n",
    "    score = converter.parse(os.path.join(path, dict_iter[\"Name\"]))\n",
    "    #key = score.analyze('key')\n",
    "\n",
    "    note_array = []\n",
    "    start_measure = dict_iter[\"StartMeasure\"]\n",
    "    end_measure = dict_iter[\"EndMeasure\"]\n",
    "    staff_num = dict_iter[\"Staff\"]\n",
    "    voice_num = dict_iter[\"Voice\"]\n",
    "\n",
    "    dux_len = dict_iter[\"DuxLen\"]#notes to extract\n",
    "\n",
    "    tonal_center = pitch.Pitch(dict_iter[\"TonalCenter\"])\n",
    "\n",
    "    for i,part in enumerate(score.parts[staff_num-1].measures(start_measure,end_measure)):\n",
    "        if part.isStream:\n",
    "            if part.isClassOrSubclass:\n",
    "                try:\n",
    "                    note_array += [n.pitch for n in part.voices[voice_num-1].notes]\n",
    "                except:\n",
    "                    note_array += [n.pitch for n in part.notes]\n",
    "\n",
    "    #trim to dux notes only            \n",
    "    note_array = note_array[:dux_len]\n",
    "    #Calculate sum in dux\n",
    "    old_num = tonal_center\n",
    "    num_array = []\n",
    "    for i, e in enumerate(note_array):\n",
    "        #num_array.append(e.diatonicNoteNum-old_num)\n",
    "        #old_num = e.diatonicNoteNum\n",
    "        \n",
    "        num_array.append(e.midi - old_num.midi)\n",
    "        old_num = e\n",
    "    print(sum(num_array))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for i in d.values():\n",
    "    interface(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Step Movement Investigation on an classical 7 step scale ->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.array([0, 1, 1, -4, 3, -1, -1, 1, 2, -2])) #WTK II c-moll dux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.array([0, 2, -2, 4, -4, 7, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1]))#invention #8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.array([0,1,1,1,1,-1,-1,3,-4,3,1,-1,-1,-1,1,-1,-1,-1]))#invention #8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     1,
     18
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Melody show helpers\n",
    "def convert_to_music21_sequence(sc, pa, pitches, durations):\n",
    "    note_seq = []\n",
    "    \n",
    "    tonic = sc.getTonic()\n",
    "    \n",
    "    for e, p in enumerate(pitches):\n",
    "        if p != 0:\n",
    "            c = sc.next(tonic, direction=p)\n",
    "        else:\n",
    "            c = tonic\n",
    "        #print(c,p)\n",
    "        nota = note.Note(c.nameWithOctave)\n",
    "        nota.duration.quarterLength = int(durations[e])\n",
    "        note_seq.append(nota)\n",
    "        \n",
    "    return note_seq\n",
    "# simple notes show\n",
    "def showNotes(note_sequece, time_meter, duration_divider):\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    s = stream.Score(id='mainScore')\n",
    "    p0 = stream.Part(id='part0')\n",
    "    p0.timeSignature = meter.TimeSignature(TS)\n",
    "    for i, notes in enumerate(note_sequece):\n",
    "        notes.quarterLength = notes.quarterLength*duration_divider\n",
    "        p0.append(notes)\n",
    "    s.insert(0, p0)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Show Melody Notes\n",
    "melody = ME2.oscillated_seq\n",
    "hm = scale.HarmonicMinorScale(\"C4\")\n",
    "#hm = scale.ChromaticScale(tonic=\"C4\")\n",
    "pitches = convert_to_music21_sequence(hm, PA, melody[1], melody[0])\n",
    "s = showNotes(pitches,[4,4],1)\n",
    "s.show('musicxml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# notes harmony \n",
    "\n",
    "def arpeggiator(c, es,rhythm, duration_divider):\n",
    "    chords = []\n",
    "    for i, seq in enumerate(c):\n",
    "                \n",
    "        nota = seq\n",
    "        nota.duration.quarterLength = (rhythm[es%len(rhythm)]/len(c)) * duration_divider\n",
    "        chords.append(nota)\n",
    "\n",
    "    nota = pitch.Pitch(c.pitches[0])\n",
    "    \n",
    "    \n",
    "    nota.octave = nota.octave + 2\n",
    "    nota = note.Note(nota.nameWithOctave)\n",
    "    #nota.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "    nota.duration.quarterLength = (rhythm[es%len(rhythm)]/len(c)) * duration_divider\n",
    "    \n",
    "   \n",
    "    chords.append(nota)\n",
    "    #octave adjust\n",
    "    \n",
    "    \n",
    "    #print(chords[-1].pitch.midi - chords[-2].pitch.midi, chords[-1])\n",
    "    if chords[-1].pitch.midi - chords[-2].pitch.midi >= 11:\n",
    "        chords[-1].octave = chords[-1].octave -1\n",
    "        #print(\"yes\")\n",
    "    ##\n",
    "    nota = pitch.Pitch(c.pitches[2])\n",
    "    nota.octave = nota.octave\n",
    "    nota = note.Note(nota.nameWithOctave)\n",
    "    #nota.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "    nota.duration.quarterLength = (rhythm[es%len(rhythm)]/len(c)) * duration_divider\n",
    "    chords.append(nota)\n",
    "    return chords\n",
    "\n",
    "def showHarmony(pitches, note_sequence, scala, rhythm, length, time_meter, duration_divider, arp=False,bass=True, drop2 = False):\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    \n",
    "    s = stream.Score(id='mainScore')\n",
    "    p0 = stream.Part(id='melody')\n",
    "    p0.timeSignature = meter.TimeSignature(TS)\n",
    "    p1 = stream.Part(id='chords')\n",
    "    p1.timeSignature = meter.TimeSignature(TS)\n",
    "    \n",
    "    #pseudo stuff\n",
    "    #temp_scale = scala\n",
    "    #rhythm_seq = [2,1,1,2]\n",
    "    for es, sequences in enumerate(note_sequence):\n",
    "        \n",
    "        melody = []\n",
    "        chords = []\n",
    "        \n",
    "        \n",
    "        \n",
    "        ### chords\n",
    "        #chord_seq = [sequences[0]]+sequences[1]\n",
    "        chord_seq = sequences\n",
    "        #print(chord_seq)\n",
    "        test_chord = chord.Chord(chord_seq)\n",
    "        c = chord.Chord(test_chord)\n",
    "        #c.root = sequences[0]\n",
    "        #pitches[es].quarterLength.duration\n",
    "        c.quarterLength = pitches[es].quarterLength * duration_divider\n",
    "        #c = c.sortDiatonicAscending() # for better voice leadng but not real!\n",
    "        #c.pitches.octave = 2\n",
    "        for p in c.pitches:\n",
    "            p.octave = 3\n",
    "        if drop2:\n",
    "            try:\n",
    "                #\n",
    "                #c.pitches[0].octave = 1 # drop2\n",
    "                #c.pitches[-2].octave -= 2 # drop4\n",
    "                pass\n",
    "            except:\n",
    "                pass\n",
    "        \n",
    "        if arp:\n",
    "            chords =  arpeggiator(c, es, rhythm, duration_divider)\n",
    "            #chords.append(nota)\n",
    "            \n",
    "        else:\n",
    "            chords.append(c)\n",
    "            \n",
    "        nota = pitches[es]\n",
    "        nota.quarterLength *= duration_divider\n",
    "        #nota.octave += 1 \n",
    "        melody.append(pitches[es])\n",
    "            \n",
    "        \n",
    "        ##############\n",
    "        # pseudo BASS\n",
    "        # get chord durations and apply on melody (for test purpose)\n",
    "        \n",
    "        p0.append(melody)\n",
    "        p1.append(chords)\n",
    "        \n",
    "    \n",
    "    s.insert(0, p0)\n",
    "    s.insert(0, p1)\n",
    "    \n",
    "    #s = s.transpose(0)\n",
    "    return s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#'harmonized'\n",
    "def harmonize_note_clockwise(n, chordified_scale, clock_position):\n",
    "    dummy = []\n",
    "    temp_scales = []\n",
    "    for i,e in enumerate(chordified_scale):\n",
    "        if n in e:\n",
    "            temp_scales.append(e)\n",
    "    dummy.append(temp_scales[clock_position%len(temp_scales)])\n",
    "    return dummy\n",
    "\n",
    "melody = ME.oscillated_seq\n",
    "hm = scale.HarmonicMinorScale(\"C4\")\n",
    "#hm = scale.ChromaticScale(tonic=\"C4\")\n",
    "notes = convert_to_music21_sequence(hm, PA, melody[1], melody[0])\n",
    "note_seq = [[str(p.name) for p in notes]]\n",
    "\n",
    "temp_scale = [str(p.name) for p in hm.pitches[:-1]]\n",
    "scales = [temp_scale]\n",
    "#print(scales)\n",
    "#note_seq = bass\n",
    "voice_amount = 3 \n",
    "theme_expansion = 0\n",
    "scale_expansion_amount = 1 # # 1st order expansion for harmonizing is according to schillingers default\n",
    "\n",
    "SPG = SPitch.PitchGroup()\n",
    "harmonized_note_sequence_array = []\n",
    "scale_expansion = SPG.expansions(temp_scale)\n",
    "scale_ = scale_expansion[scale_expansion_amount]\n",
    "chordified_scale = SPG.chordify_scale(scale_, voice_amount)\n",
    "#TSD = [chordified_scale[0],chordified_scale[2],chordified_scale[5],chordified_scale[6]]\n",
    "TSD = chordified_scale.copy()\n",
    "#print(chordified_scale)\n",
    "for i,no in enumerate(note_seq[0]):\n",
    "    clock_position = i\n",
    "    hn = harmonize_note_clockwise(no, TSD, clock_position)\n",
    "    harmonized_note_sequence_array.append(hn)\n",
    "    \n",
    "merged_seq = list(itertools.chain(*harmonized_note_sequence_array))\n",
    "s = showHarmony(notes, merged_seq, hm, melody[0], len(merged_seq)*2, (4,4), .5, arp=False, bass=False, drop2=True)\n",
    "s.show('musicxml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0,
     2
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#np.negative(np.arange(-5, 0, 1))\n",
    "#random.choice([a.min(),a.max()])\n",
    "#random.choice([True,False])\n",
    "#np.random.randint(0,PA.durations[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#OSCILLATOR\n",
    "\n",
    "def sinusCycle(steps, amplitude, cycles, full_cycle=True, sin=True):\n",
    "    \n",
    "    if full_cycle:\n",
    "        magnitude = 360\n",
    "    else:\n",
    "        magnitude = 180\n",
    "    \n",
    "    R = np.array(np.sin(np.arange(0, magnitude, magnitude/steps) * np.pi / 180.)*amplitude, dtype=np.float32)\n",
    "    \n",
    "    if not sin:\n",
    "        R = np.roll(R, int(steps/2))\n",
    "    \n",
    "    if steps<0:\n",
    "        R = np.negative(R)\n",
    "        \n",
    "    return np.tile(np.array(np.rint(R), dtype=np.int32), cycles)\n",
    "\n",
    "def growSeq(np_array, start_amount=1, end_amount=5):\n",
    "    c = np_array.copy()\n",
    "    dummy = np.linspace(start_amount, end_amount, len(np.nonzero(c)[0]), endpoint=True, dtype=np.int32)\n",
    "    c[np.nonzero(c)] *= dummy\n",
    "    return c\n",
    "\n",
    "def shiftSeq(np_array, start_amount=0, end_amount=1):\n",
    "    c = np_array.copy()\n",
    "    dummy = np.linspace(start_amount, end_amount, len(c), endpoint=True, dtype=np.int32)\n",
    "    c += dummy\n",
    "    return c\n",
    "\n",
    "steps=4\n",
    "amplitude = 1\n",
    "cycles = 1\n",
    "X = sinusCycle(steps, amplitude, cycles, full_cycle=True, sin=True)\n",
    "X\n",
    "Y = growSeq(X, start_amount=1, end_amount=2)\n",
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "0--6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "steps = np.arange(0, 10, 1)\n",
    "amp = 45\n",
    "amplitude = np.radians(amp)/np.pi/2\n",
    "amplitude * steps\n",
    "\n",
    "\n",
    "np.tile(np.array([0,1,0,-1], dtype=np.int32), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [conda env:python3_test]",
   "language": "python",
   "name": "conda-env-python3_test-py"
  },
  "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.5.2"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}