comparison dsp/segmentation/ClusterMeltSegmenter.cpp @ 505:930b5b0f707d

Merge branch 'codestyle-and-tidy'

 
 #include "dsp/transforms/FFT.h"
 #include "dsp/chromagram/ConstantQ.h"
 #include "dsp/rateconversion/Decimator.h"
 #include "dsp/mfcc/MFCC.h"
+
+using std::vector;
 
 ClusterMeltSegmenter::ClusterMeltSegmenter(ClusterMeltSegmenterParams params) :
     window(NULL),
     fft(NULL),
     constq(NULL),

     hopSize(params.hopSize),
     windowSize(params.windowSize),
     fmin(params.fmin),
     fmax(params.fmax),
     nbins(params.nbins),
-    ncomponents(params.ncomponents),	// NB currently not passed - no. of PCA components is set in cluser_segmenter.c
+    ncomponents(params.ncomponents),    // NB currently not passed - no. of PCA components is set in cluser_segmenter.c
     nHMMStates(params.nHMMStates),
     nclusters(params.nclusters),
     histogramLength(params.histogramLength),
     neighbourhoodLimit(params.neighbourhoodLimit),
     decimator(NULL)

         constq = new ConstantQ(config);
         constq->sparsekernel();
         
         ncoeff = constq->getK();
 
-        fft = new FFTReal(constq->getfftlength());
+        fft = new FFTReal(constq->getFFTLength());
         
     } else if (featureType == FEATURE_TYPE_MFCC) {
 
         // run internal processing at 22050 or thereabouts
         int internalRate = 22050;

     if (nsamples < getWindowsize()) {
         std::cerr << "ERROR: ClusterMeltSegmenter::extractFeatures: nsamples < windowsize (" << nsamples << " < " << getWindowsize() << ")" << std::endl;
         return;
     }
 
-    int fftsize = constq->getfftlength();
+    int fftsize = constq->getFFTLength();
 
     if (!window || window->getSize() != fftsize) {
         delete window;
         window = new Window<double>(HammingWindow, fftsize);
     }

         window->cut(frame);
         
         fft->forward(frame, real, imag);
         
         constq->process(real, imag, cqre, cqim);
-	
+        
         for (int i = 0; i < ncoeff; ++i) {
             cq[i] += sqrt(cqre[i] * cqre[i] + cqim[i] * cqim[i]);
         }
         ++frames;
 

                 frame[i] = 0.0;
             }
         }
 
         mfcc->process(frame, ccout);
-	
+        
         for (int i = 0; i < ncoeff; ++i) {
             cc[i] += ccout[i];
         }
         ++frames;
 

 /*    
     std::cerr << "ClusterMeltSegmenter::segment: have " << features.size()
               << " features with " << features[0].size() << " coefficients (ncoeff = " << ncoeff << ", ncomponents = " << ncomponents << ")" << std::endl;
 */
     // copy the features to a native array and use the existing C segmenter...
-    double** arrFeatures = new double*[features.size()];	
-    for (int i = 0; i < sz; i++)
-    {
+    double** arrFeatures = new double*[features.size()];        
+    for (int i = 0; i < sz; i++) {
         if (featureType == FEATURE_TYPE_UNKNOWN) {
             arrFeatures[i] = new double[features[0].size()];
             for (int j = 0; j < int(features[0].size()); j++) {
                 arrFeatures[i][j] = features[i][j];
             }
         } else {
-            arrFeatures[i] = new double[ncoeff+1];	// allow space for the normalised envelope
+            arrFeatures[i] = new double[ncoeff+1];      // allow space for the normalised envelope
             for (int j = 0; j < ncoeff; j++) {
                 arrFeatures[i][j] = features[i][j];
             }
         }
     }
-	
+        
     q = new int[features.size()];
-	
+        
     if (featureType == FEATURE_TYPE_UNKNOWN ||
-        featureType == FEATURE_TYPE_MFCC)
+        featureType == FEATURE_TYPE_MFCC) {
         cluster_segment(q, arrFeatures, features.size(), features[0].size(), nHMMStates, histogramLength, 
                         nclusters, neighbourhoodLimit);
-    else
+    } else {
         constq_segment(q, arrFeatures, features.size(), nbins, ncoeff, featureType, 
                        nHMMStates, histogramLength, nclusters, neighbourhoodLimit);
-	
+    }
+
     // convert the cluster assignment sequence to a segmentation
-    makeSegmentation(q, features.size());		
-	
+    makeSegmentation(q, features.size());               
+        
     // de-allocate arrays
     delete [] q;
     for (int i = 0; i < int(features.size()); i++) delete [] arrFeatures[i];
     delete [] arrFeatures;
-	
+        
     // clear the features
     clear();
 }
 
 void ClusterMeltSegmenter::makeSegmentation(int* q, int len)
 {
     segmentation.segments.clear();
     segmentation.nsegtypes = nclusters;
     segmentation.samplerate = samplerate;
-	
+        
     Segment segment;
     segment.start = 0;
     segment.type = q[0];
-	
-    for (int i = 1; i < len; i++)
-    {
-        if (q[i] != q[i-1])
-        {
+        
+    for (int i = 1; i < len; i++) {
+        if (q[i] != q[i-1]) {
             segment.end = i * getHopsize();
             segmentation.segments.push_back(segment);
             segment.type = q[i];
             segment.start = segment.end;
         }