SCHILLINGER DIATONIC BASS HARMONIZATION (4VoicePlusMelody).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Imlementation of:\n",
    "\n",
    "***SCHILLINGER RHYTHM, HARMONY, PITCH, etc***\n",
    "\n",
    "for more information: Joseph Schillinger (1946): Schillinger System of Musical Composition.(New York: C. Fischer, Inc.)\n",
    "\n",
    "Konstantin Svechtarov 2017©"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# imports \n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import schillinger.rhythm as SR\n",
    "import schillinger.pitch as SP\n",
    "import itertools\n",
    "import random\n",
    "from music21 import *\n",
    "%load_ext music21.ipython21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [],
    "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",
    "    nota.octave = nota.octave + 1\n",
    "    nota = note.Note(nota.nameWithOctave)\n",
    "    nota.duration.quarterLength = (rhythm[es%len(rhythm)]/len(c)) * duration_divider\n",
    "    chords.append(nota)\n",
    "    #octave adjust\n",
    "    #print(chords[-1].pitch.midi - chords[-2].pitch.midi, chords[-1])\n",
    "    if chords[-2].pitch.midi - chords[-3].pitch.midi >= 6:\n",
    "        chords[-2].octave = chords[-2].octave + 1\n",
    "        \n",
    "    if chords[-1].pitch.midi - chords[-2].pitch.midi >= 12:\n",
    "        chords[-1].octave = chords[-1].octave -1\n",
    "        #print(\"yes\", chords[-1], chords[-2])\n",
    "    \n",
    "    ## last note repeat the second\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)]/len(c)) * duration_divider\n",
    "    chords.append(nota)\n",
    "    return chords\n",
    "\n",
    "def showHarmony(note_sequence, melody_seq, 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",
    "    p2 = stream.Part(id='bass')\n",
    "    p2.timeSignature = meter.TimeSignature(TS)\n",
    "    \n",
    "    melody_iterator = 0\n",
    "    for es, sequences in enumerate(note_sequence):\n",
    "        \n",
    "        melody = []\n",
    "        chords = []\n",
    "        bass = []\n",
    "        \n",
    "        \n",
    "        ### chords\n",
    "        #print(sequences)\n",
    "        chord_seq = sequences\n",
    "        test_chord = chord.Chord(chord_seq)\n",
    "        c = chord.Chord(test_chord)\n",
    "        c.root = sequences[0]\n",
    "        c.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "        #c = c.sortDiatonicAscending() # for better voice leadng but not real!\n",
    "        if es % 2 == 0: # rotating clock counterclock positions\n",
    "            #c = c.semiClosedPosition(inPlace=False,forceOctave=4)\n",
    "            pass\n",
    "        else:\n",
    "            #c = c.closedPosition(inPlace=False,forceOctave=4)\n",
    "            pass\n",
    "        if drop2:\n",
    "            try:\n",
    "                #c.pitches[0].octave = c.pitches[0].octave-1 # drop2\n",
    "                #c.pitches[-2].octave = 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",
    "        #MELODY\n",
    "        # get chord durations and apply on melody (for test purpose)\n",
    "        '''dur = 0\n",
    "        for d in chords:\n",
    "            dur = dur + d.duration.quarterLength\n",
    "        #print(dur)\n",
    "        nota = pitch.Pitch(melody_seq[es])\n",
    "        nota.octave = nota.octave\n",
    "        nota = note.Note(nota.nameWithOctave)\n",
    "        nota.duration.quarterLength = dur/2\n",
    "        melody.append(nota)\n",
    "        #melody 2nd tone\n",
    "        ###'''\n",
    "        dur = 0\n",
    "        for d in chords:\n",
    "                dur = dur + d.duration.quarterLength\n",
    "        \n",
    "        if len(melody_seq) >= len(note_sequence):\n",
    "            l = round(len(melody_seq) / len(note_sequence))\n",
    "            #print(l)\n",
    "            for m in range(l):\n",
    "                #print(dur, melody_iterator,m, dur/l, l, len(note_sequence), len(melody_seq))\n",
    "                nota = pitch.Pitch(melody_seq[melody_iterator])\n",
    "                nota.octave = nota.octave\n",
    "                nota = note.Note(nota.nameWithOctave)\n",
    "                nota.duration.quarterLength = dur/l\n",
    "                melody.append(nota)\n",
    "                melody_iterator+=1\n",
    "        \n",
    "        \n",
    "        \n",
    "        #BASS\n",
    "        # get chord durations and apply on melody (for test purpose)\n",
    "        dur = 0\n",
    "        for d in chords:\n",
    "            dur = dur + d.duration.quarterLength\n",
    "        #print(melody_seq, es)\n",
    "        nota = pitch.Pitch(sequences[0])\n",
    "        nota.octave = 2\n",
    "        nota = note.Note(nota.nameWithOctave)\n",
    "        nota.duration.quarterLength = dur\n",
    "        bass.append(nota)\n",
    "        \n",
    "        \n",
    "        \n",
    "        #p0.append(melody)\n",
    "\n",
    "        p1.append(chords)\n",
    "        p2.append(bass)\n",
    "    \n",
    "    #s.insert(0, p0)\n",
    "    s.insert(0, p1)\n",
    "    s.insert(0, p2)\n",
    "    s = s.transpose(0)\n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [
     1
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# harmonize_bass func \n",
    "def harmonize_dt_bass(scales, diatonic_cycles_string, coeficients):\n",
    "    SPG = SP.PitchGroup()\n",
    "    bass = []\n",
    "    harmonies = []\n",
    "    for s in scales:\n",
    "        temp_scale = [str(p) for p in s.pitches[:-1]]\n",
    "        scale_expansion = SPG.expansions(temp_scale)\n",
    "        #print(scale_expansion)\n",
    "        C7 = scale_expansion[0]\n",
    "        Cminus7 = scale_expansion[5]\n",
    "        C3 = scale_expansion[4]\n",
    "        Cminus3 = scale_expansion[1]\n",
    "        C5 = scale_expansion[2]\n",
    "        Cminus5 = scale_expansion[3]\n",
    "        diatonic_cycles = []\n",
    "        for i in diatonic_cycles_string:\n",
    "            if i == \"C3\":\n",
    "                diatonic_cycles.append(C3)\n",
    "            elif i == \"C5\":\n",
    "                diatonic_cycles.append(C5)\n",
    "            elif i == \"C7\":\n",
    "                diatonic_cycles.append(C7)\n",
    "            elif i == \"C-3\":\n",
    "                diatonic_cycles.append(Cminus3)\n",
    "            elif i == \"C-5\":\n",
    "                diatonic_cycles.append(Cminus5)\n",
    "            elif i == \"C-7\":\n",
    "                diatonic_cycles.append(Cminus7)\n",
    "            else:\n",
    "                print(\"diatonic_cycles_string Value Error!\")\n",
    "                \n",
    "        diatonic_cycle = SP.pitch_cicles(temp_scale,diatonic_cycles, coeficients)\n",
    "        harmonies.append(temp_scale)\n",
    "        bass.append(diatonic_cycle)\n",
    "    return bass, harmonies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": [],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C4', 'E-4', 'G4', 'B-4', 'A4', 'C4', 'E-4', 'G4', 'F4', 'A4', 'C4', 'E-4', 'G4', 'B-4', 'D4', 'F4', 'C4', 'E-4', 'G4', 'B-4', 'A4', 'C4', 'E-4', 'G4', 'F4', 'A4', 'C4', 'E-4', 'D4', 'F4', 'A4', 'C4', 'B-4', 'D4', 'F4', 'A4', 'C4', 'E-4', 'G4', 'B-4', 'F4', 'A4', 'C4', 'E-4', 'D4', 'F4', 'A4', 'C4', 'B-4', 'D4', 'F4', 'A4', 'G4', 'B-4', 'D4', 'F4', 'E-4', 'G4', 'B-4', 'D4', 'F4', 'A4', 'C4', 'E-4', 'B-4', 'D4', 'F4', 'A4', 'G4', 'B-4', 'D4', 'F4', 'E-4', 'G4', 'B-4', 'D4', 'C4', 'E-4', 'G4', 'B-4', 'A4', 'C4', 'E-4', 'G4', 'B-4', 'D4', 'F4', 'A4', 'E-4', 'G4', 'B-4', 'D4', 'C4', 'E-4', 'G4', 'B-4', 'A4', 'C4', 'E-4', 'G4', 'F4', 'A4', 'C4', 'E-4', 'D4', 'F4', 'A4', 'C4', 'E-4', 'G4', 'B-4', 'D4', 'A4', 'C4', 'E-4', 'G4', 'F4', 'A4', 'C4', 'E-4', 'D4', 'F4', 'A4', 'C4', 'B-4', 'D4', 'F4', 'A4', 'G4', 'B-4', 'D4', 'F4', 'A4', 'C4', 'E-4', 'G4', 'D4', 'F4', 'A4', 'C4', 'B-4', 'D4', 'F4', 'A4', 'G4', 'B-4', 'D4', 'F4', 'E-4', 'G4', 'B-4', 'D4', 'C4', 'E-4', 'G4', 'B-4', 'D4', 'F4', 'A4', 'C4', 'G4', 'B-4', 'D4', 'F4', 'E-4', 'G4', 'B-4', 'D4', 'C4', 'E-4', 'G4', 'B-4']\n"
     ]
    }
   ],
   "source": [
    "# Main\n",
    "\n",
    "hm = scale.HarmonicMinorScale(\"C4\")\n",
    "do = scale.DorianScale(\"C4\")\n",
    "ms = scale.MixolydianScale(\"C4\")\n",
    "ls = scale.LydianScale(\"C4\")\n",
    "\n",
    "#hb = harmonize_dt_bass([hm], [\"C3\",\"C5\",\"C7\"], [2,1,1,2])\n",
    "bass, scales = harmonize_dt_bass([do], [\"C3\",\"C7\",\"C5\"], [2,1,1,2])\n",
    "\n",
    "seq_rhythm = [1]\n",
    "voice_amount = 4 # for now because of complicated fake arpeggiator + melody stuff!\n",
    "theme_expansion_amount = 0\n",
    "scale_expansion_amount = 1 # 1st order expansion for harmonizing is according to schillinger default (in thirds)\n",
    "\n",
    "whole_seq = SP.get_whole_sequence_bass(bass, scales, voice_amount, theme_expansion_amount, scale_expansion_amount)\n",
    "#print(whole_seq)\n",
    "\n",
    "merged_seq = list(itertools.chain(*whole_seq)) # convert to [note1[harmony1], ... noteN[harmonyN]]\n",
    "print(list(itertools.chain(*merged_seq)))\n",
    "## Simple fake MELODY\n",
    "melody = []\n",
    "'''for i, m in enumerate(merged_seq):\n",
    "    melody.append(random.choice([m[1][0],m[1][1]]))\n",
    "    if i == len(merged_seq)-1:\n",
    "        melody[-1] = m[0]'''\n",
    "#melody = []\n",
    "#### TO Notes ->\n",
    "\n",
    "s = showHarmony(merged_seq, melody, seq_rhythm, len(merged_seq), (3,4), 2, arp=True, bass=False, drop2=True)\n",
    "\n",
    "#s.show('musicxml')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# tests do not delete look for modulation! \n",
    "'''\n",
    "# tests\n",
    "hb = harmonize_dt_bass([scale.HarmonicMinorScale(\"C4\"),\n",
    "                        scale.MixolydianScale(\"C4\"),\n",
    "                        scale.HarmonicMinorScale(\"F4\"),\n",
    "                       scale.MixolydianScale(\"D4\"),\n",
    "                       scale.HarmonicMinorScale(\"G4\")], \n",
    "                       [\"C3\",\"C7\",\"C5\"], [1])\n",
    "\n",
    "#print(list(itertools.chain(*hb[0]))) ## could be chained for modulations!\n",
    "\n",
    "## übergang -- \n",
    "#c = chord.Chord(list(set(scales[0]).intersection(scales[1])))\n",
    "#c = c.sortAscending()\n",
    "#print(c.sortAscending(), c.pitches)\n",
    "#myscale_2 = scale.ConcreteScale(pitches = c.pitches)\n",
    "#####\n",
    "''';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#dir(scale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#harmonize_dt_bass([hm], [\"C-7\"], [1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [python3_test]",
   "language": "python",
   "name": "Python [python3_test]"
  },
  "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
}