comparison src/OnsetDetectionFunction.cpp @ 52:45231107c9d6

Reformatted comments, removed the OnsetDetectionFunction constructor with no arguments, removed a number of unused variables and made changes to the python module to fix some casting problems and removed some unused variables there also. Still getting the same results, so no overall changes to the algorithm.

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 //=======================================================================
 
 #include <math.h>
-#include <iostream>
 #include "OnsetDetectionFunction.h"
-using namespace std;
-
-//-------------------------------------------------------------------------------
-// Constructor
-OnsetDetectionFunction :: OnsetDetectionFunction()
-{	
-	// indicate that we have not initialised yet
-	initialised = 0;		
-	
-	// set pi
-	pi = 3.14159265358979;	
-	
-	// initialise with hopsize = 512, framesize = 1024, complex spectral difference DF and hanning window
-	initialise(512,1024,6,1);	
-}
-
-
-//-------------------------------------------------------------------------------
-// Constructor (with arguments)
+
+//=======================================================================
 OnsetDetectionFunction :: OnsetDetectionFunction(int arg_hsize,int arg_fsize,int arg_df_type,int arg_win_type)
 {	
 	// indicate that we have not initialised yet
 	initialised = 0;		
 	

 	// initialise with arguments to constructor
 	initialise(arg_hsize,arg_fsize,arg_df_type,arg_win_type);
 }
 
 
-//--------------------------------------------------------------------------------------
-// Destructor
+//=======================================================================
 OnsetDetectionFunction :: ~OnsetDetectionFunction()
 {
 	// destroy fft plan
     fftw_destroy_plan(p);
 	fftw_free(in); 

 	phase_old = NULL;	
 	delete [] phase_old_2;
 	phase_old_2 = NULL;
 }
 
-//-------------------------------------------------------------------------------
-// Initialisation
+//=======================================================================
 void OnsetDetectionFunction :: initialise(int arg_hsize,int arg_fsize,int arg_df_type,int arg_win_type)
 {
 	if (initialised == 1) // if we have already initialised some buffers and an FFT plan
 	{
 		//////////////////////////////////

 	p = fftw_plan_dft_1d(framesize, in, out, FFTW_FORWARD, FFTW_ESTIMATE);	// FFT plan initialisation
 	
 	initialised = 1;
 }
 
-//--------------------------------------------------------------------------------------
-// set the detection function type to that specified by the argument
+//=======================================================================
 void OnsetDetectionFunction :: set_df_type(int arg_df_type)
 {
 	df_type = arg_df_type; // set detection function type
 }
 
-
-//--------------------------------------------------------------------------------------
-// calculates a single detection function sample from a single audio frame.
+//=======================================================================
 double OnsetDetectionFunction :: getDFsample(double inputbuffer[])
 {	
 	double df_sample;
 		
 	// shift audio samples back in frame by hop size

 		
 	return df_sample;
 }
 
 
-//--------------------------------------------------------------------------------------
-// performs the fft, storing the complex result in 'out'
+//=======================================================================
 void OnsetDetectionFunction :: perform_FFT()
 {
 	int fsize2 = (framesize/2);
 	
 	// window frame and copy to complex array, swapping the first and second half of the signal

 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// Methods for Detection Functions /////////////////////////////////
 
-//--------------------------------------------------------------------------------------
-// calculates an energy envelope detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: energy_envelope()
 {
 	double sum;
 	
 	sum = 0;	// initialise sum

 	}
 	
 	return sum;		// return sum
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a half-wave rectified energy difference detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: energy_difference()
 {
 	double sum;
 	double sample;
 	

 	{
 		return 0;
 	}
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a spectral difference detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: spectral_difference()
 {
 	double diff;
 	double sum;
 	

 	}
 	
 	return sum;		
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a spectral difference detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: spectral_difference_hwr()
 {
 	double diff;
 	double sum;
 	

 	
 	return sum;		
 }
 
 
-//--------------------------------------------------------------------------------------
-// calculates a phase deviation detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: phase_deviation()
 {
 	double dev,pdev;
 	double sum;
 	

 	}
 	
 	return sum;		
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a complex spectral difference detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: complex_spectral_difference()
 {
 	double dev,pdev;
 	double sum;
 	double mag_diff,phase_diff;

 	}
 	
 	return sum;		
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a complex spectral difference detection function sample (half-wave rectified)
+//=======================================================================
 double OnsetDetectionFunction :: complex_spectral_difference_hwr()
 {
 	double dev,pdev;
 	double sum;
 	double mag_diff,phase_diff;

 	
 	return sum;		
 }
 
 
-//--------------------------------------------------------------------------------------
-// calculates a high frequency content detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: high_frequency_content()
 {
 	double sum;
-	double mag_diff;
 	
 	// perform the FFT
 	perform_FFT();
 	
 	sum = 0; // initialise sum to zero

 	}
 	
 	return sum;		
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a high frequency spectral difference detection function sample
+//=======================================================================
 double OnsetDetectionFunction :: high_frequency_spectral_difference()
 {
 	double sum;
 	double mag_diff;
 	

 	}
 	
 	return sum;		
 }
 
-//--------------------------------------------------------------------------------------
-// calculates a high frequency spectral difference detection function sample (half-wave rectified)
+//=======================================================================
 double OnsetDetectionFunction :: high_frequency_spectral_difference_hwr()
 {
 	double sum;
 	double mag_diff;
 	

 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// Methods to Calculate Windows ////////////////////////////////////
 
-//--------------------------------------------------------------------------------------
-// HANNING: set the window in the buffer 'window' to a Hanning window
+//=======================================================================
 void OnsetDetectionFunction :: set_win_hanning()
 {
 	double N;		// variable to store framesize minus 1
 	
 	N = (double) (framesize-1);	// framesize minus 1

 	{
 		window[n] = 0.5*(1-cos(2*pi*(n/N)));
 	}
 }
 
-//--------------------------------------------------------------------------------------
-// HAMMING: set the window in the buffer 'window' to a Hanning window
+//=======================================================================
 void OnsetDetectionFunction :: set_win_hamming()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	

 		window[n] = 0.54 - (0.46*cos(2*pi*(n_val/N)));
 		n_val = n_val+1;
 	}
 }
 
-//--------------------------------------------------------------------------------------
-// BLACKMAN: set the window in the buffer 'window' to a Blackman window
+//=======================================================================
 void OnsetDetectionFunction :: set_win_blackman()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	

 		window[n] = 0.42 - (0.5*cos(2*pi*(n_val/N))) + (0.08*cos(4*pi*(n_val/N)));
 		n_val = n_val+1;
 	}
 }
 
-//--------------------------------------------------------------------------------------
-// TUKEY: set the window in the buffer 'window' to a Tukey window
+//=======================================================================
 void OnsetDetectionFunction :: set_win_tukey()
 {
 	double N;		// variable to store framesize minus 1
 	double n_val;	// double version of index 'n'
 	double alpha;	// alpha [default value = 0.5];
 	
-	int lim1,lim2;
-	
 	alpha = 0.5;
 	
 	N = (double) (framesize-1);	// framesize minus 1
 		
 	// Tukey window calculation

 		n_val = n_val+1;			 
 	}
 
 }
 
-//--------------------------------------------------------------------------------------
-// RECTANGULAR: set the window in the buffer 'window' to a Rectangular window
+//=======================================================================
 void OnsetDetectionFunction :: set_win_rectangular()
 {
 	// Rectangular window calculation
 	for (int n = 0;n < framesize;n++)
 	{

 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////// Other Handy Methods //////////////////////////////////////////
 
-//--------------------------------------------------------------------------------------
-// set phase values to the range [-pi,pi]
+//=======================================================================
 double OnsetDetectionFunction :: princarg(double phaseval)
 {	
 	// if phase value is less than or equal to -pi then add 2*pi
 	while (phaseval <= (-pi)) 
 	{