annotate dsp/segmentation/ClusterMeltSegmenter.h @ 73:dcb555b90924

* Key detector: when returning key strengths, use the peak value of the
  three underlying chromagram correlations (from 36-bin chromagram)
  corresponding to each key, instead of the mean.
  Rationale: This is the same method as used when returning the key value,
  and it's nice to have the same results in both returned value and plot.
  The peak performed better than the sum with a simple test set of triads,
  so it seems reasonable to change the plot to match the key output rather
  than the other way around.

* FFT: kiss_fftr returns only the non-conjugate bins, synthesise the rest
  rather than leaving them (perhaps dangerously) undefined.  Fixes an
  uninitialised data error in chromagram that could cause garbage results
  from key detector.

* Constant Q: remove precalculated values again, I reckon they're not
  proving such a good tradeoff.

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*
 * ClusterMeltSegmenter.h
 *
 * Created by Mark Levy on 23/03/2006.
 * Copyright 2006 Centre for Digital Music, Queen Mary, University of London.
 * All rights reserved.
 */

#include <vector>

#include "segment.h"
#include "Segmenter.h"
#include "hmm/hmm.h"
#include "base/Window.h"

using std::vector;

class Decimator;
class ConstantQ;
class MFCC;
class FFTReal;

class ClusterMeltSegmenterParams
// defaults are sensible for 11025Hz with 0.2 second hopsize
{
public:
    ClusterMeltSegmenterParams() : 
        featureType(FEATURE_TYPE_CONSTQ),
        hopSize(0.2),
        windowSize(0.6),
        fmin(62),
        fmax(16000), 
        nbins(8),
        ncomponents(20),
 	nHMMStates(40),
        nclusters(10),
        histogramLength(15),
        neighbourhoodLimit(20) { }
    feature_types featureType;
    double hopSize;    	// in secs
    double windowSize;	// in secs
    int fmin;
    int fmax;
    int nbins;
    int ncomponents;
    int nHMMStates;
    int nclusters;
    int histogramLength;
    int neighbourhoodLimit;
};

class ClusterMeltSegmenter : public Segmenter
{
public:
    ClusterMeltSegmenter(ClusterMeltSegmenterParams params);
    virtual ~ClusterMeltSegmenter();
    virtual void initialise(int samplerate);
    virtual int getWindowsize();
    virtual int getHopsize();
    virtual void extractFeatures(const double* samples, int nsamples);
    void setFeatures(const vector<vector<double> >& f);		// provide the features yourself
    virtual void segment();		// segment into default number of segment-types
    void segment(int m);		// segment into m segment-types
    int getNSegmentTypes() { return nclusters; }

protected:
    void makeSegmentation(int* q, int len);
	
    void extractFeaturesConstQ(const double *, int);
    void extractFeaturesMFCC(const double *, int);

    Window<double> *window;
    FFTReal *fft;
    ConstantQ* constq; 
    MFCC* mfcc;
    model_t* model;				// the HMM
    int* q;					// the decoded HMM state sequence
    vector<vector<double> > histograms;	
    
    feature_types featureType;	
    double hopSize;		// in seconds
    double windowSize;	// in seconds
    
    // constant-Q parameters
    int fmin;
    int fmax;
    int nbins;
    int ncoeff;
    
    // PCA parameters
    int ncomponents;
    
    // HMM parameters
    int nHMMStates;
    
    // clustering parameters
    int nclusters;
    int histogramLength;
    int neighbourhoodLimit;

    Decimator *decimator;
};