HARMONY_TESTS_ON_GIANT_STEPS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#imports\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import schillinger.harmony as SH\n",
    "import numpy as np\n",
    "import itertools\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import schillinger.pitch as SP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from music21 import *\n",
    "%load_ext music21.ipython21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['B', 'G', 'E-'], ['B', 'E-', 'G']]\n",
      "['B', 'G', 'E-', 'G', 'E-', 'B', 'E-', 'G', 'B', 'E-', 'B', 'G', 'B', 'G', 'E-', 'G', 'B', 'E-', 'G', 'E-', 'B', 'E-', 'B', 'G', 'B', 'E-', 'G', 'B']\n",
      "['B', 'G', 'E-', 'G', 'E-', 'B', 'E-', 'G', 'B', 'E-']\n"
     ]
    }
   ],
   "source": [
    "# GIANT STEPS\n",
    "harmonic_roots = [\"B\",\"G\",\"E-\"]\n",
    "expansions = SP.expansions(harmonic_roots)\n",
    "print(expansions)\n",
    "C3 = expansions[0]\n",
    "C_3 = expansions[1]\n",
    "#C5 = expansions[2]\n",
    "\n",
    "root_cycles = SP.pitch_cicles(harmonic_roots,[C3,C_3],[2,1,2,4])# giant steps\n",
    "#root_cycles = SP.pitch_cicles(harmonic_roots,[C3,C_3,C5],[3,1,2,2,2,3])\n",
    "print(root_cycles) # All\n",
    "print(root_cycles[0:10])# Giant Steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([<music21.scale.MajorScale B major>,\n",
       "  <music21.scale.MajorScale G major>,\n",
       "  <music21.scale.MajorScale E- major>],\n",
       " [[['B', 'C#', 'D#', 'E', 'F#', 'G#', 'A#'],\n",
       "   ['B', 'D#', 'F#', 'A#', 'C#', 'E', 'G#'],\n",
       "   ['B', 'E', 'A#', 'D#', 'G#', 'C#', 'F#'],\n",
       "   ['B', 'F#', 'C#', 'G#', 'D#', 'A#', 'E'],\n",
       "   ['B', 'G#', 'E', 'C#', 'A#', 'F#', 'D#'],\n",
       "   ['B', 'A#', 'G#', 'F#', 'E', 'D#', 'C#']],\n",
       "  [['G', 'A', 'B', 'C', 'D', 'E', 'F#'],\n",
       "   ['G', 'B', 'D', 'F#', 'A', 'C', 'E'],\n",
       "   ['G', 'C', 'F#', 'B', 'E', 'A', 'D'],\n",
       "   ['G', 'D', 'A', 'E', 'B', 'F#', 'C'],\n",
       "   ['G', 'E', 'C', 'A', 'F#', 'D', 'B'],\n",
       "   ['G', 'F#', 'E', 'D', 'C', 'B', 'A']],\n",
       "  [['E-', 'F', 'G', 'A-', 'B-', 'C', 'D'],\n",
       "   ['E-', 'G', 'B-', 'D', 'F', 'A-', 'C'],\n",
       "   ['E-', 'A-', 'D', 'G', 'C', 'F', 'B-'],\n",
       "   ['E-', 'B-', 'F', 'C', 'G', 'D', 'A-'],\n",
       "   ['E-', 'C', 'A-', 'F', 'D', 'B-', 'G'],\n",
       "   ['E-', 'D', 'C', 'B-', 'A-', 'G', 'F']]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#harmonic_roots_to_individual_harmonies\n",
    "scale_type = scale.MajorScale\n",
    "all_root_scales = []\n",
    "all_expansions = []\n",
    "for i in harmonic_roots:\n",
    "    my_temp_scale = scale_type(i)\n",
    "    all_root_scales.append(my_temp_scale)\n",
    "    scale_to_pitchnames = [str(p.name) for p in my_temp_scale.pitches[:-1]] # convert to pitchnames\n",
    "    all_expansions.append(SP.expansions(scale_to_pitchnames))\n",
    "all_root_scales, all_expansions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(26, 26)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root_sequence = root_cycles[0:11]\n",
    "root_sequence = root_cycles\n",
    "durations = [2,2,2,2, 4,2,2, 2,2,2,2, 4,2,2, 4,2,2, 4,2,2, 4,2,2, 4,2,2] # hardcode\n",
    "form =      [1,5,1,5, 1,2,5, 1,5,1,5, 1,2,5, 1,2,5, 1,2,5, 1,2,5, 1,2,5]\n",
    "rythmic_seq = [2]\n",
    "cadences = []\n",
    "for exp in all_expansions:\n",
    "    cadence = SH.diatonic_cadences(exp)\n",
    "    cadences.append(cadence)\n",
    "    #print(cadence)\n",
    "    \n",
    "root_sequence, cadences;\n",
    "len(durations), len(form)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('B', 'D#', 'F#', 'B')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test random cadences\n",
    "test_cadences = cadences[0]\n",
    "test_cadences[0][0],random.choice(test_cadences)[1],random.choice(test_cadences)[2], test_cadences[0][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "SPG = SP.PitchGroup()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#\n",
    "'''filled_harmonies = []\n",
    "for i, rs in enumerate(root_sequence):\n",
    "    \n",
    "    #fill in the first or tonic note\n",
    "    current_harmony = root_sequence[(i)%len(root_sequence)]\n",
    "    current_harmony_idx = harmonic_roots.index(current_harmony)\n",
    "    my_scale = all_root_scales[current_harmony_idx]\n",
    "    expansions = all_expansions[current_harmony_idx] # so\n",
    "    \n",
    "    chorified_scale = SPG.chordify_scale(expansions[1],4)\n",
    "    harmonized_bass = SPG.harmonize_bass([rs], chorified_scale)\n",
    "    filled_harmonies.append(harmonized_bass[0][1])\n",
    "    filled_harmonies.append(harmonized_bass[0][1])\n",
    "    \n",
    "    \n",
    "    next_harmony = root_sequence[(i+1)%len(root_sequence)]\n",
    "    next_harmony_idx = harmonic_roots.index(next_harmony)\n",
    "    my_scale = all_root_scales[next_harmony_idx]\n",
    "    # descision if cadence or whole expansion!\n",
    "    expansions = all_expansions[next_harmony_idx] # so\n",
    "    my_cadences = cadences[next_harmony_idx] # oder so #cadence is simpler for now!\n",
    "    \n",
    "    chorified_scale = SPG.chordify_scale(expansions[1],4)\n",
    "    \n",
    "    for d in range(durations[i]-2):\n",
    "        temp_bass = my_cadences[0][(d+1)%len(my_cadences[1])]\n",
    "        harmonized_bass = SPG.harmonize_bass([temp_bass], chorified_scale)\n",
    "        filled_harmonies.append(harmonized_bass[0][1])\n",
    "        #print(harmonized_bass[0][1], my_cadences[0])\n",
    "        \n",
    "#print(filled_harmonies)''';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "code_folding": [],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#new\n",
    "filled_harmonies = []\n",
    "voice_amount = 4\n",
    "form_idx = 0\n",
    "for i, rs in enumerate(root_sequence):\n",
    "    #print(rs)\n",
    "    #fill in the first or tonic note\n",
    "    current_harmony = root_sequence[(i)%len(root_sequence)]\n",
    "    current_harmony_idx = harmonic_roots.index(current_harmony)\n",
    "    \n",
    "    my_scale = all_root_scales[current_harmony_idx]\n",
    "    expansions = all_expansions[current_harmony_idx] # so\n",
    "    expansion = expansions[1]\n",
    "    \n",
    "    chorified_scale = SPG.chordify_scale(expansion, voice_amount)\n",
    "    \n",
    "    #harmonized_bass = SPG.harmonize_bass([rs], chorified_scale)\n",
    "    \n",
    "    \n",
    "    while form[form_idx%len(form)] != 1:\n",
    "        \n",
    "        if form[form_idx%len(form)] == 5:\n",
    "            change = chorified_scale[2]\n",
    "        if form[form_idx%len(form)] == 2:\n",
    "            change = chorified_scale[4]\n",
    "        \n",
    "        for i in range(durations[form_idx%len(durations)]):\n",
    "            filled_harmonies.append(change)\n",
    "        \n",
    "        form_idx = form_idx + 1\n",
    "        \n",
    "    change = chorified_scale[0]\n",
    "    for i in range(durations[form_idx%len(durations)]):\n",
    "        filled_harmonies.append(change)\n",
    "    form_idx = form_idx + 1\n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#old\n",
    "'''for i, rs in enumerate(root_sequence):\n",
    "    \n",
    "    #fill in the first or tonic note\n",
    "    temp_ = []\n",
    "    current_harmony = root_sequence[(i)%len(root_sequence)]\n",
    "    current_harmony_idx = harmonic_roots.index(current_harmony)\n",
    "    \n",
    "    my_scale = all_root_scales[current_harmony_idx]\n",
    "    expansions = all_expansions[current_harmony_idx] # so\n",
    "    thirds_expansion = expansions[1]\n",
    "    \n",
    "    chorified_scale = SPG.chordify_scale(thirds_expansion, voice_amount)\n",
    "    harmonized_bass = SPG.harmonize_bass([rs], chorified_scale)\n",
    "    \n",
    "    #temp_.append(harmonized_bass[0])\n",
    "    \n",
    "    filled_harmonies.append(harmonized_bass[0])\n",
    "    \n",
    "    next_harmony = root_sequence[(i+1)%len(root_sequence)]\n",
    "    next_harmony_idx = harmonic_roots.index(next_harmony)\n",
    "    my_scale = all_root_scales[next_harmony_idx]\n",
    "    \n",
    "    # descision if cadence or whole expansion!\n",
    "    expansions = all_expansions[next_harmony_idx]\n",
    "    thirds_expansion = expansions[1]\n",
    "    \n",
    "    chorified_scale = SPG.chordify_scale(thirds_expansion, voice_amount)\n",
    "    \n",
    "    for y in range(rythmic_seq[i%len(rythmic_seq)]):\n",
    "        \n",
    "        #filled_harmonies.append(random.choice(chorified_scale))\n",
    "        filled_harmonies.append(chorified_scale[3])\n",
    "    ''';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "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",
    "    p1 = stream.Part(id='part1')\n",
    "    p1.timeSignature = meter.TimeSignature(TS)\n",
    "    for i, notes in enumerate(note_sequece):\n",
    "        \n",
    "        #for y in range():\n",
    "        dur = rythmic_seq[i%len(rythmic_seq)]\n",
    "        dur = 1\n",
    "        #print(notes)\n",
    "        c = chord.Chord(notes)\n",
    "        \n",
    "        c.quarterLength = dur * duration_divider\n",
    "        \n",
    "        c.pitches[2].octave = 3\n",
    "        c.pitches[0].octave = 2\n",
    "        #c.inversion(0)\n",
    "        p0.append(c)\n",
    "        \n",
    "        ## fake melody\n",
    "        melody = []\n",
    "        \n",
    "        for i in range(dur):\n",
    "            nota = pitch.Pitch(random.choice(notes))\n",
    "            nota.octave = 5\n",
    "            nota = note.Note(nota.nameWithOctave)\n",
    "            nota.duration.quarterLength = 1 * duration_divider\n",
    "            melody.append(nota)   \n",
    "        \n",
    "        p1.append(melody)\n",
    "            \n",
    "    s.insert(0, p1)\n",
    "    s.insert(0, p0)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "code_folding": [
     1
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'''melody = []\n",
    "for i, m in enumerate(filled_harmonies):\n",
    "    #print(m)\n",
    "    melody.append(random.choice(m))\n",
    "    if i == len(filled_harmonies)-1:\n",
    "        melody[-1] = m[0]\n",
    "#melody''';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = showNotes(filled_harmonies,[4,4],1)\n",
    "s.show('musicxml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "return_value = [list(itertools.chain(*filled_harmonies))][0]\n",
    "#print(return_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "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
}