quick_tests_obsolete.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     0
    ],
    "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": 3,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#notes old \n",
    "\n",
    "def convert2Dto1D(data):\n",
    "    flat_array = []\n",
    "    for d in data:\n",
    "        if isinstance(d[0], list) or isinstance(d[0], tuple):\n",
    "            for l in d:\n",
    "                \n",
    "                flat_array.append(l)\n",
    "        else:\n",
    "            flat_array.append(d)\n",
    "    return flat_array\n",
    "    \n",
    "\n",
    "def showSplittedNotes(length, data, time_meter, note_sequece, duration_divider):\n",
    "    attacks = convert2Dto1D(data)\n",
    "    #TS = str(int(len(clock))) +'/'+ str(int((clock[0].duration.quarterLength*16)))\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    \n",
    "    s = stream.Score(id='mainScore')\n",
    "    \n",
    "    for seq, sequences in enumerate(attacks):\n",
    "        p0 = stream.Part(id='part0')\n",
    "        p0.timeSignature = meter.TimeSignature(TS)\n",
    "        tones = []\n",
    "        note_counter = 0\n",
    "        for i in range(len(sequences)):\n",
    "            nota = pitch.Pitch(note_sequece[note_counter%len(note_sequece)])\n",
    "            note_counter += 1\n",
    "            #nota.octave = 4\n",
    "            nota = note.Note(nota.nameWithOctave)\n",
    "            nota.duration.quarterLength = sequences[i%len(sequences)]*duration_divider\n",
    "            tones.append(nota)\n",
    "            \n",
    "        p0.append(tones)\n",
    "        s.insert(0, p0)\n",
    "    return s\n",
    "\n",
    "def showSplittedNotesWhole(length, data, time_meter, note_sequece, duration_divider):\n",
    "    attacks = convert2Dto1D(data)\n",
    "    #TS = str(int(len(clock))) +'/'+ str(int((clock[0].duration.quarterLength*16)))\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    \n",
    "    s = stream.Score(id='mainScore')\n",
    "    \n",
    "    for sequences in attacks:\n",
    "        p0 = stream.Part(id='part0')\n",
    "        p0.timeSignature = meter.TimeSignature(TS)\n",
    "        tones = []\n",
    "        note_counter = 0\n",
    "        for i in range(length):\n",
    "            nota = pitch.Pitch(note_sequece[note_counter%len(note_sequece)])\n",
    "            note_counter += 1\n",
    "            #nota.octave = 4\n",
    "            nota = note.Note(nota.nameWithOctave)\n",
    "            nota.duration.quarterLength = sequences[i%len(sequences)]*duration_divider\n",
    "            tones.append(nota)\n",
    "            \n",
    "        p0.append(tones)\n",
    "        s.insert(0, p0)\n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3, 1, 2, 2, 1, 3], [3, 1, 2, 1, 1, 1, 1, 2, 1, 3])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 4\n",
    "b = 3\n",
    "fraction = [a,b]\n",
    "\n",
    "sr = SR.Type_I(fraction)\n",
    "_sr_ = SR.Type_II(fraction)\n",
    "sr.resultant, _sr_.resultant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# notes harmony \n",
    "def showHarmony(note_sequence, myscale, 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",
    "   \n",
    "    p1 = stream.Part(id='part0')\n",
    "    p1.timeSignature = meter.TimeSignature(TS)\n",
    "    \n",
    "    for es, sequences in enumerate(note_sequence):\n",
    "        chords = []\n",
    "        \n",
    "        ### tests\n",
    "        chord_seq = [sequences[0]]+sequences[1]\n",
    "        \n",
    "        test_chord = chord.Chord(chord_seq)\n",
    "        #print(test_chord.root())\n",
    "        ###\n",
    "        \n",
    "        c = chord.Chord(test_chord)\n",
    "        c.root = sequences[0]\n",
    "        c.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "        #c.pitches[0].octave = c.pitches[0].octave-1 # drop2\n",
    "        #c.pitches[2].octave = c.pitches[2].octave+1 # drop2\n",
    "        #c = c.sortDiatonicAscending() # for better voice leadng but not real!\n",
    "        \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+1 # drop4\n",
    "                pass\n",
    "            except:\n",
    "                pass\n",
    "        \n",
    "        if arp:\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",
    "        else:\n",
    "            chords.append(c)\n",
    "        \n",
    "        p1.append(chords)\n",
    "    \n",
    "   \n",
    "    s.insert(0, p1)\n",
    "    s = s.transpose(0)\n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 627,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# notes melody, rhythm\n",
    "\n",
    "def clock_rotation(units):\n",
    "        # Rotate Lists\n",
    "        def rotate(l, x):\n",
    "          return l[-x % len(l):] + l[:-x % len(l)]\n",
    "        #clock\n",
    "        l = []\n",
    "        for i,e in enumerate(units):\n",
    "            l.append(rotate(units, i))\n",
    "            #print(rotate(units, i))\n",
    "        return l\n",
    "\n",
    "def showMultipleScore_MelodyHarmony(note_sequence, myscale, rhythm, length, time_meter, duration_divider, arp=False,bass=True):\n",
    "    #attacks = convert2Dto1D(data)\n",
    "    #TS = str(int(len(clock))) +'/'+ str(int((clock[0].duration.quarterLength*16)))\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    \n",
    "    s = stream.Score(id='mainScore')\n",
    "    p0 = stream.Part(id='part0')\n",
    "    p0.timeSignature = meter.TimeSignature(TS)\n",
    "    p1 = stream.Part(id='part0')\n",
    "    p1.timeSignature = meter.TimeSignature(TS)\n",
    "    p3 = stream.Part(id='part0')\n",
    "    p3.timeSignature = meter.TimeSignature(TS)\n",
    "    for es, sequences in enumerate(note_sequence):\n",
    "        \n",
    "        \n",
    "        tones = []\n",
    "        chords = []\n",
    "        bass_tones = []\n",
    "        \n",
    "        #tones\n",
    "        nota = pitch.Pitch(sequences[0])\n",
    "        nota.octave = nota.octave - 2\n",
    "        nota = note.Note(nota.nameWithOctave)\n",
    "        nota.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "        tones.append(nota)\n",
    "        \n",
    "        #chords\n",
    "        ### tests\n",
    "        chord_seq = [sequences[0]]+sequences[1]\n",
    "        \n",
    "        test_chord = chord.Chord(chord_seq)\n",
    "        #print(test_chord.root())\n",
    "        ###\n",
    "        \n",
    "        c = chord.Chord(sequences[1])\n",
    "        c.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "        c = c.sortAscending(inPlace=False) # for better voice leadng but not real!\n",
    "        c = c.semiClosedPosition(inPlace=False,forceOctave=4)\n",
    "        try:\n",
    "            c.pitches[1].octave = c.pitches[1].octave-1 # drop2\n",
    "            pass\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "        if arp:\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",
    "        else:\n",
    "            chords.append(c)\n",
    "            \n",
    "        #bass\n",
    "        whole_chord = [sequences[0]] + sequences[1]\n",
    "        whole_chord = chord.Chord(whole_chord)\n",
    "        nota = pitch.Pitch(whole_chord.findRoot())\n",
    "        nota.octave = 2\n",
    "        nota = note.Note(nota.nameWithOctave)\n",
    "        nota.duration.quarterLength = rhythm[es%len(rhythm)] * duration_divider\n",
    "        bass_tones.append(nota)\n",
    "            \n",
    "        p0.append(tones)\n",
    "        p1.append(chords)\n",
    "        if bass:\n",
    "            p3.append(bass_tones)\n",
    "        \n",
    "    s.insert(0, p0)\n",
    "    s.insert(0, p1)\n",
    "    if bass:\n",
    "        s.insert(0, p3)\n",
    "    s = s.transpose(5)\n",
    "    return s\n",
    "\n",
    "# NOTES FOR RHYTM\n",
    "\n",
    "def showSplittedNotes_RHYTHM(length, data, time_meter, note_sequece, duration_divider):\n",
    "    attacks = convert2Dto1D(data)\n",
    "    #TS = str(int(len(clock))) +'/'+ str(int((clock[0].duration.quarterLength*16)))\n",
    "    TS = str(time_meter[0])+'/'+str(time_meter[1])\n",
    "    \n",
    "    s = stream.Score(id='mainScore')\n",
    "    \n",
    "    for seq, sequences in enumerate(attacks):\n",
    "        p0 = stream.Part(id='part0')\n",
    "        p0.timeSignature = meter.TimeSignature(TS)\n",
    "        tones = []\n",
    "        note_counter = 0\n",
    "        for i in range(len(sequences)):\n",
    "            nota = pitch.Pitch(note_sequece[note_counter%len(note_sequece)])\n",
    "            note_counter += 1\n",
    "            nota.octave = 4-seq\n",
    "            nota = note.Note(nota.nameWithOctave)\n",
    "            nota.duration.quarterLength = sequences[i%len(sequences)]*duration_divider\n",
    "            tones.append(nota)\n",
    "            \n",
    "        p0.append(tones)\n",
    "        s.insert(0, p0)\n",
    "    return s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# SCHILLINGER INSTRUMENT DESTRIBUTION!!!\n",
    "sr_1 = SR.Type_II([3,2])\n",
    "sr_2 = SR.Type_II([4,3])\n",
    "\n",
    "random_attack_combination = SR.get_random_attack_combination(sr_1.resultant)\n",
    "random_attack_combination_2 = SR.get_random_attack_combination(sr_2.resultant)\n",
    "\n",
    "fraction = 2/4\n",
    "dp = SR.slice_by_fraction(sr_1.resultant, fraction) # slice the resultant for fun\n",
    "\n",
    "durations_pattern = random_attack_combination # rhythm\n",
    "attack_pattern = random_attack_combination_2 #instrument destribution\n",
    "\n",
    "#durations_pattern = [3,1,2,1,2,1,3] # rhythm\n",
    "#attack_pattern = [2,2] #instrument destribution\n",
    "parts = 3 # or instuments\n",
    "order_of_parts = [0,1,2]\n",
    "\n",
    "cts = SR.CTS(parts,order_of_parts,durations_pattern,attack_pattern)\n",
    "cts_pattern = cts.get_values()\n",
    "        \n",
    "#print(flattened)\n",
    "\n",
    "#note_seq = [i[0] for i in cleaned_sequence]\n",
    "note_seq = [\"c\"]\n",
    "s = showSplittedNotes_RHYTHM(cts_pattern[0], cts_pattern[1], [cts_pattern[2][0],4], note_seq , 1/4)\n",
    "s.show('musicxml')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": [],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3], [1, 2], [2, 1], [1, 1, 1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4, 2, 1, 8, 4]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# useful functions\n",
    "# get original combinations by sum\n",
    "l = _sr_.resultant\n",
    "ts = 3\n",
    "\n",
    "def get_original_combinaions_by_sum(l, ts):\n",
    "    a = []\n",
    "    for i in range(len(l)):\n",
    "        for c in itertools.combinations(l, i):\n",
    "            if sum(c) == ts and list(c) not in a:\n",
    "                a.append(list(c))\n",
    "    return a\n",
    "\n",
    "ps = get_original_combinaions_by_sum(l, ts)\n",
    "print(ps)\n",
    "p = list(itertools.permutations(ps))\n",
    "random.choice(p)\n",
    "#####\n",
    "result = sr.resultant\n",
    "fraction = 2/4\n",
    "SR.slice_by_fraction(result, fraction)\n",
    "# random attack combinations!\n",
    "SR.get_random_attack_combination(_sr_.resultant)\n",
    "###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-555-4726f4e16009>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     71\u001b[0m \u001b[0mmerged_seq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitertools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mwhole_seq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mshowMultipleScore_MelodyHarmony\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmerged_seq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmyscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mseq_rhythm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmerged_seq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbass\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m \u001b[0;31m#sp = midi.realtime.StreamPlayer(s)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[0;31m#sp.play()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-493-b215b27917ad>\u001b[0m in \u001b[0;36mshowMultipleScore_MelodyHarmony\u001b[0;34m(note_sequence, myscale, rhythm, length, time_meter, duration_divider, arp, bass)\u001b[0m\n\u001b[1;32m     33\u001b[0m         \u001b[0;31m#tones\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m         \u001b[0mnota\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpitch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPitch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[0mnota\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moctave\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnota\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moctave\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m         \u001b[0mnota\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnote\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNote\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnota\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnameWithOctave\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0mnota\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mduration\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquarterLength\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrhythm\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mes\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrhythm\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mduration_divider\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "# expansion tests mozart\n",
    "#%reset\n",
    "\n",
    "melody = []\n",
    "scales = []\n",
    "\n",
    "myscale = scale.HarmonicMinorScale('c4') # not needed for now\n",
    "\n",
    "_scale_1 = [\"D\",\"E\",\"F\",\"G\",\"A\",\"B-\",\"C#\"]\n",
    "# lacremosa\n",
    "_notes_1 = [\"D\",\"F\",\"C#\",\"D\", \"F\",\"A\",\"G\",\"A\",\n",
    "         \"E\",\"G\",\"D\",\"C#\", \"G\",\"C#\",\"C#\",\"B-\", \n",
    "         \"F\",\"D\",\"A\",\"D\", \"G\",\"E\",\"B-\",\"G\", \n",
    "         \"A\",\"D\",\"E\",\"F\", \"A\",\"G\",\"A\",\"C#\"]\n",
    "\n",
    "_scale_2 = [\"C\",\"D\",\"E-\",\"F\",\"G\",\"A-\",\"B-\"]\n",
    "# Bach Fuga Cux\n",
    "_notes_2 = [\"G\",\"E-\",\"F\",\"G\",\"C\", \"F\", \"E-\", \"D\", \"E-\",\n",
    "        \"C\",\"B-\",\"C\",\"D\",\"G\", \"C\", \"B-\", \"A-\",\"B-\"]\n",
    "\n",
    "\n",
    "### test 2 one theme multiple scales\n",
    "#albinoni\n",
    "_scale_1 = [\"G\",\"A\",\"B-\",\"C\",\"D\",\"E-\",\"F#\"]\n",
    "\n",
    "_notes_1 = [\"D\",\"C\",\"B-\",\"A\", \"G\", \"G\", \"F#\",\n",
    "        \"E-\",\"D\",\"C\",\"B-\", \"A\", \"A\", \"G\"]\n",
    "\n",
    "_scale_2 = [\"G\",\"A\",\"B-\",\"C\",\"D\",\"E-\",\"F\"]\n",
    "\n",
    "_notes_2 = [\"G\",\"F\",\"G\",\"E-\", \"F\", \"D\", \"E-\",\n",
    "        \"F\",\"E-\",\"F\",\"D\", \"E-\", \"C\", \"D\"]\n",
    "\n",
    "####\n",
    "\n",
    "scales.append(_scale_1)\n",
    "melody.append(_notes_1)\n",
    "\n",
    "scales.append(_scale_2)\n",
    "melody.append(_notes_2)\n",
    "\n",
    "#insert modulation\n",
    "common_notes = list(set(melody[0]).intersection(melody[1]))\n",
    "melody.insert(1, common_notes)\n",
    "scales.insert(1, common_notes)\n",
    "\n",
    "##################### OWN SCALE AS MELODY\n",
    "\n",
    "#as numbers\n",
    "scales = [[9,10,0,1,3,4,6,7]]\n",
    "\n",
    "# importing own melodies test\n",
    "sBach = converter.parse('midis/test.xml') \n",
    "partOnePitches = sBach.parts[0].pitches\n",
    "melody = [[p.name for p in partOnePitches]]\n",
    "scales = melody\n",
    "\n",
    "#########\n",
    "\n",
    "sr = SR.Type_II([4,3])\n",
    "seq_rhythm = _sr_.resultant\n",
    "\n",
    "#seq_rhythm = [3,2,1,2,1,6,3]\n",
    "\n",
    "#notes_permutations = SPG.melodic_forms_definition(notes)\n",
    "voice_amount = 4\n",
    "theme_expansion = 1\n",
    "scale_expansion_amount = 1 # # 1st order expansion for harmonizing is according to schillingers default\n",
    "\n",
    "whole_seq = SP.get_whole_sequence(melody, scales, voice_amount, theme_expansion, scale_expansion_amount)\n",
    "merged_seq = list(itertools.chain(*whole_seq))\n",
    "\n",
    "s = showMultipleScore_MelodyHarmony(merged_seq, myscale, seq_rhythm, len(merged_seq)*2, [3,4], 1/4, arp=False, bass=True)\n",
    "#sp = midi.realtime.StreamPlayer(s)\n",
    "#sp.play()\n",
    "#s.show('midi')\n",
    "s.show('musicxml')\n",
    "#s.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# importing own melodies\n",
    "sBach = converter.parse('midis/test.xml') \n",
    "partOnePitches = sBach.parts[0].pitches\n",
    "center = 3\n",
    "[p.pitchClass for p in partOnePitches];\n",
    "\n",
    "\n",
    "\n",
    "#sBach.show()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 683,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## PrimaryAxis ## the primary axises can change but this class describes 1 PA for now\n",
    "#### so 0 can vary!\n",
    "# what kind of data structure should i use?? scale?\n",
    "\n",
    "# primary axis PA\n",
    "# motions in PA = 0,A,B,C and combinations of them\n",
    "# AXES:\n",
    "# 0 = no motion = absolute balance\n",
    "# A = Accending from PA = unbalancing (leading away from 0)\n",
    "# B = Descending toward PA = balancing (leading to 0)\n",
    "# C = Accending towards PA = balancing (leading to 0)\n",
    "# D = Descending from PA = unbalancing (leading away from 0)\n",
    "# VARIABLES:\n",
    "# two variables = P for pitch and T for time\n",
    "# f.e.: ATP\n",
    "# f.e.2: A4T3P\n",
    "\n",
    "# generate PA class\n",
    "# 4 args scale, motion sequence, P, T\n",
    "# take PAaxes combination f.e. [2xA 1xB 3xD 1xC] or [AABDDDC]\n",
    "# take variables f.e. P = [2,1,1,2]\n",
    "# P: f.e. P = [2,1,1,2]\n",
    "# T: f.e. T = [3,1,2,2,2,3] or so\n",
    "# combine PAaxes with P and T\n",
    "# return PA melody\n",
    "\n",
    "class PrimaryAxis:\n",
    "    \n",
    "    def __init__(self, harmony_length, motion_sequence, T, P):\n",
    "        \n",
    "        self.sequence_list = [] # not needed in return\n",
    "        self.durations = [] # return\n",
    "        self.pitches = [] # return\n",
    "        self.seq_length = 0 # return\n",
    "        \n",
    "        self.harmony_length = len(motion_sequence)## !\n",
    "        self.motion_sequence = motion_sequence\n",
    "        self.P = P\n",
    "        self.T = T\n",
    "        \n",
    "        self.combinePA()\n",
    "        self.calculate_sequence()\n",
    "        self.seq_length = len(self.durations)\n",
    "    \n",
    "    def combinePA(self):\n",
    "        \n",
    "        for i in range(self.harmony_length):\n",
    "            sequence = self.motion_sequence[i],self.T[i%len(self.T)],self.P[i%len(self.P)]\n",
    "            self.sequence_list.append(sequence)\n",
    "        return\n",
    "    \n",
    "    def calculate_sequence(self):\n",
    "        for i, e in enumerate(self.sequence_list):\n",
    "            if e[0] == \"A\":\n",
    "                self.durations.append(e[1])\n",
    "                self.pitches.append([0, 0 + e[2]])\n",
    "            elif e[0] == \"B\":\n",
    "                self.durations.append(e[1])\n",
    "                self.pitches.append([0 + e[2], 0])\n",
    "            elif e[0] == \"C\":\n",
    "                self.durations.append(e[1])\n",
    "                self.pitches.append([0 - e[2],0])\n",
    "            elif e[0] == \"D\":\n",
    "                self.durations.append(e[1])\n",
    "                self.pitches.append([0, 0 - e[2]])\n",
    "            elif e[0] == \"0\":\n",
    "                self.durations.append(e[1])\n",
    "                self.pitches.append([0, 0])\n",
    "\n",
    "def convert_to_music21_sequence(sc, pitches, durations):\n",
    "    note_seq = []\n",
    "    tonic = sc.getTonic()\n",
    "    for i, o in enumerate(pitches):\n",
    "        for e, p in enumerate(o):\n",
    "            #c = sc.pitchFromDegree(p+1)\n",
    "            if p != 0:\n",
    "                c = sc.next(tonic, direction=p)\n",
    "            else:\n",
    "                c = tonic\n",
    "                \n",
    "            nota = note.Note(c.nameWithOctave)\n",
    "            if p >= 0:\n",
    "                nota.octave = 4\n",
    "            else:\n",
    "                nota.octave = 3\n",
    "            if e is 0:\n",
    "                nota.duration.quarterLength = durations[i]\n",
    "            else:\n",
    "                nota.duration.quarterLength = 1\n",
    "            note_seq.append(nota)\n",
    "    return note_seq\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 684,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# motion_sequence = \"AABDDDC\"\n",
    "\n",
    "motion_sequence = \"DDBCCADDABCDAC\"\n",
    "time_seqence = [4,2,3,1]\n",
    "pitch_sequence = [3,2,1,1,2,3]\n",
    "harmony_length = 8 #not needed for now\n",
    "PA = PrimaryAxis(harmony_length, motion_sequence, time_seqence, pitch_sequence)\n",
    "\n",
    "myscale = scale.ConcreteScale(pitches = [\"C4\", \"D4\", \"E-4\", \"F4\", \"G4\", \"A-4\", \"B-4\"]) \n",
    "\n",
    "pitches = convert_to_music21_sequence(myscale,PA.pitches, PA.durations)\n",
    "scales = [[myscale.pitchFromDegree(x+1).name for x in range(7)]]\n",
    "\n",
    "melody = [[p.name for p in pitches]]\n",
    "scales = [[myscale.pitchFromDegree(x+1).name for x in range(7)]]\n",
    "seq_rhythm = [p.duration.quarterLength for p in pitches] #for own melody test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# diatonic harmony test\n",
    "#test_scale = [\"C4\", \"D4\", \"E-4\", \"F4\", \"G4\", \"A-4\", \"B-4\"]\n",
    "myscale_2 = scale.LydianScale(\"C4\")\n",
    "test_scale = [str(p) for p in myscale_2.pitches[:-1]]\n",
    "SPG = SP.PitchGroup()\n",
    "scale_expansion = SPG.expansions(test_scale)\n",
    "C7 = scale_expansion[0]\n",
    "C3 = scale_expansion[4]\n",
    "C5 = scale_expansion[2]\n",
    "diatonic_cycle = SP.diatonic_cicles_with_coeficients(test_scale,[C7,C5,C3,C7,C5,C3],[3,1,3,1,3,1])\n",
    "#print(diatonic_cycle)\n",
    "melody = [diatonic_cycle]\n",
    "scales = [test_scale]\n",
    "\n",
    "\n",
    "sr = SR.Type_II([4,3])\n",
    "#seq_rhythm = _sr_.resultant\n",
    "seq_rhythm = [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 688,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C4', 'F4', 'B4', 'G4', 'A-4', 'D4', 'G4', 'C4', 'F4', 'D4', 'E-4', 'A-4', 'D4', 'G4', 'C4', 'A-4', 'B4', 'E-4', 'A-4', 'D4', 'G4', 'E-4', 'F4', 'B4', 'E-4', 'A-4', 'D4', 'B4', 'C4', 'F4', 'B4', 'E-4', 'A-4', 'F4', 'G4', 'C4', 'F4', 'B4', 'E-4', 'C4', 'D4', 'G4', 'C4']\n",
      "['C4', 'F4', 'B-4', 'G4', 'A4', 'D4', 'G4', 'C4', 'F4', 'D4', 'E-4', 'A4', 'D4', 'G4', 'C4', 'A4', 'B-4', 'E-4', 'A4', 'D4', 'G4', 'E-4', 'F4', 'B-4', 'E-4', 'A4', 'D4', 'B-4', 'C4', 'F4', 'B-4', 'E-4', 'A4', 'F4', 'G4', 'C4', 'F4', 'B-4', 'E-4', 'C4', 'D4', 'G4', 'C4']\n",
      "['C4', 'D4', 'E-4', 'F4', 'G4', 'C4']\n",
      "['C4', 'D4', 'E-4', 'F4', 'G4', 'C4']\n"
     ]
    }
   ],
   "source": [
    "#'with modulation'\n",
    "SPG = SP.PitchGroup()\n",
    "scales = []\n",
    "melody = []\n",
    "#### Lydian\n",
    "myscale_2 = scale.HarmonicMinorScale(\"C4\")\n",
    "test_scale = [str(p) for p in myscale_2.pitches[:-1]]\n",
    "\n",
    "scale_expansion = SPG.expansions(test_scale)\n",
    "C7 = scale_expansion[0]\n",
    "C3 = scale_expansion[4]\n",
    "C5 = scale_expansion[2]\n",
    "diatonic_cycle = SP.diatonic_cicles_with_coeficients(test_scale,[C5,C3,C7],[2,1,1,2])\n",
    "#diatonic_cycle = SR.slice_by_fraction(diatonic_cycle, 2/3)\n",
    "scales.append(test_scale)\n",
    "melody.append(diatonic_cycle)\n",
    "print(diatonic_cycle)\n",
    "####\n",
    "\n",
    "#### dorian\n",
    "myscale_2 = scale.DorianScale(\"C4\")\n",
    "test_scale = [str(p) for p in myscale_2.pitches[:-1]]\n",
    "scale_expansion = SPG.expansions(test_scale)\n",
    "C7 = scale_expansion[0]\n",
    "C3 = scale_expansion[4]\n",
    "C5 = scale_expansion[2]\n",
    "diatonic_cycle = SP.diatonic_cicles_with_coeficients(test_scale,[C5,C3,C7],[2,1,1,2])\n",
    "#diatonic_cycle = SR.slice_by_fraction(diatonic_cycle, 2/3)\n",
    "scales.append(test_scale)\n",
    "melody.append(diatonic_cycle)\n",
    "print(diatonic_cycle)\n",
    "####\n",
    "\n",
    "#### common_notes\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",
    "#print([str(p) for p in myscale_2.pitches[:-1]])\n",
    "test_scale = [str(p) for p in myscale_2.pitches[:-1]]\n",
    "scale_expansion = SPG.expansions(test_scale)\n",
    "C7 = scale_expansion[0]\n",
    "C3 = scale_expansion[4%len(scale_expansion)]\n",
    "C5 = scale_expansion[2%len(scale_expansion)]\n",
    "diatonic_cycle = SP.diatonic_cicles_with_coeficients(test_scale,[C7],[1])\n",
    "#diatonic_cycle = SR.slice_by_fraction(diatonic_cycle, 2/3)\n",
    "print(diatonic_cycle)\n",
    "scales.insert(1,test_scale)\n",
    "melody.insert(1,diatonic_cycle)\n",
    "print(diatonic_cycle)\n",
    "#insert modulation\n",
    "#common_notes = list(set(melody[0]).intersection(melody[1]))\n",
    "#melody.insert(1, common_notes)\n",
    "#scales.insert(1, common_notes)\n",
    "\n",
    "\n",
    "#rhathm\n",
    "\n",
    "seq_rhythm = [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 692,
   "metadata": {
    "code_folding": [],
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# music21 converter \n",
    "\n",
    "########################################################\n",
    "#notes_permutations = SPG.melodic_forms_definition(notes)\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",
    "#whole_seq = SP.get_whole_sequence(melody, scales, voice_amount, theme_expansion, scale_expansion_amount)\n",
    "whole_seq = SP.get_whole_sequence_bass(melody, scales, voice_amount, theme_expansion, scale_expansion_amount)\n",
    "merged_seq = list(itertools.chain(*whole_seq))\n",
    "#print(whole_seq)\n",
    "## apply original melody (correct octaves)\n",
    "for i, m in enumerate(merged_seq):\n",
    "    #merged_seq[i][0] = merged_seq[i][0] + str(pitches[i].octave)\n",
    "    pass\n",
    "    \n",
    "#s = showMultipleScore_MelodyHarmony(merged_seq, myscale, seq_rhythm, len(merged_seq)*2, [4,4], 2, arp=False, bass=False)\n",
    "s = showHarmony(merged_seq, myscale, seq_rhythm, len(merged_seq)*2, (4,4), 1, arp=True, bass=False, drop2=True)\n",
    "\n",
    "\n",
    "s.show('musicxml')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 691,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# tests\n",
    "test_scale = [\"C4\", \"D4\", \"E4\", \"F4\", \"G4\", \"A4\", \"B4\"]\n",
    "SPG = SP.PitchGroup()\n",
    "scale_expansion = SPG.expansions(test_scale)\n",
    "C7 = scale_expansion[0]\n",
    "C3 = scale_expansion[4]\n",
    "C5 = scale_expansion[2]\n",
    "diatonic_cycle = SP.diatonic_cicles_with_coeficients(test_scale,[C7,C5,C3,C7,C5,C3],[3,1,3,1,3,1])\n",
    "#print(diatonic_cycle, len(diatonic_cycle))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 597,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AbstractCyclicalScale',\n",
       " 'AbstractDiatonicScale',\n",
       " 'AbstractHarmonicMinorScale',\n",
       " 'AbstractMelodicMinorScale',\n",
       " 'AbstractOctatonicScale',\n",
       " 'AbstractOctaveRepeatingScale',\n",
       " 'AbstractRagAsawari',\n",
       " 'AbstractRagMarwa',\n",
       " 'AbstractScale',\n",
       " 'AbstractWeightedHexatonicBlues',\n",
       " 'ChromaticScale',\n",
       " 'ConcreteScale',\n",
       " 'CyclicalScale',\n",
       " 'DIRECTION_ASCENDING',\n",
       " 'DIRECTION_BI',\n",
       " 'DIRECTION_DESCENDING',\n",
       " 'DiatonicScale',\n",
       " 'DorianScale',\n",
       " 'HarmonicMinorScale',\n",
       " 'HypoaeolianScale',\n",
       " 'HypodorianScale',\n",
       " 'HypolocrianScale',\n",
       " 'HypolydianScale',\n",
       " 'HypomixolydianScale',\n",
       " 'HypophrygianScale',\n",
       " 'LocrianScale',\n",
       " 'LydianScale',\n",
       " 'MajorScale',\n",
       " 'MelodicMinorScale',\n",
       " 'MinorScale',\n",
       " 'MixolydianScale',\n",
       " 'OctatonicScale',\n",
       " 'OctaveRepeatingScale',\n",
       " 'PhrygianScale',\n",
       " 'RagAsawari',\n",
       " 'RagMarwa',\n",
       " 'ScalaScale',\n",
       " 'Scale',\n",
       " 'ScaleException',\n",
       " 'SieveScale',\n",
       " 'TERMINUS_HIGH',\n",
       " 'TERMINUS_LOW',\n",
       " 'Test',\n",
       " 'WeightedHexatonicBlues',\n",
       " 'WholeToneScale',\n",
       " '_DOC_ORDER',\n",
       " '_MOD',\n",
       " '__ALL__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " 'abc',\n",
       " 'base',\n",
       " 'common',\n",
       " 'copy',\n",
       " 'environLocal',\n",
       " 'environment',\n",
       " 'exceptions21',\n",
       " 'interval',\n",
       " 'intervalNetwork',\n",
       " 'pitch',\n",
       " 'scala',\n",
       " 'sieve',\n",
       " 'six',\n",
       " 'unittest']"
      ]
     },
     "execution_count": 597,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(scale)"
   ]
  },
  {
   "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
}