Mercurial > hg > qm-dsp

changeset 34:ad645e404d0c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* Add range of normalise options to chromagram * bit of tidying
author cannam
date Tue, 22 Jan 2008 17:27:07 +0000
parents 499d438b52ba
children 802a24b35741
files dsp/chromagram/Chromagram.cpp dsp/chromagram/Chromagram.h dsp/keydetection/GetKeyMode.cpp maths/MathUtilities.cpp maths/MathUtilities.h
diffstat 5 files changed, 284 insertions(+), 210 deletions(-) [+]
line wrap: on
line diff
--- a/dsp/chromagram/Chromagram.cpp	Mon Jan 21 18:02:47 2008 +0000
+++ b/dsp/chromagram/Chromagram.cpp	Tue Jan 22 17:27:07 2008 +0000
@@ -25,7 +25,7 @@
     m_FMin = Config.min;		// min freq
     m_FMax = Config.max;		// max freq
     m_BPO  = Config.BPO;		// bins per octave
-    isNormalised = Config.isNormalised; // true if frame normalisation is required
+    m_normalise = Config.normalise;     // if frame normalisation is required
 
     // No. of constant Q bins
     m_uK = ( unsigned int ) ceil( m_BPO * log(m_FMax/m_FMin)/log(2.0));	
@@ -157,8 +157,7 @@
 	}
     }
 
-    if( isNormalised )
-	unityNormalise( m_chromadata );
+    MathUtilities::normalise(m_chromadata, m_BPO, m_normalise);
 
     return m_chromadata;
 }
--- a/dsp/chromagram/Chromagram.h	Mon Jan 21 18:02:47 2008 +0000
+++ b/dsp/chromagram/Chromagram.h	Tue Jan 22 17:27:07 2008 +0000
@@ -21,7 +21,7 @@
     double max;
     unsigned int BPO;
     double CQThresh;
-    bool isNormalised;
+    MathUtilities::NormaliseType normalise;
 };
 
 class Chromagram 
@@ -56,7 +56,7 @@
     unsigned int m_BPO;
     unsigned int m_uK;
 
-    bool isNormalised;
+    MathUtilities::NormaliseType m_normalise;
 
     unsigned int m_frameSize;
     unsigned int m_hopSize;
--- a/dsp/keydetection/GetKeyMode.cpp	Mon Jan 21 18:02:47 2008 +0000
+++ b/dsp/keydetection/GetKeyMode.cpp	Tue Jan 22 17:27:07 2008 +0000
@@ -1,3 +1,5 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
 // GetKeyMode.cpp: implementation of the CGetKeyMode class.
 //
 //////////////////////////////////////////////////////////////////////
@@ -27,269 +29,252 @@
 //////////////////////////////////////////////////////////////////////
 
 GetKeyMode::GetKeyMode( int sampleRate, float tuningFrequency,
-			double hpcpAverage, double medianAverage )
-:
-m_hpcpAverage( hpcpAverage ),
-m_medianAverage( medianAverage ),
-m_ChrPointer(0),
-m_DecimatedBuffer(0),
-m_ChromaBuffer(0),
-m_MeanHPCP(0),
-m_MajCorr(0),
-m_MinCorr(0),
-m_Keys(0),
-m_MedianFilterBuffer(0),
-m_SortedBuffer(0)
+			double hpcpAverage, double medianAverage ) :
+    m_hpcpAverage( hpcpAverage ),
+    m_medianAverage( medianAverage ),
+    m_ChrPointer(0),
+    m_DecimatedBuffer(0),
+    m_ChromaBuffer(0),
+    m_MeanHPCP(0),
+    m_MajCorr(0),
+    m_MinCorr(0),
+    m_Keys(0),
+    m_MedianFilterBuffer(0),
+    m_SortedBuffer(0)
 {
-	m_DecimationFactor = 8;
+    m_DecimationFactor = 8;
+        
+    // Chromagram configuration parameters
+    m_ChromaConfig.normalise = MathUtilities::NormaliseUnitMax;
+    m_ChromaConfig.FS = lrint(sampleRate/(double)m_DecimationFactor);
 
-	//Chromagram configuration parameters
-	m_ChromaConfig.isNormalised = 1;
-	m_ChromaConfig.FS = lrint(sampleRate/(double)m_DecimationFactor);
+    // Set C (= MIDI #12) as our base :
+    // This implies that key = 1 => Cmaj, key = 12 => Bmaj, key = 13 => Cmin, etc.
+    m_ChromaConfig.min = Pitch::getFrequencyForPitch
+        (12, 0, tuningFrequency);
+    m_ChromaConfig.max = Pitch::getFrequencyForPitch
+        (96, 0, tuningFrequency);
 
-//	m_ChromaConfig.min = 111.0641;
-//	m_ChromaConfig.max = 1.7770e+003;
+    m_ChromaConfig.BPO = 36;
+    m_ChromaConfig.CQThresh = 0.0054;
 
-	// Set C (= MIDI #12) as our base :
-	// This implies that key = 1 => Cmaj, key = 12 => Bmaj, key = 13 => Cmin, etc.
-	m_ChromaConfig.min = Pitch::getFrequencyForPitch
-		(12, 0, tuningFrequency);
-	m_ChromaConfig.max = Pitch::getFrequencyForPitch
-		(96, 0, tuningFrequency);
+    // Chromagram inst.
+    m_Chroma = new Chromagram( m_ChromaConfig );
 
-	// The chromagram minimum pitch is 1/6 of a tone above A, two
-	// octaves below middle C (for a 36-bin chromagram).  The
-	// maximum pitch is four octaves higher.
-/*	m_ChromaConfig.min = Pitch::getFrequencyForPitch
-		(45, 1.f / 3.f, tuningFrequency);
+    // Get calculated parameters from chroma object
+    m_ChromaFrameSize = m_Chroma->getFrameSize();
+    // override hopsize for this application
+    m_ChromaHopSize = m_ChromaFrameSize;
+    m_BPO = m_ChromaConfig.BPO;
 
-	m_ChromaConfig.max = m_ChromaConfig.min * 2;
-	m_ChromaConfig.max = m_ChromaConfig.max * 2;
-	m_ChromaConfig.max = m_ChromaConfig.max * 2;
-	m_ChromaConfig.max = m_ChromaConfig.max * 2;
-*/
-//	std::cerr << "Chromagram range: " << m_ChromaConfig.min << " -> " << m_ChromaConfig.max << std::endl;
+    // Chromagram average and estimated key median filter lengths
+    m_ChromaBuffersize = (int)ceil( m_hpcpAverage * m_ChromaConfig.FS/m_ChromaFrameSize );
+    m_MedianWinsize = (int)ceil( m_medianAverage * m_ChromaConfig.FS/m_ChromaFrameSize );
+    
+    // Reset counters
+    m_bufferindex = 0;
+    m_ChromaBufferFilling = 0;
+    m_MedianBufferFilling = 0;
 
-	m_ChromaConfig.BPO = 36;
-	m_ChromaConfig.CQThresh = 0.0054;
-
-	//Chromagram inst.
-	m_Chroma = new Chromagram( m_ChromaConfig );
-
-	//Get calculated parameters from chroma object
-	m_ChromaFrameSize = m_Chroma->getFrameSize();
-	//override hopsize for this application
-	m_ChromaHopSize = m_ChromaFrameSize;//m_Chroma->GetHopSize();
-	m_BPO = m_ChromaConfig.BPO;
-
-	//Chromagram average and estimated key median filter lengths
-	m_ChromaBuffersize = (int)ceil( m_hpcpAverage * m_ChromaConfig.FS/m_ChromaFrameSize );
-	m_MedianWinsize = (int)ceil( m_medianAverage * m_ChromaConfig.FS/m_ChromaFrameSize );
-
-	//Reset counters
-	m_bufferindex = 0;
-	m_ChromaBufferFilling = 0;
-	m_MedianBufferFilling = 0;
-
-
-	//Spawn objectc/arrays
-	m_DecimatedBuffer = new double[m_ChromaFrameSize];
-
-	m_ChromaBuffer = new double[m_BPO * m_ChromaBuffersize];
-	memset( m_ChromaBuffer, 0, sizeof(double) * m_BPO * m_ChromaBuffersize);
-	
-	m_MeanHPCP = new double[m_BPO];
-
-	m_MajCorr = new double[m_BPO];
-	m_MinCorr = new double[m_BPO];
-	m_Keys  = new double[2*m_BPO];
-	
-	m_MedianFilterBuffer = new int[ m_MedianWinsize ];
-	memset( m_MedianFilterBuffer, 0, sizeof(int)*m_MedianWinsize);
-	
-	m_SortedBuffer = new int[ m_MedianWinsize ];
-	memset( m_SortedBuffer, 0, sizeof(int)*m_MedianWinsize);	
-
-	m_Decimator = new Decimator( m_ChromaFrameSize*m_DecimationFactor, m_DecimationFactor );
+    // Spawn objectc/arrays
+    m_DecimatedBuffer = new double[m_ChromaFrameSize];
+    
+    m_ChromaBuffer = new double[m_BPO * m_ChromaBuffersize];
+    memset( m_ChromaBuffer, 0, sizeof(double) * m_BPO * m_ChromaBuffersize);
+    
+    m_MeanHPCP = new double[m_BPO];
+    
+    m_MajCorr = new double[m_BPO];
+    m_MinCorr = new double[m_BPO];
+    m_Keys  = new double[2*m_BPO];
+    
+    m_MedianFilterBuffer = new int[ m_MedianWinsize ];
+    memset( m_MedianFilterBuffer, 0, sizeof(int)*m_MedianWinsize);
+    
+    m_SortedBuffer = new int[ m_MedianWinsize ];
+    memset( m_SortedBuffer, 0, sizeof(int)*m_MedianWinsize);	
+    
+    m_Decimator = new Decimator
+        ( m_ChromaFrameSize*m_DecimationFactor, m_DecimationFactor );
 }
 
 GetKeyMode::~GetKeyMode()
 {
 
-	delete m_Chroma;
-	delete m_Decimator;
-
-	delete [] m_DecimatedBuffer;
-	delete [] m_ChromaBuffer;
-	delete [] m_MeanHPCP;
-	delete [] m_MajCorr;
-	delete [] m_MinCorr;
-	delete [] m_Keys;
-	delete [] m_MedianFilterBuffer;
-	delete [] m_SortedBuffer;
+    delete m_Chroma;
+    delete m_Decimator;
+    
+    delete [] m_DecimatedBuffer;
+    delete [] m_ChromaBuffer;
+    delete [] m_MeanHPCP;
+    delete [] m_MajCorr;
+    delete [] m_MinCorr;
+    delete [] m_Keys;
+    delete [] m_MedianFilterBuffer;
+    delete [] m_SortedBuffer;
 }
 
 double GetKeyMode::krumCorr(double *pData1, double *pData2, unsigned int length)
 {
-	double retVal= 0.0;
-		
-	double num = 0;
-	double den = 0;
-	double mX = MathUtilities::mean( pData1, length );
-	double mY = MathUtilities::mean( pData2, length );
+    double retVal= 0.0;
+    
+    double num = 0;
+    double den = 0;
+    double mX = MathUtilities::mean( pData1, length );
+    double mY = MathUtilities::mean( pData2, length );
+    
+    double sum1 = 0;
+    double sum2 = 0;
+    
+    for( unsigned int i = 0; i <length; i++ )
+    {
+        num += ( pData1[i] - mX ) * ( pData2[i] - mY );
 
-	double sum1 = 0;
-	double sum2 = 0;
+        sum1 += ( (pData1[i]-mX) * (pData1[i]-mX) );
+        sum2 += ( (pData2[i]-mY) * (pData2[i]-mY) );
+    }
+	
+    den = sqrt(sum1 * sum2);
+	
+    if( den>0 )
+        retVal = num/den;
+    else
+        retVal = 0;
 
-	for( unsigned int i = 0; i <length; i++ )
-	{
-		num += ( pData1[i] - mX ) * ( pData2[i] - mY );
 
-		sum1 += ( (pData1[i]-mX) * (pData1[i]-mX) );
-		sum2 += ( (pData2[i]-mY) * (pData2[i]-mY) );
-	}
-	
-	den = sqrt(sum1 * sum2);
-	
-	if( den>0 )
-		retVal = num/den;
-	else
-		retVal = 0;
-
-
-	return retVal;
+    return retVal;
 }
 
 int GetKeyMode::process(double *PCMData)
 {
-	int key;
+    int key;
 
-	unsigned int j,k;
+    unsigned int j,k;
 
-	//////////////////////////////////////////////
-	m_Decimator->process( PCMData, m_DecimatedBuffer);
+    //////////////////////////////////////////////
+    m_Decimator->process( PCMData, m_DecimatedBuffer);
 
-	m_ChrPointer = m_Chroma->process( m_DecimatedBuffer );		
+    m_ChrPointer = m_Chroma->process( m_DecimatedBuffer );		
 
 	
-	// Move bins such that the centre of the base note is in the middle of its three bins :
-	// Added 21.11.07 by Chris Sutton based on debugging with Katy Noland + comparison with Matlab equivalent.
-	MathUtilities::circShift( m_ChrPointer, m_BPO, 1);
+    // Move bins such that the centre of the base note is in the
+    // middle of its three bins :
+    // Added 21.11.07 by Chris Sutton based on debugging with Katy
+    // Noland + comparison with Matlab equivalent.
+    MathUtilities::circShift( m_ChrPointer, m_BPO, 1);
 
 /*
-	std::cout << "raw chroma: ";
-	for (int ii = 0; ii < m_BPO; ++ii) {
-		std::cout << m_ChrPointer[ii] << " ";
-	}
-	std::cout << std::endl;
+  std::cout << "raw chroma: ";
+  for (int ii = 0; ii < m_BPO; ++ii) {
+  std::cout << m_ChrPointer[ii] << " ";
+  }
+  std::cout << std::endl;
 */
-	// populate hpcp values;
-	int cbidx;
-	for( j = 0; j < m_BPO; j++ )
-	{
-		cbidx = (m_bufferindex * m_BPO) + j;
-		m_ChromaBuffer[ cbidx ] = m_ChrPointer[j];
-	}
+    // populate hpcp values;
+    int cbidx;
+    for( j = 0; j < m_BPO; j++ )
+    {
+        cbidx = (m_bufferindex * m_BPO) + j;
+        m_ChromaBuffer[ cbidx ] = m_ChrPointer[j];
+    }
 
-	//keep track of input buffers;
-	if( m_bufferindex++ >= m_ChromaBuffersize - 1) 
-		m_bufferindex = 0;
+    //keep track of input buffers;
+    if( m_bufferindex++ >= m_ChromaBuffersize - 1) 
+        m_bufferindex = 0;
 
-	// track filling of chroma matrix
-	if( m_ChromaBufferFilling++ >= m_ChromaBuffersize)
-		m_ChromaBufferFilling = m_ChromaBuffersize;
+    // track filling of chroma matrix
+    if( m_ChromaBufferFilling++ >= m_ChromaBuffersize)
+        m_ChromaBufferFilling = m_ChromaBuffersize;
 
-	//calculate mean 		
-	for( k = 0; k < m_BPO; k++ )
-	{
-		double mnVal = 0.0;
-		for( j = 0; j < m_ChromaBufferFilling; j++ )
-		{
-			mnVal += m_ChromaBuffer[ k + (j*m_BPO) ];
-		}
+    //calculate mean 		
+    for( k = 0; k < m_BPO; k++ )
+    {
+        double mnVal = 0.0;
+        for( j = 0; j < m_ChromaBufferFilling; j++ )
+        {
+            mnVal += m_ChromaBuffer[ k + (j*m_BPO) ];
+        }
 
-		m_MeanHPCP[k] = mnVal/(double)m_ChromaBufferFilling;
-	}
+        m_MeanHPCP[k] = mnVal/(double)m_ChromaBufferFilling;
+    }
 
 
-	for( k = 0; k < m_BPO; k++ )
-	{
-		m_MajCorr[k] = krumCorr( m_MeanHPCP, MajProfile, m_BPO );
-		m_MinCorr[k] = krumCorr( m_MeanHPCP, MinProfile, m_BPO );
+    for( k = 0; k < m_BPO; k++ )
+    {
+        m_MajCorr[k] = krumCorr( m_MeanHPCP, MajProfile, m_BPO );
+        m_MinCorr[k] = krumCorr( m_MeanHPCP, MinProfile, m_BPO );
 
-		MathUtilities::circShift( MajProfile, m_BPO, 1 );
-		MathUtilities::circShift( MinProfile, m_BPO, 1 );
-	}
+        MathUtilities::circShift( MajProfile, m_BPO, 1 );
+        MathUtilities::circShift( MinProfile, m_BPO, 1 );
+    }
 	
-	for( k = 0; k < m_BPO; k++ )
-	{
-		m_Keys[k] = m_MajCorr[k];
-		m_Keys[k+m_BPO] = m_MinCorr[k];
-	}
+    for( k = 0; k < m_BPO; k++ )
+    {
+        m_Keys[k] = m_MajCorr[k];
+        m_Keys[k+m_BPO] = m_MinCorr[k];
+    }
 
 
 /*
-	std::cout << "raw keys: ";
-	for (int ii = 0; ii < 2*m_BPO; ++ii) {
-		std::cout << m_Keys[ii] << " ";
-	}
-	std::cout << std::endl;
+  std::cout << "raw keys: ";
+  for (int ii = 0; ii < 2*m_BPO; ++ii) {
+  std::cout << m_Keys[ii] << " ";
+  }
+  std::cout << std::endl;
 */
-	double dummy;
-	// '1 +' because we number keys 1-24, not 0-23.
-	key = 1 + (int)ceil( (double)MathUtilities::getMax( m_Keys, 2* m_BPO, &dummy )/3 );
+    double dummy;
+    // '1 +' because we number keys 1-24, not 0-23.
+    key = 1 + (int)ceil( (double)MathUtilities::getMax( m_Keys, 2* m_BPO, &dummy )/3 );
 
 //	std::cout << "key pre-sorting: " << key << std::endl;
 
 
-	//Median filtering
+    //Median filtering
 
-	// track Median buffer initial filling
-	if( m_MedianBufferFilling++ >= m_MedianWinsize)
-		m_MedianBufferFilling = m_MedianWinsize;
+    // track Median buffer initial filling
+    if( m_MedianBufferFilling++ >= m_MedianWinsize)
+        m_MedianBufferFilling = m_MedianWinsize;
 		
-	//shift median buffer
-	for( k = 1; k < m_MedianWinsize; k++ )
-	{
-		m_MedianFilterBuffer[ k - 1 ] = m_MedianFilterBuffer[ k ];
-	}
+    //shift median buffer
+    for( k = 1; k < m_MedianWinsize; k++ )
+    {
+        m_MedianFilterBuffer[ k - 1 ] = m_MedianFilterBuffer[ k ];
+    }
 
-	//write new key value into median buffer
-	m_MedianFilterBuffer[ m_MedianWinsize - 1 ] = key;
+    //write new key value into median buffer
+    m_MedianFilterBuffer[ m_MedianWinsize - 1 ] = key;
 
 
-	//Copy median into sorting buffer, reversed
-	unsigned int ijx = 0;
-	for( k = 0; k < m_MedianWinsize; k++ )
-	{
-		m_SortedBuffer[k] = m_MedianFilterBuffer[m_MedianWinsize-1-ijx];
-		ijx++;
-	}
+    //Copy median into sorting buffer, reversed
+    unsigned int ijx = 0;
+    for( k = 0; k < m_MedianWinsize; k++ )
+    {
+        m_SortedBuffer[k] = m_MedianFilterBuffer[m_MedianWinsize-1-ijx];
+        ijx++;
+    }
 
+    qsort(m_SortedBuffer, m_MedianBufferFilling, sizeof(unsigned int),
+          MathUtilities::compareInt);
+/*
+  std::cout << "sorted: ";
+  for (int ii = 0; ii < m_MedianBufferFilling; ++ii) {
+  std::cout << m_SortedBuffer[ii] << " ";
+  }
+  std::cout << std::endl;
+*/
+    int sortlength = m_MedianBufferFilling;
+    int midpoint = (int)ceil((double)sortlength/2);
 
-	//quicksort 
-	qsort(m_SortedBuffer, m_MedianBufferFilling, sizeof(unsigned int), MathUtilities::compareInt);
-/*
-	std::cout << "sorted: ";
-	for (int ii = 0; ii < m_MedianBufferFilling; ++ii) {
-		std::cout << m_SortedBuffer[ii] << " ";
-	}
-	std::cout << std::endl;
-*/
-	int sortlength = m_MedianBufferFilling;
-	int midpoint = (int)ceil((double)sortlength/2);
+    if( midpoint <= 0 )
+        midpoint = 1;
 
-	if( midpoint <= 0 )
-		midpoint = 1;
+    key = m_SortedBuffer[midpoint-1];
 
-	key = m_SortedBuffer[midpoint-1];
-
-	return key;
+    return key;
 }
 
 
 int GetKeyMode::isModeMinor( int key )
 { 
-//	return ((key-1 - (int)MathUtilities::mod((double)(key-1),(double)12))/12); 
-	return (key > 12);
+    return (key > 12);
 }
--- a/maths/MathUtilities.cpp	Mon Jan 21 18:02:47 2008 +0000
+++ b/maths/MathUtilities.cpp	Tue Jan 22 17:27:07 2008 +0000
@@ -219,3 +219,75 @@
   return ( *(int*)a - *(int*)b );
 }
 
+void MathUtilities::normalise(double *data, int length, NormaliseType type)
+{
+    switch (type) {
+
+    case NormaliseNone: return;
+
+    case NormaliseUnitSum:
+    {
+        double sum = 0.0;
+        for (int i = 0; i < length; ++i) {
+            sum += data[i];
+        }
+        if (sum != 0.0) {
+            for (int i = 0; i < length; ++i) {
+                data[i] /= sum;
+            }
+        }
+    }
+    break;
+
+    case NormaliseUnitMax:
+    {
+        double max = 0.0;
+        for (int i = 0; i < length; ++i) {
+            if (fabs(data[i]) > max) {
+                max = fabs(data[i]);
+            }
+        }
+        if (max != 0.0) {
+            for (int i = 0; i < length; ++i) {
+                data[i] /= max;
+            }
+        }
+    }
+    break;
+
+    }
+}
+
+void MathUtilities::normalise(std::vector<double> &data, NormaliseType type)
+{
+    switch (type) {
+
+    case NormaliseNone: return;
+
+    case NormaliseUnitSum:
+    {
+        double sum = 0.0;
+        for (int i = 0; i < data.size(); ++i) sum += data[i];
+        if (sum != 0.0) {
+            for (int i = 0; i < data.size(); ++i) data[i] /= sum;
+        }
+    }
+    break;
+
+    case NormaliseUnitMax:
+    {
+        double max = 0.0;
+        for (int i = 0; i < data.size(); ++i) {
+            if (fabs(data[i]) > max) max = fabs(data[i]);
+        }
+        if (max != 0.0) {
+            for (int i = 0; i < data.size(); ++i) data[i] /= max;
+        }
+    }
+    break;
+
+    }
+}
+
+
+        
--- a/maths/MathUtilities.h	Mon Jan 21 18:02:47 2008 +0000
+++ b/maths/MathUtilities.h	Tue Jan 22 17:27:07 2008 +0000
@@ -17,17 +17,35 @@
 {
 public:	
     static double round( double x );
+
     static void	  getFrameMinMax( const double* data, unsigned int len,  double* min, double* max );
+
     static double mean( const double* src, unsigned int len );
     static double sum( const double* src, unsigned int len );
+    static double median( const double* src, unsigned int len );
+
     static double princarg( double ang );
-    static double median( const double* src, unsigned int len );
     static double mod( double x, double y);
+
     static void	  getAlphaNorm(const double *data, unsigned int len, unsigned int alpha, double* ANorm);
     static double getAlphaNorm(const std::vector <double> &data, unsigned int alpha );
+
     static void   circShift( double* data, int length, int shift);
+
     static int	  getMax( double* data, unsigned int length, double* max );
     static int    compareInt(const void * a, const void * b);
+
+    enum NormaliseType {
+        NormaliseNone,
+        NormaliseUnitSum,
+        NormaliseUnitMax
+    };
+
+    static void   normalise(double *data, int length,
+                            NormaliseType n = NormaliseUnitMax);
+
+    static void   normalise(std::vector<double> &data,
+                            NormaliseType n = NormaliseUnitMax);
 };
 
 #endif