comparison src/OnsetDetectionFunction.cpp @ 92:f6708e4c69f1

More code style updates

 //=======================================================================
 
 #include <math.h>
 #include "OnsetDetectionFunction.h"
 
-
-//=======================================================================
-OnsetDetectionFunction::OnsetDetectionFunction(int hopSize_,int frameSize_) : onsetDetectionFunctionType(ComplexSpectralDifferenceHWR), windowType(HanningWindow)
+//=======================================================================
+OnsetDetectionFunction::OnsetDetectionFunction (int hopSize_,int frameSize_)
+ :  onsetDetectionFunctionType (ComplexSpectralDifferenceHWR), windowType (HanningWindow)
 {
     // indicate that we have not initialised yet
 	initialised = false;
 	
 	// set pi
 	pi = 3.14159265358979;
 	
 	// initialise with arguments to constructor
-	initialise(hopSize_,frameSize_,ComplexSpectralDifferenceHWR,HanningWindow);
-}
-
-//=======================================================================
-OnsetDetectionFunction::OnsetDetectionFunction(int hopSize_,int frameSize_,int onsetDetectionFunctionType_,int windowType_) : onsetDetectionFunctionType(ComplexSpectralDifferenceHWR), windowType(HanningWindow)
+	initialise (hopSize_, frameSize_, ComplexSpectralDifferenceHWR, HanningWindow);
+}
+
+//=======================================================================
+OnsetDetectionFunction::OnsetDetectionFunction(int hopSize_,int frameSize_,int onsetDetectionFunctionType_,int windowType_)
+ :  onsetDetectionFunctionType (ComplexSpectralDifferenceHWR), windowType (HanningWindow)
 {	
 	// indicate that we have not initialised yet
 	initialised = false;
 	
 	// set pi
 	pi = 3.14159265358979;	
 	
 	// initialise with arguments to constructor
-	initialise(hopSize_,frameSize_,onsetDetectionFunctionType_,windowType_);
+	initialise (hopSize_, frameSize_, onsetDetectionFunctionType_, windowType_);
 }
 
 
 //=======================================================================
 OnsetDetectionFunction::~OnsetDetectionFunction()
 {
     if (initialised)
     {
         // destroy fft plan
-        fftw_destroy_plan(p);
-        fftw_free(complexIn);
-        fftw_free(complexOut);
+        fftw_destroy_plan (p);
+        fftw_free (complexIn);
+        fftw_free (complexOut);
     }
 }
 
 //=======================================================================
-void OnsetDetectionFunction::initialise(int hopSize_,int frameSize_)
+void OnsetDetectionFunction::initialise (int hopSize_, int frameSize_)
 {
     // use the already initialised onset detection function and window type and
     // pass the new frame and hop size to the main initialisation function
-    initialise(hopSize_, frameSize_, onsetDetectionFunctionType, windowType);
+    initialise (hopSize_, frameSize_, onsetDetectionFunctionType, windowType);
 }
 
 //=======================================================================
 void OnsetDetectionFunction::initialise(int hopSize_,int frameSize_,int onsetDetectionFunctionType_,int windowType_)
 {
 	if (initialised) // if we have already initialised FFT plan
 	{
 		// destroy fft plan
-		fftw_destroy_plan(p);
-		fftw_free(complexIn);
-		fftw_free(complexOut);
-
+		fftw_destroy_plan (p);
+		fftw_free (complexIn);
+		fftw_free (complexOut);
 	}
 	
 	hopSize = hopSize_; // set hopsize
 	frameSize = frameSize_; // set framesize
 	
 	onsetDetectionFunctionType = onsetDetectionFunctionType_; // set detection function type
     windowType = windowType_; // set window type
 		
 	// initialise buffers
-    frame.resize(frameSize);
-    window.resize(frameSize);
-    magSpec.resize(frameSize);
-    prevMagSpec.resize(frameSize);
-    phase.resize(frameSize);
-    prevPhase.resize(frameSize);
-    prevPhase2.resize(frameSize);
+    frame.resize (frameSize);
+    window.resize (frameSize);
+    magSpec.resize (frameSize);
+    prevMagSpec.resize (frameSize);
+    phase.resize (frameSize);
+    prevPhase.resize (frameSize);
+    prevPhase2.resize (frameSize);
 	
 	
 	// set the window to the specified type
-	switch (windowType){
+	switch (windowType)
+    {
 		case RectangularWindow:
 			calculateRectangularWindow();		// Rectangular window
 			break;	
 		case HanningWindow:
 			calculateHanningWindow();			// Hanning Window

 		default:
 			calculateHanningWindow();			// DEFAULT: Hanning Window
 	}
 	
 	// initialise previous magnitude spectrum to zero
-	for (int i = 0;i < frameSize;i++)
+	for (int i = 0; i < frameSize; i++)
 	{
 		prevMagSpec[i] = 0.0;
 		prevPhase[i] = 0.0;
 		prevPhase2[i] = 0.0;
 		frame[i] = 0.0;

 	prevEnergySum = 0.0;	// initialise previous energy sum value to zero
 	
 	/*  Init fft */
 	complexIn = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * frameSize);		// complex array to hold fft data
 	complexOut = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * frameSize);	// complex array to hold fft data
-	p = fftw_plan_dft_1d(frameSize, complexIn, complexOut, FFTW_FORWARD, FFTW_ESTIMATE);	// FFT plan initialisation
+	p = fftw_plan_dft_1d (frameSize, complexIn, complexOut, FFTW_FORWARD, FFTW_ESTIMATE);	// FFT plan initialisation
 	
 	initialised = true;
 }
 
 //=======================================================================
-void OnsetDetectionFunction :: setOnsetDetectionFunctionType(int onsetDetectionFunctionType_)
+void OnsetDetectionFunction::setOnsetDetectionFunctionType (int onsetDetectionFunctionType_)
 {
 	onsetDetectionFunctionType = onsetDetectionFunctionType_; // set detection function type
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: calculateOnsetDetectionFunctionSample(double *buffer)
+double OnsetDetectionFunction::calculateOnsetDetectionFunctionSample (double* buffer)
 {	
 	double odfSample;
 		
 	// shift audio samples back in frame by hop size
 	for (int i = 0; i < (frameSize-hopSize);i++)

 	{
 		frame[i] = buffer[j];
 		j++;
 	}
 		
-	switch (onsetDetectionFunctionType){
+	switch (onsetDetectionFunctionType)
+    {
 		case EnergyEnvelope:
         {
             // calculate energy envelope detection function sample
 			odfSample = energyEnvelope();
 			break;

 	return odfSample;
 }
 
 
 //=======================================================================
-void OnsetDetectionFunction :: performFFT()
+void OnsetDetectionFunction::performFFT()
 {
 	int fsize2 = (frameSize/2);
 	
 	// window frame and copy to complex array, swapping the first and second half of the signal
 	for (int i = 0;i < fsize2;i++)

 		complexIn[i+fsize2][0] = frame[i] * window[i];
 		complexIn[i+fsize2][1] = 0.0;
 	}
 	
 	// perform the fft
-	fftw_execute(p);
+	fftw_execute (p);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// Methods for Detection Functions /////////////////////////////////
 
 //=======================================================================
-double OnsetDetectionFunction :: energyEnvelope()
+double OnsetDetectionFunction::energyEnvelope()
 {
 	double sum;
 	
 	sum = 0;	// initialise sum
 	
 	// sum the squares of the samples
 	for (int i = 0;i < frameSize;i++)
 	{
-		sum = sum + (frame[i]*frame[i]);
+		sum = sum + (frame[i] * frame[i]);
 	}
 	
 	return sum;		// return sum
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: energyDifference()
+double OnsetDetectionFunction::energyDifference()
 {
 	double sum;
 	double sample;
 	
 	sum = 0;	// initialise sum
 	
 	// sum the squares of the samples
-	for (int i = 0;i < frameSize;i++)
-	{
-		sum = sum + (frame[i]*frame[i]);
+	for (int i = 0; i < frameSize; i++)
+	{
+		sum = sum + (frame[i] * frame[i]);
 	}
 	
 	sample = sum - prevEnergySum;	// sample is first order difference in energy
 	
 	prevEnergySum = sum;	// store energy value for next calculation

 		return 0;
 	}
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: spectralDifference()
+double OnsetDetectionFunction::spectralDifference()
 {
 	double diff;
 	double sum;
 	
 	// perform the FFT
 	performFFT();
 	
 	// compute first (N/2)+1 mag values
 	for (int i = 0;i < (frameSize/2)+1;i++)
 	{
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
 	}
 	// mag spec symmetric above (N/2)+1 so copy previous values
-	for (int i = (frameSize/2)+1;i < frameSize;i++)
+	for (int i = (frameSize/2)+1; i < frameSize; i++)
 	{
 		magSpec[i] = magSpec[frameSize-i];
 	}
 	
 	sum = 0;	// initialise sum to zero
 
-	for (int i = 0;i < frameSize;i++)
+	for (int i = 0; i < frameSize; i++)
 	{
 		// calculate difference
 		diff = magSpec[i] - prevMagSpec[i];
 		
 		// ensure all difference values are positive

 		{
 			diff = diff*-1;
 		}
 		
 		// add difference to sum
-		sum = sum+diff;
+		sum = sum + diff;
 		
 		// store magnitude spectrum bin for next detection function sample calculation
 		prevMagSpec[i] = magSpec[i];
 	}
 	
 	return sum;		
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: spectralDifferenceHWR()
+double OnsetDetectionFunction::spectralDifferenceHWR()
 {
 	double diff;
 	double sum;
 	
 	// perform the FFT
 	performFFT();
 	
 	// compute first (N/2)+1 mag values
-	for (int i = 0;i < (frameSize/2)+1;i++)
-	{
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+	for (int i = 0;i < (frameSize/2) + 1; i++)
+	{
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
 	}
 	// mag spec symmetric above (N/2)+1 so copy previous values
 	for (int i = (frameSize/2)+1;i < frameSize;i++)
 	{
 		magSpec[i] = magSpec[frameSize-i];

 		{
 			// add difference to sum
 			sum = sum+diff;
 		}
 		
-		
-		
 		// store magnitude spectrum bin for next detection function sample calculation
 		prevMagSpec[i] = magSpec[i];
 	}
 	
 	return sum;		
 }
 
 
 //=======================================================================
-double OnsetDetectionFunction :: phaseDeviation()
+double OnsetDetectionFunction::phaseDeviation()
 {
 	double dev,pdev;
 	double sum;
 	
 	// perform the FFT

 	
 	// compute phase values from fft output and sum deviations
 	for (int i = 0;i < frameSize;i++)
 	{
 		// calculate phase value
-		phase[i] = atan2(complexOut[i][1],complexOut[i][0]);
+		phase[i] = atan2 (complexOut[i][1],complexOut[i][0]);
 		
 		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
 		
 		
 		// if bin is not just a low energy bin then examine phase deviation
 		if (magSpec[i] > 0.1)
 		{
 			dev = phase[i] - (2*prevPhase[i]) + prevPhase2[i];	// phase deviation
-			pdev = princarg(dev);	// wrap into [-pi,pi] range
+			pdev = princarg (dev);	// wrap into [-pi,pi] range
 		
 			// make all values positive
 			if (pdev < 0)	
 			{
 				pdev = pdev*-1;

 	
 	return sum;		
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: complexSpectralDifference()
+double OnsetDetectionFunction::complexSpectralDifference()
 {
 	double phaseDeviation;
 	double sum;
 	double csd;
 	

 	
 	// compute phase values from fft output and sum deviations
 	for (int i = 0;i < frameSize;i++)
 	{
 		// calculate phase value
-		phase[i] = atan2(complexOut[i][1],complexOut[i][0]);
+		phase[i] = atan2 (complexOut[i][1],complexOut[i][0]);
 		
 		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow(complexOut[i][1],2));
 		
 		// phase deviation
-		phaseDeviation = phase[i] - (2*prevPhase[i]) + prevPhase2[i];
+		phaseDeviation = phase[i] - (2 * prevPhase[i]) + prevPhase2[i];
 		
         // calculate complex spectral difference for the current spectral bin
-		csd = sqrt(pow(magSpec[i], 2) + pow(prevMagSpec[i], 2) - 2 * magSpec[i] * prevMagSpec[i] * cos(phaseDeviation));
+		csd = sqrt (pow (magSpec[i], 2) + pow (prevMagSpec[i], 2) - 2 * magSpec[i] * prevMagSpec[i] * cos (phaseDeviation));
 			
 		// add to sum
 		sum = sum + csd;
 		
 		// store values for next calculation

 	
 	return sum;		
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: complexSpectralDifferenceHWR()
+double OnsetDetectionFunction::complexSpectralDifferenceHWR()
 {
 	double phaseDeviation;
 	double sum;
 	double magnitudeDifference;
 	double csd;

 	
 	// compute phase values from fft output and sum deviations
 	for (int i = 0;i < frameSize;i++)
 	{
 		// calculate phase value
-		phase[i] = atan2(complexOut[i][1],complexOut[i][0]);
+		phase[i] = atan2 (complexOut[i][1],complexOut[i][0]);
 		
 		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow(complexOut[i][1],2));
 		
         // phase deviation
-        phaseDeviation = phase[i] - (2*prevPhase[i]) + prevPhase2[i];
+        phaseDeviation = phase[i] - (2 * prevPhase[i]) + prevPhase2[i];
         
         // calculate magnitude difference (real part of Euclidean distance between complex frames)
         magnitudeDifference = magSpec[i] - prevMagSpec[i];
         
         // if we have a positive change in magnitude, then include in sum, otherwise ignore (half-wave rectification)
         if (magnitudeDifference > 0)
         {
             // calculate complex spectral difference for the current spectral bin
-            csd = sqrt(pow(magSpec[i], 2) + pow(prevMagSpec[i], 2) - 2 * magSpec[i] * prevMagSpec[i] * cos(phaseDeviation));
+            csd = sqrt (pow (magSpec[i], 2) + pow (prevMagSpec[i], 2) - 2 * magSpec[i] * prevMagSpec[i] * cos (phaseDeviation));
         
             // add to sum
             sum = sum + csd;
         }
         

 	return sum;		
 }
 
 
 //=======================================================================
-double OnsetDetectionFunction :: highFrequencyContent()
-{
-	double sum;
+double OnsetDetectionFunction::highFrequencyContent()
+{
+	double sum;
+	
+	// perform the FFT
+	performFFT();
+	
+	sum = 0; // initialise sum to zero
+	
+	// compute phase values from fft output and sum deviations
+	for (int i = 0; i < frameSize; i++)
+	{		
+		// calculate magnitude value
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
+		
+		
+		sum = sum + (magSpec[i] * ((double) (i+1)));
+		
+		// store values for next calculation
+		prevMagSpec[i] = magSpec[i];
+	}
+	
+	return sum;		
+}
+
+//=======================================================================
+double OnsetDetectionFunction::highFrequencySpectralDifference()
+{
+	double sum;
+	double mag_diff;
 	
 	// perform the FFT
 	performFFT();
 	
 	sum = 0; // initialise sum to zero
 	
 	// compute phase values from fft output and sum deviations
 	for (int i = 0;i < frameSize;i++)
 	{		
 		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
-		
-		
-		sum = sum + (magSpec[i]*((double) (i+1)));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
+		
+		// calculate difference
+		mag_diff = magSpec[i] - prevMagSpec[i];
+		
+		if (mag_diff < 0)
+		{
+			mag_diff = -mag_diff;
+		}
+		
+		sum = sum + (mag_diff * ((double) (i+1)));
 		
 		// store values for next calculation
 		prevMagSpec[i] = magSpec[i];
 	}
 	
 	return sum;		
 }
 
 //=======================================================================
-double OnsetDetectionFunction :: highFrequencySpectralDifference()
+double OnsetDetectionFunction::highFrequencySpectralDifferenceHWR()
 {
 	double sum;
 	double mag_diff;
 	
 	// perform the FFT

 	
 	// compute phase values from fft output and sum deviations
 	for (int i = 0;i < frameSize;i++)
 	{		
 		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
+		magSpec[i] = sqrt (pow (complexOut[i][0],2) + pow (complexOut[i][1],2));
 		
 		// calculate difference
 		mag_diff = magSpec[i] - prevMagSpec[i];
 		
-		if (mag_diff < 0)
-		{
-			mag_diff = -mag_diff;
-		}
-		
-		sum = sum + (mag_diff*((double) (i+1)));
-		
-		// store values for next calculation
-		prevMagSpec[i] = magSpec[i];
-	}
-	
-	return sum;		
-}
-
-//=======================================================================
-double OnsetDetectionFunction :: highFrequencySpectralDifferenceHWR()
-{
-	double sum;
-	double mag_diff;
-	
-	// perform the FFT
-	performFFT();
-	
-	sum = 0; // initialise sum to zero
-	
-	// compute phase values from fft output and sum deviations
-	for (int i = 0;i < frameSize;i++)
-	{		
-		// calculate magnitude value
-		magSpec[i] = sqrt(pow(complexOut[i][0],2) + pow(complexOut[i][1],2));
-		
-		// calculate difference
-		mag_diff = magSpec[i] - prevMagSpec[i];
-		
 		if (mag_diff > 0)
 		{
-			sum = sum + (mag_diff*((double) (i+1)));
+			sum = sum + (mag_diff * ((double) (i+1)));
 		}
 
 		// store values for next calculation
 		prevMagSpec[i] = magSpec[i];
 	}

 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// Methods to Calculate Windows ////////////////////////////////////
 
 //=======================================================================
-void OnsetDetectionFunction :: calculateHanningWindow()
+void OnsetDetectionFunction::calculateHanningWindow()
 {
 	double N;		// variable to store framesize minus 1
 	
 	N = (double) (frameSize-1);	// framesize minus 1
 	
 	// Hanning window calculation
-	for (int n = 0;n < frameSize;n++)
-	{
-		window[n] = 0.5*(1-cos(2*pi*(n/N)));
-	}
-}
-
-//=======================================================================
-void OnsetDetectionFunction :: calclulateHammingWindow()
+	for (int n = 0; n < frameSize; n++)
+	{
+		window[n] = 0.5 * (1 - cos (2 * pi * (n / N)));
+	}
+}
+
+//=======================================================================
+void OnsetDetectionFunction::calclulateHammingWindow()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	
 	N = (double) (frameSize-1);	// framesize minus 1
 	n_val = 0;
 	
 	// Hamming window calculation
 	for (int n = 0;n < frameSize;n++)
 	{
-		window[n] = 0.54 - (0.46*cos(2*pi*(n_val/N)));
+		window[n] = 0.54 - (0.46 * cos (2 * pi * (n_val/N)));
 		n_val = n_val+1;
 	}
 }
 
 //=======================================================================
-void OnsetDetectionFunction :: calculateBlackmanWindow()
+void OnsetDetectionFunction::calculateBlackmanWindow()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	
 	N = (double) (frameSize-1);	// framesize minus 1

 		n_val = n_val+1;
 	}
 }
 
 //=======================================================================
-void OnsetDetectionFunction :: calculateTukeyWindow()
+void OnsetDetectionFunction::calculateTukeyWindow()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	double alpha;	// alpha [default value = 0.5];
 	

 	}
 
 }
 
 //=======================================================================
-void OnsetDetectionFunction :: calculateRectangularWindow()
+void OnsetDetectionFunction::calculateRectangularWindow()
 {
 	// Rectangular window calculation
 	for (int n = 0;n < frameSize;n++)
 	{
 		window[n] = 1.0;
 	}
 }
-
-
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////// Other Handy Methods //////////////////////////////////////////
 
 //=======================================================================
-double OnsetDetectionFunction :: princarg(double phaseVal)
+double OnsetDetectionFunction::princarg(double phaseVal)
 {	
 	// if phase value is less than or equal to -pi then add 2*pi
 	while (phaseVal <= (-pi))
 	{
-		phaseVal = phaseVal + (2*pi);
+		phaseVal = phaseVal + (2 * pi);
 	}
 	
 	// if phase value is larger than pi, then subtract 2*pi
 	while (phaseVal > pi)
 	{
-		phaseVal = phaseVal - (2*pi);
+		phaseVal = phaseVal - (2 * pi);
 	}
 			
 	return phaseVal;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-