comparison src/BTrack.cpp @ 115:54c657d621dd

Code style updates

 //=======================================================================
 void BTrack::setHopSize (int hop)
 {	
 	hopSize = hop;
 	onsetDFBufferSize = (512 * 512) / hopSize;		// calculate df buffer size
-	beatPeriod = round(60/((((double) hopSize)/44100) * 120.));
+	beatPeriod = round (60 / ((((double) hopSize) / 44100) * 120.));
 
     // set size of onset detection function buffer
     onsetDF.resize (onsetDFBufferSize);
     
     // set size of cumulative score buffer

 	
 	// convert tempo from bpm value to integer index of tempo probability 
 	int tempoIndex = (int) round((tempo - 80) / 2);
 	
 	// now set previous fixed previous tempo observation values to zero
-	for (int i=0;i < 41;i++)
+	for (int i = 0; i < 41; i++)
 	{
 		prevDeltaFixed[i] = 0;
 	}
 	
 	// set desired tempo index to 1

 void BTrack::resampleOnsetDetectionFunction()
 {
 	float output[512];
     float input[onsetDFBufferSize];
     
-    for (int i = 0;i < onsetDFBufferSize;i++)
+    for (int i = 0; i < onsetDFBufferSize; i++)
         input[i] = (float) onsetDF[i];
         
     double ratio = 512.0 / ((double) onsetDFBufferSize);
     int bufferLength = onsetDFBufferSize;
     int outputLength = 512;

 	}
 	
 	beatPeriod = round ((60.0 * 44100.0) / (((2 * maxIndex) + 80) * ((double) hopSize)));
 	
 	if (beatPeriod > 0)
-        estimatedTempo = 60.0/((((double) hopSize) / 44100.0) * beatPeriod);
+        estimatedTempo = 60.0 / ((((double) hopSize) / 44100.0) * beatPeriod);
 }
 
 //=======================================================================
 void BTrack::adaptiveThreshold (std::vector<double>& x)
 {

 	{
 		for (int a = 1; a <= numCombElements; a++) // number of comb elements
 		{
 			for (int b = 1 - a; b <= a - 1; b++) // general state using normalisation of comb elements
 			{
-				combFilterBankOutput[i-1] += (acf[(a * i + b) - 1] * weightingVector[i - 1]) / (2 * a - 1);	// calculate value for comb filter row
+				combFilterBankOutput[i - 1] += (acf[(a * i + b) - 1] * weightingVector[i - 1]) / (2 * a - 1);	// calculate value for comb filter row
 			}
 		}
 	}
 }
 

     
     // perform the fft
     fftw_execute (acfForwardFFT);
     
     // multiply by complex conjugate
-    for (int i = 0;i < FFTLengthForACFCalculation;i++)
+    for (int i = 0; i < FFTLengthForACFCalculation; i++)
     {
         complexOut[i][0] = complexOut[i][0] * complexOut[i][0] + complexOut[i][1] * complexOut[i][1];
         complexOut[i][1] = 0.0;
     }
     

     
     // execute kiss fft
     kiss_fft (cfgForwards, fftIn, fftOut);
     
     // multiply by complex conjugate
-    for (int i = 0;i < FFTLengthForACFCalculation;i++)
+    for (int i = 0; i < FFTLengthForACFCalculation; i++)
     {
         fftOut[i].r = fftOut[i].r * fftOut[i].r + fftOut[i].i * fftOut[i].i;
         fftOut[i].i = 0.0;
     }
     

 	int beatExpectationWindowSize = static_cast<int> (beatPeriod);
 	double futureCumulativeScore[onsetDFBufferSize + beatExpectationWindowSize];
 	double beatExpectationWindow[beatExpectationWindowSize];
     
 	// copy cumulativeScore to first part of futureCumulativeScore
-	for (int i = 0;i < onsetDFBufferSize;i++)
+	for (int i = 0; i < onsetDFBufferSize; i++)
         futureCumulativeScore[i] = cumulativeScore[i];
 	
 	// Create a beat expectation window for predicting future beats from the "future" of the cumulative score.
     // We are making this beat prediction at the midpoint between beats, and so we make a Gaussian
     // weighting centred on the most likely beat position (half a beat period into the future)