MELODY_AXIS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#includes\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "import itertools\n",
    "import random\n",
    "import numpy as np\n",
    "from music21 import *\n",
    "import schillinger.rhythm as SRhythm\n",
    "import schillinger.pitch as SPitch\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "%load_ext music21.ipython21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class SecondaryAxis:\n",
    "    SA_Dict = {}\n",
    "    def __init__(self, primary_axis,\n",
    "                 motion_sequence, \n",
    "                 T, P, \n",
    "                 time_scale=1, \n",
    "                 motion_scale=1 ):\n",
    "        self.SA_Dict = {}\n",
    "        self.time_pointer = 0\n",
    "        self.combinePA(primary_axis, motion_sequence,T,P, time_scale,motion_scale)\n",
    "        self.T = T\n",
    "        self.P = P\n",
    "        self.time_scale = time_scale\n",
    "        \n",
    "    def combinePA(self, pa, ms, T, P, time_scale, motion_scale):\n",
    "        \n",
    "        for i in range(len(ms)):\n",
    "            dd = self.calculate_seq(pa[i],ms[i], T[i%len(T)] * time_scale, P[i%len(P)]*motion_scale)\n",
    "            self.SA_Dict[i] = dd\n",
    "            #self.sequence_list.append()\n",
    "            \n",
    "    def calculate_seq(self, pa, motion_type, T, P):\n",
    "        \n",
    "        d = {}\n",
    "        mt = []\n",
    "        if motion_type == \"a\":\n",
    "            mt = [pa, pa + P]\n",
    "        elif motion_type == \"b\":\n",
    "            mt = [pa + P, pa]\n",
    "        elif motion_type == \"c\":\n",
    "            mt = [pa - P, pa]\n",
    "        elif motion_type == \"d\":\n",
    "            mt = [pa, pa - P]\n",
    "        elif motion_type == \"0\":\n",
    "            mt = [pa, pa]\n",
    "        \n",
    "        d[\"PrimaryAxis\"] = [pa,pa]\n",
    "        d[\"Motion\"] = motion_type\n",
    "        d[\"RelativeTime\"] = T\n",
    "        d[\"AbsolutePitch\"] = mt\n",
    "        #d[\"AbsolutePitch\"] = mt+pa\n",
    "        d[\"AbsoluteTime\"] = [self.time_pointer, self.time_pointer + T]\n",
    "        \n",
    "        self.time_pointer+=T\n",
    "        \n",
    "        return d\n",
    "    def Plot(self):\n",
    "        plt.title(\"AXIS MOTION\")\n",
    "        major_ticks = np.arange(-50, 100, 1)\n",
    "        plt.axes().set_xticks(major_ticks)\n",
    "        plt.axes().set_yticks(major_ticks)\n",
    "        \n",
    "        \n",
    "        \n",
    "        x = list((object['AbsoluteTime'] for object in SA.SA_Dict.values()))\n",
    "        y = list((object['AbsolutePitch'] for object in SA.SA_Dict.values()))\n",
    "        x = list(itertools.chain(*x))\n",
    "        y = list(itertools.chain(*y))\n",
    "        \n",
    "        \n",
    "        def convert_to_binary(data): # converting numbers  1 1 1 1 to oscillation 1 0 1 0 or 3 2 to 1 1 1 0 0\n",
    "            plot_array_y = np.zeros(1, dtype=np.int32)\n",
    "            plot_array_x = np.zeros(1, dtype=np.int32)\n",
    "            for i, e in enumerate(data):\n",
    "                y = np.ones(e+1, dtype=np.int32) if plot_array_y[-1] == 0 else np.zeros(e+1, dtype=np.int32)\n",
    "                plot_array_y = np.append(plot_array_y, y)\n",
    "                x = np.arange(len(y))+plot_array_x[-1]\n",
    "                plot_array_x = np.append(plot_array_x, x)\n",
    "            plot_array_y = np.append(plot_array_y, 0 if plot_array_y[-1] == 1 else 1)\n",
    "            plot_array_x = np.append(plot_array_x, plot_array_x[-1])\n",
    "            return plot_array_x,plot_array_y\n",
    "        \n",
    "        rt = list((object['RelativeTime'] for object in SA.SA_Dict.values()))\n",
    "        \n",
    "        binary_x, binary_y = convert_to_binary(rt)\n",
    "        plt.plot(binary_x, binary_y + max(y) +1, color='black')\n",
    "        \n",
    "        \n",
    "        plt.plot(x, y,color=\"black\")\n",
    "        \n",
    "        pa = list((object['PrimaryAxis'] for object in SA.SA_Dict.values()))\n",
    "        \n",
    "        pa = list(itertools.chain(*pa))\n",
    "        #print(pa,x)\n",
    "        plt.plot(x, pa, color=\"blue\")\n",
    "        \n",
    "        plt.grid(which=\"both\")#linestyle='-'\n",
    "        plt.gca().set_aspect('equal', adjustable='box')\n",
    "        plt.axis([-1, x[-1]+1, min(y) -1, max(y) +3])\n",
    "        plt.show()\n",
    "        #return plt\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Helpers\n",
    "def movementArrayToString(motion,time,pitch):\n",
    "    s = \"\"\n",
    "    for i, m in enumerate(motion):\n",
    "        t = \"T\" if time[i] <= 1 else str(time[i]) + \"T\"\n",
    "        p = \"P\" if pitch[i] <= 1 else str(pitch[i]) + \"P\"\n",
    "        #s.append(motion[i] + t + p)\n",
    "        s = s + motion[i] + t + p\n",
    "    return s\n",
    "#movementArrayToString(M,T,P)\n",
    "def movementStringToArray(mov_string):\n",
    "   \n",
    "    times = []\n",
    "    pitches = []\n",
    "    m_temp = []\n",
    "    \n",
    "    for i in range(len(mov_string)):\n",
    "        e = mov_string[i]\n",
    "        if e == \"a\" or e == \"b\" or e == \"c\" or e == \"d\" or e == \"0\":\n",
    "            m_temp.append(e)\n",
    "        else:\n",
    "            if e.isdecimal():\n",
    "                if mov_string[i+1] == \"P\":\n",
    "                    pitches.append(int(e))\n",
    "                else:\n",
    "                    times.append(int(e))\n",
    "            elif not mov_string[i-1].isdecimal():\n",
    "                if e == \"P\":\n",
    "                    pitches.append(1)\n",
    "                else:\n",
    "                    times.append(1)\n",
    "    return m_temp, times, pitches\n",
    "#l = \"04TP\" + \"b2TP\" + \"02TP\"\n",
    "#M, T, P = movementStringToArray(l)\n",
    "#M,T,P, \n",
    "#movementArrayToString(M,T,P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAC9CAYAAABWIc9uAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nqMEXERGpAWrwRUREasD/ANgzEFWphlu4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x118440fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{0: {'AbsolutePitch': [2, 3],\n",
       "  'AbsoluteTime': [0, 8],\n",
       "  'Motion': 'a',\n",
       "  'PrimaryAxis': [2, 2],\n",
       "  'RelativeTime': 8},\n",
       " 1: {'AbsolutePitch': [3, 2],\n",
       "  'AbsoluteTime': [8, 16],\n",
       "  'Motion': 'b',\n",
       "  'PrimaryAxis': [2, 2],\n",
       "  'RelativeTime': 8}}"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = [\"a\",\"b\"]\n",
    "T = [4,4]\n",
    "P = [1,1]\n",
    "pa = [2] #Primary Axis\n",
    "PA = np.kron(pa, np.ones(len(M),dtype=np.int32))\n",
    "SA = SecondaryAxis(PA, M, T, P, time_scale=2, motion_scale=1)\n",
    "SA.Plot()\n",
    "#plt.show()\n",
    "SA.SA_Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class MelodyStructure:\n",
    "    \n",
    "    Melody_Dict = {}\n",
    "    def __init__(self, secondary_axis, melody_rhythm, motion):#\n",
    "        self.Melody_Dict = {}\n",
    "        motion_resized = np.kron(motion, np.ones(len(melody_rhythm),dtype=np.chararray))\n",
    "        at = self.convertRelativeToAbsolute(melody_rhythm)\n",
    "        \n",
    "        self.Melody_Dict = self.makeMelody(melody_rhythm, at, secondary_axis.SA_Dict, motion_resized)\n",
    "        \n",
    "    def makeMelody(self, melody_rhythm, absolute_time, SA_Dict, motion):\n",
    "        d = {}\n",
    "        step_count = 0\n",
    "        for i , e in enumerate(SA_Dict.values()):\n",
    "            X_temp_end = e[\"AbsoluteTime\"][1]\n",
    "            X_temp_start = e[\"AbsoluteTime\"][0]\n",
    "            X_steps = e[\"RelativeTime\"]\n",
    "            \n",
    "            Y_start = e[\"AbsolutePitch\"][0]\n",
    "            Y_stop = e[\"AbsolutePitch\"][1]\n",
    "            \n",
    "            tx = np.arange(0, X_steps, 1)#make x steps\n",
    "            ty = np.linspace(Y_start, Y_stop, len(tx))#layout y steps on x axis\n",
    "            \n",
    "            count=0\n",
    "            for r in range(X_steps):\n",
    "                X = X_temp_start+count # make X absolute in time\n",
    "                if X in absolute_time:\n",
    "                    \n",
    "                    Y = ty[r]\n",
    "                    #convert to ascribed or inscribed motion\n",
    "                    if(motion[i] =='ascribed' and (e['Motion'] is \"a\" or e['Motion'] is \"b\")):\n",
    "                        Y = np.ceil(Y)\n",
    "                    elif(motion[i] =='inscribed' and (e['Motion'] is \"a\" or e['Motion'] is \"b\")):\n",
    "                        Y = np.floor(Y)\n",
    "                    elif(motion[i] =='ascribed' and (e['Motion'] is \"c\" or e['Motion'] is \"d\")):\n",
    "                        Y = np.floor(Y)\n",
    "                    elif(motion[i] =='inscribed' and (e['Motion'] is \"c\" or e['Motion'] is \"d\")):\n",
    "                        Y = np.ceil(Y)\n",
    "                    else:\n",
    "                        Y = np.floor(Y)\n",
    "                    d[step_count] = {\"AbsoluteTime\": [X, X+melody_rhythm[step_count]],\n",
    "                                     \"Pitch\": [int(Y),int(Y)], \n",
    "                                     \"RelativeTime\":melody_rhythm[step_count],\n",
    "                                     \"Motion\": motion[i]}\n",
    "                    step_count+=1\n",
    "                count+=1\n",
    "        return d\n",
    "    \n",
    "    def correctMelodyRhythmLength(self,resultant,length):\n",
    "        r = []\n",
    "        for i in range(length):\n",
    "            if(sum(r)<length):\n",
    "                r.append(resultant[i%len(resultant)])\n",
    "            else:\n",
    "                break\n",
    "        return r #len(resultant)==len(seq_lentgh)\n",
    "    def convertRelativeToAbsolute(self, resultant):\n",
    "        #convert \"resultant\" relative to absolute time\n",
    "        time_pointer = 0\n",
    "        abs_resultant = [0]\n",
    "        for i in resultant:\n",
    "            abs_resultant.append(i+time_pointer)\n",
    "            time_pointer+=i\n",
    "        return abs_resultant # 0,1,2,2 -> 0,1,3,5\n",
    "    def Plot(self):\n",
    "        plt.title(\"MELODY STRUCTURE\")\n",
    "        major_ticks = np.arange(-50, 100, 1)\n",
    "        plt.axes().set_xticks(major_ticks)\n",
    "        plt.axes().set_yticks(major_ticks)\n",
    "        \n",
    "        x = list((object['AbsoluteTime'] for object in self.Melody_Dict.values()))\n",
    "        y = list((object['Pitch'] for object in self.Melody_Dict.values()))\n",
    "        x = list(itertools.chain(*x))\n",
    "        y = list(itertools.chain(*y))\n",
    "        \n",
    "        \n",
    "        def convert_to_binary(data): # converting numbers  1 1 1 1 to oscillation 1 0 1 0 or 3 2 to 1 1 1 0 0\n",
    "            plot_array_y = np.zeros(1, dtype=np.int32)\n",
    "            plot_array_x = np.zeros(1, dtype=np.int32)\n",
    "            for i, e in enumerate(data):\n",
    "                y = np.ones(e+1, dtype=np.int32) if plot_array_y[-1] == 0 else np.zeros(e+1, dtype=np.int32)\n",
    "                plot_array_y = np.append(plot_array_y, y)\n",
    "                x = np.arange(len(y))+plot_array_x[-1]\n",
    "                plot_array_x = np.append(plot_array_x, x)\n",
    "            plot_array_y = np.append(plot_array_y, 0 if plot_array_y[-1] == 1 else 1)\n",
    "            plot_array_x = np.append(plot_array_x, plot_array_x[-1])\n",
    "            return plot_array_x,plot_array_y\n",
    "        \n",
    "        rt = list((object['RelativeTime'] for object in self.Melody_Dict.values()))\n",
    "        \n",
    "        binary_x, binary_y = convert_to_binary(rt)\n",
    "        plt.plot(binary_x, binary_y + max(y) +1, color='black')\n",
    "        \n",
    "        \n",
    "        plt.plot(x, y,color=\"black\")\n",
    "        \n",
    "        plt.grid(which=\"both\")#linestyle='-'\n",
    "        plt.gca().set_aspect('equal', adjustable='box')\n",
    "        plt.axis([-1, x[-1]+1, min(y) -1, max(y) +3])\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAC9CAYAAABWIc9uAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkRbw/wHTmhn1RgjzTQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11771ea20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "{0: {'AbsoluteTime': [0, 8],\n",
       "  'Motion': 'inscribed',\n",
       "  'Pitch': [2, 2],\n",
       "  'RelativeTime': 8},\n",
       " 1: {'AbsoluteTime': [8, 12],\n",
       "  'Motion': 'inscribed',\n",
       "  'Pitch': [3, 3],\n",
       "  'RelativeTime': 4},\n",
       " 2: {'AbsoluteTime': [12, 16],\n",
       "  'Motion': 'inscribed',\n",
       "  'Pitch': [2, 2],\n",
       "  'RelativeTime': 4}}"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mel_rhythm = [8,4,4]\n",
    "mel_motions = [\"inscribed\"]\n",
    "MS = MelodyStructure(SA, mel_rhythm, mel_motions)\n",
    "MS.Plot()\n",
    "MS.Melody_Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1,  2, -2,  3, -3,  4, -4,  5, -5], dtype=int32)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def numpy_oscillator(length):\n",
    "    axis1 = np.zeros(length, dtype=np.int32)\n",
    "    axis2 = np.linspace(1,length,length, dtype=np.int32)\n",
    "    #axis1 = 0\n",
    "    #axis2 = 1\n",
    "    #axis3 = nan\n",
    "    b = np.linspace(1,length,length, dtype=np.int32)\n",
    "    c = np.negative(b)\n",
    "    #y = np.linspace(0,0,1)\n",
    "    #print(np.linspace(1,5,5, dtype=np.int32))\n",
    "    #z[1:length:2] = 1\n",
    "    \n",
    "    #o = zip(x,y)\n",
    "    \n",
    "    return np.dstack((b,c)).ravel()\n",
    "#aTP  \n",
    "numpy_oscillator(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "0 1 1 -4 3 -1 -1 1 2 -2"
   ]
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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": []
  },
  {
   "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": [],
    "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 [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
}