VibratoAnalysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "685c41aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker\n",
    "from IPython.display import Audio\n",
    "import librosa as lr\n",
    "import math\n",
    "import statsmodels.api as sm\n",
    "from scipy.signal import find_peaks\n",
    "from scipy.ndimage.filters import gaussian_filter\n",
    "import os\n",
    "import time\n",
    "\n",
    "\n",
    "def freqToCent(refFreq, freq):\n",
    "    '''returns the Interval in cents'''\n",
    "    return np.log2(np.array(freq)/refFreq)*1200\n",
    "\n",
    "def centToFreq(refFreq, cent):\n",
    "    '''returns a Frequency with the offset of cent relative to refFreq'''\n",
    "    return refFreq*np.power(2,cent/1200)\n",
    "\n",
    "def getFFTBinIndexByFreq(freq, sr, n_fft):\n",
    "    '''retunrs index of FFT bin nearest to corresponding Frequency'''\n",
    "    return round(freq/(sr/n_fft))\n",
    "\n",
    "const_noteToFreqDict = {\n",
    "    'ais': 'a#',\n",
    "    'bis': 'b',\n",
    "    'his': 'b#',\n",
    "    'cis': 'c#',\n",
    "    'dis': 'd#',\n",
    "    'eis': 'e#',\n",
    "    'fis': 'f#',\n",
    "    'gis': 'g#',\n",
    "    'aes': 'a♭',\n",
    "    'bes': 'b𝄫',\n",
    "    'hes': 'b♭',\n",
    "    'ces': 'c♭',\n",
    "    'des': 'd♭',\n",
    "    'ees': 'e♭',\n",
    "    'fes': 'f♭',\n",
    "    'ges': 'g♭',\n",
    "    'h': 'b',\n",
    "    'b': 'b♭'\n",
    "}\n",
    "def noteToFreq(note, concertPitch=440):\n",
    "    '''return the Frequency coresponding to the note(s) in german notation(cis4=c#4,b3=b♭3,a4=concertPitch)'''\n",
    "    if isinstance(note, str):\n",
    "        s=note.lower()\n",
    "        for key in const_noteToFreqDict.keys():\n",
    "            if s[:len(key)]==key:\n",
    "                s=s.replace(key,const_noteToFreqDict[key])\n",
    "                break\n",
    "        return lr.note_to_hz(s)*concertPitch/440\n",
    "    else:\n",
    "        output=[]\n",
    "        for s in note:\n",
    "            s=s.lower()\n",
    "            for key in const_noteToFreqDict.keys():\n",
    "                if s[:len(key)]==key:\n",
    "                    s=s.replace(key,const_noteToFreqDict[key])\n",
    "                    break\n",
    "            output.append(lr.note_to_hz(s)*concertPitch/440)\n",
    "        return output\n",
    "    \n",
    "\n",
    "\n",
    "def chooseChannel(xAudio, sr, targetFreq, targetFreqInterval=40, drawImages=True, drawOnlyLouderChannel=True, showImage=True, fft_param=32768):\n",
    "\n",
    "\n",
    "    fft_win_length=fft_param//2\n",
    "    \n",
    "    lowerBound=centToFreq(targetFreq, -targetFreqInterval)\n",
    "    higherBound=centToFreq(targetFreq, targetFreqInterval)\n",
    "\n",
    "    lowerIndex=getFFTBinIndexByFreq(lowerBound,sr,fft_param)\n",
    "    higherIndex=getFFTBinIndexByFreq(higherBound,sr,fft_param)\n",
    "    \n",
    "    magSum=np.zeros(2)\n",
    "    stft=[[],[]]\n",
    "    maxOverall=0\n",
    "    for iChannel in range(0,2):\n",
    "\n",
    "        stft[iChannel] = lr.stft(xAudio[iChannel],n_fft=fft_param,win_length=fft_win_length,hop_length=fft_win_length//16)\n",
    "        fft_Data=np.transpose(np.abs(stft[iChannel]))\n",
    "        \n",
    "\n",
    "        \n",
    "        for frame in fft_Data:\n",
    "            maxOfFrame=max(frame[lowerIndex:higherIndex])\n",
    "            magSum[iChannel]+=maxOfFrame\n",
    "            if maxOverall<maxOfFrame:\n",
    "                maxOverall=maxOfFrame\n",
    "                \n",
    "    louderChannel=np.argmax(magSum)\n",
    "\n",
    "    fig=[None,None]\n",
    "    if drawImages:    \n",
    "        for iChannel in range(0,2):\n",
    "            if drawOnlyLouderChannel and iChannel!=louderChannel:\n",
    "                continue\n",
    "            \n",
    "            fig[iChannel] = plt.figure(figsize=(20, 10))\n",
    "            plt.tick_params(axis='x', **tickParams)\n",
    "            plt.tick_params(axis='y', **tickParams)\n",
    "            plt.imshow(np.abs(stft[iChannel]), aspect='auto', origin='lower', extent=[0, np.shape(xAudio[iChannel])[0] / sr, 0, sr/2], vmax=maxOverall)\n",
    "            plt.ylim(lowerBound,higherBound)\n",
    "            plt.ylabel('Hz', fontsize=labelFontSize)\n",
    "            plt.xlabel('seconds', fontsize=labelFontSize)\n",
    "            plt.title(f'{fileName} Ch: {iChannel}')\n",
    "            plt.colorbar()\n",
    "            if showImage:\n",
    "                plt.show()\n",
    "            else:\n",
    "                plt.close()\n",
    "            \n",
    "    else:\n",
    "        fig=None\n",
    "\n",
    "    return louderChannel, fig[louderChannel]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def pitchDetection(audio, sampleRate, targetFreq, targetFreqInterval=None, \\\n",
    "                   maxInVoiceJumpInterval=None, acPitchInsensitivity=0.05, watchFrame=-1, acWindowLength=4096, acHopLength=None):\n",
    "    '''\n",
    "    finds Frequencies found in a given Interval by using autoCorrelation and their timeStamps\n",
    "    returns: allNotesWeigthed: List of Frequencys\n",
    "             timeScale: List of corresponding timeStamps\n",
    "             outputDict: used for internal prossesing, contains all final used parameters and if there could no note be found\n",
    "\n",
    "    Parameter:\n",
    "        audio(ndarray): mono Audio(eg as returned by librosa.load)\n",
    "        sampleRate(number): samples per second\n",
    "        targetFreq(number): estimated Frequency\n",
    "        targetFreqInterval(number): maximal offset to targetFreq in cents\n",
    "        acPitchInsensitivity(number): minimal prominence for finding peaks in the autoCorrelation\n",
    "        watchFrame(int): index of Frame for graph of autoCorrelation of this Frame. -1 means None\n",
    "        acWindowLength(int): windowLength for autoCorrelation\n",
    "        acHopLength(int): hopLength for autoCorrelation\n",
    "        maxInVoiceJumpInterval(number): maximal jump in Frequency from one Frame to another in cents\n",
    "                                        if None the smallest possible will be used(takes much more calculationTime)\n",
    "\n",
    "    '''\n",
    "    \n",
    "    if acHopLength==None:\n",
    "        acHopLength=acWindowLength//16\n",
    "  \n",
    "    outputDict = {\n",
    "        'error':None,\n",
    "        'sampleRate':sampleRate,\n",
    "        'targetFreq':targetFreq,\n",
    "        'targetFreqInterval':targetFreqInterval,\n",
    "        'acPitchInsensitivity':acPitchInsensitivity,\n",
    "        'watchFrame':watchFrame,\n",
    "        'acWindowLength':acWindowLength,\n",
    "        'acHopLength':acHopLength,\n",
    "        'maxInVoiceJumpInterval':maxInVoiceJumpInterval    \n",
    "        \n",
    "    }  \n",
    "\n",
    "    if maxInVoiceJumpInterval==None:\n",
    "        maxTrys=30\n",
    "        maxInVoiceJumpInterval=50\n",
    "        lastMaxInVoiceJumpInterval=None\n",
    "        highestFail=0\n",
    "        for nTry in range(0,maxTrys):\n",
    "            _,_,outDict = pitchDetection(audio, sampleRate, targetFreq, targetFreqInterval, \\\n",
    "                    maxInVoiceJumpInterval, acPitchInsensitivity, watchFrame, acWindowLength, acHopLength)\n",
    "            if outDict['error']==None:\n",
    "                lastMaxInVoiceJumpInterval=maxInVoiceJumpInterval\n",
    "                maxInVoiceJumpInterval=(maxInVoiceJumpInterval+highestFail)/2\n",
    "                if highestFail*1.05>lastMaxInVoiceJumpInterval:\n",
    "                    break\n",
    "            elif outDict['error']=='no note in SearchInterval':\n",
    "                if lastMaxInVoiceJumpInterval==None:\n",
    "                    outputDict['error']='no note in SearchInterval'\n",
    "                    print('no note in SearchInterval, maybe check targetFreq and targetFreqInterval')\n",
    "                    break\n",
    "                else:\n",
    "                    highestFail=maxInVoiceJumpInterval\n",
    "                    maxInVoiceJumpInterval=lastMaxInVoiceJumpInterval\n",
    "\n",
    "            else:\n",
    "                outputDict['error']='no frequency in autoCorrelation found'\n",
    "                break\n",
    "                \n",
    "            #print(f'{nTry}: maxInVoiceJumpInterval: {maxInVoiceJumpInterval}')\n",
    "                \n",
    "        maxInVoiceJumpInterval=lastMaxInVoiceJumpInterval\n",
    "        \n",
    "        \n",
    "    if not outputDict['error'] is None:\n",
    "        return None, None, outputDict\n",
    "\n",
    "    allNotesWeigthed=[]\n",
    "    timeScale=[]\n",
    "    breakWindowLoop=False\n",
    "    for windowStart in range(0,len(audio)-acWindowLength,acHopLength):\n",
    "        window=audio[windowStart:windowStart+acWindowLength]\n",
    "\n",
    "        autoCor = sm.tsa.acf(window, nlags=acWindowLength)\n",
    "\n",
    "        acPeaks, acPeaksProps = find_peaks(autoCor,prominence=acPitchInsensitivity)\n",
    "        acPitches = sampleRate/acPeaks\n",
    "        if windowStart==acHopLength*watchFrame:\n",
    "            print(acPitches)\n",
    "        noteFound=False\n",
    "\n",
    "        #single autoCorrelation plot for debugging\n",
    "        if windowStart==acHopLength*watchFrame:\n",
    "\n",
    "            print(acPeaksProps[\"right_bases\"])\n",
    "            nTicks=30\n",
    "            freqScale = np.fromfunction(lambda i: sampleRate/((i+1)*(len(autoCor)/nTicks)), (nTicks,))\n",
    "            freqScale = np.round(freqScale,1)\n",
    "            a = np.arange(np.shape(autoCor)[0])\n",
    "            \n",
    "            figFrame = plt.figure(3,figsize=(20,10))\n",
    "\n",
    "            ax = figFrame.add_subplot()\n",
    "            ax.plot(a, autoCor)\n",
    "            ax.xaxis.set_ticks(np.arange(len(autoCor)/nTicks,len(autoCor)+1,len(autoCor)/nTicks))\n",
    "            ax.xaxis.set_ticklabels(freqScale)\n",
    "\n",
    "            ax.plot(a[acPeaks], autoCor[acPeaks],'x', markersize=18)\n",
    "            \n",
    "            '''for display of accuracy\n",
    "            allPitches = sampleRate/a\n",
    "            absDisToNextFreq = []\n",
    "            centDisToNextFreq = []\n",
    "            for freqIndex in range(0,len(allPitches)-1):\n",
    "                absDisToNextFreq.append(allPitches[freqIndex]-allPitches[freqIndex+1])\n",
    "                centDisToNextFreq.append(((allPitches[freqIndex]/allPitches[freqIndex+1])-1)*100)\n",
    "                print(allPitches[freqIndex+1], allPitches[freqIndex], ((allPitches[freqIndex]/allPitches[freqIndex+1])-1)*100)\n",
    "              \n",
    "            figTolerance = plt.figure(96, figsize=(20,10))\n",
    "            axTol = figTolerance.add_subplot()\n",
    "            axTol.plot(a[1:], centDisToNextFreq)\n",
    "            axTol.xaxis.set_ticks(np.arange(len(autoCor)/nTicks,len(autoCor)+1,len(autoCor)/nTicks))\n",
    "            axTol.xaxis.set_ticklabels(freqScale)\n",
    "            axTol.set_yscale('log')\n",
    "            figTolerance.show()\n",
    "            '''\n",
    "            \n",
    "        if windowStart==0:\n",
    "            if targetFreqInterval==None:\n",
    "                tmpTargetFreqInterval=5\n",
    "            else:\n",
    "                tmpTargetFreqInterval=targetFreqInterval\n",
    "        \n",
    "        condition=True\n",
    "        tryCount=0\n",
    "        while condition:\n",
    "            if windowStart==0:\n",
    "                fMin=centToFreq(targetFreq,-tmpTargetFreqInterval)\n",
    "                fMax=centToFreq(targetFreq,tmpTargetFreqInterval)\n",
    "\n",
    "\n",
    "            if len(acPitches)>0:\n",
    "\n",
    "                lastSubHarmIndex=int(fMax/acPitches[-1]+1)\n",
    "                onlySubHarms=[]\n",
    "\n",
    "                for peakIndex in range(0, len(acPitches)):\n",
    "                    pitch = acPitches[peakIndex]\n",
    "                    for iSubHarmonic in range(1,lastSubHarmIndex):\n",
    "                        if pitch>fMin/iSubHarmonic and pitch<fMax/iSubHarmonic:\n",
    "                            index=round(sampleRate/pitch)\n",
    "                            onlySubHarms.append([pitch,iSubHarmonic,peakIndex,index])\n",
    "                            noteFound=True\n",
    "                            if windowStart==acHopLength*watchFrame:\n",
    "                                print(iSubHarmonic, pitch, pitch*iSubHarmonic, pitch - sampleRate/(index+1))\n",
    "\n",
    "                if noteFound:            \n",
    "                    weigthsTotal=0\n",
    "                    freqsTotal=0\n",
    "                    for subHarm in onlySubHarms:\n",
    "                        weigth=acPeaksProps[\"prominences\"][subHarm[2]] #prominence of the peak as weight\n",
    "                        weigthsTotal+=weigth\n",
    "                        freqsTotal+=subHarm[0]*subHarm[1]*weigth\n",
    "\n",
    "                    note=freqsTotal/weigthsTotal\n",
    "\n",
    "                    allNotesWeigthed.append(note)\n",
    "                    timeScale.append(windowStart/sampleRate)\n",
    "\n",
    "                    #\n",
    "                    fMin=centToFreq(note,-maxInVoiceJumpInterval)\n",
    "                    fMax=centToFreq(note,maxInVoiceJumpInterval)\n",
    "                    condition=False\n",
    "                #if no note found anymore, the note should have ended\n",
    "                else:\n",
    "                    if windowStart==0 and targetFreqInterval==None:\n",
    "                        tmpTargetFreqInterval*=1.5\n",
    "                        if tmpTargetFreqInterval>100:\n",
    "                            print('targetFreqInterval>100 cent: maybe check targetFreq?')\n",
    "                            break\n",
    "                    else:\n",
    "                        outputDict['error']='no note in SearchInterval'\n",
    "                        breakWindowLoop=True\n",
    "            else:\n",
    "                outputDict['error']='no freq in autoCor found'\n",
    "                breakWindowLoop=True\n",
    "            \n",
    "            if windowStart==0:\n",
    "                condition= not noteFound\n",
    "\n",
    "            else:\n",
    "                condition=False\n",
    "                \n",
    "            if tryCount>20:\n",
    "                condition=False\n",
    "                print('tryCount>20 for tmpTargetFreqInterval')\n",
    "            tryCount+=1\n",
    "                \n",
    "        if breakWindowLoop:\n",
    "            break\n",
    "            \n",
    "    \n",
    "    return allNotesWeigthed, timeScale, outputDict\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "  \n",
    "def VibratoDetection(freqs, audioDuration, times=None, referencePitch=None, useVibratoOnlyforAmps=True, \\\n",
    "                     timeSensitiveAverages=True, maxVibratoFreq=15, minSmallPeaksFactor=0.30,\\\n",
    "                     minFactorAtimedProminece=0.6, minimaEdgesMinFactor=0.7, drawPlots=True, showPlots=True):\n",
    "    '''\n",
    "    returns: \n",
    "        vibAmpsAvg : avarage Amplitude of Vibrato\n",
    "        vibFreqAvg : avarage Frequency of Vibrato\n",
    "        vibAmps : list of Amplitudes\n",
    "        vibFreqs : list of Frequencys\n",
    "        vibTimes : timestamps corresponding to vibAmps and vibFreqs\n",
    "        extrema : List of all indices of the Vibrato Extrema\n",
    "        startsWithMinima : True if first Extreme is a Minima\n",
    "        fig: Figure of Plot if drawn\n",
    "\n",
    "    \n",
    "    Parameter:\n",
    "        freqs : List of Frequency in which the Vibrato is to detect\n",
    "        audioDuration: duration of audioFile\n",
    "        times : only needed for plot, timeStamps for freqs\n",
    "        referencePitch=None : freqs are internally transformed to cent-Values, which needs a ReferencePitch. if None the average will be taken\n",
    "        useVibratoOnlyforAmps=True : uses only Vibrato without slow pitch movement to calculate Amplitudes\n",
    "        timeSensitiveAverages=True : calculates averages with wavelength as weigth(to counter higher Frequencys having more points and therefore more impact on average)\n",
    "        maxVibratoFreq=15 : highest possible Frequency for the Vibrato to be expected\n",
    "        minSmallPeaksFactor=0.30 : Factor \n",
    "        minFactorAtimedProminece=0.75\n",
    "        minimaEdgesMinFactor=0.7\n",
    "        drawPlots=True\n",
    "        showPlots=True\n",
    "\n",
    "    \n",
    "    '''\n",
    "\n",
    "    if referencePitch==None:\n",
    "        referencePitch=np.mean(freqs)\n",
    "    \n",
    "    generalPitchesCent = freqToCent(referencePitch,gaussian_filter(freqs, 15))\n",
    "    freqsCent = freqToCent(referencePitch,freqs)\n",
    "    centDiff = freqsCent-generalPitchesCent\n",
    "    smoothedCentDiff = gaussian_filter(centDiff, 3)\n",
    "\n",
    "    minDistance = np.floor((len(centDiff)/audioDuration)/maxVibratoFreq)\n",
    "    maximas,peakProps = find_peaks(smoothedCentDiff, prominence=0.1, width=3, distance=minDistance)\n",
    "\n",
    "\n",
    "    if len(peakProps['prominences'])<3:\n",
    "        return None, None, None, None, None, None, None, None, 'not enough peaks in Vibrato'\n",
    "\n",
    "    #filter small maximas relative to surrounding maximas\n",
    "    smallPeaks=[]\n",
    "\n",
    "    if peakProps['prominences'][0]<peakProps['prominences'][1]*minSmallPeaksFactor \\\n",
    "    and peakProps['prominences'][0]<peakProps['prominences'][2]*minSmallPeaksFactor:\n",
    "        smallPeaks.append(0)\n",
    "\n",
    "    for i in range(1,len(maximas)-1):\n",
    "        if peakProps['prominences'][i-1]*minSmallPeaksFactor>peakProps['prominences'][i] \\\n",
    "        and peakProps['prominences'][i]<peakProps['prominences'][i+1]*minSmallPeaksFactor:\n",
    "            smallPeaks.append(i)\n",
    "\n",
    "    if peakProps['prominences'][-1]<peakProps['prominences'][-2]*minSmallPeaksFactor \\\n",
    "    and peakProps['prominences'][-1]<peakProps['prominences'][-3]*minSmallPeaksFactor:\n",
    "        smallPeaks.append(-1)\n",
    "\n",
    "    #print(smallPeaks)\n",
    "\n",
    "    mask = np.ones(len(maximas), dtype=bool)\n",
    "    mask[smallPeaks] = False\n",
    "\n",
    "    nPeaks = len(maximas)\n",
    "    for key in peakProps:\n",
    "        #print(key, len(peakProps[key]))\n",
    "        if len(peakProps[key])==nPeaks:\n",
    "            peakProps[key] = peakProps[key][mask]\n",
    "\n",
    "    maximas = maximas[mask]\n",
    "\n",
    "\n",
    "    #filter anormal timed maximas if not big enough\n",
    "    timeBetweenPeaks=[]\n",
    "    for i in range(0,len(maximas)-1):\n",
    "        timeBetweenPeak = times[maximas[i+1]] - times[maximas[i]]\n",
    "        timeBetweenPeaks.append(timeBetweenPeak)\n",
    "        \n",
    "    if len(timeBetweenPeaks)>4:\n",
    "        Atimed=[]\n",
    "        for i in range(0,len(timeBetweenPeaks)-1):\n",
    "\n",
    "            if i==0:\n",
    "                outl=timeBetweenPeaks[i+2]\n",
    "                inl=timeBetweenPeaks[i]\n",
    "                inr=timeBetweenPeaks[i]\n",
    "                outr=timeBetweenPeaks[i+1]\n",
    "            elif i==1:\n",
    "                outl=timeBetweenPeaks[i+2]\n",
    "                inl=timeBetweenPeaks[i-1]\n",
    "                inr=timeBetweenPeaks[i]\n",
    "                outr=timeBetweenPeaks[i+1]\n",
    "            elif i==len(timeBetweenPeaks):\n",
    "                outl=timeBetweenPeaks[i-2]\n",
    "                inl=timeBetweenPeaks[i-1]\n",
    "                inr=timeBetweenPeaks[i]\n",
    "                outr=timeBetweenPeaks[i-3]\n",
    "            else:\n",
    "                outl=timeBetweenPeaks[i-2] # outer left\n",
    "                inl=timeBetweenPeaks[i-1]\n",
    "                inr=timeBetweenPeaks[i] # inner right\n",
    "                outr=timeBetweenPeaks[i+1]\n",
    "\n",
    "            seperatedRatio = np.mean([outl/inl,outl/inr,outr/inl,outr/inr])\n",
    "            combinedRatio = np.mean([(inl+inr)/outl,(inl+inr)/outr])\n",
    "\n",
    "            if seperatedRatio<1:\n",
    "                seperatedRatio=1/seperatedRatio\n",
    "            if combinedRatio<1:\n",
    "                combinedRatio=1/combinedRatio \n",
    "\n",
    "\n",
    "            if combinedRatio<seperatedRatio \\\n",
    "            and peakProps['prominences'][i]<minFactorAtimedProminece:\n",
    "                #print('atimes: ', i)\n",
    "                Atimed.append(i)\n",
    "\n",
    "\n",
    "        mask = np.ones(len(maximas), dtype=bool)\n",
    "        mask[Atimed] = False\n",
    "\n",
    "        nPeaks = len(maximas)\n",
    "        for key in peakProps:\n",
    "            if len(peakProps[key])==nPeaks:\n",
    "                peakProps[key] = peakProps[key][mask]\n",
    "\n",
    "        maximas = maximas[mask]\n",
    "\n",
    "\n",
    "        \n",
    "    #for minimas simply take lowest Value between two maximas\n",
    "    minimas=[]\n",
    "    \n",
    "    for i in range(0,len(maximas)-1):\n",
    "\n",
    "        minimaIndex=np.argmin(smoothedCentDiff[maximas[i]:maximas[i+1]])+maximas[i]\n",
    "\n",
    "        if i==0: # for possible minima in front of first peak\n",
    "            minimaIndexBefore = np.argmin(smoothedCentDiff[:maximas[i]])\n",
    "            peakValue = smoothedCentDiff[maximas[i]]\n",
    "\n",
    "            if peakValue-smoothedCentDiff[minimaIndexBefore] > (peakValue-smoothedCentDiff[minimaIndex])*minimaEdgesMinFactor:\n",
    "                minimas.append(minimaIndexBefore)\n",
    "\n",
    "        minimas.append(minimaIndex)\n",
    "\n",
    "\n",
    "        if i==len(maximas)-2: # for possible minima behind last peak\n",
    "            minimaIndexBehind=np.argmin(smoothedCentDiff[maximas[i+1]:])+maximas[i+1]\n",
    "            peakValue = smoothedCentDiff[maximas[i]]\n",
    "\n",
    "            if peakValue-smoothedCentDiff[minimaIndexBehind] > (peakValue-smoothedCentDiff[minimaIndex])*minimaEdgesMinFactor:\n",
    "                minimas.append(minimaIndexBehind)\n",
    "\n",
    "                \n",
    "                \n",
    "    if minimas[0]<maximas[0]:\n",
    "        startsWithMinima=True\n",
    "    else:\n",
    "        startsWithMinima=False\n",
    "\n",
    "        \n",
    "    extrema = np.empty(len(maximas)+len(minimas), dtype=int)\n",
    "    if startsWithMinima:\n",
    "        extrema[0::2]=minimas\n",
    "        extrema[1::2]=maximas\n",
    "    else:\n",
    "        extrema[0::2]=maximas\n",
    "        extrema[1::2]=minimas\n",
    "    \n",
    "    \n",
    "    #calc Amplitudes and VibratoFrequencys\n",
    "    vibAmps=[]\n",
    "    vibFreqs=[]\n",
    "    vibTimes=[]\n",
    "    weigths=[]\n",
    "\n",
    "    for i in range(0,len(extrema)-1):\n",
    "\n",
    "        timeStamp=(times[extrema[i+1]]+times[extrema[i]])/2\n",
    "        vibTimes.append(timeStamp)\n",
    "\n",
    "        if useVibratoOnlyforAmps:   \n",
    "            a=smoothedCentDiff[extrema[i]]\n",
    "            b=smoothedCentDiff[extrema[i+1]]\n",
    "\n",
    "        else:\n",
    "            a=freqToCent(targetFreq,freqs[extrema[i]])\n",
    "            b=freqToCent(targetFreq,freqs[extrema[i+1]])\n",
    "\n",
    "        amp=abs(a-b)/2\n",
    "        vibAmps.append(amp)\n",
    "\n",
    "\n",
    "        waveLength=amp=(times[extrema[i+1]]-times[extrema[i]])*2\n",
    "        vibFreqs.append(1/waveLength)\n",
    "        weigths.append(waveLength)\n",
    "\n",
    "\n",
    "    if timeSensitiveAverages:\n",
    "        vibAmpsAvg=np.average(vibAmps,weights=weigths)\n",
    "        vibFreqAvg=np.average(vibFreqs,weights=weigths)\n",
    "    else:\n",
    "        vibAmpsAvg=np.average(vibAmps)\n",
    "        vibFreqAvg=np.average(vibFreqs)\n",
    "    \n",
    "    \n",
    "        \n",
    "    if drawPlots:\n",
    "        if times.size==0:\n",
    "            print('Could not draw plot, parameter times not given')\n",
    "        else:\n",
    "            fig = plt.figure(figsize=(20,10))\n",
    "            plt.title('VibratoOnlyCent')\n",
    "            plt.plot(times, smoothedCentDiff)\n",
    "            plt.plot(times[maximas], smoothedCentDiff[maximas], 'x', markersize=18)\n",
    "            plt.plot(times[minimas], smoothedCentDiff[minimas], 'x', markersize=18)\n",
    "            \n",
    "            if showPlots:\n",
    "                plt.show()\n",
    "            else:\n",
    "                plt.close()\n",
    "    else:\n",
    "        fig=None\n",
    "        \n",
    "        \n",
    "    return vibAmps, vibFreqs, vibTimes, vibAmpsAvg, vibFreqAvg, extrema, startsWithMinima, fig, ''\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "const_tickSteps = [5,2.5,1]\n",
    "\n",
    "def calcTickStepSize(valRange, minTicks=5, maxTicks=15):\n",
    "    '''returns a tickStep so that valRange can be devided in at least minTicks and at most maxTicks'''\n",
    "    \n",
    "    if maxTicks/minTicks<2.5:\n",
    "        print('minTicks and maxTicks to close, they need to have at least a factor of 2.5')\n",
    "        return None\n",
    "    \n",
    "    stepIndex=2\n",
    "    decimalFactor=1\n",
    "    tickStep=const_tickSteps[stepIndex]\n",
    "    while not minTicks<=valRange/tickStep<=maxTicks:\n",
    "        if valRange/tickStep<minTicks:\n",
    "            stepIndex+=1\n",
    "            if stepIndex==len(const_tickSteps):\n",
    "                decimalFactor/=10\n",
    "                stepIndex=0\n",
    "        if valRange/tickStep>maxTicks:\n",
    "            stepIndex-=1\n",
    "            if stepIndex==-1:\n",
    "                decimalFactor*=10\n",
    "                stepIndex=len(const_tickSteps)-1\n",
    "                \n",
    "\n",
    "        tickStep=const_tickSteps[stepIndex]*decimalFactor\n",
    "\n",
    "    return tickStep\n",
    "\n",
    "\n",
    "def drawPlot(x, y, targetFreq, figSize=None, style=None, fileName=None, vibAmpsAvg=None, vibFreqAvg=None, showPlot=True, combinedAudio=False):\n",
    "    '''helpfunction for drawPlots()'''\n",
    "    \n",
    "\n",
    "    refFreq=targetFreq\n",
    "    \n",
    "    timeLabel = 'Time (s)'\n",
    "    pitchHzLabel = 'Pitch (Hz)'\n",
    "    pitchCentLabel = 'Pitch (Cent)'\n",
    "    vibAmpLabel = 'Amplitude (cent)'\n",
    "    vibFreqLabel = 'Frequency (Hz)'\n",
    "    \n",
    "    \n",
    "    if fileName==None:\n",
    "        pitchTitle = 'Pitch'\n",
    "        vibAmpTitle = 'Vibrato Amplitude'\n",
    "        vibFreqTitle = 'Vibrato Frequency'\n",
    "        combiTitle = 'Vibrato Analysis'\n",
    "    elif combinedAudio:\n",
    "        pitchTitle = 'Pitch: '+fileName[-1]\n",
    "        vibAmpTitle = 'Vibrato Amplitude: '+fileName[-1]\n",
    "        vibFreqTitle = 'Vibrato Frequency: '+fileName[-1]\n",
    "        combiTitle = 'Vibrato Analysis: '+fileName[-1]\n",
    "        \n",
    "    else:\n",
    "        pitchTitle = 'Pitch: '+fileName\n",
    "        vibAmpTitle = 'Vibrato Amplitude: '+fileName\n",
    "        vibFreqTitle = 'Vibrato Frequency: '+fileName\n",
    "        combiTitle = 'Vibrato Analysis: '+fileName\n",
    "    \n",
    "\n",
    "    \n",
    "    fig, host = plt.subplots(figsize=figSize)     \n",
    "    host.set_xlabel(timeLabel, fontsize=labelFontSize) \n",
    "    host.tick_params(axis='x', **tickParams)\n",
    "    host.tick_params(axis='y', **tickParams)\n",
    "    \n",
    "    if style=='pitch':\n",
    "        \n",
    "        par1 = host.twinx()\n",
    "        par1.tick_params(axis='y', **tickParams)\n",
    "        if combinedAudio:\n",
    "            ps = []\n",
    "            for iFile in range(0, len(x)):\n",
    "                ps.append(host.plot(x[iFile],y[iFile], label=fileName[iFile]))\n",
    "            host.legend()\n",
    "        else:\n",
    "            p1 = host.plot(x,y, color=pitchColor)\n",
    "        \n",
    "        host.axhline(refFreq, color=pitchColor, linestyle=':')\n",
    "        \n",
    "        host.set_title(pitchTitle, fontsize=titleFontSize)\n",
    "        host.set_ylabel(pitchHzLabel, fontsize=labelFontSize)\n",
    "        par1.set_ylabel(pitchCentLabel, fontsize=labelFontSize)\n",
    "        \n",
    "        ylimCent=[freqToCent(refFreq,host.get_ylim()[0]),freqToCent(refFreq,host.get_ylim()[1])]\n",
    "        ylimCentDiff=ylimCent[1]-ylimCent[0]\n",
    "\n",
    "        tickStep = calcTickStepSize(ylimCentDiff)\n",
    "        firstTickCent = tickStep * math.ceil(ylimCent[0] / tickStep)\n",
    "        centTicks = np.arange(firstTickCent, ylimCent[1],tickStep)\n",
    "        centTicksHz= centToFreq(refFreq,centTicks)\n",
    "\n",
    "        par1.set_ylim(host.get_ylim())\n",
    "        par1.yaxis.set_major_locator(matplotlib.ticker.FixedLocator(centTicksHz))\n",
    "\n",
    "        if tickStep>=1:\n",
    "            strCentTicks = [f'{t:.0f}' for t in centTicks]\n",
    "        else:\n",
    "            strCentTicks = centTicks\n",
    "\n",
    "        par1.set_yticklabels(strCentTicks)\n",
    "        \n",
    "    elif style=='vibAmp':\n",
    "        if combinedAudio:\n",
    "            ps = []\n",
    "            for iFile in range(0, len(x)):\n",
    "                ps.append(host.plot(x[iFile],y[iFile], label=fileName[iFile]))\n",
    "            host.legend()\n",
    "        else:\n",
    "            p1 = host.plot(x,y, color=vibAmpColor)\n",
    "            host.axhline(vibAmpsAvg, color=vibAmpColor, linestyle=':')\n",
    "        \n",
    "        host.set_title(vibAmpTitle, fontsize=titleFontSize)\n",
    "        host.set_ylabel(vibAmpLabel, fontsize=labelFontSize)\n",
    "\n",
    "    \n",
    "    elif style=='vibFreq':\n",
    "        if combinedAudio:\n",
    "            ps = []\n",
    "            for iFile in range(0, len(x)):\n",
    "                ps.append(host.plot(x[iFile],y[iFile], label=fileName[iFile]))\n",
    "            host.legend()\n",
    "        else:\n",
    "            p1 = host.plot(x,y, color=vibFreqColor)\n",
    "            host.axhline(vibFreqAvg, color=vibFreqColor, linestyle=':')\n",
    "            \n",
    "        host.set_title(vibFreqTitle, fontsize=titleFontSize)\n",
    "        host.set_ylabel(vibFreqLabel, fontsize=labelFontSize)\n",
    "\n",
    "\n",
    "    \n",
    "    elif style=='combi':\n",
    "\n",
    "        #pitch\n",
    "        par1 = host.twinx()\n",
    "        host.axhline(refFreq, color=pitchColor, linestyle=':')\n",
    "        \n",
    "        par1.spines.left.set_visible(True)\n",
    "        #par1.spines.right.set_visible(False)\n",
    "        par1.spines.left.set_position((\"axes\", -combiAxesOffset))\n",
    "        par1.yaxis.set_label_position('left')\n",
    "        par1.yaxis.set_ticks_position('left')\n",
    "        \n",
    "        p1 = host.plot(x[0],y[0], color=pitchColor, linewidth=combiPitchLineWidth)\n",
    "        host.set_ylabel(pitchHzLabel, fontsize=labelFontSize)\n",
    "        par1.set_ylabel(pitchCentLabel, fontsize=labelFontSize)\n",
    "        \n",
    "        ylimCent=[freqToCent(refFreq,host.get_ylim()[0]),freqToCent(refFreq,host.get_ylim()[1])]\n",
    "        ylimCentDiff=ylimCent[1]-ylimCent[0]\n",
    "\n",
    "        tickStep = calcTickStepSize(ylimCentDiff)\n",
    "        firstTickCent = tickStep * math.ceil(ylimCent[0] / tickStep)\n",
    "        centTicks = np.arange(firstTickCent, ylimCent[1],tickStep)\n",
    "        centTicksHz= centToFreq(refFreq,centTicks)\n",
    "\n",
    "        par1.set_ylim(host.get_ylim())\n",
    "        par1.yaxis.set_major_locator(matplotlib.ticker.FixedLocator(centTicksHz))\n",
    "\n",
    "        if tickStep>=1:\n",
    "            strCentTicks = [f'{t:.0f}' for t in centTicks]\n",
    "        else:\n",
    "            strCentTicks = centTicks\n",
    "\n",
    "        par1.set_yticklabels(strCentTicks)\n",
    "        \n",
    "        \n",
    "        host.tick_params(axis='y', colors=pitchColor, **tickParams)\n",
    "        par1.tick_params(axis='y', colors=pitchColor, **tickParams)\n",
    "        \n",
    "        host.yaxis.label.set_color(pitchColor)\n",
    "        par1.yaxis.label.set_color(pitchColor)\n",
    "        \n",
    "        \n",
    "        #vibAmp\n",
    "        par2 = host.twinx()\n",
    "        \n",
    "        p2 = par2.plot(x[1],y[1], color=vibAmpColor, linewidth=combiVibAmpLineWidth)\n",
    "        par2.set_ylabel(vibAmpLabel, fontsize=labelFontSize)\n",
    "        \n",
    "        par2.tick_params(axis='y', colors=vibAmpColor, **tickParams)\n",
    "        par2.yaxis.label.set_color(vibAmpColor)\n",
    "        \n",
    "        \n",
    "        #vibFreq\n",
    "        par3 = host.twinx()\n",
    "        \n",
    "        par3.spines.right.set_position((\"axes\", 1+combiAxesOffset))\n",
    "        p3 = par3.plot(x[1],y[2], color=vibFreqColor, linewidth=combiVibFreqLineWidth)\n",
    "        par3.set_ylabel(vibFreqLabel, fontsize=labelFontSize)\n",
    "        \n",
    "        par3.tick_params(axis='y', colors=vibFreqColor, **tickParams)\n",
    "        par3.yaxis.label.set_color(vibFreqColor)\n",
    "        \n",
    "        \n",
    "        #general\n",
    "          \n",
    "        par3.set_zorder(1)\n",
    "        par3.patch.set_visible(True)\n",
    "        par2.set_zorder(2)\n",
    "        host.set_zorder(4)\n",
    "        host.patch.set_visible(False)\n",
    "        \n",
    "        host.set_title(combiTitle, fontsize=titleFontSize)\n",
    "\n",
    "        \n",
    "    else:\n",
    "        p1 = host.plot(x,y)\n",
    "        print('unknown style:', style)\n",
    "        \n",
    "    if showPlot:\n",
    "        plt.show()\n",
    "    else: \n",
    "        plt.close()\n",
    "    \n",
    "    return fig\n",
    "\n",
    "\n",
    "def drawPlots(freqs, times, vibAmps, vibFreqs, vibTimes, targetFreq, fileName=None, vibAmpsAvg=None, vibFreqAvg=None, figSize=(20,10), \\\n",
    "              combiPlot=True, pitchPlot=True, vibAmpPlot=True, vibFreqPlot=True, showPlots=True, combinedAudio=False):\n",
    "    '''\n",
    "    draws and returns different plots   \n",
    "    \n",
    "    '''\n",
    "    figs=[]\n",
    "    figNames=[]\n",
    "    \n",
    "    if combiPlot:\n",
    "        figs.append(drawPlot([times,vibTimes], [freqs, vibAmps, vibFreqs], targetFreq, figSize, 'combi', fileName, showPlot=showPlots, combinedAudio=combinedAudio))\n",
    "        figNames.append('combi')\n",
    "        \n",
    "    if pitchPlot:\n",
    "        figs.append(drawPlot(times, freqs, targetFreq, figSize, 'pitch', fileName, showPlot=showPlots, combinedAudio=combinedAudio))\n",
    "        figNames.append('pitch')\n",
    "        \n",
    "    if vibAmpPlot:\n",
    "        figs.append(drawPlot(vibTimes, vibAmps, targetFreq, figSize, 'vibAmp', fileName, vibAmpsAvg=vibAmpsAvg, showPlot=showPlots, combinedAudio=combinedAudio))\n",
    "        figNames.append('vibAmp')\n",
    "            \n",
    "    if vibFreqPlot:\n",
    "        figs.append(drawPlot(vibTimes, vibFreqs, targetFreq, figSize, 'vibFreq', fileName, vibFreqAvg=vibFreqAvg, showPlot=showPlots, combinedAudio=combinedAudio))\n",
    "        figNames.append('vibFreq')\n",
    "            \n",
    "    figures=[figs,figNames]\n",
    "    return figures\n",
    "\n",
    "\n",
    "def saveToFile(figures, figureNames, path):\n",
    "    '''saves a List of Plots to Files'''\n",
    "    #path='diagrams\\\\'+recordingFolder+'\\\\'+fileName.split('.')[0]+'\\\\'\n",
    "    os.makedirs(path, exist_ok=True)\n",
    "    for i in range(0, len(figures)):\n",
    "        figures[i].savefig(os.path.join(path,figureNames[i]))\n",
    "        \n",
    "        \n",
    "def writeResultsToFile(fileName, vibAmpsAvg, vibFreqAvg, snippetNotes, paramDict):\n",
    "    '''writes results into a TextFile'''\n",
    "    \n",
    "    resultFile=os.path.join(diagramPath,'results.txt')\n",
    "    if not os.path.isfile(resultFile):\n",
    "        headLine = 'fileName\\tavgAmp\\tavgFreq\\tComment\\ttargetFreq\\trecording\\tsection\\n'\n",
    "        with open(resultFile, 'w')as file:\n",
    "            file.write(headLine)\n",
    "            \n",
    "    recording = fileName.split('_')[0]\n",
    "    section=fileName.split('_')[1].split('.')[0]\n",
    "    output=''\n",
    "    snippetResultStr = f'{fileName}\\t{vibAmpsAvg:.2f}\\t{vibFreqAvg:.2f}\\t{snippetNotes}\\t{paramDict[\"targetFreq\"]}\\t{recording}\\t{section}\\n' \n",
    "\n",
    "    with open(resultFile, mode='r',) as file:\n",
    "        snippetHasAlreadyLine=False\n",
    "        for line in file:\n",
    "            snippetName=line.split('\\t')[0]\n",
    "\n",
    "            if snippetName==fileName:\n",
    "                snippetHasAlreadyLine=True\n",
    "                line = snippetResultStr\n",
    "            #print(line.rstrip('\\n'))\n",
    "\n",
    "            output+=line#+'\\n'\n",
    "\n",
    "        if not snippetHasAlreadyLine:\n",
    "            output+=snippetResultStr\n",
    "        output.rstrip('\\n')\n",
    "    with open(resultFile, mode='w',) as file:\n",
    "        file.write(output)\n",
    "\n",
    "def analyseAudioFile(audioFile, targetFreq, specificDiagramPath, printAdditionalInfos):\n",
    "    audioDuration = None #None:whole File\n",
    "    xAudio, sr = lr.load(audioFile,mono=False,sr=None,offset=0,duration=audioDuration)\n",
    "\n",
    "    if audioDuration==None:\n",
    "        audioDuration=len(xAudio[0])/sr\n",
    "    #display(Audio(xAudio, rate=sr))\n",
    "    \n",
    "\n",
    "    targetFreqInterval = 140\n",
    "    snippetNotes=''\n",
    "    channel, fftFig = chooseChannel(xAudio, sr, targetFreq, targetFreqInterval, showImage=False)\n",
    "\n",
    "    if printAdditionalInfos:\n",
    "        print('file:',fileName)\n",
    "        print(noteName)\n",
    "        print('targetFreq: ',targetFreq)\n",
    "        print('channel', channel)\n",
    "    else:\n",
    "        print('file:',fileName, end='')\n",
    "\n",
    "    freqs, times, outDict = pitchDetection(xAudio[channel], sr, targetFreq, targetFreqInterval=None)\n",
    "    \n",
    "    if printAdditionalInfos:\n",
    "        for k, v in outDict.items():\n",
    "            print(k,v)\n",
    "\n",
    "    if not outDict['error'] is None:\n",
    "        snippetNotes+=outDict['error']\n",
    "        writeResultsToFile(fileName, 0, 0, snippetNotes, outDict)\n",
    "        saveToFile([fftFig], ['fft'], specificDiagramPath)\n",
    "        print('..Error')\n",
    "        return None\n",
    "    freqsArr = np.array(freqs)\n",
    "    timesArr = np.array(times)\n",
    "\n",
    "    vibAmps, vibFreqs, vibTimes, vibAmpsAvg, vibFreqAvg, extrema, startsWithMinima, vibOnlyFig, vibComment = VibratoDetection(freqsArr, audioDuration, timesArr, targetFreq, drawPlots=True, showPlots=False)\n",
    "    snippetNotes+=vibComment\n",
    "    if vibComment=='':\n",
    "        figures = drawPlots(freqs, times, vibAmps, vibFreqs, vibTimes, targetFreq, fileName, vibAmpsAvg, vibFreqAvg, figSize=(20,10), showPlots=False)\n",
    "        figures[0].append(vibOnlyFig)\n",
    "        figures[1].append('vibOnly')\n",
    "        writeResultsToFile(fileName, vibAmpsAvg, vibFreqAvg, snippetNotes, outDict)\n",
    "        \n",
    "    else:\n",
    "        figures = drawPlots(freqs, times, vibAmps, vibFreqs, vibTimes, targetFreq, fileName, vibAmpsAvg, vibFreqAvg, figSize=(20,10), showPlots=False, combiPlot=False, vibAmpPlot=False, vibFreqPlot=False)\n",
    "        writeResultsToFile(fileName, 0, 0, snippetNotes, outDict)\n",
    "        \n",
    "    figures[0].append(fftFig)\n",
    "    figures[1].append('fft')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    saveToFile(figures[0], figures[1], specificDiagramPath)\n",
    "\n",
    "    print('...done')\n",
    "    \n",
    "    \n",
    "def analyseCombinedAudioFile(audioFiles, fileNames, targetFreqs, specificDiagramPath, printAdditionalInfos):\n",
    "    \n",
    "    freqs = [None] * len(audioFiles)\n",
    "    times = [None] * len(audioFiles)\n",
    "    vibAmps = [None] * len(audioFiles)\n",
    "    vibFreqs = [None] * len(audioFiles)\n",
    "    vibTimes = [None] * len(audioFiles)\n",
    "    vibAmpsAvg = [None] * len(audioFiles)\n",
    "    vibFreqAvg = [None] * len(audioFiles)\n",
    "    \n",
    "    for iFile in range(0, len(audioFiles)):\n",
    "        audioDuration = None #None:whole File\n",
    "        xAudio, sr = lr.load(audioFiles[iFile],mono=False,sr=None,offset=0,duration=audioDuration)\n",
    "\n",
    "        if audioDuration==None:\n",
    "            audioDuration=len(xAudio[0])/sr\n",
    "        #display(Audio(xAudio, rate=sr))\n",
    "\n",
    "\n",
    "        targetFreqInterval = 140\n",
    "        snippetNotes=''\n",
    "        channel, fftFig = chooseChannel(xAudio, sr, targetFreqs[iFile], targetFreqInterval, showImage=False)\n",
    "\n",
    "        if printAdditionalInfos:\n",
    "            print('file:',fileNames[iFile])\n",
    "            print(noteName)\n",
    "            print('targetFreq: ',targetFreq)\n",
    "            print('channel', channel)\n",
    "        else:\n",
    "            print('file:',fileNames[iFile], end='')\n",
    "\n",
    "        freqs[iFile], times[iFile], outDict = pitchDetection(xAudio[channel], sr, targetFreqs[iFile], targetFreqInterval=None)\n",
    "\n",
    "        if fileNames[iFile].startswith('1993'):\n",
    "            for iFreq in range(0,len(freqs[iFile])):\n",
    "                freqs[iFile][iFreq] *= 1.08843537\n",
    "        elif fileNames[iFile].startswith('1985'):\n",
    "            for iFreq in range(0,len(freqs[iFile])):\n",
    "                freqs[iFile][iFreq] /= 1.0235\n",
    "        \n",
    "        \n",
    "        if printAdditionalInfos:\n",
    "            for k, v in outDict.items():\n",
    "                print(k,v)\n",
    "\n",
    "        if not outDict['error'] is None:\n",
    "            snippetNotes+=outDict['error']\n",
    "            writeResultsToFile(fileName, 0, 0, snippetNotes, outDict)\n",
    "            saveToFile([fftFig], ['fft'], specificDiagramPath)\n",
    "            print('..Error')\n",
    "            return None\n",
    "        freqsArr = np.array(freqs[iFile])\n",
    "        timesArr = np.array(times[iFile])\n",
    "\n",
    "        vibAmps[iFile], vibFreqs[iFile], vibTimes[iFile], vibAmpsAvg[iFile], vibFreqAvg[iFile], extrema, startsWithMinima, vibOnlyFig, vibComment = VibratoDetection(freqsArr, audioDuration, timesArr, targetFreqs[iFile], drawPlots=True, showPlots=False)\n",
    "        snippetNotes+=vibComment\n",
    "\n",
    "    \n",
    "        if fileNames[iFile].startswith('1993'):\n",
    "            for iVibFreq in range(0,len(vibFreqs[iFile])):\n",
    "                vibFreqs[iFile][iVibFreq] *= 1.08843537\n",
    "        elif fileNames[iFile].startswith('1985'):\n",
    "            for iVibFreq in range(0,len(vibFreqs[iFile])):\n",
    "                vibFreqs[iFile][iVibFreq] /= 1.0235\n",
    "    \n",
    "    \n",
    "    \n",
    "    if vibComment=='':\n",
    "        figures = drawPlots(freqs, times, vibAmps, vibFreqs, vibTimes, targetFreqs[0], fileNames, vibAmpsAvg, vibFreqAvg, figSize=(20,10), showPlots=False, combiPlot=False, combinedAudio=True)\n",
    "        #figures[0].append(vibOnlyFig)\n",
    "        #figures[1].append('vibOnly')\n",
    "        #writeResultsToFile(fileName, vibAmpsAvg, vibFreqAvg, snippetNotes, outDict)\n",
    "        \n",
    "    else:\n",
    "        figures = drawPlots(freqs, times, vibAmps, vibFreqs, vibTimes, targetFreqs[0], fileNames, vibAmpsAvg, vibFreqAvg, figSize=(20,10), showPlots=False, combiPlot=False, vibAmpPlot=False, vibFreqPlot=False, combinedAudio=True)\n",
    "        #writeResultsToFile(fileName, 0, 0, snippetNotes, outDict)\n",
    "        \n",
    "    #figures[0].append(fftFig)\n",
    "    #figures[1].append('fft')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    saveToFile(figures[0], figures[1], specificDiagramPath)\n",
    "\n",
    "    print('...done')\n",
    "    \n",
    "    \n",
    "#general plot settings\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"Times New Roman\"\n",
    "\n",
    "pitchColor = '#1f77b4' # blue\n",
    "vibAmpColor = '#d62728' # red\n",
    "vibFreqColor = '#2ca02c' # green\n",
    "\n",
    "labelFontSize=14\n",
    "titleFontSize=16\n",
    "\n",
    "tickParams = dict(size=5, width=2, labelsize=15)\n",
    "\n",
    "combiAxesOffset=0.08\n",
    "combiPitchLineWidth=2\n",
    "combiVibAmpLineWidth=combiVibFreqLineWidth=1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03c60414",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#loop through a folder\n",
    "startTimer = time.time()\n",
    "printAdditionalInfos=False\n",
    "chamberNote=442\n",
    "snippetPath = os.path.abspath('Schnipsel')\n",
    "diagramPath = os.path.abspath('diagrams')\n",
    "if not os.path.exists(diagramPath):\n",
    "    os.makedirs(diagramPath)\n",
    "\n",
    "allFiles=[]\n",
    "for root, dirs, files in os.walk(snippetPath):\n",
    "    for file in files:\n",
    "        allFiles.append(os.path.join(os.path.abspath(root),file))\n",
    "'''    print('root:')\n",
    "    print(root)\n",
    "    print('dirs:')\n",
    "    print(dirs)\n",
    "    print('files:')\n",
    "    print(files)'''\n",
    "print(f'analysing {len(allFiles)} AudioFiles from:')\n",
    "print(snippetPath)\n",
    "print('results will be saved at:')\n",
    "print(diagramPath)\n",
    "\n",
    "\n",
    "#Load AudioFile(s)\n",
    "for audioFile in allFiles:\n",
    "    parentDirPath, fileName = os.path.split(audioFile)    \n",
    "    _, parentDirName = os.path.split(parentDirPath)\n",
    "    \n",
    "    fileNameNoExt = os.path.splitext(fileName)[0]\n",
    "    noteName=parentDirName.split(',')[1][1:-1]\n",
    "    specificDiagramPath = os.path.join(diagramPath, parentDirName, fileNameNoExt)\n",
    "    \n",
    "    #some recordings are in general too high or to low\n",
    "    if fileName.startswith('1993'):\n",
    "        targetFreq=noteToFreq(noteName, chamberNote)/1.08843537\n",
    "    elif fileName.startswith('1985'):\n",
    "        targetFreq=noteToFreq(noteName, chamberNote)*1.0235\n",
    "    else:\n",
    "        targetFreq=noteToFreq(noteName, chamberNote)\n",
    "    \n",
    "    analyseAudioFile(audioFile, targetFreq, specificDiagramPath, printAdditionalInfos)\n",
    "\n",
    "\n",
    "endTimer = time.time()\n",
    "print(f'calculations took {endTimer - startTimer} seconds')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faa11a49",
   "metadata": {},
   "outputs": [],
   "source": [
    "#single audioFile\n",
    "printAdditionalInfos=False\n",
    "chamberNote=442\n",
    "snippetPath = os.path.abspath('Schnipsel')\n",
    "diagramPath = os.path.abspath('diagrams')\n",
    "if not os.path.exists(diagramPath):\n",
    "    os.makedirs(diagramPath)\n",
    "\n",
    "audioFile=os.path.join(snippetPath,'3+10 (EH, fis4)', '1993_3+10.wav')   \n",
    "\n",
    "parentDirPath, fileName = os.path.split(audioFile)    \n",
    "_, parentDirName = os.path.split(parentDirPath)\n",
    "\n",
    "fileNameNoExt = os.path.splitext(fileName)[0]\n",
    "noteName=parentDirName.split(',')[1][1:-1]\n",
    "specificDiagramPath = os.path.join(diagramPath, parentDirName, fileNameNoExt)\n",
    "\n",
    "#some recordings are in general too high or to low\n",
    "if fileName.startswith('1993'):\n",
    "    targetFreq=noteToFreq(noteName, chamberNote)/1.08843537\n",
    "elif fileName.startswith('1985'):\n",
    "    targetFreq=noteToFreq(noteName, chamberNote)*1.0235\n",
    "else:\n",
    "    targetFreq=noteToFreq(noteName, chamberNote)\n",
    "\n",
    "analyseAudioFile(audioFile, targetFreq, specificDiagramPath, printAdditionalInfos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67f5e947",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#multiple audioFiles of the same note combined\n",
    "printAdditionalInfos=False\n",
    "chamberNote=442\n",
    "snippetPath = os.path.abspath('Schnipsel')\n",
    "diagramPath = os.path.abspath('diagrams')\n",
    "if not os.path.exists(diagramPath):\n",
    "    os.makedirs(diagramPath)\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "parentDirNames = ['11+11 (Kl, f5)', '18+10 (Trp, fis5)', '46-6 (Kl, e5)', '52+3 (Vl solo, h5)', '52+5 (EH, b4)', '88+15 (Hrn, h4)']\n",
    "\n",
    "for parentDirName in parentDirNames:\n",
    "    onlyFirstPart = parentDirName.split()[0]\n",
    "    print(onlyFirstPart)\n",
    "    audioFiles = []   \n",
    "    audioFiles.append(os.path.join(snippetPath, parentDirName, '1964_' + onlyFirstPart +'.wav'))\n",
    "    audioFiles.append(os.path.join(snippetPath, parentDirName, '1968_' + onlyFirstPart +'.wav'))\n",
    "    audioFiles.append(os.path.join(snippetPath, parentDirName, '1986_' + onlyFirstPart +'.wav'))\n",
    "    audioFiles.append(os.path.join(snippetPath, parentDirName, '1989_' + onlyFirstPart +'.wav'))\n",
    "    audioFiles.append(os.path.join(snippetPath, parentDirName, '1993_' + onlyFirstPart +'.wav'))\n",
    "\n",
    "\n",
    "    specificDiagramPath = os.path.join(diagramPath, 'combined', parentDirName) \n",
    "\n",
    "\n",
    "\n",
    "    targetFreqs = [None] * len(audioFiles)\n",
    "    fileNames= [None] * len(audioFiles)\n",
    "\n",
    "    for iFile in range(0, len(audioFiles)):\n",
    "\n",
    "        parentDirPath, fileNames[iFile] = os.path.split(audioFiles[iFile])\n",
    "        _, parentDirName = os.path.split(parentDirPath)\n",
    "\n",
    "        noteName=parentDirName.split(',')[1][1:-1]\n",
    "\n",
    "\n",
    "        #some recordings are in general too high or to low\n",
    "        if fileNames[iFile].startswith('1993'):\n",
    "            targetFreqs[iFile]=noteToFreq(noteName, chamberNote)/1.08843537\n",
    "        elif fileNames[iFile].startswith('1985'):\n",
    "            targetFreqs[iFile]=noteToFreq(noteName, chamberNote)*1.0235\n",
    "        else:\n",
    "            targetFreqs[iFile]=noteToFreq(noteName, chamberNote)\n",
    "\n",
    "\n",
    "    fileNames.append(parentDirName)\n",
    "    print(fileNames)\n",
    "    print(targetFreqs)\n",
    "    analyseCombinedAudioFile(audioFiles, fileNames, targetFreqs, specificDiagramPath, printAdditionalInfos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e283c38",
   "metadata": {},
   "outputs": [],
   "source": [
    "#sinus Maxima Example\n",
    "\n",
    "diagramPath = os.path.abspath('diagrams')\n",
    "if not os.path.exists(diagramPath):\n",
    "    os.makedirs(diagramPath)\n",
    "    \n",
    "xValues = np.arange(0, 20, 0.1)\n",
    "normalSin = np.sin(xValues)\n",
    "risingSin = np.sin(xValues) + 0.7*xValues\n",
    "\n",
    "maximaNormalSin,_ = find_peaks(normalSin)\n",
    "maximaRisingSin,_ = find_peaks(risingSin)\n",
    "\n",
    "minimaNormalSin,_ = find_peaks(-normalSin)\n",
    "minimaRisingSin,_ = find_peaks(-risingSin)\n",
    "\n",
    "labelFontSize=14\n",
    "titleFontSize=16\n",
    "\n",
    "plt.rcParams[\"font.family\"] = \"Times New Roman\"\n",
    "tickParams = dict(size=5, width=2, labelsize=12)\n",
    "\n",
    "\n",
    "fig, host = plt.subplots(figsize=(20,10))     \n",
    "#host.set_xlabel('x', fontsize=labelFontSize) \n",
    "\n",
    "host.tick_params(**tickParams)\n",
    "\n",
    "host.plot(xValues, normalSin, label='sin(x)')\n",
    "host.plot(xValues, risingSin, label='sin(x)+0,7x')\n",
    "\n",
    "host.plot(xValues[maximaNormalSin], normalSin[maximaNormalSin],'x', markersize=18, color='green', label='maxima')\n",
    "host.plot(xValues[maximaRisingSin], risingSin[maximaRisingSin],'x', markersize=18, color='green')\n",
    "\n",
    "host.plot(xValues[minimaNormalSin], normalSin[minimaNormalSin],'x', markersize=18, color='red', label='minima')\n",
    "host.plot(xValues[minimaRisingSin], risingSin[minimaRisingSin],'x', markersize=18, color='red')\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "host.legend(prop={'size': 15})\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0b440bf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}