HARMONY_TESTS_ON_GIANT_STEPS-Experiments.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['C', 'E-', 'F#', 'A'], ['C', 'F#', 'E-', 'A'], ['C', 'A', 'F#', 'E-']]\n",
      "['C', 'E-', 'F#', 'E-', 'F#', 'A', 'C', 'F#', 'E-', 'A', 'C', 'E-', 'A', 'C', 'E-', 'A', 'C', 'F#', 'E-', 'F#', 'A', 'C', 'E-', 'F#', 'E-', 'A', 'C', 'F#', 'A', 'C', 'F#', 'A', 'C', 'F#', 'E-', 'A', 'C']\n",
      "['C', 'E-', 'F#', 'E-', 'F#', 'A', 'C', 'F#', 'E-', 'A']\n"
     ]
    }
   ],
   "source": [
    "# GIANT STEPS\n",
    "harmonic_roots = [\"C\",\"E-\",\"F#\",\"A\"]\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": 5,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#harmonic_roots_to_individual_harmonies\n",
    "scale_type = scale.MinorScale\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": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "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]#obsolete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "SPG = SP.PitchGroup()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#CADENCE\n",
    "cadences = []\n",
    "for exp in all_expansions:\n",
    "    cadence = SH.diatonic_cadences(exp)\n",
    "    cadences.append(cadence)\n",
    "    #print(cadence)\n",
    "def generate_cadence(idx):\n",
    "    \n",
    "    test_cadence = cadences[idx]\n",
    "    a,b,c,d = test_cadence[0][0],random.choice(test_cadence)[1],random.choice(test_cadence)[2], test_cadence[0][3]\n",
    "    #print(a,b,c,d)\n",
    "    return [b,c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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",
    "    cadence = generate_cadence(current_harmony_idx)\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",
    "    while form[form_idx%len(form)] != 1:\n",
    "        \n",
    "        if form[form_idx%len(form)] == 5:\n",
    "            \n",
    "            #change = chorified_scale[2] # DEFAULT\n",
    "            change = SPG.harmonize_bass([cadence[1]], chorified_scale)[0] #RANDOM CADENCE\n",
    "            \n",
    "        if form[form_idx%len(form)] == 2:\n",
    "            #change = chorified_scale[4] # DEFAULT\n",
    "            change = SPG.harmonize_bass([cadence[0]], chorified_scale)[0] #RANDOM CADENCE\n",
    "            \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",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "code_folding": [
     0
    ],
    "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 * duration_divider\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": 27,
   "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": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s = showNotes(filled_harmonies,[4,4],1)\n",
    "s.show('musicxml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#return_value = [list(itertools.chain(*filled_harmonies))][0]\n",
    "#print(return_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stored 'cleaned_filled_harm' (list)\n"
     ]
    }
   ],
   "source": [
    "#pass to another notebooks!\n",
    "cleaned_filled_harm = list(itertools.chain(*filled_harmonies))\n",
    "%store cleaned_filled_harm\n",
    "#del cleaned_filled_harm # This has deleted the variable"
   ]
  },
  {
   "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
}